diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml index cee3c74762c3c..cfa9ffb49d7ad 100644 --- a/.github/workflows/dev.yml +++ b/.github/workflows/dev.yml @@ -103,7 +103,7 @@ jobs: shell: bash run: | gem install test-unit - pip install "cython<3" setuptools six pytest jira + pip install "cython>=0.29.31" setuptools six pytest jira - name: Run Release Test env: ARROW_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/LICENSE.txt b/LICENSE.txt index c2b0a996fedd1..0423854567b26 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1889,19 +1889,6 @@ for PyArrow. Ibis is released under the Apache License, Version 2.0. -------------------------------------------------------------------------------- -This project includes code from the autobrew project. - -The following files are based on code from the autobrew project: -* r/tools/autobrew -* dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb -* dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb - -Copyright (c) 2019, Jeroen Ooms -License: MIT -Homepage: https://github.com/autobrew/ - --------------------------------------------------------------------------------- - dev/tasks/homebrew-formulae/apache-arrow.rb has the following license: BSD 2-Clause License diff --git a/ci/appveyor-cpp-build.bat b/ci/appveyor-cpp-build.bat index e69c7bf2516d9..5e561a0461ea3 100644 --- a/ci/appveyor-cpp-build.bat +++ b/ci/appveyor-cpp-build.bat @@ -132,6 +132,19 @@ set ARROW_HOME=%CONDA_PREFIX%\Library @rem ARROW-3075; pkgconfig is broken for Parquet for now set PARQUET_HOME=%CONDA_PREFIX%\Library +@rem Download IANA Timezone Database to a non-standard location to +@rem test the configurability of the timezone database path +curl https://data.iana.org/time-zones/releases/tzdata2021e.tar.gz --output tzdata.tar.gz || exit /B +mkdir %USERPROFILE%\Downloads\test\tzdata +tar --extract --file tzdata.tar.gz --directory %USERPROFILE%\Downloads\test\tzdata +curl https://raw.githubusercontent.com/unicode-org/cldr/master/common/supplemental/windowsZones.xml ^ + --output %USERPROFILE%\Downloads\test\tzdata\windowsZones.xml || exit /B +@rem Remove the database from the default location +rmdir /s /q %USERPROFILE%\Downloads\tzdata +@rem Set the env var for the non-standard location of the database +@rem (only needed for testing purposes) +set PYARROW_TZDATA_PATH=%USERPROFILE%\Downloads\test\tzdata + python setup.py develop -q || exit /B set PYTHONDEVMODE=1 diff --git a/ci/conda_env_python.txt b/ci/conda_env_python.txt index d914229ec58c0..da52b5ea689be 100644 --- a/ci/conda_env_python.txt +++ b/ci/conda_env_python.txt @@ -18,7 +18,7 @@ # don't add pandas here, because it is not a mandatory test dependency boto3 # not a direct dependency of s3fs, but needed for our s3fs fixture cffi -cython<3 +cython>=0.29.31 cloudpickle fsspec hypothesis diff --git a/ci/scripts/install_pandas.sh b/ci/scripts/install_pandas.sh index f0cb76fb663e0..6a506a86514fa 100755 --- a/ci/scripts/install_pandas.sh +++ b/ci/scripts/install_pandas.sh @@ -28,7 +28,7 @@ pandas=$1 numpy=${2:-"latest"} if [ "${numpy}" = "nightly" ]; then - pip install --extra-index-url https://pypi.anaconda.org/scipy-wheels-nightly/simple --pre numpy + pip install --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --pre numpy elif [ "${numpy}" = "latest" ]; then pip install numpy else @@ -38,7 +38,7 @@ fi if [ "${pandas}" = "upstream_devel" ]; then pip install git+https://github.com/pandas-dev/pandas.git elif [ "${pandas}" = "nightly" ]; then - pip install --extra-index-url https://pypi.anaconda.org/scipy-wheels-nightly/simple --pre pandas + pip install --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --pre pandas elif [ "${pandas}" = "latest" ]; then pip install pandas else diff --git a/ci/scripts/integration_dask.sh b/ci/scripts/integration_dask.sh index 5b57fb486aa6c..f91d21b921708 100755 --- a/ci/scripts/integration_dask.sh +++ b/ci/scripts/integration_dask.sh @@ -34,10 +34,7 @@ python -c "import dask.dataframe" # The "skip_with_pyarrow_strings" marker is meant to skip automatically, but that doesn't work with --pyargs, so de-selecting manually pytest -v --pyargs dask.dataframe.tests.test_dataframe -m "not skip_with_pyarrow_strings" pytest -v --pyargs dask.dataframe.io.tests.test_orc -# skip failing parquet tests -# test_pandas_timestamp_overflow_pyarrow is skipped because of GH-33321. pytest -v --pyargs dask.dataframe.io.tests.test_parquet \ - -k "not test_pandas_timestamp_overflow_pyarrow" \ -m "not skip_with_pyarrow_strings and not xfail_with_pyarrow_strings" # this file contains parquet tests that use S3 filesystem pytest -v --pyargs dask.bytes.tests.test_s3 diff --git a/cpp/Brewfile b/cpp/Brewfile index 58015d2121b5b..0f5527985364c 100644 --- a/cpp/Brewfile +++ b/cpp/Brewfile @@ -19,7 +19,9 @@ brew "aws-sdk-cpp" brew "bash" brew "boost" brew "brotli" +brew "bzip2" brew "c-ares" +brew "curl" brew "ccache" brew "cmake" brew "flatbuffers" @@ -29,14 +31,18 @@ brew "googletest" brew "grpc" brew "llvm@14" brew "lz4" +brew "mimalloc" brew "ninja" brew "node" brew "openssl@3" +brew "pkg-config" brew "protobuf" brew "python" brew "rapidjson" +brew "re2" brew "snappy" brew "thrift" +brew "utf8proc" brew "wget" brew "xsimd" brew "zstd" diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake index 5531415ac2277..e90c00612caa3 100644 --- a/cpp/cmake_modules/SetupCxxFlags.cmake +++ b/cpp/cmake_modules/SetupCxxFlags.cmake @@ -456,11 +456,18 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STRE # Don't complain about optimization passes that were not possible set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-pass-failed") - # Avoid clang / libc++ error about C++17 aligned allocation on macOS. - # See https://chromium.googlesource.com/chromium/src/+/eee44569858fc650b635779c4e34be5cb0c73186%5E%21/#F0 - # for details. if(APPLE) - set(CXX_ONLY_FLAGS "${CXX_ONLY_FLAGS} -fno-aligned-new") + # Avoid clang / libc++ error about C++17 aligned allocation on macOS. + # See https://chromium.googlesource.com/chromium/src/+/eee44569858fc650b635779c4e34be5cb0c73186%5E%21/#F0 + # for details. + string(APPEND CXX_ONLY_FLAGS " -fno-aligned-new") + + if(CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 20) + # Avoid C++17 std::get 'not available' issue on macOS 10.13 + # This will be required until atleast R 4.4 is released and + # CRAN (hopefully) stops checking on 10.13 + string(APPEND CXX_ONLY_FLAGS " -D_LIBCPP_DISABLE_AVAILABILITY") + endif() endif() endif() diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake index 85c0337d108be..6d6a2bf7751ee 100644 --- a/cpp/cmake_modules/ThirdpartyToolchain.cmake +++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake @@ -1308,6 +1308,26 @@ macro(build_snappy) set(SNAPPY_CMAKE_ARGS ${EP_COMMON_CMAKE_ARGS} -DSNAPPY_BUILD_TESTS=OFF -DSNAPPY_BUILD_BENCHMARKS=OFF "-DCMAKE_INSTALL_PREFIX=${SNAPPY_PREFIX}") + # Snappy unconditionaly enables Werror when building with clang this can lead + # to build failues by way of new compiler warnings. This adds a flag to disable + # Werror to the very end of the invocation to override the snappy internal setting. + if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + foreach(CONFIG DEBUG MINSIZEREL RELEASE RELWITHDEBINFO) + list(APPEND + SNAPPY_CMAKE_ARGS + "-DCMAKE_CXX_FLAGS_${UPPERCASE_BUILD_TYPE}=${EP_CXX_FLAGS_${CONFIG}} -Wno-error" + ) + endforeach() + endif() + + if(APPLE AND CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 20) + # On macOS 10.13 we need to explicitly add to avoid a missing include error + # This can be removed once CRAN no longer checks on macOS 10.13 + find_program(PATCH patch REQUIRED) + set(SNAPPY_PATCH_COMMAND ${PATCH} -p1 -i ${CMAKE_CURRENT_LIST_DIR}/snappy.diff) + else() + set(SNAPPY_PATCH_COMMAND) + endif() externalproject_add(snappy_ep ${EP_COMMON_OPTIONS} @@ -1315,6 +1335,7 @@ macro(build_snappy) INSTALL_DIR ${SNAPPY_PREFIX} URL ${SNAPPY_SOURCE_URL} URL_HASH "SHA256=${ARROW_SNAPPY_BUILD_SHA256_CHECKSUM}" + PATCH_COMMAND ${SNAPPY_PATCH_COMMAND} CMAKE_ARGS ${SNAPPY_CMAKE_ARGS} BUILD_BYPRODUCTS "${SNAPPY_STATIC_LIB}") diff --git a/cpp/cmake_modules/snappy.diff b/cpp/cmake_modules/snappy.diff new file mode 100644 index 0000000000000..f86e2bb19780c --- /dev/null +++ b/cpp/cmake_modules/snappy.diff @@ -0,0 +1,12 @@ +diff --git a/snappy.cc b/snappy.cc +index d414718..5b0d0d6 100644 +--- a/snappy.cc ++++ b/snappy.cc +@@ -83,6 +83,7 @@ + #include + #include + #include ++#include + + namespace snappy { + diff --git a/cpp/src/arrow/adapters/orc/adapter.cc b/cpp/src/arrow/adapters/orc/adapter.cc index 2466e7433abce..31fba1a9bd50e 100644 --- a/cpp/src/arrow/adapters/orc/adapter.cc +++ b/cpp/src/arrow/adapters/orc/adapter.cc @@ -204,7 +204,7 @@ class ORCFileReader::Impl { Status Init() { int64_t nstripes = reader_->getNumberOfStripes(); - stripes_.resize(nstripes); + stripes_.resize(static_cast(nstripes)); std::unique_ptr stripe; uint64_t first_row_of_stripe = 0; for (int i = 0; i < nstripes; ++i) { @@ -222,7 +222,9 @@ class ORCFileReader::Impl { int64_t NumberOfRows() { return static_cast(reader_->getNumberOfRows()); } - StripeInformation GetStripeInformation(int64_t stripe) { return stripes_[stripe]; } + StripeInformation GetStripeInformation(int64_t stripe) { + return stripes_[static_cast(stripe)]; + } FileVersion GetFileVersion() { liborc::FileVersion orc_file_version = reader_->getFormatVersion(); @@ -365,7 +367,7 @@ class ORCFileReader::Impl { liborc::RowReaderOptions opts = default_row_reader_options(); RETURN_NOT_OK(SelectStripe(&opts, stripe)); ARROW_ASSIGN_OR_RAISE(auto schema, ReadSchema(opts)); - return ReadBatch(opts, schema, stripes_[stripe].num_rows); + return ReadBatch(opts, schema, stripes_[static_cast(stripe)].num_rows); } Result> ReadStripe( @@ -374,7 +376,7 @@ class ORCFileReader::Impl { RETURN_NOT_OK(SelectIndices(&opts, include_indices)); RETURN_NOT_OK(SelectStripe(&opts, stripe)); ARROW_ASSIGN_OR_RAISE(auto schema, ReadSchema(opts)); - return ReadBatch(opts, schema, stripes_[stripe].num_rows); + return ReadBatch(opts, schema, stripes_[static_cast(stripe)].num_rows); } Result> ReadStripe( @@ -383,15 +385,15 @@ class ORCFileReader::Impl { RETURN_NOT_OK(SelectNames(&opts, include_names)); RETURN_NOT_OK(SelectStripe(&opts, stripe)); ARROW_ASSIGN_OR_RAISE(auto schema, ReadSchema(opts)); - return ReadBatch(opts, schema, stripes_[stripe].num_rows); + return ReadBatch(opts, schema, stripes_[static_cast(stripe)].num_rows); } Status SelectStripe(liborc::RowReaderOptions* opts, int64_t stripe) { ARROW_RETURN_IF(stripe < 0 || stripe >= NumberOfStripes(), Status::Invalid("Out of bounds stripe: ", stripe)); - opts->range(static_cast(stripes_[stripe].offset), - static_cast(stripes_[stripe].length)); + opts->range(static_cast(stripes_[static_cast(stripe)].offset), + static_cast(stripes_[static_cast(stripe)].length)); return Status::OK(); } diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc index 0b82a82fbdb26..2bef9d725d37f 100644 --- a/cpp/src/arrow/array/array_test.cc +++ b/cpp/src/arrow/array/array_test.cc @@ -388,7 +388,12 @@ static std::vector> TestArrayUtilitiesAgainstTheseType large_utf8(), list(utf8()), list(int64()), // NOTE: Regression case for ARROW-9071/MakeArrayOfNull + list(large_utf8()), + list(list(int64())), + list(list(large_utf8())), + large_list(utf8()), large_list(large_utf8()), + large_list(list(large_utf8())), fixed_size_list(utf8(), 3), fixed_size_list(int64(), 4), dictionary(int32(), utf8()), diff --git a/cpp/src/arrow/array/util.cc b/cpp/src/arrow/array/util.cc index e84ab404ad6e3..98e9d51b5fc75 100644 --- a/cpp/src/arrow/array/util.cc +++ b/cpp/src/arrow/array/util.cc @@ -366,9 +366,11 @@ class NullArrayFactory { } template - enable_if_var_size_list Visit(const T&) { + enable_if_var_size_list Visit(const T& type) { // values array may be empty, but there must be at least one offset of 0 - return MaxOf(sizeof(typename T::offset_type) * (length_ + 1)); + RETURN_NOT_OK(MaxOf(sizeof(typename T::offset_type) * (length_ + 1))); + RETURN_NOT_OK(MaxOf(GetBufferLength(type.value_type(), length_))); + return Status::OK(); } template diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc index 0f2bd4583574e..19ff8e28b536c 100644 --- a/cpp/src/arrow/array/validate.cc +++ b/cpp/src/arrow/array/validate.cc @@ -713,8 +713,10 @@ struct ValidateArrayImpl { } // An empty list array can have 0 offsets - const auto required_offsets = (data.length > 0) ? data.length + data.offset + 1 : 0; const auto offsets_byte_size = data.buffers[1]->size(); + const auto required_offsets = ((data.length > 0) || (offsets_byte_size > 0)) + ? data.length + data.offset + 1 + : 0; if (offsets_byte_size / static_cast(sizeof(offset_type)) < required_offsets) { return Status::Invalid("Offsets buffer size (bytes): ", offsets_byte_size, diff --git a/cpp/src/arrow/dataset/dataset_writer.cc b/cpp/src/arrow/dataset/dataset_writer.cc index 686c7712fe183..a2096d691b4bf 100644 --- a/cpp/src/arrow/dataset/dataset_writer.cc +++ b/cpp/src/arrow/dataset/dataset_writer.cc @@ -139,7 +139,7 @@ class DatasetWriterFileQueue { : options_(options), schema_(schema), writer_state_(writer_state) {} void Start(util::AsyncTaskScheduler* file_tasks, const std::string& filename) { - file_tasks_ = std::move(file_tasks); + file_tasks_ = file_tasks; // Because the scheduler runs one task at a time we know the writer will // be opened before any attempt to write file_tasks_->AddSimpleTask( @@ -575,7 +575,7 @@ class DatasetWriter::DatasetWriterImpl { } protected: - Status CloseLargestFile() { + Status TryCloseLargestFile() { std::shared_ptr largest = nullptr; uint64_t largest_num_rows = 0; for (auto& dir_queue : directory_queues_) { @@ -584,7 +584,10 @@ class DatasetWriter::DatasetWriterImpl { largest = dir_queue.second; } } - DCHECK_NE(largest, nullptr); + if (largest == nullptr) { + // GH-38011: If all written files has written 0 rows, we should not close any file + return Status::OK(); + } return largest->FinishCurrentFile(); } @@ -618,7 +621,7 @@ class DatasetWriter::DatasetWriterImpl { backpressure = writer_state_.open_files_throttle.Acquire(1); if (!backpressure.is_finished()) { EVENT_ON_CURRENT_SPAN("DatasetWriter::Backpressure::TooManyOpenFiles"); - RETURN_NOT_OK(CloseLargestFile()); + RETURN_NOT_OK(TryCloseLargestFile()); break; } } diff --git a/cpp/src/arrow/extension/fixed_shape_tensor.cc b/cpp/src/arrow/extension/fixed_shape_tensor.cc index e4195ea9e6656..af8305a025291 100644 --- a/cpp/src/arrow/extension/fixed_shape_tensor.cc +++ b/cpp/src/arrow/extension/fixed_shape_tensor.cc @@ -26,7 +26,9 @@ #include "arrow/tensor.h" #include "arrow/util/int_util_overflow.h" #include "arrow/util/logging.h" +#include "arrow/util/print.h" #include "arrow/util/sort.h" +#include "arrow/util/string.h" #include #include @@ -104,6 +106,22 @@ bool FixedShapeTensorType::ExtensionEquals(const ExtensionType& other) const { permutation_equivalent; } +std::string FixedShapeTensorType::ToString() const { + std::stringstream ss; + ss << "extension<" << this->extension_name() + << "[value_type=" << value_type_->ToString() + << ", shape=" << ::arrow::internal::PrintVector{shape_, ","}; + + if (!permutation_.empty()) { + ss << ", permutation=" << ::arrow::internal::PrintVector{permutation_, ","}; + } + if (!dim_names_.empty()) { + ss << ", dim_names=[" << internal::JoinStrings(dim_names_, ",") << "]"; + } + ss << "]>"; + return ss.str(); +} + std::string FixedShapeTensorType::Serialize() const { rj::Document document; document.SetObject(); diff --git a/cpp/src/arrow/extension/fixed_shape_tensor.h b/cpp/src/arrow/extension/fixed_shape_tensor.h index 93837f13002aa..fcfb1ebbab96a 100644 --- a/cpp/src/arrow/extension/fixed_shape_tensor.h +++ b/cpp/src/arrow/extension/fixed_shape_tensor.h @@ -61,6 +61,7 @@ class ARROW_EXPORT FixedShapeTensorType : public ExtensionType { dim_names_(dim_names) {} std::string extension_name() const override { return "arrow.fixed_shape_tensor"; } + std::string ToString() const override; /// Number of dimensions of tensor elements size_t ndim() { return shape_.size(); } diff --git a/cpp/src/arrow/extension/fixed_shape_tensor_test.cc b/cpp/src/arrow/extension/fixed_shape_tensor_test.cc index c3c97bc6e5790..b8be1edc49e60 100644 --- a/cpp/src/arrow/extension/fixed_shape_tensor_test.cc +++ b/cpp/src/arrow/extension/fixed_shape_tensor_test.cc @@ -434,4 +434,32 @@ TEST_F(TestExtensionType, ComputeStrides) { ASSERT_EQ(ext_type_7->Serialize(), R"({"shape":[3,4,7],"permutation":[2,0,1]})"); } +TEST_F(TestExtensionType, ToString) { + auto exact_ext_type = internal::checked_pointer_cast(ext_type_); + + auto ext_type_1 = internal::checked_pointer_cast( + fixed_shape_tensor(int16(), {3, 4, 7})); + auto ext_type_2 = internal::checked_pointer_cast( + fixed_shape_tensor(int32(), {3, 4, 7}, {1, 0, 2})); + auto ext_type_3 = internal::checked_pointer_cast( + fixed_shape_tensor(int64(), {3, 4, 7}, {}, {"C", "H", "W"})); + + std::string result_1 = ext_type_1->ToString(); + std::string expected_1 = + "extension"; + ASSERT_EQ(expected_1, result_1); + + std::string result_2 = ext_type_2->ToString(); + std::string expected_2 = + "extension"; + ASSERT_EQ(expected_2, result_2); + + std::string result_3 = ext_type_3->ToString(); + std::string expected_3 = + "extension"; + ASSERT_EQ(expected_3, result_3); +} + } // namespace arrow diff --git a/cpp/src/arrow/io/caching.cc b/cpp/src/arrow/io/caching.cc index 307b933d16ee3..bd61c40693a27 100644 --- a/cpp/src/arrow/io/caching.cc +++ b/cpp/src/arrow/io/caching.cc @@ -174,8 +174,9 @@ struct ReadRangeCache::Impl { // Add the given ranges to the cache, coalescing them where possible virtual Status Cache(std::vector ranges) { - ranges = internal::CoalesceReadRanges(std::move(ranges), options.hole_size_limit, - options.range_size_limit); + ARROW_ASSIGN_OR_RAISE( + ranges, internal::CoalesceReadRanges(std::move(ranges), options.hole_size_limit, + options.range_size_limit)); std::vector new_entries = MakeCacheEntries(ranges); // Add new entries, themselves ordered by offset if (entries.size() > 0) { diff --git a/cpp/src/arrow/io/interfaces.cc b/cpp/src/arrow/io/interfaces.cc index d3229fd067cbe..1d35549cc4345 100644 --- a/cpp/src/arrow/io/interfaces.cc +++ b/cpp/src/arrow/io/interfaces.cc @@ -425,7 +425,7 @@ ThreadPool* GetIOThreadPool() { namespace { struct ReadRangeCombiner { - std::vector Coalesce(std::vector ranges) { + Result> Coalesce(std::vector ranges) { if (ranges.empty()) { return ranges; } @@ -454,7 +454,9 @@ struct ReadRangeCombiner { const auto& left = ranges[i]; const auto& right = ranges[i + 1]; DCHECK_LE(left.offset, right.offset); - DCHECK_LE(left.offset + left.length, right.offset) << "Some read ranges overlap"; + if (left.offset + left.length > right.offset) { + return Status::IOError("Some read ranges overlap"); + } } #endif @@ -509,9 +511,9 @@ struct ReadRangeCombiner { }; // namespace -std::vector CoalesceReadRanges(std::vector ranges, - int64_t hole_size_limit, - int64_t range_size_limit) { +Result> CoalesceReadRanges(std::vector ranges, + int64_t hole_size_limit, + int64_t range_size_limit) { DCHECK_GT(range_size_limit, hole_size_limit); ReadRangeCombiner combiner{hole_size_limit, range_size_limit}; diff --git a/cpp/src/arrow/io/util_internal.h b/cpp/src/arrow/io/util_internal.h index b1d75d1d0bd1f..2015f6a211292 100644 --- a/cpp/src/arrow/io/util_internal.h +++ b/cpp/src/arrow/io/util_internal.h @@ -45,9 +45,9 @@ ARROW_EXPORT Status ValidateWriteRange(int64_t offset, int64_t size, int64_t fil ARROW_EXPORT Status ValidateRange(int64_t offset, int64_t size); ARROW_EXPORT -std::vector CoalesceReadRanges(std::vector ranges, - int64_t hole_size_limit, - int64_t range_size_limit); +Result> CoalesceReadRanges(std::vector ranges, + int64_t hole_size_limit, + int64_t range_size_limit); ARROW_EXPORT ::arrow::internal::ThreadPool* GetIOThreadPool(); diff --git a/cpp/src/arrow/pretty_print.cc b/cpp/src/arrow/pretty_print.cc index 03e2051c2fb88..a4a1fa90c2878 100644 --- a/cpp/src/arrow/pretty_print.cc +++ b/cpp/src/arrow/pretty_print.cc @@ -151,14 +151,14 @@ class ArrayPrinter : public PrettyPrinter { IndentAfterNewline(); (*sink_) << "..."; if (!is_last && options_.skip_new_lines) { - (*sink_) << ","; + (*sink_) << options_.array_delimiters.element; } i = array.length() - window - 1; } else if (array.IsNull(i)) { IndentAfterNewline(); (*sink_) << options_.null_rep; if (!is_last) { - (*sink_) << ","; + (*sink_) << options_.array_delimiters.element; } } else { if (indent_non_null_values) { @@ -166,7 +166,7 @@ class ArrayPrinter : public PrettyPrinter { } RETURN_NOT_OK(func(i)); if (!is_last) { - (*sink_) << ","; + (*sink_) << options_.array_delimiters.element; } } Newline(); @@ -453,12 +453,12 @@ Status PrettyPrint(const ChunkedArray& chunked_arr, const PrettyPrintOptions& op if (!skip_new_lines) { *sink << "\n"; } - bool skip_comma = true; + bool skip_element_delimiter = true; for (int i = 0; i < num_chunks; ++i) { - if (skip_comma) { - skip_comma = false; + if (skip_element_delimiter) { + skip_element_delimiter = false; } else { - (*sink) << ","; + (*sink) << options.chunked_array_delimiters.element; if (!skip_new_lines) { *sink << "\n"; } @@ -467,12 +467,13 @@ Status PrettyPrint(const ChunkedArray& chunked_arr, const PrettyPrintOptions& op for (int i = 0; i < indent; ++i) { (*sink) << " "; } - (*sink) << "...,"; + (*sink) << "..."; + (*sink) << options.chunked_array_delimiters.element; if (!skip_new_lines) { *sink << "\n"; } i = num_chunks - window - 1; - skip_comma = true; + skip_element_delimiter = true; } else { PrettyPrintOptions chunk_options = options; chunk_options.indent += options.indent_size; diff --git a/cpp/src/arrow/pretty_print.h b/cpp/src/arrow/pretty_print.h index 5d22fd5c51ab8..96a214c68b8a6 100644 --- a/cpp/src/arrow/pretty_print.h +++ b/cpp/src/arrow/pretty_print.h @@ -32,7 +32,21 @@ class Schema; class Status; class Table; -struct PrettyPrintOptions { +/// \class PrettyPrintDelimiters +/// \brief Options for controlling which delimiters to use when printing +/// an Array or ChunkedArray. +struct ARROW_EXPORT PrettyPrintDelimiters { + /// Delimiter for separating individual elements of an Array (e.g. ","), + /// or individual chunks of a ChunkedArray + std::string element = ","; + + /// Create a PrettyPrintDelimiters instance with default values + static PrettyPrintDelimiters Defaults() { return PrettyPrintDelimiters(); } +}; + +/// \class PrettyPrintOptions +/// \brief Options for controlling how various Arrow types should be printed. +struct ARROW_EXPORT PrettyPrintOptions { PrettyPrintOptions() = default; PrettyPrintOptions(int indent, // NOLINT runtime/explicit @@ -47,6 +61,7 @@ struct PrettyPrintOptions { skip_new_lines(skip_new_lines), truncate_metadata(truncate_metadata) {} + /// Create a PrettyPrintOptions instance with default values static PrettyPrintOptions Defaults() { return PrettyPrintOptions(); } /// Number of spaces to shift entire formatted object to the right @@ -77,6 +92,12 @@ struct PrettyPrintOptions { /// If true, display schema metadata when pretty-printing a Schema bool show_schema_metadata = true; + + /// Delimiters to use when printing an Array + PrettyPrintDelimiters array_delimiters = PrettyPrintDelimiters::Defaults(); + + /// Delimiters to use when printing a ChunkedArray + PrettyPrintDelimiters chunked_array_delimiters = PrettyPrintDelimiters::Defaults(); }; /// \brief Print human-readable representation of RecordBatch diff --git a/cpp/src/arrow/pretty_print_test.cc b/cpp/src/arrow/pretty_print_test.cc index 9a6e347c0bdb2..45bb4ecffe054 100644 --- a/cpp/src/arrow/pretty_print_test.cc +++ b/cpp/src/arrow/pretty_print_test.cc @@ -200,6 +200,65 @@ TEST_F(TestPrettyPrint, PrimitiveTypeNoNewlines) { CheckPrimitive(options, is_valid, values, expected, false); } +TEST_F(TestPrettyPrint, ArrayCustomElementDelimiter) { + PrettyPrintOptions options{}; + // Use a custom array element delimiter of " | ", + // rather than the default delimiter (i.e. ","). + options.array_delimiters.element = " | "; + + // Short array without ellipsis + { + std::vector is_valid = {true, true, false, true, false}; + std::vector values = {1, 2, 3, 4, 5}; + static const char* expected = R"expected([ + 1 | + 2 | + null | + 4 | + null +])expected"; + CheckPrimitive(options, is_valid, values, expected, false); + } + + // Longer array with ellipsis + { + std::vector is_valid = {true, false, true}; + std::vector values = {1, 2, 3}; + // Append 20 copies of the value "10" to the end of the values vector. + values.insert(values.end(), 20, 10); + // Append 20 copies of the value "true" to the end of the validity bitmap vector. + is_valid.insert(is_valid.end(), 20, true); + // Append the values 4, 5, and 6 to the end of the values vector. + values.insert(values.end(), {4, 5, 6}); + // Append the values true, false, and true to the end of the validity bitmap vector. + is_valid.insert(is_valid.end(), {true, false, true}); + static const char* expected = R"expected([ + 1 | + null | + 3 | + 10 | + 10 | + 10 | + 10 | + 10 | + 10 | + 10 | + ... + 10 | + 10 | + 10 | + 10 | + 10 | + 10 | + 10 | + 4 | + null | + 6 +])expected"; + CheckPrimitive(options, is_valid, values, expected, false); + } +} + TEST_F(TestPrettyPrint, Int8) { static const char* expected = R"expected([ 0, @@ -1020,6 +1079,58 @@ TEST_F(TestPrettyPrint, ChunkedArrayPrimitiveType) { CheckStream(chunked_array_2, {0}, expected_2); } +TEST_F(TestPrettyPrint, ChunkedArrayCustomElementDelimiter) { + PrettyPrintOptions options{}; + // Use a custom ChunkedArray element delimiter of ";", + // rather than the default delimiter (i.e. ","). + options.chunked_array_delimiters.element = ";"; + // Use a custom Array element delimiter of " | ", + // rather than the default delimiter (i.e. ","). + options.array_delimiters.element = " | "; + + const auto chunk = ArrayFromJSON(int32(), "[1, 2, null, 4, null]"); + + // ChunkedArray with 1 chunk + { + const ChunkedArray chunked_array(chunk); + + static const char* expected = R"expected([ + [ + 1 | + 2 | + null | + 4 | + null + ] +])expected"; + CheckStream(chunked_array, options, expected); + } + + // ChunkedArray with 2 chunks + { + const ChunkedArray chunked_array({chunk, chunk}); + + static const char* expected = R"expected([ + [ + 1 | + 2 | + null | + 4 | + null + ]; + [ + 1 | + 2 | + null | + 4 | + null + ] +])expected"; + + CheckStream(chunked_array, options, expected); + } +} + TEST_F(TestPrettyPrint, TablePrimitive) { std::shared_ptr int_field = field("column", int32()); auto array = ArrayFromJSON(int_field->type(), "[0, 1, null, 3, null]"); diff --git a/cpp/src/arrow/util/print.h b/cpp/src/arrow/util/print.h index d11aa443a95a3..82cea473c5b27 100644 --- a/cpp/src/arrow/util/print.h +++ b/cpp/src/arrow/util/print.h @@ -18,6 +18,9 @@ #pragma once #include +#include "arrow/util/string.h" + +using arrow::internal::ToChars; namespace arrow { namespace internal { @@ -47,5 +50,28 @@ void PrintTuple(OStream* os, const std::tuple& tup) { detail::TuplePrinter, sizeof...(Args)>::Print(os, tup); } +template +struct PrintVector { + const Range& range_; + const Separator& separator_; + + template // template to dodge inclusion of + friend Os& operator<<(Os& os, PrintVector l) { + bool first = true; + os << "["; + for (const auto& element : l.range_) { + if (first) { + first = false; + } else { + os << l.separator_; + } + os << ToChars(element); // use ToChars to avoid locale dependence + } + os << "]"; + return os; + } +}; +template +PrintVector(const Range&, const Separator&) -> PrintVector; } // namespace internal } // namespace arrow diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc index 8585b1ccf11aa..315405ef1e569 100644 --- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc +++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc @@ -2354,10 +2354,11 @@ void TestGetRecordBatchReader( TEST(TestArrowReadWrite, GetRecordBatchReader) { TestGetRecordBatchReader(); } -// Same as the test above, but using coalesced reads. -TEST(TestArrowReadWrite, CoalescedReads) { +// Same as the test above, but using non-coalesced reads. +TEST(TestArrowReadWrite, NoneCoalescedReads) { ArrowReaderProperties arrow_properties = default_arrow_reader_properties(); - arrow_properties.set_pre_buffer(true); + arrow_properties.set_pre_buffer(false); + arrow_properties.set_cache_options(::arrow::io::CacheOptions::Defaults()); TestGetRecordBatchReader(arrow_properties); } diff --git a/cpp/src/parquet/arrow/reader.cc b/cpp/src/parquet/arrow/reader.cc index 142119b770b8c..99b8a9ccef1fa 100644 --- a/cpp/src/parquet/arrow/reader.cc +++ b/cpp/src/parquet/arrow/reader.cc @@ -999,7 +999,8 @@ Status FileReaderImpl::GetRecordBatchReader(const std::vector& row_groups, for (int row_group : row_groups) { int64_t num_rows = parquet_reader()->metadata()->RowGroup(row_group)->num_rows(); - batches.insert(batches.end(), num_rows / batch_size, max_sized_batch); + batches.insert(batches.end(), static_cast(num_rows / batch_size), + max_sized_batch); if (int64_t trailing_rows = num_rows % batch_size) { batches.push_back(max_sized_batch->Slice(0, trailing_rows)); diff --git a/cpp/src/parquet/arrow/reader_internal.cc b/cpp/src/parquet/arrow/reader_internal.cc index 7034f5839e1ea..5146aa12c2c36 100644 --- a/cpp/src/parquet/arrow/reader_internal.cc +++ b/cpp/src/parquet/arrow/reader_internal.cc @@ -365,7 +365,7 @@ Status TransferBool(RecordReader* reader, bool nullable, MemoryPool* pool, Datum // Transfer boolean values to packed bitmap auto values = reinterpret_cast(reader->values()); uint8_t* data_ptr = data->mutable_data(); - memset(data_ptr, 0, buffer_size); + memset(data_ptr, 0, static_cast(buffer_size)); for (int64_t i = 0; i < length; i++) { if (values[i]) { diff --git a/cpp/src/parquet/bloom_filter.cc b/cpp/src/parquet/bloom_filter.cc index e5095515e7d82..427e73b9e6428 100644 --- a/cpp/src/parquet/bloom_filter.cc +++ b/cpp/src/parquet/bloom_filter.cc @@ -143,7 +143,7 @@ BlockSplitBloomFilter BlockSplitBloomFilter::Deserialize( const auto bloom_filter_bytes_in_header = header_buf->size() - header_size; if (bloom_filter_bytes_in_header > 0) { std::memcpy(buffer->mutable_data(), header_buf->data() + header_size, - bloom_filter_bytes_in_header); + static_cast(bloom_filter_bytes_in_header)); } const auto required_read_size = bloom_filter_size - bloom_filter_bytes_in_header; diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc index fa013dd2ea583..e09369effb698 100644 --- a/cpp/src/parquet/column_reader.cc +++ b/cpp/src/parquet/column_reader.cc @@ -1792,7 +1792,7 @@ class TypedRecordReader : public TypedColumnReaderImpl, // Avoid valgrind warnings memset(valid_bits_->mutable_data() + valid_bytes_old, 0, - valid_bytes_new - valid_bytes_old); + static_cast(valid_bytes_new - valid_bytes_old)); } } } @@ -1935,7 +1935,7 @@ class TypedRecordReader : public TypedColumnReaderImpl, // Conservative upper bound const int64_t possible_num_values = std::max(num_records, levels_written_ - levels_position_); - ReserveValues(possible_num_values); + ReserveValues(static_cast(possible_num_values)); const int64_t start_levels_position = levels_position_; diff --git a/cpp/src/parquet/column_scanner.h b/cpp/src/parquet/column_scanner.h index d53435f03cd32..a9953866fab22 100644 --- a/cpp/src/parquet/column_scanner.h +++ b/cpp/src/parquet/column_scanner.h @@ -48,8 +48,10 @@ class PARQUET_EXPORT Scanner { value_offset_(0), values_buffered_(0), reader_(std::move(reader)) { - def_levels_.resize(descr()->max_definition_level() > 0 ? batch_size_ : 0); - rep_levels_.resize(descr()->max_repetition_level() > 0 ? batch_size_ : 0); + def_levels_.resize( + descr()->max_definition_level() > 0 ? static_cast(batch_size_) : 0); + rep_levels_.resize( + descr()->max_repetition_level() > 0 ? static_cast(batch_size_) : 0); } virtual ~Scanner() {} diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc index a0aedeee9e968..be1881d00e035 100644 --- a/cpp/src/parquet/column_writer.cc +++ b/cpp/src/parquet/column_writer.cc @@ -895,11 +895,13 @@ class ColumnWriterImpl { void ConcatenateBuffers(int64_t definition_levels_rle_size, int64_t repetition_levels_rle_size, const std::shared_ptr& values, uint8_t* combined) { - memcpy(combined, repetition_levels_rle_->data(), repetition_levels_rle_size); + memcpy(combined, repetition_levels_rle_->data(), + static_cast(repetition_levels_rle_size)); combined += repetition_levels_rle_size; - memcpy(combined, definition_levels_rle_->data(), definition_levels_rle_size); + memcpy(combined, definition_levels_rle_->data(), + static_cast(definition_levels_rle_size)); combined += definition_levels_rle_size; - memcpy(combined, values->data(), values->size()); + memcpy(combined, values->data(), static_cast(values->size())); } }; diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc index 931b9fd10729f..c136671bd1327 100644 --- a/cpp/src/parquet/encoding.cc +++ b/cpp/src/parquet/encoding.cc @@ -850,8 +850,8 @@ std::shared_ptr ByteStreamSplitEncoder::FlushValues() { AllocateBuffer(this->memory_pool(), EstimatedDataEncodedSize()); uint8_t* output_buffer_raw = output_buffer->mutable_data(); const uint8_t* raw_values = sink_.data(); - ::arrow::util::internal::ByteStreamSplitEncode(raw_values, num_values_in_buffer_, - output_buffer_raw); + ::arrow::util::internal::ByteStreamSplitEncode( + raw_values, static_cast(num_values_in_buffer_), output_buffer_raw); sink_.Reset(); num_values_in_buffer_ = 0; return std::move(output_buffer); @@ -1018,7 +1018,7 @@ inline int DecodePlain(const uint8_t* data, int64_t data_size, int num_values, } // If bytes_to_decode == 0, data could be null if (bytes_to_decode > 0) { - memcpy(out, data, bytes_to_decode); + memcpy(out, data, static_cast(bytes_to_decode)); } return static_cast(bytes_to_decode); } @@ -1574,7 +1574,7 @@ class DictDecoderImpl : public DecoderImpl, virtual public DictDecoder { // XXX(wesm): Cannot append "valid bits" directly to the builder std::vector valid_bytes(num_values, 0); - int64_t i = 0; + size_t i = 0; VisitNullBitmapInline( valid_bits, valid_bits_offset, num_values, null_count, [&]() { valid_bytes[i++] = 1; }, [&]() { ++i; }); diff --git a/cpp/src/parquet/file_reader.cc b/cpp/src/parquet/file_reader.cc index 5247b9d4b543d..7318b5640c0a0 100644 --- a/cpp/src/parquet/file_reader.cc +++ b/cpp/src/parquet/file_reader.cc @@ -139,8 +139,10 @@ const RowGroupMetaData* RowGroupReader::metadata() const { return contents_->met ::arrow::io::ReadRange ComputeColumnChunkRange(FileMetaData* file_metadata, int64_t source_size, int row_group_index, int column_index) { - auto row_group_metadata = file_metadata->RowGroup(row_group_index); - auto column_metadata = row_group_metadata->ColumnChunk(column_index); + std::unique_ptr row_group_metadata = + file_metadata->RowGroup(row_group_index); + std::unique_ptr column_metadata = + row_group_metadata->ColumnChunk(column_index); int64_t col_start = column_metadata->data_page_offset(); if (column_metadata->has_dictionary_page() && @@ -918,7 +920,7 @@ int64_t ScanFileContents(std::vector columns, const int32_t column_batch_si ScanAllValues(column_batch_size, def_levels.data(), rep_levels.data(), values.data(), &values_read, col_reader.get()); if (col_reader->descr()->max_repetition_level() > 0) { - for (int64_t i = 0; i < levels_read; i++) { + for (size_t i = 0; i < static_cast(levels_read); i++) { if (rep_levels[i] == 0) { total_rows[col]++; } diff --git a/cpp/src/parquet/metadata.cc b/cpp/src/parquet/metadata.cc index 4ef2151fee59d..8697cd52515ae 100644 --- a/cpp/src/parquet/metadata.cc +++ b/cpp/src/parquet/metadata.cc @@ -1843,7 +1843,8 @@ class FileMetaDataBuilder::FileMetaDataBuilderImpl { key_value_metadata_ = key_value_metadata_->Merge(*key_value_metadata); } metadata_->key_value_metadata.clear(); - metadata_->key_value_metadata.reserve(key_value_metadata_->size()); + metadata_->key_value_metadata.reserve( + static_cast(key_value_metadata_->size())); for (int64_t i = 0; i < key_value_metadata_->size(); ++i) { format::KeyValue kv_pair; kv_pair.__set_key(key_value_metadata_->key(i)); diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h index 387147ac7a3c5..6d3d5aa4f44b4 100644 --- a/cpp/src/parquet/properties.h +++ b/cpp/src/parquet/properties.h @@ -196,7 +196,12 @@ class PARQUET_EXPORT ColumnProperties { size_t max_statistics_size() const { return max_stats_size_; } - int compression_level() const { return codec_options_->compression_level; } + int compression_level() const { + if (!codec_options_) { + return ::arrow::util::kUseDefaultCompressionLevel; + } + return codec_options_->compression_level; + } const std::shared_ptr& codec_options() const { return codec_options_; } @@ -857,8 +862,8 @@ class PARQUET_EXPORT ArrowReaderProperties { : use_threads_(use_threads), read_dict_indices_(), batch_size_(kArrowDefaultBatchSize), - pre_buffer_(false), - cache_options_(::arrow::io::CacheOptions::Defaults()), + pre_buffer_(true), + cache_options_(::arrow::io::CacheOptions::LazyDefaults()), coerce_int96_timestamp_unit_(::arrow::TimeUnit::NANO) {} /// \brief Set whether to use the IO thread pool to parse columns in parallel. diff --git a/cpp/src/parquet/properties_test.cc b/cpp/src/parquet/properties_test.cc index 96c3a63b831eb..b2c574413abf7 100644 --- a/cpp/src/parquet/properties_test.cc +++ b/cpp/src/parquet/properties_test.cc @@ -49,6 +49,15 @@ TEST(TestWriterProperties, Basics) { ASSERT_FALSE(props->page_checksum_enabled()); } +TEST(TestWriterProperties, DefaultCompression) { + std::shared_ptr props = WriterProperties::Builder().build(); + + ASSERT_EQ(props->compression(ColumnPath::FromDotString("any")), + Compression::UNCOMPRESSED); + ASSERT_EQ(props->compression_level(ColumnPath::FromDotString("any")), + ::arrow::util::kUseDefaultCompressionLevel); +} + TEST(TestWriterProperties, AdvancedHandling) { WriterProperties::Builder builder; builder.compression("gzip", Compression::GZIP); diff --git a/cpp/src/parquet/statistics.cc b/cpp/src/parquet/statistics.cc index d5fc71b3958e1..ccfb69c487d40 100644 --- a/cpp/src/parquet/statistics.cc +++ b/cpp/src/parquet/statistics.cc @@ -771,7 +771,7 @@ void TypedStatisticsImpl::PlainEncode(const T& src, std::string* dst) con encoder->Put(&src, 1); auto buffer = encoder->FlushValues(); auto ptr = reinterpret_cast(buffer->data()); - dst->assign(ptr, buffer->size()); + dst->assign(ptr, static_cast(buffer->size())); } template diff --git a/cpp/thirdparty/versions.txt b/cpp/thirdparty/versions.txt index 52d302592b55c..56163f35d2499 100644 --- a/cpp/thirdparty/versions.txt +++ b/cpp/thirdparty/versions.txt @@ -101,9 +101,8 @@ ARROW_RAPIDJSON_BUILD_VERSION=232389d4f1012dddec4ef84861face2d2ba85709 ARROW_RAPIDJSON_BUILD_SHA256_CHECKSUM=b9290a9a6d444c8e049bd589ab804e0ccf2b05dc5984a19ed5ae75d090064806 ARROW_RE2_BUILD_VERSION=2022-06-01 ARROW_RE2_BUILD_SHA256_CHECKSUM=f89c61410a072e5cbcf8c27e3a778da7d6fd2f2b5b1445cd4f4508bee946ab0f -# 1.1.9 is patched to implement https://github.com/google/snappy/pull/148 if this is bumped, remove the patch -ARROW_SNAPPY_BUILD_VERSION=1.1.9 -ARROW_SNAPPY_BUILD_SHA256_CHECKSUM=75c1fbb3d618dd3a0483bff0e26d0a92b495bbe5059c8b4f1c962b478b6e06e7 +ARROW_SNAPPY_BUILD_VERSION=1.1.10 +ARROW_SNAPPY_BUILD_SHA256_CHECKSUM=49d831bffcc5f3d01482340fe5af59852ca2fe76c3e05df0e67203ebbe0f1d90 ARROW_SUBSTRAIT_BUILD_VERSION=v0.27.0 ARROW_SUBSTRAIT_BUILD_SHA256_CHECKSUM=4ed375f69d972a57fdc5ec406c17003a111831d8640d3f1733eccd4b3ff45628 ARROW_S2N_TLS_BUILD_VERSION=v1.3.35 diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs index 806defdc7ce66..a3b39923809bb 100644 --- a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs +++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs @@ -50,7 +50,8 @@ private class ArrayDataConcatenationVisitor : IArrowTypeVisitor, IArrowTypeVisitor, IArrowTypeVisitor, - IArrowTypeVisitor + IArrowTypeVisitor, + IArrowTypeVisitor { public ArrayData Result { get; private set; } private readonly IReadOnlyList _arrayDataList; @@ -92,15 +93,7 @@ public void Visit(FixedWidthType type) public void Visit(StringType type) => ConcatenateVariableBinaryArrayData(type); - public void Visit(ListType type) - { - CheckData(type, 2); - ArrowBuffer validityBuffer = ConcatenateValidityBuffer(); - ArrowBuffer offsetBuffer = ConcatenateOffsetBuffer(); - ArrayData child = Concatenate(SelectChildren(0), _allocator); - - Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer, offsetBuffer }, new[] { child }); - } + public void Visit(ListType type) => ConcatenateLists(type); public void Visit(FixedSizeListType type) { @@ -114,6 +107,7 @@ public void Visit(FixedSizeListType type) public void Visit(StructType type) { CheckData(type, 1); + ArrowBuffer validityBuffer = ConcatenateValidityBuffer(); List children = new List(type.Fields.Count); for (int i = 0; i < type.Fields.Count; i++) @@ -121,7 +115,7 @@ public void Visit(StructType type) children.Add(Concatenate(SelectChildren(i), _allocator)); } - Result = new ArrayData(type, _arrayDataList[0].Length, _arrayDataList[0].NullCount, 0, _arrayDataList[0].Buffers, children); + Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer }, children); } public void Visit(UnionType type) @@ -151,6 +145,8 @@ public void Visit(UnionType type) Result = new ArrayData(type, _totalLength, _totalNullCount, 0, buffers, children); } + public void Visit(MapType type) => ConcatenateLists(type.UnsortedKey()); /* Can't tell if the output is still sorted */ + public void Visit(IArrowType type) { throw new NotImplementedException($"Concatenation for {type.Name} is not supported yet."); @@ -175,6 +171,16 @@ private void ConcatenateVariableBinaryArrayData(IArrowType type) Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer, offsetBuffer, valueBuffer }); } + private void ConcatenateLists(NestedType type) + { + CheckData(type, 2); + ArrowBuffer validityBuffer = ConcatenateValidityBuffer(); + ArrowBuffer offsetBuffer = ConcatenateOffsetBuffer(); + ArrayData child = Concatenate(SelectChildren(0), _allocator); + + Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer, offsetBuffer }, new[] { child }); + } + private ArrowBuffer ConcatenateValidityBuffer() { if (_totalNullCount == 0) diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs index 6b54ec1edb573..1698e0672fb60 100644 --- a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs +++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs @@ -28,7 +28,8 @@ internal sealed class ArrayDataTypeComparer : IArrowTypeVisitor, IArrowTypeVisitor, IArrowTypeVisitor, - IArrowTypeVisitor + IArrowTypeVisitor, + IArrowTypeVisitor { private readonly IArrowType _expectedType; private bool _dataTypeMatch; @@ -132,6 +133,16 @@ public void Visit(UnionType actualType) } } + public void Visit(MapType actualType) + { + if (_expectedType is MapType expectedType + && expectedType.KeySorted == actualType.KeySorted + && CompareNested(expectedType, actualType)) + { + _dataTypeMatch = true; + } + } + private static bool CompareNested(NestedType expectedType, NestedType actualType) { if (expectedType.Fields.Count != actualType.Fields.Count) diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayConcatenator.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayConcatenator.cs index cc151210aec6b..ac8252211eae4 100644 --- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayConcatenator.cs +++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayConcatenator.cs @@ -18,9 +18,9 @@ namespace Apache.Arrow { - static class ArrowArrayConcatenator + public static class ArrowArrayConcatenator { - internal static IArrowArray Concatenate(IReadOnlyList arrowArrayList , MemoryAllocator allocator = default) + public static IArrowArray Concatenate(IReadOnlyList arrowArrayList , MemoryAllocator allocator = default) { if(arrowArrayList == null || arrowArrayList.Count == 0) { diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs index aa407203d1858..d3b7d65185abe 100644 --- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs +++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs @@ -59,6 +59,8 @@ public static IArrowArray BuildArray(ArrayData data) return new TimestampArray(data); case ArrowTypeId.List: return new ListArray(data); + case ArrowTypeId.Map: + return new MapArray(data); case ArrowTypeId.Struct: return new StructArray(data); case ArrowTypeId.Union: @@ -86,7 +88,6 @@ public static IArrowArray BuildArray(ArrayData data) case ArrowTypeId.FixedSizeList: return new FixedSizeListArray(data); case ArrowTypeId.Interval: - case ArrowTypeId.Map: default: throw new NotSupportedException($"An ArrowArray cannot be built for type {data.DataType.TypeId}."); } diff --git a/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs b/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs index 4fd8059f6fe70..20fe0342cca40 100644 --- a/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs +++ b/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs @@ -237,7 +237,7 @@ public TBuilder Reserve(int capacity) // TODO: [ARROW-9366] Reserve capacity in the value buffer in a more sensible way. ValueOffsets.Reserve(capacity + 1); ValueBuffer.Reserve(capacity); - ValidityBuffer.Reserve(capacity + 1); + ValidityBuffer.Reserve(capacity); return Instance; } @@ -246,7 +246,7 @@ public TBuilder Resize(int length) // TODO: [ARROW-9366] Resize the value buffer to a safe length based on offsets, not `length`. ValueOffsets.Resize(length + 1); ValueBuffer.Resize(length); - ValidityBuffer.Resize(length + 1); + ValidityBuffer.Resize(length); return Instance; } diff --git a/csharp/src/Apache.Arrow/Arrays/FixedSizeBinaryArray.cs b/csharp/src/Apache.Arrow/Arrays/FixedSizeBinaryArray.cs index 7d3d8754747e9..866a674bc9df8 100644 --- a/csharp/src/Apache.Arrow/Arrays/FixedSizeBinaryArray.cs +++ b/csharp/src/Apache.Arrow/Arrays/FixedSizeBinaryArray.cs @@ -111,14 +111,14 @@ public TArray Build(MemoryAllocator allocator = default) public TBuilder Reserve(int capacity) { ValueBuffer.Reserve(capacity * ByteWidth); - ValidityBuffer.Reserve(capacity + 1); + ValidityBuffer.Reserve(capacity); return Instance; } public TBuilder Resize(int length) { ValueBuffer.Resize(length * ByteWidth); - ValidityBuffer.Resize(length + 1); + ValidityBuffer.Resize(length); return Instance; } diff --git a/csharp/src/Apache.Arrow/Arrays/ListArray.cs b/csharp/src/Apache.Arrow/Arrays/ListArray.cs index 97673cb48e6a8..4d2ff96a3d005 100644 --- a/csharp/src/Apache.Arrow/Arrays/ListArray.cs +++ b/csharp/src/Apache.Arrow/Arrays/ListArray.cs @@ -91,14 +91,14 @@ public ListArray Build(MemoryAllocator allocator = default) public Builder Reserve(int capacity) { ValueOffsetsBufferBuilder.Reserve(capacity + 1); - ValidityBufferBuilder.Reserve(capacity + 1); + ValidityBufferBuilder.Reserve(capacity); return this; } public Builder Resize(int length) { ValueOffsetsBufferBuilder.Resize(length + 1); - ValidityBufferBuilder.Resize(length + 1); + ValidityBufferBuilder.Resize(length); return this; } @@ -139,6 +139,14 @@ private ListArray(ArrayData data, IArrowArray values) : base(data) Values = values; } + // Constructor for child MapArray + internal ListArray(ArrayData data, IArrowArray values, ArrowTypeId typeId) : base(data) + { + data.EnsureBufferCount(2); + data.EnsureDataType(typeId); + Values = values; + } + public override void Accept(IArrowArrayVisitor visitor) => Accept(this, visitor); diff --git a/csharp/src/Apache.Arrow/Arrays/MapArray.cs b/csharp/src/Apache.Arrow/Arrays/MapArray.cs new file mode 100644 index 0000000000000..a6676b134e34a --- /dev/null +++ b/csharp/src/Apache.Arrow/Arrays/MapArray.cs @@ -0,0 +1,174 @@ +// Licensed to the Apache Software Foundation (ASF) under one or more +// contributor license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright ownership. +// The ASF licenses this file to You under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +using System; +using System.Collections.Generic; +using Apache.Arrow.Memory; +using Apache.Arrow.Types; + +namespace Apache.Arrow +{ + public class MapArray : ListArray // MapArray = ListArray(StructArray("key", "value")) + { + // Same as ListArray.Builder, but with KeyBuilder + public new class Builder : IArrowArrayBuilder + { + public IArrowArrayBuilder> KeyBuilder { get; } + public IArrowArrayBuilder> ValueBuilder { get; } + + public int Length => ValueOffsetsBufferBuilder.Length; + + private ArrowBuffer.Builder ValueOffsetsBufferBuilder { get; } + + private ArrowBuffer.BitmapBuilder ValidityBufferBuilder { get; } + + public int NullCount { get; protected set; } + + public MapType DataType { get; } + + public Builder(MapType type) + { + KeyBuilder = ArrowArrayBuilderFactory.Build(type.KeyField.DataType); + ValueBuilder = ArrowArrayBuilderFactory.Build(type.ValueField.DataType); + ValueOffsetsBufferBuilder = new ArrowBuffer.Builder(); + ValidityBufferBuilder = new ArrowBuffer.BitmapBuilder(); + DataType = type; + } + + /// + /// Start a new variable-length list slot + /// + /// This function should be called before beginning to append elements to the + /// value builder + /// + /// + public Builder Append() + { + ValueOffsetsBufferBuilder.Append(KeyBuilder.Length); + ValidityBufferBuilder.Append(true); + + return this; + } + + public Builder AppendNull() + { + ValueOffsetsBufferBuilder.Append(KeyBuilder.Length); + ValidityBufferBuilder.Append(false); + NullCount++; + + return this; + } + + public MapArray Build(MemoryAllocator allocator = default) + { + ValueOffsetsBufferBuilder.Append(KeyBuilder.Length); + + ArrowBuffer validityBuffer = NullCount > 0 ? ValidityBufferBuilder.Build(allocator) : ArrowBuffer.Empty; + + StructArray structs = new StructArray( + DataType.KeyValueType, KeyBuilder.Length, + new IArrowArray[] { KeyBuilder.Build(allocator), ValueBuilder.Build(allocator) }, + ArrowBuffer.Empty, 0 + ); + + return new MapArray(DataType, Length - 1, ValueOffsetsBufferBuilder.Build(allocator), structs, validityBuffer, NullCount); + } + + public Builder Reserve(int capacity) + { + ValueOffsetsBufferBuilder.Reserve(capacity + 1); + ValidityBufferBuilder.Reserve(capacity); + return this; + } + + public Builder Resize(int length) + { + ValueOffsetsBufferBuilder.Resize(length + 1); + ValidityBufferBuilder.Resize(length); + return this; + } + + public Builder Clear() + { + ValueOffsetsBufferBuilder.Clear(); + KeyBuilder.Clear(); + ValueBuilder.Clear(); + ValidityBufferBuilder.Clear(); + return this; + } + + } + + public StructArray KeyValues => base.Values as StructArray; + public IArrowArray Keys => KeyValues.Fields[0]; + public new IArrowArray Values => KeyValues.Fields[1]; + + public MapArray(IArrowType dataType, int length, + ArrowBuffer valueOffsetsBuffer, IArrowArray structs, + ArrowBuffer nullBitmapBuffer, int nullCount = 0, int offset = 0) + : this( + new ArrayData( + dataType, length, nullCount, offset, new[] { nullBitmapBuffer, valueOffsetsBuffer }, + new[] { structs.Data } + ), structs) + { + } + + public MapArray(ArrayData data) + : this(data, ArrowArrayFactory.BuildArray(data.Children[0])) + { + } + + private MapArray(ArrayData data, IArrowArray structs) : base(data, structs, ArrowTypeId.Map) + { + } + + public IEnumerable> GetTuples(int index, Func getKey, Func getValue) + where TKeyArray : Array where TValueArray : Array + { + ReadOnlySpan offsets = ValueOffsets; + // Get key values + int start = offsets[index]; + int end = offsets[index + 1]; + StructArray array = KeyValues.Slice(start, end - start) as StructArray; + + TKeyArray keyArray = array.Fields[0] as TKeyArray; + TValueArray valueArray = array.Fields[1] as TValueArray; + + for (int i = start; i < end; i++) + { + yield return new Tuple(getKey(keyArray, i), getValue(valueArray, i)); + } + } + + public IEnumerable> GetKeyValuePairs(int index, Func getKey, Func getValue) + where TKeyArray : Array where TValueArray : Array + { + ReadOnlySpan offsets = ValueOffsets; + // Get key values + int start = offsets[index]; + int end = offsets[index + 1]; + StructArray array = KeyValues.Slice(start, end - start) as StructArray; + + TKeyArray keyArray = array.Fields[0] as TKeyArray; + TValueArray valueArray = array.Fields[1] as TValueArray; + + for (int i = start; i < end; i++) + { + yield return new KeyValuePair(getKey(keyArray, i), getValue(valueArray, i)); + } + } + } +} diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs index da1b0f31b8f08..1b40ec49658bb 100644 --- a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs +++ b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs @@ -180,6 +180,9 @@ private ArrayData GetAsArrayData(CArrowArray* cArray, IArrowType type) }; ; break; case ArrowTypeId.Map: + MapType mapType = (MapType)type; + children = ProcessListChildren(cArray, mapType.Fields[0].DataType); + buffers = ImportListBuffers(cArray); break; case ArrowTypeId.Null: buffers = System.Array.Empty(); diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs index c1a12362a942a..f3479903889d1 100644 --- a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs +++ b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs @@ -188,6 +188,7 @@ private static string GetFormat(IArrowType datatype) return $"+w:{fixedListType.ListSize}"; case StructType _: return "+s"; case UnionType u: return FormatUnion(u); + case MapType _: return "+m"; // Dictionary case DictionaryType dictionaryType: return GetFormat(dictionaryType.IndexType); @@ -212,10 +213,9 @@ private static long GetFlags(IArrowType datatype, bool nullable = true) } } - if (datatype.TypeId == ArrowTypeId.Map) + if (datatype is MapType mapType && mapType.KeySorted) { - // TODO: when we implement MapType, make sure to set the KEYS_SORTED flag. - throw new NotSupportedException("Exporting MapTypes is not supported."); + flags |= CArrowSchema.ArrowFlagMapKeysSorted; } return flags; diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs index f7216df869abd..f2a08f5e4a40b 100644 --- a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs +++ b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs @@ -206,8 +206,14 @@ public ArrowType GetAsType() return new FixedSizeListType(childField, width); } + else if (format == "+m") + { + return new MapType( + ParseChildren("map").Single(), + (_cSchema->flags & CArrowSchema.ArrowFlagMapKeysSorted) != 0); + } - // TODO: Map type and large list type + // TODO: Large list type // Decimals if (format.StartsWith("d:")) diff --git a/csharp/src/Apache.Arrow/DecimalUtility.cs b/csharp/src/Apache.Arrow/DecimalUtility.cs index c117c263612fe..4a29d068c6eff 100644 --- a/csharp/src/Apache.Arrow/DecimalUtility.cs +++ b/csharp/src/Apache.Arrow/DecimalUtility.cs @@ -50,10 +50,21 @@ internal static decimal GetDecimal(in ArrowBuffer valueBuffer, int index, int sc { BigInteger scaleBy = BigInteger.Pow(10, scale); BigInteger integerPart = BigInteger.DivRem(integerValue, scaleBy, out BigInteger fractionalPart); - if (integerPart > _maxDecimal || integerPart < _minDecimal) // decimal overflow, not much we can do here - C# needs a BigDecimal + + // decimal overflow, not much we can do here - C# needs a BigDecimal + if (integerPart > _maxDecimal) + { + throw new OverflowException($"Value: {integerPart} of {integerValue} is too big be represented as a decimal"); + } + else if (integerPart < _minDecimal) { - throw new OverflowException($"Value: {integerPart} too big or too small to be represented as a decimal"); + throw new OverflowException($"Value: {integerPart} of {integerValue} is too small be represented as a decimal"); } + else if (fractionalPart > _maxDecimal || fractionalPart < _minDecimal) + { + throw new OverflowException($"Value: {fractionalPart} of {integerValue} is too precise be represented as a decimal"); + } + return (decimal)integerPart + DivideByScale(fractionalPart, scale); } else diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs index b11467538dd04..425d9326addfe 100644 --- a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs +++ b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs @@ -67,6 +67,7 @@ class TypeVisitor : IArrowTypeVisitor, IArrowTypeVisitor, IArrowTypeVisitor, + IArrowTypeVisitor, IArrowTypeVisitor { private FlatBufferBuilder Builder { get; } @@ -229,6 +230,13 @@ public void Visit(FixedSizeBinaryType type) Flatbuf.FixedSizeBinary.CreateFixedSizeBinary(Builder, type.ByteWidth)); } + public void Visit(MapType type) + { + Result = FieldType.Build( + Flatbuf.Type.Map, + Flatbuf.Map.CreateMap(Builder, type.KeySorted)); + } + public void Visit(NullType type) { Flatbuf.Null.StartNull(Builder); @@ -239,7 +247,7 @@ public void Visit(NullType type) public void Visit(IArrowType type) { - throw new NotImplementedException(); + throw new NotImplementedException($"Cannot visit type {type}"); } } diff --git a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs index 6249063ba81f4..9847c376cf82e 100644 --- a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs +++ b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs @@ -207,6 +207,13 @@ private static Types.IArrowType GetFieldArrowType(Flatbuf.Field field, Field[] c Debug.Assert(childFields != null); Flatbuf.Union unionMetadata = field.Type().Value; return new Types.UnionType(childFields, unionMetadata.GetTypeIdsArray(), unionMetadata.Mode.ToArrow()); + case Flatbuf.Type.Map: + if (childFields == null || childFields.Length != 1) + { + throw new InvalidDataException($"Map type must have exactly one struct child."); + } + Flatbuf.Map meta = field.Type().Value; + return new Types.MapType(childFields[0], meta.KeysSorted); default: throw new InvalidDataException($"Arrow primitive '{field.TypeType}' is unsupported."); } diff --git a/csharp/src/Apache.Arrow/Types/ListType.cs b/csharp/src/Apache.Arrow/Types/ListType.cs index a006c2282dd11..b467934ec541d 100644 --- a/csharp/src/Apache.Arrow/Types/ListType.cs +++ b/csharp/src/Apache.Arrow/Types/ListType.cs @@ -13,8 +13,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -using System; - namespace Apache.Arrow.Types { public sealed class ListType : NestedType diff --git a/csharp/src/Apache.Arrow/Types/MapType.cs b/csharp/src/Apache.Arrow/Types/MapType.cs new file mode 100644 index 0000000000000..73112c815bfbf --- /dev/null +++ b/csharp/src/Apache.Arrow/Types/MapType.cs @@ -0,0 +1,58 @@ +// Licensed to the Apache Software Foundation (ASF) under one or more +// contributor license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright ownership. +// The ASF licenses this file to You under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +using System.Collections.Generic; + +namespace Apache.Arrow.Types +{ + public sealed class MapType : NestedType // MapType = ListType(StructType("key", "value")) + { + public override ArrowTypeId TypeId => ArrowTypeId.Map; + public override string Name => "map"; + public readonly bool KeySorted; + + public StructType KeyValueType => Fields[0].DataType as StructType; + public Field KeyField => KeyValueType.Fields[0]; + public Field ValueField => KeyValueType.Fields[1]; + + public MapType(IArrowType key, IArrowType value, bool nullable = true, bool keySorted = false) + : this(new Field("key", key, false), new Field("value", value, nullable), keySorted) + { + } + + public MapType(Field key, Field value, bool keySorted = false) + : this(new StructType(new List() { key, value }), keySorted) + { + } + + public MapType(StructType entries, bool keySorted = false) : this(new Field("entries", entries, false), keySorted) + { + } + + public MapType(Field entries, bool keySorted = false) : base(entries) + { + KeySorted = keySorted; + } + + public override void Accept(IArrowTypeVisitor visitor) => Accept(this, visitor); + + public MapType UnsortedKey() + { + if (!KeySorted) { return this; } + + return new MapType(Fields[0], keySorted: false); + } + } +} diff --git a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs index 85f66890edf47..d06249bef2661 100644 --- a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs +++ b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs @@ -124,6 +124,7 @@ private static IArrowType ToArrowType(JsonArrowType type, Field[] children) "fixedsizelist" => ToFixedSizeListArrowType(type, children), "struct" => ToStructArrowType(type, children), "union" => ToUnionArrowType(type, children), + "map" => ToMapArrowType(type, children), "null" => NullType.Default, _ => throw new NotSupportedException($"JsonArrowType not supported: {type.Name}") }; @@ -227,6 +228,11 @@ private static IArrowType ToUnionArrowType(JsonArrowType type, Field[] children) }; return new UnionType(children, type.TypeIds, mode); } + + private static IArrowType ToMapArrowType(JsonArrowType type, Field[] children) + { + return new MapType(children[0], type.KeysSorted); + } } public class JsonField @@ -271,6 +277,9 @@ public class JsonArrowType public string Mode { get; set; } public int[] TypeIds { get; set; } + // map fields + public bool KeysSorted { get; set; } + [JsonExtensionData] public Dictionary ExtensionData { get; set; } } @@ -345,6 +354,7 @@ private class ArrayCreator : IArrowTypeVisitor, IArrowTypeVisitor, IArrowTypeVisitor, + IArrowTypeVisitor, IArrowTypeVisitor { private JsonFieldData JsonFieldData { get; set; } @@ -616,6 +626,21 @@ public void Visit(UnionType type) Array = UnionArray.Create(arrayData); } + public void Visit(MapType type) + { + ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount); + ArrowBuffer offsetBuffer = GetOffsetBuffer(); + + var data = JsonFieldData; + JsonFieldData = data.Children[0]; + type.KeyValueType.Accept(this); + JsonFieldData = data; + + ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0, + new[] { validityBuffer, offsetBuffer }, new[] { Array.Data }); + Array = new MapArray(arrayData); + } + private ArrayData[] GetChildren(NestedType type) { ArrayData[] children = new ArrayData[type.Fields.Count]; diff --git a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs index c8bcc3cee0f99..ad3527c47807b 100644 --- a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs +++ b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs @@ -29,7 +29,8 @@ public class ArrayTypeComparer : IArrowTypeVisitor, IArrowTypeVisitor, IArrowTypeVisitor, - IArrowTypeVisitor + IArrowTypeVisitor, + IArrowTypeVisitor { private readonly IArrowType _expectedType; @@ -131,6 +132,16 @@ public void Visit(UnionType actualType) CompareNested(expectedType, actualType); } + public void Visit(MapType actualType) + { + Assert.IsAssignableFrom(_expectedType); + var expectedType = (MapType)_expectedType; + + Assert.Equal(expectedType.KeySorted, actualType.KeySorted); + + CompareNested(expectedType, actualType); + } + private static void CompareNested(NestedType expectedType, NestedType actualType) { Assert.Equal(expectedType.Fields.Count, actualType.Fields.Count); diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs index f5a2c345e2ae6..6f4c17a959981 100644 --- a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs +++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs @@ -30,7 +30,7 @@ public void TestStandardCases() { foreach ((List testTargetArrayList, IArrowArray expectedArray) in GenerateTestData()) { - IArrowArray actualArray = ArrowArrayConcatenatorReflector.InvokeConcatenate(testTargetArrayList); + IArrowArray actualArray = ArrowArrayConcatenator.Concatenate(testTargetArrayList); ArrowReaderVerifier.CompareArrays(expectedArray, actualArray); } } @@ -38,15 +38,15 @@ public void TestStandardCases() [Fact] public void TestNullOrEmpty() { - Assert.Null(ArrowArrayConcatenatorReflector.InvokeConcatenate(null)); - Assert.Null(ArrowArrayConcatenatorReflector.InvokeConcatenate(new List())); + Assert.Null(ArrowArrayConcatenator.Concatenate(null)); + Assert.Null(ArrowArrayConcatenator.Concatenate(new List())); } [Fact] public void TestSingleElement() { Int32Array array = new Int32Array.Builder().Append(1).Append(2).Build(); - IArrowArray actualArray = ArrowArrayConcatenatorReflector.InvokeConcatenate(new[] { array }); + IArrowArray actualArray = ArrowArrayConcatenator.Concatenate(new[] { array }); ArrowReaderVerifier.CompareArrays(array, actualArray); } @@ -93,6 +93,10 @@ private static IEnumerable, IArrowArray>> GenerateTestDa new[] { 0, 1 }, UnionMode.Dense ), + new MapType( + new Field.Builder().Name("key").DataType(StringType.Default).Nullable(false).Build(), + new Field.Builder().Name("value").DataType(Int32Type.Default).Nullable(true).Build(), + keySorted: false), }; foreach (IArrowType type in targetTypes) @@ -103,17 +107,6 @@ private static IEnumerable, IArrowArray>> GenerateTestDa } } - private static class ArrowArrayConcatenatorReflector - { - private static readonly MethodInfo s_concatenateInfo = typeof(ArrayData).Assembly.GetType("Apache.Arrow.ArrowArrayConcatenator") - .GetMethod("Concatenate", BindingFlags.Static | BindingFlags.NonPublic); - - internal static IArrowArray InvokeConcatenate(IReadOnlyList arrowArrayList, MemoryAllocator allocator = default) - { - return s_concatenateInfo.Invoke(null, new object[] { arrowArrayList, allocator }) as IArrowArray; - } - } - private class TestDataGenerator : IArrowTypeVisitor, IArrowTypeVisitor, @@ -136,7 +129,8 @@ private class TestDataGenerator : IArrowTypeVisitor, IArrowTypeVisitor, IArrowTypeVisitor, - IArrowTypeVisitor + IArrowTypeVisitor, + IArrowTypeVisitor { private List> _baseData; @@ -310,7 +304,6 @@ public void Visit(StringType type) public void Visit(ListType type) { ListArray.Builder resultBuilder = new ListArray.Builder(type.ValueDataType).Reserve(_baseDataTotalElementCount); - //Todo : Support various types Int64Array.Builder resultValueBuilder = (Int64Array.Builder)resultBuilder.ValueBuilder.Reserve(_baseDataTotalElementCount); for (int i = 0; i < _baseDataListCount; i++) @@ -346,7 +339,6 @@ public void Visit(ListType type) public void Visit(FixedSizeListType type) { FixedSizeListArray.Builder resultBuilder = new FixedSizeListArray.Builder(type.ValueDataType, type.ListSize).Reserve(_baseDataTotalElementCount); - //Todo : Support various types Int32Array.Builder resultValueBuilder = (Int32Array.Builder)resultBuilder.ValueBuilder.Reserve(_baseDataTotalElementCount); for (int i = 0; i < _baseDataListCount; i++) @@ -406,7 +398,7 @@ public void Visit(StructType type) StringArray resultStringArray = resultStringBuilder.Build(); Int32Array resultInt32Array = resultInt32Builder.Build(); - ExpectedArray = new StructArray(type, 3, new List { resultStringArray, resultInt32Array }, nullBitmapBuffer, 1); + ExpectedArray = new StructArray(type, 9, new List { resultStringArray, resultInt32Array }, nullBitmapBuffer, 3); } public void Visit(UnionType type) @@ -495,6 +487,46 @@ public void Visit(UnionType type) new[] { stringResultBuilder.Build().Data, intResultBuilder.Build().Data })); } + public void Visit(MapType type) + { + MapArray.Builder resultBuilder = new MapArray.Builder(type).Reserve(_baseDataTotalElementCount); + StringArray.Builder resultKeyBuilder = (StringArray.Builder)resultBuilder.KeyBuilder.Reserve(_baseDataTotalElementCount); + Int32Array.Builder resultValueBuilder = (Int32Array.Builder)resultBuilder.ValueBuilder.Reserve(_baseDataTotalElementCount); + ArrowBuffer nullBitmapBuilder = new ArrowBuffer.BitmapBuilder().Append(true).Append(true).Append(false).Build(); + + for (int i = 0; i < _baseData.Count; i++) + { + List dataList = _baseData[i]; + + MapArray.Builder builder = new MapArray.Builder(type).Reserve(dataList.Count); + StringArray.Builder keyBuilder = (StringArray.Builder)builder.KeyBuilder.Reserve(dataList.Count); + Int32Array.Builder valueBuilder = (Int32Array.Builder)builder.ValueBuilder.Reserve(dataList.Count); + + foreach (int? value in dataList) + { + if (value.HasValue) + { + builder.Append(); + resultBuilder.Append(); + + keyBuilder.Append(value.Value.ToString()); + valueBuilder.Append(value.Value); + resultKeyBuilder.Append(value.Value.ToString()); + resultValueBuilder.Append(value.Value); + } + else + { + builder.AppendNull(); + resultBuilder.AppendNull(); + } + } + + TestTargetArrayList.Add(builder.Build()); + } + + ExpectedArray = resultBuilder.Build(); + } + public void Visit(IArrowType type) { throw new NotImplementedException(); diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs index b6b65a582d953..7aee37b8212c3 100644 --- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs +++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs @@ -115,6 +115,8 @@ private static Schema GetTestSchema() .Field(f => f.Name("dense_union").DataType(new UnionType(new[] { new Field("i64", Int64Type.Default, false), new Field("f32", FloatType.Default, true), }, new[] { 0, 1 }, UnionMode.Dense))) .Field(f => f.Name("sparse_union").DataType(new UnionType(new[] { new Field("i32", Int32Type.Default, true), new Field("f64", DoubleType.Default, false), }, new[] { 0, 1 }, UnionMode.Sparse))) + .Field(f => f.Name("map").DataType(new MapType(StringType.Default, Int32Type.Default)).Nullable(false)) + // Checking wider characters. .Field(f => f.Name("hello 你好 😄").DataType(BooleanType.Default).Nullable(true)) @@ -178,6 +180,8 @@ private static IEnumerable GetPythonFields() yield return pa.field("dense_union", pa.dense_union(List(pa.field("i64", pa.int64(), false), pa.field("f32", pa.float32(), true)))); yield return pa.field("sparse_union", pa.sparse_union(List(pa.field("i32", pa.int32(), true), pa.field("f64", pa.float64(), false)))); + yield return pa.field("map", pa.map_(pa.@string(), pa.int32()), false); + yield return pa.field("hello 你好 😄", pa.bool_(), true); } } @@ -512,8 +516,12 @@ public unsafe void ImportRecordBatch() ), /* field name */ List("i32", "s"), /* type codes */ List(3, 2)), + pa.MapArray.from_arrays( + List(0, 0, 1, 2, 4, 10), + pa.array(List("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten")), + pa.array(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))), }), - new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8", "col9" }); + new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8", "col9", "col10" }); dynamic batch = table.to_batches()[0]; @@ -585,6 +593,11 @@ public unsafe void ImportRecordBatch() UnionArray col9 = (UnionArray)recordBatch.Column("col9"); Assert.Equal(5, col9.Length); Assert.True(col9 is DenseUnionArray); + + MapArray col10 = (MapArray)recordBatch.Column("col10"); + Assert.Equal(5, col10.Length); + Assert.Equal(new int[] { 0, 0, 1, 2, 4, 10}, col10.ValueOffsets.ToArray()); + Assert.Equal(new long?[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, ((Int64Array)col10.Values).ToList().ToArray()); } [SkippableFact] diff --git a/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs b/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs index d235524d9110c..9c7e5b587cb9d 100644 --- a/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs +++ b/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs @@ -46,6 +46,25 @@ public void HasExpectedResultOrThrows(decimal d, int precision , int scale, bool Assert.Equal(d, result.GetValue(0)); } } + + [Theory] + [InlineData(4.56, 38, 9, false)] + [InlineData(7.89, 76, 38, true)] + public void Decimal256HasExpectedResultOrThrows(decimal d, int precision, int scale, bool shouldThrow) + { + var builder = new Decimal256Array.Builder(new Decimal256Type(precision, scale)); + builder.Append(d); + Decimal256Array result = builder.Build(new TestMemoryAllocator()); ; + + if (shouldThrow) + { + Assert.Throws(() => result.GetValue(0)); + } + else + { + Assert.Equal(d, result.GetValue(0)); + } + } } } } diff --git a/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs b/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs new file mode 100644 index 0000000000000..034f120f3f016 --- /dev/null +++ b/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs @@ -0,0 +1,92 @@ +// Licensed to the Apache Software Foundation (ASF) under one or more +// contributor license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright ownership. +// The ASF licenses this file to You under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +using System; +using System.Collections.Generic; +using System.Linq; +using Apache.Arrow.Types; +using Xunit; + +namespace Apache.Arrow.Tests +{ + public class MapArrayTests + { + [Fact] + public void MapArray_Should_GetTuple() + { + MapType type = new MapType(StringType.Default, Int64Type.Default); + MapArray.Builder builder = new MapArray.Builder(type); + var keyBuilder = builder.KeyBuilder as StringArray.Builder; + var valueBuilder = builder.ValueBuilder as Int64Array.Builder; + + Tuple kv0 = Tuple.Create("test", (long?)1); + Tuple kv1 = Tuple.Create("other", (long?)123); + Tuple kv2 = Tuple.Create("kv", (long?)null); + + builder.Append(); + keyBuilder.Append("test"); + valueBuilder.Append(1); + + builder.AppendNull(); + + builder.Append(); + keyBuilder.Append("other"); + valueBuilder.Append(123); + keyBuilder.Append("kv"); + valueBuilder.AppendNull(); + + MapArray array = builder.Build(); + + Assert.Equal(new Tuple[] { kv0 }, array.GetTuples(0, GetKey, GetValue).ToArray()); + Assert.True(array.IsNull(1)); + Assert.Equal(new Tuple[] { kv1, kv2 }, array.GetTuples(2, GetKey, GetValue).ToArray()); + } + + [Fact] + public void MapArray_Should_GetKeyValuePairs() + { + MapType type = new MapType(StringType.Default, Int32Type.Default); + MapArray.Builder builder = new MapArray.Builder(type); + var keyBuilder = builder.KeyBuilder as StringArray.Builder; + var valueBuilder = builder.ValueBuilder as Int32Array.Builder; + + KeyValuePair kv0 = KeyValuePair.Create("test", (int?)1); + KeyValuePair kv1 = KeyValuePair.Create("other", (int?)123); + KeyValuePair kv2 = KeyValuePair.Create("kv", (int?)null); + + builder.Append(); + keyBuilder.Append("test"); + valueBuilder.Append(1); + + builder.AppendNull(); + + builder.Append(); + keyBuilder.Append("other"); + valueBuilder.Append(123); + keyBuilder.Append("kv"); + valueBuilder.AppendNull(); + + MapArray array = builder.Build(); + + Assert.Equal(new KeyValuePair[] { kv0 }, array.GetKeyValuePairs(0, GetKey, GetValue).ToArray()); + Assert.True(array.IsNull(1)); + Assert.Equal(new KeyValuePair[] { kv1, kv2 }, array.GetKeyValuePairs(2, GetKey, GetValue).ToArray()); + } + + private static string GetKey(StringArray array, int index) => array.GetString(index); + private static int? GetValue(Int32Array array, int index) => array.GetValue(index); + private static long? GetValue(Int64Array array, int index) => array.GetValue(index); + } +} diff --git a/csharp/test/Apache.Arrow.Tests/TableTests.cs b/csharp/test/Apache.Arrow.Tests/TableTests.cs index 8b07a38c1b8c0..234dd63a79cd2 100644 --- a/csharp/test/Apache.Arrow.Tests/TableTests.cs +++ b/csharp/test/Apache.Arrow.Tests/TableTests.cs @@ -60,7 +60,7 @@ public void TestTableFromRecordBatches() Table table1 = Table.TableFromRecordBatches(recordBatch1.Schema, recordBatches); Assert.Equal(20, table1.RowCount); - Assert.Equal(26, table1.ColumnCount); + Assert.Equal(27, table1.ColumnCount); FixedSizeBinaryType type = new FixedSizeBinaryType(17); Field newField1 = new Field(type.Name, type, false); diff --git a/csharp/test/Apache.Arrow.Tests/TestData.cs b/csharp/test/Apache.Arrow.Tests/TestData.cs index 9e2061e3428a9..e3a40dbdafd61 100644 --- a/csharp/test/Apache.Arrow.Tests/TestData.cs +++ b/csharp/test/Apache.Arrow.Tests/TestData.cs @@ -54,6 +54,7 @@ public static RecordBatch CreateSampleRecordBatch(int length, int columnSetCount builder.Field(CreateField(new StructType(new List { CreateField(StringType.Default, i), CreateField(Int32Type.Default, i) }), i)); builder.Field(CreateField(new Decimal128Type(10, 6), i)); builder.Field(CreateField(new Decimal256Type(16, 8), i)); + builder.Field(CreateField(new MapType(StringType.Default, Int32Type.Default), i)); if (createAdvancedTypeArrays) { @@ -132,6 +133,7 @@ private class ArrayCreator : IArrowTypeVisitor, IArrowTypeVisitor, IArrowTypeVisitor, + IArrowTypeVisitor, IArrowTypeVisitor { private int Length { get; } @@ -261,7 +263,6 @@ public void Visit(ListType type) { var builder = new ListArray.Builder(type.ValueField).Reserve(Length); - //Todo : Support various types var valueBuilder = (Int64Array.Builder)builder.ValueBuilder.Reserve(Length + 1); for (var i = 0; i < Length; i++) @@ -279,7 +280,6 @@ public void Visit(FixedSizeListType type) { var builder = new FixedSizeListArray.Builder(type.ValueField, type.ListSize).Reserve(Length); - //Todo : Support various types var valueBuilder = (Int32Array.Builder)builder.ValueBuilder; for (var i = 0; i < Length; i++) @@ -410,6 +410,25 @@ public void Visit(FixedSizeBinaryType type) Array = new FixedSizeBinaryArray(arrayData); } + public void Visit(MapType type) + { + MapArray.Builder builder = new MapArray.Builder(type).Reserve(Length); + var keyBuilder = builder.KeyBuilder.Reserve(Length + 1) as StringArray.Builder; + var valueBuilder = builder.ValueBuilder.Reserve(Length + 1) as Int32Array.Builder; + + for (var i = 0; i < Length; i++) + { + builder.Append(); + keyBuilder.Append(i.ToString()); + valueBuilder.Append(i); + } + //Add a value to check if Values.Length can exceed MapArray.Length + keyBuilder.Append("0"); + valueBuilder.Append(0); + + Array = builder.Build(); + } + public void Visit(NullType type) { Array = new NullArray(Length); diff --git a/csharp/test/Apache.Arrow.Tests/Types/MapTypeTests.cs b/csharp/test/Apache.Arrow.Tests/Types/MapTypeTests.cs new file mode 100644 index 0000000000000..ba306ec104e79 --- /dev/null +++ b/csharp/test/Apache.Arrow.Tests/Types/MapTypeTests.cs @@ -0,0 +1,57 @@ +// Licensed to the Apache Software Foundation (ASF) under one or more +// contributor license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright ownership. +// The ASF licenses this file to You under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +using Apache.Arrow.Types; +using Xunit; + +namespace Apache.Arrow.Tests.Types +{ + public class MapTypeTests + { + [Fact] + public void MapType_Should_HaveCorrectTypeId() + { + var type = new MapType(StringType.Default, Int32Type.Default); + Assert.Equal(ArrowTypeId.Map, type.TypeId); + } + + [Fact] + public void MapType_Should_HaveCorrectStructType() + { + var type = new MapType(BooleanType.Default, Int32Type.Default, true); + Assert.IsType(type.Fields[0].DataType); + Assert.Equal(2, type.KeyValueType.Fields.Count); + + Assert.Equal("entries", type.Fields[0].Name); + Assert.Equal("key", type.KeyField.Name); + Assert.Equal("value", type.ValueField.Name); + + Assert.False(type.Fields[0].IsNullable); + Assert.False(type.KeyField.IsNullable); + Assert.True(type.ValueField.IsNullable); + Assert.False(new MapType(BooleanType.Default, Int32Type.Default, false).ValueField.IsNullable); + + Assert.IsType(type.KeyField.DataType); + Assert.IsType(type.ValueField.DataType); + } + + [Fact] + public void MapType_Should_SetKeySorted() + { + Assert.False(new MapType(BooleanType.Default, Int32Type.Default).KeySorted); + Assert.True(new MapType(StringType.Default, Int32Type.Default, true, true).KeySorted); + } + } +} diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py index 8d0cc6b0b01a8..01672fbe7488a 100644 --- a/dev/archery/archery/integration/datagen.py +++ b/dev/archery/archery/integration/datagen.py @@ -1815,8 +1815,7 @@ def _temp_path(): .skip_tester('C#') .skip_tester('JS'), - generate_map_case() - .skip_tester('C#'), + generate_map_case(), generate_non_canonical_map_case() .skip_tester('C#') diff --git a/dev/release/01-prepare-test.rb b/dev/release/01-prepare-test.rb index 54437e9da60ce..8fb23f45f0f3a 100644 --- a/dev/release/01-prepare-test.rb +++ b/dev/release/01-prepare-test.rb @@ -150,13 +150,6 @@ def test_version_pre_tag "+ url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@release_version}/apache-arrow-#{@release_version}.tar.gz\""], ], }, - { - path: "dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb", - hunks: [ - ["- url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@previous_version}.9000/apache-arrow-#{@previous_version}.9000.tar.gz\"", - "+ url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@release_version}/apache-arrow-#{@release_version}.tar.gz\""], - ], - }, ] unless release_type == :patch expected_changes += [ diff --git a/dev/release/post-11-bump-versions-test.rb b/dev/release/post-11-bump-versions-test.rb index 8253472ccc5b9..a017d2d70a167 100644 --- a/dev/release/post-11-bump-versions-test.rb +++ b/dev/release/post-11-bump-versions-test.rb @@ -128,13 +128,6 @@ def test_version_post_tag "+ url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@next_snapshot_version}/apache-arrow-#{@next_snapshot_version}.tar.gz\""], ], }, - { - path: "dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb", - hunks: [ - ["- url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@previous_version}.9000/apache-arrow-#{@previous_version}.9000.tar.gz\"", - "+ url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@release_version}.9000/apache-arrow-#{@release_version}.9000.tar.gz\""], - ], - }, ] unless release_type == :patch expected_changes += [ diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt index aebe321d613ab..af084ea215621 100644 --- a/dev/release/rat_exclude_files.txt +++ b/dev/release/rat_exclude_files.txt @@ -24,6 +24,7 @@ cpp/build-support/iwyu/* cpp/cmake_modules/FindPythonLibsNew.cmake cpp/cmake_modules/SnappyCMakeLists.txt cpp/cmake_modules/SnappyConfig.h +cpp/cmake_modules/snappy.diff cpp/examples/parquet/parquet-arrow/cmake_modules/FindArrow.cmake cpp/src/parquet/.parquetcppversion cpp/src/generated/parquet_constants.cpp diff --git a/dev/release/utils-prepare.sh b/dev/release/utils-prepare.sh index 464702b811d8b..23c89ad54eb01 100644 --- a/dev/release/utils-prepare.sh +++ b/dev/release/utils-prepare.sh @@ -80,11 +80,6 @@ update_versions() { popd pushd "${ARROW_DIR}/dev/tasks/homebrew-formulae" - sed -i.bak -E -e \ - "s/arrow-[0-9.]+[0-9]+/arrow-${r_version}/g" \ - autobrew/apache-arrow.rb - rm -f autobrew/apache-arrow.rb.bak - git add autobrew/apache-arrow.rb sed -i.bak -E -e \ "s/arrow-[0-9.\-]+[0-9SNAPHOT]+/arrow-${version}/g" \ apache-arrow-glib.rb \ diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh index ae28ebe792404..21a3b84a875f4 100755 --- a/dev/release/verify-release-candidate.sh +++ b/dev/release/verify-release-candidate.sh @@ -666,7 +666,7 @@ test_python() { show_header "Build and test Python libraries" # Build and test Python - maybe_setup_virtualenv "cython<3" numpy "setuptools_scm<8.0.0" setuptools || exit 1 + maybe_setup_virtualenv "cython>=0.29.31" numpy "setuptools_scm<8.0.0" setuptools || exit 1 maybe_setup_conda --file ci/conda_env_python.txt || exit 1 if [ "${USE_CONDA}" -gt 0 ]; then diff --git a/dev/tasks/conda-recipes/r-arrow/build.sh b/dev/tasks/conda-recipes/r-arrow/build.sh index 340b2196a2c8f..9f5255cbaeee3 100755 --- a/dev/tasks/conda-recipes/r-arrow/build.sh +++ b/dev/tasks/conda-recipes/r-arrow/build.sh @@ -1,8 +1,6 @@ #!/bin/bash set -ex -export DISABLE_AUTOBREW=1 - # arrow uses C++17 export ARROW_R_CXXFLAGS="${ARROW_R_CXXFLAGS} -std=c++17" export LIBARROW_BUILD=false diff --git a/dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb b/dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb deleted file mode 100644 index 4586649d0c0bc..0000000000000 --- a/dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb +++ /dev/null @@ -1,99 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# Cloned from https://github.com/autobrew/homebrew-core/blob/high-sierra/Formula/apache-arrow.rb -# Upstream any relevant changes (dependencies, build args ...) - -class ApacheArrowStatic < Formula - desc "Columnar in-memory analytics layer designed to accelerate big data" - homepage "https://arrow.apache.org/" - url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-8.0.0.9000/apache-arrow-8.0.0.9000.tar.gz" - # Uncomment and update to test on a release candidate - # mirror "https://dist.apache.org/repos/dist/dev/arrow/apache-arrow-8.0.0-rc1/apache-arrow-8.0.0.tar.gz" - sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28" - head "https://github.com/apache/arrow.git", branch: "main" - - bottle do - sha256 cellar: :any, arm64_big_sur: "ef89d21a110b89840cc6148add685d407e75bd633bc8f79625eb33d00e3694b4" - sha256 cellar: :any, big_sur: "6fcb9f55d44eb61d295a8020e039a0622bdc044b220cfffef855f3e3ab8057a1" - sha256 cellar: :any, catalina: "bf71b17766688077fb9b4e679f309742c16524015287dd3633758c679752c977" - end - - depends_on "boost" => :build - depends_on "cmake" => :build - depends_on "aws-sdk-cpp-static" - depends_on "brotli" - depends_on "lz4" - depends_on "snappy" - depends_on "thrift" - depends_on "zstd" - - conflicts_with "apache-arrow", because: "both install Arrow" - - def install - ENV.cxx11 - # https://github.com/Homebrew/homebrew-core/issues/94724 - # https://issues.apache.org/jira/browse/ARROW-15664 - ENV["HOMEBREW_OPTIMIZATION_LEVEL"] = "O2" - - args = %W[ - -DARROW_BUILD_SHARED=OFF - -DARROW_BUILD_UTILITIES=ON - -DARROW_ACERO=ON - -DARROW_COMPUTE=ON - -DARROW_CSV=ON - -DARROW_DATASET=ON - -DARROW_FILESYSTEM=ON - -DARROW_GCS=ON - -DARROW_JEMALLOC=ON - -DARROW_JSON=ON - -DARROW_MIMALLOC=ON - -DARROW_PARQUET=ON - -DARROW_S3=ON - -DARROW_VERBOSE_THIRDPARTY_BUILD=ON - -DARROW_WITH_BROTLI=ON - -DARROW_WITH_BZ2=ON - -DARROW_WITH_LZ4=ON - -DARROW_WITH_SNAPPY=ON - -DARROW_WITH_ZLIB=ON - -DARROW_WITH_ZSTD=ON - -DLZ4_HOME=#{Formula["lz4"].prefix} - -DPARQUET_BUILD_EXECUTABLES=ON - -DTHRIFT_HOME=#{Formula["thrift"].prefix} - ] - - mkdir "build" - cd "build" do - system "cmake", "../cpp", *std_cmake_args, *args - system "make" - system "make", "install" - end - end - - test do - (testpath/"test.cpp").write <<~EOS - #include "arrow/api.h" - int main(void) { - arrow::int64(); - return 0; - } - EOS - system ENV.cxx, "test.cpp", "-std=c++17", "-I#{include}", "-L#{lib}", \ - "-larrow", "-larrow_bundled_dependencies", "-o", "test" - system "./test" - end -end diff --git a/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb b/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb deleted file mode 100644 index 387759edf27e6..0000000000000 --- a/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb +++ /dev/null @@ -1,92 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# https://github.com/autobrew/homebrew-core/blob/-/Formula/apache-arrow.rb -class ApacheArrow < Formula - desc "Columnar in-memory analytics layer designed to accelerate big data" - homepage "https://arrow.apache.org/" - url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-13.0.0.9000/apache-arrow-13.0.0.9000.tar.gz" - sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28" - head "https://github.com/apache/arrow.git", branch: "main" - - bottle do - cellar :any - sha256 "9cd44700798638b5e3ee8774b3929f3fad815290d05572d1f39f01d6423eaad0" => :high_sierra - root_url "https://autobrew.github.io/bottles" - end - - # NOTE: if you add something here, be sure to add to PKG_LIBS in r/tools/autobrew - depends_on "boost" => :build - depends_on "cmake" => :build - depends_on "aws-sdk-cpp" - depends_on "brotli" - depends_on "lz4" - depends_on "openssl@1.1" - depends_on "snappy" - depends_on "thrift" - depends_on "zstd" - - def install - ENV.cxx11 - args = %W[ - -DARROW_BUILD_SHARED=OFF - -DARROW_BUILD_UTILITIES=ON - -DARROW_ACERO=ON - -DARROW_COMPUTE=ON - -DARROW_CSV=ON - -DARROW_CXXFLAGS="-D_LIBCPP_DISABLE_AVAILABILITY" - -DARROW_DATASET=ON - -DARROW_FILESYSTEM=ON - -DARROW_GCS=ON - -DARROW_JEMALLOC=ON - -DARROW_JSON=ON - -DARROW_MIMALLOC=ON - -DARROW_PARQUET=ON - -DARROW_S3=ON - -DARROW_VERBOSE_THIRDPARTY_BUILD=ON - -DARROW_WITH_BROTLI=ON - -DARROW_WITH_BZ2=ON - -DARROW_WITH_LZ4=ON - -DARROW_WITH_SNAPPY=ON - -DARROW_WITH_ZLIB=ON - -DARROW_WITH_ZSTD=ON - -DLZ4_HOME=#{Formula["lz4"].prefix} - -DPARQUET_BUILD_EXECUTABLES=ON - -DTHRIFT_HOME=#{Formula["thrift"].prefix} - ] - - mkdir "build" - cd "build" do - system "cmake", "../cpp", *std_cmake_args, *args - system "make" - system "make", "install" - end - end - - test do - (testpath/"test.cpp").write <<~EOS - #include "arrow/api.h" - int main(void) { - arrow::int64(); - return 0; - } - EOS - system ENV.cxx, "test.cpp", "-std=c++17", "-I#{include}", "-L#{lib}", \ - "-larrow", "-larrow_bundled_dependencies", "-o", "test" - system "./test" - end -end diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja index faf77a1168d1b..2a6cbe3e61109 100644 --- a/dev/tasks/macros.jinja +++ b/dev/tasks/macros.jinja @@ -256,22 +256,6 @@ on: done {% endmacro %} -{%- macro pin_brew_formulae(is_fork = false) -%} -{#- This macro expects the cwd to be arrow/r -#} - # Copy all *brew formulae - cp ../dev/tasks/homebrew-formulae/autobrew/apache-arrow*.rb tools/ - - # Pin the git commit in the formula to match - pushd tools - if [ "{{ is_fork }}" == "true" ]; then - sed -i.bak -E -e 's/apache\/arrow.git", branch: "main"$/{{ arrow.github_repo.split("/") | join("\/") }}.git", :revision => "'"{{ arrow.head }}"'"/' apache-arrow*.rb - else - sed -i.bak -E -e 's/arrow.git", branch: "main"$/arrow.git", :revision => "'"{{ arrow.head }}"'"/' apache-arrow*.rb - fi - rm -f apache-arrow*.rb.bak - popd -{% endmacro %} - {%- macro github_change_r_pkg_version(is_fork, version) -%} - name: Modify version shell: bash @@ -282,8 +266,6 @@ on: DESCRIPTION head DESCRIPTION rm -f DESCRIPTION.bak - - {{ pin_brew_formulae(is_fork) }} {% endmacro %} {%- macro github_test_r_src_pkg() -%} @@ -307,7 +289,8 @@ on: stopifnot(packageVersion("arrow") == {{ '"${{needs.source.outputs.pkg_version}}"' }}) {% endmacro %} -{%- macro github_setup_local_r_repo(get_nix, get_win) -%} +{%- macro github_setup_local_r_repo(get_nix, get_win, get_mac=False) -%} +# TODO: improve arg handling - name: Setup local repo shell: bash run: mkdir repo @@ -327,6 +310,17 @@ on: path: repo/libarrow/bin/linux-openssl-{{ openssl_version }} {% endfor %} {% endif %} + {% if get_mac %} + {% for openssl_version in ["1.1", "3.0"] %} + {% for arch in ["x86_64", "arm64"] %} + - name: Get macOS {{ arch }} OpenSSL {{ openssl_version }} binary + uses: actions/download-artifact@v3 + with: + name: r-lib__libarrow__bin__darwin-{{arch}}-openssl-{{ openssl_version }} + path: repo/libarrow/bin/darwin-{{ arch }}-openssl-{{ openssl_version }} + {% endfor %} + {% endfor %} + {% endif %} - name: Get src pkg uses: actions/download-artifact@v3 with: @@ -380,7 +374,7 @@ on: "AWS_SECRET_ACCESS_KEY": '${{ secrets.AWS_SECRET_ACCESS_KEY }}', "SCCACHE_BUCKET": '${{ secrets.SCCACHE_BUCKET }}', "SCCACHE_REGION": '${{ secrets.SCCACHE_REGION }}', - "SCCACHE_S3_KEY_PREFIX": sccache_key_prefix + "SCCACHE_S3_KEY_PREFIX": sccache_key_prefix } %} {% for key, value in sccache_vars.items() %} @@ -394,7 +388,7 @@ on: "AWS_SECRET_ACCESS_KEY": '$(AWS_SECRET_ACCESS_KEY)', "SCCACHE_BUCKET": '$(SCCACHE_BUCKET)', "SCCACHE_REGION": '$(SCCACHE_REGION)', - "SCCACHE_S3_KEY_PREFIX": sccache_key_prefix + "SCCACHE_S3_KEY_PREFIX": sccache_key_prefix } %} {% for key, value in sccache_vars.items() %} diff --git a/dev/tasks/r/github.macos-linux.local.yml b/dev/tasks/r/github.macos-linux.local.yml index f39471d5c5742..c65eb79f613c4 100644 --- a/dev/tasks/r/github.macos-linux.local.yml +++ b/dev/tasks/r/github.macos-linux.local.yml @@ -20,7 +20,7 @@ {{ macros.github_header() }} jobs: - autobrew: + local: name: "install from local source" runs-on: {{ "${{ matrix.os }}" }} {% if env is defined %} @@ -37,14 +37,14 @@ jobs: steps: {{ macros.github_checkout_arrow()|indent }} - - name: Configure non-autobrew dependencies (macos) + - name: Configure dependencies (macos) if: contains(matrix.os, 'macOS') run: | brew install openssl # disable sccache on macos as it timesout for unknown reasons # see GH-33721 # brew install sccache - - name: Configure non-autobrew dependencies (linux) + - name: Configure dependencies (linux) if: contains(matrix.os, 'ubuntu') run: | sudo env \ diff --git a/dev/tasks/r/github.macos.autobrew.yml b/dev/tasks/r/github.macos.autobrew.yml deleted file mode 100644 index b8e23690e2090..0000000000000 --- a/dev/tasks/r/github.macos.autobrew.yml +++ /dev/null @@ -1,88 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -{% import 'macros.jinja' as macros with context %} -{% set is_fork = macros.is_fork %} - -{{ macros.github_header() }} - -jobs: - autobrew: - name: "Autobrew {{ '${{ matrix.platform }} R ${{ matrix.r-version }}' }}" - runs-on: {{ "${{ matrix.platform }}" }} - strategy: - fail-fast: false - matrix: - platform: - - macos-11 - - macos-10.13 # self-hosted - r-version: - - "{{ macros.r_release.ver }}" - - "{{ macros.r_oldrel.ver }}" - steps: - {{ macros.github_checkout_arrow(action_v='3')|indent }} - - name: Configure autobrew script - run: | - # minio and sccache are pre-installed on the self-hosted 10.13 runner - if [ {{ '${{ matrix.platform }}' }} != macos-10.13 ]; then - # install minio for tests - brew install minio - brew install sccache - fi - cd arrow/r - {{ macros.pin_brew_formulae(is_fork)|indent }} - - uses: r-lib/actions/setup-r@v2 - if: matrix.platform != 'macos-10.13' - with: - r-version: {{ '${{ matrix.r-version }}' }} - use-public-rspm: true - - name: Setup R - if: matrix.platform == 'macos-10.13' - run: | - # rig is a system utility that allows for switching - # between pre-installed R version on the self-hosted runners - rig default {{ '${{ matrix.r-version }}' }} - rig system setup-user-lib - rig system add-pak - - uses: r-lib/actions/setup-r-dependencies@v2 - with: - working-directory: 'arrow/r' - extra-packages: | - any::rcmdcheck - any::sys - any::readr - - name: Check - env: - _R_CHECK_CRAN_INCOMING_: false - NOT_CRAN: true - ARROW_USE_PKG_CONFIG: false - ARROW_R_DEV: true - FORCE_AUTOBREW: true - {{ macros.github_set_sccache_envvars()|indent(8)}} - run: arrow/ci/scripts/r_test.sh arrow - - name: Dump install logs - run: cat arrow/r/check/arrow.Rcheck/00install.out - if: always() - - name: Dump test logs - run: cat arrow/r/check/arrow.Rcheck/tests/testthat.Rout* - if: always() - - name: Save the test output - if: always() - uses: actions/upload-artifact@v2 - with: - name: test-output - path: arrow/r/check/arrow.Rcheck/tests/testthat.Rout* diff --git a/dev/tasks/r/github.macos.brew.yml b/dev/tasks/r/github.macos.brew.yml deleted file mode 100644 index 285eefa293eaa..0000000000000 --- a/dev/tasks/r/github.macos.brew.yml +++ /dev/null @@ -1,84 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -{% import 'macros.jinja' as macros with context %} - -{{ macros.github_header() }} - -jobs: - autobrew: - name: "Homebrew + R package" - runs-on: macOS-11 - steps: - - name: Show system information - run: | - sysctl hw.optional machdep.cpu - - {{ macros.github_checkout_arrow()|indent }} - - {{ macros.configure_homebrew_arrow(formula)|indent }} - - name: Install apache-arrow - env: - {{ macros.github_set_sccache_envvars()|indent(8)}} - run: | - brew install sccache - # for testing - brew install minio - - # TODO(ARROW-16907): apache/arrow@main seems to be installed already - # so this does nothing on a branch/PR - brew install -v --HEAD {{ '$(brew --repository homebrew/core)/Formula/a/apache-arrow.rb' }} - - mkdir -p homebrew-logs - cp -a ~/Library/Logs/Homebrew/apache-arrow homebrew-logs/ - - name: Save logs - if: always() - uses: actions/upload-artifact@v2 - with: - name: homebrew-logs - path: homebrew-logs - - - uses: r-lib/actions/setup-r@v2 - - name: Install dependencies - run: | - install.packages("remotes") - remotes::install_deps("arrow/r", dependencies = TRUE) - remotes::install_cran(c("rcmdcheck", "sys", "sessioninfo")) - shell: Rscript {0} - - name: Session info - run: | - options(width = 100) - pkgs <- installed.packages()[, "Package"] - sessioninfo::session_info(pkgs, include_base = TRUE) - shell: Rscript {0} - - name: Check - env: - _R_CHECK_CRAN_INCOMING_: false - ARROW_R_VERBOSE_TEST: true - run: arrow/ci/scripts/r_test.sh arrow - - name: Dump install logs - run: cat arrow/r/check/arrow.Rcheck/00install.out - if: always() - - name: Dump test logs - run: cat arrow/r/check/arrow.Rcheck/tests/testthat.Rout* - if: always() - - name: Save the test output - if: always() - uses: actions/upload-artifact@v2 - with: - name: test-output - path: arrow/r/check/arrow.Rcheck/tests/testthat.Rout* diff --git a/dev/tasks/r/github.packages.yml b/dev/tasks/r/github.packages.yml index dbe21ffb6b160..760e3b6da448d 100644 --- a/dev/tasks/r/github.packages.yml +++ b/dev/tasks/r/github.packages.yml @@ -56,6 +56,59 @@ jobs: name: r-pkg__src__contrib path: arrow/r/arrow_*.tar.gz + macos-cpp: + name: C++ Binary macOS OpenSSL {{ '${{ matrix.openssl }}' }} {{ '${{ matrix.platform.arch }}' }} + + runs-on: {{ '${{ matrix.platform.runs_on }}' }} + + needs: source + strategy: + fail-fast: false + matrix: + platform: + - { runs_on: ["self-hosted", "macos-10.13"], arch: "x86_64" } + + - { runs_on: ["self-hosted", "macOS", "arm64", "devops-managed"], arch: "arm64" } + openssl: ['3.0', '1.1'] + + steps: + {{ macros.github_checkout_arrow(action_v="3")|indent }} + {{ macros.github_change_r_pkg_version(is_fork, '${{ needs.source.outputs.pkg_version }}')|indent }} + - name: Install Deps + if: {{ "${{ !contains(matrix.platform.runs_on, 'macos-10.13') }}" }} + run: | + brew install sccache ninja + brew install openssl@{{ '${{ matrix.openssl }}' }} + - name: Build libarrow + shell: bash + env: + {{ macros.github_set_sccache_envvars()|indent(8) }} + MACOSX_DEPLOYMENT_TARGET: "10.13" + ARROW_S3: ON + ARROW_GCS: ON + ARROW_DEPENDENCY_SOURCE: BUNDLED + CMAKE_GENERATOR: Ninja + LIBARROW_MINIMAL: false + run: | + sccache --start-server + export EXTRA_CMAKE_FLAGS="-DOPENSSL_ROOT_DIR=$(brew --prefix openssl@{{ '${{ matrix.openssl }}' }})" + cd arrow + r/inst/build_arrow_static.sh + - name: Bundle libarrow + shell: bash + env: + PKG_FILE: arrow-{{ '${{ needs.source.outputs.pkg_version }}' }}.zip + VERSION: {{ '${{ needs.source.outputs.pkg_version }}' }} + run: | + cd arrow/r/libarrow/dist + zip -r $PKG_FILE lib/ include/ + + - name: Upload binary artifact + uses: actions/upload-artifact@v3 + with: + name: r-lib__libarrow__bin__darwin-{{ '${{ matrix.platform.arch }}' }}-openssl-{{ '${{ matrix.openssl }}' }} + path: arrow/r/libarrow/dist/arrow-*.zip + linux-cpp: name: C++ Binary Linux OpenSSL {{ '${{ matrix.openssl }}' }} runs-on: ubuntu-latest @@ -135,7 +188,7 @@ jobs: path: build/arrow-*.zip r-packages: - needs: [source, windows-cpp] + needs: [source, windows-cpp, macos-cpp] name: {{ '${{ matrix.platform.name }} ${{ matrix.r_version.r }}' }} runs-on: {{ '${{ matrix.platform.runs_on }}' }} strategy: @@ -167,7 +220,7 @@ jobs: rig system setup-user-lib rig system add-pak - {{ macros.github_setup_local_r_repo(false, true)|indent }} + {{ macros.github_setup_local_r_repo(false, true, true)|indent }} - name: Prepare Dependency Installation shell: bash @@ -178,18 +231,19 @@ jobs: with: working-directory: 'arrow' extra-packages: cpp11 - - name: Install sccache - if: startsWith(matrix.platform, 'macos') - run: brew install sccache + - name: Set CRAN like openssl + if: contains(matrix.platform.runs_on, 'arm64') + run: | + # The arm64 runners contain openssl 1.1.1t in this path that is always included first so we need to override the + # default setting of the brew --prefix as root dir to avoid version conflicts. + echo "OPENSSL_ROOT_DIR=/opt/R/arm64" >> $GITHUB_ENV - name: Build Binary id: build shell: Rscript {0} env: - NOT_CRAN: "true" # actions/setup-r sets this implicitly + NOT_CRAN: "false" # actions/setup-r sets this implicitly ARROW_R_DEV: "true" - FORCE_AUTOBREW: "true" # this is ignored on windows - # sccache for macos - {{ macros.github_set_sccache_envvars()|indent(8) }} + LIBARROW_BINARY: "true" # has to be set as long as allowlist not updated run: | on_windows <- tolower(Sys.info()[["sysname"]]) == "windows" @@ -213,8 +267,10 @@ jobs: INSTALL_opts = INSTALL_opts ) + # Test library(arrow) + arrow_info() read_parquet(system.file("v0.7.1.parquet", package = "arrow")) # encode contrib.url for artifact name @@ -233,7 +289,6 @@ jobs: with: name: r-pkg{{ '${{ steps.build.outputs.path }}' }} path: arrow_* - test-linux-binary: needs: [source, linux-cpp] name: Test binary {{ '${{ matrix.config.image }}' }} @@ -291,7 +346,10 @@ jobs: with: name: r-pkg_centos7 path: arrow_* + test-centos-binary: + # arrow binary package not on ppm currently see #37922 + if: false needs: test-linux-binary runs-on: ubuntu-latest container: "rstudio/r-base:4.2-centos7" @@ -317,7 +375,8 @@ jobs: read_parquet(system.file("v0.7.1.parquet", package = "arrow")) print(arrow_info()) - test-source: + #TODO test macos source build? + test-linux-source: needs: source name: Test linux source build runs-on: ubuntu-latest @@ -367,7 +426,7 @@ jobs: upload-binaries: # Only upload binaries if all tests pass. - needs: [r-packages, test-source, test-linux-binary, test-centos-binary] + needs: [r-packages, test-linux-source, test-linux-binary] name: Upload artifacts runs-on: ubuntu-latest steps: diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml index 859ff8ddb5b44..e32e61bfbce46 100644 --- a/dev/tasks/tasks.yml +++ b/dev/tasks/tasks.yml @@ -82,8 +82,6 @@ groups: r: - test*-r-* - - homebrew-r-autobrew - - homebrew-r-brew # r-conda tasks - conda-linux-x64-cpu-r* - conda-linux-aarch64-cpu-r* @@ -149,10 +147,7 @@ groups: - conan-* - conda-* - java-jars - # List the homebrews explicitly because we don't care about running homebrew-cpp-autobrew - homebrew-cpp - - homebrew-r-autobrew - - homebrew-r-brew - nuget - test-* - example-* @@ -172,10 +167,7 @@ groups: - conda-* - conan-* - java-jars - # List the homebrews explicitly because we don't care about running homebrew-cpp-autobrew - homebrew-cpp - - homebrew-r-autobrew - - homebrew-r-brew - nuget - wheel-* - python-sdist @@ -779,24 +771,6 @@ tasks: params: formula: apache-arrow.rb - homebrew-cpp-autobrew: - ci: github - template: homebrew-formulae/github.macos.yml - params: - formula: autobrew/apache-arrow.rb - - homebrew-r-autobrew: - # This tests that the autobrew formula + script work in practice - ci: github - template: r/github.macos.autobrew.yml - - homebrew-r-brew: - # This tests that the autobrew formula + script work in practice - ci: github - template: r/github.macos.brew.yml - params: - formula: apache-arrow.rb - ############################## Arrow JAR's ################################## java-jars: @@ -994,6 +968,10 @@ tasks: - r-lib__libarrow__bin__linux-openssl-1.0__arrow-{no_rc_r_version}\.zip - r-lib__libarrow__bin__linux-openssl-1.1__arrow-{no_rc_r_version}\.zip - r-lib__libarrow__bin__linux-openssl-3.0__arrow-{no_rc_r_version}\.zip + - r-lib__libarrow__bin__darwin-arm64-openssl-1.1__arrow-{no_rc_r_version}\.zip + - r-lib__libarrow__bin__darwin-arm64-openssl-3.0__arrow-{no_rc_r_version}\.zip + - r-lib__libarrow__bin__darwin-x86_64-openssl-1.1__arrow-{no_rc_r_version}\.zip + - r-lib__libarrow__bin__darwin-x86_64-openssl-3.0__arrow-{no_rc_r_version}\.zip - r-pkg__bin__windows__contrib__4.1__arrow_{no_rc_r_version}\.zip - r-pkg__bin__windows__contrib__4.2__arrow_{no_rc_r_version}\.zip - r-pkg__bin__macosx__contrib__4.1__arrow_{no_rc_r_version}\.tgz @@ -1607,9 +1585,9 @@ tasks: image: conda-python-hdfs {% endfor %} -{% for python_version, spark_version, test_pyarrow_only, numpy_version in [("3.8", "v3.4.1", "false", "latest"), - ("3.10", "v3.4.1", "false", "1.23"), - ("3.11", "master", "false", "latest")] %} +{% for python_version, spark_version, test_pyarrow_only, numpy_version, jdk_version in [("3.8", "v3.5.0", "false", "latest", "8"), + ("3.10", "v3.5.0", "false", "1.23", "8"), + ("3.11", "master", "false", "latest", "17")] %} test-conda-python-{{ python_version }}-spark-{{ spark_version }}: ci: github template: docker-tests/github.linux.yml @@ -1619,6 +1597,7 @@ tasks: SPARK: "{{ spark_version }}" TEST_PYARROW_ONLY: "{{ test_pyarrow_only }}" NUMPY: "{{ numpy_version }}" + JDK: "{{ jdk_version }}" # use the branch-3.0 of spark, so prevent reusing any layers flags: --no-leaf-cache image: conda-python-spark diff --git a/docs/source/developers/java/development.rst b/docs/source/developers/java/development.rst index ce7e1704f641c..f7b19d73da2e2 100644 --- a/docs/source/developers/java/development.rst +++ b/docs/source/developers/java/development.rst @@ -23,6 +23,20 @@ Development Guidelines .. contents:: +Logger Abstraction +================== + +Apache Arrow Java uses the SLF4J API, so please configure SLF4J to see logs (e.g. via Logback/Apache Log4j): + +1. If no jar dependencies are added by the user via Logback or Apache Log4j then SLF4J will default + to no-operation (NOP) logging. + +2. If a user adds any dependencies via Logback or Apache Log4j but does not configure/add/define + logback.xml/log4j2.xml, then logs will default to DEBUG mode. + +3. To disable debug logs, the user must define their own rules within their logback.xml/log4j2.xml + and define their own loggers. + Unit Testing ============ Unit tests are run by Maven during the build. diff --git a/docs/source/developers/python.rst b/docs/source/developers/python.rst index 23bbb835a3044..e4699a65e211e 100644 --- a/docs/source/developers/python.rst +++ b/docs/source/developers/python.rst @@ -717,6 +717,9 @@ Install the development version of PyArrow from `arrow-nightlies conda install -c arrow-nightlies pyarrow +Note that this requires to use the ``conda-forge`` channel for all other +packages (``conda config --add channels conda-forge``). + Install the development version from an `alternative PyPI `_ index: diff --git a/docs/source/format/Columnar.rst b/docs/source/format/Columnar.rst index afbe2a08ee28c..3f8cd946292ea 100644 --- a/docs/source/format/Columnar.rst +++ b/docs/source/format/Columnar.rst @@ -108,7 +108,7 @@ the different physical layouts defined by Arrow: * **Variable-size Binary**: a sequence of values each having a variable byte length. Two variants of this layout are supported using 32-bit and 64-bit length encoding. -* **Views of Variable-size Binary**: a sequence of values each having a +* **View of Variable-size Binary**: a sequence of values each having a variable byte length. In contrast to Variable-size Binary, the values of this layout are distributed across potentially multiple buffers instead of densely and sequentially packed in a single buffer. @@ -118,6 +118,11 @@ the different physical layouts defined by Arrow: variable-length sequence of values taken from a child data type. Two variants of this layout are supported using 32-bit and 64-bit length encoding. +* **View of Variable-size List**: a nested layout where each value is a + variable-length sequence of values taken from a child data type. This + layout differs from **Variable-size List** by having an additional + buffer containing the sizes of each list value. This removes a constraint + on the offsets buffer — it does not need to be in order. * **Struct**: a nested layout consisting of a collection of named child **fields** each having the same length but possibly different types. @@ -382,7 +387,7 @@ In both the long and short string cases, the first four bytes encode the length of the string and can be used to determine how the rest of the view should be interpreted. -In the short string case the string's bytes are inlined- stored inside the +In the short string case the string's bytes are inlined — stored inside the view itself, in the twelve bytes which follow the length. In the long string case, a buffer index indicates which data buffer @@ -405,7 +410,14 @@ Variable-size List Layout ------------------------- List is a nested type which is semantically similar to variable-size -binary. It is defined by two buffers, a validity bitmap and an offsets +binary. There are two list layout variations — "list" and "list-view" — +and each variation can be delimited by either 32-bit or 64-bit offsets +integers. + +List Layout +~~~~~~~~~~~ + +The List layout is defined by two buffers, a validity bitmap and an offsets buffer, and a child array. The offsets are the same as in the variable-size binary case, and both 32-bit and 64-bit signed integer offsets are supported options for the offsets. Rather than referencing @@ -441,7 +453,7 @@ will have the following representation: :: |------------|-------------|-------------|-------------|-------------|-----------------------| | 0 | 3 | 3 | 7 | 7 | unspecified (padding) | - * Values array (Int8array): + * Values array (Int8Array): * Length: 7, Null count: 0 * Validity bitmap buffer: Not required * Values buffer (int8) @@ -487,6 +499,103 @@ will be represented as follows: :: |-------------------------------|-----------------------| | 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 | unspecified (padding) | +ListView Layout +~~~~~~~~~~~~~~~ + +The ListView layout is defined by three buffers: a validity bitmap, an offsets +buffer, and an additional sizes buffer. Sizes and offsets have the identical bit +width and both 32-bit and 64-bit signed integer options are supported. + +As in the List layout, the offsets encode the start position of each slot in the +child array. In contrast to the List layout, list lengths are stored explicitly +in the sizes buffer instead of inferred. This allows offsets to be out of order. +Elements of the child array do not have to be stored in the same order they +logically appear in the list elements of the parent array. + +Every list-view value, including null values, has to guarantee the following +invariants: :: + + 0 <= offsets[i] <= length of the child array + 0 <= offsets[i] + size[i] <= length of the child array + +A list-view type is specified like ``ListView``, where ``T`` is any type +(primitive or nested). In these examples we use 32-bit offsets and sizes where +the 64-bit version would be denoted by ``LargeListView``. + +**Example Layout: ``ListView`` Array** + +We illustrate an example of ``ListView`` with length 4 having values:: + + [[12, -7, 25], null, [0, -127, 127, 50], []] + +It may have the following representation: :: + + * Length: 4, Null count: 1 + * Validity bitmap buffer: + + | Byte 0 (validity bitmap) | Bytes 1-63 | + |--------------------------|-----------------------| + | 00001101 | 0 (padding) | + + * Offsets buffer (int32) + + | Bytes 0-3 | Bytes 4-7 | Bytes 8-11 | Bytes 12-15 | Bytes 16-63 | + |------------|-------------|-------------|-------------|-----------------------| + | 0 | 7 | 3 | 0 | unspecified (padding) | + + * Sizes buffer (int32) + + | Bytes 0-3 | Bytes 4-7 | Bytes 8-11 | Bytes 12-15 | Bytes 16-63 | + |------------|-------------|-------------|-------------|-----------------------| + | 3 | 0 | 4 | 0 | unspecified (padding) | + + * Values array (Int8Array): + * Length: 7, Null count: 0 + * Validity bitmap buffer: Not required + * Values buffer (int8) + + | Bytes 0-6 | Bytes 7-63 | + |------------------------------|-----------------------| + | 12, -7, 25, 0, -127, 127, 50 | unspecified (padding) | + +**Example Layout: ``ListView`` Array** + +We continue with the ``ListView`` type, but this instance illustrates out +of order offsets and sharing of child array values. It is an array with length 5 +having logical values:: + + [[12, -7, 25], null, [0, -127, 127, 50], [], [50, 12]] + +It may have the following representation: :: + + * Length: 4, Null count: 1 + * Validity bitmap buffer: + + | Byte 0 (validity bitmap) | Bytes 1-63 | + |--------------------------|-----------------------| + | 00011101 | 0 (padding) | + + * Offsets buffer (int32) + + | Bytes 0-3 | Bytes 4-7 | Bytes 8-11 | Bytes 12-15 | Bytes 16-19 | Bytes 20-63 | + |------------|-------------|-------------|-------------|-------------|-----------------------| + | 4 | 7 | 0 | 0 | 3 | unspecified (padding) | + + * Sizes buffer (int32) + + | Bytes 0-3 | Bytes 4-7 | Bytes 8-11 | Bytes 12-15 | Bytes 16-19 | Bytes 20-63 | + |------------|-------------|-------------|-------------|-------------|-----------------------| + | 3 | 0 | 4 | 0 | 2 | unspecified (padding) | + + * Values array (Int8Array): + * Length: 7, Null count: 0 + * Validity bitmap buffer: Not required + * Values buffer (int8) + + | Bytes 0-6 | Bytes 7-63 | + |------------------------------|-----------------------| + | 0, -127, 127, 50, 12, -7, 25 | unspecified (padding) | + Fixed-Size List Layout ---------------------- @@ -858,19 +967,19 @@ are held in the second child array. For the purposes of determining field names and schemas, these child arrays are prescribed the standard names of **run_ends** and **values** respectively. -The values in the first child array represent the accumulated length of all runs +The values in the first child array represent the accumulated length of all runs from the first to the current one, i.e. the logical index where the current run ends. This allows relatively efficient random access from a logical index using binary search. The length of an individual run can be determined by subtracting two adjacent values. (Contrast this with run-length encoding, in which the lengths of the runs are represented directly, and in which random -access is less efficient.) +access is less efficient.) .. note:: Because the ``run_ends`` child array cannot have nulls, it's reasonable to consider why the ``run_ends`` are a child array instead of just a buffer, like the offsets for a :ref:`variable-size-list-layout`. This - layout was considered, but it was decided to use the child arrays. + layout was considered, but it was decided to use the child arrays. Child arrays allow us to keep the "logical length" (the decoded length) associated with the parent array and the "physical length" (the number @@ -1122,7 +1231,7 @@ addresses between libraries, it is recommended to set ``size`` to the actual memory size rather than the padded size. Variadic buffers -^^^^^^^^^^^^^^^^ +---------------- Some types such as Utf8View are represented using a variable number of buffers. For each such Field in the pre-ordered flattened logical schema, there will be diff --git a/docs/source/python/extending_types.rst b/docs/source/python/extending_types.rst index 53ce70e13b4d1..87f04f37dc69c 100644 --- a/docs/source/python/extending_types.rst +++ b/docs/source/python/extending_types.rst @@ -419,8 +419,8 @@ Extension arrays can be used as columns in ``pyarrow.Table`` or f0: int8 f1: string f2: bool - tensors_int: extension - tensors_float: extension + tensors_int: extension + tensors_float: extension ---- f0: [[1,2,3]] f1: [["foo","bar",null]] diff --git a/docs/source/python/install.rst b/docs/source/python/install.rst index ef4353415fa21..99d1c43b024aa 100644 --- a/docs/source/python/install.rst +++ b/docs/source/python/install.rst @@ -56,8 +56,8 @@ need to install the `Visual C++ Redistributable for Visual Studio 2015 .. warning:: On Linux, you will need pip >= 19.0 to detect the prebuilt binary packages. -Installing from source ----------------------- +Installing nightly packages or from source +------------------------------------------ See :ref:`python-development`. diff --git a/docs/source/status.rst b/docs/source/status.rst index e2b3852e2229f..6024c1d3172bb 100644 --- a/docs/source/status.rst +++ b/docs/source/status.rst @@ -81,7 +81,7 @@ Data Types +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+ | Struct | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+ -| Map | ✓ | ✓ | ✓ | ✓ | | ✓ | ✓ | | +| Map | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+ | Dense Union | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+ diff --git a/format/Schema.fbs b/format/Schema.fbs index fdaf623931760..70d9634463d61 100644 --- a/format/Schema.fbs +++ b/format/Schema.fbs @@ -22,7 +22,8 @@ /// Version 1.1 - Add Decimal256. /// Version 1.2 - Add Interval MONTH_DAY_NANO. /// Version 1.3 - Add Run-End Encoded. -/// Version 1.4 - Add BinaryView, Utf8View, and variadicBufferCounts. +/// Version 1.4 - Add BinaryView, Utf8View, variadicBufferCounts, ListView, and +/// LargeListView. namespace org.apache.arrow.flatbuf; @@ -97,6 +98,17 @@ table List { table LargeList { } +/// Represents the same logical types that List can, but contains offsets and +/// sizes allowing for writes in any order and sharing of child values among +/// list values. +table ListView { +} + +/// Same as ListView, but with 64-bit offsets and sizes, allowing to represent +/// extremely large data values. +table LargeListView { +} + table FixedSizeList { /// Number of list items per value listSize: int; @@ -451,6 +463,8 @@ union Type { RunEndEncoded, BinaryView, Utf8View, + ListView, + LargeListView, } /// ---------------------------------------------------------------------- diff --git a/go/LICENSE.txt b/go/LICENSE.txt index 9ea2e1f4497fb..57310329835da 100644 --- a/go/LICENSE.txt +++ b/go/LICENSE.txt @@ -1681,17 +1681,6 @@ for PyArrow. Ibis is released under the Apache License, Version 2.0. -------------------------------------------------------------------------------- -This project includes code from the autobrew project. - -* r/tools/autobrew and dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb - are based on code from the autobrew project. - -Copyright (c) 2019, Jeroen Ooms -License: MIT -Homepage: https://github.com/jeroen/autobrew - --------------------------------------------------------------------------------- - dev/tasks/homebrew-formulae/apache-arrow.rb has the following license: BSD 2-Clause License diff --git a/go/arrow/flight/flightsql/driver/driver_test.go b/go/arrow/flight/flightsql/driver/driver_test.go index 3ec8533979a32..4449b390974a7 100644 --- a/go/arrow/flight/flightsql/driver/driver_test.go +++ b/go/arrow/flight/flightsql/driver/driver_test.go @@ -812,6 +812,17 @@ func (s *MockServer) DoPutPreparedStatementQuery(ctx context.Context, qry flight return fmt.Errorf("parameter schema: %w", arrow.ErrInvalid) } + // GH-35328: it's rare, but this function can complete execution and return + // closing the reader *after* the schema is written but *before* the parameter batch + // is written (race condition based on goroutine scheduling). In that situation, + // the client call to Write the parameter record batch will return an io.EOF because + // this end of the connection will have closed before it attempted to send the batch. + // This created a flaky test situation that was difficult to reproduce (1-4 failures + // in 5000 runs). We can avoid this flakiness by simply *explicitly* draining the + // record batch messages from the reader before returning. + for r.Next() { + } + return nil } diff --git a/go/arrow/flight/flightsql/driver/utils.go b/go/arrow/flight/flightsql/driver/utils.go index a2ed4ef26e227..99352e7251c53 100644 --- a/go/arrow/flight/flightsql/driver/utils.go +++ b/go/arrow/flight/flightsql/driver/utils.go @@ -58,46 +58,56 @@ func (g grpcCredentials) RequireTransportSecurity() bool { // *** Type conversions *** func fromArrowType(arr arrow.Array, idx int) (interface{}, error) { + if arr.IsNull(idx) { + return nil, nil + } + switch c := arr.(type) { case *array.Boolean: return c.Value(idx), nil case *array.Float16: - return float64(c.Value(idx).Float32()), nil + return c.Value(idx), nil case *array.Float32: - return float64(c.Value(idx)), nil + return c.Value(idx), nil case *array.Float64: return c.Value(idx), nil + case *array.Decimal128: + v := arr.DataType().(*arrow.Decimal128Type) + return c.Value(idx).ToFloat64(v.Scale), nil + case *array.Decimal256: + v := arr.DataType().(*arrow.Decimal256Type) + return c.Value(idx).ToFloat64(v.Scale), nil case *array.Int8: - return int64(c.Value(idx)), nil + return c.Value(idx), nil case *array.Int16: - return int64(c.Value(idx)), nil + return c.Value(idx), nil case *array.Int32: - return int64(c.Value(idx)), nil + return c.Value(idx), nil case *array.Int64: return c.Value(idx), nil + case *array.Binary: + return c.Value(idx), nil case *array.String: return c.Value(idx), nil case *array.Time32: - dt, ok := arr.DataType().(*arrow.Time32Type) - if !ok { - return nil, fmt.Errorf("datatype %T not matching time32", arr.DataType()) - } + d32 := arr.DataType().(*arrow.Time32Type) v := c.Value(idx) - return v.ToTime(dt.TimeUnit()), nil + return v.ToTime(d32.TimeUnit()), nil case *array.Time64: - dt, ok := arr.DataType().(*arrow.Time64Type) - if !ok { - return nil, fmt.Errorf("datatype %T not matching time64", arr.DataType()) - } + d64 := arr.DataType().(*arrow.Time64Type) v := c.Value(idx) - return v.ToTime(dt.TimeUnit()), nil + return v.ToTime(d64.TimeUnit()), nil case *array.Timestamp: - dt, ok := arr.DataType().(*arrow.TimestampType) - if !ok { - return nil, fmt.Errorf("datatype %T not matching timestamp", arr.DataType()) - } + ts := arr.DataType().(*arrow.TimestampType) v := c.Value(idx) - return v.ToTime(dt.TimeUnit()), nil + return v.ToTime(ts.TimeUnit()), nil + case *array.Date64: + return c.Value(idx).ToTime(), nil + case *array.DayTimeInterval: + durationDays := time.Duration(c.Value(idx).Days*24) * time.Hour + duration := time.Duration(c.Value(idx).Milliseconds) * time.Millisecond + + return durationDays + duration, nil } return nil, fmt.Errorf("type %T: %w", arr, ErrNotSupported) diff --git a/go/arrow/flight/flightsql/driver/utils_test.go b/go/arrow/flight/flightsql/driver/utils_test.go new file mode 100644 index 0000000000000..355c888f56cc4 --- /dev/null +++ b/go/arrow/flight/flightsql/driver/utils_test.go @@ -0,0 +1,126 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +package driver + +import ( + "fmt" + "math/big" + "reflect" + "testing" + "time" + + "github.com/apache/arrow/go/v14/arrow" + "github.com/apache/arrow/go/v14/arrow/array" + "github.com/apache/arrow/go/v14/arrow/decimal128" + "github.com/apache/arrow/go/v14/arrow/decimal256" + "github.com/apache/arrow/go/v14/arrow/float16" + "github.com/apache/arrow/go/v14/arrow/memory" + "github.com/stretchr/testify/require" +) + +func Test_fromArrowType(t *testing.T) { + fields := []arrow.Field{ + {Name: "f1-bool", Type: arrow.FixedWidthTypes.Boolean}, + {Name: "f2-f16", Type: arrow.FixedWidthTypes.Float16}, + {Name: "f3-f32", Type: arrow.PrimitiveTypes.Float32}, + {Name: "f4-f64", Type: arrow.PrimitiveTypes.Float64}, + {Name: "f5-d128", Type: &arrow.Decimal128Type{}}, + {Name: "f6-d256", Type: &arrow.Decimal256Type{}}, + {Name: "f7-i8", Type: arrow.PrimitiveTypes.Int8}, + {Name: "f8-i16", Type: arrow.PrimitiveTypes.Int16}, + {Name: "f9-i32", Type: arrow.PrimitiveTypes.Int32}, + {Name: "f10-i64", Type: arrow.PrimitiveTypes.Int64}, + {Name: "f11-binary", Type: arrow.BinaryTypes.Binary}, + {Name: "f12-string", Type: arrow.BinaryTypes.String}, + {Name: "f13-t32s", Type: arrow.FixedWidthTypes.Time32s}, + {Name: "f14-t64us", Type: arrow.FixedWidthTypes.Time64us}, + {Name: "f15-ts_us", Type: arrow.FixedWidthTypes.Timestamp_ns}, + {Name: "f16-d64", Type: arrow.FixedWidthTypes.Date64}, + {Name: "f17-dti", Type: arrow.FixedWidthTypes.DayTimeInterval}, + } + + schema := arrow.NewSchema(fields, nil) + pool := memory.NewGoAllocator() + b := array.NewRecordBuilder(pool, schema) + defer b.Release() + + b.Field(0).(*array.BooleanBuilder).Append(true) + b.Field(1).(*array.Float16Builder).Append(float16.New(1)) + b.Field(2).(*array.Float32Builder).Append(1) + b.Field(3).(*array.Float64Builder).Append(1) + b.Field(4).(*array.Decimal128Builder).Append(decimal128.FromBigInt(big.NewInt(1))) + b.Field(5).(*array.Decimal256Builder).Append(decimal256.FromBigInt(big.NewInt(1))) + b.Field(6).(*array.Int8Builder).Append(1) + b.Field(7).(*array.Int16Builder).Append(1) + b.Field(8).(*array.Int32Builder).Append(1) + b.Field(9).(*array.Int64Builder).Append(1) + b.Field(10).(*array.BinaryBuilder).Append([]byte("a")) + b.Field(11).(*array.StringBuilder).Append("a") + + t32, err := arrow.Time32FromString("12:30:00", arrow.Second) + require.NoError(t, err) + + b.Field(12).(*array.Time32Builder).Append(t32) + + t64, err := arrow.Time64FromString("12:00:00", arrow.Microsecond) + require.NoError(t, err) + + b.Field(13).(*array.Time64Builder).Append(t64) + + ts, err := arrow.TimestampFromString("1970-01-01T12:00:00", arrow.Nanosecond) + require.NoError(t, err) + + fmt.Println(ts.ToTime(arrow.Nanosecond)) + + b.Field(14).(*array.TimestampBuilder).Append(ts) + + testTime := time.Now() + b.Field(15).(*array.Date64Builder).Append(arrow.Date64FromTime(testTime)) + b.Field(16).(*array.DayTimeIntervalBuilder).Append(arrow.DayTimeInterval{Days: 1, Milliseconds: 1000}) + + rec := b.NewRecord() + defer rec.Release() + + tf := func(t *testing.T, idx int, want any) { + t.Run(fmt.Sprintf("fromArrowType %v %s", fields[idx].Type, fields[idx].Name), func(t *testing.T) { + v, err := fromArrowType(rec.Column(idx), 0) + if err != nil { + t.Fatalf("err when converting from arrow: %s", err) + } + if !reflect.DeepEqual(v, want) { + t.Fatalf("test failed, wanted %T %v got %T %v", want, want, v, v) + } + }) + } + + tf(t, 0, true) // "f1-bool" + tf(t, 1, float16.New(1)) // "f2-f16" + tf(t, 2, float32(1)) // "f3-f32" + tf(t, 3, float64(1)) // "f4-f64" + tf(t, 4, float64(1)) // "f5-d128" + tf(t, 5, float64(1)) // "f6-d256" + tf(t, 6, int8(1)) // "f7-i8" + tf(t, 7, int16(1)) // "f8-i16" + tf(t, 8, int32(1)) // "f9-i32" + tf(t, 9, int64(1)) // "f10-i64" + tf(t, 10, []byte("a")) // "f11-binary" + tf(t, 11, "a") // "f12-string" + tf(t, 12, time.Date(1970, 1, 1, 12, 30, 0, 0, time.UTC)) // "f13-t32s" + tf(t, 13, time.Date(1970, 1, 1, 12, 0, 0, 0, time.UTC)) // "f14-t64us" + tf(t, 14, time.Date(1970, 1, 1, 12, 0, 0, 0, time.UTC)) // "f15-ts_us" + tf(t, 15, testTime.In(time.UTC).Truncate(24*time.Hour)) // "f16-d64" + tf(t, 16, time.Duration(24*time.Hour+time.Second)) // "f17-dti" +} diff --git a/go/parquet/internal/bmi/_lib/bitmap_bmi2.c b/go/parquet/internal/bmi/_lib/bitmap_bmi2.c index cc345d5798b8c..a020294fd6a38 100644 --- a/go/parquet/internal/bmi/_lib/bitmap_bmi2.c +++ b/go/parquet/internal/bmi/_lib/bitmap_bmi2.c @@ -17,6 +17,10 @@ #include #include +#if !defined(__ARM_NEON) && !defined(__ARM_NEON__) +// don't compile this for ARM, the pure go lookup table version +// is more performant anyways since ARM doesn't have a BMI2/pext_u64 +// instruction we can call directly. uint64_t FULL_NAME(extract_bits)(uint64_t bitmap, uint64_t select_bitmap) { #if defined(__BMI2__) return (uint64_t)(_pext_u64(bitmap, select_bitmap)); @@ -32,6 +36,8 @@ uint64_t FULL_NAME(extract_bits)(uint64_t bitmap, uint64_t select_bitmap) { #endif } +#endif + uint64_t FULL_NAME(levels_to_bitmap)(const int16_t* levels, const int num_levels, const int16_t rhs) { uint64_t mask = 0; for (int x = 0; x < num_levels; x++) { diff --git a/go/parquet/internal/bmi/_lib/bitmap_neon.s b/go/parquet/internal/bmi/_lib/bitmap_neon.s index f6d4e751be63a..d1d146f55cfab 100644 --- a/go/parquet/internal/bmi/_lib/bitmap_neon.s +++ b/go/parquet/internal/bmi/_lib/bitmap_neon.s @@ -1,37 +1,5 @@ .text .file "bitmap_bmi2.c" - .globl extract_bits_neon // -- Begin function extract_bits_neon - .p2align 2 - .type extract_bits_neon,@function -extract_bits_neon: // @extract_bits_neon -// %bb.0: - stp x29, x30, [sp, #-16]! // 16-byte Folded Spill - mov x29, sp - cbz x1, .LBB0_4 -// %bb.1: - mov x8, x0 - mov x0, xzr - mov w9, #1 -.LBB0_2: // =>This Inner Loop Header: Depth=1 - and x10, x1, x8 - neg x11, x1 - tst x10, x11 - sub x12, x1, #1 // =1 - csel x10, xzr, x9, eq - ands x1, x12, x1 - orr x0, x10, x0 - lsl x9, x9, #1 - b.ne .LBB0_2 -// %bb.3: - ldp x29, x30, [sp], #16 // 16-byte Folded Reload - ret -.LBB0_4: - mov x0, xzr - ldp x29, x30, [sp], #16 // 16-byte Folded Reload - ret -.Lfunc_end0: - .size extract_bits_neon, .Lfunc_end0-extract_bits_neon - // -- End function .section .rodata.cst16,"aM",@progbits,16 .p2align 4 // -- Begin function levels_to_bitmap_neon .LCPI1_0: diff --git a/go/parquet/internal/bmi/bitmap_neon_arm64.go b/go/parquet/internal/bmi/bitmap_neon_arm64.go index b3b0b093734be..65471d35288c3 100755 --- a/go/parquet/internal/bmi/bitmap_neon_arm64.go +++ b/go/parquet/internal/bmi/bitmap_neon_arm64.go @@ -14,21 +14,13 @@ // See the License for the specific language governing permissions and // limitations under the License. +//go:build !noasm // +build !noasm package bmi import "unsafe" -//go:noescape -func _extract_bits_neon(bitmap, selectBitmap uint64) (res uint64) - -// There is no single instruction similar with 'pext' on Arm64. -// The equivalent of 'pext' was implemented with Arm64 Neon for Parallel Bits Extract -func extractBitsNEON(bitmap, selectBitmap uint64) uint64 { - return _extract_bits_neon(bitmap, selectBitmap) -} - //go:noescape func _levels_to_bitmap_neon(levels unsafe.Pointer, numLevels int, rhs int16) (res uint64) diff --git a/go/parquet/internal/bmi/bitmap_neon_arm64.s b/go/parquet/internal/bmi/bitmap_neon_arm64.s index 019aaef5d99b8..abde5843c68e2 100755 --- a/go/parquet/internal/bmi/bitmap_neon_arm64.s +++ b/go/parquet/internal/bmi/bitmap_neon_arm64.s @@ -1,36 +1,6 @@ //+build !noasm !appengine // (C2GOASM doesn't work correctly for Arm64) -// func _extract_bits_neon(bitmap, selectBitmap uint64) (res uint64) -TEXT ·_extract_bits_neon(SB), $0-24 - - MOVD bitmap+0(FP), R0 - MOVD selectBitmap+8(FP), R1 - - WORD $0xa9bf7bfd // stp x29, x30, [sp, #-16]! - WORD $0x910003fd // mov x29, sp - CBZ R1, LBB0_4 - WORD $0xaa0003e8 // mov x8, x0 - WORD $0xaa1f03e0 // mov x0, xzr - WORD $0x52800029 // mov w9, #1 -LBB0_2: - WORD $0x8a08002a // and x10, x1, x8 - WORD $0xcb0103eb // neg x11, x1 - WORD $0xea0b015f // tst x10, x11 - WORD $0xd100042c // sub x12, x1, #1 - WORD $0x9a8903ea // csel x10, xzr, x9, eq - WORD $0xea010181 // ands x1, x12, x1 - WORD $0xaa000140 // orr x0, x10, x0 - WORD $0xd37ff929 // lsl x9, x9, #1 - BNE LBB0_2 - WORD $0xa8c17bfd // ldp x29, x30, [sp], #16 - MOVD R0, res+16(FP) - RET -LBB0_4: - WORD $0xaa1f03e0 // mov x0, xzr - WORD $0xa8c17bfd // ldp x29, x30, [sp], #16 - RET - // func _levels_to_bitmap_neon(levels unsafe.Pointer, numLevels int, rhs int16) (res uint64) TEXT ·_levels_to_bitmap_neon(SB), $0-32 diff --git a/go/parquet/internal/bmi/bmi_arm64.go b/go/parquet/internal/bmi/bmi_arm64.go index a436fadf72651..4174f6d06d989 100755 --- a/go/parquet/internal/bmi/bmi_arm64.go +++ b/go/parquet/internal/bmi/bmi_arm64.go @@ -14,44 +14,51 @@ // See the License for the specific language governing permissions and // limitations under the License. +//go:build !noasm // +build !noasm package bmi import ( + "fmt" "os" "strings" -) -import ( - "golang.org/x/sys/cpu" + + "github.com/klauspost/cpuid/v2" ) func init() { - // Added ability to enable extension via environment: + // Added ability to enable extension via environment: // ARM_ENABLE_EXT=NEON go test if ext, ok := os.LookupEnv("ARM_ENABLE_EXT"); ok { - exts := strings.Split(ext, ",") - - for _, x := range exts { - switch x { - case "NEON": - cpu.ARM64.HasASIMD = true - case "AES": - cpu.ARM64.HasAES = true - case "PMULL": - cpu.ARM64.HasPMULL = true - default: - cpu.ARM64.HasASIMD = false - cpu.ARM64.HasAES = false - cpu.ARM64.HasPMULL = false + if ext == "DISABLE" { + cpuid.CPU.Disable(cpuid.ASIMD, cpuid.AESARM, cpuid.PMULL) + } else { + exts := strings.Split(ext, ",") + + for _, x := range exts { + switch x { + case "NEON": + cpuid.CPU.Enable(cpuid.ASIMD) + case "AES": + cpuid.CPU.Enable(cpuid.AESARM) + case "PMULL": + cpuid.CPU.Enable(cpuid.PMULL) + default: + fmt.Fprintln(os.Stderr, "unrecognized value for ARM_ENABLE_EXT:", x) + } } } } - if cpu.ARM64.HasASIMD { - funclist.extractBits = extractBitsNEON + + // after benchmarking, turns out the pure go lookup table version + // is nearly twice as fast as the non-lookup table assembly + // because arm doesn't have a PEXT instruction. + funclist.extractBits = extractBitsGo + + if cpuid.CPU.Has(cpuid.ASIMD) { funclist.gtbitmap = greaterThanBitmapNEON } else { - funclist.extractBits = extractBitsGo funclist.gtbitmap = greaterThanBitmapGo } } diff --git a/go/parquet/internal/bmi/bmi_test.go b/go/parquet/internal/bmi/bmi_test.go new file mode 100644 index 0000000000000..460c6ec4e24c6 --- /dev/null +++ b/go/parquet/internal/bmi/bmi_test.go @@ -0,0 +1,47 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package bmi_test + +import ( + "fmt" + "testing" + + "github.com/apache/arrow/go/v14/parquet/internal/bmi" + "github.com/stretchr/testify/assert" +) + +// Testing the issue in GH-37712 +func TestBasicExtractBits(t *testing.T) { + tests := []struct { + bitmap, selection uint64 + expected uint64 + }{ + {0, 0, 0}, + {0xFF, 0, 0}, + {0xFF, ^uint64(0), 0xFF}, + {0xFF00FF, 0xAAAA, 0x000F}, + {0xFF0AFF, 0xAFAA, 0x00AF}, + {0xFFAAFF, 0xAFAA, 0x03AF}, + {0xFECBDA9876543210, 0xF00FF00FF00FF00F, 0xFBD87430}, + } + + for _, tt := range tests { + t.Run(fmt.Sprintf("%d-%d=>%d", tt.bitmap, tt.selection, tt.expected), func(t *testing.T) { + assert.Equal(t, tt.expected, bmi.ExtractBits(tt.bitmap, tt.selection)) + }) + } +} diff --git a/go/parquet/internal/utils/Makefile b/go/parquet/internal/utils/Makefile index 58643223876ea..f6dce46197fef 100644 --- a/go/parquet/internal/utils/Makefile +++ b/go/parquet/internal/utils/Makefile @@ -32,11 +32,14 @@ C_FLAGS_NEON=-O3 -fvectorize -mllvm -force-vector-width=16 -fno-asynchronous-unw GO_SOURCES := $(shell find . -path ./_lib -prune -o -name '*.go' -not -name '*_test.go') ALL_SOURCES := $(shell find . -path ./_lib -prune -o -name '*.go' -name '*.s' -not -name '*_test.go') -.PHONEY: assembly +.PHONY: assembly INTEL_SOURCES := \ - bit_packing_avx2.s \ - unpack_bool_avx2.s unpack_bool_sse4.s + bit_packing_avx2_amd64.s \ + unpack_bool_avx2_amd64.s unpack_bool_sse4_amd64.s + +ARM_SOURCES := \ + bit_packing_neon_arm64.s unpack_bool_neon_arm64.s # # ARROW-15336: DO NOT add the assembly target for Arm64 (ARM_SOURCES) until c2goasm added the Arm64 support. @@ -58,13 +61,16 @@ _lib/unpack_bool_sse4.s: _lib/unpack_bool.c _lib/unpack_bool_neon.s: _lib/unpack_bool.c $(CC) -S $(C_FLAGS_NEON) $^ -o $@ ; $(PERL_FIXUP_ROTATE) $@ -bit_packing_avx2.s: _lib/bit_packing_avx2.s +_lib/bit_packing_neon.s: _lib/bit_packing_neon.c + $(CC) -S $(C_FLAGS_NEON) $^ -o $@ + +bit_packing_avx2_amd64.s: _lib/bit_packing_avx2.s $(C2GOASM) -a -f $^ $@ -unpack_bool_avx2.s: _lib/unpack_bool_avx2.s +unpack_bool_avx2_amd64.s: _lib/unpack_bool_avx2.s $(C2GOASM) -a -f $^ $@ -unpack_bool_sse4.s: _lib/unpack_bool_sse4.s +unpack_bool_sse4_amd64.s: _lib/unpack_bool_sse4.s $(C2GOASM) -a -f $^ $@ clean: diff --git a/go/parquet/internal/utils/_lib/README.md b/go/parquet/internal/utils/_lib/README.md new file mode 100644 index 0000000000000..10cc9a257e055 --- /dev/null +++ b/go/parquet/internal/utils/_lib/README.md @@ -0,0 +1,154 @@ + + +# SIMD Bit Packing Implementation + +Go doesn't have any SIMD intrinsics so for some low-level optimizations we can +leverage auto-vectorization by C++ compilers and the fact that Go lets you specify the body of a +function in assembly to benefit from SIMD. + +In here we have implementations using SIMD intrinsics for AVX (amd64) and NEON (arm64). + +## Generating the Go assembly + +c2goasm and asm2plan9s are two projects which can be used in conjunction to generate +compatible Go assembly from C assembly. + +First the tools need to be installed: + +```bash +go install github.com/klauspost/asmfmt/cmd/asmfmt@latest +go install github.com/minio/asm2plan9s@latest +go install github.com/minio/c2goasm@latest +``` + +### Generating for amd64 + +The Makefile in the directory above will work for amd64. `make assembly` will compile +the c sources and then call `c2goasm` to generate the Go assembly for amd64 +architectures. + +### Generating for arm64 + +Unfortunately there are some caveats for arm64. c2goasm / asm2plan9s doesn't fully +support arm64 correctly. However, proper assembly can be created with some slight +manipulation of the result. + +The Makefile has the NEON flags for compiling the assembly by using +`make _lib/bit_packing_neon.s` and `make _lib/unpack_bool_neon.s` to generate the +raw assembly sources. + +Before calling `c2goasm` there's a few things that need to be modified in the assembly: + +* x86-64 assembly uses `#` for comments while arm64 assembly uses `//` for comments. + `c2goasm` assumes `#` for comments and splits lines based on them. For most lines + this isn't an issue, but for any constants this is important and will need to have + the comment character converted from `//` to `#`. +* A `word` for x86-64 is 16 bits, a `double` word is 32 bits, and a `quad` is 64 bits. + For arm64, a `word` is 32 bits. This means that constants in the assembly need to be + modified. `c2goasm` and `asm2plan9s` expect the x86-64 meaning for the sizes, so + usage of `.word ######` needs to be converted to `.long #####` before running + `c2goasm`. In addition, `.xword` is an 8-byte value and as such should be changed to + `.quad` before running `c2goasm`. +* Because of this change in bits, `MOVQ` instructions will also be converted to + `MOVD` instructions. + +After running `c2goasm` there will still need to be modifications made to the +resulting assembly. + +* Most of the ARM instructions will be converted to using the Go assembly construction + of `WORD $0x########` to provide an instruction directly to the processor rather than + going through the Go assembler. Some of the instructions, however, aren't recognized + by `c2goasm` and will need to added. If you look at the assembly, you'll see these + as assembly that is commented out without any `WORD` instruction. For example: + ```asm + // stp x29, x30, [sp, #-48]! + WORD $0x11007c48 // add w8, w2, #31 + ``` + The `stp` instruction needs to be added. This can be done in one of two ways: + 1. Many instructions are properly handled by the Go assembler correctly. You can + find the arm-specific caveats to Go's assembly [here](https://pkg.go.dev/cmd/internal/obj/arm64). In this case, the instruction would be `STP.W (R29, R30), -48(RSP)`. + 2. Assuming that the GNU assembler is installed, you can use it to generate the + correct byte sequence. Create a file named `neon.asm` with a single line + (the instruction) and call `as -o neon.o neon.asm`. Then you can run + `objdump -S neon.o` to get the value to use. The output should look something + like: + ``` + Disassembly of section .text: + + 0000000000000000 <.text>: + 0: 11 00 7c 48 add w8, w2, #31 + ``` + And then update the assembly as `WORD $0x11007c48 // add w8, w2, #31` +* Labels used in instructions won't work when using the `WORD $0x#########` syntax. + They need to be the actual instructions for the labels. So all lines that have a + label will need to be converted. This is two-fold: + 1. Any lines for branching such as those which end with `// b.le LBB0_10` are updated + to be `BLE LBB0_10`. The same is true for `b.gt`, `b.ge`, `b.ne`, and `b.eq`. `b` + instructions are instead converted to `JMP` calls. + 2. References to constants need to be updated, for example `LCPI0_192`. By default, + these will get converted to global data instructions like + `DATA LCDATA1<>+0xc68(SB)/8, $0x0000000000000000`. Unfortunately, these seem to + have issues with being referenced by the assembler. The pattern to look for in + the assembly is an `adrp x9, .LCPI0_192` instruction that is later followed by + an instruction that looks like `str d4, [x9, 0:lo12:.LCPI0_192]`. These will + need to be converted to a macro and a `VMOV` instruction. + * In the original assembly, you'll see blocks like: + ```asm + .LCPI0_0 + .word 1 // 0x00000001 + .word 2 // 0x00000002 + .LCPI0_1 + .word 4294967265 // 0xffffffe1 + .word 4294967266 // 0xffffffe2 + ``` + which were converted to the `DATA LCDATA1`.... lines. Instead they should get + converted to a macro and a vector instruction: + ```asm + #define LCPI0_0 $0x0000000200000001 + #define LCPI0_1 $0xffffffe2ffffffe1 + ``` + Notice the lower/higher bits! + Then replace the `str`/`ldr`/`mov` instruction as `VMOVD LCPI0_0, v4`. Because + the original instruction storing the value in `d4`, we use `VMOVD` and `V4`. + Alternately we might find a prefix of `q` instead of `d`, in which case it we + need to use `VMOVQ` and pass the lower bytes followed by the higher bytes. + ```asm + #define LCPI0_48L $0x0000000d00000008 + #define LCPI0_48H $0x0000001700000012 + ... + VMOVQ LCPI0_48L, LCPI0_48H, V4 + ``` + After replacing the instructions, both the `adrp` and the `str`/`ldr`/`mov` + instructions should be removed/commented out. + There might also be a `LEAQ LCDATA1<>(SB), BP` instruction at the top of the + function. That should be removed/commented out as we are replacing the constants + with macros. +* Finally, if the function has a return value, make sure that at the end of the + function, ends with something akin to `MOVD R0, num+32(FP)`. Where `num` is the + local variable name of the return value, and `32` is the byte size of the arguments. + +To faciliate some automation, a `script.sed` file is provided in this directory which +can be run against the generated assembly from `c2goasm` as +`sed -f _lib/script.sed -i bit_packing_neon_arm64.s` which will perform several of +these steps on the generated assembly such as convering `b.le`/etc calls with labels +to proper `BLE LBB0_....` lines, and converting `adrp`/`ldr` pairs to `VMOVD` and +`VMOVQ` instructions. + +This should be sufficient to ensuring the assembly is generated and works properly! \ No newline at end of file diff --git a/go/parquet/internal/utils/_lib/bit_packing_neon.c b/go/parquet/internal/utils/_lib/bit_packing_neon.c index c333a346c3ac9..c8dd97c2a36a2 100755 --- a/go/parquet/internal/utils/_lib/bit_packing_neon.c +++ b/go/parquet/internal/utils/_lib/bit_packing_neon.c @@ -20,8 +20,9 @@ #include "arm_neon.h" inline const uint32_t* unpack0_32_neon(const uint32_t* in, uint32_t* out) { - memset(out, 0x0, 32 * sizeof(*out)); - out += 32; + for (const uint32_t* end = out + 32; out != end; out++) { + *out = 0; + } return in; } @@ -647,7 +648,7 @@ inline static const uint32_t* unpack7_32_neon(const uint32_t* in, uint32_t* out) out += 4; // shift the 2nd 4 outs - ind[2] = (in[0] >> 28 | in[1] << 4) >> shifts_2nd[0]; + ind[0] = (in[0] >> 28 | in[1] << 4) >> shifts_2nd[0]; ind[1] = in[1] >> shifts_2nd[1]; ind[2] = in[1] >> shifts_2nd[2]; ind[3] = in[1] >> shifts_2nd[3]; @@ -842,7 +843,7 @@ inline static const uint32_t* unpack9_32_neon(const uint32_t* in, uint32_t* out) out += 4; // shift the 2nd 4 outs - ind[2] = in[1] >> shifts_2nd[0]; + ind[0] = in[1] >> shifts_2nd[0]; ind[1] = in[1] >> shifts_2nd[1]; ind[2] = in[1] >> shifts_2nd[2]; ind[3] = (in[1] >> 31 | in[2] << 1) >> shifts_2nd[3]; @@ -939,7 +940,7 @@ inline static const uint32_t* unpack10_32_neon(const uint32_t* in, uint32_t* out out += 4; // shift the 2nd 4 outs - ind[2] = in[1] >> shifts_2nd[0]; + ind[0] = in[1] >> shifts_2nd[0]; ind[1] = in[1] >> shifts_2nd[1]; ind[2] = (in[1] >> 28 | in[2] << 4) >> shifts_2nd[2]; ind[3] = in[2] >> shifts_2nd[3]; @@ -1040,7 +1041,7 @@ inline static const uint32_t* unpack11_32_neon(const uint32_t* in, uint32_t* out out += 4; // shift the 2nd 4 outs - ind[2] = in[1] >> shifts_2nd[0]; + ind[0] = in[1] >> shifts_2nd[0]; ind[1] = (in[1] >> 23 | in[2] << 9) >> shifts_2nd[1]; ind[2] = in[2] >> shifts_2nd[2]; ind[3] = in[2] >> shifts_2nd[3]; @@ -1135,7 +1136,7 @@ inline static const uint32_t* unpack12_32_neon(const uint32_t* in, uint32_t* out out += 4; // shift the 2nd 4 outs - ind[2] = in[1] >> shifts_2nd[0]; + ind[0] = in[1] >> shifts_2nd[0]; ind[1] = (in[1] >> 28 | in[2] << 4) >> shifts_2nd[1]; ind[2] = in[2] >> shifts_2nd[2]; ind[3] = in[2] >> shifts_2nd[3]; @@ -1236,7 +1237,7 @@ inline static const uint32_t* unpack13_32_neon(const uint32_t* in, uint32_t* out out += 4; // shift the 2nd 4 outs - ind[2] = (in[1] >> 20 | in[2] << 12) >> shifts_2nd[0]; + ind[0] = (in[1] >> 20 | in[2] << 12) >> shifts_2nd[0]; ind[1] = in[2] >> shifts_2nd[1]; ind[2] = in[2] >> shifts_2nd[2]; ind[3] = (in[2] >> 27 | in[3] << 5) >> shifts_2nd[3]; @@ -1698,7 +1699,6 @@ inline static const uint32_t* unpack17_32_neon(const uint32_t* in, uint32_t* out vst1q_u32(out, results); out += 4; - in += 17; return in; @@ -1908,7 +1908,7 @@ inline static const uint32_t* unpack20_32_neon(const uint32_t* in, uint32_t* out uint32_t shifts_1st[4] = {0, 0, 8, 0}; uint32_t shifts_2nd[4] = {0, 4, 0, 12}; uint32x4_t reg_shft, reg_masks; - uint32x4_t results; + uint32x4_t results; reg_masks = vdupq_n_u32(mask); @@ -2093,7 +2093,6 @@ inline static const uint32_t* unpack21_32_neon(const uint32_t* in, uint32_t* out vst1q_u32(out, results); out += 4; - in += 21; return in; @@ -3079,9 +3078,10 @@ inline static const uint32_t* unpack31_32_neon(const uint32_t* in, uint32_t* out } inline const uint32_t* unpack32_32_neon(const uint32_t* in, uint32_t* out) { - memcpy(out, in, 32 * sizeof(*out)); - in += 32; - out += 32; + for (const uint32_t* end = out + 32; out != end; out++) { + *out = *in; + in++; + } return in; } diff --git a/go/parquet/internal/utils/_lib/script.sed b/go/parquet/internal/utils/_lib/script.sed new file mode 100644 index 0000000000000..908cce695a5ba --- /dev/null +++ b/go/parquet/internal/utils/_lib/script.sed @@ -0,0 +1,22 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +s|WORD $0x54[0-9a-f]\+[[:space:]]\+//[[:space:]]\+b.\([leqgtnso]\+\)[[:space:]]\+.\(LBB0_[0-9]\+\)|B\U\1 \2| +s|WORD $0x14000000[[:space:]]\+//[[:space:]]\+b[[:space:]]\+.\(LBB0_[0-9]\+\)|JMP \1| +s|\(WORD $0x9[0-9a-f]\+ // adrp.*\)|// \1| +s|WORD $0x[0-9a-f]\+ // ldr[[:space:]]\+d\([0-9]\+\), \[x[0-9]\+, :lo[0-9]\+:.\(LCPI0_[0-9]\+\)\]|VMOVD \2, V\1| +s|WORD $0x[0-9a-f]\+ // ldr[[:space:]]\+q\([0-9]\+\), \[x[0-9]\+, :lo[0-9]\+:.\(LCPI0_[0-9]\+\)\]|VMOVQ \2L, \2H, V\1| diff --git a/go/parquet/internal/utils/bit_packing_arm64.go b/go/parquet/internal/utils/bit_packing_arm64.go index 61eead02633ca..92fe0f97b77c3 100644 --- a/go/parquet/internal/utils/bit_packing_arm64.go +++ b/go/parquet/internal/utils/bit_packing_arm64.go @@ -20,33 +20,14 @@ package utils import ( - "os" - "strings" - - "golang.org/x/sys/cpu" + "github.com/klauspost/cpuid/v2" + // import for side effect of initializing feature flags + // based on ARM_ENABLE_EXT env var + _ "github.com/apache/arrow/go/v14/parquet/internal/bmi" ) func init() { - cpu.ARM64.HasASIMD = false - cpu.ARM64.HasAES = false - cpu.ARM64.HasPMULL = false - // Added ability to enable extension via environment: - if ext, ok := os.LookupEnv("ARM_ENABLE_EXT"); ok { - exts := strings.Split(ext, ",") - - for _, x := range exts { - switch x { - case "NEON": - cpu.ARM64.HasASIMD = true - case "AES": - cpu.ARM64.HasAES = true - case "PMULL": - cpu.ARM64.HasPMULL = true - default: - } - } - } - if cpu.ARM64.HasASIMD { + if cpuid.CPU.Has(cpuid.ASIMD) { unpack32 = unpack32NEON } else { // default to the pure go implementation if no avx2 available unpack32 = unpack32Default diff --git a/go/parquet/internal/utils/bit_packing_neon_arm64.s b/go/parquet/internal/utils/bit_packing_neon_arm64.s old mode 100755 new mode 100644 index 047e5b720e4a0..2d18dccdb573b --- a/go/parquet/internal/utils/bit_packing_neon_arm64.s +++ b/go/parquet/internal/utils/bit_packing_neon_arm64.s @@ -1,3351 +1,6926 @@ //+build !noasm !appengine +// AUTO-GENERATED BY C2GOASM -- DO NOT EDIT + +#include "go_asm.h" +#include "textflag.h" + +#define LCPI0_0L $0x000000000000000e +#define LCPI0_0H $0x000000000000000f +#define LCPI0_1L $0x000000000000000c +#define LCPI0_1H $0x000000000000000d +#define LCPI0_2L $0x000000000000000a +#define LCPI0_2H $0x000000000000000b +#define LCPI0_3L $0x0000000000000008 +#define LCPI0_3H $0x0000000000000009 +#define LCPI0_4L $0x0000000000000006 +#define LCPI0_4H $0x0000000000000007 +#define LCPI0_5L $0x0000000000000004 +#define LCPI0_5H $0x0000000000000005 +#define LCPI0_6L $0x0000000000000002 +#define LCPI0_6H $0x0000000000000003 +#define LCPI0_7L $0x0000000000000000 +#define LCPI0_7H $0x0000000000000001 + +#define LCPI0_10L $0x0000000500000004 +#define LCPI0_10H $0x0000000700000006 +#define LCPI0_11L $0xffffffe5ffffffe4 +#define LCPI0_11H $0xffffffe7ffffffe6 +#define LCPI0_12L $0x0000000900000008 +#define LCPI0_12H $0x0000000b0000000a +#define LCPI0_13L $0xffffffe9ffffffe8 +#define LCPI0_13H $0xffffffebffffffea +#define LCPI0_14L $0x0000000d0000000c +#define LCPI0_14H $0x0000000f0000000e +#define LCPI0_15L $0xffffffedffffffec +#define LCPI0_15H $0xffffffefffffffee +#define LCPI0_16L $0x0000001100000010 +#define LCPI0_16H $0x0000001300000012 +#define LCPI0_17L $0xfffffff1fffffff0 +#define LCPI0_17H $0xfffffff3fffffff2 +#define LCPI0_18L $0x0000001500000014 +#define LCPI0_18H $0x0000001700000016 +#define LCPI0_19L $0xfffffff5fffffff4 +#define LCPI0_19H $0xfffffff7fffffff6 +#define LCPI0_20L $0x0000001900000018 +#define LCPI0_20H $0x0000001b0000001a +#define LCPI0_21L $0xfffffff9fffffff8 +#define LCPI0_21H $0xfffffffbfffffffa +#define LCPI0_26L $0x0000000a00000008 +#define LCPI0_26H $0x0000000e0000000c +#define LCPI0_27L $0xffffffeaffffffe8 +#define LCPI0_27H $0xffffffeeffffffec +#define LCPI0_28L $0x0000001200000010 +#define LCPI0_28H $0x0000001600000014 +#define LCPI0_29L $0xfffffff2fffffff0 +#define LCPI0_29H $0xfffffff6fffffff4 +#define LCPI0_34L $0x0000000f0000000c +#define LCPI0_34H $0x0000001500000012 +#define LCPI0_35L $0xffffffefffffffec +#define LCPI0_35H $0xfffffff5fffffff2 +#define LCPI0_38L $0x0000000700000004 +#define LCPI0_38H $0x0000000d0000000a +#define LCPI0_39L $0xffffffe7ffffffe4 +#define LCPI0_39H $0xffffffedffffffea +#define LCPI0_40L $0x0000001300000010 +#define LCPI0_40H $0x0000001900000016 +#define LCPI0_41L $0xfffffff3fffffff0 +#define LCPI0_41H $0xfffffff9fffffff6 +#define LCPI0_44L $0x0000000b00000008 +#define LCPI0_44H $0x000000110000000e +#define LCPI0_45L $0xffffffebffffffe8 +#define LCPI0_45H $0xfffffff1ffffffee +#define LCPI0_56L $0x0000000d00000008 +#define LCPI0_56H $0x0000001700000012 +#define LCPI0_57L $0xffffffedffffffe8 +#define LCPI0_57H $0xfffffff7fffffff2 +#define LCPI0_62L $0x0000000900000004 +#define LCPI0_62H $0x000000130000000e +#define LCPI0_63L $0xffffffe9ffffffe4 +#define LCPI0_63H $0xfffffff3ffffffee +#define LCPI0_173L $0xfffffff5fffffffc +#define LCPI0_173H $0xffffffe7ffffffee +#define LCPI0_177L $0xfffffff2fffffff8 +#define LCPI0_177H $0xffffffe6ffffffec +#define LCPI0_180L $0xfffffff3fffffff8 +#define LCPI0_180H $0xffffffe9ffffffee +#define LCPI0_183L $0xfffffff7fffffffc +#define LCPI0_183H $0xffffffedfffffff2 +#define LCPI0_185L $0xffffffeffffffff4 +#define LCPI0_185H $0xffffffe5ffffffea +#define LCPI0_187L $0xffffffecfffffff0 +#define LCPI0_187H $0xffffffe4ffffffe8 +#define LCPI0_189L $0xfffffff1fffffff4 +#define LCPI0_189H $0xffffffebffffffee +#define LCPI0_191L $0xfffffff9fffffffc +#define LCPI0_191H $0xfffffff3fffffff6 +#define LCPI0_192L $0xffffffedfffffff0 +#define LCPI0_192H $0xffffffe7ffffffea +#define LCPI0_194L $0xfffffff5fffffff8 +#define LCPI0_194H $0xffffffeffffffff2 +#define LCPI0_195L $0xffffffe9ffffffec +#define LCPI0_195H $0xffffffe3ffffffe6 +#define LCPI0_197L $0xfffffff6fffffff8 +#define LCPI0_197H $0xfffffff2fffffff4 +#define LCPI0_198L $0xffffffeefffffff0 +#define LCPI0_198H $0xffffffeaffffffec +#define LCPI0_199L $0xffffffe6ffffffe8 +#define LCPI0_199H $0xffffffe2ffffffe4 +#define LCPI0_201L $0xfffffffbfffffffc +#define LCPI0_201H $0xfffffff9fffffffa +#define LCPI0_202L $0xfffffff7fffffff8 +#define LCPI0_202H $0xfffffff5fffffff6 +#define LCPI0_203L $0xfffffff3fffffff4 +#define LCPI0_203H $0xfffffff1fffffff2 +#define LCPI0_204L $0xffffffeffffffff0 +#define LCPI0_204H $0xffffffedffffffee +#define LCPI0_205L $0xffffffebffffffec +#define LCPI0_205H $0xffffffe9ffffffea +#define LCPI0_206L $0xffffffe7ffffffe8 +#define LCPI0_206H $0xffffffe5ffffffe6 +#define LCPI0_207L $0xffffffe3ffffffe4 +#define LCPI0_207H $0xffffffe1ffffffe2 + +#define LCPI0_8 $0x0000000200000001 +#define LCPI0_9 $0xffffffe2ffffffe1 +#define LCPI0_22 $0x0000001d0000001c +#define LCPI0_23 $0xfffffffdfffffffc +#define LCPI0_24 $0x0000000400000002 +#define LCPI0_25 $0xffffffe4ffffffe2 +#define LCPI0_30 $0x0000001a00000018 +#define LCPI0_31 $0xfffffffafffffff8 +#define LCPI0_32 $0x0000000600000003 +#define LCPI0_33 $0xffffffe6ffffffe3 +#define LCPI0_36 $0x0000001b00000018 +#define LCPI0_37 $0xfffffffbfffffff8 +#define LCPI0_42 $0x0000000500000002 +#define LCPI0_43 $0xffffffe5ffffffe2 +#define LCPI0_46 $0x0000001700000014 +#define LCPI0_47 $0xfffffff7fffffff4 +#define LCPI0_48 $0x0000000800000004 +#define LCPI0_49 $0xffffffe8ffffffe4 +#define LCPI0_50 $0x0000001400000010 +#define LCPI0_51 $0xfffffff4fffffff0 +#define LCPI0_52 $0x0000000a00000005 +#define LCPI0_53 $0xffffffeaffffffe5 +#define LCPI0_54 $0x0000001900000014 +#define LCPI0_55 $0xfffffff9fffffff4 +#define LCPI0_58 $0x0000000600000001 +#define LCPI0_59 $0xffffffe6ffffffe1 +#define LCPI0_60 $0x0000001500000010 +#define LCPI0_61 $0xfffffff5fffffff0 +#define LCPI0_64 $0x0000000700000002 +#define LCPI0_65 $0xffffffe7ffffffe2 +#define LCPI0_66 $0x000000110000000c +#define LCPI0_67 $0xfffffff1ffffffec +#define LCPI0_68 $0x0000000c00000006 +#define LCPI0_69 $0xffffffecffffffe6 +#define LCPI0_70 $0x0000000a00000004 +#define LCPI0_71 $0xffffffeaffffffe4 +#define LCPI0_72 $0x0000001600000010 +#define LCPI0_73 $0xfffffff6fffffff0 +#define LCPI0_74 $0x0000000e00000008 +#define LCPI0_75 $0xffffffeeffffffe8 +#define LCPI0_76 $0x0000000e00000007 +#define LCPI0_77 $0xffffffeeffffffe7 +#define LCPI0_78 $0x0000000a00000003 +#define LCPI0_79 $0xffffffeaffffffe3 +#define LCPI0_80 $0x0000000d00000006 +#define LCPI0_81 $0xffffffedffffffe6 +#define LCPI0_82 $0x0000000900000002 +#define LCPI0_83 $0xffffffe9ffffffe2 +#define LCPI0_84 $0x0000001700000010 +#define LCPI0_85 $0xfffffff7fffffff0 +#define LCPI0_86 $0x000000130000000c +#define LCPI0_87 $0xfffffff3ffffffec +#define LCPI0_88 $0x0000000f00000008 +#define LCPI0_89 $0xffffffefffffffe8 +#define LCPI0_90 $0x0000000b00000004 +#define LCPI0_91 $0xffffffebffffffe4 +#define LCPI0_92 $0x0000001000000008 +#define LCPI0_93 $0xfffffff0ffffffe8 +#define LCPI0_94 $0x0000001200000009 +#define LCPI0_95 $0xfffffff2ffffffe9 +#define LCPI0_96 $0x0000000d00000004 +#define LCPI0_97 $0xffffffedffffffe4 +#define LCPI0_98 $0x0000001100000008 +#define LCPI0_99 $0xfffffff1ffffffe8 +#define LCPI0_100 $0x000000150000000c +#define LCPI0_101 $0xfffffff5ffffffec +#define LCPI0_102 $0x0000000b00000002 +#define LCPI0_103 $0xffffffebffffffe2 +#define LCPI0_104 $0x0000000f00000006 +#define LCPI0_105 $0xffffffefffffffe6 +#define LCPI0_106 $0x0000000a00000001 +#define LCPI0_107 $0xffffffeaffffffe1 +#define LCPI0_108 $0x0000000e00000005 +#define LCPI0_109 $0xffffffeeffffffe5 +#define LCPI0_110 $0x000000140000000a +#define LCPI0_111 $0xfffffff4ffffffea +#define LCPI0_112 $0x0000001200000008 +#define LCPI0_113 $0xfffffff2ffffffe8 +#define LCPI0_114 $0x0000000e00000004 +#define LCPI0_115 $0xffffffeeffffffe4 +#define LCPI0_116 $0x0000000c00000002 +#define LCPI0_117 $0xffffffecffffffe2 +#define LCPI0_118 $0x0000000d00000002 +#define LCPI0_119 $0xffffffedffffffe2 +#define LCPI0_120 $0x0000000e00000003 +#define LCPI0_121 $0xffffffeeffffffe3 +#define LCPI0_122 $0x0000000f00000004 +#define LCPI0_123 $0xffffffefffffffe4 +#define LCPI0_124 $0x0000001100000006 +#define LCPI0_125 $0xfffffff1ffffffe6 +#define LCPI0_126 $0x0000001200000007 +#define LCPI0_127 $0xfffffff2ffffffe7 +#define LCPI0_128 $0x0000001300000008 +#define LCPI0_129 $0xfffffff3ffffffe8 +#define LCPI0_130 $0x0000000e00000001 +#define LCPI0_131 $0xffffffeeffffffe1 +#define LCPI0_132 $0x0000000f00000002 +#define LCPI0_133 $0xffffffefffffffe2 +#define LCPI0_134 $0x0000001100000004 +#define LCPI0_135 $0xfffffff1ffffffe4 +#define LCPI0_136 $0x0000001200000005 +#define LCPI0_137 $0xfffffff2ffffffe5 +#define LCPI0_138 $0xffffffeffffffffe +#define LCPI0_139 $0xffffffeefffffffc +#define LCPI0_140 $0xfffffff2ffffffff +#define LCPI0_141 $0xfffffff1fffffffe +#define LCPI0_142 $0xffffffeffffffffc +#define LCPI0_143 $0xffffffeefffffffb +#define LCPI0_144 $0xffffffedfffffffa +#define LCPI0_145 $0xffffffecfffffff8 +#define LCPI0_146 $0xfffffff3fffffffe +#define LCPI0_147 $0xfffffff2fffffffd +#define LCPI0_148 $0xfffffff1fffffffc +#define LCPI0_149 $0xffffffeffffffffa +#define LCPI0_150 $0xffffffeefffffff9 +#define LCPI0_151 $0xffffffedfffffff8 +#define LCPI0_152 $0xffffffebfffffff6 +#define LCPI0_153 $0xffffffecfffffff6 +#define LCPI0_154 $0xffffffeefffffff8 +#define LCPI0_155 $0xfffffff2fffffffc +#define LCPI0_156 $0xfffffff4fffffffe +#define LCPI0_157 $0xffffffeefffffff7 +#define LCPI0_158 $0xfffffff3fffffffc +#define LCPI0_159 $0xffffffeffffffff8 +#define LCPI0_160 $0xffffffebfffffff4 +#define LCPI0_161 $0xfffffff5fffffffe +#define LCPI0_162 $0xfffffff1fffffffa +#define LCPI0_163 $0xfffffff6ffffffff +#define LCPI0_164 $0xfffffff2fffffffb +#define LCPI0_165 $0xfffffff0fffffff8 +#define LCPI0_166 $0xfffffff2fffffff9 +#define LCPI0_167 $0xfffffff6fffffffd +#define LCPI0_168 $0xfffffff3fffffffa +#define LCPI0_169 $0xfffffff7fffffffe +#define LCPI0_170 $0xffffffe9fffffff0 +#define LCPI0_171 $0xffffffedfffffff4 +#define LCPI0_172 $0xfffffff1fffffff8 +#define LCPI0_174 $0xfffffff4fffffffa +#define LCPI0_175 $0xfffffff6fffffffc +#define LCPI0_176 $0xffffffeafffffff0 +#define LCPI0_178 $0xfffffff6fffffffb +#define LCPI0_179 $0xffffffe7ffffffec +#define LCPI0_181 $0xfffffffaffffffff +#define LCPI0_182 $0xffffffebfffffff0 +#define LCPI0_184 $0xfffffff9fffffffe +#define LCPI0_186 $0xfffffff8fffffffc +#define LCPI0_188 $0xfffffffafffffffd +#define LCPI0_190 $0xffffffe5ffffffe8 +#define LCPI0_193 $0xfffffffbfffffffe +#define LCPI0_196 $0xfffffffcfffffffe +#define LCPI0_200 $0xfffffffeffffffff + +TEXT ·_unpack32_neon(SB), $0-40 + + MOVD in+0(FP), R0 + MOVD out+8(FP), R1 + MOVD batchSize+16(FP), R2 + MOVD nbits+24(FP), R3 + // LEAQ LCDATA1<>(SB), BP + + // %bb.0: + WORD $0xa9ba7bfd // stp x29, x30, [sp, #-96]! + WORD $0xd10643e9 // sub x9, sp, #400 + WORD $0xa9016ffc // stp x28, x27, [sp, #16] + WORD $0xa90267fa // stp x26, x25, [sp, #32] + WORD $0x910003fd // mov x29, sp + WORD $0xa9035ff8 // stp x24, x23, [sp, #48] + WORD $0xa90457f6 // stp x22, x21, [sp, #64] + WORD $0xa9054ff4 // stp x20, x19, [sp, #80] + WORD $0x927df13f // and sp, x9, #0xfffffffffffffff8 + WORD $0x11007c48 // add w8, w2, #31 + WORD $0x7100005f // cmp w2, #0 + WORD $0x1a82b108 // csel w8, w8, w2, lt + WORD $0xaa0103fa // mov x26, x1 + WORD $0x13057d13 // asr w19, w8, #5 + WORD $0x71003c7f // cmp w3, #15 + BLE LBB0_14 + + // %bb.1: + WORD $0x71005c7f // cmp w3, #23 + BLE LBB0_22 + + // %bb.2: + WORD $0x71006c7f // cmp w3, #27 + BLE LBB0_36 + + // %bb.3: + WORD $0x7100747f // cmp w3, #29 + BLE LBB0_60 + + // %bb.4: + WORD $0x7100787f // cmp w3, #30 + BEQ LBB0_148 + + // %bb.5: + WORD $0x71007c7f // cmp w3, #31 + BEQ LBB0_100 + + // %bb.6: + WORD $0x7100807f // cmp w3, #32 + BNE LBB0_156 + + // %bb.7: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.8: + WORD $0x7100427f // cmp w19, #16 + BLO LBB0_11 + + // %bb.9: + WORD $0xd379e268 // lsl x8, x19, #7 + WORD $0x8b080009 // add x9, x0, x8 + WORD $0xeb1a013f // cmp x9, x26 + BLS LBB0_157 + + // %bb.10: + WORD $0x8b080348 // add x8, x26, x8 + WORD $0xeb00011f // cmp x8, x0 + BLS LBB0_157 + +LBB0_11: + WORD $0xf9000fff // str xzr, [sp, #24] -// ARROW-15336 -// (C2GOASM doesn't work correctly for Arm64) -// Partly GENERATED BY asm2plan9s. - -DATA LJTI<>+0x000(SB)/2, $0 -DATA LJTI<>+0x002(SB)/2, $9 -DATA LJTI<>+0x004(SB)/2, $72 -DATA LJTI<>+0x006(SB)/2, $133 -DATA LJTI<>+0x008(SB)/2, $210 -DATA LJTI<>+0x00a(SB)/2, $291 -DATA LJTI<>+0x00c(SB)/2, $390 -DATA LJTI<>+0x00e(SB)/2, $474 -DATA LJTI<>+0x010(SB)/2, $567 -DATA LJTI<>+0x012(SB)/2, $657 -DATA LJTI<>+0x014(SB)/2, $758 -DATA LJTI<>+0x016(SB)/2, $854 -DATA LJTI<>+0x018(SB)/2, $957 -DATA LJTI<>+0x01a(SB)/2, $1048 -DATA LJTI<>+0x01c(SB)/2, $4601 -DATA LJTI<>+0x01e(SB)/2, $1250 -DATA LJTI<>+0x020(SB)/2, $1354 -DATA LJTI<>+0x022(SB)/2, $1436 -DATA LJTI<>+0x024(SB)/2, $1541 -DATA LJTI<>+0x026(SB)/2, $1645 -DATA LJTI<>+0x028(SB)/2, $1773 -DATA LJTI<>+0x02a(SB)/2, $1875 -DATA LJTI<>+0x02c(SB)/2, $2015 -DATA LJTI<>+0x02e(SB)/2, $2145 -DATA LJTI<>+0x030(SB)/2, $2292 -DATA LJTI<>+0x032(SB)/2, $2390 -DATA LJTI<>+0x034(SB)/2, $3140 -DATA LJTI<>+0x036(SB)/2, $2533 -DATA LJTI<>+0x038(SB)/2, $2667 -DATA LJTI<>+0x03a(SB)/2, $2781 -DATA LJTI<>+0x03c(SB)/2, $2902 -DATA LJTI<>+0x03e(SB)/2, $3008 -DATA LJTI<>+0x040(SB)/2, $3117 -GLOBL LJTI<>+0(SB), 8, $66 - - -// func _unpack32_neon(in, out unsafe.Pointer, batchSize, nbits int) (num int) -TEXT ·_unpack32_neon(SB), $24-40 - - MOVD in+0(FP), R0 - MOVD out+8(FP), R1 - MOVD batchSize+16(FP), R2 - MOVD nbits+24(FP), R3 - - WORD $0xa9be7bfd // stp x29, x30, [sp, #-32]! - WORD $0x11007c48 // add w8, w2, #31 - WORD $0x7100005f // cmp w2, #0 - WORD $0x1a82b108 // csel w8, w8, w2, lt - WORD $0xf9000bf3 // str x19, [sp, #16] - WORD $0x7100807f // cmp w3, #32 - WORD $0x121b6913 // and w19, w8, #0xffffffe0 - WORD $0x910003fd // mov x29, sp - BHI LBB0_99 - WORD $0x2a0303e9 // mov w9, w3 - MOVD LJTI<>+0x00(SB), R10 - WORD $0x1000000b // adr x11, LBB0_2 - WORD $0x7869794c // ldrh w12, [x10, x9, lsl #1] - WORD $0x8b0c096b // add x11, x11, x12, lsl #2 - WORD $0x13057d08 // asr w8, w8, #5 - WORD $0xd61f0160 // br x11 -LBB0_2: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - WORD $0x51000508 // sub w8, w8, #1 - WORD $0xd379e108 // lsl x8, x8, #7 - WORD $0x91020102 // add x2, x8, #128 - WORD $0xaa0103e0 // mov x0, x1 - WORD $0x2a1f03e1 // mov w1, wzr - WORD $0x94000000 // bl memset - JMP LBB0_99 -LBB0_4: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - VMOVQ $0x0000000500000004, $0x0000000700000006, V1 // LCPI0_1 - VMOVQ $0x0000000900000008, $0x0000000b0000000a, V2 // LCPI0_3 - VMOVQ $0x0000000d0000000c, $0x0000000f0000000e, V3 // LCPI0_5 - VMOVQ $0x0000001100000010, $0x0000001300000012, V4 // LCPI0_7 - VMOVQ $0x0000001500000014, $0x0000001700000016, V5 // LCPI0_9 - VMOVQ $0x0000001900000018, $0x0000001b0000001a, V6 // LCPI0_11 - VMOVQ $0x0000001d0000001c, $0x0000001f0000001e, V7 // LCPI0_121 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f000420 // movi v0.4s, #1 - WORD $0x6ea0b821 // neg v1.4s, v1.4s - WORD $0x6ea0b842 // neg v2.4s, v2.4s - WORD $0x6ea0b863 // neg v3.4s, v3.4s - WORD $0x6ea0b884 // neg v4.4s, v4.4s - WORD $0x6ea0b8a5 // neg v5.4s, v5.4s - WORD $0x6ea0b8c6 // neg v6.4s, v6.4s - WORD $0x6ea0b8e7 // neg v7.4s, v7.4s - WORD $0xaa0003ea // mov x10, x0 -LBB0_6: - WORD $0xb940000b // ldr w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53017d6c // lsr w12, w11, #1 - WORD $0x1e270170 // fmov s16, w11 - WORD $0x53027d6d // lsr w13, w11, #2 - WORD $0x4e0c1d90 // mov v16.s[1], w12 - WORD $0x53037d6e // lsr w14, w11, #3 - WORD $0x4e141db0 // mov v16.s[2], w13 - WORD $0x4e1c1dd0 // mov v16.s[3], w14 - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9c0130 // stur q16, [x9, #-64] - WORD $0x4ddfc950 // ld1r { v16.4s }, [x10], #4 - WORD $0x6ea14610 // ushl v16.4s, v16.4s, v1.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9d0130 // stur q16, [x9, #-48] - WORD $0x4d40c810 // ld1r { v16.4s }, [x0] - WORD $0x6ea24610 // ushl v16.4s, v16.4s, v2.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9e0130 // stur q16, [x9, #-32] - WORD $0x4d40c810 // ld1r { v16.4s }, [x0] - WORD $0x6ea34610 // ushl v16.4s, v16.4s, v3.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9f0130 // stur q16, [x9, #-16] - WORD $0x4d40c810 // ld1r { v16.4s }, [x0] - WORD $0x6ea44610 // ushl v16.4s, v16.4s, v4.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800130 // str q16, [x9] - WORD $0x4d40c810 // ld1r { v16.4s }, [x0] - WORD $0x6ea54610 // ushl v16.4s, v16.4s, v5.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800530 // str q16, [x9, #16] - WORD $0x4d40c810 // ld1r { v16.4s }, [x0] - WORD $0x6ea64610 // ushl v16.4s, v16.4s, v6.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800930 // str q16, [x9, #32] - WORD $0x4d40c810 // ld1r { v16.4s }, [x0] - WORD $0xaa0a03e0 // mov x0, x10 - WORD $0x6ea74610 // ushl v16.4s, v16.4s, v7.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800d30 // str q16, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_6 - JMP LBB0_99 -LBB0_7: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - VMOVQ $0x0000000a00000008, $0x0000000e0000000c, V1 // LCPI0_15 - VMOVQ $0x0000001200000010, $0x0000001600000014, V2 // LCPI0_17 - VMOVQ $0x0000001a00000018, $0x0000001e0000001c, V3 // LCPI0_120 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f000460 // movi v0.4s, #3 - WORD $0x6ea0b821 // neg v1.4s, v1.4s - WORD $0x6ea0b842 // neg v2.4s, v2.4s - WORD $0x6ea0b863 // neg v3.4s, v3.4s -LBB0_9: - WORD $0xb940000a // ldr w10, [x0] - WORD $0xaa0003eb // mov x11, x0 - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53027d4c // lsr w12, w10, #2 - WORD $0x1e270144 // fmov s4, w10 - WORD $0x53047d4d // lsr w13, w10, #4 - WORD $0x4e0c1d84 // mov v4.s[1], w12 - WORD $0x53067d4e // lsr w14, w10, #6 - WORD $0x4e141da4 // mov v4.s[2], w13 - WORD $0x4e1c1dc4 // mov v4.s[3], w14 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3c9c0124 // stur q4, [x9, #-64] - WORD $0x4ddfc964 // ld1r { v4.4s }, [x11], #4 - WORD $0x6ea14484 // ushl v4.4s, v4.4s, v1.4s - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3c9d0124 // stur q4, [x9, #-48] - WORD $0x4d40c804 // ld1r { v4.4s }, [x0] - WORD $0x6ea24484 // ushl v4.4s, v4.4s, v2.4s - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3c9e0124 // stur q4, [x9, #-32] - WORD $0xb840840a // ldr w10, [x0], #8 - WORD $0x4e040d44 // dup v4.4s, w10 - WORD $0x6ea34484 // ushl v4.4s, v4.4s, v3.4s - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3c9f0124 // stur q4, [x9, #-16] - WORD $0xb940016a // ldr w10, [x11] - WORD $0x53027d4c // lsr w12, w10, #2 - WORD $0x1e270144 // fmov s4, w10 - WORD $0x53047d4d // lsr w13, w10, #4 - WORD $0x4e0c1d84 // mov v4.s[1], w12 - WORD $0x53067d4e // lsr w14, w10, #6 - WORD $0x4e141da4 // mov v4.s[2], w13 - WORD $0x4e1c1dc4 // mov v4.s[3], w14 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800124 // str q4, [x9] - WORD $0x4d40c964 // ld1r { v4.4s }, [x11] - WORD $0x6ea14484 // ushl v4.4s, v4.4s, v1.4s - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800524 // str q4, [x9, #16] - WORD $0x4d40c964 // ld1r { v4.4s }, [x11] - WORD $0x6ea24484 // ushl v4.4s, v4.4s, v2.4s - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800924 // str q4, [x9, #32] - WORD $0x4d40c964 // ld1r { v4.4s }, [x11] - WORD $0x6ea34484 // ushl v4.4s, v4.4s, v3.4s - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800d24 // str q4, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_9 - JMP LBB0_99 -LBB0_10: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - VMOVQ $0x0000000f0000000c, $0x0000001500000012, V1 // LCPI0_21 - MOVD $0x0000001b00000018, R2 // LCPI0_23 - VMOVQ $0x0000000700000004, $0x0000000d0000000a, V3 // LCPI0_25 - VMOVQ $0x0000001300000010, $0x0000001900000016, V4 // LCPI0_27 - MOVD $0x0000000500000002, R5 // LCPI0_29 - VMOVQ $0x0000000b00000008, $0x000000110000000e, V6 // LCPI0_31 - VMOVQ $0x0000001700000014, $0x0000001d0000001a, V7 // LCPI0_119 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f0004e0 // movi v0.4s, #7 - WORD $0x6ea0b821 // neg v1.4s, v1.4s - WORD $0x2ea0b842 // neg v2.2s, v2.2s - WORD $0x6ea0b863 // neg v3.4s, v3.4s - WORD $0x6ea0b884 // neg v4.4s, v4.4s - WORD $0x2ea0b8a5 // neg v5.2s, v5.2s - WORD $0x6ea0b8c6 // neg v6.4s, v6.4s - WORD $0x6ea0b8e7 // neg v7.4s, v7.4s LBB0_12: - WORD $0xb940000a // ldr w10, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53037d4b // lsr w11, w10, #3 - WORD $0x1e270150 // fmov s16, w10 - WORD $0x53067d4c // lsr w12, w10, #6 - WORD $0x4e0c1d70 // mov v16.s[1], w11 - WORD $0x53097d4d // lsr w13, w10, #9 - WORD $0x4e141d90 // mov v16.s[2], w12 - WORD $0x4e1c1db0 // mov v16.s[3], w13 - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0xaa0003ea // mov x10, x0 - WORD $0x3c9c0130 // stur q16, [x9, #-64] - WORD $0x4ddfc950 // ld1r { v16.4s }, [x10], #4 - WORD $0x6ea14610 // ushl v16.4s, v16.4s, v1.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9d0130 // stur q16, [x9, #-48] - WORD $0xb940000b // ldr w11, [x0] - WORD $0xb940014c // ldr w12, [x10] - WORD $0x0e040d70 // dup v16.2s, w11 - WORD $0x138b798b // extr w11, w12, w11, #30 - WORD $0x2ea24610 // ushl v16.2s, v16.2s, v2.2s - WORD $0x53017d8c // lsr w12, w12, #1 - WORD $0x4e141d70 // mov v16.s[2], w11 - WORD $0x4e1c1d90 // mov v16.s[3], w12 - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9e0130 // stur q16, [x9, #-32] - WORD $0x4d40c950 // ld1r { v16.4s }, [x10] - WORD $0x9100200c // add x12, x0, #8 - WORD $0x6ea34610 // ushl v16.4s, v16.4s, v3.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9f0130 // stur q16, [x9, #-16] - WORD $0x4d40c950 // ld1r { v16.4s }, [x10] - WORD $0x6ea44610 // ushl v16.4s, v16.4s, v4.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800130 // str q16, [x9] - WORD $0xb940014a // ldr w10, [x10] - WORD $0xb940080b // ldr w11, [x0, #8] - WORD $0x91003000 // add x0, x0, #12 - WORD $0x531c7d4d // lsr w13, w10, #28 - WORD $0x138a7d6a // extr w10, w11, w10, #31 - WORD $0x0e040d70 // dup v16.2s, w11 - WORD $0x1e2701b1 // fmov s17, w13 - WORD $0x2ea54610 // ushl v16.2s, v16.2s, v5.2s - WORD $0x4e0c1d51 // mov v17.s[1], w10 - WORD $0x6e180611 // mov v17.d[1], v16.d[0] - WORD $0x4e201e30 // and v16.16b, v17.16b, v0.16b - WORD $0x3d800530 // str q16, [x9, #16] - WORD $0x4d40c990 // ld1r { v16.4s }, [x12] - WORD $0x6ea64610 // ushl v16.4s, v16.4s, v6.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800930 // str q16, [x9, #32] - WORD $0x4d40c990 // ld1r { v16.4s }, [x12] - WORD $0x6ea74610 // ushl v16.4s, v16.4s, v7.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800d30 // str q16, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_12 - JMP LBB0_99 + WORD $0xf9400fe8 // ldr x8, [sp, #24] + WORD $0x8b081f4a // add x10, x26, x8, lsl #7 + WORD $0xcb080268 // sub x8, x19, x8 + WORD $0x9101014a // add x10, x10, #64 + LBB0_13: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - VMOVQ $0x0000001400000010, $0x0000001c00000018, V1 // LCPI0_118 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f0005e0 // movi v0.4s, #15 - WORD $0x6ea0b821 // neg v1.4s, v1.4s -LBB0_15: - WORD $0xb940000a // ldr w10, [x0] - WORD $0xaa0003eb // mov x11, x0 - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x530c7d4e // lsr w14, w10, #12 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1dc2 // mov v2.s[3], w14 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9c0122 // stur q2, [x9, #-64] - WORD $0x4ddfc962 // ld1r { v2.4s }, [x11], #4 - WORD $0x6ea14442 // ushl v2.4s, v2.4s, v1.4s - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9d0122 // stur q2, [x9, #-48] - WORD $0xb940016a // ldr w10, [x11] - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x530c7d4e // lsr w14, w10, #12 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1dc2 // mov v2.s[3], w14 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9e0122 // stur q2, [x9, #-32] - WORD $0x4d40c962 // ld1r { v2.4s }, [x11] - WORD $0x9100200b // add x11, x0, #8 - WORD $0x6ea14442 // ushl v2.4s, v2.4s, v1.4s - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9f0122 // stur q2, [x9, #-16] - WORD $0xb940080a // ldr w10, [x0, #8] - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x530c7d4e // lsr w14, w10, #12 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1dc2 // mov v2.s[3], w14 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9f0122 // stur q2, [x9, #-16] - WORD $0xb940080a // ldr w10, [x0, #8] - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x530c7d4e // lsr w14, w10, #12 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1dc2 // mov v2.s[3], w14 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800122 // str q2, [x9] - WORD $0x4d40c962 // ld1r { v2.4s }, [x11] - WORD $0x9100300b // add x11, x0, #12 - WORD $0x6ea14442 // ushl v2.4s, v2.4s, v1.4s - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800522 // str q2, [x9, #16] - WORD $0xb9400c0a // ldr w10, [x0, #12] - WORD $0x91004000 // add x0, x0, #16 - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x530c7d4e // lsr w14, w10, #12 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1dc2 // mov v2.s[3], w14 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800922 // str q2, [x9, #32] - WORD $0x4d40c962 // ld1r { v2.4s }, [x11] - WORD $0x6ea14442 // ushl v2.4s, v2.4s, v1.4s - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800d22 // str q2, [x9, #48] - WORD $0x91020129 //add x9, x9, #128 - BNE LBB0_15 - JMP LBB0_99 -LBB0_16: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000001900000014, R1 // LCPI0_37 - VMOVQ $0x0000000d00000008, $0x0000001700000012, V2 // LCPI0_39 - MOVD $0x0000000600000001, R3 // LCPI0_41 - MOVD $0x0000001500000010, R4 // LCPI0_43 - VMOVQ $0x0000000900000004, $0x000000130000000e, V5 // LCPI0_45 - MOVD $0x0000000700000002, R6 // LCPI0_47 - VMOVQ $0x000000110000000c, $0x0000001b00000016, V7 // LCPI0_117 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f0007e0 // movi v0.4s, #31 - WORD $0x2ea0b821 //neg v1.2s, v1.2s - WORD $0x6ea0b842 //neg v2.4s, v2.4s - WORD $0x2ea0b863 //neg v3.2s, v3.2s - WORD $0x2ea0b884 //neg v4.2s, v4.2s - WORD $0x6ea0b8a5 //neg v5.4s, v5.4s - WORD $0x2ea0b8c6 //neg v6.2s, v6.2s - WORD $0x6ea0b8e7 //neg v7.4s, v7.4s -LBB0_18: - WORD $0xb940000a //ldr w10, [x0] - WORD $0xf1000508 //subs x8, x8, #1 - WORD $0x53057d4b //lsr w11, w10, #5 - WORD $0x1e270150 //fmov s16, w10 - WORD $0x530a7d4c //lsr w12, w10, #10 - WORD $0x4e0c1d70 //mov v16.s[1], w11 - WORD $0x530f7d4d //lsr w13, w10, #15 - WORD $0x4e141d90 //mov v16.s[2], w12 - WORD $0x4e1c1db0 //mov v16.s[3], w13 - WORD $0x4e201e10 //and v16.16b, v16.16b, v0.16b - WORD $0x3c9c0130 // stur q16, [x9, #-64] - WORD $0x29402c0a //ldp w10, w11, [x0] - WORD $0x9100100c //add x12, x0, #4 - WORD $0x0e040d50 // dup v16.2s, w10 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x2ea14610 // ushl v16.2s, v16.2s, v1.2s - WORD $0x53037d6b // lsr w11, w11, #3 - WORD $0x4e141d50 // mov v16.s[2], w10 - WORD $0x4e1c1d70 // mov v16.s[3], w11 - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9d0130 // stur q16, [x9, #-48] - WORD $0x4d40c990 // ld1r { v16.4s }, [x12] - WORD $0x9100300c // add x12, x0, #12 - WORD $0x6ea24610 // ushl v16.4s, v16.4s, v2.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3c9e0130 // stur q16, [x9, #-32] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x0e040d70 // dup v16.2s, w11 - WORD $0x2ea34610 // ushl v16.2s, v16.2s, v3.2s - WORD $0x1e270151 // fmov s17, w10 - WORD $0x6e0c0611 // mov v17.s[1], v16.s[0] - WORD $0x530b7d6b // lsr w11, w11, #11 - WORD $0x6e142611 // mov v17.s[2], v16.s[1] - WORD $0x4e1c1d71 // mov v17.s[3], w11 - WORD $0x4e201e30 // and v16.16b, v17.16b, v0.16b - WORD $0x3c9f0130 // stur q16, [x9, #-16] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0x0e040d50 // dup v16.2s, w10 - WORD $0x531a7d4d // lsr w13, w10, #26 - WORD $0x2ea44610 // ushl v16.2s, v16.2s, v4.2s - WORD $0x138a7d6a // extr w10, w11, w10, #31 - WORD $0x4e141db0 // mov v16.s[2], w13 - WORD $0x4e1c1d50 // mov v16.s[3], w10 - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800130 // str q16, [x9] - WORD $0x4d40c990 // ld1r { v16.4s }, [x12] - WORD $0x9100400c // add x12, x0, #16 - WORD $0x6ea54610 // ushl v16.4s, v16.4s, v5.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800530 // str q16, [x9, #16] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0x91005000 // add x0, x0, #20 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x138a756a // extr w10, w11, w10, #29 - WORD $0x0e040d70 // dup v16.2s, w11 - WORD $0x1e2701b1 // fmov s17, w13 - WORD $0x2ea64610 // ushl v16.2s, v16.2s, v6.2s - WORD $0x4e0c1d51 // mov v17.s[1], w10 - WORD $0x6e180611 // mov v17.d[1], v16.d[0] - WORD $0x4e201e30 // and v16.16b, v17.16b, v0.16b - WORD $0x3d800930 // str q16, [x9, #32] - WORD $0x4d40c990 // ld1r { v16.4s }, [x12] - WORD $0x6ea74610 // ushl v16.4s, v16.4s, v7.4s - WORD $0x4e201e10 // and v16.16b, v16.16b, v0.16b - WORD $0x3d800d30 // str q16, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_18 - JMP LBB0_99 -LBB0_19: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000000a00000004, R1 // LCPI0_51 - MOVD $0x0000001600000010, R2 // LCPI0_53 - VMOVQ $0x0000000e00000008, $0x0000001a00000014, V3 // LCPI0_116 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f0107e0 // movi v0.4s, #63 - WORD $0x2ea0b821 // neg v1.2s, v1.2s - WORD $0x2ea0b842 // neg v2.2s, v2.2s - WORD $0x6ea0b863 // neg v3.4s, v3.4s + WORD $0xb940000b // ldr w11, [x0] + WORD $0xf1000508 // subs x8, x8, #1 + WORD $0xb81c014b // stur w11, [x10, #-64] + WORD $0xb940040b // ldr w11, [x0, #4] + WORD $0xb81c414b // stur w11, [x10, #-60] + WORD $0xb940080b // ldr w11, [x0, #8] + WORD $0xb81c814b // stur w11, [x10, #-56] + WORD $0xb9400c0b // ldr w11, [x0, #12] + WORD $0xb81cc14b // stur w11, [x10, #-52] + WORD $0xb940100b // ldr w11, [x0, #16] + WORD $0xb81d014b // stur w11, [x10, #-48] + WORD $0xb940140b // ldr w11, [x0, #20] + WORD $0xb81d414b // stur w11, [x10, #-44] + WORD $0xb940180b // ldr w11, [x0, #24] + WORD $0xb81d814b // stur w11, [x10, #-40] + WORD $0xb9401c0b // ldr w11, [x0, #28] + WORD $0xb81dc14b // stur w11, [x10, #-36] + WORD $0xb940200b // ldr w11, [x0, #32] + WORD $0xb81e014b // stur w11, [x10, #-32] + WORD $0xb940240b // ldr w11, [x0, #36] + WORD $0xb81e414b // stur w11, [x10, #-28] + WORD $0xb940280b // ldr w11, [x0, #40] + WORD $0xb81e814b // stur w11, [x10, #-24] + WORD $0xb9402c0b // ldr w11, [x0, #44] + WORD $0xb81ec14b // stur w11, [x10, #-20] + WORD $0xb940300b // ldr w11, [x0, #48] + WORD $0xb81f014b // stur w11, [x10, #-16] + WORD $0xb940340b // ldr w11, [x0, #52] + WORD $0xb81f414b // stur w11, [x10, #-12] + WORD $0xb940380b // ldr w11, [x0, #56] + WORD $0xb81f814b // stur w11, [x10, #-8] + WORD $0xb9403c0b // ldr w11, [x0, #60] + WORD $0xb81fc14b // stur w11, [x10, #-4] + WORD $0xb940400b // ldr w11, [x0, #64] + WORD $0xb900014b // str w11, [x10] + WORD $0xb940440b // ldr w11, [x0, #68] + WORD $0xb900054b // str w11, [x10, #4] + WORD $0xb940480b // ldr w11, [x0, #72] + WORD $0xb900094b // str w11, [x10, #8] + WORD $0xb9404c0b // ldr w11, [x0, #76] + WORD $0xb9000d4b // str w11, [x10, #12] + WORD $0xb940500b // ldr w11, [x0, #80] + WORD $0xb900114b // str w11, [x10, #16] + WORD $0xb940540b // ldr w11, [x0, #84] + WORD $0xb900154b // str w11, [x10, #20] + WORD $0xb940580b // ldr w11, [x0, #88] + WORD $0xb900194b // str w11, [x10, #24] + WORD $0xb9405c0b // ldr w11, [x0, #92] + WORD $0xb9001d4b // str w11, [x10, #28] + WORD $0xb940600b // ldr w11, [x0, #96] + WORD $0xb900214b // str w11, [x10, #32] + WORD $0xb940640b // ldr w11, [x0, #100] + WORD $0xb900254b // str w11, [x10, #36] + WORD $0xb940680b // ldr w11, [x0, #104] + WORD $0xb900294b // str w11, [x10, #40] + WORD $0xb9406c0b // ldr w11, [x0, #108] + WORD $0xb9002d4b // str w11, [x10, #44] + WORD $0xb940700b // ldr w11, [x0, #112] + WORD $0xb900314b // str w11, [x10, #48] + WORD $0xb940740b // ldr w11, [x0, #116] + WORD $0xb900354b // str w11, [x10, #52] + WORD $0xb940780b // ldr w11, [x0, #120] + WORD $0xb900394b // str w11, [x10, #56] + WORD $0xb9407c0b // ldr w11, [x0, #124] + WORD $0x91020000 // add x0, x0, #128 + WORD $0xb9003d4b // str w11, [x10, #60] + WORD $0x9102014a // add x10, x10, #128 + BNE LBB0_13 + JMP LBB0_156 + +LBB0_14: + WORD $0x71001c7f // cmp w3, #7 + BGT LBB0_29 + + // %bb.15: + WORD $0x71000c7f // cmp w3, #3 + BGT LBB0_42 + + // %bb.16: + WORD $0x7100047f // cmp w3, #1 + BGT LBB0_65 + + // %bb.17: + WORD $0x34000003 // cbz w3, .LBB0_103 + + // %bb.18: + WORD $0x7100047f // cmp w3, #1 + BNE LBB0_156 + + // %bb.19: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.20: + // WORD $0x90000009 // adrp x9, .LCPI0_201 + // WORD $0x90000008 // adrp x8, .LCPI0_200 + // WORD $0x9000000a // adrp x10, .LCPI0_202 + // WORD $0x9000000b // adrp x11, .LCPI0_206 + WORD $0x4f000427 // movi v7.4s, #1 + VMOVQ LCPI0_201L, LCPI0_201H, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_204 + VMOVD LCPI0_200, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_203 + VMOVQ LCPI0_202L, LCPI0_202H, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_205 + VMOVQ LCPI0_204L, LCPI0_204H, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_207 + VMOVQ LCPI0_203L, LCPI0_203H, V3 + WORD $0x91010348 // add x8, x26, #64 + VMOVQ LCPI0_205L, LCPI0_205H, V5 + WORD $0xaa0003ea // mov x10, x0 + VMOVQ LCPI0_206L, LCPI0_206H, V6 + VMOVQ LCPI0_207L, LCPI0_207H, V16 + WORD $0xaa1303e9 // mov x9, x19 + LBB0_21: - WORD $0xb940000a // ldr w10, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53067d4b // lsr w11, w10, #6 - WORD $0x1e270144 // fmov s4, w10 - WORD $0x530c7d4c // lsr w12, w10, #12 - WORD $0x4e0c1d64 // mov v4.s[1], w11 - WORD $0x53127d4d // lsr w13, w10, #18 - WORD $0x4e141d84 // mov v4.s[2], w12 - WORD $0x4e1c1da4 // mov v4.s[3], w13 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3c9c0124 // stur q4, [x9, #-64] - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0x53187d4c // lsr w12, w10, #24 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x0e040d64 // dup v4.2s, w11 - WORD $0x1e270185 // fmov s5, w12 - WORD $0x2ea14484 // ushl v4.2s, v4.2s, v1.2s - WORD $0x4e0c1d45 // mov v5.s[1], w10 - WORD $0x6e180485 // mov v5.d[1], v4.d[0] - WORD $0x4e201ca4 // and v4.16b, v5.16b, v0.16b - WORD $0x3c9d0124 // stur q4, [x9, #-48] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0x9100200c // add x12, x0, #8 - WORD $0x0e040d44 // dup v4.2s, w10 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x2ea24484 // ushl v4.2s, v4.2s, v2.2s - WORD $0x53027d6b // lsr w11, w11, #2 - WORD $0x4e141d44 // mov v4.s[2], w10 - WORD $0x4e1c1d64 // mov v4.s[3], w11 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3c9e0124 // stur q4, [x9, #-32] - WORD $0x4d40c984 // ld1r { v4.4s }, [x12] - WORD $0x6ea34484 // ushl v4.4s, v4.4s, v3.4s - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3c9f0124 // stur q4, [x9, #-16] - WORD $0xb9400c0a // ldr w10, [x0, #12] - WORD $0x53067d4b // lsr w11, w10, #6 - WORD $0x1e270144 // fmov s4, w10 - WORD $0x530c7d4c // lsr w12, w10, #12 - WORD $0x4e0c1d64 // mov v4.s[1], w11 - WORD $0x53127d4d // lsr w13, w10, #18 - WORD $0x4e141d84 // mov v4.s[2], w12 - WORD $0x4e1c1da4 // mov v4.s[3], w13 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800124 // str q4, [x9] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0x53187d4c // lsr w12, w10, #24 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x0e040d64 // dup v4.2s, w11 - WORD $0x1e270185 // fmov s5, w12 - WORD $0x2ea14484 // ushl v4.2s, v4.2s, v1.2s - WORD $0x4e0c1d45 // mov v5.s[1], w10 - WORD $0x6e180485 // mov v5.d[1], v4.d[0] - WORD $0x4e201ca4 // and v4.16b, v5.16b, v0.16b - WORD $0x3d800524 // str q4, [x9, #16] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0x9100500c // add x12, x0, #20 - WORD $0x91006000 // add x0, x0, #24 - WORD $0x0e040d44 // dup v4.2s, w10 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x2ea24484 // ushl v4.2s, v4.2s, v2.2s - WORD $0x53027d6b // lsr w11, w11, #2 - WORD $0x4e141d44 // mov v4.s[2], w10 - WORD $0x4e1c1d64 // mov v4.s[3], w11 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800924 // str q4, [x9, #32] - WORD $0x4d40c984 // ld1r { v4.4s }, [x12] - WORD $0x6ea34484 // ushl v4.4s, v4.4s, v3.4s - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800d24 // str q4, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_21 - JMP LBB0_99 + WORD $0xb940000b // ldr w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x1e270172 // fmov s18, w11 + WORD $0x53037d6b // lsr w11, w11, #3 + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x2ea04631 // ushl v17.2s, v17.2s, v0.2s + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d71 // mov v17.s[3], w11 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9c0111 // stur q17, [x8, #-64] + WORD $0x4ddfc951 // ld1r { v17.4s }, [x10], #4 + WORD $0x6ea14631 // ushl v17.4s, v17.4s, v1.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9d0111 // stur q17, [x8, #-48] + WORD $0x4d40c811 // ld1r { v17.4s }, [x0] + WORD $0x6ea24631 // ushl v17.4s, v17.4s, v2.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9e0111 // stur q17, [x8, #-32] + WORD $0x4d40c811 // ld1r { v17.4s }, [x0] + WORD $0x6ea34631 // ushl v17.4s, v17.4s, v3.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9f0111 // stur q17, [x8, #-16] + WORD $0x4d40c811 // ld1r { v17.4s }, [x0] + WORD $0x6ea44631 // ushl v17.4s, v17.4s, v4.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800111 // str q17, [x8] + WORD $0x4d40c811 // ld1r { v17.4s }, [x0] + WORD $0x6ea54631 // ushl v17.4s, v17.4s, v5.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800511 // str q17, [x8, #16] + WORD $0x4d40c811 // ld1r { v17.4s }, [x0] + WORD $0x6ea64631 // ushl v17.4s, v17.4s, v6.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800911 // str q17, [x8, #32] + WORD $0x4d40c811 // ld1r { v17.4s }, [x0] + WORD $0xaa0a03e0 // mov x0, x10 + WORD $0x6eb04631 // ushl v17.4s, v17.4s, v16.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800d11 // str q17, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_21 + JMP LBB0_156 + LBB0_22: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000000d00000006, R1 // LCPI0_59 - MOVD $0x0000000900000002, R2 // LCPI0_61 - MOVD $0x0000001700000010, R3 // LCPI0_63 - MOVD $0x000000130000000c, R4 // LCPI0_65 - MOVD $0x0000000f00000008, R5 // LCPI0_67 - VMOVQ $0x0000000b00000004, $0x0000001900000012, V6 // LCPI0_115 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f0307e0 // movi v0.4s, #127 - WORD $0x2ea0b821 // neg v1.2s, v1.2s - WORD $0x2ea0b842 // neg v2.2s, v2.2s - WORD $0x2ea0b863 // neg v3.2s, v3.2s - WORD $0x2ea0b884 // neg v4.2s, v4.2s - WORD $0x2ea0b8a5 // neg v5.2s, v5.2s - WORD $0x6ea0b8c6 // neg v6.4s, v6.4s -LBB0_24: - WORD $0xb940000a // ldr w10, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53077d4b // lsr w11, w10, #7 - WORD $0x1e270147 // fmov s7, w10 - WORD $0x530e7d4c // lsr w12, w10, #14 - WORD $0x4e0c1d67 // mov v7.s[1], w11 - WORD $0x53157d4d // lsr w13, w10, #21 - WORD $0x4e141d87 // mov v7.s[2], w12 - WORD $0x4e1c1da7 // mov v7.s[3], w13 - WORD $0x4e201cf0 // and v16.16b, v7.16b, v0.16b - WORD $0x3c9c0130 // stur q16, [x9, #-64] - WORD $0xb940040a // ldr w10, [x0, #4] - WORD $0x53037d4b // lsr w11, w10, #3 - WORD $0x530a7d4c // lsr w12, w10, #10 - WORD $0x4e0c1d67 // mov v7.s[1], w11 - WORD $0x53117d4a // lsr w10, w10, #17 - WORD $0x4e141d87 // mov v7.s[2], w12 - WORD $0x4e1c1d47 // mov v7.s[3], w10 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3c9d0127 // stur q7, [x9, #-48] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0x53187d4c // lsr w12, w10, #24 - WORD $0x138a7d6a // extr w10, w11, w10, #31 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x1e270190 // fmov s16, w12 - WORD $0x2ea144e7 // ushl v7.2s, v7.2s, v1.2s - WORD $0x4e0c1d50 // mov v16.s[1], w10 - WORD $0x6e1804f0 // mov v16.d[1], v7.d[0] - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3c9e0127 // stur q7, [x9, #-32] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0x53147d4c // lsr w12, w10, #20 - WORD $0x138a6d6a // extr w10, w11, w10, #27 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x1e270190 // fmov s16, w12 - WORD $0x2ea244e7 // ushl v7.2s, v7.2s, v2.2s - WORD $0x4e0c1d50 // mov v16.s[1], w10 - WORD $0x6e1804f0 // mov v16.d[1], v7.d[0] - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3c9f0127 // stur q7, [x9, #-16] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0x9100600c // add x12, x0, #24 - WORD $0x0e040d47 // dup v7.2s, w10 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x2ea344e7 // ushl v7.2s, v7.2s, v3.2s - WORD $0x53057d6b // lsr w11, w11, #5 - WORD $0x4e141d47 // mov v7.s[2], w10 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3d800127 // str q7, [x9] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0x0e040d47 // dup v7.2s, w10 - WORD $0x138a696a // extr w10, w11, w10, #26 - WORD $0x2ea444e7 // ushl v7.2s, v7.2s, v4.2s - WORD $0x53017d6b // lsr w11, w11, #1 - WORD $0x4e141d47 // mov v7.s[2], w10 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3d800527 // str q7, [x9, #16] - WORD $0x2942ac0a // ldp w10, w11, [x0, #20] - WORD $0x91007000 // add x0, x0, #28 - WORD $0x0e040d47 // dup v7.2s, w10 - WORD $0x53167d4d // lsr w13, w10, #22 - WORD $0x2ea544e7 // ushl v7.2s, v7.2s, v5.2s - WORD $0x138a756a // extr w10, w11, w10, #29 - WORD $0x4e141da7 // mov v7.s[2], w13 - WORD $0x4e1c1d47 // mov v7.s[3], w10 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3d800927 // str q7, [x9, #32] - WORD $0x4d40c987 // ld1r { v7.4s }, [x12] - WORD $0x6ea644e7 // ushl v7.4s, v7.4s, v6.4s - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3d800d27 // str q7, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_24 - JMP LBB0_99 -LBB0_25: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x6f00e620 // movi v0.2d, #0x0000ff000000ff -LBB0_27: - WORD $0xb940000a // ldr w10, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x4e0c1d61 // mov v1.s[1], w11 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x4e141d81 // mov v1.s[2], w12 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9c0121 // stur q1, [x9, #-64] - WORD $0xb940040a // ldr w10, [x0, #4] - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x4e0c1d61 // mov v1.s[1], w11 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x4e141d81 // mov v1.s[2], w12 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9d0121 // stur q1, [x9, #-48] - WORD $0xb940080a // ldr w10, [x0, #8] - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x4e0c1d61 // mov v1.s[1], w11 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x4e141d81 // mov v1.s[2], w12 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9e0121 // stur q1, [x9, #-32] - WORD $0xb9400c0a // ldr w10, [x0, #12] - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x4e0c1d61 // mov v1.s[1], w11 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x4e141d81 // mov v1.s[2], w12 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9f0121 // stur q1, [x9, #-16] - WORD $0xb940100a // ldr w10, [x0, #16] - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x4e0c1d61 // mov v1.s[1], w11 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x4e141d81 // mov v1.s[2], w12 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800121 // str q1, [x9] - WORD $0xb940140a // ldr w10, [x0, #20] - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x4e0c1d61 // mov v1.s[1], w11 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x4e141d81 // mov v1.s[2], w12 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800521 // str q1, [x9, #16] - WORD $0xb940180a // ldr w10, [x0, #24] - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x4e0c1d61 // mov v1.s[1], w11 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x4e141d81 // mov v1.s[2], w12 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800921 // str q1, [x9, #32] - WORD $0xb9401c0a // ldr w10, [x0, #28] - WORD $0x91008000 // add x0, x0, #32 - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x4e0c1d61 // mov v1.s[1], w11 - WORD $0x53187d4d // lsr w13, w10, #24 - WORD $0x4e141d81 // mov v1.s[2], w12 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800d21 // str q1, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_27 - JMP LBB0_99 + WORD $0x71004c7f // cmp w3, #19 + BGT LBB0_48 + + // %bb.23: + WORD $0x7100447f // cmp w3, #17 + BGT LBB0_70 + + // %bb.24: + WORD $0x7100407f // cmp w3, #16 + BEQ LBB0_106 + + // %bb.25: + WORD $0x7100447f // cmp w3, #17 + BNE LBB0_156 + + // %bb.26: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.27: + WORD $0x4f00d420 // movi v0.4s, #1, msl #16 + WORD $0x91010348 // add x8, x26, #64 + WORD $0xaa1303e9 // mov x9, x19 + LBB0_28: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000001100000008, R1 // LCPI0_73 - MOVD $0x000000150000000C, R2 // LCPI0_75 - MOVD $0x0000000b00000002, R3 // LCPI0_77 - MOVD $0x0000000f00000006, R4 // LCPI0_79 - MOVD $0x0000000a00000001, R5 // LCPI0_81 - MOVD $0x0000000e00000005, R6 // LCPI0_83 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00c420 // movi v0.4s, #1, msl #8 - WORD $0x2ea0b821 // neg v1.2s, v1.2s - WORD $0x2ea0b842 // neg v2.2s, v2.2s - WORD $0x2ea0b863 // neg v3.2s, v3.2s - WORD $0x2ea0b884 // neg v4.2s, v4.2s - WORD $0x2ea0b8a5 // neg v5.2s, v5.2s - WORD $0x2ea0b8c6 // neg v6.2s, v6.2s -LBB0_30: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53097d4c // lsr w12, w10, #9 - WORD $0x1e270147 // fmov s7, w10 - WORD $0x53127d4d // lsr w13, w10, #18 - WORD $0x4e0c1d87 // mov v7.s[1], w12 - WORD $0x138a6d6b // extr w11, w11, w10, #27 - WORD $0x4e141da7 // mov v7.s[2], w13 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201cf0 // and v16.16b, v7.16b, v0.16b - WORD $0x3c9c0130 // stur q16, [x9, #-64] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0x530d7d4c // lsr w12, w10, #13 - WORD $0x53167d4d // lsr w13, w10, #22 - WORD $0x4e0c1d87 // mov v7.s[1], w12 - WORD $0x138a7d6a // extr w10, w11, w10, #31 - WORD $0x4e141da7 // mov v7.s[2], w13 - WORD $0x4e1c1d47 // mov v7.s[3], w10 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3c9d0127 // stur q7, [x9, #-48] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0x0e040d47 // dup v7.2s, w10 - WORD $0x138a696a // extr w10, w11, w10, #26 - WORD $0x2ea144e7 // ushl v7.2s, v7.2s, v1.2s - WORD $0x53037d6b // lsr w11, w11, #3 - WORD $0x4e141d47 // mov v7.s[2], w10 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3c9e0127 // stur q7, [x9, #-32] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0x0e040d47 // dup v7.2s, w10 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x2ea244e7 // ushl v7.2s, v7.2s, v2.2s - WORD $0x53077d6b // lsr w11, w11, #7 - WORD $0x4e141d47 // mov v7.s[2], w10 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3c9f0127 // stur q7, [x9, #-16] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x138a656a // extr w10, w11, w10, #25 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x1e270190 // fmov s16, w12 - WORD $0x2ea344e7 // ushl v7.2s, v7.2s, v3.2s - WORD $0x4e0c1d50 // mov v16.s[1], w10 - WORD $0x6e1804f0 // mov v16.d[1], v7.d[0] - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3d800127 // str q7, [x9] - WORD $0x2942ac0a // ldp w10, w11, [x0, #20] - WORD $0x53147d4c // lsr w12, w10, #20 - WORD $0x138a756a // extr w10, w11, w10, #29 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x1e270190 // fmov s16, w12 - WORD $0x2ea444e7 // ushl v7.2s, v7.2s, v4.2s - WORD $0x4e0c1d50 // mov v16.s[1], w10 - WORD $0x6e1804f0 // mov v16.d[1], v7.d[0] - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3d800527 // str q7, [x9, #16] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x2ea544e7 // ushl v7.2s, v7.2s, v5.2s - WORD $0x1e270150 // fmov s16, w10 - WORD $0x6e0c04f0 // mov v16.s[1], v7.s[0] - WORD $0x53137d6b // lsr w11, w11, #19 - WORD $0x6e1424f0 // mov v16.s[2], v7.s[1] - WORD $0x4e1c1d70 // mov v16.s[3], w11 - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3d800927 // str q7, [x9, #32] - WORD $0x2943ac0a // ldp w10, w11, [x0, #28] - WORD $0x91009000 // add x0, x0, #36 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x2ea644e7 // ushl v7.2s, v7.2s, v6.2s - WORD $0x1e270150 // fmov s16, w10 - WORD $0x6e0c04f0 // mov v16.s[1], v7.s[0] - WORD $0x53177d6b // lsr w11, w11, #23 - WORD $0x6e1424f0 // mov v16.s[2], v7.s[1] - WORD $0x4e1c1d70 // mov v16.s[3], w11 - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3d800d27 // str q7, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_30 - JMP LBB0_99 -LBB0_31: - WORD $0x7100805f //cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000000e00000004, R1 // LCPI0_87 - MOVD $0x0000000c00000002, R2 // LCPI0_89 - MOVD $0x0000001200000008, R3 // LCPI0_85 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00c460 // movi v0.4s, #3, msl #8 - WORD $0x2ea0b821 // neg v1.2s, v1.2s - WORD $0x2ea0b842 // neg v2.2s, v2.2s - WORD $0x2ea0b863 // neg v3.2s, v3.2s -LBB0_33: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x530a7d4c // lsr w12, w10, #10 - WORD $0x1e270144 // fmov s4, w10 - WORD $0x53147d4d // lsr w13, w10, #20 - WORD $0x4e0c1d84 // mov v4.s[1], w12 - WORD $0x138a796b // extr w11, w11, w10, #30 - WORD $0x4e141da4 // mov v4.s[2], w13 - WORD $0x4e1c1d64 // mov v4.s[3], w11 - WORD $0x4e201c85 // and v5.16b, v4.16b, v0.16b - WORD $0x3c9c0125 // stur q5, [x9, #-64] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0x53127d4c // lsr w12, w10, #18 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x4e0c1d84 // mov v4.s[1], w12 - WORD $0x53067d6b // lsr w11, w11, #6 - WORD $0x4e141d44 // mov v4.s[2], w10 - WORD $0x4e1c1d64 // mov v4.s[3], w11 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3c9d0124 // stur q4, [x9, #-48] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x138a696a // extr w10, w11, w10, #26 - WORD $0x0e040d64 // dup v4.2s, w11 - WORD $0x1e270185 // fmov s5, w12 - WORD $0x2ea14484 // ushl v4.2s, v4.2s, v1.2s - WORD $0x4e0c1d45 // mov v5.s[1], w10 - WORD $0x6e180485 // mov v5.d[1], v4.d[0] - WORD $0x4e201ca4 // and v4.16b, v5.16b, v0.16b - WORD $0x3c9e0124 // stur q4, [x9, #-32] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x0e040d64 // dup v4.2s, w11 - WORD $0x2ea24484 // ushl v4.2s, v4.2s, v2.2s - WORD $0x1e270145 // fmov s5, w10 - WORD $0x6e0c0485 // mov v5.s[1], v4.s[0] - WORD $0x53167d6b // lsr w11, w11, #22 - WORD $0x6e142485 // mov v5.s[2], v4.s[1] - WORD $0x4e1c1d65 // mov v5.s[3], w11 - WORD $0x4e201ca4 // and v4.16b, v5.16b, v0.16b - WORD $0x3c9f0124 // stur q4, [x9, #-16] - WORD $0x2942ac0a // ldp w10, w11, [x0, #20] - WORD $0x530a7d4c // lsr w12, w10, #10 - WORD $0x1e270144 // fmov s4, w10 - WORD $0x53147d4d // lsr w13, w10, #20 - WORD $0x4e0c1d84 // mov v4.s[1], w12 - WORD $0x138a796b // extr w11, w11, w10, #30 - WORD $0x4e141da4 // mov v4.s[2], w13 - WORD $0x4e1c1d64 // mov v4.s[3], w11 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800124 // str q4, [x9] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0x0e040d44 // dup v4.2s, w10 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x2ea34484 // ushl v4.2s, v4.2s, v3.2s - WORD $0x53067d6b // lsr w11, w11, #6 - WORD $0x4e141d44 // mov v4.s[2], w10 - WORD $0x4e1c1d64 // mov v4.s[3], w11 - WORD $0x4e201c84 // and v4.16b, v4.16b, v0.16b - WORD $0x3d800524 // str q4, [x9, #16] - WORD $0x2943ac0a // ldp w10, w11, [x0, #28] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x138a696a // extr w10, w11, w10, #26 - WORD $0x0e040d64 // dup v4.2s, w11 - WORD $0x1e270185 // fmov s5, w12 - WORD $0x2ea14484 // ushl v4.2s, v4.2s, v1.2s - WORD $0x4e0c1d45 // mov v5.s[1], w10 - WORD $0x6e180485 // mov v5.d[1], v4.d[0] - WORD $0x4e201ca4 // and v4.16b, v5.16b, v0.16b - WORD $0x3d800924 // str q4, [x9, #32] - WORD $0x29442c0a // ldp w10, w11, [x0, #32] - WORD $0x9100a000 // add x0, x0, #40 - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x0e040d64 // dup v4.2s, w11 - WORD $0x2ea24484 // ushl v4.2s, v4.2s, v2.2s - WORD $0x1e270145 // fmov s5, w10 - WORD $0x6e0c0485 // mov v5.s[1], v4.s[0] - WORD $0x53167d6b // lsr w11, w11, #22 - WORD $0x6e142485 // mov v5.s[2], v4.s[1] - WORD $0x4e1c1d65 // mov v5.s[3], w11 - WORD $0x4e201ca4 // and v4.16b, v5.16b, v0.16b - WORD $0x3d800d24 // str q4, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_33 - JMP LBB0_99 -LBB0_34: - WORD $0x7100805f // cmp w2, #32 - BL LBB0_99 - MOVD $0x0000000e00000003, R1 // LCPI0_93 - MOVD $0x0000000f00000004, R2 // LCPI0_95 - MOVD $0x0000001100000006, R3 // LCPI0_97 - MOVD $0x0000001200000007, R4 // LCPI0_99 - MOVD $0x0000001300000008, R5 // LCPI0_101 - MOVD $0x000000150000000a, R6 // LCPI0_114 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00c4e0 // movi v0.4s, #7, msl #8 - WORD $0x2ea0b821 // neg v1.2s, v1.2s - WORD $0x2ea0b842 // neg v2.2s, v2.2s - WORD $0x2ea0b863 // neg v3.2s, v3.2s - WORD $0x2ea0b884 // neg v4.2s, v4.2s - WORD $0x2ea0b8a5 // neg v5.2s, v5.2s - WORD $0x2ea0b8c6 // neg v6.2s, v6.2s + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x138a456c // extr w12, w11, w10, #17 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53027d6a // lsr w10, w11, #2 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0xb940080c // ldr w12, [x0, #8] + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b4d8a // extr w10, w12, w11, #19 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9c0101 // stur q1, [x8, #-64] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x53047d4c // lsr w12, w10, #4 + WORD $0x138a556a // extr w10, w11, w10, #21 + WORD $0x1e270181 // fmov s1, w12 + WORD $0xb940100c // ldr w12, [x0, #16] + WORD $0x4e0c1d41 // mov v1.s[1], w10 + WORD $0x53067d6a // lsr w10, w11, #6 + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b5d8a // extr w10, w12, w11, #23 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9d0101 // stur q1, [x8, #-48] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x53087d4c // lsr w12, w10, #8 + WORD $0x138a656a // extr w10, w11, w10, #25 + WORD $0x1e270181 // fmov s1, w12 + WORD $0xb940180c // ldr w12, [x0, #24] + WORD $0x4e0c1d41 // mov v1.s[1], w10 + WORD $0x530a7d6a // lsr w10, w11, #10 + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b6d8a // extr w10, w12, w11, #27 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9e0101 // stur q1, [x8, #-32] + WORD $0x29432c0a // ldp w10, w11, [x0, #24] + WORD $0x530c7d4c // lsr w12, w10, #12 + WORD $0x138a756a // extr w10, w11, w10, #29 + WORD $0x1e270181 // fmov s1, w12 + WORD $0xb940200c // ldr w12, [x0, #32] + WORD $0x4e0c1d41 // mov v1.s[1], w10 + WORD $0x530e7d6a // lsr w10, w11, #14 + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b7d8a // extr w10, w12, w11, #31 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9f0101 // stur q1, [x8, #-16] + WORD $0x29442c0a // ldp w10, w11, [x0, #32] + WORD $0x138a416a // extr w10, w11, w10, #16 + WORD $0x53017d6c // lsr w12, w11, #1 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940280a // ldr w10, [x0, #40] + WORD $0x138b494b // extr w11, w10, w11, #18 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x53037d4a // lsr w10, w10, #3 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800101 // str q1, [x8] + WORD $0x29452c0a // ldp w10, w11, [x0, #40] + WORD $0x138a516a // extr w10, w11, w10, #20 + WORD $0x53057d6c // lsr w12, w11, #5 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940300a // ldr w10, [x0, #48] + WORD $0x138b594b // extr w11, w10, w11, #22 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x53077d4a // lsr w10, w10, #7 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800501 // str q1, [x8, #16] + WORD $0x29462c0a // ldp w10, w11, [x0, #48] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x53097d6c // lsr w12, w11, #9 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940380a // ldr w10, [x0, #56] + WORD $0x138b694b // extr w11, w10, w11, #26 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x530b7d4a // lsr w10, w10, #11 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800901 // str q1, [x8, #32] + WORD $0x29472c0a // ldp w10, w11, [x0, #56] + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x530d7d6c // lsr w12, w11, #13 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940400a // ldr w10, [x0, #64] + WORD $0x91011000 // add x0, x0, #68 + WORD $0x138b794b // extr w11, w10, w11, #30 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x530f7d4a // lsr w10, w10, #15 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800d01 // str q1, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_28 + JMP LBB0_156 + +LBB0_29: + WORD $0x71002c7f // cmp w3, #11 + BGT LBB0_54 + + // %bb.30: + WORD $0x7100247f // cmp w3, #9 + BGT LBB0_75 + + // %bb.31: + WORD $0x7100207f // cmp w3, #8 + BEQ LBB0_109 + + // %bb.32: + WORD $0x7100247f // cmp w3, #9 + BNE LBB0_156 + + // %bb.33: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.34: + // WORD $0x90000008 // adrp x8, .LCPI0_157 + // WORD $0x90000009 // adrp x9, .LCPI0_158 + // WORD $0x9000000a // adrp x10, .LCPI0_159 + WORD $0x4f00c427 // movi v7.4s, #1, msl #8 + VMOVD LCPI0_157, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_160 + VMOVD LCPI0_158, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_161 + VMOVD LCPI0_159, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_162 + VMOVD LCPI0_160, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_163 + VMOVD LCPI0_161, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_164 + VMOVD LCPI0_162, V5 + VMOVD LCPI0_163, V6 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_164, V16 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_35: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x138a6d6a // extr w10, w11, w10, #27 + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x2ea04631 // ushl v17.2s, v17.2s, v0.2s + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9c0111 // stur q17, [x8, #-64] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x53167d4c // lsr w12, w10, #22 + WORD $0x138a7d6a // extr w10, w11, w10, #31 + WORD $0x2ea14631 // ushl v17.2s, v17.2s, v1.2s + WORD $0x4e141d91 // mov v17.s[2], w12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9d0111 // stur q17, [x8, #-48] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x2ea24631 // ushl v17.2s, v17.2s, v2.2s + WORD $0x4e141d51 // mov v17.s[2], w10 + WORD $0x53037d6a // lsr w10, w11, #3 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9e0111 // stur q17, [x8, #-32] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x2ea34631 // ushl v17.2s, v17.2s, v3.2s + WORD $0x4e141d51 // mov v17.s[2], w10 + WORD $0x53077d6a // lsr w10, w11, #7 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9f0111 // stur q17, [x8, #-16] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x138a656a // extr w10, w11, w10, #25 + WORD $0x1e270192 // fmov s18, w12 + WORD $0x2ea44631 // ushl v17.2s, v17.2s, v4.2s + WORD $0x4e0c1d52 // mov v18.s[1], w10 + WORD $0x6e180632 // mov v18.d[1], v17.d[0] + WORD $0x4e271e51 // and v17.16b, v18.16b, v7.16b + WORD $0x3d800111 // str q17, [x8] + WORD $0x2942ac0a // ldp w10, w11, [x0, #20] + WORD $0x53147d4c // lsr w12, w10, #20 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x138a756a // extr w10, w11, w10, #29 + WORD $0x1e270192 // fmov s18, w12 + WORD $0x2ea54631 // ushl v17.2s, v17.2s, v5.2s + WORD $0x4e0c1d52 // mov v18.s[1], w10 + WORD $0x6e180632 // mov v18.d[1], v17.d[0] + WORD $0x4e271e51 // and v17.16b, v18.16b, v7.16b + WORD $0x3d800511 // str q17, [x8, #16] + WORD $0x29432c0a // ldp w10, w11, [x0, #24] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x53137d6a // lsr w10, w11, #19 + WORD $0x2ea64631 // ushl v17.2s, v17.2s, v6.2s + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800911 // str q17, [x8, #32] + WORD $0x2943ac0a // ldp w10, w11, [x0, #28] + WORD $0x91009000 // add x0, x0, #36 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x53177d6a // lsr w10, w11, #23 + WORD $0x2eb04631 // ushl v17.2s, v17.2s, v16.2s + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800d11 // str q17, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_35 + JMP LBB0_156 + LBB0_36: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x530b7d4c // lsr w12, w10, #11 - WORD $0x1e270147 // fmov s7, w10 - WORD $0x138a596d // extr w13, w11, w10, #22 - WORD $0x4e0c1d87 // mov v7.s[1], w12 - WORD $0x53017d6b // lsr w11, w11, #1 - WORD $0x4e141da7 // mov v7.s[2], w13 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201cf0 // and v16.16b, v7.16b, v0.16b - WORD $0x3c9c0130 // stur q16, [x9, #-64] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0x138a5d6a // extr w10, w11, w10, #23 - WORD $0x53027d6c // lsr w12, w11, #2 - WORD $0x4e0c1d47 // mov v7.s[1], w10 - WORD $0x530d7d6b // lsr w11, w11, #13 - WORD $0x4e141d87 // mov v7.s[2], w12 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3c9d0127 // stur q7, [x9, #-48] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0xb940100c // ldr w12, [x0, #16] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x2ea144e7 // ushl v7.2s, v7.2s, v1.2s - WORD $0x1e270150 // fmov s16, w10 - WORD $0x6e0c04f0 // mov v16.s[1], v7.s[0] - WORD $0x138b658b // extr w11, w12, w11, #25 - WORD $0x6e1424f0 // mov v16.s[2], v7.s[1] - WORD $0x4e1c1d70 // mov v16.s[3], w11 - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3c9e0127 // stur q7, [x9, #-32] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0x0e040d47 // dup v7.2s, w10 - WORD $0x138a696a // extr w10, w11, w10, #26 - WORD $0x2ea244e7 // ushl v7.2s, v7.2s, v2.2s - WORD $0x53057d6b // lsr w11, w11, #5 - WORD $0x4e141d47 // mov v7.s[2], w10 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3c9f0127 // stur q7, [x9, #-16] - WORD $0x2942ac0a // ldp w10, w11, [x0, #20] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x138a6d6a // extr w10, w11, w10, #27 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x1e270190 // fmov s16, w12 - WORD $0x2ea344e7 // ushl v7.2s, v7.2s, v3.2s - WORD $0x4e0c1d50 // mov v16.s[1], w10 - WORD $0x6e1804f0 // mov v16.d[1], v7.d[0] - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3d800127 // str q7, [x9] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0xb940200c // ldr w12, [x0, #32] - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x2ea444e7 // ushl v7.2s, v7.2s, v4.2s - WORD $0x1e270150 // fmov s16, w10 - WORD $0x6e0c04f0 // mov v16.s[1], v7.s[0] - WORD $0x138b758b // extr w11, w12, w11, #29 - WORD $0x6e1424f0 // mov v16.s[2], v7.s[1] - WORD $0x4e1c1d70 // mov v16.s[3], w11 - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3d800527 // str q7, [x9, #16] - WORD $0x29442c0a // ldp w10, w11, [x0, #32] - WORD $0x0e040d47 // dup v7.2s, w10 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x2ea544e7 // ushl v7.2s, v7.2s, v5.2s - WORD $0x53097d6b // lsr w11, w11, #9 - WORD $0x4e141d47 // mov v7.s[2], w10 - WORD $0x4e1c1d67 // mov v7.s[3], w11 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3d800927 // str q7, [x9, #32] - WORD $0x2944ac0a // ldp w10, w11, [x0, #36] - WORD $0x9100b000 // add x0, x0, #44 - WORD $0x53147d4c // lsr w12, w10, #20 - WORD $0x138a7d6a // extr w10, w11, w10, #31 - WORD $0x0e040d67 // dup v7.2s, w11 - WORD $0x1e270190 // fmov s16, w12 - WORD $0x2ea644e7 // ushl v7.2s, v7.2s, v6.2s - WORD $0x4e0c1d50 // mov v16.s[1], w10 - WORD $0x6e1804f0 // mov v16.d[1], v7.d[0] - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3d800d27 // str q7, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_36 - JMP LBB0_99 -LBB0_37: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000000e00000003, R1 // LCPI0_113 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00c5e0 // movi v0.4s, #15, msl #8 - WORD $0x2ea0b821 // neg v1.2s, v1.2s -LBB0_39: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x530c7d4c // lsr w12, w10, #12 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x53047d6b // lsr w11, w11, #4 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c43 // and v3.16b, v2.16b, v0.16b - WORD $0x3c9c0123 // stur q3, [x9, #-64] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x53087d6c // lsr w12, w11, #8 - WORD $0x4e0c1d42 // mov v2.s[1], w10 - WORD $0x53147d6b // lsr w11, w11, #20 - WORD $0x4e141d82 // mov v2.s[2], w12 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9d0122 // stur q2, [x9, #-48] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0x530c7d4c // lsr w12, w10, #12 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x53047d6b // lsr w11, w11, #4 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9e0122 // stur q2, [x9, #-32] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x0e040d62 // dup v2.2s, w11 - WORD $0x1e270183 // fmov s3, w12 - WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s - WORD $0x4e0c1d43 // mov v3.s[1], w10 - WORD $0x6e180443 // mov v3.d[1], v2.d[0] - WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b - WORD $0x3c9f0122 // stur q2, [x9, #-16] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0x530c7d4c // lsr w12, w10, #12 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x53047d6b // lsr w11, w11, #4 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800122 // str q2, [x9] - WORD $0x2943ac0a // ldp w10, w11, [x0, #28] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x0e040d62 // dup v2.2s, w11 - WORD $0x1e270183 // fmov s3, w12 - WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s - WORD $0x4e0c1d43 // mov v3.s[1], w10 - WORD $0x6e180443 // mov v3.d[1], v2.d[0] - WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b - WORD $0x3d800522 // str q2, [x9, #16] - WORD $0x2944ac0a // ldp w10, w11, [x0, #36] - WORD $0x530c7d4c // lsr w12, w10, #12 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x53047d6b // lsr w11, w11, #4 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800922 // str q2, [x9, #32] - WORD $0x29452c0a // ldp w10, w11, [x0, #40] - WORD $0x9100c000 // add x0, x0, #48 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x0e040d62 // dup v2.2s, w11 - WORD $0x1e270183 // fmov s3, w12 - WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s - WORD $0x4e0c1d43 // mov v3.s[1], w10 - WORD $0x6e180443 // mov v3.d[1], v2.d[0] - WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b - WORD $0x3d800d22 // str q2, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_39 - JMP LBB0_99 -LBB0_40: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000000f00000002, R1 // LCPI0_105 - MOVD $0x0000001100000004, R2 // LCPI0_107 - MOVD $0x0000001200000005, R3 // LCPI0_109 - MOVD $0x0000001300000006, R4 // LCPI0_112 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00c7e0 // movi v0.4s, #31, msl #8 - WORD $0x2ea0b821 // neg v1.2s, v1.2s - WORD $0x2ea0b842 // neg v2.2s, v2.2s - WORD $0x2ea0b863 // neg v3.2s, v3.2s - WORD $0x2ea0b884 // neg v4.2s, v4.2s + WORD $0x7100647f // cmp w3, #25 + BGT LBB0_80 + + // %bb.37: + WORD $0x7100607f // cmp w3, #24 + BEQ LBB0_112 + + // %bb.38: + WORD $0x7100647f // cmp w3, #25 + BNE LBB0_156 + + // %bb.39: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.40: + // WORD $0x90000008 // adrp x8, .LCPI0_76 + // WORD $0x90000009 // adrp x9, .LCPI0_77 + // WORD $0x9000000a // adrp x10, .LCPI0_78 + // WORD $0x9000000b // adrp x11, .LCPI0_91 + VMOVD LCPI0_76, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_79 + VMOVD LCPI0_77, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_80 + VMOVD LCPI0_78, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_81 + VMOVD LCPI0_79, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_82 + VMOVD LCPI0_80, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_83 + VMOVD LCPI0_81, V5 + // WORD $0x9000000a // adrp x10, .LCPI0_84 + VMOVD LCPI0_82, V6 + // WORD $0x90000008 // adrp x8, .LCPI0_85 + VMOVD LCPI0_83, V7 + // WORD $0x90000009 // adrp x9, .LCPI0_86 + VMOVD LCPI0_84, V16 + // WORD $0x9000000a // adrp x10, .LCPI0_87 + VMOVD LCPI0_85, V17 + // WORD $0x90000008 // adrp x8, .LCPI0_88 + VMOVD LCPI0_86, V18 + // WORD $0x90000009 // adrp x9, .LCPI0_89 + VMOVD LCPI0_87, V19 + // WORD $0x9000000a // adrp x10, .LCPI0_90 + VMOVD LCPI0_88, V20 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_89, V21 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_90, V22 + VMOVD LCPI0_91, V23 + +LBB0_41: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404018 // ldur d24, [x0, #4] + WORD $0xb9400c0b // ldr w11, [x0, #12] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x1e27015a // fmov s26, w10 + WORD $0x2ea0471b // ushl v27.2s, v24.2s, v0.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x6e1a235a // ext v26.16b, v26.16b, v26.16b, #4 + WORD $0x138a2d6a // extr w10, w11, w10, #11 + WORD $0x2ea14739 // ushl v25.2s, v25.2s, v1.2s + WORD $0x0eb91f79 // orr v25.8b, v27.8b, v25.8b + WORD $0x6e196358 // ext v24.16b, v26.16b, v25.16b, #12 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f0777d8 // bic v24.4s, #254, lsl #24 + WORD $0x3c9c0118 // stur q24, [x8, #-64] + WORD $0xb9400c0a // ldr w10, [x0, #12] + WORD $0xfd400818 // ldr d24, [x0, #16] + WORD $0xb940180b // ldr w11, [x0, #24] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x53047d4a // lsr w10, w10, #4 + WORD $0x2ea2471a // ushl v26.2s, v24.2s, v2.2s + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x1e27015b // fmov s27, w10 + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x6e1b237b // ext v27.16b, v27.16b, v27.16b, #4 + WORD $0x2ea34739 // ushl v25.2s, v25.2s, v3.2s + WORD $0x138a3d6a // extr w10, w11, w10, #15 + WORD $0x0eb91f59 // orr v25.8b, v26.8b, v25.8b + WORD $0x6e196378 // ext v24.16b, v27.16b, v25.16b, #12 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f0777d8 // bic v24.4s, #254, lsl #24 + WORD $0x3c9d0118 // stur q24, [x8, #-48] + WORD $0x2943280b // ldp w11, w10, [x0, #24] + WORD $0xfd401018 // ldr d24, [x0, #32] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x138b214b // extr w11, w10, w11, #8 + WORD $0x53017d4a // lsr w10, w10, #1 + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x2ea44718 // ushl v24.2s, v24.2s, v4.2s + WORD $0x1e27017a // fmov s26, w11 + WORD $0x2ea54739 // ushl v25.2s, v25.2s, v5.2s + WORD $0x4e0c1d5a // mov v26.s[1], w10 + WORD $0x0eb91f18 // orr v24.8b, v24.8b, v25.8b + WORD $0x6e18071a // mov v26.d[1], v24.d[0] + WORD $0x6f0777da // bic v26.4s, #254, lsl #24 + WORD $0x3c9e011a // stur q26, [x8, #-32] + WORD $0x2944a80b // ldp w11, w10, [x0, #36] + WORD $0xfc42c018 // ldur d24, [x0, #44] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x138b314b // extr w11, w10, w11, #12 + WORD $0x53057d4a // lsr w10, w10, #5 + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x2ea64718 // ushl v24.2s, v24.2s, v6.2s + WORD $0x1e27017a // fmov s26, w11 + WORD $0x2ea74739 // ushl v25.2s, v25.2s, v7.2s + WORD $0x4e0c1d5a // mov v26.s[1], w10 + WORD $0x0eb91f18 // orr v24.8b, v24.8b, v25.8b + WORD $0x6e18071a // mov v26.d[1], v24.d[0] + WORD $0x6f0777da // bic v26.4s, #254, lsl #24 + WORD $0x3c9f011a // stur q26, [x8, #-16] + WORD $0xfc434018 // ldur d24, [x0, #52] + WORD $0xbd403019 // ldr s25, [x0, #48] + WORD $0xb9403c0c // ldr w12, [x0, #60] + WORD $0x2eb0471a // ushl v26.2s, v24.2s, v16.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x53027d4b // lsr w11, w10, #2 + WORD $0x138a6d8a // extr w10, w12, w10, #27 + WORD $0x2eb14739 // ushl v25.2s, v25.2s, v17.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d78 // mov v24.s[2], w11 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f0777d8 // bic v24.4s, #254, lsl #24 + WORD $0x3d800118 // str q24, [x8] + WORD $0xfd402018 // ldr d24, [x0, #64] + WORD $0xbd403c19 // ldr s25, [x0, #60] + WORD $0xb940480c // ldr w12, [x0, #72] + WORD $0x2eb2471a // ushl v26.2s, v24.2s, v18.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x53067d4b // lsr w11, w10, #6 + WORD $0x138a7d8a // extr w10, w12, w10, #31 + WORD $0x2eb34739 // ushl v25.2s, v25.2s, v19.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d78 // mov v24.s[2], w11 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f0777d8 // bic v24.4s, #254, lsl #24 + WORD $0x3d800518 // str q24, [x8, #16] + WORD $0xfc44c018 // ldur d24, [x0, #76] + WORD $0xbd404819 // ldr s25, [x0, #72] + WORD $0xb940540b // ldr w11, [x0, #84] + WORD $0x2eb4471a // ushl v26.2s, v24.2s, v20.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x138a296a // extr w10, w11, w10, #10 + WORD $0x2eb54739 // ushl v25.2s, v25.2s, v21.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d58 // mov v24.s[2], w10 + WORD $0x53037d6a // lsr w10, w11, #3 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f0777d8 // bic v24.4s, #254, lsl #24 + WORD $0x3d800918 // str q24, [x8, #32] + WORD $0xfd402c18 // ldr d24, [x0, #88] + WORD $0xbd405419 // ldr s25, [x0, #84] + WORD $0xb940600b // ldr w11, [x0, #96] + WORD $0x91019000 // add x0, x0, #100 + WORD $0x2eb6471a // ushl v26.2s, v24.2s, v22.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x138a396a // extr w10, w11, w10, #14 + WORD $0x2eb74739 // ushl v25.2s, v25.2s, v23.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d58 // mov v24.s[2], w10 + WORD $0x53077d6a // lsr w10, w11, #7 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f0777d8 // bic v24.4s, #254, lsl #24 + WORD $0x3d800d18 // str q24, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_41 + JMP LBB0_156 + LBB0_42: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x530d7d4c // lsr w12, w10, #13 - WORD $0x1e270145 // fmov s5, w10 - WORD $0x138a696d // extr w13, w11, w10, #26 - WORD $0x4e0c1d85 // mov v5.s[1], w12 - WORD $0x53077d6b // lsr w11, w11, #7 - WORD $0x4e141da5 // mov v5.s[2], w13 - WORD $0x4e1c1d65 // mov v5.s[3], w11 - WORD $0x4e201ca6 // and v6.16b, v5.16b, v0.16b - WORD $0x3c9c0126 // stur q6, [x9, #-64] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0x53017d4c // lsr w12, w10, #1 - WORD $0x530e7d4d // lsr w13, w10, #14 - WORD $0x4e0c1d85 // mov v5.s[1], w12 - WORD $0x138a6d6a // extr w10, w11, w10, #27 - WORD $0x4e141da5 // mov v5.s[2], w13 - WORD $0x4e1c1d45 // mov v5.s[3], w10 - WORD $0x4e201ca5 // and v5.16b, v5.16b, v0.16b - WORD $0x3c9d0125 // stur q5, [x9, #-48] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0x53087d4c // lsr w12, w10, #8 - WORD $0x138a556a // extr w10, w11, w10, #21 - WORD $0x0e040d65 // dup v5.2s, w11 - WORD $0x1e270186 // fmov s6, w12 - WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s - WORD $0x4e0c1d46 // mov v6.s[1], w10 - WORD $0x6e1804a6 // mov v6.d[1], v5.d[0] - WORD $0x4e201cc5 // and v5.16b, v6.16b, v0.16b - WORD $0x3c9e0125 // stur q5, [x9, #-32] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0xb940180c // ldr w12, [x0, #24] - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x53097d6d // lsr w13, w11, #9 - WORD $0x1e270145 // fmov s5, w10 - WORD $0x138b598b // extr w11, w12, w11, #22 - WORD $0x4e0c1da5 // mov v5.s[1], w13 - WORD $0x53037d8c // lsr w12, w12, #3 - WORD $0x4e141d65 // mov v5.s[2], w11 - WORD $0x4e1c1d85 // mov v5.s[3], w12 - WORD $0x4e201ca5 // and v5.16b, v5.16b, v0.16b - WORD $0x3c9f0125 // stur q5, [x9, #-16] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0xb940200c // ldr w12, [x0, #32] - WORD $0x53107d4d // lsr w13, w10, #16 - WORD $0x138a756a // extr w10, w11, w10, #29 - WORD $0x1e2701a5 // fmov s5, w13 - WORD $0x530a7d6e // lsr w14, w11, #10 - WORD $0x4e0c1d45 // mov v5.s[1], w10 - WORD $0x138b5d8b // extr w11, w12, w11, #23 - WORD $0x4e141dc5 // mov v5.s[2], w14 - WORD $0x4e1c1d65 // mov v5.s[3], w11 - WORD $0x4e201ca5 // and v5.16b, v5.16b, v0.16b - WORD $0x3d800125 // str q5, [x9] - WORD $0x29442c0a // ldp w10, w11, [x0, #32] - WORD $0x0e040d45 // dup v5.2s, w10 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x2ea244a5 // ushl v5.2s, v5.2s, v2.2s - WORD $0x530b7d6b // lsr w11, w11, #11 - WORD $0x4e141d45 // mov v5.s[2], w10 - WORD $0x4e1c1d65 // mov v5.s[3], w11 - WORD $0x4e201ca5 // and v5.16b, v5.16b, v0.16b - WORD $0x3d800525 // str q5, [x9, #16] - WORD $0x2944ac0a // ldp w10, w11, [x0, #36] - WORD $0xb9402c0c // ldr w12, [x0, #44] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x0e040d65 // dup v5.2s, w11 - WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s - WORD $0x1e270146 // fmov s6, w10 - WORD $0x6e0c04a6 // mov v6.s[1], v5.s[0] - WORD $0x138b7d8b // extr w11, w12, w11, #31 - WORD $0x6e1424a6 // mov v6.s[2], v5.s[1] - WORD $0x4e1c1d66 // mov v6.s[3], w11 - WORD $0x4e201cc5 // and v5.16b, v6.16b, v0.16b - WORD $0x3d800925 // str q5, [x9, #32] - WORD $0x2945ac0a // ldp w10, w11, [x0, #44] - WORD $0x9100d000 // add x0, x0, #52 - WORD $0x530c7d4c // lsr w12, w10, #12 - WORD $0x138a656a // extr w10, w11, w10, #25 - WORD $0x0e040d65 // dup v5.2s, w11 - WORD $0x1e270186 // fmov s6, w12 - WORD $0x2ea444a5 // ushl v5.2s, v5.2s, v4.2s - WORD $0x4e0c1d46 // mov v6.s[1], w10 - WORD $0x6e1804a6 // mov v6.d[1], v5.d[0] - WORD $0x4e201cc5 // and v5.16b, v6.16b, v0.16b - WORD $0x3d800d25 // str q5, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_42 - JMP LBB0_99 -LBB0_43: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000001200000004, R1 // LCPI0_111 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f01c7e0 // movi v0.4s, #63, msl #8 - WORD $0x2ea0b821 // neg v1.2s, v1.2s -LBB0_45: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x530e7d4c // lsr w12, w10, #14 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138a716d // extr w13, w11, w10, #28 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x530a7d6b // lsr w11, w11, #10 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9c0122 // stur q2, [x9, #-64] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0xb9400c0c // ldr w12, [x0, #12] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x53067d6d // lsr w13, w11, #6 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b518b // extr w11, w12, w11, #20 - WORD $0x4e0c1da2 // mov v2.s[1], w13 - WORD $0x53027d8c // lsr w12, w12, #2 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9d0122 // stur q2, [x9, #-48] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0xb940140c // ldr w12, [x0, #20] - WORD $0x53107d4d // lsr w13, w10, #16 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x1e2701a2 // fmov s2, w13 - WORD $0x530c7d6e // lsr w14, w11, #12 - WORD $0x4e0c1d42 // mov v2.s[1], w10 - WORD $0x138b698b // extr w11, w12, w11, #26 - WORD $0x4e141dc2 // mov v2.s[2], w14 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9e0122 // stur q2, [x9, #-32] - WORD $0x2942ac0a // ldp w10, w11, [x0, #20] - WORD $0x53087d4c // lsr w12, w10, #8 - WORD $0x138a596a // extr w10, w11, w10, #22 - WORD $0x0e040d62 // dup v2.2s, w11 - WORD $0x1e270183 // fmov s3, w12 - WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s - WORD $0x4e0c1d43 // mov v3.s[1], w10 - WORD $0x6e180443 // mov v3.d[1], v2.d[0] - WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b - WORD $0x3c9f0122 // stur q2, [x9, #-16] - WORD $0x2943ac0a // ldp w10, w11, [x0, #28] - WORD $0x530e7d4c // lsr w12, w10, #14 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138a716d // extr w13, w11, w10, #28 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x530a7d6b // lsr w11, w11, #10 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800122 // str q2, [x9] - WORD $0x29442c0a // ldp w10, w11, [x0, #32] - WORD $0xb940280c // ldr w12, [x0, #40] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x53067d6d // lsr w13, w11, #6 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b518b // extr w11, w12, w11, #20 - WORD $0x4e0c1da2 // mov v2.s[1], w13 - WORD $0x53027d8c // lsr w12, w12, #2 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800522 // str q2, [x9, #16] - WORD $0x29452c0a // ldp w10, w11, [x0, #40] - WORD $0xb940300c // ldr w12, [x0, #48] - WORD $0x53107d4d // lsr w13, w10, #16 - WORD $0x138a796a // extr w10, w11, w10, #30 - WORD $0x1e2701a2 // fmov s2, w13 - WORD $0x530c7d6e // lsr w14, w11, #12 - WORD $0x4e0c1d42 // mov v2.s[1], w10 - WORD $0x138b698b // extr w11, w12, w11, #26 - WORD $0x4e141dc2 // mov v2.s[2], w14 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800922 // str q2, [x9, #32] - WORD $0x29462c0a // ldp w10, w11, [x0, #48] - WORD $0x9100e000 // add x0, x0, #56 - WORD $0x53087d4c // lsr w12, w10, #8 - WORD $0x138a596a // extr w10, w11, w10, #22 - WORD $0x0e040d62 // dup v2.2s, w11 - WORD $0x1e270183 // fmov s3, w12 - WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s - WORD $0x4e0c1d43 // mov v3.s[1], w10 - WORD $0x6e180443 // mov v3.d[1], v2.d[0] - WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b - WORD $0x3d800d22 // str q2, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_45 - JMP LBB0_99 -LBB0_46: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000001100000002, R1 // LCPI0_110 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f03c7e0 // movi v0.4s, #127, msl #8 - WORD $0x2ea0b821 // neg v1.2s, v1.2s + WORD $0x7100147f // cmp w3, #5 + BGT LBB0_85 + + // %bb.43: + WORD $0x7100107f // cmp w3, #4 + BEQ LBB0_115 + + // %bb.44: + WORD $0x7100147f // cmp w3, #5 + BNE LBB0_156 + + // %bb.45: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.46: + // WORD $0x90000008 // adrp x8, .LCPI0_178 + // WORD $0x90000009 // adrp x9, .LCPI0_179 + // WORD $0x9000000a // adrp x10, .LCPI0_180 + WORD $0x4f0007e7 // movi v7.4s, #31 + VMOVD LCPI0_178, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_181 + VMOVD LCPI0_179, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_182 + VMOVQ LCPI0_180L, LCPI0_180H, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_183 + VMOVD LCPI0_181, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_184 + VMOVD LCPI0_182, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_185 + VMOVQ LCPI0_183L, LCPI0_183H, V5 + VMOVD LCPI0_184, V6 + WORD $0x91010348 // add x8, x26, #64 + VMOVQ LCPI0_185L, LCPI0_185H, V16 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_47: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x530f7d4a // lsr w10, w10, #15 + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x2ea04631 // ushl v17.2s, v17.2s, v0.2s + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9c0111 // stur q17, [x8, #-64] + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x2ea14631 // ushl v17.2s, v17.2s, v1.2s + WORD $0x4e141d51 // mov v17.s[2], w10 + WORD $0x53037d6a // lsr w10, w11, #3 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x9100100a // add x10, x0, #4 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9d0111 // stur q17, [x8, #-48] + WORD $0x4d40c951 // ld1r { v17.4s }, [x10] + WORD $0x6ea24631 // ushl v17.4s, v17.4s, v2.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9e0111 // stur q17, [x8, #-32] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x530b7d6a // lsr w10, w11, #11 + WORD $0x2ea34631 // ushl v17.2s, v17.2s, v3.2s + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9f0111 // stur q17, [x8, #-16] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x531a7d4c // lsr w12, w10, #26 + WORD $0x138a7d6a // extr w10, w11, w10, #31 + WORD $0x2ea44631 // ushl v17.2s, v17.2s, v4.2s + WORD $0x4e141d91 // mov v17.s[2], w12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x9100300a // add x10, x0, #12 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800111 // str q17, [x8] + WORD $0x4d40c951 // ld1r { v17.4s }, [x10] + WORD $0x6ea54631 // ushl v17.4s, v17.4s, v5.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800511 // str q17, [x8, #16] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x53187d4c // lsr w12, w10, #24 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x138a756a // extr w10, w11, w10, #29 + WORD $0x1e270192 // fmov s18, w12 + WORD $0x2ea64631 // ushl v17.2s, v17.2s, v6.2s + WORD $0x4e0c1d52 // mov v18.s[1], w10 + WORD $0x9100400a // add x10, x0, #16 + WORD $0x91005000 // add x0, x0, #20 + WORD $0x6e180632 // mov v18.d[1], v17.d[0] + WORD $0x4e271e51 // and v17.16b, v18.16b, v7.16b + WORD $0x3d800911 // str q17, [x8, #32] + WORD $0x4d40c951 // ld1r { v17.4s }, [x10] + WORD $0x6eb04631 // ushl v17.4s, v17.4s, v16.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800d11 // str q17, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_47 + JMP LBB0_156 + LBB0_48: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x530f7d4c // lsr w12, w10, #15 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138a796d // extr w13, w11, w10, #30 - WORD $0x4e0c1d82 // mov v2.s[1], w12 - WORD $0x530d7d6b // lsr w11, w11, #13 - WORD $0x4e141da2 // mov v2.s[2], w13 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9c0122 // stur q2, [x9, #-64] - WORD $0x2940ac0a // ldp w10, w11, [x0, #4] - WORD $0xb9400c0c // ldr w12, [x0, #12] - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x530b7d6d // lsr w13, w11, #11 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b698b // extr w11, w12, w11, #26 - WORD $0x4e0c1da2 // mov v2.s[1], w13 - WORD $0x53097d8c // lsr w12, w12, #9 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9d0122 // stur q2, [x9, #-48] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0xb940140c // ldr w12, [x0, #20] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x53077d6d // lsr w13, w11, #7 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b598b // extr w11, w12, w11, #22 - WORD $0x4e0c1da2 // mov v2.s[1], w13 - WORD $0x53057d8c // lsr w12, w12, #5 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9e0122 // stur q2, [x9, #-32] - WORD $0x2942ac0a // ldp w10, w11, [x0, #20] - WORD $0xb9401c0c // ldr w12, [x0, #28] - WORD $0x138a516a // extr w10, w11, w10, #20 - WORD $0x53037d6d // lsr w13, w11, #3 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b498b // extr w11, w12, w11, #18 - WORD $0x4e0c1da2 // mov v2.s[1], w13 - WORD $0x53017d8c // lsr w12, w12, #1 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3c9f0122 // stur q2, [x9, #-16] - WORD $0x2943ac0a // ldp w10, w11, [x0, #28] - WORD $0xb940240c // ldr w12, [x0, #36] - WORD $0x53107d4d // lsr w13, w10, #16 - WORD $0x138a7d6a // extr w10, w11, w10, #31 - WORD $0x1e2701a2 // fmov s2, w13 - WORD $0x530e7d6e // lsr w14, w11, #14 - WORD $0x4e0c1d42 // mov v2.s[1], w10 - WORD $0x138b758b // extr w11, w12, w11, #29 - WORD $0x4e141dc2 // mov v2.s[2], w14 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800122 // str q2, [x9] - WORD $0x2944ac0a // ldp w10, w11, [x0, #36] - WORD $0xb9402c0c // ldr w12, [x0, #44] - WORD $0x530c7d4d // lsr w13, w10, #12 - WORD $0x138a6d6a // extr w10, w11, w10, #27 - WORD $0x1e2701a2 // fmov s2, w13 - WORD $0x530a7d6e // lsr w14, w11, #10 - WORD $0x4e0c1d42 // mov v2.s[1], w10 - WORD $0x138b658b // extr w11, w12, w11, #25 - WORD $0x4e141dc2 // mov v2.s[2], w14 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800522 // str q2, [x9, #16] - WORD $0x2945ac0a // ldp w10, w11, [x0, #44] - WORD $0xb940340c // ldr w12, [x0, #52] - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x138a5d6a // extr w10, w11, w10, #23 - WORD $0x1e2701a2 // fmov s2, w13 - WORD $0x53067d6e // lsr w14, w11, #6 - WORD $0x4e0c1d42 // mov v2.s[1], w10 - WORD $0x138b558b // extr w11, w12, w11, #21 - WORD $0x4e141dc2 // mov v2.s[2], w14 - WORD $0x4e1c1d62 // mov v2.s[3], w11 - WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b - WORD $0x3d800922 // str q2, [x9, #32] - WORD $0x2946ac0a // ldp w10, w11, [x0, #52] - WORD $0x9100f000 // add x0, x0, #60 - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x138a4d6a // extr w10, w11, w10, #19 - WORD $0x0e040d62 // dup v2.2s, w11 - WORD $0x1e270183 // fmov s3, w12 - WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s - WORD $0x4e0c1d43 // mov v3.s[1], w10 - WORD $0x6e180443 // mov v3.d[1], v2.d[0] - WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b - WORD $0x3d800d22 // str q2, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_48 - JMP LBB0_99 -LBB0_49: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x6f01e660 // movi v0.2d, #0x00ffff0000ffff -LBB0_51: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x4e0c1d81 // mov v1.s[1], w12 - WORD $0x53107d6d // lsr w13, w11, #16 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9c0121 // stur q1, [x9, #-64] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x4e0c1d81 // mov v1.s[1], w12 - WORD $0x53107d6d // lsr w13, w11, #16 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9d0121 // stur q1, [x9, #-48] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x4e0c1d81 // mov v1.s[1], w12 - WORD $0x53107d6d // lsr w13, w11, #16 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9e0121 // stur q1, [x9, #-32] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x4e0c1d81 // mov v1.s[1], w12 - WORD $0x53107d6d // lsr w13, w11, #16 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9f0121 // stur q1, [x9, #-16] - WORD $0x29442c0a // ldp w10, w11, [x0, #32] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x4e0c1d81 // mov v1.s[1], w12 - WORD $0x53107d6d // lsr w13, w11, #16 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800121 // str q1, [x9] - WORD $0x29452c0a // ldp w10, w11, [x0, #40] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x4e0c1d81 // mov v1.s[1], w12 - WORD $0x53107d6d // lsr w13, w11, #16 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800521 // str q1, [x9, #16] - WORD $0x29462c0a // ldp w10, w11, [x0, #48] - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x4e0c1d81 // mov v1.s[1], w12 - WORD $0x53107d6d // lsr w13, w11, #16 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800921 // str q1, [x9, #32] - WORD $0x29472c0a // ldp w10, w11, [x0, #56] - WORD $0x91010000 // add x0, x0, #64 - WORD $0x53107d4c // lsr w12, w10, #16 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x4e0c1d81 // mov v1.s[1], w12 - WORD $0x53107d6d // lsr w13, w11, #16 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1da1 // mov v1.s[3], w13 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800d21 // str q1, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_51 - JMP LBB0_99 -LBB0_52: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00d420 // movi v0.4s, #1, msl #16 + WORD $0x7100547f // cmp w3, #21 + BGT LBB0_90 + + // %bb.49: + WORD $0x7100507f // cmp w3, #20 + BEQ LBB0_118 + + // %bb.50: + WORD $0x7100547f // cmp w3, #21 + BNE LBB0_156 + + // %bb.51: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.52: + // WORD $0x90000008 // adrp x8, .LCPI0_118 + // WORD $0x90000009 // adrp x9, .LCPI0_119 + // WORD $0x9000000a // adrp x10, .LCPI0_120 + WORD $0x4f00d7f3 // movi v19.4s, #31, msl #16 + VMOVD LCPI0_118, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_121 + VMOVD LCPI0_119, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_122 + VMOVD LCPI0_120, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_123 + VMOVD LCPI0_121, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_124 + VMOVD LCPI0_122, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_125 + VMOVD LCPI0_123, V5 + // WORD $0x9000000a // adrp x10, .LCPI0_126 + VMOVD LCPI0_124, V6 + // WORD $0x90000008 // adrp x8, .LCPI0_127 + VMOVD LCPI0_125, V7 + // WORD $0x90000009 // adrp x9, .LCPI0_128 + VMOVD LCPI0_126, V16 + // WORD $0x9000000a // adrp x10, .LCPI0_129 + VMOVD LCPI0_127, V17 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_128, V18 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_129, V20 + +LBB0_53: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x138a556c // extr w12, w11, w10, #21 + WORD $0x1e270155 // fmov s21, w10 + WORD $0x530a7d6a // lsr w10, w11, #10 + WORD $0x4e0c1d95 // mov v21.s[1], w12 + WORD $0xb940080c // ldr w12, [x0, #8] + WORD $0x4e141d55 // mov v21.s[2], w10 + WORD $0x138b7d8a // extr w10, w12, w11, #31 + WORD $0x4e1c1d55 // mov v21.s[3], w10 + WORD $0x4e331eb5 // and v21.16b, v21.16b, v19.16b + WORD $0x3c9c0115 // stur q21, [x8, #-64] + WORD $0x2941280b // ldp w11, w10, [x0, #8] + WORD $0xfd400815 // ldr d21, [x0, #16] + WORD $0x1e270156 // fmov s22, w10 + WORD $0x138b514b // extr w11, w10, w11, #20 + WORD $0x53097d4a // lsr w10, w10, #9 + WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s + WORD $0x2ea046b5 // ushl v21.2s, v21.2s, v0.2s + WORD $0x1e270177 // fmov s23, w11 + WORD $0x2ea146d6 // ushl v22.2s, v22.2s, v1.2s + WORD $0x4e0c1d57 // mov v23.s[1], w10 + WORD $0x0eb61eb5 // orr v21.8b, v21.8b, v22.8b + WORD $0x6e1806b7 // mov v23.d[1], v21.d[0] + WORD $0x4e331ef5 // and v21.16b, v23.16b, v19.16b + WORD $0x3c9d0115 // stur q21, [x8, #-48] + WORD $0xb940140a // ldr w10, [x0, #20] + WORD $0xfd400c15 // ldr d21, [x0, #24] + WORD $0x1e270156 // fmov s22, w10 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea246b7 // ushl v23.2s, v21.2s, v2.2s + WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s + WORD $0x1e270158 // fmov s24, w10 + WORD $0x0e0c3eaa // mov w10, v21.s[1] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x2ea346d6 // ushl v22.2s, v22.2s, v3.2s + WORD $0x53077d4a // lsr w10, w10, #7 + WORD $0x0eb61ef6 // orr v22.8b, v23.8b, v22.8b + WORD $0x6e166315 // ext v21.16b, v24.16b, v22.16b, #12 + WORD $0x4e1c1d55 // mov v21.s[3], w10 + WORD $0x4e331eb5 // and v21.16b, v21.16b, v19.16b + WORD $0x3c9e0115 // stur q21, [x8, #-32] + WORD $0xfd401015 // ldr d21, [x0, #32] + WORD $0xbd401c16 // ldr s22, [x0, #28] + WORD $0xb940280c // ldr w12, [x0, #40] + WORD $0x2ea446b7 // ushl v23.2s, v21.2s, v4.2s + WORD $0x0e0c3eaa // mov w10, v21.s[1] + WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s + WORD $0x53067d4b // lsr w11, w10, #6 + WORD $0x138a6d8a // extr w10, w12, w10, #27 + WORD $0x2ea546d6 // ushl v22.2s, v22.2s, v5.2s + WORD $0x0eb61ef5 // orr v21.8b, v23.8b, v22.8b + WORD $0x4e141d75 // mov v21.s[2], w11 + WORD $0x4e1c1d55 // mov v21.s[3], w10 + WORD $0x4e331eb5 // and v21.16b, v21.16b, v19.16b + WORD $0x3c9f0115 // stur q21, [x8, #-16] + WORD $0x2945280b // ldp w11, w10, [x0, #40] + WORD $0xfd401815 // ldr d21, [x0, #48] + WORD $0x1e270156 // fmov s22, w10 + WORD $0x138b414b // extr w11, w10, w11, #16 + WORD $0x53057d4a // lsr w10, w10, #5 + WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s + WORD $0x2ea646b5 // ushl v21.2s, v21.2s, v6.2s + WORD $0x1e270177 // fmov s23, w11 + WORD $0x2ea746d6 // ushl v22.2s, v22.2s, v7.2s + WORD $0x4e0c1d57 // mov v23.s[1], w10 + WORD $0x0eb61eb5 // orr v21.8b, v21.8b, v22.8b + WORD $0x6e1806b7 // mov v23.d[1], v21.d[0] + WORD $0x4e331ef5 // and v21.16b, v23.16b, v19.16b + WORD $0x3d800115 // str q21, [x8] + WORD $0xb940340a // ldr w10, [x0, #52] + WORD $0xfd401c15 // ldr d21, [x0, #56] + WORD $0x1e270156 // fmov s22, w10 + WORD $0x53047d4a // lsr w10, w10, #4 + WORD $0x2eb046b7 // ushl v23.2s, v21.2s, v16.2s + WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s + WORD $0x1e270158 // fmov s24, w10 + WORD $0x0e0c3eaa // mov w10, v21.s[1] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x2eb146d6 // ushl v22.2s, v22.2s, v17.2s + WORD $0x53037d4a // lsr w10, w10, #3 + WORD $0x0eb61ef6 // orr v22.8b, v23.8b, v22.8b + WORD $0x6e166315 // ext v21.16b, v24.16b, v22.16b, #12 + WORD $0x4e1c1d55 // mov v21.s[3], w10 + WORD $0x4e331eb5 // and v21.16b, v21.16b, v19.16b + WORD $0x3d800515 // str q21, [x8, #16] + WORD $0xfd402015 // ldr d21, [x0, #64] + WORD $0xbd403c16 // ldr s22, [x0, #60] + WORD $0xb940480c // ldr w12, [x0, #72] + WORD $0x2eb246b7 // ushl v23.2s, v21.2s, v18.2s + WORD $0x0e0c3eaa // mov w10, v21.s[1] + WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s + WORD $0x53027d4b // lsr w11, w10, #2 + WORD $0x138a5d8a // extr w10, w12, w10, #23 + WORD $0x2eb446d6 // ushl v22.2s, v22.2s, v20.2s + WORD $0x0eb61ef5 // orr v21.8b, v23.8b, v22.8b + WORD $0x4e141d75 // mov v21.s[2], w11 + WORD $0x4e1c1d55 // mov v21.s[3], w10 + WORD $0x4e331eb5 // and v21.16b, v21.16b, v19.16b + WORD $0x3d800915 // str q21, [x8, #32] + WORD $0x29492c0a // ldp w10, w11, [x0, #72] + WORD $0x138a316a // extr w10, w11, w10, #12 + WORD $0x53017d6c // lsr w12, w11, #1 + WORD $0x1e270155 // fmov s21, w10 + WORD $0xb940500a // ldr w10, [x0, #80] + WORD $0x91015000 // add x0, x0, #84 + WORD $0x138b594b // extr w11, w10, w11, #22 + WORD $0x4e0c1d95 // mov v21.s[1], w12 + WORD $0x530b7d4a // lsr w10, w10, #11 + WORD $0x4e141d75 // mov v21.s[2], w11 + WORD $0x4e1c1d55 // mov v21.s[3], w10 + WORD $0x4e331eb5 // and v21.16b, v21.16b, v19.16b + WORD $0x3d800d15 // str q21, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_53 + JMP LBB0_156 + LBB0_54: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xb940080c // ldr w12, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a456d // extr w13, w11, w10, #17 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53027d6e // lsr w14, w11, #2 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x138b4d8b // extr w11, w12, w11, #19 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9c0121 // stur q1, [x9, #-64] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0xb940100c // ldr w12, [x0, #16] - WORD $0x53047d4d // lsr w13, w10, #4 - WORD $0x138a556a // extr w10, w11, w10, #21 - WORD $0x1e2701a1 // fmov s1, w13 - WORD $0x53067d6e // lsr w14, w11, #6 - WORD $0x4e0c1d41 // mov v1.s[1], w10 - WORD $0x138b5d8b // extr w11, w12, w11, #23 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9d0121 // stur q1, [x9, #-48] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0xb940180c // ldr w12, [x0, #24] - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x138a656a // extr w10, w11, w10, #25 - WORD $0x1e2701a1 // fmov s1, w13 - WORD $0x530a7d6e // lsr w14, w11, #10 - WORD $0x4e0c1d41 // mov v1.s[1], w10 - WORD $0x138b6d8b // extr w11, w12, w11, #27 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9e0121 // stur q1, [x9, #-32] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0xb940200c // ldr w12, [x0, #32] - WORD $0x530c7d4d // lsr w13, w10, #12 - WORD $0x138a756a // extr w10, w11, w10, #29 - WORD $0x1e2701a1 // fmov s1, w13 - WORD $0x530e7d6e // lsr w14, w11, #14 - WORD $0x4e0c1d41 // mov v1.s[1], w10 - WORD $0x138b7d8b // extr w11, w12, w11, #31 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9f0121 // stur q1, [x9, #-16] - WORD $0x29442c0a // ldp w10, w11, [x0, #32] - WORD $0xb940280c // ldr w12, [x0, #40] - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x53017d6d // lsr w13, w11, #1 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b498b // extr w11, w12, w11, #18 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x53037d8c // lsr w12, w12, #3 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800121 // str q1, [x9] - WORD $0x29452c0a // ldp w10, w11, [x0, #40] - WORD $0xb940300c // ldr w12, [x0, #48] - WORD $0x138a516a // extr w10, w11, w10, #20 - WORD $0x53057d6d // lsr w13, w11, #5 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b598b // extr w11, w12, w11, #22 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x53077d8c // lsr w12, w12, #7 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800521 // str q1, [x9, #16] - WORD $0x29462c0a // ldp w10, w11, [x0, #48] - WORD $0xb940380c // ldr w12, [x0, #56] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x53097d6d // lsr w13, w11, #9 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b698b // extr w11, w12, w11, #26 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x530b7d8c // lsr w12, w12, #11 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800921 // str q1, [x9, #32] - WORD $0x29472c0a // ldp w10, w11, [x0, #56] - WORD $0xb940400c // ldr w12, [x0, #64] - WORD $0x91011000 // add x0, x0, #68 - WORD $0x138a716a // extr w10, w11, w10, #28 - WORD $0x530d7d6d // lsr w13, w11, #13 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b798b // extr w11, w12, w11, #30 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x530f7d8c // lsr w12, w12, #15 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800d21 // str q1, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_54 - JMP LBB0_99 -LBB0_55: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00d460 // movi v0.4s, #3, msl #16 -LBB0_57: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xb940080c // ldr w12, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a496d // extr w13, w11, w10, #18 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53047d6e // lsr w14, w11, #4 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x138b598b // extr w11, w12, w11, #22 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9c0121 // stur q1, [x9, #-64] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0xb940100c // ldr w12, [x0, #16] - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x138a696a // extr w10, w11, w10, #26 - WORD $0x1e2701a1 // fmov s1, w13 - WORD $0x530c7d6e // lsr w14, w11, #12 - WORD $0x4e0c1d41 // mov v1.s[1], w10 - WORD $0x138b798b // extr w11, w12, w11, #30 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9d0121 // stur q1, [x9, #-48] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0xb940180c // ldr w12, [x0, #24] - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x53027d6d // lsr w13, w11, #2 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b518b // extr w11, w12, w11, #20 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x53067d8c // lsr w12, w12, #6 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9e0121 // stur q1, [x9, #-32] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0xb940200c // ldr w12, [x0, #32] - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x530a7d6d // lsr w13, w11, #10 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b718b // extr w11, w12, w11, #28 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x530e7d8c // lsr w12, w12, #14 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9f0121 // stur q1, [x9, #-16] - WORD $0x2944ac0a // ldp w10, w11, [x0, #36] - WORD $0xb9402c0c // ldr w12, [x0, #44] - WORD $0x138a496d // extr w13, w11, w10, #18 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53047d6e // lsr w14, w11, #4 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x138b598b // extr w11, w12, w11, #22 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800121 // str q1, [x9] - WORD $0x2945ac0a // ldp w10, w11, [x0, #44] - WORD $0xb940340c // ldr w12, [x0, #52] - WORD $0x53087d4d // lsr w13, w10, #8 - WORD $0x138a696a // extr w10, w11, w10, #26 - WORD $0x1e2701a1 // fmov s1, w13 - WORD $0x530c7d6e // lsr w14, w11, #12 - WORD $0x4e0c1d41 // mov v1.s[1], w10 - WORD $0x138b798b // extr w11, w12, w11, #30 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800521 // str q1, [x9, #16] - WORD $0x2946ac0a // ldp w10, w11, [x0, #52] - WORD $0xb9403c0c // ldr w12, [x0, #60] - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x53027d6d // lsr w13, w11, #2 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b518b // extr w11, w12, w11, #20 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x53067d8c // lsr w12, w12, #6 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800921 // str q1, [x9, #32] - WORD $0x2947ac0a // ldp w10, w11, [x0, #60] - WORD $0xb940440c // ldr w12, [x0, #68] - WORD $0x91012000 // add x0, x0, #72 - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x530a7d6d // lsr w13, w11, #10 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b718b // extr w11, w12, w11, #28 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x530e7d8c // lsr w12, w12, #14 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800d21 // str q1, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_57 - JMP LBB0_99 -LBB0_58: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x000000120000001f, R5 // LCPI0_102 - MOVD $0x0000000e00000001, R1 // LCPI0_103 - MOVD $0x000000110000001e, R6 // LCPI0_104 - MOVD $0x0000000f00000002, R2 // LCPI0_105 - MOVD $0x0000000f0000001c, R7 // LCPI0_106 - MOVD $0x0000001100000004, R3 // LCPI0_107 - MOVD $0x0000000e0000001b, R16 // LCPI0_108 - MOVD $0x0000001200000005, R4 // LCPI0_109 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00d4e0 // movi v0.4s, #7, msl #16 - WORD $0x2ea0b8a5 // neg v5.2s, v5.2s - WORD $0x2ea0b8c6 // neg v6.2s, v6.2s - WORD $0x2ea0b8e7 // neg v7.2s, v7.2s - WORD $0x2ea0ba10 // neg v16.2s, v16.2s + WORD $0x7100347f // cmp w3, #13 + BGT LBB0_95 + + // %bb.55: + WORD $0x7100307f // cmp w3, #12 + BEQ LBB0_121 + + // %bb.56: + WORD $0x7100347f // cmp w3, #13 + BNE LBB0_156 + + // %bb.57: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.58: + // WORD $0x90000008 // adrp x8, .LCPI0_140 + // WORD $0x90000009 // adrp x9, .LCPI0_141 + // WORD $0x9000000a // adrp x10, .LCPI0_142 + // WORD $0x9000000b // adrp x11, .LCPI0_143 + // WORD $0x9000000c // adrp x12, .LCPI0_144 + WORD $0x4f00c7e3 // movi v3.4s, #31, msl #8 + VMOVD LCPI0_140, V0 + VMOVD LCPI0_141, V1 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_142, V2 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_143, V4 + VMOVD LCPI0_144, V5 + +LBB0_59: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x530d7d4c // lsr w12, w10, #13 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x4e0c1d86 // mov v6.s[1], w12 + WORD $0x4e141d46 // mov v6.s[2], w10 + WORD $0x53077d6a // lsr w10, w11, #7 + WORD $0x4e1c1d46 // mov v6.s[3], w10 + WORD $0x4e231cc6 // and v6.16b, v6.16b, v3.16b + WORD $0x3c9c0106 // stur q6, [x8, #-64] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x138a516a // extr w10, w11, w10, #20 + WORD $0x0e040d66 // dup v6.2s, w11 + WORD $0x1e270147 // fmov s7, w10 + WORD $0xb9400c0a // ldr w10, [x0, #12] + WORD $0x2ea044c6 // ushl v6.2s, v6.2s, v0.2s + WORD $0x138b6d4a // extr w10, w10, w11, #27 + WORD $0x6e0720e7 // ext v7.16b, v7.16b, v7.16b, #4 + WORD $0x6e0660e6 // ext v6.16b, v7.16b, v6.16b, #12 + WORD $0x4e1c1d46 // mov v6.s[3], w10 + WORD $0x4e231cc6 // and v6.16b, v6.16b, v3.16b + WORD $0x3c9d0106 // stur q6, [x8, #-48] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x53087d4c // lsr w12, w10, #8 + WORD $0x0e040d66 // dup v6.2s, w11 + WORD $0x138a556a // extr w10, w11, w10, #21 + WORD $0x1e270187 // fmov s7, w12 + WORD $0x2ea144c6 // ushl v6.2s, v6.2s, v1.2s + WORD $0x4e0c1d47 // mov v7.s[1], w10 + WORD $0x6e1804c7 // mov v7.d[1], v6.d[0] + WORD $0x4e231ce6 // and v6.16b, v7.16b, v3.16b + WORD $0x3c9e0106 // stur q6, [x8, #-32] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x53097d6c // lsr w12, w11, #9 + WORD $0x1e270146 // fmov s6, w10 + WORD $0xb940180a // ldr w10, [x0, #24] + WORD $0x138b594b // extr w11, w10, w11, #22 + WORD $0x4e0c1d86 // mov v6.s[1], w12 + WORD $0x53037d4a // lsr w10, w10, #3 + WORD $0x4e141d66 // mov v6.s[2], w11 + WORD $0x4e1c1d46 // mov v6.s[3], w10 + WORD $0x4e231cc6 // and v6.16b, v6.16b, v3.16b + WORD $0x3c9f0106 // stur q6, [x8, #-16] + WORD $0x29432c0a // ldp w10, w11, [x0, #24] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x138a756a // extr w10, w11, w10, #29 + WORD $0x1e270186 // fmov s6, w12 + WORD $0xb940200c // ldr w12, [x0, #32] + WORD $0x4e0c1d46 // mov v6.s[1], w10 + WORD $0x530a7d6a // lsr w10, w11, #10 + WORD $0x4e141d46 // mov v6.s[2], w10 + WORD $0x138b5d8a // extr w10, w12, w11, #23 + WORD $0x4e1c1d46 // mov v6.s[3], w10 + WORD $0x4e231cc6 // and v6.16b, v6.16b, v3.16b + WORD $0x3d800106 // str q6, [x8] + WORD $0x29442c0a // ldp w10, w11, [x0, #32] + WORD $0x0e040d46 // dup v6.2s, w10 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x2ea244c6 // ushl v6.2s, v6.2s, v2.2s + WORD $0x4e141d46 // mov v6.s[2], w10 + WORD $0x530b7d6a // lsr w10, w11, #11 + WORD $0x4e1c1d46 // mov v6.s[3], w10 + WORD $0x4e231cc6 // and v6.16b, v6.16b, v3.16b + WORD $0x3d800506 // str q6, [x8, #16] + WORD $0x2944ac0a // ldp w10, w11, [x0, #36] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x0e040d66 // dup v6.2s, w11 + WORD $0x1e270147 // fmov s7, w10 + WORD $0xb9402c0a // ldr w10, [x0, #44] + WORD $0x2ea444c6 // ushl v6.2s, v6.2s, v4.2s + WORD $0x138b7d4a // extr w10, w10, w11, #31 + WORD $0x6e0720e7 // ext v7.16b, v7.16b, v7.16b, #4 + WORD $0x6e0660e6 // ext v6.16b, v7.16b, v6.16b, #12 + WORD $0x4e1c1d46 // mov v6.s[3], w10 + WORD $0x4e231cc6 // and v6.16b, v6.16b, v3.16b + WORD $0x3d800906 // str q6, [x8, #32] + WORD $0x2945ac0a // ldp w10, w11, [x0, #44] + WORD $0x9100d000 // add x0, x0, #52 + WORD $0x530c7d4c // lsr w12, w10, #12 + WORD $0x0e040d66 // dup v6.2s, w11 + WORD $0x138a656a // extr w10, w11, w10, #25 + WORD $0x1e270187 // fmov s7, w12 + WORD $0x2ea544c6 // ushl v6.2s, v6.2s, v5.2s + WORD $0x4e0c1d47 // mov v7.s[1], w10 + WORD $0x6e1804c7 // mov v7.d[1], v6.d[0] + WORD $0x4e231ce6 // and v6.16b, v7.16b, v3.16b + WORD $0x3d800d06 // str q6, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_59 + JMP LBB0_156 + LBB0_60: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xb940080c // ldr w12, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a4d6d // extr w13, w11, w10, #19 - WORD $0x1e270151 // fmov s17, w10 - WORD $0x53067d6e // lsr w14, w11, #6 - WORD $0x4e0c1db1 // mov v17.s[1], w13 - WORD $0x138b658b // extr w11, w12, w11, #25 - WORD $0x4e141dd1 // mov v17.s[2], w14 - WORD $0x4e1c1d71 // mov v17.s[3], w11 - WORD $0x4e201e31 // and v17.16b, v17.16b, v0.16b - WORD $0x3c9c0131 // stur q17, [x9, #-64] - WORD $0xb940080a // ldr w10, [x0, #8] - WORD $0xfc40c011 // ldur d17, [x0, #12] - WORD $0x1e270152 // fmov s18, w10 - WORD $0x0e913a52 // zip1 v25.2s, v25.2s, v17.2s - WORD $0x530c7d4b // lsr w11, w10, #12 - WORD $0x2ea14633 // ushl v19.2s, v17.2s, v1.2s - WORD $0x0e0c3e2a // mov w10, v17.s[1] - WORD $0x2ea54651 // ushl v17.2s, v25.2s, v5.2s - WORD $0x1e270172 // fmov s18, w11 - WORD $0x0eb11e71 // orr v17.8b, v19.8b, v17.8b - WORD $0x6e0c0632 // mov v25.s[1], v17.s[0] - WORD $0x53057d4a // lsr w10, w10, #5 - WORD $0x6e142632 // mov v25.s[2], v17.s[1] - WORD $0x4e1c1d52 // mov v25.s[3], w10 - WORD $0x4e201e51 // and v17.16b, v25.16b, v0.16b - WORD $0x3c9d0131 // stur q17, [x9, #-48] - WORD $0x29422c0a // ldp w10, w11, [x0, #16] - WORD $0xfd400c11 // ldr d17, [x0, #24] - WORD $0x1e270172 // fmov s18, w11 - WORD $0x138a616a // extr w10, w11, w10, #24 - WORD $0x0e913a52 // zip1 v25.2s, v25.2s, v17.2s - WORD $0x530b7d6c // lsr w12, w11, #11 - WORD $0x2ea24631 // ushl v17.2s, v17.2s, v2.2s - WORD $0x1e270153 // fmov s19, w10 - WORD $0x2ea64652 // ushl v25.2s, v25.2s, v6.2s - WORD $0x4e0c1d93 // mov v19.s[1], w12 - WORD $0x0eb21e31 // orr v17.8b, v17.8b, v25.8b - WORD $0x6e180633 // mov v19.d[1], v17.d[0] - WORD $0x4e201e71 // and v17.16b, v19.16b, v0.16b - WORD $0x3c9e0131 // stur q17, [x9, #-32] - WORD $0x2943ac0a // ldp w10, w11, [x0, #28] - WORD $0xb940240c // ldr w12, [x0, #36] - WORD $0x53047d4d // lsr w13, w10, #4 - WORD $0x138a5d6a // extr w10, w11, w10, #23 - WORD $0x1e2701b1 // fmov s17, w13 - WORD $0x530a7d6e // lsr w14, w11, #10 - WORD $0x4e0c1d51 // mov v17.s[1], w10 - WORD $0x138b758b // extr w11, w12, w11, #29 - WORD $0x4e141dd1 // mov v17.s[2], w14 - WORD $0x4e1c1d71 // mov v17.s[3], w11 - WORD $0x4e201e31 // and v17.16b, v17.16b, v0.16b - WORD $0x3c9f0131 // stur q17, [x9, #-16] - WORD $0x2944ac0a // ldp w10, w11, [x0, #36] - WORD $0xb9402c0c // ldr w12, [x0, #44] - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x53037d6d // lsr w13, w11, #3 - WORD $0x1e270151 // fmov s17, w10 - WORD $0x138b598b // extr w11, w12, w11, #22 - WORD $0x4e0c1db1 // mov v17.s[1], w13 - WORD $0x53097d8c // lsr w12, w12, #9 - WORD $0x4e141d71 // mov v17.s[2], w11 - WORD $0x4e1c1d91 // mov v17.s[3], w12 - WORD $0x4e201e31 // and v17.16b, v17.16b, v0.16b - WORD $0x3d800131 // str q17, [x9] - WORD $0xfd401811 // ldr d17, [x0, #48] - WORD $0xbd402c12 // ldr s18, [x0, #44] - WORD $0xb940380a // ldr w10, [x0, #56] - WORD $0x2ea34633 // ushl v19.2s, v17.2s, v3.2s - WORD $0x0e913a52 // zip1 v25.2s, v25.2s, v17.2s - WORD $0x0e0c3e2b // mov w11, v17.s[1] - WORD $0x2ea74651 // ushl v17.2s, v25.2s, v7.2s - WORD $0x53027d6c // lsr w12, w11, #2 - WORD $0x0eb11e71 // orr v17.8b, v19.8b, v17.8b - WORD $0x138b554a // extr w10, w10, w11, #21 - WORD $0x4e141d91 // mov v17.s[2], w12 - WORD $0x4e1c1d51 // mov v17.s[3], w10 - WORD $0x4e201e31 // and v17.16b, v17.16b, v0.16b - WORD $0x3d800531 // str q17, [x9, #16] - WORD $0xb940380a // ldr w10, [x0, #56] - WORD $0xfc43c011 // ldur d17, [x0, #60] - WORD $0x1e270152 // fmov s18, w10 - WORD $0x0e913a52 // zip1 v25.2s, v25.2s, v17.2s - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x2ea44633 // ushl v19.2s, v17.2s, v4.2s - WORD $0x0e0c3e2a // mov w10, v17.s[1] - WORD $0x2eb04651 // ushl v17.2s, v25.2s, v16.2s - WORD $0x1e270172 // fmov s18, w11 - WORD $0x0eb11e71 // orr v17.8b, v19.8b, v17.8b - WORD $0x6e0c0632 // mov v25.s[1], v17.s[0] - WORD $0x53017d4a // lsr w10, w10, #1 - WORD $0x6e142632 // mov v25.s[2], v17.s[1] - WORD $0x4e1c1d52 // mov v25.s[3], w10 - WORD $0x4e201e51 // and v17.16b, v25.16b, v0.16b - WORD $0x3d800931 // str q17, [x9, #32] - WORD $0x29482c0a // ldp w10, w11, [x0, #64] - WORD $0xb940480c // ldr w12, [x0, #72] - WORD $0x91013000 // add x0, x0, #76 - WORD $0x138a516a // extr w10, w11, w10, #20 - WORD $0x53077d6d // lsr w13, w11, #7 - WORD $0x1e270151 // fmov s17, w10 - WORD $0x138b698b // extr w11, w12, w11, #26 - WORD $0x4e0c1db1 // mov v17.s[1], w13 - WORD $0x530d7d8c // lsr w12, w12, #13 - WORD $0x4e141d71 // mov v17.s[2], w11 - WORD $0x4e1c1d91 // mov v17.s[3], w12 - WORD $0x4e201e31 // and v17.16b, v17.16b, v0.16b - WORD $0x3d800d31 // str q17, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_60 - JMP LBB0_99 -LBB0_61: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00d5e0 // movi v0.4s, #15, msl #16 -LBB0_63: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xb940080c // ldr w12, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a516d // extr w13, w11, w10, #20 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53087d6e // lsr w14, w11, #8 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x138b718b // extr w11, w12, w11, #28 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9c0121 // stur q1, [x9, #-64] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0xb940100c // ldr w12, [x0, #16] - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x53047d6d // lsr w13, w11, #4 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b618b // extr w11, w12, w11, #24 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x530c7d8c // lsr w12, w12, #12 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9d0121 // stur q1, [x9, #-48] - WORD $0x2942ac0a // ldp w10, w11, [x0, #20] - WORD $0xb9401c0c // ldr w12, [x0, #28] - WORD $0x138a516d // extr w13, w11, w10, #20 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53087d6e // lsr w14, w11, #8 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x138b718b // extr w11, w12, w11, #28 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9e0121 // stur q1, [x9, #-32] - WORD $0x2943ac0a // ldp w10, w11, [x0, #28] - WORD $0xb940240c // ldr w12, [x0, #36] - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x53047d6d // lsr w13, w11, #4 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b618b // extr w11, w12, w11, #24 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x530c7d8c // lsr w12, w12, #12 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3c9f0121 // stur q1, [x9, #-16] - WORD $0x29452c0a // ldp w10, w11, [x0, #40] - WORD $0xb940300c // ldr w12, [x0, #48] - WORD $0x138a516d // extr w13, w11, w10, #20 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53087d6e // lsr w14, w11, #8 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x138b718b // extr w11, w12, w11, #28 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800121 // str q1, [x9] - WORD $0x29462c0a // ldp w10, w11, [x0, #48] - WORD $0xb940380c // ldr w12, [x0, #56] - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x53047d6d // lsr w13, w11, #4 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b618b // extr w11, w12, w11, #24 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x530c7d8c // lsr w12, w12, #12 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800521 // str q1, [x9, #16] - WORD $0x2947ac0a // ldp w10, w11, [x0, #60] - WORD $0xb940440c // ldr w12, [x0, #68] - WORD $0x138a516d // extr w13, w11, w10, #20 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x53087d6e // lsr w14, w11, #8 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x138b718b // extr w11, w12, w11, #28 - WORD $0x4e141dc1 // mov v1.s[2], w14 - WORD $0x4e1c1d61 // mov v1.s[3], w11 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800921 // str q1, [x9, #32] - WORD $0x2948ac0a // ldp w10, w11, [x0, #68] - WORD $0xb9404c0c // ldr w12, [x0, #76] - WORD $0x91014000 // add x0, x0, #80 - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x53047d6d // lsr w13, w11, #4 - WORD $0x1e270141 // fmov s1, w10 - WORD $0x138b618b // extr w11, w12, w11, #24 - WORD $0x4e0c1da1 // mov v1.s[1], w13 - WORD $0x530c7d8c // lsr w12, w12, #12 - WORD $0x4e141d61 // mov v1.s[2], w11 - WORD $0x4e1c1d81 // mov v1.s[3], w12 - WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b - WORD $0x3d800d21 // str q1, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - BNE LBB0_63 - JMP LBB0_99 + WORD $0x7100707f // cmp w3, #28 + BEQ LBB0_124 + + // %bb.61: + WORD $0x7100747f // cmp w3, #29 + BNE LBB0_156 + + // %bb.62: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.63: + // WORD $0x90000008 // adrp x8, .LCPI0_32 + // WORD $0x90000009 // adrp x9, .LCPI0_33 + // WORD $0x9000000a // adrp x10, .LCPI0_34 + // WORD $0x9000000b // adrp x11, .LCPI0_47 + VMOVD LCPI0_32, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_35 + VMOVD LCPI0_33, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_36 + VMOVQ LCPI0_34L, LCPI0_34H, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_37 + VMOVQ LCPI0_35L, LCPI0_35H, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_38 + VMOVD LCPI0_36, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_39 + VMOVD LCPI0_37, V5 + // WORD $0x9000000a // adrp x10, .LCPI0_40 + VMOVQ LCPI0_38L, LCPI0_38H, V6 + // WORD $0x90000008 // adrp x8, .LCPI0_41 + VMOVQ LCPI0_39L, LCPI0_39H, V7 + // WORD $0x90000009 // adrp x9, .LCPI0_42 + VMOVQ LCPI0_40L, LCPI0_40H, V16 + // WORD $0x9000000a // adrp x10, .LCPI0_43 + VMOVQ LCPI0_41L, LCPI0_41H, V17 + // WORD $0x90000008 // adrp x8, .LCPI0_44 + VMOVD LCPI0_42, V18 + // WORD $0x90000009 // adrp x9, .LCPI0_45 + VMOVD LCPI0_43, V19 + // WORD $0x9000000a // adrp x10, .LCPI0_46 + VMOVQ LCPI0_44L, LCPI0_44H, V20 + WORD $0x91010348 // add x8, x26, #64 + VMOVQ LCPI0_45L, LCPI0_45H, V21 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_46, V22 + VMOVD LCPI0_47, V23 + LBB0_64: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x000000130000001e, R7 // LCPI0_90 - MOVD $0x0000000d00000002, R1 // LCPI0_91 - MOVD $0x000000120000001d, R16 // LCPI0_92 - MOVD $0x0000000e00000003, R2 // LCPI0_93 - MOVD $0x000000110000001c, R17 // LCPI0_94 - MOVD $0x0000000f00000004, R3 // LCPI0_95 - MOVD $0x0000000f0000001a, R25 // LCPI0_96 - MOVD $0x0000001100000006, R4 // LCPI0_97 - MOVD $0x0000000e00000019, R19 // LCPI0_98 - MOVD $0x0000001200000007, R5 // LCPI0_99 - MOVD $0x0000000d00000018, R20 // LCPI0_100 - MOVD $0x0000001300000008, R6 // LCPI0_101 - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f00d7e0 // movi v0.4s, #31, msl #16 - WORD $0x2ea0b8e7 // neg v7.2s, v7.2s - WORD $0x2ea0ba10 // neg v16.2s, v16.2s - WORD $0x2ea0ba31 // neg v17.2s, v17.2s - WORD $0x2ea0bb39 // neg v25.2s, v25.2s - WORD $0x2ea0ba73 // neg v19.2s, v19.2s - WORD $0x2ea0ba94 // neg v20.2s, v20.2s -LBB0_66: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xb940080c // ldr w12, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a556d // extr w13, w11, w10, #21 - WORD $0x1e270155 // fmov s21, w10 - WORD $0x530a7d6e // lsr w14, w11, #10 - WORD $0x4e0c1db5 // mov v21.s[1], w13 - WORD $0x138b7d8b // extr w11, w12, w11, #31 - WORD $0x4e141dd5 // mov v21.s[2], w14 - WORD $0x4e1c1d75 // mov v21.s[3], w11 - WORD $0x4e201eb5 // and v21.16b, v21.16b, v0.16b - WORD $0x3c9c0135 // stur q21, [x9, #-64] - WORD $0x29412c0a // ldp w10, w11, [x0, #8] - WORD $0xfd400815 // ldr d21, [x0, #16] - WORD $0x1e270176 // fmov s22, w11 - WORD $0x138a516a // extr w10, w11, w10, #20 - WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s - WORD $0x53097d6c // lsr w12, w11, #9 - WORD $0x2ea146b5 // ushl v21.2s, v21.2s, v1.2s - WORD $0x1e270157 // fmov s23, w10 - WORD $0x2ea746d6 // ushl v22.2s, v22.2s, v7.2s - WORD $0x4e0c1d97 // mov v23.s[1], w12 - WORD $0x0eb61eb5 // orr v21.8b, v21.8b, v22.8b - WORD $0x6e1806b7 // mov v23.d[1], v21.d[0] - WORD $0x4e201ef5 // and v21.16b, v23.16b, v0.16b - WORD $0x3c9d0135 // stur q21, [x9, #-48] - WORD $0xb940140a // ldr w10, [x0, #20] - WORD $0xfd400c15 // ldr d21, [x0, #24] - WORD $0x1e270156 // fmov s22, w10 - WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x2ea246b7 // ushl v23.2s, v21.2s, v2.2s - WORD $0x0e0c3eaa // mov w10, v21.s[1] - WORD $0x2eb046d5 // ushl v21.2s, v22.2s, v16.2s - WORD $0x1e270176 // fmov s22, w11 - WORD $0x0eb51ef5 // orr v21.8b, v23.8b, v21.8b - WORD $0x6e0c06b6 // mov v22.s[1], v21.s[0] - WORD $0x53077d4a // lsr w10, w10, #7 - WORD $0x6e1426b6 // mov v22.s[2], v21.s[1] - WORD $0x4e1c1d56 // mov v22.s[3], w10 - WORD $0x4e201ed5 // and v21.16b, v22.16b, v0.16b - WORD $0x3c9e0135 // stur q21, [x9, #-32] - WORD $0xfd401015 // ldr d21, [x0, #32] - WORD $0xbd401c16 // ldr s22, [x0, #28] - WORD $0xb940280a // ldr w10, [x0, #40] - WORD $0x2ea346b7 // ushl v23.2s, v21.2s, v3.2s - WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s - WORD $0x0e0c3eab // mov w11, v21.s[1] - WORD $0x2eb146d5 // ushl v21.2s, v22.2s, v17.2s - WORD $0x53067d6c // lsr w12, w11, #6 - WORD $0x0eb51ef5 // orr v21.8b, v23.8b, v21.8b - WORD $0x138b6d4a // extr w10, w10, w11, #27 - WORD $0x4e141d95 // mov v21.s[2], w12 - WORD $0x4e1c1d55 // mov v21.s[3], w10 - WORD $0x4e201eb5 // and v21.16b, v21.16b, v0.16b - WORD $0x3c9f0135 // stur q21, [x9, #-16] - WORD $0x29452c0a // ldp w10, w11, [x0, #40] - WORD $0xfd401815 // ldr d21, [x0, #48] - WORD $0x1e270176 // fmov s22, w11 - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s - WORD $0x53057d6c // lsr w12, w11, #5 - WORD $0x2ea446b5 // ushl v21.2s, v21.2s, v4.2s - WORD $0x1e270157 // fmov s23, w10 - WORD $0x2eb246d6 // ushl v22.2s, v22.2s, v25.2s - WORD $0x4e0c1d97 // mov v23.s[1], w12 - WORD $0x0eb61eb5 // orr v21.8b, v21.8b, v22.8b - WORD $0x6e1806b7 // mov v23.d[1], v21.d[0] - WORD $0x4e201ef5 // and v21.16b, v23.16b, v0.16b - WORD $0x3d800135 // str q21, [x9] - WORD $0xb940340a // ldr w10, [x0, #52] - WORD $0xfd401c15 // ldr d21, [x0, #56] - WORD $0x1e270156 // fmov s22, w10 - WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s - WORD $0x53047d4b // lsr w11, w10, #4 - WORD $0x2ea546b7 // ushl v23.2s, v21.2s, v5.2s - WORD $0x0e0c3eaa // mov w10, v21.s[1] - WORD $0x2eb346d5 // ushl v21.2s, v22.2s, v19.2s - WORD $0x1e270176 // fmov s22, w11 - WORD $0x0eb51ef5 // orr v21.8b, v23.8b, v21.8b - WORD $0x6e0c06b6 // mov v22.s[1], v21.s[0] - WORD $0x53037d4a // lsr w10, w10, #3 - WORD $0x6e1426b6 // mov v22.s[2], v21.s[1] - WORD $0x4e1c1d56 // mov v22.s[3], w10 - WORD $0x4e201ed5 // and v21.16b, v22.16b, v0.16b - WORD $0x3d800535 // str q21, [x9, #16] - WORD $0xfd402015 // ldr d21, [x0, #64] - WORD $0xbd403c16 // ldr s22, [x0, #60] - WORD $0xb940480a // ldr w10, [x0, #72] - WORD $0x2ea646b7 // ushl v23.2s, v21.2s, v6.2s - WORD $0x0e953ad6 // zip1 v22.2s, v22.2s, v21.2s - WORD $0x0e0c3eab // mov w11, v21.s[1] - WORD $0x2eb446d5 // ushl v21.2s, v22.2s, v20.2s - WORD $0x53027d6c // lsr w12, w11, #2 - WORD $0x0eb51ef5 // orr v21.8b, v23.8b, v21.8b - WORD $0x138b5d4a // extr w10, w10, w11, #23 - WORD $0x4e141d95 // mov v21.s[2], w12 - WORD $0x4e1c1d55 // mov v21.s[3], w10 - WORD $0x4e201eb5 // and v21.16b, v21.16b, v0.16b - WORD $0x3d800935 // str q21, [x9, #32] - WORD $0x29492c0a // ldp w10, w11, [x0, #72] - WORD $0xb940500c // ldr w12, [x0, #80] - WORD $0x91015000 // add x0, x0, #84 - WORD $0x138a316a // extr w10, w11, w10, #12 - WORD $0x53017d6d // lsr w13, w11, #1 - WORD $0x1e270155 // fmov s21, w10 - WORD $0x138b598b // extr w11, w12, w11, #22 - WORD $0x4e0c1db5 // mov v21.s[1], w13 - WORD $0x530b7d8c // lsr w12, w12, #11 - WORD $0x4e141d75 // mov v21.s[2], w11 - WORD $0x4e1c1d95 // mov v21.s[3], w12 - WORD $0x4e201eb5 // and v21.16b, v21.16b, v0.16b - WORD $0x3d800d35 // str q21, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_66 - JMP LBB0_99 -LBB0_67: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000000e00000018, R4 // LCPI0_84 - MOVD $0x0000001200000008, R1 // LCPI0_85 - MOVD $0x000000120000001c, R5 // LCPI0_86 - MOVD $0x0000000e00000004, R2 // LCPI0_87 - MOVD $0x000000140000001e, R6 // LCPI0_88 - MOVD $0x0000000c00000002, R3 // LCPI0_89 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f01d7e0 // movi v0.4s, #63, msl #16 - WORD $0x2ea0b884 // neg v4.2s, v4.2s - WORD $0x2ea0b8a5 // neg v5.2s, v5.2s - WORD $0x2ea0b8c6 // neg v6.2s, v6.2s + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404018 // ldur d24, [x0, #4] + WORD $0xb9400c0b // ldr w11, [x0, #12] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x1e27015a // fmov s26, w10 + WORD $0x2ea0471b // ushl v27.2s, v24.2s, v0.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x6e1a235a // ext v26.16b, v26.16b, v26.16b, #4 + WORD $0x138a5d6a // extr w10, w11, w10, #23 + WORD $0x2ea14739 // ushl v25.2s, v25.2s, v1.2s + WORD $0x0eb91f79 // orr v25.8b, v27.8b, v25.8b + WORD $0x6e196358 // ext v24.16b, v26.16b, v25.16b, #12 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f077418 // bic v24.4s, #224, lsl #24 + WORD $0x3c9c0118 // stur q24, [x8, #-64] + WORD $0xbd400c18 // ldr s24, [x0, #12] + WORD $0x3dc00419 // ldr q25, [x0, #16] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6ea24739 // ushl v25.4s, v25.4s, v2.4s + WORD $0x6ea34718 // ushl v24.4s, v24.4s, v3.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f077418 // bic v24.4s, #224, lsl #24 + WORD $0x3c9d0118 // stur q24, [x8, #-48] + WORD $0xfd401018 // ldr d24, [x0, #32] + WORD $0xbd401c19 // ldr s25, [x0, #28] + WORD $0xb940280c // ldr w12, [x0, #40] + WORD $0x2ea4471a // ushl v26.2s, v24.2s, v4.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x53027d4b // lsr w11, w10, #2 + WORD $0x138a7d8a // extr w10, w12, w10, #31 + WORD $0x2ea54739 // ushl v25.2s, v25.2s, v5.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d78 // mov v24.s[2], w11 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f077418 // bic v24.4s, #224, lsl #24 + WORD $0x3c9e0118 // stur q24, [x8, #-32] + WORD $0xbd402818 // ldr s24, [x0, #40] + WORD $0x3cc2c019 // ldur q25, [x0, #44] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6ea64739 // ushl v25.4s, v25.4s, v6.4s + WORD $0x6ea74718 // ushl v24.4s, v24.4s, v7.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f077418 // bic v24.4s, #224, lsl #24 + WORD $0x3c9f0118 // stur q24, [x8, #-16] + WORD $0xbd403818 // ldr s24, [x0, #56] + WORD $0x3cc3c019 // ldur q25, [x0, #60] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6eb04739 // ushl v25.4s, v25.4s, v16.4s + WORD $0x6eb14718 // ushl v24.4s, v24.4s, v17.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f077418 // bic v24.4s, #224, lsl #24 + WORD $0x3d800118 // str q24, [x8] + WORD $0x2949280b // ldp w11, w10, [x0, #72] + WORD $0xfd402818 // ldr d24, [x0, #80] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x138b114b // extr w11, w10, w11, #4 + WORD $0x53017d4a // lsr w10, w10, #1 + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x2eb24718 // ushl v24.2s, v24.2s, v18.2s + WORD $0x1e27017a // fmov s26, w11 + WORD $0x2eb34739 // ushl v25.2s, v25.2s, v19.2s + WORD $0x4e0c1d5a // mov v26.s[1], w10 + WORD $0x0eb91f18 // orr v24.8b, v24.8b, v25.8b + WORD $0x6e18071a // mov v26.d[1], v24.d[0] + WORD $0x6f07741a // bic v26.4s, #224, lsl #24 + WORD $0x3d80051a // str q26, [x8, #16] + WORD $0xbd405418 // ldr s24, [x0, #84] + WORD $0x3cc58019 // ldur q25, [x0, #88] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6eb44739 // ushl v25.4s, v25.4s, v20.4s + WORD $0x6eb54718 // ushl v24.4s, v24.4s, v21.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f077418 // bic v24.4s, #224, lsl #24 + WORD $0x3d800918 // str q24, [x8, #32] + WORD $0xfd403418 // ldr d24, [x0, #104] + WORD $0xbd406419 // ldr s25, [x0, #100] + WORD $0xb940700b // ldr w11, [x0, #112] + WORD $0x9101d000 // add x0, x0, #116 + WORD $0x2eb6471a // ushl v26.2s, v24.2s, v22.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x138a196a // extr w10, w11, w10, #6 + WORD $0x2eb74739 // ushl v25.2s, v25.2s, v23.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d58 // mov v24.s[2], w10 + WORD $0x53037d6a // lsr w10, w11, #3 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f077418 // bic v24.4s, #224, lsl #24 + WORD $0x3d800d18 // str q24, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_64 + JMP LBB0_156 + +LBB0_65: + WORD $0x7100087f // cmp w3, #2 + BEQ LBB0_127 + + // %bb.66: + WORD $0x71000c7f // cmp w3, #3 + BNE LBB0_156 + + // %bb.67: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.68: + // WORD $0x90000008 // adrp x8, .LCPI0_188 + // WORD $0x90000009 // adrp x9, .LCPI0_189 + // WORD $0x9000000a // adrp x10, .LCPI0_190 + WORD $0x4f0004e7 // movi v7.4s, #7 + VMOVD LCPI0_188, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_191 + VMOVQ LCPI0_189L, LCPI0_189H, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_192 + VMOVD LCPI0_190, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_193 + VMOVQ LCPI0_191L, LCPI0_191H, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_194 + VMOVQ LCPI0_192L, LCPI0_192H, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_195 + VMOVD LCPI0_193, V5 + VMOVQ LCPI0_194L, LCPI0_194H, V6 + WORD $0x91010348 // add x8, x26, #64 + VMOVQ LCPI0_195L, LCPI0_195H, V16 + WORD $0xaa1303e9 // mov x9, x19 + LBB0_69: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xb940080c // ldr w12, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a596d // extr w13, w11, w10, #22 - WORD $0x1e270147 // fmov s7, w10 - WORD $0x138b318b // extr w11, w12, w11, #12 - WORD $0x4e0c1da7 // mov v7.s[1], w13 - WORD $0x53027d8c // lsr w12, w12, #2 - WORD $0x4e141d67 // mov v7.s[2], w11 - WORD $0x4e1c1d87 // mov v7.s[3], w12 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3c9c0127 // stur q7, [x9, #-64] - WORD $0xfc40c007 // ldur d7, [x0, #12] - WORD $0xbd400810 // ldr s16, [x0, #8] - WORD $0xb940140a // ldr w10, [x0, #20] - WORD $0x2ea144f1 // ushl v17.2s, v7.2s, v1.2s - WORD $0x0e873a10 // zip1 v16.2s, v16.2s, v7.2s - WORD $0x0e0c3ceb // mov w11, v7.s[1] - WORD $0x2ea44607 // ushl v7.2s, v16.2s, v4.2s - WORD $0x53047d6c // lsr w12, w11, #4 - WORD $0x0ea71e27 // orr v7.8b, v17.8b, v7.8b - WORD $0x138b694a // extr w10, w10, w11, #26 - WORD $0x4e141d87 // mov v7.s[2], w12 - WORD $0x4e1c1d47 // mov v7.s[3], w10 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3c9d0127 // stur q7, [x9, #-48] - WORD $0x2942ac0a // ldp w10, w11, [x0, #20] - WORD $0xfc41c007 // ldur d7, [x0, #28] - WORD $0x1e270170 // fmov s16, w11 - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x0e873a10 // zip1 v16.2s, v16.2s, v7.2s - WORD $0x53067d6c // lsr w12, w11, #6 - WORD $0x2ea244e7 // ushl v7.2s, v7.2s, v2.2s - WORD $0x1e270151 // fmov s17, w10 - WORD $0x2ea54610 // ushl v16.2s, v16.2s, v5.2s - WORD $0x4e0c1d91 // mov v17.s[1], w12 - WORD $0x0eb01ce7 // orr v7.8b, v7.8b, v16.8b - WORD $0x6e1804f1 // mov v17.d[1], v7.d[0] - WORD $0x4e201e27 // and v7.16b, v17.16b, v0.16b - WORD $0x3c9e0127 // stur q7, [x9, #-32] - WORD $0xb940200a // ldr w10, [x0, #32] - WORD $0xfc424007 // ldur d7, [x0, #36] - WORD $0x1e270150 // fmov s16, w10 - WORD $0x0e873a10 // zip1 v16.2s, v16.2s, v7.2s - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x2ea344f1 // ushl v17.2s, v7.2s, v3.2s - WORD $0x0e0c3cea // mov w10, v7.s[1] - WORD $0x2ea64607 // ushl v7.2s, v16.2s, v6.2s - WORD $0x1e270170 // fmov s16, w11 - WORD $0x0ea71e27 // orr v7.8b, v17.8b, v7.8b - WORD $0x6e0c04f0 // mov v16.s[1], v7.s[0] - WORD $0x530a7d4a // lsr w10, w10, #10 - WORD $0x6e1424f0 // mov v16.s[2], v7.s[1] - WORD $0x4e1c1d50 // mov v16.s[3], w10 - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3c9f0127 // stur q7, [x9, #-16] - WORD $0x2945ac0a // ldp w10, w11, [x0, #44] - WORD $0x138a596d // extr w13, w11, w10, #22 - WORD $0x1e270147 // fmov s7, w10 - WORD $0x138b318b // extr w11, w12, w11, #12 - WORD $0x4e0c1da7 // mov v7.s[1], w13 - WORD $0x53027d8c // lsr w12, w12, #2 - WORD $0x4e141d67 // mov v7.s[2], w11 - WORD $0x4e1c1d87 // mov v7.s[3], w12 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3d800127 // str q7, [x9] - WORD $0xfd401c07 // ldr d7, [x0, #56] - WORD $0xbd403410 // ldr s16, [x0, #52] - WORD $0xb940400a // ldr w10, [x0, #64] - WORD $0x2ea144f1 // ushl v17.2s, v7.2s, v1.2s - WORD $0x0e873a10 // zip1 v16.2s, v16.2s, v7.2s - WORD $0x0e0c3ceb // mov w11, v7.s[1] - WORD $0x2ea44607 // ushl v7.2s, v16.2s, v4.2s - WORD $0x53047d6c // lsr w12, w11, #4 - WORD $0x0ea71e27 // orr v7.8b, v17.8b, v7.8b - WORD $0x138b694a // extr w10, w10, w11, #26 - WORD $0x4e141d87 // mov v7.s[2], w12 - WORD $0x4e1c1d47 // mov v7.s[3], w10 - WORD $0x4e201ce7 // and v7.16b, v7.16b, v0.16b - WORD $0x3d800527 // str q7, [x9, #16] - WORD $0x29482c0a // ldp w10, w11, [x0, #64] - WORD $0xfd402407 // ldr d7, [x0, #72] - WORD $0x1e270170 // fmov s16, w11 - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x0e873a10 // zip1 v16.2s, v16.2s, v7.2s - WORD $0x53067d6c // lsr w12, w11, #6 - WORD $0x2ea244e7 // ushl v7.2s, v7.2s, v2.2s - WORD $0x1e270151 // fmov s17, w10 - WORD $0x2ea54610 // ushl v16.2s, v16.2s, v5.2s - WORD $0x4e0c1d91 // mov v17.s[1], w12 - WORD $0x0eb01ce7 // orr v7.8b, v7.8b, v16.8b - WORD $0x6e1804f1 // mov v17.d[1], v7.d[0] - WORD $0x4e201e27 // and v7.16b, v17.16b, v0.16b - WORD $0x3d800927 // str q7, [x9, #32] - WORD $0xb9404c0a // ldr w10, [x0, #76] - WORD $0xfd402807 // ldr d7, [x0, #80] - WORD $0x91016000 // add x0, x0, #88 - WORD $0x1e270150 // fmov s16, w10 - WORD $0x0e873a10 // zip1 v16.2s, v16.2s, v7.2s - WORD $0x53087d4b // lsr w11, w10, #8 - WORD $0x2ea344f1 // ushl v17.2s, v7.2s, v3.2s - WORD $0x0e0c3cea // mov w10, v7.s[1] - WORD $0x2ea64607 // ushl v7.2s, v16.2s, v6.2s - WORD $0x1e270170 // fmov s16, w11 - WORD $0x0ea71e27 // orr v7.8b, v17.8b, v7.8b - WORD $0x6e0c04f0 // mov v16.s[1], v7.s[0] - WORD $0x530a7d4a // lsr w10, w10, #10 - WORD $0x6e1424f0 // mov v16.s[2], v7.s[1] - WORD $0x4e1c1d50 // mov v16.s[3], w10 - WORD $0x4e201e07 // and v7.16b, v16.16b, v0.16b - WORD $0x3d800d27 // str q7, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_69 - JMP LBB0_99 + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x53097d4a // lsr w10, w10, #9 + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x2ea04631 // ushl v17.2s, v17.2s, v0.2s + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0xaa0003ea // mov x10, x0 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9c0111 // stur q17, [x8, #-64] + WORD $0x4ddfc951 // ld1r { v17.4s }, [x10], #4 + WORD $0x6ea14631 // ushl v17.4s, v17.4s, v1.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9d0111 // stur q17, [x8, #-48] + WORD $0xb940000b // ldr w11, [x0] + WORD $0xb940014c // ldr w12, [x10] + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x138b798b // extr w11, w12, w11, #30 + WORD $0x2ea24631 // ushl v17.2s, v17.2s, v2.2s + WORD $0x4e141d71 // mov v17.s[2], w11 + WORD $0x53017d8b // lsr w11, w12, #1 + WORD $0x4e1c1d71 // mov v17.s[3], w11 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9e0111 // stur q17, [x8, #-32] + WORD $0x4d40c951 // ld1r { v17.4s }, [x10] + WORD $0x6ea34631 // ushl v17.4s, v17.4s, v3.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9f0111 // stur q17, [x8, #-16] + WORD $0x4d40c951 // ld1r { v17.4s }, [x10] + WORD $0x6ea44631 // ushl v17.4s, v17.4s, v4.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800111 // str q17, [x8] + WORD $0xb940014a // ldr w10, [x10] + WORD $0xb940080b // ldr w11, [x0, #8] + WORD $0x531c7d4c // lsr w12, w10, #28 + WORD $0x138a7d6a // extr w10, w11, w10, #31 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x1e270192 // fmov s18, w12 + WORD $0x2ea54631 // ushl v17.2s, v17.2s, v5.2s + WORD $0x4e0c1d52 // mov v18.s[1], w10 + WORD $0x9100200a // add x10, x0, #8 + WORD $0x91003000 // add x0, x0, #12 + WORD $0x6e180632 // mov v18.d[1], v17.d[0] + WORD $0x4e271e51 // and v17.16b, v18.16b, v7.16b + WORD $0x3d800511 // str q17, [x8, #16] + WORD $0x4d40c951 // ld1r { v17.4s }, [x10] + WORD $0x6ea64631 // ushl v17.4s, v17.4s, v6.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800911 // str q17, [x8, #32] + WORD $0x4d40c951 // ld1r { v17.4s }, [x10] + WORD $0x6eb04631 // ushl v17.4s, v17.4s, v16.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800d11 // str q17, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_69 + JMP LBB0_156 + LBB0_70: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x000000130000001c, R16 // LCPI0_70 - MOVD $0x0000000d00000004, R1 // LCPI0_71 - MOVD $0x0000000f00000018, R17 // LCPI0_72 - MOVD $0x0000001100000008, R2 // LCPI0_73 - MOVD $0x0000000b00000014, R25 // LCPI0_74 - MOVD $0x000000150000000c, R3 // LCPI0_75 - MOVD $0x000000150000001e, R19 // LCPI0_76 - MOVD $0x0000000b00000002, R4 // LCPI0_77 - MOVD $0x000000110000001a, R20 // LCPI0_78 - MOVD $0x0000000f00000006, R5 // LCPI0_79 - MOVD $0x000000160000001f, R21 // LCPI0_80 - MOVD $0x0000000a00000001, R6 // LCPI0_81 - MOVD $0x000000120000001b, R22 // LCPI0_82 - MOVD $0x0000000e00000005, R7 // LCPI0_83 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x4f03d7e0 // movi v0.4s, #127, msl #16 - WORD $0x2ea0ba10 // neg v16.2s, v16.2s - WORD $0x2ea0ba31 // neg v17.2s, v17.2s - WORD $0x2ea0bb39 //neg v25.2s, v25.2s - WORD $0x2ea0ba73 // neg v19.2s, v19.2s - WORD $0x2ea0ba94 // neg v20.2s, v20.2s - WORD $0x2ea0bab5 // neg v21.2s, v21.2s - WORD $0x2ea0bad6 // neg v22.2s, v22.2s -LBB0_72: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xb940080c // ldr w12, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a5d6d // extr w13, w11, w10, #23 - WORD $0x1e270157 // fmov s23, w10 - WORD $0x138b398b // extr w11, w12, w11, #14 - WORD $0x4e0c1db7 // mov v23.s[1], w13 - WORD $0x53057d8c // lsr w12, w12, #5 - WORD $0x4e141d77 // mov v23.s[2], w11 - WORD $0x4e1c1d97 // mov v23.s[3], w12 - WORD $0x4e201ef7 // and v23.16b, v23.16b, v0.16b - WORD $0x3c9c0137 // stur q23, [x9, #-64] - WORD $0xfc40c017 // ldur d23, [x0, #12] - WORD $0xbd400818 // ldr s24, [x0, #8] - WORD $0xb940140a // ldr w10, [x0, #20] - WORD $0x2ea146f9 // ushl v25.2s, v23.2s, v1.2s - WORD $0x0e973b18 // zip1 v24.2s, v24.2s, v23.2s - WORD $0x0e0c3eeb // mov w11, v23.s[1] - WORD $0x2eb04717 // ushl v23.2s, v24.2s, v16.2s - WORD $0x53017d4c // lsr w12, w10, #1 - WORD $0x138b294a // extr w10, w10, w11, #10 - WORD $0x0eb71f37 // orr v23.8b, v25.8b, v23.8b - WORD $0x4e141d57 // mov v23.s[2], w10 - WORD $0x4e1c1d97 // mov v23.s[3], w12 - WORD $0x4e201ef7 // and v23.16b, v23.16b, v0.16b - WORD $0x3c9d0137 // stur q23, [x9, #-48] - WORD $0xfd400c17 // ldr d23, [x0, #24] - WORD $0xbd401418 // ldr s24, [x0, #20] - WORD $0xb940200a // ldr w10, [x0, #32] - WORD $0x2ea246f9 // ushl v25.2s, v23.2s, v2.2s - WORD $0x0e973b18 // zip1 v24.2s, v24.2s, v23.2s - WORD $0x0e0c3eeb // mov w11, v23.s[1] - WORD $0x2eb14717 // ushl v23.2s, v24.2s, v17.2s - WORD $0x53067d6c // lsr w12, w11, #6 - WORD $0x0eb71f37 // orr v23.8b, v25.8b, v23.8b - WORD $0x138b754a // extr w10, w10, w11, #29 - WORD $0x4e141d97 // mov v23.s[2], w12 - WORD $0x4e1c1d57 // mov v23.s[3], w10 - WORD $0x4e201ef7 // and v23.16b, v23.16b, v0.16b - WORD $0x3c9e0137 // stur q23, [x9, #-32] - WORD $0xfc424017 // ldur d23, [x0, #36] - WORD $0xbd402018 // ldr s24, [x0, #32] - WORD $0xb9402c0a // ldr w10, [x0, #44] - WORD $0x2ea346f9 // ushl v25.2s, v23.2s, v3.2s - WORD $0x0e973b18 // zip1 v24.2s, v24.2s, v23.2s - WORD $0x0e0c3eeb // mov w11, v23.s[1] - WORD $0x2eb24717 // ushl v23.2s, v24.2s, v25.2s - WORD $0x53027d6c // lsr w12, w11, #2 - WORD $0x0eb71f37 // orr v23.8b, v25.8b, v23.8b - WORD $0x138b654a // extr w10, w10, w11, #25 - WORD $0x4e141d97 // mov v23.s[2], w12 - WORD $0x4e1c1d57 // mov v23.s[3], w10 - WORD $0x4e201ef7 // and v23.16b, v23.16b, v0.16b - WORD $0x3c9f0137 // stur q23, [x9, #-16] - WORD $0x2945ac0a // ldp w10, w11, [x0, #44] - WORD $0xfc434017 // ldur d23, [x0, #52] - WORD $0x1e270178 // fmov s24, w11 - WORD $0x138a416a // extr w10, w11, w10, #16 - WORD $0x0e973b18 // zip1 v24.2s, v24.2s, v23.2s - WORD $0x53077d6c // lsr w12, w11, #7 - WORD $0x2ea446f7 // ushl v23.2s, v23.2s, v4.2s - WORD $0x1e270159 // fmov s25, w10 - WORD $0x2eb34718 // ushl v24.2s, v24.2s, v19.2s - WORD $0x4e0c1d99 // mov v25.s[1], w12 - WORD $0x0eb81ef7 // orr v23.8b, v23.8b, v24.8b - WORD $0x6e1806f9 // mov v25.d[1], v23.d[0] - WORD $0x4e201f37 // and v23.16b, v25.16b, v0.16b - WORD $0x3d800137 // str q23, [x9] - WORD $0x29472c0a // ldp w10, w11, [x0, #56] - WORD $0xfd402017 // ldr d23, [x0, #64] - WORD $0x1e270178 // fmov s24, w11 - WORD $0x138a316a // extr w10, w11, w10, #12 - WORD $0x0e973b18 // zip1 v24.2s, v24.2s, v23.2s - WORD $0x53037d6c // lsr w12, w11, #3 - WORD $0x2ea546f7 // ushl v23.2s, v23.2s, v5.2s - WORD $0x1e270159 // fmov s25, w10 - WORD $0x2eb44718 // ushl v24.2s, v24.2s, v20.2s - WORD $0x4e0c1d99 // mov v25.s[1], w12 - WORD $0x0eb81ef7 // orr v23.8b, v23.8b, v24.8b - WORD $0x6e1806f9 // mov v25.d[1], v23.d[0] - WORD $0x4e201f37 // and v23.16b, v25.16b, v0.16b - WORD $0x3d800537 // str q23, [x9, #16] - WORD $0xb940440a // ldr w10, [x0, #68] - WORD $0xfd402417 // ldr d23, [x0, #72] - WORD $0xb940500b // ldr w11, [x0, #80] - WORD $0x1e270158 // fmov s24, w10 - WORD $0x0e973b18 // zip1 v24.2s, v24.2s, v23.2s - WORD $0x53087d4c // lsr w12, w10, #8 - WORD $0x2ea646f9 // ushl v25.2s, v23.2s, v6.2s - WORD $0x0e0c3eea // mov w10, v23.s[1] - WORD $0x2eb54717 // ushl v23.2s, v24.2s, v21.2s - WORD $0x1e270198 // fmov s24, w12 - WORD $0x0eb71f37 // orr v23.8b, v25.8b, v23.8b - WORD $0x6e0c06f8 // mov v24.s[1], v23.s[0] - WORD $0x138a356a // extr w10, w11, w10, #13 - WORD $0x6e1426f8 // mov v24.s[2], v23.s[1] - WORD $0x4e1c1d58 // mov v24.s[3], w10 - WORD $0x4e201f17 // and v23.16b, v24.16b, v0.16b - WORD $0x3d800937 // str q23, [x9, #32] - WORD $0xb940500a // ldr w10, [x0, #80] - WORD $0xfc454017 // ldur d23, [x0, #84] - WORD $0x91017000 // add x0, x0, #92 - WORD $0x1e270158 // fmov s24, w10 - WORD $0x0e973b18 // zip1 v24.2s, v24.2s, v23.2s - WORD $0x53047d4b // lsr w11, w10, #4 - WORD $0x2ea746f9 // ushl v25.2s, v23.2s, v7.2s - WORD $0x0e0c3eea // mov w10, v23.s[1] - WORD $0x2eb64717 // ushl v23.2s, v24.2s, v22.2s - WORD $0x1e270178 // fmov s24, w11 - WORD $0x0eb71f37 // orr v23.8b, v25.8b, v23.8b - WORD $0x6e0c06f8 // mov v24.s[1], v23.s[0] - WORD $0x53097d4a // lsr w10, w10, #9 - WORD $0x6e1426f8 // mov v24.s[2], v23.s[1] - WORD $0x4e1c1d58 // mov v24.s[3], w10 - WORD $0x4e201f17 // and v23.16b, v24.16b, v0.16b - WORD $0x3d800d37 // str q23, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_72 - JMP LBB0_99 -LBB0_73: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - WORD $0x91001829 // add x9, x1, #6 + WORD $0x7100487f // cmp w3, #18 + BEQ LBB0_130 + + // %bb.71: + WORD $0x71004c7f // cmp w3, #19 + BNE LBB0_156 + + // %bb.72: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.73: + // WORD $0x90000008 // adrp x8, .LCPI0_130 + // WORD $0x90000009 // adrp x9, .LCPI0_131 + // WORD $0x9000000a // adrp x10, .LCPI0_132 + WORD $0x4f00d4e7 // movi v7.4s, #7, msl #16 + VMOVD LCPI0_130, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_133 + VMOVD LCPI0_131, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_134 + VMOVD LCPI0_132, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_135 + VMOVD LCPI0_133, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_136 + VMOVD LCPI0_134, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_137 + VMOVD LCPI0_135, V5 + VMOVD LCPI0_136, V6 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_137, V16 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_74: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x138a4d6c // extr w12, w11, w10, #19 + WORD $0x1e270151 // fmov s17, w10 + WORD $0x53067d6a // lsr w10, w11, #6 + WORD $0x4e0c1d91 // mov v17.s[1], w12 + WORD $0xb940080c // ldr w12, [x0, #8] + WORD $0x4e141d51 // mov v17.s[2], w10 + WORD $0x138b658a // extr w10, w12, w11, #25 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9c0111 // stur q17, [x8, #-64] + WORD $0xb940080a // ldr w10, [x0, #8] + WORD $0xfc40c011 // ldur d17, [x0, #12] + WORD $0x1e270152 // fmov s18, w10 + WORD $0x530c7d4a // lsr w10, w10, #12 + WORD $0x2ea04633 // ushl v19.2s, v17.2s, v0.2s + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x1e270154 // fmov s20, w10 + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x6e142294 // ext v20.16b, v20.16b, v20.16b, #4 + WORD $0x2ea14652 // ushl v18.2s, v18.2s, v1.2s + WORD $0x53057d4a // lsr w10, w10, #5 + WORD $0x0eb21e72 // orr v18.8b, v19.8b, v18.8b + WORD $0x6e126291 // ext v17.16b, v20.16b, v18.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9d0111 // stur q17, [x8, #-48] + WORD $0x2942280b // ldp w11, w10, [x0, #16] + WORD $0xfd400c11 // ldr d17, [x0, #24] + WORD $0x1e270152 // fmov s18, w10 + WORD $0x138b614b // extr w11, w10, w11, #24 + WORD $0x530b7d4a // lsr w10, w10, #11 + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x2ea24631 // ushl v17.2s, v17.2s, v2.2s + WORD $0x1e270173 // fmov s19, w11 + WORD $0x2ea34652 // ushl v18.2s, v18.2s, v3.2s + WORD $0x4e0c1d53 // mov v19.s[1], w10 + WORD $0x0eb21e31 // orr v17.8b, v17.8b, v18.8b + WORD $0x6e180633 // mov v19.d[1], v17.d[0] + WORD $0x4e271e71 // and v17.16b, v19.16b, v7.16b + WORD $0x3c9e0111 // stur q17, [x8, #-32] + WORD $0x2943ac0a // ldp w10, w11, [x0, #28] + WORD $0x53047d4c // lsr w12, w10, #4 + WORD $0x138a5d6a // extr w10, w11, w10, #23 + WORD $0x1e270191 // fmov s17, w12 + WORD $0xb940240c // ldr w12, [x0, #36] + WORD $0x4e0c1d51 // mov v17.s[1], w10 + WORD $0x530a7d6a // lsr w10, w11, #10 + WORD $0x4e141d51 // mov v17.s[2], w10 + WORD $0x138b758a // extr w10, w12, w11, #29 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9f0111 // stur q17, [x8, #-16] + WORD $0x2944ac0a // ldp w10, w11, [x0, #36] + WORD $0x138a416a // extr w10, w11, w10, #16 + WORD $0x53037d6c // lsr w12, w11, #3 + WORD $0x1e270151 // fmov s17, w10 + WORD $0xb9402c0a // ldr w10, [x0, #44] + WORD $0x138b594b // extr w11, w10, w11, #22 + WORD $0x4e0c1d91 // mov v17.s[1], w12 + WORD $0x53097d4a // lsr w10, w10, #9 + WORD $0x4e141d71 // mov v17.s[2], w11 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800111 // str q17, [x8] + WORD $0xfd401811 // ldr d17, [x0, #48] + WORD $0xbd402c12 // ldr s18, [x0, #44] + WORD $0xb940380c // ldr w12, [x0, #56] + WORD $0x2ea44633 // ushl v19.2s, v17.2s, v4.2s + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x53027d4b // lsr w11, w10, #2 + WORD $0x138a558a // extr w10, w12, w10, #21 + WORD $0x2ea54652 // ushl v18.2s, v18.2s, v5.2s + WORD $0x0eb21e71 // orr v17.8b, v19.8b, v18.8b + WORD $0x4e141d71 // mov v17.s[2], w11 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800511 // str q17, [x8, #16] + WORD $0xb940380a // ldr w10, [x0, #56] + WORD $0xfc43c011 // ldur d17, [x0, #60] + WORD $0x1e270152 // fmov s18, w10 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea64633 // ushl v19.2s, v17.2s, v6.2s + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x1e270154 // fmov s20, w10 + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x6e142294 // ext v20.16b, v20.16b, v20.16b, #4 + WORD $0x2eb04652 // ushl v18.2s, v18.2s, v16.2s + WORD $0x53017d4a // lsr w10, w10, #1 + WORD $0x0eb21e72 // orr v18.8b, v19.8b, v18.8b + WORD $0x6e126291 // ext v17.16b, v20.16b, v18.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800911 // str q17, [x8, #32] + WORD $0x29482c0a // ldp w10, w11, [x0, #64] + WORD $0x138a516a // extr w10, w11, w10, #20 + WORD $0x53077d6c // lsr w12, w11, #7 + WORD $0x1e270151 // fmov s17, w10 + WORD $0xb940480a // ldr w10, [x0, #72] + WORD $0x91013000 // add x0, x0, #76 + WORD $0x138b694b // extr w11, w10, w11, #26 + WORD $0x4e0c1d91 // mov v17.s[1], w12 + WORD $0x530d7d4a // lsr w10, w10, #13 + WORD $0x4e141d71 // mov v17.s[2], w11 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800d11 // str q17, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_74 + JMP LBB0_156 + LBB0_75: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0xb940080c // ldr w12, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x1e270140 // fmov s0, w10 - WORD $0x138b418b // extr w11, w12, w11, #16 - WORD $0x4e0c1da0 // mov v0.s[1], w13 - WORD $0x53087d8c // lsr w12, w12, #8 - WORD $0x4e141d60 // mov v0.s[2], w11 - WORD $0x4e1c1d80 // mov v0.s[3], w12 - WORD $0x6f0777e0 // bic v0.4s, #255, lsl #24 - WORD $0x3c9c0120 // stur q0, [x9, #-64] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0xb940140c // ldr w12, [x0, #20] - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x1e270140 // fmov s0, w10 - WORD $0x138b418b // extr w11, w12, w11, #16 - WORD $0x4e0c1da0 // mov v0.s[1], w13 - WORD $0x53087d8c // lsr w12, w12, #8 - WORD $0x4e141d60 // mov v0.s[2], w11 - WORD $0x4e1c1d80 // mov v0.s[3], w12 - WORD $0x6f0777e0 // bic v0.4s, #255, lsl #24 - WORD $0x3c9d0120 // stur q0, [x9, #-48] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0xb940200c // ldr w12, [x0, #32] - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x1e270140 // fmov s0, w10 - WORD $0x138b418b // extr w11, w12, w11, #16 - WORD $0x4e0c1da0 // mov v0.s[1], w13 - WORD $0x53087d8c // lsr w12, w12, #8 - WORD $0x4e141d60 // mov v0.s[2], w11 - WORD $0x4e1c1d80 // mov v0.s[3], w12 - WORD $0x6f0777e0 // bic v0.4s, #255, lsl #24 - WORD $0x3c9e0120 // stur q0, [x9, #-32] - WORD $0x2944ac0a // ldp w10, w11, [x0, #36] - WORD $0xb9402c0c // ldr w12, [x0, #44] - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x1e270140 // fmov s0, w10 - WORD $0x138b418b // extr w11, w12, w11, #16 - WORD $0x4e0c1da0 // mov v0.s[1], w13 - WORD $0x53087d8c // lsr w12, w12, #8 - WORD $0x4e141d60 // mov v0.s[2], w11 - WORD $0x4e1c1d80 // mov v0.s[3], w12 - WORD $0x6f0777e0 // bic v0.4s, #255, lsl #24 - WORD $0x3c9f0120 // stur q0, [x9, #-16] - WORD $0x29462c0a // ldp w10, w11, [x0, #48] - WORD $0xb940380c // ldr w12, [x0, #56] - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x1e270140 // fmov s0, w10 - WORD $0x138b418b // extr w11, w12, w11, #16 - WORD $0x4e0c1da0 // mov v0.s[1], w13 - WORD $0x53087d8c // lsr w12, w12, #8 - WORD $0x4e141d60 // mov v0.s[2], w11 - WORD $0x4e1c1d80 // mov v0.s[3], w12 - WORD $0x6f0777e0 // bic v0.4s, #255, lsl #24 - WORD $0x3d800120 // str q0, [x9] - WORD $0x2947ac0a // ldp w10, w11, [x0, #60] - WORD $0xb940440c // ldr w12, [x0, #68] - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x1e270140 // fmov s0, w10 - WORD $0x138b418b // extr w11, w12, w11, #16 - WORD $0x4e0c1da0 // mov v0.s[1], w13 - WORD $0x53087d8c // lsr w12, w12, #8 - WORD $0x4e141d60 // mov v0.s[2], w11 - WORD $0x4e1c1d80 // mov v0.s[3], w12 - WORD $0x6f0777e0 // bic v0.4s, #255, lsl #24 - WORD $0x3d800520 // str q0, [x9, #16] - WORD $0x29492c0a // ldp w10, w11, [x0, #72] - WORD $0xb940500c // ldr w12, [x0, #80] - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x1e270140 // fmov s0, w10 - WORD $0x138b418b // extr w11, w12, w11, #16 - WORD $0x4e0c1da0 // mov v0.s[1], w13 - WORD $0x53087d8c // lsr w12, w12, #8 - WORD $0x4e141d60 // mov v0.s[2], w11 - WORD $0x4e1c1d80 // mov v0.s[3], w12 - WORD $0x6f0777e0 // bic v0.4s, #255, lsl #24 - WORD $0x3d800920 // str q0, [x9, #32] - WORD $0x294aac0a // ldp w10, w11, [x0, #84] - WORD $0xb9405c0c // ldr w12, [x0, #92] - WORD $0x91018000 // add x0, x0, #96 - WORD $0x138a616d // extr w13, w11, w10, #24 - WORD $0x1e270140 // fmov s0, w10 - WORD $0x138b418b // extr w11, w12, w11, #16 - WORD $0x4e0c1da0 // mov v0.s[1], w13 - WORD $0x53087d8c // lsr w12, w12, #8 - WORD $0x4e141d60 // mov v0.s[2], w11 - WORD $0x4e1c1d80 // mov v0.s[3], w12 - WORD $0x6f0777e0 // bic v0.4s, #255, lsl #24 - WORD $0x3d800d20 // str q0, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_75 - JMP LBB0_99 -LBB0_76: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x000000160000001d, R7 // LCPI0_56 - MOVD $0x0000000a00000003, R0 // LCPI0_57 - MOVD $0x000000130000001a, R16 // LCPI0_58 - MOVD $0x0000000d00000006, R1 // LCPI0_59 - MOVD $0x000000170000001e, R17 // LCPI0_60 - MOVD $0x0000000900000002, R2 // LCPI0_61 - MOVD $0x0000000900000010, R25 // LCPI0_62 - MOVD $0x0000001700000010, R3 // LCPI0_63 - MOVD $0x0000000d00000014, R19 // LCPI0_64 - MOVD $0x000000130000000c, R4 // LCPI0_65 - MOVD $0x0000001100000018, R20 // LCPI0_66 - MOVD $0x0000000f00000008, R5 // LCPI0_67 - MOVD $0x000000150000001c, R21 // LCPI0_68 - MOVD $0x0000000b00000004, R6 // LCPI0_69 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x2ea0b8e7 // neg v7.2s, v7.2s - WORD $0x2ea0ba10 // neg v16.2s, v16.2s - WORD $0x2ea0ba31 // neg v17.2s, v17.2s - WORD $0x2ea0bb39 // neg v25.2s, v25.2s - WORD $0x2ea0ba73 // neg v19.2s, v19.2s - WORD $0x2ea0ba94 // neg v20.2s, v20.2s - WORD $0x2ea0bab5 // neg v21.2s, v21.2s -LBB0_78: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0x2941340c // ldp w12, w13, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a656e // extr w14, w11, w10, #25 - WORD $0x1e270156 // fmov s22, w10 - WORD $0x138b498b // extr w11, w12, w11, #18 - WORD $0x4e0c1dd6 // mov v22.s[1], w14 - WORD $0x138c2dac // extr w12, w13, w12, #11 - WORD $0x4e141d76 // mov v22.s[2], w11 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f0777d6 // bic v22.4s, #254, lsl #24 - WORD $0x3c9c0136 // stur q22, [x9, #-64] - WORD $0xb9400c0a // ldr w10, [x0, #12] - WORD $0xfd400816 // ldr d22, [x0, #16] - WORD $0xb940180b // ldr w11, [x0, #24] - WORD $0x1e270157 // fmov s23, w10 - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x2ea046d8 // ushl v24.2s, v22.2s, v0.2s - WORD $0x0e0c3eca // mov w10, v22.s[1] - WORD $0x2ea746f6 // ushl v22.2s, v23.2s, v7.2s - WORD $0x1e270197 // fmov s23, w12 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x6e0c06d7 // mov v23.s[1], v22.s[0] - WORD $0x138a3d6a // extr w10, w11, w10, #15 - WORD $0x6e1426d7 // mov v23.s[2], v22.s[1] - WORD $0x4e1c1d57 // mov v23.s[3], w10 - WORD $0x6f0777d7 // bic v23.4s, #254, lsl #24 - WORD $0x3c9d0137 // stur q23, [x9, #-48] - WORD $0x29432c0a // ldp w10, w11, [x0, #24] - WORD $0xfd401016 // ldr d22, [x0, #32] - WORD $0x1e270177 // fmov s23, w11 - WORD $0x138a216a // extr w10, w11, w10, #8 - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x53017d6c // lsr w12, w11, #1 - WORD $0x2ea146d6 // ushl v22.2s, v22.2s, v1.2s - WORD $0x1e270158 // fmov s24, w10 - WORD $0x2eb046f7 // ushl v23.2s, v23.2s, v16.2s - WORD $0x4e0c1d98 // mov v24.s[1], w12 - WORD $0x0eb71ed6 // orr v22.8b, v22.8b, v23.8b - WORD $0x6e1806d8 // mov v24.d[1], v22.d[0] - WORD $0x6f0777d8 // bic v24.4s, #254, lsl #24 - WORD $0x3c9e0138 // stur q24, [x9, #-32] - WORD $0x2944ac0a // ldp w10, w11, [x0, #36] - WORD $0xfc42c016 // ldur d22, [x0, #44] - WORD $0x1e270177 // fmov s23, w11 - WORD $0x138a316a // extr w10, w11, w10, #12 - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x53057d6c // lsr w12, w11, #5 - WORD $0x2ea246d6 // ushl v22.2s, v22.2s, v2.2s - WORD $0x1e270158 // fmov s24, w10 - WORD $0x2eb146f7 // ushl v23.2s, v23.2s, v17.2s - WORD $0x4e0c1d98 // mov v24.s[1], w12 - WORD $0x0eb71ed6 // orr v22.8b, v22.8b, v23.8b - WORD $0x6e1806d8 // mov v24.d[1], v22.d[0] - WORD $0x6f0777d8 // bic v24.4s, #254, lsl #24 - WORD $0x3c9f0138 // stur q24, [x9, #-16] - WORD $0xfc434016 // ldur d22, [x0, #52] - WORD $0xbd403017 // ldr s23, [x0, #48] - WORD $0xb9403c0a // ldr w10, [x0, #60] - WORD $0x2ea346d8 // ushl v24.2s, v22.2s, v3.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb246f6 // ushl v22.2s, v23.2s, v25.2s - WORD $0x53027d6c // lsr w12, w11, #2 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x138b6d4a // extr w10, w10, w11, #27 - WORD $0x4e141d96 // mov v22.s[2], w12 - WORD $0x4e1c1d56 // mov v22.s[3], w10 - WORD $0x6f0777d6 // bic v22.4s, #254, lsl #24 - WORD $0x3d800136 // str q22, [x9] - WORD $0xfd402016 // ldr d22, [x0, #64] - WORD $0xbd403c17 // ldr s23, [x0, #60] - WORD $0xb940480a // ldr w10, [x0, #72] - WORD $0x2ea446d8 // ushl v24.2s, v22.2s, v4.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb346f6 // ushl v22.2s, v23.2s, v19.2s - WORD $0x53067d6c // lsr w12, w11, #6 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x138b7d4a // extr w10, w10, w11, #31 - WORD $0x4e141d96 // mov v22.s[2], w12 - WORD $0x4e1c1d56 // mov v22.s[3], w10 - WORD $0x6f0777d6 // bic v22.4s, #254, lsl #24 - WORD $0x3d800536 // str q22, [x9, #16] - WORD $0xfc44c016 // ldur d22, [x0, #76] - WORD $0xbd404817 // ldr s23, [x0, #72] - WORD $0xb940540a // ldr w10, [x0, #84] - WORD $0x2ea546d8 // ushl v24.2s, v22.2s, v5.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb446f6 // ushl v22.2s, v23.2s, v20.2s - WORD $0x53037d4c // lsr w12, w10, #3 - WORD $0x138b294a // extr w10, w10, w11, #10 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x4e141d56 // mov v22.s[2], w10 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f0777d6 // bic v22.4s, #254, lsl #24 - WORD $0x3d800936 // str q22, [x9, #32] - WORD $0xfd402c16 // ldr d22, [x0, #88] - WORD $0xbd405417 // ldr s23, [x0, #84] - WORD $0xb940600a // ldr w10, [x0, #96] - WORD $0x91019000 // add x0, x0, #100 - WORD $0x2ea646d8 // ushl v24.2s, v22.2s, v6.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb546f6 // ushl v22.2s, v23.2s, v21.2s - WORD $0x138b394a // extr w10, w10, w11, #14 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x4e141d56 // mov v22.s[2], w10 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f0777d6 // bic v22.4s, #254, lsl #24 - WORD $0x3d800d36 // str q22, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_78 - JMP LBB0_99 + WORD $0x7100287f // cmp w3, #10 + BEQ LBB0_133 + + // %bb.76: + WORD $0x71002c7f // cmp w3, #11 + BNE LBB0_156 + + // %bb.77: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.78: + // WORD $0x90000009 // adrp x9, .LCPI0_147 + // WORD $0x90000008 // adrp x8, .LCPI0_146 + // WORD $0x9000000a // adrp x10, .LCPI0_148 + WORD $0x4f00c4e6 // movi v6.4s, #7, msl #8 + VMOVD LCPI0_147, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_150 + VMOVD LCPI0_146, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_149 + VMOVD LCPI0_148, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_151 + VMOVD LCPI0_150, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_152 + VMOVD LCPI0_149, V3 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_151, V5 + VMOVD LCPI0_152, V7 + WORD $0xaa1303e9 // mov x9, x19 + LBB0_79: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x000000070000000c, R7 // LCPI0_36 - MOVD $0x0000001900000014, R0 // LCPI0_37 - VMOVQ $0x0000001300000018, $0x000000090000000e, V16 // LCPI0_38 - VMOVQ $0x0000000d00000008, $0x0000001700000012, V1 // LCPI0_39 - MOVD $0x0000001a0000001f, R17 // LCPI0_40 - MOVD $0x0000000600000001, R2 // LCPI0_41 - MOVD $0x0000000b00000010, R25 // LCPI0_42 - MOVD $0x0000001500000010, R3 // LCPI0_43 - VMOVQ $0x000000170000001c, $0x0000000d00000012, V19 // LCPI0_44 - VMOVQ $0x0000000900000004, $0x000000130000000e, V4 // LCPI0_45 - MOVD $0x000000190000001e, R20 // LCPI0_46 - MOVD $0x0000000700000002, R5 // LCPI0_47 - MOVD $0x0000000f00000014, R21 // LCPI0_48 - MOVD $0x000000110000000c, R6 // LCPI0_49 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x2ea0b8e7 // neg v7.2s, v7.2s - WORD $0x6ea0ba10 // neg v16.4s, v16.4s - WORD $0x2ea0ba31 // neg v17.2s, v17.2s - WORD $0x2ea0bb39 // neg v25.2s, v25.2s - WORD $0x6ea0ba73 // neg v19.4s, v19.4s - WORD $0x2ea0ba94 // neg v20.2s, v20.2s - WORD $0x2ea0bab5 // neg v21.2s, v21.2s -LBB0_81: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0x2941340c // ldp w12, w13, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a6d6e // extr w14, w11, w10, #27 - WORD $0x1e270156 // fmov s22, w10 - WORD $0x138b598b // extr w11, w12, w11, #22 - WORD $0x4e0c1dd6 // mov v22.s[1], w14 - WORD $0x138c45ac // extr w12, w13, w12, #17 - WORD $0x4e141d76 // mov v22.s[2], w11 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f077716 // bic v22.4s, #248, lsl #24 - WORD $0x3c9c0136 // stur q22, [x9, #-64] - WORD $0xfd400816 // ldr d22, [x0, #16] - WORD $0xbd400c17 // ldr s23, [x0, #12] - WORD $0xb940180a // ldr w10, [x0, #24] - WORD $0x2ea046d8 // ushl v24.2s, v22.2s, v0.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2ea746f6 // ushl v22.2s, v23.2s, v7.2s - WORD $0x53027d6c // lsr w12, w11, #2 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x138b754a // extr w10, w10, w11, #29 - WORD $0x4e141d96 // mov v22.s[2], w12 - WORD $0x4e1c1d56 // mov v22.s[3], w10 - WORD $0x6f077716 // bic v22.4s, #248, lsl #24 - WORD $0x3c9d0136 // stur q22, [x9, #-48] - WORD $0xbd401816 // ldr s22, [x0, #24] - WORD $0x3cc1c017 // ldur q23, [x0, #28] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6ea146f8 // ushl v24.4s, v23.4s, v1.4s - WORD $0x6eb046d6 // ushl v22.4s, v22.4s, v16.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x6f077716 // bic v22.4s, #248, lsl #24 - WORD $0x3c9e0136 // stur q22, [x9, #-32] - WORD $0xb940280a // ldr w10, [x0, #40] - WORD $0xfc42c016 // ldur d22, [x0, #44] - WORD $0xb940340b // ldr w11, [x0, #52] - WORD $0x1e270157 // fmov s23, w10 - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x2ea246d8 // ushl v24.2s, v22.2s, v2.2s - WORD $0x0e0c3eca // mov w10, v22.s[1] - WORD $0x2eb146f6 // ushl v22.2s, v23.2s, v17.2s - WORD $0x1e270197 // fmov s23, w12 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x6e0c06d7 // mov v23.s[1], v22.s[0] - WORD $0x138a556a // extr w10, w11, w10, #21 - WORD $0x6e1426d7 // mov v23.s[2], v22.s[1] - WORD $0x4e1c1d57 // mov v23.s[3], w10 - WORD $0x6f077717 // bic v23.4s, #248, lsl #24 - WORD $0x3c9f0137 // stur q23, [x9, #-16] - WORD $0xfd401c16 // ldr d22, [x0, #56] - WORD $0xbd403417 // ldr s23, [x0, #52] - WORD $0xb940400a // ldr w10, [x0, #64] - WORD $0x2ea346d8 // ushl v24.2s, v22.2s, v3.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb246f6 // ushl v22.2s, v23.2s, v25.2s - WORD $0x53017d4c // lsr w12, w10, #1 - WORD $0x138b194a // extr w10, w10, w11, #6 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x4e141d56 // mov v22.s[2], w10 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f077716 // bic v22.4s, #248, lsl #24 - WORD $0x3d800136 // str q22, [x9] - WORD $0xbd404016 // ldr s22, [x0, #64] - WORD $0x3cc44017 // ldur q23, [x0, #68] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6ea446f8 // ushl v24.4s, v23.4s, v4.4s - WORD $0x6eb346d6 // ushl v22.4s, v22.4s, v19.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x6f077716 // bic v22.4s, #248, lsl #24 - WORD $0x3d800536 // str q22, [x9, #16] - WORD $0x294a2c0a // ldp w10, w11, [x0, #80] - WORD $0xfd402c16 // ldr d22, [x0, #88] - WORD $0x1e270177 // fmov s23, w11 - WORD $0x138a216a // extr w10, w11, w10, #8 - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x53037d6c // lsr w12, w11, #3 - WORD $0x2ea546d6 // ushl v22.2s, v22.2s, v5.2s - WORD $0x1e270158 // fmov s24, w10 - WORD $0x2eb446f7 // ushl v23.2s, v23.2s, v20.2s - WORD $0x4e0c1d98 // mov v24.s[1], w12 - WORD $0x0eb71ed6 // orr v22.8b, v22.8b, v23.8b - WORD $0x6e1806d8 // mov v24.d[1], v22.d[0] - WORD $0x6f077718 // bic v24.4s, #248, lsl #24 - WORD $0x3d800938 // str q24, [x9, #32] - WORD $0xfd403016 // ldr d22, [x0, #96] - WORD $0xbd405c17 // ldr s23, [x0, #92] - WORD $0xb940680a // ldr w10, [x0, #104] - WORD $0x9101b000 // add x0, x0, #108 - WORD $0x2ea646d8 // ushl v24.2s, v22.2s, v6.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb546f6 // ushl v22.2s, v23.2s, v21.2s - WORD $0x53057d4c // lsr w12, w10, #5 - WORD $0x138b294a // extr w10, w10, w11, #10 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x4e141d56 // mov v22.s[2], w10 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f077716 // bic v22.4s, #248, lsl #24 - WORD $0x3d800d36 // str q22, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_81 - JMP LBB0_99 -LBB0_82: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x0000000c00000010, R1 // LCPI0_34 - MOVD $0x0000001400000010, R0 // LCPI0_35 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x2ea0b821 // neg v1.2s, v1.2s + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x530b7d4c // lsr w12, w10, #11 + WORD $0x1e270150 // fmov s16, w10 + WORD $0x138a596a // extr w10, w11, w10, #22 + WORD $0x4e0c1d90 // mov v16.s[1], w12 + WORD $0x4e141d50 // mov v16.s[2], w10 + WORD $0x53017d6a // lsr w10, w11, #1 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x4e261e10 // and v16.16b, v16.16b, v6.16b + WORD $0x3c9c0110 // stur q16, [x8, #-64] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x530c7d4c // lsr w12, w10, #12 + WORD $0x0e040d70 // dup v16.2s, w11 + WORD $0x138a5d6a // extr w10, w11, w10, #23 + WORD $0x1e270191 // fmov s17, w12 + WORD $0x2ea04610 // ushl v16.2s, v16.2s, v0.2s + WORD $0x4e0c1d51 // mov v17.s[1], w10 + WORD $0x6e180611 // mov v17.d[1], v16.d[0] + WORD $0x4e261e30 // and v16.16b, v17.16b, v6.16b + WORD $0x3c9d0110 // stur q16, [x8, #-48] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x0e040d70 // dup v16.2s, w11 + WORD $0x1e270151 // fmov s17, w10 + WORD $0xb940100a // ldr w10, [x0, #16] + WORD $0x2ea14610 // ushl v16.2s, v16.2s, v1.2s + WORD $0x138b654a // extr w10, w10, w11, #25 + WORD $0x6e112231 // ext v17.16b, v17.16b, v17.16b, #4 + WORD $0x6e106230 // ext v16.16b, v17.16b, v16.16b, #12 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x4e261e10 // and v16.16b, v16.16b, v6.16b + WORD $0x3c9e0110 // stur q16, [x8, #-32] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x0e040d50 // dup v16.2s, w10 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x2ea24610 // ushl v16.2s, v16.2s, v2.2s + WORD $0x4e141d50 // mov v16.s[2], w10 + WORD $0x53057d6a // lsr w10, w11, #5 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x4e261e10 // and v16.16b, v16.16b, v6.16b + WORD $0x3c9f0110 // stur q16, [x8, #-16] + WORD $0x2942ac0a // ldp w10, w11, [x0, #20] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x0e040d70 // dup v16.2s, w11 + WORD $0x138a6d6a // extr w10, w11, w10, #27 + WORD $0x1e270191 // fmov s17, w12 + WORD $0x2ea34610 // ushl v16.2s, v16.2s, v3.2s + WORD $0x4e0c1d51 // mov v17.s[1], w10 + WORD $0x6e180611 // mov v17.d[1], v16.d[0] + WORD $0x4e261e30 // and v16.16b, v17.16b, v6.16b + WORD $0x3d800110 // str q16, [x8] + WORD $0x29432c0a // ldp w10, w11, [x0, #24] + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x0e040d70 // dup v16.2s, w11 + WORD $0x1e270151 // fmov s17, w10 + WORD $0xb940200a // ldr w10, [x0, #32] + WORD $0x2ea44610 // ushl v16.2s, v16.2s, v4.2s + WORD $0x138b754a // extr w10, w10, w11, #29 + WORD $0x6e112231 // ext v17.16b, v17.16b, v17.16b, #4 + WORD $0x6e106230 // ext v16.16b, v17.16b, v16.16b, #12 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x4e261e10 // and v16.16b, v16.16b, v6.16b + WORD $0x3d800510 // str q16, [x8, #16] + WORD $0x29442c0a // ldp w10, w11, [x0, #32] + WORD $0x0e040d50 // dup v16.2s, w10 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x2ea54610 // ushl v16.2s, v16.2s, v5.2s + WORD $0x4e141d50 // mov v16.s[2], w10 + WORD $0x53097d6a // lsr w10, w11, #9 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x4e261e10 // and v16.16b, v16.16b, v6.16b + WORD $0x3d800910 // str q16, [x8, #32] + WORD $0x2944ac0a // ldp w10, w11, [x0, #36] + WORD $0x9100b000 // add x0, x0, #44 + WORD $0x53147d4c // lsr w12, w10, #20 + WORD $0x0e040d70 // dup v16.2s, w11 + WORD $0x138a7d6a // extr w10, w11, w10, #31 + WORD $0x1e270191 // fmov s17, w12 + WORD $0x2ea74610 // ushl v16.2s, v16.2s, v7.2s + WORD $0x4e0c1d51 // mov v17.s[1], w10 + WORD $0x6e180611 // mov v17.d[1], v16.d[0] + WORD $0x4e261e30 // and v16.16b, v17.16b, v6.16b + WORD $0x3d800d10 // str q16, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_79 + JMP LBB0_156 + +LBB0_80: + WORD $0x7100687f // cmp w3, #26 + BEQ LBB0_136 + + // %bb.81: + WORD $0x71006c7f // cmp w3, #27 + BNE LBB0_156 + + // %bb.82: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.83: + // WORD $0x90000008 // adrp x8, .LCPI0_52 + // WORD $0x90000009 // adrp x9, .LCPI0_53 + // WORD $0x9000000a // adrp x10, .LCPI0_54 + // WORD $0x9000000b // adrp x11, .LCPI0_67 + VMOVD LCPI0_52, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_55 + VMOVD LCPI0_53, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_56 + VMOVD LCPI0_54, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_57 + VMOVD LCPI0_55, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_58 + VMOVQ LCPI0_56L, LCPI0_56H, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_59 + VMOVQ LCPI0_57L, LCPI0_57H, V5 + // WORD $0x9000000a // adrp x10, .LCPI0_60 + VMOVD LCPI0_58, V6 + // WORD $0x90000008 // adrp x8, .LCPI0_61 + VMOVD LCPI0_59, V7 + // WORD $0x90000009 // adrp x9, .LCPI0_62 + VMOVD LCPI0_60, V16 + // WORD $0x9000000a // adrp x10, .LCPI0_63 + VMOVD LCPI0_61, V17 + // WORD $0x90000008 // adrp x8, .LCPI0_64 + VMOVQ LCPI0_62L, LCPI0_62H, V18 + // WORD $0x90000009 // adrp x9, .LCPI0_65 + VMOVQ LCPI0_63L, LCPI0_63H, V19 + // WORD $0x9000000a // adrp x10, .LCPI0_66 + VMOVD LCPI0_64, V20 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_65, V21 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_66, V22 + VMOVD LCPI0_67, V23 + LBB0_84: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0x2941340c // ldp w12, w13, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a716e // extr w14, w11, w10, #28 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b618b // extr w11, w12, w11, #24 - WORD $0x4e0c1dc2 // mov v2.s[1], w14 - WORD $0x138c51ac // extr w12, w13, w12, #20 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x6f077602 // bic v2.4s, #240, lsl #24 - WORD $0x3c9c0122 // stur q2, [x9, #-64] - WORD $0xfd400802 // ldr d2, [x0, #16] - WORD $0xbd400c03 // ldr s3, [x0, #12] - WORD $0xb940180a // ldr w10, [x0, #24] - WORD $0x2ea04444 // ushl v4.2s, v2.2s, v0.2s - WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s - WORD $0x0e0c3c4b // mov w11, v2.s[1] - WORD $0x2ea14462 // ushl v2.2s, v3.2s, v1.2s - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x138b214a // extr w10, w10, w11, #8 - WORD $0x0ea21c82 // orr v2.8b, v4.8b, v2.8b - WORD $0x4e141d42 // mov v2.s[2], w10 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x6f077602 // bic v2.4s, #240, lsl #24 - WORD $0x3c9d0122 // stur q2, [x9, #-48] - WORD $0x2943ac0a // ldp w10, w11, [x0, #28] - WORD $0x2944b40c // ldp w12, w13, [x0, #36] - WORD $0x138a716e // extr w14, w11, w10, #28 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b618b // extr w11, w12, w11, #24 - WORD $0x4e0c1dc2 // mov v2.s[1], w14 - WORD $0x138c51ac // extr w12, w13, w12, #20 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x6f077602 // bic v2.4s, #240, lsl #24 - WORD $0x3c9e0122 // stur q2, [x9, #-32] - WORD $0xfc42c002 // ldur d2, [x0, #44] - WORD $0xbd402803 // ldr s3, [x0, #40] - WORD $0xb940340a // ldr w10, [x0, #52] - WORD $0x2ea04444 // ushl v4.2s, v2.2s, v0.2s - WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s - WORD $0x0e0c3c4b // mov w11, v2.s[1] - WORD $0x2ea14462 // ushl v2.2s, v3.2s, v1.2s - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x138b214a // extr w10, w10, w11, #8 - WORD $0x0ea21c82 // orr v2.8b, v4.8b, v2.8b - WORD $0x4e141d42 // mov v2.s[2], w10 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x6f077602 // bic v2.4s, #240, lsl #24 - WORD $0x3c9f0122 // stur q2, [x9, #-16] - WORD $0x29472c0a // ldp w10, w11, [x0, #56] - WORD $0x2948340c // ldp w12, w13, [x0, #64] - WORD $0x138a716e // extr w14, w11, w10, #28 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b618b // extr w11, w12, w11, #24 - WORD $0x4e0c1dc2 // mov v2.s[1], w14 - WORD $0x138c51ac // extr w12, w13, w12, #20 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x6f077602 // bic v2.4s, #240, lsl #24 - WORD $0x3d800122 // str q2, [x9] - WORD $0xfd402402 // ldr d2, [x0, #72] - WORD $0xbd404403 // ldr s3, [x0, #68] - WORD $0xb940500a // ldr w10, [x0, #80] - WORD $0x2ea04444 // ushl v4.2s, v2.2s, v0.2s - WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s - WORD $0x0e0c3c4b // mov w11, v2.s[1] - WORD $0x2ea14462 // ushl v2.2s, v3.2s, v1.2s - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x138b214a // extr w10, w10, w11, #8 - WORD $0x0ea21c82 // orr v2.8b, v4.8b, v2.8b - WORD $0x4e141d42 // mov v2.s[2], w10 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x6f077602 // bic v2.4s, #240, lsl #24 - WORD $0x3d800522 // str q2, [x9, #16] - WORD $0x294aac0a // ldp w10, w11, [x0, #84] - WORD $0x294bb40c // ldp w12, w13, [x0, #92] - WORD $0x138a716e // extr w14, w11, w10, #28 - WORD $0x1e270142 // fmov s2, w10 - WORD $0x138b618b // extr w11, w12, w11, #24 - WORD $0x4e0c1dc2 // mov v2.s[1], w14 - WORD $0x138c51ac // extr w12, w13, w12, #20 - WORD $0x4e141d62 // mov v2.s[2], w11 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x6f077602 // bic v2.4s, #240, lsl #24 - WORD $0x3d800922 // str q2, [x9, #32] - WORD $0xfc464002 // ldur d2, [x0, #100] - WORD $0xbd406003 // ldr s3, [x0, #96] - WORD $0xb9406c0a // ldr w10, [x0, #108] - WORD $0x9101c000 // add x0, x0, #112 - WORD $0x2ea04444 // ushl v4.2s, v2.2s, v0.2s - WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s - WORD $0x0e0c3c4b // mov w11, v2.s[1] - WORD $0x2ea14462 // ushl v2.2s, v3.2s, v1.2s - WORD $0x53047d4c // lsr w12, w10, #4 - WORD $0x138b214a // extr w10, w10, w11, #8 - WORD $0x0ea21c82 // orr v2.8b, v4.8b, v2.8b - WORD $0x4e141d42 // mov v2.s[2], w10 - WORD $0x4e1c1d82 // mov v2.s[3], w12 - WORD $0x6f077602 // bic v2.4s, #240, lsl #24 - WORD $0x3d800d22 // str q2, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_84 - JMP LBB0_99 + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404018 // ldur d24, [x0, #4] + WORD $0xb9400c0b // ldr w11, [x0, #12] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x1e27015a // fmov s26, w10 + WORD $0x2ea0471b // ushl v27.2s, v24.2s, v0.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x6e1a235a // ext v26.16b, v26.16b, v26.16b, #4 + WORD $0x138a456a // extr w10, w11, w10, #17 + WORD $0x2ea14739 // ushl v25.2s, v25.2s, v1.2s + WORD $0x0eb91f79 // orr v25.8b, v27.8b, v25.8b + WORD $0x6e196358 // ext v24.16b, v26.16b, v25.16b, #12 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f077718 // bic v24.4s, #248, lsl #24 + WORD $0x3c9c0118 // stur q24, [x8, #-64] + WORD $0xfd400818 // ldr d24, [x0, #16] + WORD $0xbd400c19 // ldr s25, [x0, #12] + WORD $0xb940180c // ldr w12, [x0, #24] + WORD $0x2ea2471a // ushl v26.2s, v24.2s, v2.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x53027d4b // lsr w11, w10, #2 + WORD $0x138a758a // extr w10, w12, w10, #29 + WORD $0x2ea34739 // ushl v25.2s, v25.2s, v3.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d78 // mov v24.s[2], w11 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f077718 // bic v24.4s, #248, lsl #24 + WORD $0x3c9d0118 // stur q24, [x8, #-48] + WORD $0xbd401818 // ldr s24, [x0, #24] + WORD $0x3cc1c019 // ldur q25, [x0, #28] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6ea44739 // ushl v25.4s, v25.4s, v4.4s + WORD $0x6ea54718 // ushl v24.4s, v24.4s, v5.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f077718 // bic v24.4s, #248, lsl #24 + WORD $0x3c9e0118 // stur q24, [x8, #-32] + WORD $0xb940280a // ldr w10, [x0, #40] + WORD $0xfc42c018 // ldur d24, [x0, #44] + WORD $0xb940340b // ldr w11, [x0, #52] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x53047d4a // lsr w10, w10, #4 + WORD $0x2ea6471a // ushl v26.2s, v24.2s, v6.2s + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x1e27015b // fmov s27, w10 + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x6e1b237b // ext v27.16b, v27.16b, v27.16b, #4 + WORD $0x2ea74739 // ushl v25.2s, v25.2s, v7.2s + WORD $0x138a556a // extr w10, w11, w10, #21 + WORD $0x0eb91f59 // orr v25.8b, v26.8b, v25.8b + WORD $0x6e196378 // ext v24.16b, v27.16b, v25.16b, #12 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f077718 // bic v24.4s, #248, lsl #24 + WORD $0x3c9f0118 // stur q24, [x8, #-16] + WORD $0xfd401c18 // ldr d24, [x0, #56] + WORD $0xbd403419 // ldr s25, [x0, #52] + WORD $0xb940400b // ldr w11, [x0, #64] + WORD $0x2eb0471a // ushl v26.2s, v24.2s, v16.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x138a196a // extr w10, w11, w10, #6 + WORD $0x2eb14739 // ushl v25.2s, v25.2s, v17.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d58 // mov v24.s[2], w10 + WORD $0x53017d6a // lsr w10, w11, #1 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f077718 // bic v24.4s, #248, lsl #24 + WORD $0x3d800118 // str q24, [x8] + WORD $0xbd404018 // ldr s24, [x0, #64] + WORD $0x3cc44019 // ldur q25, [x0, #68] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6eb24739 // ushl v25.4s, v25.4s, v18.4s + WORD $0x6eb34718 // ushl v24.4s, v24.4s, v19.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f077718 // bic v24.4s, #248, lsl #24 + WORD $0x3d800518 // str q24, [x8, #16] + WORD $0x294a280b // ldp w11, w10, [x0, #80] + WORD $0xfd402c18 // ldr d24, [x0, #88] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x138b214b // extr w11, w10, w11, #8 + WORD $0x53037d4a // lsr w10, w10, #3 + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x2eb44718 // ushl v24.2s, v24.2s, v20.2s + WORD $0x1e27017a // fmov s26, w11 + WORD $0x2eb54739 // ushl v25.2s, v25.2s, v21.2s + WORD $0x4e0c1d5a // mov v26.s[1], w10 + WORD $0x0eb91f18 // orr v24.8b, v24.8b, v25.8b + WORD $0x6e18071a // mov v26.d[1], v24.d[0] + WORD $0x6f07771a // bic v26.4s, #248, lsl #24 + WORD $0x3d80091a // str q26, [x8, #32] + WORD $0xfd403018 // ldr d24, [x0, #96] + WORD $0xbd405c19 // ldr s25, [x0, #92] + WORD $0xb940680b // ldr w11, [x0, #104] + WORD $0x9101b000 // add x0, x0, #108 + WORD $0x2eb6471a // ushl v26.2s, v24.2s, v22.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x138a296a // extr w10, w11, w10, #10 + WORD $0x2eb74739 // ushl v25.2s, v25.2s, v23.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d58 // mov v24.s[2], w10 + WORD $0x53057d6a // lsr w10, w11, #5 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f077718 // bic v24.4s, #248, lsl #24 + WORD $0x3d800d18 // str q24, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_84 + JMP LBB0_156 + LBB0_85: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - VMOVQ $0x0000001100000014, $0x0000000b0000000e, V7 // LCPI0_20 - VMOVQ $0x0000000f0000000c, $0x0000001500000012, V0 // LCPI0_21 - MOVD $0x0000000500000008, R16 // LCPI0_22 - MOVD $0x0000001b00000018, R1 // LCPI0_23 - VMOVQ $0x000000190000001c, $0x0000001300000016, V17 // LCPI0_24 - VMOVQ $0x0000000700000004, $0x0000000d0000000a, V2 // LCPI0_25 - VMOVQ $0x0000000d00000010, $0x000000070000000a, V25 // LCPI0_26 - VMOVQ $0x0000001300000010, $0x0000001900000016, V3 // LCPI0_27 - MOVD $0x0000001b0000001e, R19 // LCPI0_28 - MOVD $0x0000000500000002, R4 // LCPI0_29 - VMOVQ $0x0000001500000018, $0x0000000f00000012, V20 // LCPI0_30 - VMOVQ $0x0000000b00000008, $0x000000110000000e, V5 // LCPI0_31 - MOVD $0x000000090000000c, R21 // LCPI0_32 - MOVD $0x0000001700000014, R6 // LCPI0_33 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x6ea0b8e7 // neg v7.4s, v7.4s - WORD $0x2ea0ba10 // neg v16.2s, v16.2s - WORD $0x6ea0ba31 // neg v17.4s, v17.4s - WORD $0x6ea0ba52 // neg v25.4s, v25.4s - WORD $0x2ea0ba73 // neg v19.2s, v19.2s - WORD $0x6ea0ba94 // neg v20.4s, v20.4s - WORD $0x2ea0bab5 // neg v21.2s, v21.2s -LBB0_87: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0x2941340c // ldp w12, w13, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a756e // extr w14, w11, w10, #29 - WORD $0x1e270156 // fmov s22, w10 - WORD $0x138b698b // extr w11, w12, w11, #26 - WORD $0x4e0c1dd6 // mov v22.s[1], w14 - WORD $0x138c5dac // extr w12, w13, w12, #23 - WORD $0x4e141d76 // mov v22.s[2], w11 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f077416 // bic v22.4s, #224, lsl #24 - WORD $0x3c9c0136 // stur q22, [x9, #-64] - WORD $0xbd400c16 // ldr s22, [x0, #12] - WORD $0x3dc00417 // ldr q23, [x0, #16] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6ea046f8 // ushl v24.4s, v23.4s, v0.4s - WORD $0x6ea746d6 // ushl v22.4s, v22.4s, v7.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x6f077416 // bic v22.4s, #224, lsl #24 - WORD $0x3c9d0136 // stur q22, [x9, #-48] - WORD $0xfd401016 // ldr d22, [x0, #32] - WORD $0xbd401c17 // ldr s23, [x0, #28] - WORD $0xb940280a // ldr w10, [x0, #40] - WORD $0x2ea146d8 // ushl v24.2s, v22.2s, v1.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb046f6 // ushl v22.2s, v23.2s, v16.2s - WORD $0x53027d6c // lsr w12, w11, #2 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x138b7d4a // extr w10, w10, w11, #31 - WORD $0x4e141d96 // mov v22.s[2], w12 - WORD $0x4e1c1d56 // mov v22.s[3], w10 - WORD $0x6f077416 // bic v22.4s, #224, lsl #24 - WORD $0x3c9e0136 // stur q22, [x9, #-32] - WORD $0xbd402816 // ldr s22, [x0, #40] - WORD $0x3cc2c017 // ldur q23, [x0, #44] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6ea246f8 // ushl v24.4s, v23.4s, v2.4s - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6f077418 // bic v24.4s, #224, lsl #24 - WORD $0x6eb146d6 // ushl v22.4s, v22.4s, v17.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x3c9f0136 // stur q22, [x9, #-16] - WORD $0xbd403816 // ldr s22, [x0, #56] - WORD $0x3cc3c017 // ldur q23, [x0, #60] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6ea346f8 // ushl v24.4s, v23.4s, v3.4s - WORD $0x6eb246d6 // ushl v22.4s, v22.4s, v25.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x6f077416 // bic v22.4s, #224, lsl #24 - WORD $0x3d800136 // str q22, [x9] - WORD $0x29492c0a // ldp w10, w11, [x0, #72] - WORD $0xfd402816 // ldr d22, [x0, #80] - WORD $0x1e270177 // fmov s23, w11 - WORD $0x138a116a // extr w10, w11, w10, #4 - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x53017d6c // lsr w12, w11, #1 - WORD $0x2ea446d6 // ushl v22.2s, v22.2s, v4.2s - WORD $0x1e270158 // fmov s24, w10 - WORD $0x2eb346f7 // ushl v23.2s, v23.2s, v19.2s - WORD $0x4e0c1d98 // mov v24.s[1], w12 - WORD $0x0eb71ed6 // orr v22.8b, v22.8b, v23.8b - WORD $0x6e1806d8 // mov v24.d[1], v22.d[0] - WORD $0x6f077418 // bic v24.4s, #224, lsl #24 - WORD $0x3d800538 // str q24, [x9, #16] - WORD $0xbd405416 // ldr s22, [x0, #84] - WORD $0x3cc58017 // ldur q23, [x0, #88] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6ea546f8 // ushl v24.4s, v23.4s, v5.4s - WORD $0x6eb446d6 // ushl v22.4s, v22.4s, v20.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x6f077416 // bic v22.4s, #224, lsl #24 - WORD $0x3d800936 // str q22, [x9, #32] - WORD $0xfd403416 // ldr d22, [x0, #104] - WORD $0xbd406417 // ldr s23, [x0, #100] - WORD $0xb940700a // ldr w10, [x0, #112] - WORD $0x9101d000 // add x0, x0, #116 - WORD $0x2ea646d8 // ushl v24.2s, v22.2s, v6.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb546f6 // ushl v22.2s, v23.2s, v21.2s - WORD $0x53037d4c // lsr w12, w10, #3 - WORD $0x138b194a // extr w10, w10, w11, #6 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x4e141d56 // mov v22.s[2], w10 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f077416 // bic v22.4s, #224, lsl #24 - WORD $0x3d800d36 // str q22, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_87 - JMP LBB0_99 -LBB0_88: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - VMOVQ $0x0000001600000018, $0x0000001200000014, V3 // LCPI0_14 - VMOVQ $0x0000000a00000008, $0x0000000e0000000c, V0 // LCPI0_15 - VMOVQ $0x0000000e00000010, $0x0000000a0000000c, V4 // LCPI0_16 - VMOVQ $0x0000001200000010, $0x0000001600000014, V1 // LCPI0_17 - MOVD $0x0000000600000008, R5 // LCPI0_18 - MOVD $0x0000001a00000018, R2 // LCPI0_19 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x6ea0b863 // neg v3.4s, v3.4s - WORD $0x6ea0b884 // neg v4.4s, v4.4s - WORD $0x2ea0b8a5 // neg v5.2s, v5.2s + WORD $0x7100187f // cmp w3, #6 + BEQ LBB0_139 + + // %bb.86: + WORD $0x71001c7f // cmp w3, #7 + BNE LBB0_156 + + // %bb.87: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.88: + // WORD $0x90000008 // adrp x8, .LCPI0_166 + // WORD $0x90000009 // adrp x9, .LCPI0_167 + // WORD $0x9000000a // adrp x10, .LCPI0_168 + WORD $0x4f0307e7 // movi v7.4s, #127 + VMOVD LCPI0_166, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_169 + VMOVD LCPI0_167, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_170 + VMOVD LCPI0_168, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_171 + VMOVD LCPI0_169, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_172 + VMOVD LCPI0_170, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_173 + VMOVD LCPI0_171, V5 + VMOVD LCPI0_172, V6 + WORD $0x91010348 // add x8, x26, #64 + VMOVQ LCPI0_173L, LCPI0_173H, V16 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_89: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x53157d4a // lsr w10, w10, #21 + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x2ea04631 // ushl v17.2s, v17.2s, v0.2s + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9c0111 // stur q17, [x8, #-64] + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x53117d6a // lsr w10, w11, #17 + WORD $0x2ea14631 // ushl v17.2s, v17.2s, v1.2s + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x6e116251 // ext v17.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9d0111 // stur q17, [x8, #-48] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x53187d4c // lsr w12, w10, #24 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x138a7d6a // extr w10, w11, w10, #31 + WORD $0x1e270192 // fmov s18, w12 + WORD $0x2ea24631 // ushl v17.2s, v17.2s, v2.2s + WORD $0x4e0c1d52 // mov v18.s[1], w10 + WORD $0x6e180632 // mov v18.d[1], v17.d[0] + WORD $0x4e271e51 // and v17.16b, v18.16b, v7.16b + WORD $0x3c9e0111 // stur q17, [x8, #-32] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x53147d4c // lsr w12, w10, #20 + WORD $0x0e040d71 // dup v17.2s, w11 + WORD $0x138a6d6a // extr w10, w11, w10, #27 + WORD $0x1e270192 // fmov s18, w12 + WORD $0x2ea34631 // ushl v17.2s, v17.2s, v3.2s + WORD $0x4e0c1d52 // mov v18.s[1], w10 + WORD $0x6e180632 // mov v18.d[1], v17.d[0] + WORD $0x4e271e51 // and v17.16b, v18.16b, v7.16b + WORD $0x3c9f0111 // stur q17, [x8, #-16] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x2ea44631 // ushl v17.2s, v17.2s, v4.2s + WORD $0x4e141d51 // mov v17.s[2], w10 + WORD $0x53057d6a // lsr w10, w11, #5 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800111 // str q17, [x8] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x2ea54631 // ushl v17.2s, v17.2s, v5.2s + WORD $0x4e141d51 // mov v17.s[2], w10 + WORD $0x53017d6a // lsr w10, w11, #1 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800511 // str q17, [x8, #16] + WORD $0x2942ac0a // ldp w10, w11, [x0, #20] + WORD $0x0e040d51 // dup v17.2s, w10 + WORD $0x53167d4c // lsr w12, w10, #22 + WORD $0x138a756a // extr w10, w11, w10, #29 + WORD $0x2ea64631 // ushl v17.2s, v17.2s, v6.2s + WORD $0x4e141d91 // mov v17.s[2], w12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x9100600a // add x10, x0, #24 + WORD $0x91007000 // add x0, x0, #28 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800911 // str q17, [x8, #32] + WORD $0x4d40c951 // ld1r { v17.4s }, [x10] + WORD $0x6eb04631 // ushl v17.4s, v17.4s, v16.4s + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800d11 // str q17, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_89 + JMP LBB0_156 + LBB0_90: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0x2941340c // ldp w12, w13, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a796e // extr w14, w11, w10, #30 - WORD $0x1e270146 // fmov s6, w10 - WORD $0x138b718b // extr w11, w12, w11, #28 - WORD $0x4e0c1dc6 // mov v6.s[1], w14 - WORD $0x138c69ac // extr w12, w13, w12, #26 - WORD $0x4e141d66 // mov v6.s[2], w11 - WORD $0x4e1c1d86 // mov v6.s[3], w12 - WORD $0x6f067406 // bic v6.4s, #192, lsl #24 - WORD $0x3c9c0126 // stur q6, [x9, #-64] - WORD $0xbd400c06 // ldr s6, [x0, #12] - WORD $0x3dc00407 // ldr q7, [x0, #16] - WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 - WORD $0x6ea044f0 // ushl v16.4s, v7.4s, v0.4s - WORD $0x6e0760c6 // ext v6.16b, v6.16b, v7.16b, #12 - WORD $0x6f067410 // bic v16.4s, #192, lsl #24 - WORD $0x6ea344c6 // ushl v6.4s, v6.4s, v3.4s - WORD $0x4ea61e06 // orr v6.16b, v16.16b, v6.16b - WORD $0x3c9d0126 // stur q6, [x9, #-48] - WORD $0xbd401c06 // ldr s6, [x0, #28] - WORD $0x3dc00807 // ldr q7, [x0, #32] - WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 - WORD $0x6ea144f0 // ushl v16.4s, v7.4s, v1.4s - WORD $0x6e0760c6 // ext v6.16b, v6.16b, v7.16b, #12 - WORD $0x6f067410 // bic v16.4s, #192, lsl #24 - WORD $0x6ea444c6 // ushl v6.4s, v6.4s, v4.4s - WORD $0x4ea61e06 // orr v6.16b, v16.16b, v6.16b - WORD $0x3c9e0126 // stur q6, [x9, #-32] - WORD $0xfd401806 // ldr d6, [x0, #48] - WORD $0xbd402c07 // ldr s7, [x0, #44] - WORD $0xb940380a // ldr w10, [x0, #56] - WORD $0x2ea244d0 // ushl v16.2s, v6.2s, v2.2s - WORD $0x0e8638e7 // zip1 v7.2s, v7.2s, v6.2s - WORD $0x0e0c3ccb // mov w11, v6.s[1] - WORD $0x2ea544e6 // ushl v6.2s, v7.2s, v5.2s - WORD $0x53027d4c // lsr w12, w10, #2 - WORD $0x138b114a // extr w10, w10, w11, #4 - WORD $0x0ea61e06 // orr v6.8b, v16.8b, v6.8b - WORD $0x4e141d46 // mov v6.s[2], w10 - WORD $0x4e1c1d86 // mov v6.s[3], w12 - WORD $0x6f067406 // bic v6.4s, #192, lsl #24 - WORD $0x3c9f0126 // stur q6, [x9, #-16] - WORD $0x2947ac0a // ldp w10, w11, [x0, #60] - WORD $0x2948b40c // ldp w12, w13, [x0, #68] - WORD $0x138a796e // extr w14, w11, w10, #30 - WORD $0x1e270146 // fmov s6, w10 - WORD $0x138b718b // extr w11, w12, w11, #28 - WORD $0x4e0c1dc6 // mov v6.s[1], w14 - WORD $0x138c69ac // extr w12, w13, w12, #26 - WORD $0x4e141d66 // mov v6.s[2], w11 - WORD $0x4e1c1d86 // mov v6.s[3], w12 - WORD $0x6f067406 // bic v6.4s, #192, lsl #24 - WORD $0x3d800126 // str q6, [x9] - WORD $0xbd404806 // ldr s6, [x0, #72] - WORD $0x3cc4c007 // ldur q7, [x0, #76] - WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 - WORD $0x6ea044f0 // ushl v16.4s, v7.4s, v0.4s - WORD $0x6e0760c6 // ext v6.16b, v6.16b, v7.16b, #12 - WORD $0x6f067410 // bic v16.4s, #192, lsl #24 - WORD $0x6ea344c6 // ushl v6.4s, v6.4s, v3.4s - WORD $0x4ea61e06 // orr v6.16b, v16.16b, v6.16b - WORD $0x3d800526 // str q6, [x9, #16] - WORD $0xbd405806 // ldr s6, [x0, #88] - WORD $0x3cc5c007 // ldur q7, [x0, #92] - WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 - WORD $0x6ea144f0 // ushl v16.4s, v7.4s, v1.4s - WORD $0x6e0760c6 // ext v6.16b, v6.16b, v7.16b, #12 - WORD $0x6f067410 // bic v16.4s, #192, lsl #24 - WORD $0x6ea444c6 // ushl v6.4s, v6.4s, v4.4s - WORD $0x4ea61e06 // orr v6.16b, v16.16b, v6.16b - WORD $0x3d800926 // str q6, [x9, #32] - WORD $0xfc46c006 // ldur d6, [x0, #108] - WORD $0xbd406807 // ldr s7, [x0, #104] - WORD $0xb940740a // ldr w10, [x0, #116] - WORD $0x9101e000 // add x0, x0, #120 - WORD $0x2ea244d0 // ushl v16.2s, v6.2s, v2.2s - WORD $0x0e8638e7 // zip1 v7.2s, v7.2s, v6.2s - WORD $0x0e0c3ccb // mov w11, v6.s[1] - WORD $0x2ea544e6 // ushl v6.2s, v7.2s, v5.2s - WORD $0x53027d4c // lsr w12, w10, #2 - WORD $0x138b114a // extr w10, w10, w11, #4 - WORD $0x0ea61e06 // orr v6.8b, v16.8b, v6.8b - WORD $0x4e141d46 // mov v6.s[2], w10 - WORD $0x4e1c1d86 // mov v6.s[3], w12 - WORD $0x6f067406 // bic v6.4s, #192, lsl #24 - WORD $0x3d800d26 // str q6, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_90 - JMP LBB0_99 -LBB0_91: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - VMOVQ $0x0000001b0000001c, $0x000000190000001a, V7 // LCPI0_0 - VMOVQ $0x0000000500000004, $0x0000000700000006, V0 // LCPI0_1 - VMOVQ $0x0000001700000018, $0x0000001500000016, V16 // LCPI0_2 - VMOVQ $0x0000000900000008, $0x0000000b0000000a, V1 // LCPI0_3 - VMOVQ $0x0000001300000014, $0x0000001100000012, V17 // LCPI0_4 - VMOVQ $0x0000000d0000000c, $0x0000000f0000000e, V2 // LCPI0_5 - VMOVQ $0x0000000f00000010, $0x0000000d0000000e, V25 // LCPI0_6 - VMOVQ $0x0000001100000010, $0x0000001300000012, V3 // LCPI0_7 - VMOVQ $0x0000000b0000000c, $0x000000090000000a, V19 // LCPI0_8 - VMOVQ $0x0000001500000014, $0x0000001700000016, V4 // LCPI0_9 - VMOVQ $0x0000000700000008, $0x0000000500000006, V20 // LCPI0_10 - VMOVQ $0x0000001900000018, $0x0000001b0000001a, V5 // LCPI0_11 - MOVD $0x0000000300000004, R21 // LCPI0_12 - MOVD $0x0000001d0000001c, R6 // LCPI0_13 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x6ea0b8e7 // neg v7.4s, v7.4s - WORD $0x6ea0ba10 // neg v16.4s, v16.4s - WORD $0x6ea0ba31 // neg v17.4s, v17.4s - WORD $0x6ea0ba52 // neg v25.4s, v25.4s - WORD $0x6ea0ba73 // neg v19.4s, v19.4s - WORD $0x6ea0ba94 // neg v20.4s, v20.4s - WORD $0x2ea0bab5 // neg v21.2s, v21.2s -LBB0_93: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0x2941340c // ldp w12, w13, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a7d6e // extr w14, w11, w10, #31 - WORD $0x1e270156 // fmov s22, w10 - WORD $0x4e0c1dd6 // mov v22.s[1], w14 - WORD $0x138c75ac // extr w12, w13, w12, #29 - WORD $0x4e141d76 // mov v22.s[2], w11 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f047416 // bic v22.4s, #128, lsl #24 - WORD $0x3c9c0136 // stur q22, [x9, #-64] - WORD $0xbd400c16 // ldr s22, [x0, #12] - WORD $0x3dc00417 // ldr q23, [x0, #16] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6ea046f8 // ushl v24.4s, v23.4s, v0.4s - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6f047418 // bic v24.4s, #128, lsl #24 - WORD $0x6ea746d6 // ushl v22.4s, v22.4s, v7.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x3c9d0136 // stur q22, [x9, #-48] - WORD $0xbd401c16 // ldr s22, [x0, #28] - WORD $0x3dc00817 // ldr q23, [x0, #32] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6ea146f8 // ushl v24.4s, v23.4s, v1.4s - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6f047418 // bic v24.4s, #128, lsl #24 - WORD $0x6eb046d6 // ushl v22.4s, v22.4s, v16.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x3c9e0136 // stur q22, [x9, #-32] - WORD $0xbd402c16 // ldr s22, [x0, #44] - WORD $0x3dc00c17 // ldr q23, [x0, #48] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6ea246f8 // ushl v24.4s, v23.4s, v2.4s - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6f047418 // bic v24.4s, #128, lsl #24 - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x3c9f0136 // stur q22, [x9, #-16] - WORD $0xbd403c16 // ldr s22, [x0, #60] - WORD $0x3dc01017 // ldr q23, [x0, #64] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6ea346f8 // ushl v24.4s, v23.4s, v3.4s - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6f047418 // bic v24.4s, #128, lsl #24 - WORD $0x6eb246d6 // ushl v22.4s, v22.4s, v25.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x3d800136 // str q22, [x9] - WORD $0xbd404c16 // ldr s22, [x0, #76] - WORD $0x3dc01417 // ldr q23, [x0, #80] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6ea446f8 // ushl v24.4s, v23.4s, v4.4s - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6f047418 // bic v24.4s, #128, lsl #24 - WORD $0x6eb346d6 // ushl v22.4s, v22.4s, v19.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x3d800536 // str q22, [x9, #16] - WORD $0xbd405c16 // ldr s22, [x0, #92] - WORD $0x3dc01817 // ldr q23, [x0, #96] - WORD $0x6e1622d6 // ext v22.16b, v22.16b, v22.16b, #4 - WORD $0x6ea546f8 // ushl v24.4s, v23.4s, v5.4s - WORD $0x6e1762d6 // ext v22.16b, v22.16b, v23.16b, #12 - WORD $0x6f047418 // bic v24.4s, #128, lsl #24 - WORD $0x6eb446d6 // ushl v22.4s, v22.4s, v20.4s - WORD $0x4eb61f16 // orr v22.16b, v24.16b, v22.16b - WORD $0x3d800936 // str q22, [x9, #32] - WORD $0xfd403816 // ldr d22, [x0, #112] - WORD $0xbd406c17 // ldr s23, [x0, #108] - WORD $0xb940780a // ldr w10, [x0, #120] - WORD $0x9101f000 // add x0, x0, #124 - WORD $0x2ea646d8 // ushl v24.2s, v22.2s, v6.2s - WORD $0x0e963af7 // zip1 v23.2s, v23.2s, v22.2s - WORD $0x0e0c3ecb // mov w11, v22.s[1] - WORD $0x2eb546f6 // ushl v22.2s, v23.2s, v21.2s - WORD $0x53017d4c // lsr w12, w10, #1 - WORD $0x138b094a // extr w10, w10, w11, #2 - WORD $0x0eb61f16 // orr v22.8b, v24.8b, v22.8b - WORD $0x4e141d56 // mov v22.s[2], w10 - WORD $0x4e1c1d96 // mov v22.s[3], w12 - WORD $0x6f047416 // bic v22.4s, #128, lsl #24 - WORD $0x3d800d36 // str q22, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_93 - JMP LBB0_99 + WORD $0x7100587f // cmp w3, #22 + BEQ LBB0_142 + + // %bb.91: + WORD $0x71005c7f // cmp w3, #23 + BNE LBB0_156 + + // %bb.92: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.93: + // WORD $0x90000009 // adrp x9, .LCPI0_95 + // WORD $0x90000008 // adrp x8, .LCPI0_94 + // WORD $0x9000000a // adrp x10, .LCPI0_96 + WORD $0x4f03d7f7 // movi v23.4s, #127, msl #16 + VMOVD LCPI0_95, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_98 + VMOVD LCPI0_94, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_97 + VMOVD LCPI0_96, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_99 + VMOVD LCPI0_98, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_101 + VMOVD LCPI0_97, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_100 + VMOVD LCPI0_99, V5 + // WORD $0x9000000a // adrp x10, .LCPI0_102 + VMOVD LCPI0_101, V7 + // WORD $0x90000009 // adrp x9, .LCPI0_104 + VMOVD LCPI0_100, V6 + // WORD $0x90000008 // adrp x8, .LCPI0_103 + VMOVD LCPI0_102, V16 + // WORD $0x9000000a // adrp x10, .LCPI0_105 + VMOVD LCPI0_104, V18 + // WORD $0x90000009 // adrp x9, .LCPI0_107 + VMOVD LCPI0_103, V17 + // WORD $0x90000008 // adrp x8, .LCPI0_106 + VMOVD LCPI0_105, V19 + // WORD $0x9000000a // adrp x10, .LCPI0_108 + VMOVD LCPI0_107, V21 + // WORD $0x90000009 // adrp x9, .LCPI0_109 + VMOVD LCPI0_106, V20 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_108, V22 + VMOVD LCPI0_109, V24 + WORD $0xaa1303e9 // mov x9, x19 + LBB0_94: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404019 // ldur d25, [x0, #4] + WORD $0x1e27015a // fmov s26, w10 + WORD $0x1e27015b // fmov s27, w10 + WORD $0x2ea0473c // ushl v28.2s, v25.2s, v0.2s + WORD $0x0e0c3f2a // mov w10, v25.s[1] + WORD $0x0e993b5a // zip1 v26.2s, v26.2s, v25.2s + WORD $0x6e1b237b // ext v27.16b, v27.16b, v27.16b, #4 + WORD $0x53057d4a // lsr w10, w10, #5 + WORD $0x2ea1475a // ushl v26.2s, v26.2s, v1.2s + WORD $0x0eba1f9a // orr v26.8b, v28.8b, v26.8b + WORD $0x6e1a6379 // ext v25.16b, v27.16b, v26.16b, #12 + WORD $0x4e1c1d59 // mov v25.s[3], w10 + WORD $0x4e371f39 // and v25.16b, v25.16b, v23.16b + WORD $0x3c9c0119 // stur q25, [x8, #-64] + WORD $0xfc40c019 // ldur d25, [x0, #12] + WORD $0xbd40081a // ldr s26, [x0, #8] + WORD $0xb940140b // ldr w11, [x0, #20] + WORD $0x2ea2473b // ushl v27.2s, v25.2s, v2.2s + WORD $0x0e0c3f2a // mov w10, v25.s[1] + WORD $0x0e993b5a // zip1 v26.2s, v26.2s, v25.2s + WORD $0x138a296a // extr w10, w11, w10, #10 + WORD $0x2ea3475a // ushl v26.2s, v26.2s, v3.2s + WORD $0x0eba1f79 // orr v25.8b, v27.8b, v26.8b + WORD $0x4e141d59 // mov v25.s[2], w10 + WORD $0x53017d6a // lsr w10, w11, #1 + WORD $0x4e1c1d59 // mov v25.s[3], w10 + WORD $0x4e371f39 // and v25.16b, v25.16b, v23.16b + WORD $0x3c9d0119 // stur q25, [x8, #-48] + WORD $0xfd400c19 // ldr d25, [x0, #24] + WORD $0xbd40141a // ldr s26, [x0, #20] + WORD $0xb940200c // ldr w12, [x0, #32] + WORD $0x2ea4473b // ushl v27.2s, v25.2s, v4.2s + WORD $0x0e0c3f2a // mov w10, v25.s[1] + WORD $0x0e993b5a // zip1 v26.2s, v26.2s, v25.2s + WORD $0x53067d4b // lsr w11, w10, #6 + WORD $0x138a758a // extr w10, w12, w10, #29 + WORD $0x2ea5475a // ushl v26.2s, v26.2s, v5.2s + WORD $0x0eba1f79 // orr v25.8b, v27.8b, v26.8b + WORD $0x4e141d79 // mov v25.s[2], w11 + WORD $0x4e1c1d59 // mov v25.s[3], w10 + WORD $0x4e371f39 // and v25.16b, v25.16b, v23.16b + WORD $0x3c9e0119 // stur q25, [x8, #-32] + WORD $0xfc424019 // ldur d25, [x0, #36] + WORD $0xbd40201a // ldr s26, [x0, #32] + WORD $0xb9402c0c // ldr w12, [x0, #44] + WORD $0x2ea6473b // ushl v27.2s, v25.2s, v6.2s + WORD $0x0e0c3f2a // mov w10, v25.s[1] + WORD $0x0e993b5a // zip1 v26.2s, v26.2s, v25.2s + WORD $0x53027d4b // lsr w11, w10, #2 + WORD $0x138a658a // extr w10, w12, w10, #25 + WORD $0x2ea7475a // ushl v26.2s, v26.2s, v7.2s + WORD $0x0eba1f79 // orr v25.8b, v27.8b, v26.8b + WORD $0x4e141d79 // mov v25.s[2], w11 + WORD $0x4e1c1d59 // mov v25.s[3], w10 + WORD $0x4e371f39 // and v25.16b, v25.16b, v23.16b + WORD $0x3c9f0119 // stur q25, [x8, #-16] + WORD $0x2945a80b // ldp w11, w10, [x0, #44] + WORD $0xfc434019 // ldur d25, [x0, #52] + WORD $0x1e27015a // fmov s26, w10 + WORD $0x138b414b // extr w11, w10, w11, #16 + WORD $0x53077d4a // lsr w10, w10, #7 + WORD $0x0e993b5a // zip1 v26.2s, v26.2s, v25.2s + WORD $0x2eb04739 // ushl v25.2s, v25.2s, v16.2s + WORD $0x1e27017b // fmov s27, w11 + WORD $0x2eb1475a // ushl v26.2s, v26.2s, v17.2s + WORD $0x4e0c1d5b // mov v27.s[1], w10 + WORD $0x0eba1f39 // orr v25.8b, v25.8b, v26.8b + WORD $0x6e18073b // mov v27.d[1], v25.d[0] + WORD $0x4e371f79 // and v25.16b, v27.16b, v23.16b + WORD $0x3d800119 // str q25, [x8] + WORD $0x2947280b // ldp w11, w10, [x0, #56] + WORD $0xfd402019 // ldr d25, [x0, #64] + WORD $0x1e27015a // fmov s26, w10 + WORD $0x138b314b // extr w11, w10, w11, #12 + WORD $0x53037d4a // lsr w10, w10, #3 + WORD $0x0e993b5a // zip1 v26.2s, v26.2s, v25.2s + WORD $0x2eb24739 // ushl v25.2s, v25.2s, v18.2s + WORD $0x1e27017b // fmov s27, w11 + WORD $0x2eb3475a // ushl v26.2s, v26.2s, v19.2s + WORD $0x4e0c1d5b // mov v27.s[1], w10 + WORD $0x0eba1f39 // orr v25.8b, v25.8b, v26.8b + WORD $0x6e18073b // mov v27.d[1], v25.d[0] + WORD $0x4e371f79 // and v25.16b, v27.16b, v23.16b + WORD $0x3d800519 // str q25, [x8, #16] + WORD $0xb940440a // ldr w10, [x0, #68] + WORD $0xfd402419 // ldr d25, [x0, #72] + WORD $0xb940500b // ldr w11, [x0, #80] + WORD $0x1e27015a // fmov s26, w10 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2eb4473b // ushl v27.2s, v25.2s, v20.2s + WORD $0x0e993b5a // zip1 v26.2s, v26.2s, v25.2s + WORD $0x1e27015c // fmov s28, w10 + WORD $0x0e0c3f2a // mov w10, v25.s[1] + WORD $0x6e1c239c // ext v28.16b, v28.16b, v28.16b, #4 + WORD $0x2eb5475a // ushl v26.2s, v26.2s, v21.2s + WORD $0x138a356a // extr w10, w11, w10, #13 + WORD $0x0eba1f7a // orr v26.8b, v27.8b, v26.8b + WORD $0x6e1a6399 // ext v25.16b, v28.16b, v26.16b, #12 + WORD $0x4e1c1d59 // mov v25.s[3], w10 + WORD $0x4e371f39 // and v25.16b, v25.16b, v23.16b + WORD $0x3d800919 // str q25, [x8, #32] + WORD $0xb940500a // ldr w10, [x0, #80] + WORD $0xfc454019 // ldur d25, [x0, #84] + WORD $0x91017000 // add x0, x0, #92 + WORD $0x1e27015a // fmov s26, w10 + WORD $0x53047d4a // lsr w10, w10, #4 + WORD $0x2eb6473b // ushl v27.2s, v25.2s, v22.2s + WORD $0x0e993b5a // zip1 v26.2s, v26.2s, v25.2s + WORD $0x1e27015c // fmov s28, w10 + WORD $0x0e0c3f2a // mov w10, v25.s[1] + WORD $0x6e1c239c // ext v28.16b, v28.16b, v28.16b, #4 + WORD $0x2eb8475a // ushl v26.2s, v26.2s, v24.2s + WORD $0x53097d4a // lsr w10, w10, #9 + WORD $0x0eba1f7a // orr v26.8b, v27.8b, v26.8b + WORD $0x6e1a6399 // ext v25.16b, v28.16b, v26.16b, #12 + WORD $0x4e1c1d59 // mov v25.s[3], w10 + WORD $0x4e371f39 // and v25.16b, v25.16b, v23.16b + WORD $0x3d800d19 // str q25, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_94 + JMP LBB0_156 + LBB0_95: - WORD $0xad410400 // ldp q0, q1, [x0, #32] - WORD $0xad400c02 // ldp q2, q3, [x0] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0xad010420 // stp q0, q1, [x1, #32] - WORD $0xad000c22 // stp q2, q3, [x1] - WORD $0xad430400 // ldp q0, q1, [x0, #96] - WORD $0xad420c02 // ldp q2, q3, [x0, #64] - WORD $0x91020000 // add x0, x0, #128 - WORD $0xad030420 // stp q0, q1, [x1, #96] - WORD $0xad020c22 // stp q2, q3, [x1, #64] - WORD $0x91020021 // add x1, x1, #128 - - BNE LBB0_95 - JMP LBB0_99 -LBB0_96: - WORD $0x7100805f // cmp w2, #32 - BLT LBB0_99 - MOVD $0x000000160000001c, R3 // LCPI0_50 - MOVD $0x0000000a00000004, R0 // LCPI0_51 - MOVD $0x0000000a00000010, R4 // LCPI0_52 - MOVD $0x0000001600000010, R1 // LCPI0_53 - MOVD $0x0000001200000018, R5 // LCPI0_54 - MOVD $0x0000000e00000008, R2 // LCPI0_55 - - WORD $0x91010029 // add x9, x1, #64 - WORD $0x2ea0b863 // neg v3.2s, v3.2s - WORD $0x2ea0b884 // neg v4.2s, v4.2s - WORD $0x2ea0b8a5 // neg v5.2s, v5.2s -LBB0_98: - WORD $0x29402c0a // ldp w10, w11, [x0] - WORD $0x2941340c // ldp w12, w13, [x0, #8] - WORD $0xf1000508 // subs x8, x8, #1 - WORD $0x138a696e // extr w14, w11, w10, #26 - WORD $0x1e270146 // fmov s6, w10 - WORD $0x138b518b // extr w11, w12, w11, #20 - WORD $0x4e0c1dc6 // mov v6.s[1], w14 - WORD $0x138c39ac // extr w12, w13, w12, #14 - WORD $0x4e141d66 // mov v6.s[2], w11 - WORD $0x4e1c1d86 // mov v6.s[3], w12 - WORD $0x6f077786 // bic v6.4s, #252, lsl #24 - WORD $0x3c9c0126 // stur q6, [x9, #-64] - WORD $0x2941ac0a // ldp w10, w11, [x0, #12] - WORD $0xfc414006 // ldur d6, [x0, #20] - WORD $0x1e270167 // fmov s7, w11 - WORD $0x138a216a // extr w10, w11, w10, #8 - WORD $0x0e8638e7 // zip1 v7.2s, v7.2s, v6.2s - WORD $0x53027d6c // lsr w12, w11, #2 - WORD $0x2ea044c6 // ushl v6.2s, v6.2s, v0.2s - WORD $0x1e270150 // fmov s16, w10 - WORD $0x2ea344e7 // ushl v7.2s, v7.2s, v3.2s - WORD $0x4e0c1d90 // mov v16.s[1], w12 - WORD $0x0ea71cc6 // orr v6.8b, v6.8b, v7.8b - WORD $0x6e1804d0 // mov v16.d[1], v6.d[0] - WORD $0x6f077790 // bic v16.4s, #252, lsl #24 - WORD $0x3c9d0130 // stur q16, [x9, #-48] - WORD $0xfc41c006 // ldur d6, [x0, #28] - WORD $0xbd401807 // ldr s7, [x0, #24] - WORD $0xb940240a // ldr w10, [x0, #36] - WORD $0x2ea144d0 // ushl v16.2s, v6.2s, v1.2s - WORD $0x0e8638e7 // zip1 v7.2s, v7.2s, v6.2s - WORD $0x0e0c3ccb // mov w11, v6.s[1] - WORD $0x2ea444e6 // ushl v6.2s, v7.2s, v4.2s - WORD $0x53047d6c // lsr w12, w11, #4 - WORD $0x0ea61e06 // orr v6.8b, v16.8b, v6.8b - WORD $0x138b794a // extr w10, w10, w11, #30 - WORD $0x4e141d86 // mov v6.s[2], w12 - WORD $0x4e1c1d46 // mov v6.s[3], w10 - WORD $0x6f077786 // bic v6.4s, #252, lsl #24 - WORD $0x3c9e0126 // stur q6, [x9, #-32] - WORD $0xfd401406 // ldr d6, [x0, #40] - WORD $0xbd402407 // ldr s7, [x0, #36] - WORD $0xb940300a // ldr w10, [x0, #48] - WORD $0x2ea244d0 // ushl v16.2s, v6.2s, v2.2s - WORD $0x0e8638e7 // zip1 v7.2s, v7.2s, v6.2s - WORD $0x0e0c3ccb // mov w11, v6.s[1] - WORD $0x2ea544e6 // ushl v6.2s, v7.2s, v5.2s - WORD $0x138b314a // extr w10, w10, w11, #12 - WORD $0x0ea61e06 // orr v6.8b, v16.8b, v6.8b - WORD $0x4e141d46 // mov v6.s[2], w10 - WORD $0x4e1c1d86 // mov v6.s[3], w12 - WORD $0x6f077786 // bic v6.4s, #252, lsl #24 - WORD $0x3c9f0126 // stur q6, [x9, #-16] - WORD $0x2946ac0a // ldp w10, w11, [x0, #52] - WORD $0x2947b40c // ldp w12, w13, [x0, #60] - WORD $0x138a696e // extr w14, w11, w10, #26 - WORD $0x1e270146 // fmov s6, w10 - WORD $0x138b518b // extr w11, w12, w11, #20 - WORD $0x4e0c1dc6 // mov v6.s[1], w14 - WORD $0x138c39ac // extr w12, w13, w12, #14 - WORD $0x4e1c1d86 // mov v6.s[3], w12 - WORD $0x6f077786 // bic v6.4s, #252, lsl #24 - WORD $0x3d800126 // str q6, [x9] - WORD $0x29482c0a // ldp w10, w11, [x0, #64] - WORD $0xfd402406 // ldr d6, [x0, #72] - WORD $0x1e270167 // fmov s7, w11 - WORD $0x138a216a // extr w10, w11, w10, #8 - WORD $0x0e8638e7 // zip1 v7.2s, v7.2s, v6.2s - WORD $0x2ea044c6 // ushl v6.2s, v6.2s, v0.2s - WORD $0x1e270150 // fmov s16, w10 - WORD $0x2ea344e7 // ushl v7.2s, v7.2s, v3.2s - WORD $0x4e0c1d90 // mov v16.s[1], w12 - WORD $0x0ea71cc6 // orr v6.8b, v6.8b, v7.8b - WORD $0x6e1804d0 // mov v16.d[1], v6.d[0] - WORD $0x6f077790 // bic v16.4s, #252, lsl #24 - WORD $0x3d800530 // str q16, [x9, #16] - WORD $0xfd402806 // ldr d6, [x0, #80] - WORD $0xbd404c07 // ldr s7, [x0, #76] - WORD $0xb940580a // ldr w10, [x0, #88] - WORD $0x2ea144d0 // ushl v16.2s, v6.2s, v1.2s - WORD $0x0e8638e7 // zip1 v7.2s, v7.2s, v6.2s - WORD $0x0e0c3ccb // mov w11, v6.s[1] - WORD $0x2ea444e6 // ushl v6.2s, v7.2s, v4.2s - WORD $0x53047d6c // lsr w12, w11, #4 - WORD $0x0ea61e06 // orr v6.8b, v16.8b, v6.8b - WORD $0x138b794a // extr w10, w10, w11, #30 - WORD $0x4e141d86 // mov v6.s[2], w12 - WORD $0x4e1c1d46 // mov v6.s[3], w10 - WORD $0x6f077786 // bic v6.4s, #252, lsl #24 - WORD $0x3d800926 // str q6, [x9, #32] - WORD $0xfc45c006 // ldur d6, [x0, #92] - WORD $0xbd405807 // ldr s7, [x0, #88] - WORD $0xb940640a // ldr w10, [x0, #100] - WORD $0x9101a000 // add x0, x0, #104 - WORD $0x2ea244d0 // ushl v16.2s, v6.2s, v2.2s - WORD $0x0e8638e7 // zip1 v7.2s, v7.2s, v6.2s - WORD $0x0e0c3ccb // mov w11, v6.s[1] - WORD $0x2ea544e6 // ushl v6.2s, v7.2s, v5.2s - WORD $0x53067d4c // lsr w12, w10, #6 - WORD $0x138b314a // extr w10, w10, w11, #12 - WORD $0x0ea61e06 // orr v6.8b, v16.8b, v6.8b - WORD $0x4e141d46 // mov v6.s[2], w10 - WORD $0x4e1c1d86 // mov v6.s[3], w12 - WORD $0x6f077786 // bic v6.4s, #252, lsl #24 - WORD $0x3d800d26 // str q6, [x9, #48] - WORD $0x91020129 // add x9, x9, #128 - - BNE LBB0_98 + WORD $0x7100387f // cmp w3, #14 + BEQ LBB0_145 + + // %bb.96: + WORD $0x71003c7f // cmp w3, #15 + BNE LBB0_156 + + // %bb.97: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.98: + // WORD $0x90000009 // adrp x9, .LCPI0_138 + WORD $0x91010348 // add x8, x26, #64 + WORD $0x4f03c7e0 // movi v0.4s, #127, msl #8 + VMOVD LCPI0_138, V1 + WORD $0xaa1303e9 // mov x9, x19 + LBB0_99: - MOVD R19, num+32(FP) - WORD $0xf9400bf3 // ldr x19, [sp, #16] - WORD $0xa8c27bfd // ldp x29, x30, [sp], #32 - RET + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x530f7d4c // lsr w12, w10, #15 + WORD $0x1e270142 // fmov s2, w10 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x530d7d6a // lsr w10, w11, #13 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9c0102 // stur q2, [x8, #-64] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x530b7d6c // lsr w12, w11, #11 + WORD $0x1e270142 // fmov s2, w10 + WORD $0xb9400c0a // ldr w10, [x0, #12] + WORD $0x138b694b // extr w11, w10, w11, #26 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x53097d4a // lsr w10, w10, #9 + WORD $0x4e141d62 // mov v2.s[2], w11 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9d0102 // stur q2, [x8, #-48] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x53077d6c // lsr w12, w11, #7 + WORD $0x1e270142 // fmov s2, w10 + WORD $0xb940140a // ldr w10, [x0, #20] + WORD $0x138b594b // extr w11, w10, w11, #22 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x53057d4a // lsr w10, w10, #5 + WORD $0x4e141d62 // mov v2.s[2], w11 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9e0102 // stur q2, [x8, #-32] + WORD $0x2942ac0a // ldp w10, w11, [x0, #20] + WORD $0x138a516a // extr w10, w11, w10, #20 + WORD $0x53037d6c // lsr w12, w11, #3 + WORD $0x1e270142 // fmov s2, w10 + WORD $0xb9401c0a // ldr w10, [x0, #28] + WORD $0x138b494b // extr w11, w10, w11, #18 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x53017d4a // lsr w10, w10, #1 + WORD $0x4e141d62 // mov v2.s[2], w11 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9f0102 // stur q2, [x8, #-16] + WORD $0x2943ac0a // ldp w10, w11, [x0, #28] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x138a7d6a // extr w10, w11, w10, #31 + WORD $0x1e270182 // fmov s2, w12 + WORD $0xb940240c // ldr w12, [x0, #36] + WORD $0x4e0c1d42 // mov v2.s[1], w10 + WORD $0x530e7d6a // lsr w10, w11, #14 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x138b758a // extr w10, w12, w11, #29 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800102 // str q2, [x8] + WORD $0x2944ac0a // ldp w10, w11, [x0, #36] + WORD $0x530c7d4c // lsr w12, w10, #12 + WORD $0x138a6d6a // extr w10, w11, w10, #27 + WORD $0x1e270182 // fmov s2, w12 + WORD $0xb9402c0c // ldr w12, [x0, #44] + WORD $0x4e0c1d42 // mov v2.s[1], w10 + WORD $0x530a7d6a // lsr w10, w11, #10 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x138b658a // extr w10, w12, w11, #25 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800502 // str q2, [x8, #16] + WORD $0x2945ac0a // ldp w10, w11, [x0, #44] + WORD $0x53087d4c // lsr w12, w10, #8 + WORD $0x138a5d6a // extr w10, w11, w10, #23 + WORD $0x1e270182 // fmov s2, w12 + WORD $0xb940340c // ldr w12, [x0, #52] + WORD $0x4e0c1d42 // mov v2.s[1], w10 + WORD $0x53067d6a // lsr w10, w11, #6 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x138b558a // extr w10, w12, w11, #21 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800902 // str q2, [x8, #32] + WORD $0x2946ac0a // ldp w10, w11, [x0, #52] + WORD $0x9100f000 // add x0, x0, #60 + WORD $0x53047d4c // lsr w12, w10, #4 + WORD $0x0e040d62 // dup v2.2s, w11 + WORD $0x138a4d6a // extr w10, w11, w10, #19 + WORD $0x1e270183 // fmov s3, w12 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x4e0c1d43 // mov v3.s[1], w10 + WORD $0x6e180443 // mov v3.d[1], v2.d[0] + WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b + WORD $0x3d800d02 // str q2, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_99 + JMP LBB0_156 + +LBB0_100: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.101: + // WORD $0x90000008 // adrp x8, .LCPI0_8 + // WORD $0x90000009 // adrp x9, .LCPI0_9 + // WORD $0x9000000a // adrp x10, .LCPI0_10 + // WORD $0x9000000b // adrp x11, .LCPI0_23 + VMOVD LCPI0_8, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_11 + VMOVD LCPI0_9, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_12 + VMOVQ LCPI0_10L, LCPI0_10H, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_13 + VMOVQ LCPI0_11L, LCPI0_11H, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_14 + VMOVQ LCPI0_12L, LCPI0_12H, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_15 + VMOVQ LCPI0_13L, LCPI0_13H, V5 + // WORD $0x9000000a // adrp x10, .LCPI0_16 + VMOVQ LCPI0_14L, LCPI0_14H, V6 + // WORD $0x90000008 // adrp x8, .LCPI0_17 + VMOVQ LCPI0_15L, LCPI0_15H, V7 + // WORD $0x90000009 // adrp x9, .LCPI0_18 + VMOVQ LCPI0_16L, LCPI0_16H, V16 + // WORD $0x9000000a // adrp x10, .LCPI0_19 + VMOVQ LCPI0_17L, LCPI0_17H, V17 + // WORD $0x90000008 // adrp x8, .LCPI0_20 + VMOVQ LCPI0_18L, LCPI0_18H, V18 + // WORD $0x90000009 // adrp x9, .LCPI0_21 + VMOVQ LCPI0_19L, LCPI0_19H, V19 + // WORD $0x9000000a // adrp x10, .LCPI0_22 + VMOVQ LCPI0_20L, LCPI0_20H, V20 + WORD $0x91010348 // add x8, x26, #64 + VMOVQ LCPI0_21L, LCPI0_21H, V21 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_22, V22 + VMOVD LCPI0_23, V23 + +LBB0_102: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404018 // ldur d24, [x0, #4] + WORD $0xb9400c0b // ldr w11, [x0, #12] + WORD $0x1e270159 // fmov s25, w10 + WORD $0x1e27015a // fmov s26, w10 + WORD $0x2ea0471b // ushl v27.2s, v24.2s, v0.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x6e1a235a // ext v26.16b, v26.16b, v26.16b, #4 + WORD $0x138a756a // extr w10, w11, w10, #29 + WORD $0x2ea14739 // ushl v25.2s, v25.2s, v1.2s + WORD $0x0eb91f79 // orr v25.8b, v27.8b, v25.8b + WORD $0x6e196358 // ext v24.16b, v26.16b, v25.16b, #12 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f047418 // bic v24.4s, #128, lsl #24 + WORD $0x3c9c0118 // stur q24, [x8, #-64] + WORD $0xbd400c18 // ldr s24, [x0, #12] + WORD $0x3dc00419 // ldr q25, [x0, #16] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6ea24739 // ushl v25.4s, v25.4s, v2.4s + WORD $0x6ea34718 // ushl v24.4s, v24.4s, v3.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f047418 // bic v24.4s, #128, lsl #24 + WORD $0x3c9d0118 // stur q24, [x8, #-48] + WORD $0xbd401c18 // ldr s24, [x0, #28] + WORD $0x3dc00819 // ldr q25, [x0, #32] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6ea44739 // ushl v25.4s, v25.4s, v4.4s + WORD $0x6ea54718 // ushl v24.4s, v24.4s, v5.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f047418 // bic v24.4s, #128, lsl #24 + WORD $0x3c9e0118 // stur q24, [x8, #-32] + WORD $0xbd402c18 // ldr s24, [x0, #44] + WORD $0x3dc00c19 // ldr q25, [x0, #48] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6ea64739 // ushl v25.4s, v25.4s, v6.4s + WORD $0x6ea74718 // ushl v24.4s, v24.4s, v7.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f047418 // bic v24.4s, #128, lsl #24 + WORD $0x3c9f0118 // stur q24, [x8, #-16] + WORD $0xbd403c18 // ldr s24, [x0, #60] + WORD $0x3dc01019 // ldr q25, [x0, #64] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6eb04739 // ushl v25.4s, v25.4s, v16.4s + WORD $0x6eb14718 // ushl v24.4s, v24.4s, v17.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f047418 // bic v24.4s, #128, lsl #24 + WORD $0x3d800118 // str q24, [x8] + WORD $0xbd404c18 // ldr s24, [x0, #76] + WORD $0x3dc01419 // ldr q25, [x0, #80] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6eb24739 // ushl v25.4s, v25.4s, v18.4s + WORD $0x6eb34718 // ushl v24.4s, v24.4s, v19.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f047418 // bic v24.4s, #128, lsl #24 + WORD $0x3d800518 // str q24, [x8, #16] + WORD $0xbd405c18 // ldr s24, [x0, #92] + WORD $0x3dc01819 // ldr q25, [x0, #96] + WORD $0x6e182318 // ext v24.16b, v24.16b, v24.16b, #4 + WORD $0x6e196318 // ext v24.16b, v24.16b, v25.16b, #12 + WORD $0x6eb44739 // ushl v25.4s, v25.4s, v20.4s + WORD $0x6eb54718 // ushl v24.4s, v24.4s, v21.4s + WORD $0x4eb81f38 // orr v24.16b, v25.16b, v24.16b + WORD $0x6f047418 // bic v24.4s, #128, lsl #24 + WORD $0x3d800918 // str q24, [x8, #32] + WORD $0xfd403818 // ldr d24, [x0, #112] + WORD $0xbd406c19 // ldr s25, [x0, #108] + WORD $0xb940780b // ldr w11, [x0, #120] + WORD $0x9101f000 // add x0, x0, #124 + WORD $0x2eb6471a // ushl v26.2s, v24.2s, v22.2s + WORD $0x0e0c3f0a // mov w10, v24.s[1] + WORD $0x0e983b39 // zip1 v25.2s, v25.2s, v24.2s + WORD $0x138a096a // extr w10, w11, w10, #2 + WORD $0x2eb74739 // ushl v25.2s, v25.2s, v23.2s + WORD $0x0eb91f58 // orr v24.8b, v26.8b, v25.8b + WORD $0x4e141d58 // mov v24.s[2], w10 + WORD $0x53017d6a // lsr w10, w11, #1 + WORD $0x4e1c1d58 // mov v24.s[3], w10 + WORD $0x6f047418 // bic v24.4s, #128, lsl #24 + WORD $0x3d800d18 // str q24, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_102 + JMP LBB0_156 + +LBB0_103: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.104: + WORD $0x7100427f // cmp w19, #16 + WORD $0x54000002 // b.hs .LBB0_151 + + // %bb.105: + WORD $0xaa1f03e8 // mov x8, xzr + JMP LBB0_154 + +LBB0_106: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.107: + WORD $0x6f01e660 // movi v0.2d, #0x00ffff0000ffff + WORD $0x91010348 // add x8, x26, #64 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_108: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53107d6a // lsr w10, w11, #16 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9c0101 // stur q1, [x8, #-64] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53107d6a // lsr w10, w11, #16 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9d0101 // stur q1, [x8, #-48] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53107d6a // lsr w10, w11, #16 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9e0101 // stur q1, [x8, #-32] + WORD $0x29432c0a // ldp w10, w11, [x0, #24] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53107d6a // lsr w10, w11, #16 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9f0101 // stur q1, [x8, #-16] + WORD $0x29442c0a // ldp w10, w11, [x0, #32] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53107d6a // lsr w10, w11, #16 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800101 // str q1, [x8] + WORD $0x29452c0a // ldp w10, w11, [x0, #40] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53107d6a // lsr w10, w11, #16 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800501 // str q1, [x8, #16] + WORD $0x29462c0a // ldp w10, w11, [x0, #48] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53107d6a // lsr w10, w11, #16 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800901 // str q1, [x8, #32] + WORD $0x29472c0a // ldp w10, w11, [x0, #56] + WORD $0x91010000 // add x0, x0, #64 + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53107d6a // lsr w10, w11, #16 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800d01 // str q1, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_108 + JMP LBB0_156 + +LBB0_109: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.110: + // WORD $0x90000009 // adrp x9, .LCPI0_165 + WORD $0x91010348 // add x8, x26, #64 + WORD $0x6f00e620 // movi v0.2d, #0x0000ff000000ff + VMOVD LCPI0_165, V1 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_111: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d42 // dup v2.2s, w10 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x53187d4a // lsr w10, w10, #24 + WORD $0x6e032063 // ext v3.16b, v3.16b, v3.16b, #4 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x6e026062 // ext v2.16b, v3.16b, v2.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9c0102 // stur q2, [x8, #-64] + WORD $0xb940040a // ldr w10, [x0, #4] + WORD $0x0e040d42 // dup v2.2s, w10 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x53187d4a // lsr w10, w10, #24 + WORD $0x6e032063 // ext v3.16b, v3.16b, v3.16b, #4 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x6e026062 // ext v2.16b, v3.16b, v2.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9d0102 // stur q2, [x8, #-48] + WORD $0xb940080a // ldr w10, [x0, #8] + WORD $0x0e040d42 // dup v2.2s, w10 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x53187d4a // lsr w10, w10, #24 + WORD $0x6e032063 // ext v3.16b, v3.16b, v3.16b, #4 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x6e026062 // ext v2.16b, v3.16b, v2.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9e0102 // stur q2, [x8, #-32] + WORD $0xb9400c0a // ldr w10, [x0, #12] + WORD $0x0e040d42 // dup v2.2s, w10 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x53187d4a // lsr w10, w10, #24 + WORD $0x6e032063 // ext v3.16b, v3.16b, v3.16b, #4 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x6e026062 // ext v2.16b, v3.16b, v2.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9f0102 // stur q2, [x8, #-16] + WORD $0xb940100a // ldr w10, [x0, #16] + WORD $0x0e040d42 // dup v2.2s, w10 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x53187d4a // lsr w10, w10, #24 + WORD $0x6e032063 // ext v3.16b, v3.16b, v3.16b, #4 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x6e026062 // ext v2.16b, v3.16b, v2.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800102 // str q2, [x8] + WORD $0xb940140a // ldr w10, [x0, #20] + WORD $0x0e040d42 // dup v2.2s, w10 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x53187d4a // lsr w10, w10, #24 + WORD $0x6e032063 // ext v3.16b, v3.16b, v3.16b, #4 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x6e026062 // ext v2.16b, v3.16b, v2.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800502 // str q2, [x8, #16] + WORD $0xb940180a // ldr w10, [x0, #24] + WORD $0x0e040d42 // dup v2.2s, w10 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x53187d4a // lsr w10, w10, #24 + WORD $0x6e032063 // ext v3.16b, v3.16b, v3.16b, #4 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x6e026062 // ext v2.16b, v3.16b, v2.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800902 // str q2, [x8, #32] + WORD $0xb9401c0a // ldr w10, [x0, #28] + WORD $0x91008000 // add x0, x0, #32 + WORD $0x0e040d42 // dup v2.2s, w10 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x53187d4a // lsr w10, w10, #24 + WORD $0x6e032063 // ext v3.16b, v3.16b, v3.16b, #4 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x6e026062 // ext v2.16b, v3.16b, v2.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800d02 // str q2, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_111 + JMP LBB0_156 + +LBB0_112: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.113: + // WORD $0x90000009 // adrp x9, .LCPI0_92 + // WORD $0x9000000a // adrp x10, .LCPI0_93 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_92, V0 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_93, V1 + +LBB0_114: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404002 // ldur d2, [x0, #4] + WORD $0x1e270143 // fmov s3, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x2ea04445 // ushl v5.2s, v2.2s, v0.2s + WORD $0x0e0c3c4a // mov w10, v2.s[1] + WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x0ea31ca3 // orr v3.8b, v5.8b, v3.8b + WORD $0x6e036082 // ext v2.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x6f0777e2 // bic v2.4s, #255, lsl #24 + WORD $0x3c9c0102 // stur q2, [x8, #-64] + WORD $0xb9400c0a // ldr w10, [x0, #12] + WORD $0xfd400802 // ldr d2, [x0, #16] + WORD $0x1e270143 // fmov s3, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x2ea04445 // ushl v5.2s, v2.2s, v0.2s + WORD $0x0e0c3c4a // mov w10, v2.s[1] + WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x0ea31ca3 // orr v3.8b, v5.8b, v3.8b + WORD $0x6e036082 // ext v2.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x6f0777e2 // bic v2.4s, #255, lsl #24 + WORD $0x3c9d0102 // stur q2, [x8, #-48] + WORD $0xb940180a // ldr w10, [x0, #24] + WORD $0xfc41c002 // ldur d2, [x0, #28] + WORD $0x1e270143 // fmov s3, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x2ea04445 // ushl v5.2s, v2.2s, v0.2s + WORD $0x0e0c3c4a // mov w10, v2.s[1] + WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x0ea31ca3 // orr v3.8b, v5.8b, v3.8b + WORD $0x6e036082 // ext v2.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x6f0777e2 // bic v2.4s, #255, lsl #24 + WORD $0x3c9e0102 // stur q2, [x8, #-32] + WORD $0xb940240a // ldr w10, [x0, #36] + WORD $0xfd401402 // ldr d2, [x0, #40] + WORD $0x1e270143 // fmov s3, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x2ea04445 // ushl v5.2s, v2.2s, v0.2s + WORD $0x0e0c3c4a // mov w10, v2.s[1] + WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x0ea31ca3 // orr v3.8b, v5.8b, v3.8b + WORD $0x6e036082 // ext v2.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x6f0777e2 // bic v2.4s, #255, lsl #24 + WORD $0x3c9f0102 // stur q2, [x8, #-16] + WORD $0xb940300a // ldr w10, [x0, #48] + WORD $0xfc434002 // ldur d2, [x0, #52] + WORD $0x1e270143 // fmov s3, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x2ea04445 // ushl v5.2s, v2.2s, v0.2s + WORD $0x0e0c3c4a // mov w10, v2.s[1] + WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x0ea31ca3 // orr v3.8b, v5.8b, v3.8b + WORD $0x6e036082 // ext v2.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x6f0777e2 // bic v2.4s, #255, lsl #24 + WORD $0x3d800102 // str q2, [x8] + WORD $0xb9403c0a // ldr w10, [x0, #60] + WORD $0xfd402002 // ldr d2, [x0, #64] + WORD $0x1e270143 // fmov s3, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x2ea04445 // ushl v5.2s, v2.2s, v0.2s + WORD $0x0e0c3c4a // mov w10, v2.s[1] + WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x0ea31ca3 // orr v3.8b, v5.8b, v3.8b + WORD $0x6e036082 // ext v2.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x6f0777e2 // bic v2.4s, #255, lsl #24 + WORD $0x3d800502 // str q2, [x8, #16] + WORD $0xb940480a // ldr w10, [x0, #72] + WORD $0xfc44c002 // ldur d2, [x0, #76] + WORD $0x1e270143 // fmov s3, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x2ea04445 // ushl v5.2s, v2.2s, v0.2s + WORD $0x0e0c3c4a // mov w10, v2.s[1] + WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x0ea31ca3 // orr v3.8b, v5.8b, v3.8b + WORD $0x6e036082 // ext v2.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x6f0777e2 // bic v2.4s, #255, lsl #24 + WORD $0x3d800902 // str q2, [x8, #32] + WORD $0xb940540a // ldr w10, [x0, #84] + WORD $0xfd402c02 // ldr d2, [x0, #88] + WORD $0x91018000 // add x0, x0, #96 + WORD $0x1e270143 // fmov s3, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x2ea04445 // ushl v5.2s, v2.2s, v0.2s + WORD $0x0e0c3c4a // mov w10, v2.s[1] + WORD $0x0e823863 // zip1 v3.2s, v3.2s, v2.2s + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x0ea31ca3 // orr v3.8b, v5.8b, v3.8b + WORD $0x6e036082 // ext v2.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x6f0777e2 // bic v2.4s, #255, lsl #24 + WORD $0x3d800d02 // str q2, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_114 + JMP LBB0_156 + +LBB0_115: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.116: + // WORD $0x90000009 // adrp x9, .LCPI0_186 + // WORD $0x9000000a // adrp x10, .LCPI0_187 + WORD $0x4f0005e0 // movi v0.4s, #15 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_186, V1 + WORD $0xaa1303e9 // mov x9, x19 + VMOVQ LCPI0_187L, LCPI0_187H, V2 + +LBB0_117: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d43 // dup v3.2s, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x530c7d4a // lsr w10, w10, #12 + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x6e036083 // ext v3.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d43 // mov v3.s[3], w10 + WORD $0xaa0003ea // mov x10, x0 + WORD $0x4e201c63 // and v3.16b, v3.16b, v0.16b + WORD $0x3c9c0103 // stur q3, [x8, #-64] + WORD $0x4ddfc943 // ld1r { v3.4s }, [x10], #4 + WORD $0x6ea24463 // ushl v3.4s, v3.4s, v2.4s + WORD $0x4e201c63 // and v3.16b, v3.16b, v0.16b + WORD $0x3c9d0103 // stur q3, [x8, #-48] + WORD $0xb940014b // ldr w11, [x10] + WORD $0x0e040d63 // dup v3.2s, w11 + WORD $0x1e270164 // fmov s4, w11 + WORD $0x530c7d6b // lsr w11, w11, #12 + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x6e036083 // ext v3.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d63 // mov v3.s[3], w11 + WORD $0x4e201c63 // and v3.16b, v3.16b, v0.16b + WORD $0x3c9e0103 // stur q3, [x8, #-32] + WORD $0x4d40c943 // ld1r { v3.4s }, [x10] + WORD $0x6ea24463 // ushl v3.4s, v3.4s, v2.4s + WORD $0x4e201c63 // and v3.16b, v3.16b, v0.16b + WORD $0x3c9f0103 // stur q3, [x8, #-16] + WORD $0xb940080a // ldr w10, [x0, #8] + WORD $0x0e040d43 // dup v3.2s, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x530c7d4a // lsr w10, w10, #12 + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x6e036083 // ext v3.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d43 // mov v3.s[3], w10 + WORD $0x9100200a // add x10, x0, #8 + WORD $0x4e201c63 // and v3.16b, v3.16b, v0.16b + WORD $0x3d800103 // str q3, [x8] + WORD $0x4d40c943 // ld1r { v3.4s }, [x10] + WORD $0x6ea24463 // ushl v3.4s, v3.4s, v2.4s + WORD $0x4e201c63 // and v3.16b, v3.16b, v0.16b + WORD $0x3d800503 // str q3, [x8, #16] + WORD $0xb9400c0a // ldr w10, [x0, #12] + WORD $0x0e040d43 // dup v3.2s, w10 + WORD $0x1e270144 // fmov s4, w10 + WORD $0x530c7d4a // lsr w10, w10, #12 + WORD $0x6e042084 // ext v4.16b, v4.16b, v4.16b, #4 + WORD $0x2ea14463 // ushl v3.2s, v3.2s, v1.2s + WORD $0x6e036083 // ext v3.16b, v4.16b, v3.16b, #12 + WORD $0x4e1c1d43 // mov v3.s[3], w10 + WORD $0x9100300a // add x10, x0, #12 + WORD $0x91004000 // add x0, x0, #16 + WORD $0x4e201c63 // and v3.16b, v3.16b, v0.16b + WORD $0x3d800903 // str q3, [x8, #32] + WORD $0x4d40c943 // ld1r { v3.4s }, [x10] + WORD $0x6ea24463 // ushl v3.4s, v3.4s, v2.4s + WORD $0x4e201c63 // and v3.16b, v3.16b, v0.16b + WORD $0x3d800d03 // str q3, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_117 + JMP LBB0_156 + +LBB0_118: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.119: + WORD $0x4f00d5e0 // movi v0.4s, #15, msl #16 + WORD $0x91010348 // add x8, x26, #64 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_120: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x138a516c // extr w12, w11, w10, #20 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53087d6a // lsr w10, w11, #8 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0xb940080c // ldr w12, [x0, #8] + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b718a // extr w10, w12, w11, #28 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9c0101 // stur q1, [x8, #-64] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x138a416a // extr w10, w11, w10, #16 + WORD $0x53047d6c // lsr w12, w11, #4 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940100a // ldr w10, [x0, #16] + WORD $0x138b614b // extr w11, w10, w11, #24 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x530c7d4a // lsr w10, w10, #12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9d0101 // stur q1, [x8, #-48] + WORD $0x2942ac0a // ldp w10, w11, [x0, #20] + WORD $0x138a516c // extr w12, w11, w10, #20 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53087d6a // lsr w10, w11, #8 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0xb9401c0c // ldr w12, [x0, #28] + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b718a // extr w10, w12, w11, #28 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9e0101 // stur q1, [x8, #-32] + WORD $0x2943ac0a // ldp w10, w11, [x0, #28] + WORD $0x138a416a // extr w10, w11, w10, #16 + WORD $0x53047d6c // lsr w12, w11, #4 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940240a // ldr w10, [x0, #36] + WORD $0x138b614b // extr w11, w10, w11, #24 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x530c7d4a // lsr w10, w10, #12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9f0101 // stur q1, [x8, #-16] + WORD $0x29452c0a // ldp w10, w11, [x0, #40] + WORD $0x138a516c // extr w12, w11, w10, #20 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53087d6a // lsr w10, w11, #8 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0xb940300c // ldr w12, [x0, #48] + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b718a // extr w10, w12, w11, #28 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800101 // str q1, [x8] + WORD $0x29462c0a // ldp w10, w11, [x0, #48] + WORD $0x138a416a // extr w10, w11, w10, #16 + WORD $0x53047d6c // lsr w12, w11, #4 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940380a // ldr w10, [x0, #56] + WORD $0x138b614b // extr w11, w10, w11, #24 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x530c7d4a // lsr w10, w10, #12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800501 // str q1, [x8, #16] + WORD $0x2947ac0a // ldp w10, w11, [x0, #60] + WORD $0x138a516c // extr w12, w11, w10, #20 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53087d6a // lsr w10, w11, #8 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0xb940440c // ldr w12, [x0, #68] + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b718a // extr w10, w12, w11, #28 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800901 // str q1, [x8, #32] + WORD $0x2948ac0a // ldp w10, w11, [x0, #68] + WORD $0x138a416a // extr w10, w11, w10, #16 + WORD $0x53047d6c // lsr w12, w11, #4 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb9404c0a // ldr w10, [x0, #76] + WORD $0x91014000 // add x0, x0, #80 + WORD $0x138b614b // extr w11, w10, w11, #24 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x530c7d4a // lsr w10, w10, #12 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800d01 // str q1, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_120 + JMP LBB0_156 + +LBB0_121: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.122: + // WORD $0x90000009 // adrp x9, .LCPI0_145 + WORD $0x91010348 // add x8, x26, #64 + WORD $0x4f00c5e0 // movi v0.4s, #15, msl #8 + VMOVD LCPI0_145, V1 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_123: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x530c7d4c // lsr w12, w10, #12 + WORD $0x1e270142 // fmov s2, w10 + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9c0102 // stur q2, [x8, #-64] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x0e040d62 // dup v2.2s, w11 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x1e270183 // fmov s3, w12 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x4e0c1d43 // mov v3.s[1], w10 + WORD $0x6e180443 // mov v3.d[1], v2.d[0] + WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b + WORD $0x3c9d0102 // stur q2, [x8, #-48] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x530c7d4c // lsr w12, w10, #12 + WORD $0x1e270142 // fmov s2, w10 + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9e0102 // stur q2, [x8, #-32] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x0e040d62 // dup v2.2s, w11 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x1e270183 // fmov s3, w12 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x4e0c1d43 // mov v3.s[1], w10 + WORD $0x6e180443 // mov v3.d[1], v2.d[0] + WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b + WORD $0x3c9f0102 // stur q2, [x8, #-16] + WORD $0x29432c0a // ldp w10, w11, [x0, #24] + WORD $0x530c7d4c // lsr w12, w10, #12 + WORD $0x1e270142 // fmov s2, w10 + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800102 // str q2, [x8] + WORD $0x2943ac0a // ldp w10, w11, [x0, #28] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x0e040d62 // dup v2.2s, w11 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x1e270183 // fmov s3, w12 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x4e0c1d43 // mov v3.s[1], w10 + WORD $0x6e180443 // mov v3.d[1], v2.d[0] + WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b + WORD $0x3d800502 // str q2, [x8, #16] + WORD $0x2944ac0a // ldp w10, w11, [x0, #36] + WORD $0x530c7d4c // lsr w12, w10, #12 + WORD $0x1e270142 // fmov s2, w10 + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800902 // str q2, [x8, #32] + WORD $0x29452c0a // ldp w10, w11, [x0, #40] + WORD $0x9100c000 // add x0, x0, #48 + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x0e040d62 // dup v2.2s, w11 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x1e270183 // fmov s3, w12 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x4e0c1d43 // mov v3.s[1], w10 + WORD $0x6e180443 // mov v3.d[1], v2.d[0] + WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b + WORD $0x3d800d02 // str q2, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_123 + JMP LBB0_156 + +LBB0_124: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.125: + // WORD $0x90000008 // adrp x8, .LCPI0_48 + // WORD $0x90000009 // adrp x9, .LCPI0_49 + // WORD $0x9000000a // adrp x10, .LCPI0_50 + // WORD $0x9000000b // adrp x11, .LCPI0_51 + VMOVD LCPI0_48, V0 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_49, V1 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_50, V2 + VMOVD LCPI0_51, V3 + +LBB0_126: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404004 // ldur d4, [x0, #4] + WORD $0xb9400c0b // ldr w11, [x0, #12] + WORD $0x1e270145 // fmov s5, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x2ea04487 // ushl v7.2s, v4.2s, v0.2s + WORD $0x0e0c3c8a // mov w10, v4.s[1] + WORD $0x0e8438a5 // zip1 v5.2s, v5.2s, v4.2s + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x138a516a // extr w10, w11, w10, #20 + WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s + WORD $0x0ea51ce5 // orr v5.8b, v7.8b, v5.8b + WORD $0x6e0560c4 // ext v4.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d44 // mov v4.s[3], w10 + WORD $0x6f077604 // bic v4.4s, #240, lsl #24 + WORD $0x3c9c0104 // stur q4, [x8, #-64] + WORD $0xfd400804 // ldr d4, [x0, #16] + WORD $0xbd400c05 // ldr s5, [x0, #12] + WORD $0xb940180b // ldr w11, [x0, #24] + WORD $0x2ea24486 // ushl v6.2s, v4.2s, v2.2s + WORD $0x0e0c3c8a // mov w10, v4.s[1] + WORD $0x0e8438a5 // zip1 v5.2s, v5.2s, v4.2s + WORD $0x138a216a // extr w10, w11, w10, #8 + WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s + WORD $0x0ea51cc4 // orr v4.8b, v6.8b, v5.8b + WORD $0x4e141d44 // mov v4.s[2], w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e1c1d44 // mov v4.s[3], w10 + WORD $0x6f077604 // bic v4.4s, #240, lsl #24 + WORD $0x3c9d0104 // stur q4, [x8, #-48] + WORD $0xb9401c0a // ldr w10, [x0, #28] + WORD $0xfd401004 // ldr d4, [x0, #32] + WORD $0xb940280b // ldr w11, [x0, #40] + WORD $0x1e270145 // fmov s5, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x2ea04487 // ushl v7.2s, v4.2s, v0.2s + WORD $0x0e0c3c8a // mov w10, v4.s[1] + WORD $0x0e8438a5 // zip1 v5.2s, v5.2s, v4.2s + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x138a516a // extr w10, w11, w10, #20 + WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s + WORD $0x0ea51ce5 // orr v5.8b, v7.8b, v5.8b + WORD $0x6e0560c4 // ext v4.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d44 // mov v4.s[3], w10 + WORD $0x6f077604 // bic v4.4s, #240, lsl #24 + WORD $0x3c9e0104 // stur q4, [x8, #-32] + WORD $0xfc42c004 // ldur d4, [x0, #44] + WORD $0xbd402805 // ldr s5, [x0, #40] + WORD $0xb940340b // ldr w11, [x0, #52] + WORD $0x2ea24486 // ushl v6.2s, v4.2s, v2.2s + WORD $0x0e0c3c8a // mov w10, v4.s[1] + WORD $0x0e8438a5 // zip1 v5.2s, v5.2s, v4.2s + WORD $0x138a216a // extr w10, w11, w10, #8 + WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s + WORD $0x0ea51cc4 // orr v4.8b, v6.8b, v5.8b + WORD $0x4e141d44 // mov v4.s[2], w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e1c1d44 // mov v4.s[3], w10 + WORD $0x6f077604 // bic v4.4s, #240, lsl #24 + WORD $0x3c9f0104 // stur q4, [x8, #-16] + WORD $0xb940380a // ldr w10, [x0, #56] + WORD $0xfc43c004 // ldur d4, [x0, #60] + WORD $0xb940440b // ldr w11, [x0, #68] + WORD $0x1e270145 // fmov s5, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x2ea04487 // ushl v7.2s, v4.2s, v0.2s + WORD $0x0e0c3c8a // mov w10, v4.s[1] + WORD $0x0e8438a5 // zip1 v5.2s, v5.2s, v4.2s + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x138a516a // extr w10, w11, w10, #20 + WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s + WORD $0x0ea51ce5 // orr v5.8b, v7.8b, v5.8b + WORD $0x6e0560c4 // ext v4.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d44 // mov v4.s[3], w10 + WORD $0x6f077604 // bic v4.4s, #240, lsl #24 + WORD $0x3d800104 // str q4, [x8] + WORD $0xfd402404 // ldr d4, [x0, #72] + WORD $0xbd404405 // ldr s5, [x0, #68] + WORD $0xb940500b // ldr w11, [x0, #80] + WORD $0x2ea24486 // ushl v6.2s, v4.2s, v2.2s + WORD $0x0e0c3c8a // mov w10, v4.s[1] + WORD $0x0e8438a5 // zip1 v5.2s, v5.2s, v4.2s + WORD $0x138a216a // extr w10, w11, w10, #8 + WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s + WORD $0x0ea51cc4 // orr v4.8b, v6.8b, v5.8b + WORD $0x4e141d44 // mov v4.s[2], w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e1c1d44 // mov v4.s[3], w10 + WORD $0x6f077604 // bic v4.4s, #240, lsl #24 + WORD $0x3d800504 // str q4, [x8, #16] + WORD $0xb940540a // ldr w10, [x0, #84] + WORD $0xfd402c04 // ldr d4, [x0, #88] + WORD $0xb940600b // ldr w11, [x0, #96] + WORD $0x1e270145 // fmov s5, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x2ea04487 // ushl v7.2s, v4.2s, v0.2s + WORD $0x0e0c3c8a // mov w10, v4.s[1] + WORD $0x0e8438a5 // zip1 v5.2s, v5.2s, v4.2s + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x138a516a // extr w10, w11, w10, #20 + WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s + WORD $0x0ea51ce5 // orr v5.8b, v7.8b, v5.8b + WORD $0x6e0560c4 // ext v4.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d44 // mov v4.s[3], w10 + WORD $0x6f077604 // bic v4.4s, #240, lsl #24 + WORD $0x3d800904 // str q4, [x8, #32] + WORD $0xfc464004 // ldur d4, [x0, #100] + WORD $0xbd406005 // ldr s5, [x0, #96] + WORD $0xb9406c0b // ldr w11, [x0, #108] + WORD $0x9101c000 // add x0, x0, #112 + WORD $0x2ea24486 // ushl v6.2s, v4.2s, v2.2s + WORD $0x0e0c3c8a // mov w10, v4.s[1] + WORD $0x0e8438a5 // zip1 v5.2s, v5.2s, v4.2s + WORD $0x138a216a // extr w10, w11, w10, #8 + WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s + WORD $0x0ea51cc4 // orr v4.8b, v6.8b, v5.8b + WORD $0x4e141d44 // mov v4.s[2], w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e1c1d44 // mov v4.s[3], w10 + WORD $0x6f077604 // bic v4.4s, #240, lsl #24 + WORD $0x3d800d04 // str q4, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_126 + JMP LBB0_156 + +LBB0_127: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.128: + // WORD $0x90000008 // adrp x8, .LCPI0_196 + // WORD $0x90000009 // adrp x9, .LCPI0_197 + // WORD $0x9000000a // adrp x10, .LCPI0_198 + // WORD $0x9000000b // adrp x11, .LCPI0_199 + WORD $0x4f000462 // movi v2.4s, #3 + VMOVD LCPI0_196, V0 + WORD $0x91010348 // add x8, x26, #64 + VMOVQ LCPI0_197L, LCPI0_197H, V1 + WORD $0xaa1303e9 // mov x9, x19 + VMOVQ LCPI0_198L, LCPI0_198H, V3 + VMOVQ LCPI0_199L, LCPI0_199H, V4 + +LBB0_129: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x53067d4a // lsr w10, w10, #6 + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x2ea044a5 // ushl v5.2s, v5.2s, v0.2s + WORD $0x6e0560c5 // ext v5.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0xaa0003ea // mov x10, x0 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9c0105 // stur q5, [x8, #-64] + WORD $0x4ddfc945 // ld1r { v5.4s }, [x10], #4 + WORD $0x6ea144a5 // ushl v5.4s, v5.4s, v1.4s + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9d0105 // stur q5, [x8, #-48] + WORD $0x4d40c805 // ld1r { v5.4s }, [x0] + WORD $0x6ea344a5 // ushl v5.4s, v5.4s, v3.4s + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9e0105 // stur q5, [x8, #-32] + WORD $0xb840840b // ldr w11, [x0], #8 + WORD $0x4e040d65 // dup v5.4s, w11 + WORD $0x6ea444a5 // ushl v5.4s, v5.4s, v4.4s + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9f0105 // stur q5, [x8, #-16] + WORD $0xb940014b // ldr w11, [x10] + WORD $0x0e040d65 // dup v5.2s, w11 + WORD $0x1e270166 // fmov s6, w11 + WORD $0x53067d6b // lsr w11, w11, #6 + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x2ea044a5 // ushl v5.2s, v5.2s, v0.2s + WORD $0x6e0560c5 // ext v5.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d65 // mov v5.s[3], w11 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800105 // str q5, [x8] + WORD $0x4d40c945 // ld1r { v5.4s }, [x10] + WORD $0x6ea144a5 // ushl v5.4s, v5.4s, v1.4s + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800505 // str q5, [x8, #16] + WORD $0x4d40c945 // ld1r { v5.4s }, [x10] + WORD $0x6ea344a5 // ushl v5.4s, v5.4s, v3.4s + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800905 // str q5, [x8, #32] + WORD $0x4d40c945 // ld1r { v5.4s }, [x10] + WORD $0x6ea444a5 // ushl v5.4s, v5.4s, v4.4s + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800d05 // str q5, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_129 + JMP LBB0_156 + +LBB0_130: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.131: + WORD $0x4f00d460 // movi v0.4s, #3, msl #16 + WORD $0x91010348 // add x8, x26, #64 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_132: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x138a496c // extr w12, w11, w10, #18 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0xb940080c // ldr w12, [x0, #8] + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b598a // extr w10, w12, w11, #22 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9c0101 // stur q1, [x8, #-64] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x53087d4c // lsr w12, w10, #8 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x1e270181 // fmov s1, w12 + WORD $0xb940100c // ldr w12, [x0, #16] + WORD $0x4e0c1d41 // mov v1.s[1], w10 + WORD $0x530c7d6a // lsr w10, w11, #12 + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b798a // extr w10, w12, w11, #30 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9d0101 // stur q1, [x8, #-48] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x138a416a // extr w10, w11, w10, #16 + WORD $0x53027d6c // lsr w12, w11, #2 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940180a // ldr w10, [x0, #24] + WORD $0x138b514b // extr w11, w10, w11, #20 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x53067d4a // lsr w10, w10, #6 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9e0101 // stur q1, [x8, #-32] + WORD $0x29432c0a // ldp w10, w11, [x0, #24] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x530a7d6c // lsr w12, w11, #10 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940200a // ldr w10, [x0, #32] + WORD $0x138b714b // extr w11, w10, w11, #28 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x530e7d4a // lsr w10, w10, #14 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3c9f0101 // stur q1, [x8, #-16] + WORD $0x2944ac0a // ldp w10, w11, [x0, #36] + WORD $0x138a496c // extr w12, w11, w10, #18 + WORD $0x1e270141 // fmov s1, w10 + WORD $0x53047d6a // lsr w10, w11, #4 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0xb9402c0c // ldr w12, [x0, #44] + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b598a // extr w10, w12, w11, #22 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800101 // str q1, [x8] + WORD $0x2945ac0a // ldp w10, w11, [x0, #44] + WORD $0x53087d4c // lsr w12, w10, #8 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x1e270181 // fmov s1, w12 + WORD $0xb940340c // ldr w12, [x0, #52] + WORD $0x4e0c1d41 // mov v1.s[1], w10 + WORD $0x530c7d6a // lsr w10, w11, #12 + WORD $0x4e141d41 // mov v1.s[2], w10 + WORD $0x138b798a // extr w10, w12, w11, #30 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800501 // str q1, [x8, #16] + WORD $0x2946ac0a // ldp w10, w11, [x0, #52] + WORD $0x138a416a // extr w10, w11, w10, #16 + WORD $0x53027d6c // lsr w12, w11, #2 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb9403c0a // ldr w10, [x0, #60] + WORD $0x138b514b // extr w11, w10, w11, #20 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x53067d4a // lsr w10, w10, #6 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800901 // str q1, [x8, #32] + WORD $0x2947ac0a // ldp w10, w11, [x0, #60] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x530a7d6c // lsr w12, w11, #10 + WORD $0x1e270141 // fmov s1, w10 + WORD $0xb940440a // ldr w10, [x0, #68] + WORD $0x91012000 // add x0, x0, #72 + WORD $0x138b714b // extr w11, w10, w11, #28 + WORD $0x4e0c1d81 // mov v1.s[1], w12 + WORD $0x530e7d4a // lsr w10, w10, #14 + WORD $0x4e141d61 // mov v1.s[2], w11 + WORD $0x4e1c1d41 // mov v1.s[3], w10 + WORD $0x4e201c21 // and v1.16b, v1.16b, v0.16b + WORD $0x3d800d01 // str q1, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_132 + JMP LBB0_156 + +LBB0_133: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.134: + // WORD $0x90000008 // adrp x8, .LCPI0_153 + // WORD $0x90000009 // adrp x9, .LCPI0_154 + // WORD $0x9000000a // adrp x10, .LCPI0_155 + // WORD $0x9000000b // adrp x11, .LCPI0_156 + WORD $0x4f00c462 // movi v2.4s, #3, msl #8 + VMOVD LCPI0_153, V0 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_154, V1 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_155, V3 + VMOVD LCPI0_156, V4 + +LBB0_135: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x2ea044a5 // ushl v5.2s, v5.2s, v0.2s + WORD $0x6e0560c5 // ext v5.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9c0105 // stur q5, [x8, #-64] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s + WORD $0x4e141d45 // mov v5.s[2], w10 + WORD $0x53067d6a // lsr w10, w11, #6 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9d0105 // stur q5, [x8, #-48] + WORD $0x29412c0a // ldp w10, w11, [x0, #8] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x0e040d65 // dup v5.2s, w11 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x1e270186 // fmov s6, w12 + WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s + WORD $0x4e0c1d46 // mov v6.s[1], w10 + WORD $0x6e1804a6 // mov v6.d[1], v5.d[0] + WORD $0x4e221cc5 // and v5.16b, v6.16b, v2.16b + WORD $0x3c9e0105 // stur q5, [x8, #-32] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x0e040d65 // dup v5.2s, w11 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x53167d6a // lsr w10, w11, #22 + WORD $0x2ea444a5 // ushl v5.2s, v5.2s, v4.2s + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x6e0560c5 // ext v5.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9f0105 // stur q5, [x8, #-16] + WORD $0x2942ac0a // ldp w10, w11, [x0, #20] + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x2ea044a5 // ushl v5.2s, v5.2s, v0.2s + WORD $0x6e0560c5 // ext v5.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800105 // str q5, [x8] + WORD $0x29432c0a // ldp w10, w11, [x0, #24] + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s + WORD $0x4e141d45 // mov v5.s[2], w10 + WORD $0x53067d6a // lsr w10, w11, #6 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800505 // str q5, [x8, #16] + WORD $0x2943ac0a // ldp w10, w11, [x0, #28] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x0e040d65 // dup v5.2s, w11 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x1e270186 // fmov s6, w12 + WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s + WORD $0x4e0c1d46 // mov v6.s[1], w10 + WORD $0x6e1804a6 // mov v6.d[1], v5.d[0] + WORD $0x4e221cc5 // and v5.16b, v6.16b, v2.16b + WORD $0x3d800905 // str q5, [x8, #32] + WORD $0x29442c0a // ldp w10, w11, [x0, #32] + WORD $0x9100a000 // add x0, x0, #40 + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x0e040d65 // dup v5.2s, w11 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x53167d6a // lsr w10, w11, #22 + WORD $0x2ea444a5 // ushl v5.2s, v5.2s, v4.2s + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x6e0560c5 // ext v5.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800d05 // str q5, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_135 + JMP LBB0_156 + +LBB0_136: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.137: + // WORD $0x90000008 // adrp x8, .LCPI0_68 + // WORD $0x90000009 // adrp x9, .LCPI0_69 + // WORD $0x9000000a // adrp x10, .LCPI0_70 + VMOVD LCPI0_68, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_71 + VMOVD LCPI0_69, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_72 + VMOVD LCPI0_70, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_73 + VMOVD LCPI0_71, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_74 + VMOVD LCPI0_72, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_75 + VMOVD LCPI0_73, V5 + VMOVD LCPI0_74, V6 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_75, V7 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_138: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404010 // ldur d16, [x0, #4] + WORD $0xb9400c0b // ldr w11, [x0, #12] + WORD $0x1e270151 // fmov s17, w10 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x2ea04613 // ushl v19.2s, v16.2s, v0.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x138a396a // extr w10, w11, w10, #14 + WORD $0x2ea14631 // ushl v17.2s, v17.2s, v1.2s + WORD $0x0eb11e71 // orr v17.8b, v19.8b, v17.8b + WORD $0x6e116250 // ext v16.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f077790 // bic v16.4s, #252, lsl #24 + WORD $0x3c9c0110 // stur q16, [x8, #-64] + WORD $0x2941a80b // ldp w11, w10, [x0, #12] + WORD $0xfc414010 // ldur d16, [x0, #20] + WORD $0x1e270151 // fmov s17, w10 + WORD $0x138b214b // extr w11, w10, w11, #8 + WORD $0x53027d4a // lsr w10, w10, #2 + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x2ea24610 // ushl v16.2s, v16.2s, v2.2s + WORD $0x1e270172 // fmov s18, w11 + WORD $0x2ea34631 // ushl v17.2s, v17.2s, v3.2s + WORD $0x4e0c1d52 // mov v18.s[1], w10 + WORD $0x0eb11e10 // orr v16.8b, v16.8b, v17.8b + WORD $0x6e180612 // mov v18.d[1], v16.d[0] + WORD $0x6f077792 // bic v18.4s, #252, lsl #24 + WORD $0x3c9d0112 // stur q18, [x8, #-48] + WORD $0xfc41c010 // ldur d16, [x0, #28] + WORD $0xbd401811 // ldr s17, [x0, #24] + WORD $0xb940240c // ldr w12, [x0, #36] + WORD $0x2ea44612 // ushl v18.2s, v16.2s, v4.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x53047d4b // lsr w11, w10, #4 + WORD $0x138a798a // extr w10, w12, w10, #30 + WORD $0x2ea54631 // ushl v17.2s, v17.2s, v5.2s + WORD $0x0eb11e50 // orr v16.8b, v18.8b, v17.8b + WORD $0x4e141d70 // mov v16.s[2], w11 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f077790 // bic v16.4s, #252, lsl #24 + WORD $0x3c9e0110 // stur q16, [x8, #-32] + WORD $0xfd401410 // ldr d16, [x0, #40] + WORD $0xbd402411 // ldr s17, [x0, #36] + WORD $0xb940300b // ldr w11, [x0, #48] + WORD $0x2ea64612 // ushl v18.2s, v16.2s, v6.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x138a316a // extr w10, w11, w10, #12 + WORD $0x2ea74631 // ushl v17.2s, v17.2s, v7.2s + WORD $0x0eb11e50 // orr v16.8b, v18.8b, v17.8b + WORD $0x4e141d50 // mov v16.s[2], w10 + WORD $0x53067d6a // lsr w10, w11, #6 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f077790 // bic v16.4s, #252, lsl #24 + WORD $0x3c9f0110 // stur q16, [x8, #-16] + WORD $0xb940340a // ldr w10, [x0, #52] + WORD $0xfd401c10 // ldr d16, [x0, #56] + WORD $0xb940400b // ldr w11, [x0, #64] + WORD $0x1e270151 // fmov s17, w10 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x2ea04613 // ushl v19.2s, v16.2s, v0.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x138a396a // extr w10, w11, w10, #14 + WORD $0x2ea14631 // ushl v17.2s, v17.2s, v1.2s + WORD $0x0eb11e71 // orr v17.8b, v19.8b, v17.8b + WORD $0x6e116250 // ext v16.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f077790 // bic v16.4s, #252, lsl #24 + WORD $0x3d800110 // str q16, [x8] + WORD $0x2948280b // ldp w11, w10, [x0, #64] + WORD $0xfd402410 // ldr d16, [x0, #72] + WORD $0x1e270151 // fmov s17, w10 + WORD $0x138b214b // extr w11, w10, w11, #8 + WORD $0x53027d4a // lsr w10, w10, #2 + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x2ea24610 // ushl v16.2s, v16.2s, v2.2s + WORD $0x1e270172 // fmov s18, w11 + WORD $0x2ea34631 // ushl v17.2s, v17.2s, v3.2s + WORD $0x4e0c1d52 // mov v18.s[1], w10 + WORD $0x0eb11e10 // orr v16.8b, v16.8b, v17.8b + WORD $0x6e180612 // mov v18.d[1], v16.d[0] + WORD $0x6f077792 // bic v18.4s, #252, lsl #24 + WORD $0x3d800512 // str q18, [x8, #16] + WORD $0xfd402810 // ldr d16, [x0, #80] + WORD $0xbd404c11 // ldr s17, [x0, #76] + WORD $0xb940580c // ldr w12, [x0, #88] + WORD $0x2ea44612 // ushl v18.2s, v16.2s, v4.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x53047d4b // lsr w11, w10, #4 + WORD $0x138a798a // extr w10, w12, w10, #30 + WORD $0x2ea54631 // ushl v17.2s, v17.2s, v5.2s + WORD $0x0eb11e50 // orr v16.8b, v18.8b, v17.8b + WORD $0x4e141d70 // mov v16.s[2], w11 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f077790 // bic v16.4s, #252, lsl #24 + WORD $0x3d800910 // str q16, [x8, #32] + WORD $0xfc45c010 // ldur d16, [x0, #92] + WORD $0xbd405811 // ldr s17, [x0, #88] + WORD $0xb940640b // ldr w11, [x0, #100] + WORD $0x9101a000 // add x0, x0, #104 + WORD $0x2ea64612 // ushl v18.2s, v16.2s, v6.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x138a316a // extr w10, w11, w10, #12 + WORD $0x2ea74631 // ushl v17.2s, v17.2s, v7.2s + WORD $0x0eb11e50 // orr v16.8b, v18.8b, v17.8b + WORD $0x4e141d50 // mov v16.s[2], w10 + WORD $0x53067d6a // lsr w10, w11, #6 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f077790 // bic v16.4s, #252, lsl #24 + WORD $0x3d800d10 // str q16, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_138 + JMP LBB0_156 + +LBB0_139: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.140: + // WORD $0x90000008 // adrp x8, .LCPI0_174 + // WORD $0x90000009 // adrp x9, .LCPI0_175 + // WORD $0x9000000a // adrp x10, .LCPI0_176 + // WORD $0x9000000b // adrp x11, .LCPI0_177 + WORD $0x4f0107e2 // movi v2.4s, #63 + VMOVD LCPI0_174, V0 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_175, V1 + WORD $0xaa1303e9 // mov x9, x19 + VMOVD LCPI0_176, V3 + VMOVQ LCPI0_177L, LCPI0_177H, V4 + +LBB0_141: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x53127d4a // lsr w10, w10, #18 + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x2ea044a5 // ushl v5.2s, v5.2s, v0.2s + WORD $0x6e0560c5 // ext v5.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9c0105 // stur q5, [x8, #-64] + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0x53187d4c // lsr w12, w10, #24 + WORD $0x0e040d65 // dup v5.2s, w11 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x1e270186 // fmov s6, w12 + WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s + WORD $0x4e0c1d46 // mov v6.s[1], w10 + WORD $0x6e1804a6 // mov v6.d[1], v5.d[0] + WORD $0x4e221cc5 // and v5.16b, v6.16b, v2.16b + WORD $0x3c9d0105 // stur q5, [x8, #-48] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s + WORD $0x4e141d45 // mov v5.s[2], w10 + WORD $0x53027d6a // lsr w10, w11, #2 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x9100200a // add x10, x0, #8 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9e0105 // stur q5, [x8, #-32] + WORD $0x4d40c945 // ld1r { v5.4s }, [x10] + WORD $0x6ea444a5 // ushl v5.4s, v5.4s, v4.4s + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3c9f0105 // stur q5, [x8, #-16] + WORD $0xb9400c0a // ldr w10, [x0, #12] + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x1e270146 // fmov s6, w10 + WORD $0x53127d4a // lsr w10, w10, #18 + WORD $0x6e0620c6 // ext v6.16b, v6.16b, v6.16b, #4 + WORD $0x2ea044a5 // ushl v5.2s, v5.2s, v0.2s + WORD $0x6e0560c5 // ext v5.16b, v6.16b, v5.16b, #12 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800105 // str q5, [x8] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x53187d4c // lsr w12, w10, #24 + WORD $0x0e040d65 // dup v5.2s, w11 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x1e270186 // fmov s6, w12 + WORD $0x2ea144a5 // ushl v5.2s, v5.2s, v1.2s + WORD $0x4e0c1d46 // mov v6.s[1], w10 + WORD $0x6e1804a6 // mov v6.d[1], v5.d[0] + WORD $0x4e221cc5 // and v5.16b, v6.16b, v2.16b + WORD $0x3d800505 // str q5, [x8, #16] + WORD $0x29422c0a // ldp w10, w11, [x0, #16] + WORD $0x0e040d45 // dup v5.2s, w10 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x2ea344a5 // ushl v5.2s, v5.2s, v3.2s + WORD $0x4e141d45 // mov v5.s[2], w10 + WORD $0x53027d6a // lsr w10, w11, #2 + WORD $0x4e1c1d45 // mov v5.s[3], w10 + WORD $0x9100500a // add x10, x0, #20 + WORD $0x91006000 // add x0, x0, #24 + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800905 // str q5, [x8, #32] + WORD $0x4d40c945 // ld1r { v5.4s }, [x10] + WORD $0x6ea444a5 // ushl v5.4s, v5.4s, v4.4s + WORD $0x4e221ca5 // and v5.16b, v5.16b, v2.16b + WORD $0x3d800d05 // str q5, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_141 + JMP LBB0_156 + +LBB0_142: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.143: + // WORD $0x90000008 // adrp x8, .LCPI0_110 + // WORD $0x90000009 // adrp x9, .LCPI0_111 + // WORD $0x9000000a // adrp x10, .LCPI0_112 + WORD $0x4f01d7e7 // movi v7.4s, #63, msl #16 + VMOVD LCPI0_110, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_113 + VMOVD LCPI0_111, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_114 + VMOVD LCPI0_112, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_115 + VMOVD LCPI0_113, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_116 + VMOVD LCPI0_114, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_117 + VMOVD LCPI0_115, V5 + VMOVD LCPI0_116, V6 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_117, V16 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_144: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404011 // ldur d17, [x0, #4] + WORD $0x1e270152 // fmov s18, w10 + WORD $0x1e270153 // fmov s19, w10 + WORD $0x2ea04634 // ushl v20.2s, v17.2s, v0.2s + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x6e132273 // ext v19.16b, v19.16b, v19.16b, #4 + WORD $0x53027d4a // lsr w10, w10, #2 + WORD $0x2ea14652 // ushl v18.2s, v18.2s, v1.2s + WORD $0x0eb21e92 // orr v18.8b, v20.8b, v18.8b + WORD $0x6e126271 // ext v17.16b, v19.16b, v18.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9c0111 // stur q17, [x8, #-64] + WORD $0xfc40c011 // ldur d17, [x0, #12] + WORD $0xbd400812 // ldr s18, [x0, #8] + WORD $0xb940140c // ldr w12, [x0, #20] + WORD $0x2ea24633 // ushl v19.2s, v17.2s, v2.2s + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x53047d4b // lsr w11, w10, #4 + WORD $0x138a698a // extr w10, w12, w10, #26 + WORD $0x2ea34652 // ushl v18.2s, v18.2s, v3.2s + WORD $0x0eb21e71 // orr v17.8b, v19.8b, v18.8b + WORD $0x4e141d71 // mov v17.s[2], w11 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9d0111 // stur q17, [x8, #-48] + WORD $0x2942a80b // ldp w11, w10, [x0, #20] + WORD $0xfc41c011 // ldur d17, [x0, #28] + WORD $0x1e270152 // fmov s18, w10 + WORD $0x138b414b // extr w11, w10, w11, #16 + WORD $0x53067d4a // lsr w10, w10, #6 + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x2ea44631 // ushl v17.2s, v17.2s, v4.2s + WORD $0x1e270173 // fmov s19, w11 + WORD $0x2ea54652 // ushl v18.2s, v18.2s, v5.2s + WORD $0x4e0c1d53 // mov v19.s[1], w10 + WORD $0x0eb21e31 // orr v17.8b, v17.8b, v18.8b + WORD $0x6e180633 // mov v19.d[1], v17.d[0] + WORD $0x4e271e71 // and v17.16b, v19.16b, v7.16b + WORD $0x3c9e0111 // stur q17, [x8, #-32] + WORD $0xb940200a // ldr w10, [x0, #32] + WORD $0xfc424011 // ldur d17, [x0, #36] + WORD $0x1e270152 // fmov s18, w10 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea64633 // ushl v19.2s, v17.2s, v6.2s + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x1e270154 // fmov s20, w10 + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x6e142294 // ext v20.16b, v20.16b, v20.16b, #4 + WORD $0x2eb04652 // ushl v18.2s, v18.2s, v16.2s + WORD $0x530a7d4a // lsr w10, w10, #10 + WORD $0x0eb21e72 // orr v18.8b, v19.8b, v18.8b + WORD $0x6e126291 // ext v17.16b, v20.16b, v18.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3c9f0111 // stur q17, [x8, #-16] + WORD $0xb9402c0a // ldr w10, [x0, #44] + WORD $0xfd401811 // ldr d17, [x0, #48] + WORD $0x1e270152 // fmov s18, w10 + WORD $0x1e270153 // fmov s19, w10 + WORD $0x2ea04634 // ushl v20.2s, v17.2s, v0.2s + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x6e132273 // ext v19.16b, v19.16b, v19.16b, #4 + WORD $0x53027d4a // lsr w10, w10, #2 + WORD $0x2ea14652 // ushl v18.2s, v18.2s, v1.2s + WORD $0x0eb21e92 // orr v18.8b, v20.8b, v18.8b + WORD $0x6e126271 // ext v17.16b, v19.16b, v18.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800111 // str q17, [x8] + WORD $0xfd401c11 // ldr d17, [x0, #56] + WORD $0xbd403412 // ldr s18, [x0, #52] + WORD $0xb940400c // ldr w12, [x0, #64] + WORD $0x2ea24633 // ushl v19.2s, v17.2s, v2.2s + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x53047d4b // lsr w11, w10, #4 + WORD $0x138a698a // extr w10, w12, w10, #26 + WORD $0x2ea34652 // ushl v18.2s, v18.2s, v3.2s + WORD $0x0eb21e71 // orr v17.8b, v19.8b, v18.8b + WORD $0x4e141d71 // mov v17.s[2], w11 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800511 // str q17, [x8, #16] + WORD $0x2948280b // ldp w11, w10, [x0, #64] + WORD $0xfd402411 // ldr d17, [x0, #72] + WORD $0x1e270152 // fmov s18, w10 + WORD $0x138b414b // extr w11, w10, w11, #16 + WORD $0x53067d4a // lsr w10, w10, #6 + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x2ea44631 // ushl v17.2s, v17.2s, v4.2s + WORD $0x1e270173 // fmov s19, w11 + WORD $0x2ea54652 // ushl v18.2s, v18.2s, v5.2s + WORD $0x4e0c1d53 // mov v19.s[1], w10 + WORD $0x0eb21e31 // orr v17.8b, v17.8b, v18.8b + WORD $0x6e180633 // mov v19.d[1], v17.d[0] + WORD $0x4e271e71 // and v17.16b, v19.16b, v7.16b + WORD $0x3d800911 // str q17, [x8, #32] + WORD $0xb9404c0a // ldr w10, [x0, #76] + WORD $0xfd402811 // ldr d17, [x0, #80] + WORD $0x91016000 // add x0, x0, #88 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x53087d4a // lsr w10, w10, #8 + WORD $0x2ea64633 // ushl v19.2s, v17.2s, v6.2s + WORD $0x0e913a52 // zip1 v18.2s, v18.2s, v17.2s + WORD $0x1e270154 // fmov s20, w10 + WORD $0x0e0c3e2a // mov w10, v17.s[1] + WORD $0x6e142294 // ext v20.16b, v20.16b, v20.16b, #4 + WORD $0x2eb04652 // ushl v18.2s, v18.2s, v16.2s + WORD $0x530a7d4a // lsr w10, w10, #10 + WORD $0x0eb21e72 // orr v18.8b, v19.8b, v18.8b + WORD $0x6e126291 // ext v17.16b, v20.16b, v18.16b, #12 + WORD $0x4e1c1d51 // mov v17.s[3], w10 + WORD $0x4e271e31 // and v17.16b, v17.16b, v7.16b + WORD $0x3d800d11 // str q17, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_144 + JMP LBB0_156 + +LBB0_145: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.146: + // WORD $0x90000009 // adrp x9, .LCPI0_139 + WORD $0x91010348 // add x8, x26, #64 + WORD $0x4f01c7e0 // movi v0.4s, #63, msl #8 + VMOVD LCPI0_139, V1 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_147: + WORD $0x29402c0a // ldp w10, w11, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0x530e7d4c // lsr w12, w10, #14 + WORD $0x1e270142 // fmov s2, w10 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x530a7d6a // lsr w10, w11, #10 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9c0102 // stur q2, [x8, #-64] + WORD $0x2940ac0a // ldp w10, w11, [x0, #4] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x53067d6c // lsr w12, w11, #6 + WORD $0x1e270142 // fmov s2, w10 + WORD $0xb9400c0a // ldr w10, [x0, #12] + WORD $0x138b514b // extr w11, w10, w11, #20 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x53027d4a // lsr w10, w10, #2 + WORD $0x4e141d62 // mov v2.s[2], w11 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9d0102 // stur q2, [x8, #-48] + WORD $0x2941ac0a // ldp w10, w11, [x0, #12] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x1e270182 // fmov s2, w12 + WORD $0xb940140c // ldr w12, [x0, #20] + WORD $0x4e0c1d42 // mov v2.s[1], w10 + WORD $0x530c7d6a // lsr w10, w11, #12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x138b698a // extr w10, w12, w11, #26 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3c9e0102 // stur q2, [x8, #-32] + WORD $0x2942ac0a // ldp w10, w11, [x0, #20] + WORD $0x53087d4c // lsr w12, w10, #8 + WORD $0x0e040d62 // dup v2.2s, w11 + WORD $0x138a596a // extr w10, w11, w10, #22 + WORD $0x1e270183 // fmov s3, w12 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x4e0c1d43 // mov v3.s[1], w10 + WORD $0x6e180443 // mov v3.d[1], v2.d[0] + WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b + WORD $0x3c9f0102 // stur q2, [x8, #-16] + WORD $0x2943ac0a // ldp w10, w11, [x0, #28] + WORD $0x530e7d4c // lsr w12, w10, #14 + WORD $0x1e270142 // fmov s2, w10 + WORD $0x138a716a // extr w10, w11, w10, #28 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x530a7d6a // lsr w10, w11, #10 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800102 // str q2, [x8] + WORD $0x29442c0a // ldp w10, w11, [x0, #32] + WORD $0x138a616a // extr w10, w11, w10, #24 + WORD $0x53067d6c // lsr w12, w11, #6 + WORD $0x1e270142 // fmov s2, w10 + WORD $0xb940280a // ldr w10, [x0, #40] + WORD $0x138b514b // extr w11, w10, w11, #20 + WORD $0x4e0c1d82 // mov v2.s[1], w12 + WORD $0x53027d4a // lsr w10, w10, #2 + WORD $0x4e141d62 // mov v2.s[2], w11 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800502 // str q2, [x8, #16] + WORD $0x29452c0a // ldp w10, w11, [x0, #40] + WORD $0x53107d4c // lsr w12, w10, #16 + WORD $0x138a796a // extr w10, w11, w10, #30 + WORD $0x1e270182 // fmov s2, w12 + WORD $0xb940300c // ldr w12, [x0, #48] + WORD $0x4e0c1d42 // mov v2.s[1], w10 + WORD $0x530c7d6a // lsr w10, w11, #12 + WORD $0x4e141d42 // mov v2.s[2], w10 + WORD $0x138b698a // extr w10, w12, w11, #26 + WORD $0x4e1c1d42 // mov v2.s[3], w10 + WORD $0x4e201c42 // and v2.16b, v2.16b, v0.16b + WORD $0x3d800902 // str q2, [x8, #32] + WORD $0x29462c0a // ldp w10, w11, [x0, #48] + WORD $0x9100e000 // add x0, x0, #56 + WORD $0x53087d4c // lsr w12, w10, #8 + WORD $0x0e040d62 // dup v2.2s, w11 + WORD $0x138a596a // extr w10, w11, w10, #22 + WORD $0x1e270183 // fmov s3, w12 + WORD $0x2ea14442 // ushl v2.2s, v2.2s, v1.2s + WORD $0x4e0c1d43 // mov v3.s[1], w10 + WORD $0x6e180443 // mov v3.d[1], v2.d[0] + WORD $0x4e201c62 // and v2.16b, v3.16b, v0.16b + WORD $0x3d800d02 // str q2, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_147 + JMP LBB0_156 + +LBB0_148: + WORD $0x7100805f // cmp w2, #32 + BLT LBB0_156 + + // %bb.149: + // WORD $0x90000008 // adrp x8, .LCPI0_24 + // WORD $0x90000009 // adrp x9, .LCPI0_25 + // WORD $0x9000000a // adrp x10, .LCPI0_26 + VMOVD LCPI0_24, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_27 + VMOVD LCPI0_25, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_28 + VMOVQ LCPI0_26L, LCPI0_26H, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_29 + VMOVQ LCPI0_27L, LCPI0_27H, V3 + // WORD $0x90000008 // adrp x8, .LCPI0_30 + VMOVQ LCPI0_28L, LCPI0_28H, V4 + // WORD $0x90000009 // adrp x9, .LCPI0_31 + VMOVQ LCPI0_29L, LCPI0_29H, V5 + VMOVD LCPI0_30, V6 + WORD $0x91010348 // add x8, x26, #64 + VMOVD LCPI0_31, V7 + WORD $0xaa1303e9 // mov x9, x19 + +LBB0_150: + WORD $0xb940000a // ldr w10, [x0] + WORD $0xf1000529 // subs x9, x9, #1 + WORD $0xfc404010 // ldur d16, [x0, #4] + WORD $0xb9400c0b // ldr w11, [x0, #12] + WORD $0x1e270151 // fmov s17, w10 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x2ea04613 // ushl v19.2s, v16.2s, v0.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x2ea14631 // ushl v17.2s, v17.2s, v1.2s + WORD $0x0eb11e71 // orr v17.8b, v19.8b, v17.8b + WORD $0x6e116250 // ext v16.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f067410 // bic v16.4s, #192, lsl #24 + WORD $0x3c9c0110 // stur q16, [x8, #-64] + WORD $0xbd400c10 // ldr s16, [x0, #12] + WORD $0x3dc00411 // ldr q17, [x0, #16] + WORD $0x6e102210 // ext v16.16b, v16.16b, v16.16b, #4 + WORD $0x6e116210 // ext v16.16b, v16.16b, v17.16b, #12 + WORD $0x6ea24631 // ushl v17.4s, v17.4s, v2.4s + WORD $0x6ea34610 // ushl v16.4s, v16.4s, v3.4s + WORD $0x4eb01e30 // orr v16.16b, v17.16b, v16.16b + WORD $0x6f067410 // bic v16.4s, #192, lsl #24 + WORD $0x3c9d0110 // stur q16, [x8, #-48] + WORD $0xbd401c10 // ldr s16, [x0, #28] + WORD $0x3dc00811 // ldr q17, [x0, #32] + WORD $0x6e102210 // ext v16.16b, v16.16b, v16.16b, #4 + WORD $0x6e116210 // ext v16.16b, v16.16b, v17.16b, #12 + WORD $0x6ea44631 // ushl v17.4s, v17.4s, v4.4s + WORD $0x6ea54610 // ushl v16.4s, v16.4s, v5.4s + WORD $0x4eb01e30 // orr v16.16b, v17.16b, v16.16b + WORD $0x6f067410 // bic v16.4s, #192, lsl #24 + WORD $0x3c9e0110 // stur q16, [x8, #-32] + WORD $0xfd401810 // ldr d16, [x0, #48] + WORD $0xbd402c11 // ldr s17, [x0, #44] + WORD $0xb940380b // ldr w11, [x0, #56] + WORD $0x2ea64612 // ushl v18.2s, v16.2s, v6.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x138a116a // extr w10, w11, w10, #4 + WORD $0x2ea74631 // ushl v17.2s, v17.2s, v7.2s + WORD $0x0eb11e50 // orr v16.8b, v18.8b, v17.8b + WORD $0x4e141d50 // mov v16.s[2], w10 + WORD $0x53027d6a // lsr w10, w11, #2 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f067410 // bic v16.4s, #192, lsl #24 + WORD $0x3c9f0110 // stur q16, [x8, #-16] + WORD $0xb9403c0a // ldr w10, [x0, #60] + WORD $0xfd402010 // ldr d16, [x0, #64] + WORD $0xb940480b // ldr w11, [x0, #72] + WORD $0x1e270151 // fmov s17, w10 + WORD $0x1e270152 // fmov s18, w10 + WORD $0x2ea04613 // ushl v19.2s, v16.2s, v0.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x6e122252 // ext v18.16b, v18.16b, v18.16b, #4 + WORD $0x138a696a // extr w10, w11, w10, #26 + WORD $0x2ea14631 // ushl v17.2s, v17.2s, v1.2s + WORD $0x0eb11e71 // orr v17.8b, v19.8b, v17.8b + WORD $0x6e116250 // ext v16.16b, v18.16b, v17.16b, #12 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f067410 // bic v16.4s, #192, lsl #24 + WORD $0x3d800110 // str q16, [x8] + WORD $0xbd404810 // ldr s16, [x0, #72] + WORD $0x3cc4c011 // ldur q17, [x0, #76] + WORD $0x6e102210 // ext v16.16b, v16.16b, v16.16b, #4 + WORD $0x6e116210 // ext v16.16b, v16.16b, v17.16b, #12 + WORD $0x6ea24631 // ushl v17.4s, v17.4s, v2.4s + WORD $0x6ea34610 // ushl v16.4s, v16.4s, v3.4s + WORD $0x4eb01e30 // orr v16.16b, v17.16b, v16.16b + WORD $0x6f067410 // bic v16.4s, #192, lsl #24 + WORD $0x3d800510 // str q16, [x8, #16] + WORD $0xbd405810 // ldr s16, [x0, #88] + WORD $0x3cc5c011 // ldur q17, [x0, #92] + WORD $0x6e102210 // ext v16.16b, v16.16b, v16.16b, #4 + WORD $0x6e116210 // ext v16.16b, v16.16b, v17.16b, #12 + WORD $0x6ea44631 // ushl v17.4s, v17.4s, v4.4s + WORD $0x6ea54610 // ushl v16.4s, v16.4s, v5.4s + WORD $0x4eb01e30 // orr v16.16b, v17.16b, v16.16b + WORD $0x6f067410 // bic v16.4s, #192, lsl #24 + WORD $0x3d800910 // str q16, [x8, #32] + WORD $0xfc46c010 // ldur d16, [x0, #108] + WORD $0xbd406811 // ldr s17, [x0, #104] + WORD $0xb940740b // ldr w11, [x0, #116] + WORD $0x9101e000 // add x0, x0, #120 + WORD $0x2ea64612 // ushl v18.2s, v16.2s, v6.2s + WORD $0x0e0c3e0a // mov w10, v16.s[1] + WORD $0x0e903a31 // zip1 v17.2s, v17.2s, v16.2s + WORD $0x138a116a // extr w10, w11, w10, #4 + WORD $0x2ea74631 // ushl v17.2s, v17.2s, v7.2s + WORD $0x0eb11e50 // orr v16.8b, v18.8b, v17.8b + WORD $0x4e141d50 // mov v16.s[2], w10 + WORD $0x53027d6a // lsr w10, w11, #2 + WORD $0x4e1c1d50 // mov v16.s[3], w10 + WORD $0x6f067410 // bic v16.4s, #192, lsl #24 + WORD $0x3d800d10 // str q16, [x8, #48] + WORD $0x91020108 // add x8, x8, #128 + BNE LBB0_150 + JMP LBB0_156 + +LBB0_151: + // WORD $0x90000008 // adrp x8, .LCPI0_0 + // WORD $0x90000009 // adrp x9, .LCPI0_1 + // WORD $0x9000000a // adrp x10, .LCPI0_2 + // WORD $0x9000000b // adrp x11, .LCPI0_3 + WORD $0x5280020c // mov w12, #16 + VMOVQ LCPI0_0L, LCPI0_0H, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_4 + VMOVQ LCPI0_1L, LCPI0_1H, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_5 + VMOVQ LCPI0_2L, LCPI0_2H, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_6 + VMOVQ LCPI0_3L, LCPI0_3H, V3 + // WORD $0x9000000b // adrp x11, .LCPI0_7 + VMOVQ LCPI0_4L, LCPI0_4H, V4 + WORD $0x927c6e68 // and x8, x19, #0xfffffff0 + VMOVQ LCPI0_5L, LCPI0_5H, V5 + WORD $0xaa0803e9 // mov x9, x8 + VMOVQ LCPI0_6L, LCPI0_6H, V6 + WORD $0x4e080d90 // dup v16.2d, x12 + VMOVQ LCPI0_7L, LCPI0_7H, V7 + +LBB0_152: + WORD $0x4f4554f1 // shl v17.2d, v7.2d, #5 + WORD $0xf1004129 // subs x9, x9, #16 + WORD $0x4f4554d2 // shl v18.2d, v6.2d, #5 + WORD $0x4f4554b3 // shl v19.2d, v5.2d, #5 + WORD $0x4f455494 // shl v20.2d, v4.2d, #5 + WORD $0x4e183e2d // mov x13, v17.d[1] + WORD $0x9e66022a // fmov x10, d17 + WORD $0x4e183e4e // mov x14, v18.d[1] + WORD $0x9e66026f // fmov x15, d19 + WORD $0x4e183e70 // mov x16, v19.d[1] + WORD $0x4f455471 // shl v17.2d, v3.2d, #5 + WORD $0x8b0a0b4c // add x12, x26, x10, lsl #2 + WORD $0x9e660280 // fmov x0, d20 + WORD $0x8b0f0b4a // add x10, x26, x15, lsl #2 + WORD $0x4f455453 // shl v19.2d, v2.2d, #5 + WORD $0x9e66024b // fmov x11, d18 + WORD $0x8b0d0b51 // add x17, x26, x13, lsl #2 + WORD $0x8b0e0b4f // add x15, x26, x14, lsl #2 + WORD $0x4f455412 // shl v18.2d, v0.2d, #5 + WORD $0x8b100b4d // add x13, x26, x16, lsl #2 + WORD $0x8b000b4e // add x14, x26, x0, lsl #2 + WORD $0x9e660230 // fmov x16, d17 + WORD $0x4e183e20 // mov x0, v17.d[1] + WORD $0x9e660263 // fmov x3, d19 + WORD $0x4f455431 // shl v17.2d, v1.2d, #5 + WORD $0x8b0b0b4b // add x11, x26, x11, lsl #2 + WORD $0x4e183e92 // mov x18, v20.d[1] + WORD $0x8b100b50 // add x16, x26, x16, lsl #2 + WORD $0x4e183e62 // mov x2, v19.d[1] + WORD $0x8b030b54 // add x20, x26, x3, lsl #2 + WORD $0x4e183e46 // mov x6, v18.d[1] + WORD $0x8b000b40 // add x0, x26, x0, lsl #2 + WORD $0x4e183e23 // mov x3, v17.d[1] + WORD $0xb900019f // str wzr, [x12] + WORD $0x9e660225 // fmov x5, d17 + WORD $0x8b120b52 // add x18, x26, x18, lsl #2 + WORD $0x9e660247 // fmov x7, d18 + WORD $0x8b020b44 // add x4, x26, x2, lsl #2 + WORD $0x4ef084a5 // add v5.2d, v5.2d, v16.2d + WORD $0x8b060b46 // add x6, x26, x6, lsl #2 + WORD $0x4ef084c6 // add v6.2d, v6.2d, v16.2d + WORD $0x8b050b45 // add x5, x26, x5, lsl #2 + WORD $0x4ef084e7 // add v7.2d, v7.2d, v16.2d + WORD $0x8b030b42 // add x2, x26, x3, lsl #2 + WORD $0x4ef08484 // add v4.2d, v4.2d, v16.2d + WORD $0x8b070b43 // add x3, x26, x7, lsl #2 + WORD $0x4ef08463 // add v3.2d, v3.2d, v16.2d + WORD $0xb900023f // str wzr, [x17] + WORD $0x4ef08442 // add v2.2d, v2.2d, v16.2d + WORD $0xb900017f // str wzr, [x11] + WORD $0x4ef08421 // add v1.2d, v1.2d, v16.2d + WORD $0xb90001ff // str wzr, [x15] + WORD $0x4ef08400 // add v0.2d, v0.2d, v16.2d + WORD $0xb900015f // str wzr, [x10] + WORD $0xb90001bf // str wzr, [x13] + WORD $0xb90001df // str wzr, [x14] + WORD $0xb900025f // str wzr, [x18] + WORD $0xb900021f // str wzr, [x16] + WORD $0xb900001f // str wzr, [x0] + WORD $0xb900029f // str wzr, [x20] + WORD $0xb900009f // str wzr, [x4] + WORD $0xb90000bf // str wzr, [x5] + WORD $0xb900005f // str wzr, [x2] + WORD $0xb900007f // str wzr, [x3] + WORD $0xb90000df // str wzr, [x6] + WORD $0xb900059f // str wzr, [x12, #4] + WORD $0xb900063f // str wzr, [x17, #4] + WORD $0xb900057f // str wzr, [x11, #4] + WORD $0xb90005ff // str wzr, [x15, #4] + WORD $0xb900055f // str wzr, [x10, #4] + WORD $0xb90005bf // str wzr, [x13, #4] + WORD $0xb90005df // str wzr, [x14, #4] + WORD $0xb900065f // str wzr, [x18, #4] + WORD $0xb900061f // str wzr, [x16, #4] + WORD $0xb900041f // str wzr, [x0, #4] + WORD $0xb900069f // str wzr, [x20, #4] + WORD $0xb900049f // str wzr, [x4, #4] + WORD $0xb90004bf // str wzr, [x5, #4] + WORD $0xb900045f // str wzr, [x2, #4] + WORD $0xb900047f // str wzr, [x3, #4] + WORD $0xb90004df // str wzr, [x6, #4] + WORD $0xb900099f // str wzr, [x12, #8] + WORD $0xb9000a3f // str wzr, [x17, #8] + WORD $0xb900097f // str wzr, [x11, #8] + WORD $0xb90009ff // str wzr, [x15, #8] + WORD $0xb900095f // str wzr, [x10, #8] + WORD $0xb90009bf // str wzr, [x13, #8] + WORD $0xb90009df // str wzr, [x14, #8] + WORD $0xb9000a5f // str wzr, [x18, #8] + WORD $0xb9000a1f // str wzr, [x16, #8] + WORD $0xb900081f // str wzr, [x0, #8] + WORD $0xb9000a9f // str wzr, [x20, #8] + WORD $0xb900089f // str wzr, [x4, #8] + WORD $0xb90008bf // str wzr, [x5, #8] + WORD $0xb900085f // str wzr, [x2, #8] + WORD $0xb900087f // str wzr, [x3, #8] + WORD $0xb90008df // str wzr, [x6, #8] + WORD $0xb9000d9f // str wzr, [x12, #12] + WORD $0xb9000e3f // str wzr, [x17, #12] + WORD $0xb9000d7f // str wzr, [x11, #12] + WORD $0xb9000dff // str wzr, [x15, #12] + WORD $0xb9000d5f // str wzr, [x10, #12] + WORD $0xb9000dbf // str wzr, [x13, #12] + WORD $0xb9000ddf // str wzr, [x14, #12] + WORD $0xb9000e5f // str wzr, [x18, #12] + WORD $0xb9000e1f // str wzr, [x16, #12] + WORD $0xb9000c1f // str wzr, [x0, #12] + WORD $0xb9000e9f // str wzr, [x20, #12] + WORD $0xb9000c9f // str wzr, [x4, #12] + WORD $0xb9000cbf // str wzr, [x5, #12] + WORD $0xb9000c5f // str wzr, [x2, #12] + WORD $0xb9000c7f // str wzr, [x3, #12] + WORD $0xb9000cdf // str wzr, [x6, #12] + WORD $0xb900119f // str wzr, [x12, #16] + WORD $0xb900123f // str wzr, [x17, #16] + WORD $0xb900117f // str wzr, [x11, #16] + WORD $0xb90011ff // str wzr, [x15, #16] + WORD $0xb900115f // str wzr, [x10, #16] + WORD $0xb90011bf // str wzr, [x13, #16] + WORD $0xb90011df // str wzr, [x14, #16] + WORD $0xb900125f // str wzr, [x18, #16] + WORD $0xb900121f // str wzr, [x16, #16] + WORD $0xb900101f // str wzr, [x0, #16] + WORD $0xb900129f // str wzr, [x20, #16] + WORD $0xb900109f // str wzr, [x4, #16] + WORD $0xb90010bf // str wzr, [x5, #16] + WORD $0xb900105f // str wzr, [x2, #16] + WORD $0xb900107f // str wzr, [x3, #16] + WORD $0xb90010df // str wzr, [x6, #16] + WORD $0xb900159f // str wzr, [x12, #20] + WORD $0xb900163f // str wzr, [x17, #20] + WORD $0xb900157f // str wzr, [x11, #20] + WORD $0xb90015ff // str wzr, [x15, #20] + WORD $0xb900155f // str wzr, [x10, #20] + WORD $0xb90015bf // str wzr, [x13, #20] + WORD $0xb90015df // str wzr, [x14, #20] + WORD $0xb900165f // str wzr, [x18, #20] + WORD $0xb900161f // str wzr, [x16, #20] + WORD $0xb900141f // str wzr, [x0, #20] + WORD $0xb900169f // str wzr, [x20, #20] + WORD $0xb900149f // str wzr, [x4, #20] + WORD $0xb90014bf // str wzr, [x5, #20] + WORD $0xb900145f // str wzr, [x2, #20] + WORD $0xb900147f // str wzr, [x3, #20] + WORD $0xb90014df // str wzr, [x6, #20] + WORD $0xb900199f // str wzr, [x12, #24] + WORD $0xb9001a3f // str wzr, [x17, #24] + WORD $0xb900197f // str wzr, [x11, #24] + WORD $0xb90019ff // str wzr, [x15, #24] + WORD $0xb900195f // str wzr, [x10, #24] + WORD $0xb90019bf // str wzr, [x13, #24] + WORD $0xb90019df // str wzr, [x14, #24] + WORD $0xb9001a5f // str wzr, [x18, #24] + WORD $0xb9001a1f // str wzr, [x16, #24] + WORD $0xb900181f // str wzr, [x0, #24] + WORD $0xb9001a9f // str wzr, [x20, #24] + WORD $0xb900189f // str wzr, [x4, #24] + WORD $0xb90018bf // str wzr, [x5, #24] + WORD $0xb900185f // str wzr, [x2, #24] + WORD $0xb900187f // str wzr, [x3, #24] + WORD $0xb90018df // str wzr, [x6, #24] + WORD $0xb9001d9f // str wzr, [x12, #28] + WORD $0xb9001e3f // str wzr, [x17, #28] + WORD $0xb9001d7f // str wzr, [x11, #28] + WORD $0xb9001dff // str wzr, [x15, #28] + WORD $0xb9001d5f // str wzr, [x10, #28] + WORD $0xb9001dbf // str wzr, [x13, #28] + WORD $0xb9001ddf // str wzr, [x14, #28] + WORD $0xb9001e5f // str wzr, [x18, #28] + WORD $0xb9001e1f // str wzr, [x16, #28] + WORD $0xb9001c1f // str wzr, [x0, #28] + WORD $0xb9001e9f // str wzr, [x20, #28] + WORD $0xb9001c9f // str wzr, [x4, #28] + WORD $0xb9001cbf // str wzr, [x5, #28] + WORD $0xb9001c5f // str wzr, [x2, #28] + WORD $0xb9001c7f // str wzr, [x3, #28] + WORD $0xb9001cdf // str wzr, [x6, #28] + WORD $0xb900219f // str wzr, [x12, #32] + WORD $0xb900223f // str wzr, [x17, #32] + WORD $0xb900217f // str wzr, [x11, #32] + WORD $0xb90021ff // str wzr, [x15, #32] + WORD $0xb900215f // str wzr, [x10, #32] + WORD $0xb90021bf // str wzr, [x13, #32] + WORD $0xb90021df // str wzr, [x14, #32] + WORD $0xb900225f // str wzr, [x18, #32] + WORD $0xb900221f // str wzr, [x16, #32] + WORD $0xb900201f // str wzr, [x0, #32] + WORD $0xb900229f // str wzr, [x20, #32] + WORD $0xb900209f // str wzr, [x4, #32] + WORD $0xb90020bf // str wzr, [x5, #32] + WORD $0xb900205f // str wzr, [x2, #32] + WORD $0xb900207f // str wzr, [x3, #32] + WORD $0xb90020df // str wzr, [x6, #32] + WORD $0xb900259f // str wzr, [x12, #36] + WORD $0xb900263f // str wzr, [x17, #36] + WORD $0xb900257f // str wzr, [x11, #36] + WORD $0xb90025ff // str wzr, [x15, #36] + WORD $0xb900255f // str wzr, [x10, #36] + WORD $0xb90025bf // str wzr, [x13, #36] + WORD $0xb90025df // str wzr, [x14, #36] + WORD $0xb900265f // str wzr, [x18, #36] + WORD $0xb900261f // str wzr, [x16, #36] + WORD $0xb900241f // str wzr, [x0, #36] + WORD $0xb900269f // str wzr, [x20, #36] + WORD $0xb900249f // str wzr, [x4, #36] + WORD $0xb90024bf // str wzr, [x5, #36] + WORD $0xb900245f // str wzr, [x2, #36] + WORD $0xb900247f // str wzr, [x3, #36] + WORD $0xb90024df // str wzr, [x6, #36] + WORD $0xb900299f // str wzr, [x12, #40] + WORD $0xb9002a3f // str wzr, [x17, #40] + WORD $0xb900297f // str wzr, [x11, #40] + WORD $0xb90029ff // str wzr, [x15, #40] + WORD $0xb900295f // str wzr, [x10, #40] + WORD $0xb90029bf // str wzr, [x13, #40] + WORD $0xb90029df // str wzr, [x14, #40] + WORD $0xb9002a5f // str wzr, [x18, #40] + WORD $0xb9002a1f // str wzr, [x16, #40] + WORD $0xb900281f // str wzr, [x0, #40] + WORD $0xb9002a9f // str wzr, [x20, #40] + WORD $0xb900289f // str wzr, [x4, #40] + WORD $0xb90028bf // str wzr, [x5, #40] + WORD $0xb900285f // str wzr, [x2, #40] + WORD $0xb900287f // str wzr, [x3, #40] + WORD $0xb90028df // str wzr, [x6, #40] + WORD $0xb9002d9f // str wzr, [x12, #44] + WORD $0xb9002e3f // str wzr, [x17, #44] + WORD $0xb9002d7f // str wzr, [x11, #44] + WORD $0xb9002dff // str wzr, [x15, #44] + WORD $0xb9002d5f // str wzr, [x10, #44] + WORD $0xb9002dbf // str wzr, [x13, #44] + WORD $0xb9002ddf // str wzr, [x14, #44] + WORD $0xb9002e5f // str wzr, [x18, #44] + WORD $0xb9002e1f // str wzr, [x16, #44] + WORD $0xb9002c1f // str wzr, [x0, #44] + WORD $0xb9002e9f // str wzr, [x20, #44] + WORD $0xb9002c9f // str wzr, [x4, #44] + WORD $0xb9002cbf // str wzr, [x5, #44] + WORD $0xb9002c5f // str wzr, [x2, #44] + WORD $0xb9002c7f // str wzr, [x3, #44] + WORD $0xb9002cdf // str wzr, [x6, #44] + WORD $0xb900319f // str wzr, [x12, #48] + WORD $0xb900323f // str wzr, [x17, #48] + WORD $0xb900317f // str wzr, [x11, #48] + WORD $0xb90031ff // str wzr, [x15, #48] + WORD $0xb900315f // str wzr, [x10, #48] + WORD $0xb90031bf // str wzr, [x13, #48] + WORD $0xb90031df // str wzr, [x14, #48] + WORD $0xb900325f // str wzr, [x18, #48] + WORD $0xb900321f // str wzr, [x16, #48] + WORD $0xb900301f // str wzr, [x0, #48] + WORD $0xb900329f // str wzr, [x20, #48] + WORD $0xb900309f // str wzr, [x4, #48] + WORD $0xb90030bf // str wzr, [x5, #48] + WORD $0xb900305f // str wzr, [x2, #48] + WORD $0xb900307f // str wzr, [x3, #48] + WORD $0xb90030df // str wzr, [x6, #48] + WORD $0xb900359f // str wzr, [x12, #52] + WORD $0xb900363f // str wzr, [x17, #52] + WORD $0xb900357f // str wzr, [x11, #52] + WORD $0xb90035ff // str wzr, [x15, #52] + WORD $0xb900355f // str wzr, [x10, #52] + WORD $0xb90035bf // str wzr, [x13, #52] + WORD $0xb90035df // str wzr, [x14, #52] + WORD $0xb900365f // str wzr, [x18, #52] + WORD $0xb900361f // str wzr, [x16, #52] + WORD $0xb900341f // str wzr, [x0, #52] + WORD $0xb900369f // str wzr, [x20, #52] + WORD $0xb900349f // str wzr, [x4, #52] + WORD $0xb90034bf // str wzr, [x5, #52] + WORD $0xb900345f // str wzr, [x2, #52] + WORD $0xb900347f // str wzr, [x3, #52] + WORD $0xb90034df // str wzr, [x6, #52] + WORD $0xb900399f // str wzr, [x12, #56] + WORD $0xb9003a3f // str wzr, [x17, #56] + WORD $0xb900397f // str wzr, [x11, #56] + WORD $0xb90039ff // str wzr, [x15, #56] + WORD $0xb900395f // str wzr, [x10, #56] + WORD $0xb90039bf // str wzr, [x13, #56] + WORD $0xb90039df // str wzr, [x14, #56] + WORD $0xb9003a5f // str wzr, [x18, #56] + WORD $0xb9003a1f // str wzr, [x16, #56] + WORD $0xb900381f // str wzr, [x0, #56] + WORD $0xb9003a9f // str wzr, [x20, #56] + WORD $0xb900389f // str wzr, [x4, #56] + WORD $0xb90038bf // str wzr, [x5, #56] + WORD $0xb900385f // str wzr, [x2, #56] + WORD $0xb900387f // str wzr, [x3, #56] + WORD $0xb90038df // str wzr, [x6, #56] + WORD $0xb9003d9f // str wzr, [x12, #60] + WORD $0xb9003e3f // str wzr, [x17, #60] + WORD $0xb9003d7f // str wzr, [x11, #60] + WORD $0xb9003dff // str wzr, [x15, #60] + WORD $0xb9003d5f // str wzr, [x10, #60] + WORD $0xb9003dbf // str wzr, [x13, #60] + WORD $0xb9003ddf // str wzr, [x14, #60] + WORD $0xb9003e5f // str wzr, [x18, #60] + WORD $0xb9003e1f // str wzr, [x16, #60] + WORD $0xb9003c1f // str wzr, [x0, #60] + WORD $0xb9003e9f // str wzr, [x20, #60] + WORD $0xb9003c9f // str wzr, [x4, #60] + WORD $0xb9003cbf // str wzr, [x5, #60] + WORD $0xb9003c5f // str wzr, [x2, #60] + WORD $0xb9003c7f // str wzr, [x3, #60] + WORD $0xb9003cdf // str wzr, [x6, #60] + WORD $0xb900419f // str wzr, [x12, #64] + WORD $0xb900423f // str wzr, [x17, #64] + WORD $0xb900417f // str wzr, [x11, #64] + WORD $0xb90041ff // str wzr, [x15, #64] + WORD $0xb900415f // str wzr, [x10, #64] + WORD $0xb90041bf // str wzr, [x13, #64] + WORD $0xb90041df // str wzr, [x14, #64] + WORD $0xb900425f // str wzr, [x18, #64] + WORD $0xb900421f // str wzr, [x16, #64] + WORD $0xb900401f // str wzr, [x0, #64] + WORD $0xb900429f // str wzr, [x20, #64] + WORD $0xb900409f // str wzr, [x4, #64] + WORD $0xb90040bf // str wzr, [x5, #64] + WORD $0xb900405f // str wzr, [x2, #64] + WORD $0xb900407f // str wzr, [x3, #64] + WORD $0xb90040df // str wzr, [x6, #64] + WORD $0xb900459f // str wzr, [x12, #68] + WORD $0xb900463f // str wzr, [x17, #68] + WORD $0xb900457f // str wzr, [x11, #68] + WORD $0xb90045ff // str wzr, [x15, #68] + WORD $0xb900455f // str wzr, [x10, #68] + WORD $0xb90045bf // str wzr, [x13, #68] + WORD $0xb90045df // str wzr, [x14, #68] + WORD $0xb900465f // str wzr, [x18, #68] + WORD $0xb900461f // str wzr, [x16, #68] + WORD $0xb900441f // str wzr, [x0, #68] + WORD $0xb900469f // str wzr, [x20, #68] + WORD $0xb900449f // str wzr, [x4, #68] + WORD $0xb90044bf // str wzr, [x5, #68] + WORD $0xb900445f // str wzr, [x2, #68] + WORD $0xb900447f // str wzr, [x3, #68] + WORD $0xb90044df // str wzr, [x6, #68] + WORD $0xb900499f // str wzr, [x12, #72] + WORD $0xb9004a3f // str wzr, [x17, #72] + WORD $0xb900497f // str wzr, [x11, #72] + WORD $0xb90049ff // str wzr, [x15, #72] + WORD $0xb900495f // str wzr, [x10, #72] + WORD $0xb90049bf // str wzr, [x13, #72] + WORD $0xb90049df // str wzr, [x14, #72] + WORD $0xb9004a5f // str wzr, [x18, #72] + WORD $0xb9004a1f // str wzr, [x16, #72] + WORD $0xb900481f // str wzr, [x0, #72] + WORD $0xb9004a9f // str wzr, [x20, #72] + WORD $0xb900489f // str wzr, [x4, #72] + WORD $0xb90048bf // str wzr, [x5, #72] + WORD $0xb900485f // str wzr, [x2, #72] + WORD $0xb900487f // str wzr, [x3, #72] + WORD $0xb90048df // str wzr, [x6, #72] + WORD $0xb9004d9f // str wzr, [x12, #76] + WORD $0xb9004e3f // str wzr, [x17, #76] + WORD $0xb9004d7f // str wzr, [x11, #76] + WORD $0xb9004dff // str wzr, [x15, #76] + WORD $0xb9004d5f // str wzr, [x10, #76] + WORD $0xb9004dbf // str wzr, [x13, #76] + WORD $0xb9004ddf // str wzr, [x14, #76] + WORD $0xb9004e5f // str wzr, [x18, #76] + WORD $0xb9004e1f // str wzr, [x16, #76] + WORD $0xb9004c1f // str wzr, [x0, #76] + WORD $0xb9004e9f // str wzr, [x20, #76] + WORD $0xb9004c9f // str wzr, [x4, #76] + WORD $0xb9004cbf // str wzr, [x5, #76] + WORD $0xb9004c5f // str wzr, [x2, #76] + WORD $0xb9004c7f // str wzr, [x3, #76] + WORD $0xb9004cdf // str wzr, [x6, #76] + WORD $0xb900519f // str wzr, [x12, #80] + WORD $0xb900523f // str wzr, [x17, #80] + WORD $0xb900517f // str wzr, [x11, #80] + WORD $0xb90051ff // str wzr, [x15, #80] + WORD $0xb900515f // str wzr, [x10, #80] + WORD $0xb90051bf // str wzr, [x13, #80] + WORD $0xb90051df // str wzr, [x14, #80] + WORD $0xb900525f // str wzr, [x18, #80] + WORD $0xb900521f // str wzr, [x16, #80] + WORD $0xb900501f // str wzr, [x0, #80] + WORD $0xb900529f // str wzr, [x20, #80] + WORD $0xb900509f // str wzr, [x4, #80] + WORD $0xb90050bf // str wzr, [x5, #80] + WORD $0xb900505f // str wzr, [x2, #80] + WORD $0xb900507f // str wzr, [x3, #80] + WORD $0xb90050df // str wzr, [x6, #80] + WORD $0xb900559f // str wzr, [x12, #84] + WORD $0xb900563f // str wzr, [x17, #84] + WORD $0xb900557f // str wzr, [x11, #84] + WORD $0xb90055ff // str wzr, [x15, #84] + WORD $0xb900555f // str wzr, [x10, #84] + WORD $0xb90055bf // str wzr, [x13, #84] + WORD $0xb90055df // str wzr, [x14, #84] + WORD $0xb900565f // str wzr, [x18, #84] + WORD $0xb900561f // str wzr, [x16, #84] + WORD $0xb900541f // str wzr, [x0, #84] + WORD $0xb900569f // str wzr, [x20, #84] + WORD $0xb900549f // str wzr, [x4, #84] + WORD $0xb90054bf // str wzr, [x5, #84] + WORD $0xb900545f // str wzr, [x2, #84] + WORD $0xb900547f // str wzr, [x3, #84] + WORD $0xb90054df // str wzr, [x6, #84] + WORD $0xb900599f // str wzr, [x12, #88] + WORD $0xb9005a3f // str wzr, [x17, #88] + WORD $0xb900597f // str wzr, [x11, #88] + WORD $0xb90059ff // str wzr, [x15, #88] + WORD $0xb900595f // str wzr, [x10, #88] + WORD $0xb90059bf // str wzr, [x13, #88] + WORD $0xb90059df // str wzr, [x14, #88] + WORD $0xb9005a5f // str wzr, [x18, #88] + WORD $0xb9005a1f // str wzr, [x16, #88] + WORD $0xb900581f // str wzr, [x0, #88] + WORD $0xb9005a9f // str wzr, [x20, #88] + WORD $0xb900589f // str wzr, [x4, #88] + WORD $0xb90058bf // str wzr, [x5, #88] + WORD $0xb900585f // str wzr, [x2, #88] + WORD $0xb900587f // str wzr, [x3, #88] + WORD $0xb90058df // str wzr, [x6, #88] + WORD $0xb9005d9f // str wzr, [x12, #92] + WORD $0xb9005e3f // str wzr, [x17, #92] + WORD $0xb9005d7f // str wzr, [x11, #92] + WORD $0xb9005dff // str wzr, [x15, #92] + WORD $0xb9005d5f // str wzr, [x10, #92] + WORD $0xb9005dbf // str wzr, [x13, #92] + WORD $0xb9005ddf // str wzr, [x14, #92] + WORD $0xb9005e5f // str wzr, [x18, #92] + WORD $0xb9005e1f // str wzr, [x16, #92] + WORD $0xb9005c1f // str wzr, [x0, #92] + WORD $0xb9005e9f // str wzr, [x20, #92] + WORD $0xb9005c9f // str wzr, [x4, #92] + WORD $0xb9005cbf // str wzr, [x5, #92] + WORD $0xb9005c5f // str wzr, [x2, #92] + WORD $0xb9005c7f // str wzr, [x3, #92] + WORD $0xb9005cdf // str wzr, [x6, #92] + WORD $0xb900619f // str wzr, [x12, #96] + WORD $0xb900623f // str wzr, [x17, #96] + WORD $0xb900617f // str wzr, [x11, #96] + WORD $0xb90061ff // str wzr, [x15, #96] + WORD $0xb900615f // str wzr, [x10, #96] + WORD $0xb90061bf // str wzr, [x13, #96] + WORD $0xb90061df // str wzr, [x14, #96] + WORD $0xb900625f // str wzr, [x18, #96] + WORD $0xb900621f // str wzr, [x16, #96] + WORD $0xb900601f // str wzr, [x0, #96] + WORD $0xb900629f // str wzr, [x20, #96] + WORD $0xb900609f // str wzr, [x4, #96] + WORD $0xb90060bf // str wzr, [x5, #96] + WORD $0xb900605f // str wzr, [x2, #96] + WORD $0xb900607f // str wzr, [x3, #96] + WORD $0xb90060df // str wzr, [x6, #96] + WORD $0xb900659f // str wzr, [x12, #100] + WORD $0xb900663f // str wzr, [x17, #100] + WORD $0xb900657f // str wzr, [x11, #100] + WORD $0xb90065ff // str wzr, [x15, #100] + WORD $0xb900655f // str wzr, [x10, #100] + WORD $0xb90065bf // str wzr, [x13, #100] + WORD $0xb90065df // str wzr, [x14, #100] + WORD $0xb900665f // str wzr, [x18, #100] + WORD $0xb900661f // str wzr, [x16, #100] + WORD $0xb900641f // str wzr, [x0, #100] + WORD $0xb900669f // str wzr, [x20, #100] + WORD $0xb900649f // str wzr, [x4, #100] + WORD $0xb90064bf // str wzr, [x5, #100] + WORD $0xb900645f // str wzr, [x2, #100] + WORD $0xb900647f // str wzr, [x3, #100] + WORD $0xb90064df // str wzr, [x6, #100] + WORD $0xb900699f // str wzr, [x12, #104] + WORD $0xb9006a3f // str wzr, [x17, #104] + WORD $0xb900697f // str wzr, [x11, #104] + WORD $0xb90069ff // str wzr, [x15, #104] + WORD $0xb900695f // str wzr, [x10, #104] + WORD $0xb90069bf // str wzr, [x13, #104] + WORD $0xb90069df // str wzr, [x14, #104] + WORD $0xb9006a5f // str wzr, [x18, #104] + WORD $0xb9006a1f // str wzr, [x16, #104] + WORD $0xb900681f // str wzr, [x0, #104] + WORD $0xb9006a9f // str wzr, [x20, #104] + WORD $0xb900689f // str wzr, [x4, #104] + WORD $0xb90068bf // str wzr, [x5, #104] + WORD $0xb900685f // str wzr, [x2, #104] + WORD $0xb900687f // str wzr, [x3, #104] + WORD $0xb90068df // str wzr, [x6, #104] + WORD $0xb9006d9f // str wzr, [x12, #108] + WORD $0xb9006e3f // str wzr, [x17, #108] + WORD $0xb9006d7f // str wzr, [x11, #108] + WORD $0xb9006dff // str wzr, [x15, #108] + WORD $0xb9006d5f // str wzr, [x10, #108] + WORD $0xb9006dbf // str wzr, [x13, #108] + WORD $0xb9006ddf // str wzr, [x14, #108] + WORD $0xb9006e5f // str wzr, [x18, #108] + WORD $0xb9006e1f // str wzr, [x16, #108] + WORD $0xb9006c1f // str wzr, [x0, #108] + WORD $0xb9006e9f // str wzr, [x20, #108] + WORD $0xb9006c9f // str wzr, [x4, #108] + WORD $0xb9006cbf // str wzr, [x5, #108] + WORD $0xb9006c5f // str wzr, [x2, #108] + WORD $0xb9006c7f // str wzr, [x3, #108] + WORD $0xb9006cdf // str wzr, [x6, #108] + WORD $0xb900719f // str wzr, [x12, #112] + WORD $0xb900723f // str wzr, [x17, #112] + WORD $0xb900717f // str wzr, [x11, #112] + WORD $0xb90071ff // str wzr, [x15, #112] + WORD $0xb900715f // str wzr, [x10, #112] + WORD $0xb90071bf // str wzr, [x13, #112] + WORD $0xb90071df // str wzr, [x14, #112] + WORD $0xb900725f // str wzr, [x18, #112] + WORD $0xb900721f // str wzr, [x16, #112] + WORD $0xb900701f // str wzr, [x0, #112] + WORD $0xb900729f // str wzr, [x20, #112] + WORD $0xb900709f // str wzr, [x4, #112] + WORD $0xb90070bf // str wzr, [x5, #112] + WORD $0xb900705f // str wzr, [x2, #112] + WORD $0xb900707f // str wzr, [x3, #112] + WORD $0xb90070df // str wzr, [x6, #112] + WORD $0xb900759f // str wzr, [x12, #116] + WORD $0xb900763f // str wzr, [x17, #116] + WORD $0xb900757f // str wzr, [x11, #116] + WORD $0xb90075ff // str wzr, [x15, #116] + WORD $0xb900755f // str wzr, [x10, #116] + WORD $0xb90075bf // str wzr, [x13, #116] + WORD $0xb90075df // str wzr, [x14, #116] + WORD $0xb900765f // str wzr, [x18, #116] + WORD $0xb900761f // str wzr, [x16, #116] + WORD $0xb900741f // str wzr, [x0, #116] + WORD $0xb900769f // str wzr, [x20, #116] + WORD $0xb900749f // str wzr, [x4, #116] + WORD $0xb90074bf // str wzr, [x5, #116] + WORD $0xb900745f // str wzr, [x2, #116] + WORD $0xb900747f // str wzr, [x3, #116] + WORD $0xb90074df // str wzr, [x6, #116] + WORD $0xb900799f // str wzr, [x12, #120] + WORD $0xb9007a3f // str wzr, [x17, #120] + WORD $0xb900797f // str wzr, [x11, #120] + WORD $0xb90079ff // str wzr, [x15, #120] + WORD $0xb900795f // str wzr, [x10, #120] + WORD $0xb90079bf // str wzr, [x13, #120] + WORD $0xb90079df // str wzr, [x14, #120] + WORD $0xb9007a5f // str wzr, [x18, #120] + WORD $0xb9007a1f // str wzr, [x16, #120] + WORD $0xb900781f // str wzr, [x0, #120] + WORD $0xb9007a9f // str wzr, [x20, #120] + WORD $0xb900789f // str wzr, [x4, #120] + WORD $0xb90078bf // str wzr, [x5, #120] + WORD $0xb900785f // str wzr, [x2, #120] + WORD $0xb900787f // str wzr, [x3, #120] + WORD $0xb90078df // str wzr, [x6, #120] + WORD $0xb9007d9f // str wzr, [x12, #124] + WORD $0xb9007e3f // str wzr, [x17, #124] + WORD $0xb9007d7f // str wzr, [x11, #124] + WORD $0xb9007dff // str wzr, [x15, #124] + WORD $0xb9007d5f // str wzr, [x10, #124] + WORD $0xb9007dbf // str wzr, [x13, #124] + WORD $0xb9007ddf // str wzr, [x14, #124] + WORD $0xb9007e5f // str wzr, [x18, #124] + WORD $0xb9007e1f // str wzr, [x16, #124] + WORD $0xb9007c1f // str wzr, [x0, #124] + WORD $0xb9007e9f // str wzr, [x20, #124] + WORD $0xb9007c9f // str wzr, [x4, #124] + WORD $0xb9007cbf // str wzr, [x5, #124] + WORD $0xb9007c5f // str wzr, [x2, #124] + WORD $0xb9007c7f // str wzr, [x3, #124] + WORD $0xb9007cdf // str wzr, [x6, #124] + BNE LBB0_152 + + // %bb.153: + WORD $0xeb13011f // cmp x8, x19 + BEQ LBB0_156 + +LBB0_154: + WORD $0x8b081f49 // add x9, x26, x8, lsl #7 + WORD $0xcb080268 // sub x8, x19, x8 + WORD $0x6f00e400 // movi v0.2d, #0000000000000000 + WORD $0x91010129 // add x9, x9, #64 + +LBB0_155: + WORD $0xad3e0120 // stp q0, q0, [x9, #-64] + WORD $0xf1000508 // subs x8, x8, #1 + WORD $0xad3f0120 // stp q0, q0, [x9, #-32] + WORD $0xad000120 // stp q0, q0, [x9] + WORD $0xad010120 // stp q0, q0, [x9, #32] + WORD $0x91020129 // add x9, x9, #128 + BNE LBB0_155 + +LBB0_157: + // WORD $0x90000008 // adrp x8, .LCPI0_0 + // WORD $0x90000009 // adrp x9, .LCPI0_1 + // WORD $0x9000000a // adrp x10, .LCPI0_2 + // WORD $0x9000000b // adrp x11, .LCPI0_3 + WORD $0xaa1f03ec // mov x12, xzr + WORD $0xf9000bf3 // str x19, [sp, #16] + VMOVQ LCPI0_0L, LCPI0_0H, V0 + // WORD $0x90000008 // adrp x8, .LCPI0_4 + VMOVQ LCPI0_1L, LCPI0_1H, V1 + // WORD $0x90000009 // adrp x9, .LCPI0_5 + VMOVQ LCPI0_2L, LCPI0_2H, V2 + // WORD $0x9000000a // adrp x10, .LCPI0_6 + VMOVQ LCPI0_4L, LCPI0_4H, V4 + // WORD $0x90000008 // adrp x8, .LCPI0_7 + VMOVQ LCPI0_3L, LCPI0_3H, V3 + WORD $0x927c6e6b // and x11, x19, #0xfffffff0 + VMOVQ LCPI0_5L, LCPI0_5H, V5 + WORD $0xf90047fa // str x26, [sp, #136] + VMOVQ LCPI0_7L, LCPI0_7H, V7 + WORD $0x52800208 // mov w8, #16 + VMOVQ LCPI0_6L, LCPI0_6H, V6 + WORD $0x8b0b1c09 // add x9, x0, x11, lsl #7 + WORD $0xf9000feb // str x11, [sp, #24] + WORD $0x4e080d10 // dup v16.2d, x8 + WORD $0xf90007e9 // str x9, [sp, #8] + +LBB0_158: + WORD $0x4f4554f2 // shl v18.2d, v7.2d, #5 + WORD $0xd379e188 // lsl x8, x12, #7 + WORD $0x4f4554d3 // shl v19.2d, v6.2d, #5 + WORD $0xb278010b // orr x11, x8, #0x100 + WORD $0x4f4554b4 // shl v20.2d, v5.2d, #5 + WORD $0xf90043ec // str x12, [sp, #128] + WORD $0x8b0b0010 // add x16, x0, x11 + WORD $0x8b080003 // add x3, x0, x8 + WORD $0x4e183e4b // mov x11, v18.d[1] + WORD $0x9e66024c // fmov x12, d18 + WORD $0x4f455492 // shl v18.2d, v4.2d, #5 + WORD $0xb279010a // orr x10, x8, #0x80 + WORD $0x4e183e6d // mov x13, v19.d[1] + WORD $0x8b0a0014 // add x20, x0, x10 + WORD $0x8b0c0b49 // add x9, x26, x12, lsl #2 + WORD $0x9e66028c // fmov x12, d20 + WORD $0x8b0b0b5b // add x27, x26, x11, lsl #2 + WORD $0xb279050a // orr x10, x8, #0x180 + WORD $0x4e183e8b // mov x11, v20.d[1] + WORD $0x9e66026e // fmov x14, d19 + WORD $0x9e66024f // fmov x15, d18 + WORD $0x8b0a0013 // add x19, x0, x10 + WORD $0xb277010a // orr x10, x8, #0x200 + WORD $0x8b0d0b57 // add x23, x26, x13, lsl #2 + WORD $0x8b0c0b5c // add x28, x26, x12, lsl #2 + WORD $0x8b0a0011 // add x17, x0, x10 + WORD $0x2940306d // ldp w13, w12, [x3] + WORD $0x5280500a // mov w10, #640 + WORD $0x8b0e0b41 // add x1, x26, x14, lsl #2 + WORD $0xaa0a010a // orr x10, x8, x10 + WORD $0xf900bbe3 // str x3, [sp, #368] + WORD $0x2940168e // ldp w14, w5, [x20] + WORD $0x8b0b0b43 // add x3, x26, x11, lsl #2 + WORD $0x8b0f0b44 // add x4, x26, x15, lsl #2 + WORD $0x29403e0b // ldp w11, w15, [x16] + WORD $0x8b0a0006 // add x6, x0, x10 + WORD $0xb90057ec // str w12, [sp, #84] + WORD $0x4e183e4c // mov x12, v18.d[1] + WORD $0xb278050a // orr x10, x8, #0x300 + WORD $0x8b0a0007 // add x7, x0, x10 + WORD $0xb900012d // str w13, [x9] + WORD $0xb900036e // str w14, [x27] + WORD $0xb279090a // orr x10, x8, #0x380 + WORD $0xb900002b // str w11, [x1] + WORD $0x29402ccd // ldp w13, w11, [x6] + WORD $0x4f455471 // shl v17.2d, v3.2d, #5 + WORD $0xa91453f0 // stp x16, x20, [sp, #320] + WORD $0x290f17ef // stp w15, w5, [sp, #120] + WORD $0x8b0c0b45 // add x5, x26, x12, lsl #2 + WORD $0x2940426c // ldp w12, w16, [x19] + WORD $0x8b0a0012 // add x18, x0, x10 + WORD $0xf9009ff3 // str x19, [sp, #312] + WORD $0xaa1103f3 // mov x19, x17 + WORD $0xa9181ff1 // stp x17, x7, [sp, #384] + WORD $0xb9400231 // ldr w17, [x17] + WORD $0xb90067eb // str w11, [sp, #100] + WORD $0xb276010a // orr x10, x8, #0x400 + WORD $0xb94000eb // ldr w11, [x7] + WORD $0x8b0a0002 // add x2, x0, x10 + WORD $0xb90077f0 // str w16, [sp, #116] + WORD $0x9e660230 // fmov x16, d17 + WORD $0xb90002ec // str w12, [x23] + WORD $0xb94004ee // ldr w14, [x7, #4] + WORD $0xb9000391 // str w17, [x28] + WORD $0x5280900a // mov w10, #1152 + WORD $0xb900006d // str w13, [x3] + WORD $0xaa0a010a // orr x10, x8, x10 + WORD $0xb900008b // str w11, [x4] + WORD $0x29402e4c // ldp w12, w11, [x18] + WORD $0x4e183e2f // mov x15, v17.d[1] + WORD $0x8b100b4d // add x13, x26, x16, lsl #2 + WORD $0xa90c27f7 // stp x23, x9, [sp, #192] + WORD $0x290bbbeb // stp w11, w14, [sp, #92] + WORD $0xb940004b // ldr w11, [x2] + WORD $0x8b0a000e // add x14, x0, x10 + WORD $0x5280a00a // mov w10, #1280 + WORD $0x4f455451 // shl v17.2d, v2.2d, #5 + WORD $0xf9004fed // str x13, [sp, #152] + WORD $0xb90000ac // str w12, [x5] + WORD $0xaa0a010a // orr x10, x8, x10 + WORD $0xb90001ab // str w11, [x13] + WORD $0xb9400669 // ldr w9, [x19, #4] + WORD $0x294035cb // ldp w11, w13, [x14] + WORD $0x8b0a0011 // add x17, x0, x10 + WORD $0x8b0f0b4c // add x12, x26, x15, lsl #2 + WORD $0x9e660230 // fmov x16, d17 + WORD $0x5280b00a // mov w10, #1408 + WORD $0xaa0a010a // orr x10, x8, x10 + WORD $0xb9006fe9 // str w9, [sp, #108] + WORD $0xaa0103e9 // mov x9, x1 + WORD $0xaa0603e1 // mov x1, x6 + WORD $0xa911cbe6 // stp x6, x18, [sp, #280] + WORD $0x8b0a0006 // add x6, x0, x10 + WORD $0xf9006fec // str x12, [sp, #216] + WORD $0xb9400452 // ldr w18, [x2, #4] + WORD $0x4e183e2f // mov x15, v17.d[1] + WORD $0xb900018b // str w11, [x12] + WORD $0x4f455431 // shl v17.2d, v1.2d, #5 + WORD $0x8b100b4c // add x12, x26, x16, lsl #2 + WORD $0x2940422a // ldp w10, w16, [x17] + WORD $0xb277050b // orr x11, x8, #0x600 + WORD $0xaa0c03fe // mov x30, x12 + WORD $0x8b0b000b // add x11, x0, x11 + WORD $0xf90073ec // str x12, [sp, #224] + WORD $0x2909cbed // stp w13, w18, [sp, #76] + WORD $0x8b0f0b4d // add x13, x26, x15, lsl #2 + WORD $0xb900018a // str w10, [x12] + WORD $0x9e66022a // fmov x10, d17 + WORD $0x294030cf // ldp w15, w12, [x6] + WORD $0xaa0e03f3 // mov x19, x14 + WORD $0xf900b3ee // str x14, [sp, #352] + WORD $0x8b0a0b4e // add x14, x26, x10, lsl #2 + WORD $0xb940016a // ldr w10, [x11] + WORD $0xb9006bec // str w12, [sp, #104] + WORD $0xaa0b03ec // mov x12, x11 + WORD $0x5280d00b // mov w11, #1664 + WORD $0xb90001af // str w15, [x13] + WORD $0xaa0d03f9 // mov x25, x13 + WORD $0xf9005fed // str x13, [sp, #184] + WORD $0xaa0b010d // orr x13, x8, x11 + WORD $0xb90073f0 // str w16, [sp, #112] + WORD $0x8b0d0012 // add x18, x0, x13 + WORD $0xb90001ca // str w10, [x14] + WORD $0x4e183e30 // mov x16, v17.d[1] + WORD $0xb278090a // orr x10, x8, #0x700 + WORD $0x4f455412 // shl v18.2d, v0.2d, #5 + WORD $0xb2790d08 // orr x8, x8, #0x780 + WORD $0xf90053e5 // str x5, [sp, #160] + WORD $0xb940058b // ldr w11, [x12, #4] + WORD $0xaa0c03f6 // mov x22, x12 + WORD $0xf9009bec // str x12, [sp, #304] + WORD $0x8b08000c // add x12, x0, x8 + WORD $0x8b0a0007 // add x7, x0, x10 + WORD $0x29401648 // ldp w8, w5, [x18] + WORD $0x8b100b4d // add x13, x26, x16, lsl #2 + WORD $0xf90077e3 // str x3, [sp, #232] + WORD $0x9e660243 // fmov x3, d18 + WORD $0xf900abe2 // str x2, [sp, #336] + WORD $0x4e183e42 // mov x2, v18.d[1] + WORD $0xb9005beb // str w11, [sp, #88] + WORD $0xf94047eb // ldr x11, [sp, #136] + WORD $0xb90001a8 // str w8, [x13] + WORD $0x294040ea // ldp w10, w16, [x7] + WORD $0xa9103be4 // stp x4, x14, [sp, #256] + WORD $0xb9400588 // ldr w8, [x12, #4] + WORD $0x8b030b4e // add x14, x26, x3, lsl #2 + WORD $0xa94c0fe4 // ldp x4, x3, [sp, #192] + WORD $0x8b02096f // add x15, x11, x2, lsl #2 + WORD $0x290843e8 // stp w8, w16, [sp, #64] + WORD $0xb940018b // ldr w11, [x12] + WORD $0xb90001ca // str w10, [x14] + WORD $0xb94057e8 // ldr w8, [sp, #84] + WORD $0xf90097f1 // str x17, [sp, #296] + WORD $0xf940a3f1 // ldr x17, [sp, #320] + WORD $0xaa1203f7 // mov x23, x18 + WORD $0xb90001eb // str w11, [x15] + WORD $0xf94077eb // ldr x11, [sp, #232] + WORD $0xb9000468 // str w8, [x3, #4] + WORD $0xb9400a88 // ldr w8, [x20, #8] + WORD $0xaa0903f4 // mov x20, x9 + WORD $0xf900b7f2 // str x18, [sp, #360] + WORD $0xa9580bf2 // ldp x18, x2, [sp, #384] + WORD $0xb90057e8 // str w8, [sp, #84] + WORD $0xaa0d03f8 // mov x24, x13 + WORD $0xb9407fe8 // ldr w8, [sp, #124] + WORD $0xf900bfec // str x12, [sp, #376] + WORD $0xa95243ed // ldp x13, x16, [sp, #288] + WORD $0xaa0f03fa // mov x26, x15 + WORD $0xf9006bef // str x15, [sp, #208] + WORD $0xb9000768 // str w8, [x27, #4] + WORD $0xb9400a28 // ldr w8, [x17, #8] + WORD $0xb9400a4a // ldr w10, [x18, #8] + WORD $0xa90f3bfb // stp x27, x14, [sp, #240] + WORD $0xaa0703f5 // mov x21, x7 + WORD $0xb9004be8 // str w8, [sp, #72] + WORD $0xb9407be8 // ldr w8, [sp, #120] + WORD $0xf940abee // ldr x14, [sp, #336] + WORD $0xa90ae3f4 // stp x20, x24, [sp, #168] + WORD $0xa9501fec // ldp x12, x7, [sp, #256] + WORD $0xf900aff5 // str x21, [sp, #344] + WORD $0xb9000528 // str w8, [x9, #4] + WORD $0xf9409fe8 // ldr x8, [sp, #312] + WORD $0xf9004bfc // str x28, [sp, #144] + WORD $0xb9400909 // ldr w9, [x8, #8] + WORD $0x4ef084a5 // add v5.2d, v5.2d, v16.2d + WORD $0x4ef084c6 // add v6.2d, v6.2d, v16.2d + WORD $0xb90033e9 // str w9, [sp, #48] + WORD $0xb94077e9 // ldr w9, [sp, #116] + WORD $0x4ef084e7 // add v7.2d, v7.2d, v16.2d + WORD $0x4ef08484 // add v4.2d, v4.2d, v16.2d + WORD $0xb9000489 // str w9, [x4, #4] + WORD $0xb9406fe9 // ldr w9, [sp, #108] + WORD $0x4ef08463 // add v3.2d, v3.2d, v16.2d + WORD $0x4ef08442 // add v2.2d, v2.2d, v16.2d + WORD $0xb9000789 // str w9, [x28, #4] + WORD $0xb9400829 // ldr w9, [x1, #8] + WORD $0xf9406fe1 // ldr x1, [sp, #216] + WORD $0x4ef08421 // add v1.2d, v1.2d, v16.2d + WORD $0x29072be9 // stp w9, w10, [sp, #56] + WORD $0xb94067e9 // ldr w9, [sp, #100] + WORD $0xa949abef // ldp x15, x10, [sp, #152] + WORD $0x4ef08400 // add v0.2d, v0.2d, v16.2d + WORD $0xb9000569 // str w9, [x11, #4] + WORD $0xb9400849 // ldr w9, [x2, #8] + WORD $0xb9007be9 // str w9, [sp, #120] + WORD $0xb94063e9 // ldr w9, [sp, #96] + WORD $0xb9000589 // str w9, [x12, #4] + WORD $0xb94009a9 // ldr w9, [x13, #8] + WORD $0xb90037e9 // str w9, [sp, #52] + WORD $0xb9405fe9 // ldr w9, [sp, #92] + WORD $0xb9000549 // str w9, [x10, #4] + WORD $0xb94009c9 // ldr w9, [x14, #8] + WORD $0xb9005fe9 // str w9, [sp, #92] + WORD $0xb94053e9 // ldr w9, [sp, #80] + WORD $0xb90005e9 // str w9, [x15, #4] + WORD $0xb9400a69 // ldr w9, [x19, #8] + WORD $0xb94047f3 // ldr w19, [sp, #68] + WORD $0xb90067e9 // str w9, [sp, #100] + WORD $0xb9404fe9 // ldr w9, [sp, #76] + WORD $0xb9000429 // str w9, [x1, #4] + WORD $0xb9400a09 // ldr w9, [x16, #8] + WORD $0xb90077e9 // str w9, [sp, #116] + WORD $0xb94073e9 // ldr w9, [sp, #112] + WORD $0xb90007c9 // str w9, [x30, #4] + WORD $0xb9406be9 // ldr w9, [sp, #104] + WORD $0xb94008de // ldr w30, [x6, #8] + WORD $0xb9000729 // str w9, [x25, #4] + WORD $0xb9400ac9 // ldr w9, [x22, #8] + WORD $0xaa1803f6 // mov x22, x24 + WORD $0xb9007fe9 // str w9, [sp, #124] + WORD $0xb9405be9 // ldr w9, [sp, #88] + WORD $0xb90004e9 // str w9, [x7, #4] + WORD $0xb9400ae9 // ldr w9, [x23, #8] + WORD $0xf9407ff7 // ldr x23, [sp, #248] + WORD $0xb9000705 // str w5, [x24, #4] + WORD $0xaa1503f8 // mov x24, x21 + WORD $0xb9006be9 // str w9, [sp, #104] + WORD $0xf940bbe9 // ldr x9, [sp, #368] + WORD $0xb90006f3 // str w19, [x23, #4] + WORD $0xb9400ab3 // ldr w19, [x21, #8] + WORD $0xf9408ff5 // ldr x21, [sp, #280] + WORD $0x29416525 // ldp w5, w25, [x9, #8] + WORD $0xb90073f3 // str w19, [sp, #112] + WORD $0xb94043f3 // ldr w19, [sp, #64] + WORD $0xb9000753 // str w19, [x26, #4] + WORD $0xaa0f03f3 // mov x19, x15 + WORD $0xb9000865 // str w5, [x3, #8] + WORD $0xf940a7e3 // ldr x3, [sp, #328] + WORD $0xaa0403fa // mov x26, x4 + WORD $0xb9400c69 // ldr w9, [x3, #12] + WORD $0xaa0603e3 // mov x3, x6 + WORD $0xb9006fe9 // str w9, [sp, #108] + WORD $0xb94057e9 // ldr w9, [sp, #84] + WORD $0xb9000b69 // str w9, [x27, #8] + WORD $0xb9404be9 // ldr w9, [sp, #72] + WORD $0xb9400e3b // ldr w27, [x17, #12] + WORD $0xaa0703f1 // mov x17, x7 + WORD $0xb9000a89 // str w9, [x20, #8] + WORD $0xb9400d09 // ldr w9, [x8, #12] + WORD $0xb94033e8 // ldr w8, [sp, #48] + WORD $0xb9000888 // str w8, [x4, #8] + WORD $0xb9400e48 // ldr w8, [x18, #12] + WORD $0xaa0103e4 // mov x4, x1 + WORD $0x2908a7e8 // stp w8, w9, [sp, #68] + WORD $0xb9403fe8 // ldr w8, [sp, #60] + WORD $0xaa0a03e9 // mov x9, x10 + WORD $0xb9000b88 // str w8, [x28, #8] + WORD $0xb9400ea8 // ldr w8, [x21, #12] + WORD $0xb90063e8 // str w8, [sp, #96] + WORD $0xb9403be8 // ldr w8, [sp, #56] + WORD $0xb9000968 // str w8, [x11, #8] + WORD $0xb9407be8 // ldr w8, [sp, #120] + WORD $0xb9400c4b // ldr w11, [x2, #12] + WORD $0xaa1003e2 // mov x2, x16 + WORD $0xb9000988 // str w8, [x12, #8] + WORD $0xb9400da8 // ldr w8, [x13, #12] + WORD $0xf94073ec // ldr x12, [sp, #224] + WORD $0xb9407fed // ldr w13, [sp, #124] + WORD $0xb9007be8 // str w8, [sp, #120] + WORD $0xb94037e8 // ldr w8, [sp, #52] + WORD $0xb9000948 // str w8, [x10, #8] + WORD $0xb9400dc8 // ldr w8, [x14, #12] + WORD $0xf940b3ea // ldr x10, [sp, #352] + WORD $0x290623eb // stp w11, w8, [sp, #48] + WORD $0xb9405fe8 // ldr w8, [sp, #92] + WORD $0xb9400e0b // ldr w11, [x16, #12] + WORD $0xb90009e8 // str w8, [x15, #8] + WORD $0xb9400d48 // ldr w8, [x10, #12] + WORD $0xb9002fe8 // str w8, [sp, #44] + WORD $0xb94067e8 // ldr w8, [sp, #100] + WORD $0xb9000828 // str w8, [x1, #8] + WORD $0xb94077e8 // ldr w8, [sp, #116] + WORD $0xaa1703e1 // mov x1, x23 + WORD $0xb9000988 // str w8, [x12, #8] + WORD $0xb9400cc8 // ldr w8, [x6, #12] + WORD $0x290aafe8 // stp w8, w11, [sp, #84] + WORD $0xf9405feb // ldr x11, [sp, #184] + WORD $0xf9409be8 // ldr x8, [sp, #304] + WORD $0xb900097e // str w30, [x11, #8] + WORD $0xf940b7fe // ldr x30, [sp, #360] + WORD $0xb9400d0f // ldr w15, [x8, #12] + WORD $0xb90008ed // str w13, [x7, #8] + WORD $0xf940bfed // ldr x13, [sp, #376] + WORD $0xb9400fce // ldr w14, [x30, #12] + WORD $0xf940a7e7 // ldr x7, [sp, #328] + WORD $0xb94009a5 // ldr w5, [x13, #8] + WORD $0x2909bfee // stp w14, w15, [sp, #76] + WORD $0xb9406bee // ldr w14, [sp, #104] + WORD $0xb94010ef // ldr w15, [x7, #16] + WORD $0xb9000ace // str w14, [x22, #8] + WORD $0xb9400f0e // ldr w14, [x24, #12] + WORD $0xa94ec3f6 // ldp x22, x16, [sp, #232] + WORD $0xb9006bee // str w14, [sp, #104] + WORD $0xb9400db8 // ldr w24, [x13, #12] + WORD $0x294dbbed // ldp w13, w14, [sp, #108] + WORD $0xb9000aee // str w14, [x23, #8] + WORD $0xa94cdff2 // ldp x18, x23, [sp, #200] + WORD $0xb9000ae5 // str w5, [x23, #8] + WORD $0xb9000e59 // str w25, [x18, #12] + WORD $0xb9000e0d // str w13, [x16, #12] + WORD $0xa953b7e5 // ldp x5, x13, [sp, #312] + WORD $0xb9000e9b // str w27, [x20, #12] + WORD $0xf940c3fb // ldr x27, [sp, #384] + WORD $0xb94011ae // ldr w14, [x13, #16] + WORD $0x29073fee // stp w14, w15, [sp, #56] + WORD $0xb94010ae // ldr w14, [x5, #16] + WORD $0xb94012af // ldr w15, [x21, #16] + WORD $0xb90067ee // str w14, [sp, #100] + WORD $0xb9404bee // ldr w14, [sp, #72] + WORD $0xb90043ef // str w15, [sp, #64] + WORD $0xb94063ef // ldr w15, [sp, #96] + WORD $0xb9000f4e // str w14, [x26, #12] + WORD $0xb940136e // ldr w14, [x27, #16] + WORD $0xb9005fee // str w14, [sp, #92] + WORD $0xb94047ee // ldr w14, [sp, #68] + WORD $0xb9000f8e // str w14, [x28, #12] + WORD $0xaa1503ee // mov x14, x21 + WORD $0xb9000ecf // str w15, [x22, #12] + WORD $0xf940c7ef // ldr x15, [sp, #392] + WORD $0xf94083f5 // ldr x21, [sp, #256] + WORD $0xb94011e6 // ldr w6, [x15, #16] + WORD $0xb9006fe6 // str w6, [sp, #108] + WORD $0xb94033e6 // ldr w6, [sp, #48] + WORD $0xb9000ea6 // str w6, [x21, #12] + WORD $0xf94093e6 // ldr x6, [sp, #288] + WORD $0xb94010d9 // ldr w25, [x6, #16] + WORD $0xb90047f9 // str w25, [sp, #68] + WORD $0xb9407bf9 // ldr w25, [sp, #120] + WORD $0xb9000d39 // str w25, [x9, #12] + WORD $0xf940abf9 // ldr x25, [sp, #336] + WORD $0xb9401329 // ldr w9, [x25, #16] + WORD $0xb90077e9 // str w9, [sp, #116] + WORD $0xb94037e9 // ldr w9, [sp, #52] + WORD $0xb9000e69 // str w9, [x19, #12] + WORD $0xb9401149 // ldr w9, [x10, #16] + WORD $0xf940bbea // ldr x10, [sp, #368] + WORD $0xaa1603f3 // mov x19, x22 + WORD $0xb90063e9 // str w9, [sp, #96] + WORD $0xb9402fe9 // ldr w9, [sp, #44] + WORD $0xb9000c89 // str w9, [x4, #12] + WORD $0xb9401049 // ldr w9, [x2, #16] + WORD $0xb9401544 // ldr w4, [x10, #20] + WORD $0xaa1403e2 // mov x2, x20 + WORD $0xb9004be9 // str w9, [sp, #72] + WORD $0xb9405be9 // ldr w9, [sp, #88] + WORD $0xb9000d89 // str w9, [x12, #12] + WORD $0xb9401069 // ldr w9, [x3, #16] + WORD $0xaa0303ec // mov x12, x3 + WORD $0xaa0b03e3 // mov x3, x11 + WORD $0xb90073e9 // str w9, [sp, #112] + WORD $0xb94057e9 // ldr w9, [sp, #84] + WORD $0xf9008bec // str x12, [sp, #272] + WORD $0xb9000d69 // str w9, [x11, #12] + WORD $0xb9401109 // ldr w9, [x8, #16] + WORD $0xb94053e8 // ldr w8, [sp, #80] + WORD $0xb9406beb // ldr w11, [sp, #104] + WORD $0xb9000e28 // str w8, [x17, #12] + WORD $0xb94013c8 // ldr w8, [x30, #16] + WORD $0xf94087fe // ldr x30, [sp, #264] + WORD $0x290f23e9 // stp w9, w8, [sp, #120] + WORD $0xf9405be9 // ldr x9, [sp, #176] + WORD $0xb9404fe8 // ldr w8, [sp, #76] + WORD $0xb9000d28 // str w8, [x9, #12] + WORD $0xb9401148 // ldr w8, [x10, #16] + WORD $0xb9000c2b // str w11, [x1, #12] + WORD $0xb94015aa // ldr w10, [x13, #20] + WORD $0xb9000ef8 // str w24, [x23, #12] + WORD $0xb940172d // ldr w13, [x25, #20] + WORD $0xb9001248 // str w8, [x18, #16] + WORD $0xb94014e8 // ldr w8, [x7, #20] + WORD $0xa9559fe1 // ldp x1, x7, [sp, #344] + WORD $0xaa0503eb // mov x11, x5 + WORD $0xb9006be8 // str w8, [sp, #104] + WORD $0xb9403fe8 // ldr w8, [sp, #60] + WORD $0xb9401031 // ldr w17, [x1, #16] + WORD $0xb9001208 // str w8, [x16, #16] + WORD $0xb9403be8 // ldr w8, [sp, #56] + WORD $0xb94014d0 // ldr w16, [x6, #20] + WORD $0xb9001288 // str w8, [x20, #16] + WORD $0xb94014a8 // ldr w8, [x5, #20] + WORD $0x2909c3ed // stp w13, w16, [sp, #76] + WORD $0xb94077ed // ldr w13, [sp, #116] + WORD $0xaa0f03e5 // mov x5, x15 + WORD $0xf940bff0 // ldr x16, [sp, #376] + WORD $0x29062be8 // stp w8, w10, [sp, #48] + WORD $0xb94067e8 // ldr w8, [sp, #100] + WORD $0xb94015ca // ldr w10, [x14, #20] + WORD $0xb9001348 // str w8, [x26, #16] + WORD $0xb9401768 // ldr w8, [x27, #20] + WORD $0xaa0903fb // mov x27, x9 + WORD $0xb9407fe9 // ldr w9, [sp, #124] + WORD $0xb9002fe8 // str w8, [sp, #44] + WORD $0xb9405fe8 // ldr w8, [sp, #92] + WORD $0xb9001388 // str w8, [x28, #16] + WORD $0xb94043e8 // ldr w8, [sp, #64] + WORD $0xaa0e03fc // mov x28, x14 + WORD $0xa94dbbf8 // ldp x24, x14, [sp, #216] + WORD $0xb90012c8 // str w8, [x22, #16] + WORD $0xb94015e8 // ldr w8, [x15, #20] + WORD $0xa949dff6 // ldp x22, x23, [sp, #152] + WORD $0x290aabe8 // stp w8, w10, [sp, #84] + WORD $0xb9406fe8 // ldr w8, [sp, #108] + WORD $0xb94047ea // ldr w10, [sp, #68] + WORD $0xa952bff4 // ldp x20, x15, [sp, #296] + WORD $0xb90012a8 // str w8, [x21, #16] + WORD $0xaa0603e8 // mov x8, x6 + WORD $0xb90012ea // str w10, [x23, #16] + WORD $0xaa1903ea // mov x10, x25 + WORD $0xb90012cd // str w13, [x22, #16] + WORD $0xb94014ed // ldr w13, [x7, #20] + WORD $0xa94f67fa // ldp x26, x25, [sp, #240] + WORD $0xb90077ed // str w13, [sp, #116] + WORD $0xb94063ed // ldr w13, [sp, #96] + WORD $0xb900130d // str w13, [x24, #16] + WORD $0xb940168d // ldr w13, [x20, #20] + WORD $0xb9003fed // str w13, [sp, #60] + WORD $0xb9404bed // ldr w13, [sp, #72] + WORD $0xb90011cd // str w13, [x14, #16] + WORD $0xb940158d // ldr w13, [x12, #20] + WORD $0xb90067ed // str w13, [sp, #100] + WORD $0xb94073ed // ldr w13, [sp, #112] + WORD $0xb900106d // str w13, [x3, #16] + WORD $0xb94015ed // ldr w13, [x15, #20] + WORD $0xb9401203 // ldr w3, [x16, #16] + WORD $0xb9004bed // str w13, [sp, #72] + WORD $0xb9407bed // ldr w13, [sp, #120] + WORD $0xb90013cd // str w13, [x30, #16] + WORD $0xf940b7ed // ldr x13, [sp, #360] + WORD $0xb9001369 // str w9, [x27, #16] + WORD $0xb9401429 // ldr w9, [x1, #20] + WORD $0xb9001331 // str w17, [x25, #16] + WORD $0xaa1403e1 // mov x1, x20 + WORD $0xb94015a6 // ldr w6, [x13, #20] + WORD $0xb9007fe9 // str w9, [sp, #124] + WORD $0xb9003be6 // str w6, [sp, #56] + WORD $0xb9401606 // ldr w6, [x16, #20] + WORD $0xf9406bf0 // ldr x16, [sp, #208] + WORD $0xb9001203 // str w3, [x16, #16] + WORD $0xa95447e3 // ldp x3, x17, [sp, #320] + WORD $0xb9001644 // str w4, [x18, #20] + WORD $0xaa0d03e4 // mov x4, x13 + WORD $0xb9401a29 // ldr w9, [x17, #24] + WORD $0xb90073e9 // str w9, [sp, #112] + WORD $0xb9406be9 // ldr w9, [sp, #104] + WORD $0xb9001749 // str w9, [x26, #20] + WORD $0xb9401869 // ldr w9, [x3, #24] + WORD $0xb9005fe9 // str w9, [sp, #92] + WORD $0xb94037e9 // ldr w9, [sp, #52] + WORD $0xb9001449 // str w9, [x2, #20] + WORD $0xb9401969 // ldr w9, [x11, #24] + WORD $0xf94063e2 // ldr x2, [sp, #192] + WORD $0xf940c3eb // ldr x11, [sp, #384] + WORD $0xb9006fe9 // str w9, [sp, #108] + WORD $0xb94033e9 // ldr w9, [sp, #48] + WORD $0xb9001449 // str w9, [x2, #20] + WORD $0xb9401969 // ldr w9, [x11, #24] + WORD $0xf9404beb // ldr x11, [sp, #144] + WORD $0xb9006be9 // str w9, [sp, #104] + WORD $0xb9402fe9 // ldr w9, [sp, #44] + WORD $0xb9001569 // str w9, [x11, #20] + WORD $0xb9401b89 // ldr w9, [x28, #24] + WORD $0xf940bbfc // ldr x28, [sp, #368] + WORD $0xb90063e9 // str w9, [sp, #96] + WORD $0xb9405be9 // ldr w9, [sp, #88] + WORD $0xb9001669 // str w9, [x19, #20] + WORD $0xb94018a9 // ldr w9, [x5, #24] + WORD $0xaa1803e5 // mov x5, x24 + WORD $0xaa1603f3 // mov x19, x22 + WORD $0xb9005be9 // str w9, [sp, #88] + WORD $0xb94057e9 // ldr w9, [sp, #84] + WORD $0xb90016a9 // str w9, [x21, #20] + WORD $0xb9401909 // ldr w9, [x8, #24] + WORD $0xb94053e8 // ldr w8, [sp, #80] + WORD $0xaa1203f5 // mov x21, x18 + WORD $0xb90016e8 // str w8, [x23, #20] + WORD $0xb9401948 // ldr w8, [x10, #24] + WORD $0xb940198a // ldr w10, [x12, #24] + WORD $0xf940afec // ldr x12, [sp, #344] + WORD $0x290a27e8 // stp w8, w9, [sp, #80] + WORD $0xb9404fe8 // ldr w8, [sp, #76] + WORD $0xb94018e9 // ldr w9, [x7, #24] + WORD $0xb90016c8 // str w8, [x22, #20] + WORD $0xb94077e8 // ldr w8, [sp, #116] + WORD $0xb9001708 // str w8, [x24, #20] + WORD $0xb9401a88 // ldr w8, [x20, #24] + WORD $0xa9585ff8 // ldp x24, x23, [sp, #384] + WORD $0xaa0203f4 // mov x20, x2 + WORD $0x290827e8 // stp w8, w9, [sp, #64] + WORD $0xb9403fe8 // ldr w8, [sp, #60] + WORD $0xb94067e9 // ldr w9, [sp, #100] + WORD $0xb90015c8 // str w8, [x14, #20] + WORD $0xf9405fe8 // ldr x8, [sp, #184] + WORD $0xb9405bee // ldr w14, [sp, #88] + WORD $0xb9001509 // str w9, [x8, #20] + WORD $0xb94019e9 // ldr w9, [x15, #24] + WORD $0xf9409fef // ldr x15, [sp, #312] + WORD $0x290ea7ea // stp w10, w9, [sp, #116] + WORD $0xb9404be9 // ldr w9, [sp, #72] + WORD $0xb9401b8a // ldr w10, [x28, #24] + WORD $0xb90017c9 // str w9, [x30, #20] + WORD $0xb94019a9 // ldr w9, [x13, #24] + WORD $0xf94053fe // ldr x30, [sp, #160] + WORD $0xb9004fe9 // str w9, [sp, #76] + WORD $0xb9403be9 // ldr w9, [sp, #56] + WORD $0xb9001769 // str w9, [x27, #20] + WORD $0xb9407fe9 // ldr w9, [sp, #124] + WORD $0xaa0803fb // mov x27, x8 + WORD $0xb9001729 // str w9, [x25, #20] + WORD $0xb9401989 // ldr w9, [x12, #24] + WORD $0xb9001606 // str w6, [x16, #20] + WORD $0xb9401df0 // ldr w16, [x15, #28] + WORD $0xb9001a4a // str w10, [x18, #24] + WORD $0xb9401e2a // ldr w10, [x17, #28] + WORD $0xaa1a03f2 // mov x18, x26 + WORD $0xb9007fe9 // str w9, [sp, #124] + WORD $0xb9401f86 // ldr w6, [x28, #28] + WORD $0xaa1c03e9 // mov x9, x28 + WORD $0xb90067ea // str w10, [sp, #100] + WORD $0xb94073ea // ldr w10, [sp, #112] + WORD $0xaa1103fc // mov x28, x17 + WORD $0xa94e37f9 // ldp x25, x13, [sp, #224] + WORD $0xa951c7f6 // ldp x22, x17, [sp, #280] + WORD $0xb9001b4a // str w10, [x26, #24] + WORD $0xaa0303fa // mov x26, x3 + WORD $0xb9401c6a // ldr w10, [x3, #28] + WORD $0xf94057e3 // ldr x3, [sp, #168] + WORD $0xb9401d8c // ldr w12, [x12, #28] + WORD $0xb9004bea // str w10, [sp, #72] + WORD $0xb9405fea // ldr w10, [sp, #92] + WORD $0xb900186a // str w10, [x3, #24] + WORD $0xb9406fea // ldr w10, [sp, #108] + WORD $0xb900184a // str w10, [x2, #24] + WORD $0xb9401f0a // ldr w10, [x24, #28] + WORD $0xaa0703e2 // mov x2, x7 + WORD $0x2906c3ea // stp w10, w16, [sp, #52] + WORD $0xaa0b03ea // mov x10, x11 + WORD $0xb9406beb // ldr w11, [sp, #104] + WORD $0xb9401ef0 // ldr w16, [x23, #28] + WORD $0xb900194b // str w11, [x10, #24] + WORD $0xb9401ec8 // ldr w8, [x22, #28] + WORD $0xb94063eb // ldr w11, [sp, #96] + WORD $0xb90019ab // str w11, [x13, #24] + WORD $0xf94083eb // ldr x11, [sp, #256] + WORD $0xb900196e // str w14, [x11, #24] + WORD $0xb9401e2e // ldr w14, [x17, #28] + WORD $0x2905bbf0 // stp w16, w14, [sp, #44] + WORD $0xb94057ee // ldr w14, [sp, #84] + WORD $0xb90057ec // str w12, [sp, #84] + WORD $0xf9407fec // ldr x12, [sp, #248] + WORD $0xb9001bce // str w14, [x30, #24] + WORD $0xf940abee // ldr x14, [sp, #336] + WORD $0xb9401dd0 // ldr w16, [x14, #28] + WORD $0xb9003ff0 // str w16, [sp, #60] + WORD $0xb94053f0 // ldr w16, [sp, #80] + WORD $0xb9001a70 // str w16, [x19, #24] + WORD $0xb9401cf0 // ldr w16, [x7, #28] + WORD $0xf9409be7 // ldr x7, [sp, #304] + WORD $0x290b23f0 // stp w16, w8, [sp, #88] + WORD $0xb94047f0 // ldr w16, [sp, #68] + WORD $0xb90018b0 // str w16, [x5, #24] + WORD $0xb9401c30 // ldr w16, [x1, #28] + WORD $0xf9408be5 // ldr x5, [sp, #272] + WORD $0xb90063f0 // str w16, [sp, #96] + WORD $0xb94043f0 // ldr w16, [sp, #64] + WORD $0xb9001b30 // str w16, [x25, #24] + WORD $0xb9401cb0 // ldr w16, [x5, #28] + WORD $0xb90053f0 // str w16, [sp, #80] + WORD $0x294ec3e8 // ldp w8, w16, [sp, #116] + WORD $0xb9001b68 // str w8, [x27, #24] + WORD $0xb9401ce8 // ldr w8, [x7, #28] + WORD $0xb90077e8 // str w8, [sp, #116] + WORD $0xf94087e8 // ldr x8, [sp, #264] + WORD $0xb9001910 // str w16, [x8, #24] + WORD $0xb9401c90 // ldr w16, [x4, #28] + WORD $0xf940bfe8 // ldr x8, [sp, #376] + WORD $0xb9404fe4 // ldr w4, [sp, #76] + WORD $0xb9006bf0 // str w16, [sp, #104] + WORD $0xf9405bf0 // ldr x16, [sp, #176] + WORD $0x29432101 // ldp w1, w8, [x8, #24] + WORD $0xb9001a04 // str w4, [x16, #24] + WORD $0xb9407fe4 // ldr w4, [sp, #124] + WORD $0xb90073e8 // str w8, [sp, #112] + WORD $0xf9406be8 // ldr x8, [sp, #208] + WORD $0xb9001984 // str w4, [x12, #24] + WORD $0xb94067e4 // ldr w4, [sp, #100] + WORD $0xb9001901 // str w1, [x8, #24] + WORD $0xb9402381 // ldr w1, [x28, #32] + WORD $0xb9001ea6 // str w6, [x21, #28] + WORD $0xaa0703f5 // mov x21, x7 + WORD $0xb9001e44 // str w4, [x18, #28] + WORD $0xb9402352 // ldr w18, [x26, #32] + WORD $0xf94097fa // ldr x26, [sp, #296] + WORD $0xb9006fe1 // str w1, [sp, #108] + WORD $0xaa1c03e1 // mov x1, x28 + WORD $0xb9402126 // ldr w6, [x9, #32] + WORD $0xb9007ff2 // str w18, [sp, #124] + WORD $0xb9404bf2 // ldr w18, [sp, #72] + WORD $0xf940affc // ldr x28, [sp, #344] + WORD $0xb9001c72 // str w18, [x3, #28] + WORD $0xb94021f2 // ldr w18, [x15, #32] + WORD $0xb9402384 // ldr w4, [x28, #32] + WORD $0xb90067f2 // str w18, [sp, #100] + WORD $0xaa0f03f2 // mov x18, x15 + WORD $0x2946bfe3 // ldp w3, w15, [sp, #52] + WORD $0xb9001e8f // str w15, [x20, #28] + WORD $0xf94057f4 // ldr x20, [sp, #168] + WORD $0xb9001d43 // str w3, [x10, #28] + WORD $0xaa0a03e3 // mov x3, x10 + WORD $0xb94022ca // ldr w10, [x22, #32] + WORD $0xb940230f // ldr w15, [x24, #32] + WORD $0x29093fea // stp w10, w15, [sp, #72] + WORD $0xb9405fea // ldr w10, [sp, #92] + WORD $0xaa1803ef // mov x15, x24 + WORD $0xaa0203f8 // mov x24, x2 + WORD $0xb9001daa // str w10, [x13, #28] + WORD $0xb94022ea // ldr w10, [x23, #32] + WORD $0xf9406ff7 // ldr x23, [sp, #216] + WORD $0xb9003bea // str w10, [sp, #56] + WORD $0x2945b7ea // ldp w10, w13, [sp, #44] + WORD $0xb9001d6a // str w10, [x11, #28] + WORD $0xb940222a // ldr w10, [x17, #32] + WORD $0xb9001fcd // str w13, [x30, #28] + WORD $0xb94021cd // ldr w13, [x14, #32] + WORD $0xb940204e // ldr w14, [x2, #32] + WORD $0xaa1103eb // mov x11, x17 + WORD $0xb90037ea // str w10, [sp, #52] + WORD $0xaa1e03ea // mov x10, x30 + WORD $0xb9005fed // str w13, [sp, #92] + WORD $0xb9403fed // ldr w13, [sp, #60] + WORD $0xaa1b03f1 // mov x17, x27 + WORD $0xf94087fe // ldr x30, [sp, #264] + WORD $0xaa1903e2 // mov x2, x25 + WORD $0xb940256b // ldr w11, [x11, #36] + WORD $0xb9001e6d // str w13, [x19, #28] + WORD $0xb9405bed // ldr w13, [sp, #88] + WORD $0xb9001eed // str w13, [x23, #28] + WORD $0xb940234d // ldr w13, [x26, #32] + WORD $0xb9005bed // str w13, [sp, #88] + WORD $0xb94063ed // ldr w13, [sp, #96] + WORD $0xb9001f2d // str w13, [x25, #28] + WORD $0xb94020ad // ldr w13, [x5, #32] + WORD $0xaa0503f9 // mov x25, x5 + WORD $0x29083bed // stp w13, w14, [sp, #64] + WORD $0xb94020ee // ldr w14, [x7, #32] + WORD $0xaa0903e7 // mov x7, x9 + WORD $0x294a27ed // ldp w13, w9, [sp, #80] + WORD $0xb9001f6d // str w13, [x27, #28] + WORD $0xb94077ed // ldr w13, [sp, #116] + WORD $0xf940b7fb // ldr x27, [sp, #360] + WORD $0xb94024e5 // ldr w5, [x7, #36] + WORD $0xb9001fcd // str w13, [x30, #28] + WORD $0xb940236d // ldr w13, [x27, #32] + WORD $0x290ebbed // stp w13, w14, [sp, #116] + WORD $0xb9406bed // ldr w13, [sp, #104] + WORD $0xb9006beb // str w11, [sp, #104] + WORD $0xb94037eb // ldr w11, [sp, #52] + WORD $0xb9001e0d // str w13, [x16, #28] + WORD $0xf94083f0 // ldr x16, [sp, #256] + WORD $0xb9001d89 // str w9, [x12, #28] + WORD $0xb940242c // ldr w12, [x1, #36] + WORD $0x294da7ed // ldp w13, w9, [sp, #108] + WORD $0xb90073ec // str w12, [sp, #112] + WORD $0xa94eb3e1 // ldp x1, x12, [sp, #232] + WORD $0xb9001d09 // str w9, [x8, #28] + WORD $0xaa0703e9 // mov x9, x7 + WORD $0xf94067e8 // ldr x8, [sp, #200] + WORD $0xaa0f03e7 // mov x7, x15 + WORD $0xb9002106 // str w6, [x8, #32] + WORD $0xf94063e6 // ldr x6, [sp, #192] + WORD $0xb900218d // str w13, [x12, #32] + WORD $0xf940a3ed // ldr x13, [sp, #320] + WORD $0xb94025ae // ldr w14, [x13, #36] + WORD $0xb90053ee // str w14, [sp, #80] + WORD $0xb9407fee // ldr w14, [sp, #124] + WORD $0xb900228e // str w14, [x20, #32] + WORD $0xb940264e // ldr w14, [x18, #36] + WORD $0xaa0a03f2 // mov x18, x10 + WORD $0xb90063ee // str w14, [sp, #96] + WORD $0xb94067ee // ldr w14, [sp, #100] + WORD $0xb90020ce // str w14, [x6, #32] + WORD $0xb94025ee // ldr w14, [x15, #36] + WORD $0xb9006fee // str w14, [sp, #108] + WORD $0xb9404fee // ldr w14, [sp, #76] + WORD $0xb900206e // str w14, [x3, #32] + WORD $0xb94026ce // ldr w14, [x22, #36] + WORD $0xb9007fee // str w14, [sp, #124] + WORD $0xb9404bee // ldr w14, [sp, #72] + WORD $0xb900202e // str w14, [x1, #32] + WORD $0xf940c7ee // ldr x14, [sp, #392] + WORD $0xb94025cf // ldr w15, [x14, #36] + WORD $0xb9003fef // str w15, [sp, #60] + WORD $0xb9403bef // ldr w15, [sp, #56] + WORD $0xb900220f // str w15, [x16, #32] + WORD $0xaa0203ef // mov x15, x2 + WORD $0xb900214b // str w11, [x10, #32] + WORD $0xf940abea // ldr x10, [sp, #336] + WORD $0xb940254b // ldr w11, [x10, #36] + WORD $0xb9004feb // str w11, [sp, #76] + WORD $0xb9405feb // ldr w11, [sp, #92] + WORD $0xb900226b // str w11, [x19, #32] + WORD $0xb940270b // ldr w11, [x24, #36] + WORD $0xaa1503f3 // mov x19, x21 + WORD $0xaa1e03f8 // mov x24, x30 + WORD $0xb9004beb // str w11, [sp, #72] + WORD $0xb94047eb // ldr w11, [sp, #68] + WORD $0xb90022eb // str w11, [x23, #32] + WORD $0xb940274b // ldr w11, [x26, #36] + WORD $0xf9405bfa // ldr x26, [sp, #176] + WORD $0xb90067eb // str w11, [sp, #100] + WORD $0xb9405beb // ldr w11, [sp, #88] + WORD $0xb900204b // str w11, [x2, #32] + WORD $0xb940272b // ldr w11, [x25, #36] + WORD $0xb9402762 // ldr w2, [x27, #36] + WORD $0xb9005feb // str w11, [sp, #92] + WORD $0xaa1103eb // mov x11, x17 + WORD $0xb94043f1 // ldr w17, [sp, #64] + WORD $0xb9002171 // str w17, [x11, #32] + WORD $0xb94026b1 // ldr w17, [x21, #36] + WORD $0xf940bff5 // ldr x21, [sp, #376] + WORD $0xb9005bf1 // str w17, [sp, #88] + WORD $0x294ec7f9 // ldp w25, w17, [sp, #116] + WORD $0xb9007be2 // str w2, [sp, #120] + WORD $0xaa1b03e2 // mov x2, x27 + WORD $0xf9407ffb // ldr x27, [sp, #248] + WORD $0xb90023d1 // str w17, [x30, #32] + WORD $0xb94022b1 // ldr w17, [x21, #32] + WORD $0xb9002359 // str w25, [x26, #32] + WORD $0xb9402799 // ldr w25, [x28, #36] + WORD $0xb9002364 // str w4, [x27, #32] + WORD $0xb94026a4 // ldr w4, [x21, #36] + WORD $0xf9409ffe // ldr x30, [sp, #312] + WORD $0xb90057f9 // str w25, [sp, #84] + WORD $0xf9406bf9 // ldr x25, [sp, #208] + WORD $0xb90077e4 // str w4, [sp, #116] + WORD $0xaa0803e4 // mov x4, x8 + WORD $0xf940a7f5 // ldr x21, [sp, #328] + WORD $0xb9002331 // str w17, [x25, #32] + WORD $0xb9002505 // str w5, [x8, #36] + WORD $0xb94073e8 // ldr w8, [sp, #112] + WORD $0xb9402ab1 // ldr w17, [x21, #40] + WORD $0xaa1603e5 // mov x5, x22 + WORD $0xb9002588 // str w8, [x12, #36] + WORD $0xb94029a8 // ldr w8, [x13, #40] + WORD $0xb90073e8 // str w8, [sp, #112] + WORD $0xb94053e8 // ldr w8, [sp, #80] + WORD $0xb9002688 // str w8, [x20, #36] + WORD $0xb9402bc8 // ldr w8, [x30, #40] + WORD $0xaa0303f4 // mov x20, x3 + WORD $0xb90047e8 // str w8, [sp, #68] + WORD $0xb94063e8 // ldr w8, [sp, #96] + WORD $0xb90024c8 // str w8, [x6, #36] + WORD $0xb94028e8 // ldr w8, [x7, #40] + WORD $0xaa1a03e7 // mov x7, x26 + WORD $0xb90063e8 // str w8, [sp, #96] + WORD $0xb9406fe8 // ldr w8, [sp, #108] + WORD $0xb9002468 // str w8, [x3, #36] + WORD $0xb9402ac8 // ldr w8, [x22, #40] + WORD $0xaa1303f6 // mov x22, x19 + WORD $0xb90053e8 // str w8, [sp, #80] + WORD $0xb9407fe8 // ldr w8, [sp, #124] + WORD $0xb9002428 // str w8, [x1, #36] + WORD $0xb9403fe8 // ldr w8, [sp, #60] + WORD $0xb94029c1 // ldr w1, [x14, #40] + WORD $0xf940b3ee // ldr x14, [sp, #352] + WORD $0xb9002608 // str w8, [x16, #36] + WORD $0xa95243e3 // ldp x3, x16, [sp, #288] + WORD $0xb9402868 // ldr w8, [x3, #40] + WORD $0xb9003be8 // str w8, [sp, #56] + WORD $0xb9406be8 // ldr w8, [sp, #104] + WORD $0xb9002648 // str w8, [x18, #36] + WORD $0xb9402948 // ldr w8, [x10, #40] + WORD $0xf9404fea // ldr x10, [sp, #152] + WORD $0xb9402932 // ldr w18, [x9, #40] + WORD $0xb90043e8 // str w8, [sp, #64] + WORD $0xb9404fe8 // ldr w8, [sp, #76] + WORD $0xb9002548 // str w8, [x10, #36] + WORD $0xb94029c8 // ldr w8, [x14, #40] + WORD $0xb90037e8 // str w8, [sp, #52] + WORD $0xb9404be8 // ldr w8, [sp, #72] + WORD $0xb90026e8 // str w8, [x23, #36] + WORD $0xb9402a08 // ldr w8, [x16, #40] + WORD $0xb9004fe8 // str w8, [sp, #76] + WORD $0xb94067e8 // ldr w8, [sp, #100] + WORD $0xb90025e8 // str w8, [x15, #36] + WORD $0xf9408bef // ldr x15, [sp, #272] + WORD $0xb94029e8 // ldr w8, [x15, #40] + WORD $0xb90067e8 // str w8, [sp, #100] + WORD $0xb9405fe8 // ldr w8, [sp, #92] + WORD $0xb9002568 // str w8, [x11, #36] + WORD $0xb9405be8 // ldr w8, [sp, #88] + WORD $0xb9402a6b // ldr w11, [x19, #40] + WORD $0xf9405ff3 // ldr x19, [sp, #184] + WORD $0xb9002708 // str w8, [x24, #36] + WORD $0xb9402848 // ldr w8, [x2, #40] + WORD $0xaa1403f8 // mov x24, x20 + WORD $0xb9006fe8 // str w8, [sp, #108] + WORD $0xb9407be8 // ldr w8, [sp, #120] + WORD $0xb9002748 // str w8, [x26, #36] + WORD $0xaa0903e8 // mov x8, x9 + WORD $0xb94057e9 // ldr w9, [sp, #84] + WORD $0xaa1c03fa // mov x26, x28 + WORD $0xb9402d02 // ldr w2, [x8, #44] + WORD $0xaa0403e8 // mov x8, x4 + WORD $0xb9002769 // str w9, [x27, #36] + WORD $0xb9402b89 // ldr w9, [x28, #40] + WORD $0xaa0303fb // mov x27, x3 + WORD $0x290f2fe9 // stp w9, w11, [sp, #120] + WORD $0xb94077e9 // ldr w9, [sp, #116] + WORD $0xaa1503eb // mov x11, x21 + WORD $0xb9002729 // str w9, [x25, #36] + WORD $0xb9402ea9 // ldr w9, [x21, #44] + WORD $0xb9002892 // str w18, [x4, #40] + WORD $0xf94057f2 // ldr x18, [sp, #168] + WORD $0xb9002991 // str w17, [x12, #40] + WORD $0xaa0603e4 // mov x4, x6 + WORD $0xb9003fe9 // str w9, [sp, #60] + WORD $0xb9402da9 // ldr w9, [x13, #44] + WORD $0xaa0c03f9 // mov x25, x12 + WORD $0xb9402cb1 // ldr w17, [x5, #44] + WORD $0xb9005be9 // str w9, [sp, #88] + WORD $0xb94073e9 // ldr w9, [sp, #112] + WORD $0xa95037ec // ldp x12, x13, [sp, #256] + WORD $0xb9002a49 // str w9, [x18, #40] + WORD $0xb9402fc9 // ldr w9, [x30, #44] + WORD $0xf940abfe // ldr x30, [sp, #336] + WORD $0xb90073e9 // str w9, [sp, #112] + WORD $0xb94047e9 // ldr w9, [sp, #68] + WORD $0xb90028c9 // str w9, [x6, #40] + WORD $0xa9581bfc // ldp x28, x6, [sp, #384] + WORD $0xb9402f89 // ldr w9, [x28, #44] + WORD $0xb9006be9 // str w9, [sp, #104] + WORD $0xb94063e9 // ldr w9, [sp, #96] + WORD $0xb9002a89 // str w9, [x20, #40] + WORD $0xb94053e9 // ldr w9, [sp, #80] + WORD $0xa94e57f4 // ldp x20, x21, [sp, #224] + WORD $0xb9002aa9 // str w9, [x21, #40] + WORD $0xb9402cc9 // ldr w9, [x6, #44] + WORD $0xb9002981 // str w1, [x12, #40] + WORD $0xaa1703e1 // mov x1, x23 + WORD $0x290bc7e9 // stp w9, w17, [sp, #92] + WORD $0xb9402c69 // ldr w9, [x3, #44] + WORD $0xf94053f1 // ldr x17, [sp, #160] + WORD $0xaa0a03e3 // mov x3, x10 + WORD $0xb90033e9 // str w9, [sp, #48] + WORD $0xb9403be9 // ldr w9, [sp, #56] + WORD $0xb9002a29 // str w9, [x17, #40] + WORD $0xb9402fc9 // ldr w9, [x30, #44] + WORD $0xb90077e9 // str w9, [sp, #116] + WORD $0xb94043e9 // ldr w9, [sp, #64] + WORD $0xb9002949 // str w9, [x10, #40] + WORD $0xb94037e9 // ldr w9, [sp, #52] + WORD $0xb9402dca // ldr w10, [x14, #44] + WORD $0xf9406bee // ldr x14, [sp, #208] + WORD $0xb9002ae9 // str w9, [x23, #40] + WORD $0xb9402e09 // ldr w9, [x16, #44] + WORD $0xf940b7f0 // ldr x16, [sp, #360] + WORD $0xaa0303f7 // mov x23, x3 + WORD $0x2906abe9 // stp w9, w10, [sp, #52] + WORD $0xb9404fe9 // ldr w9, [sp, #76] + WORD $0xb9402dea // ldr w10, [x15, #44] + WORD $0xb9002a89 // str w9, [x20, #40] + WORD $0xb94067e9 // ldr w9, [sp, #100] + WORD $0xb9002a69 // str w9, [x19, #40] + WORD $0xb9402ec9 // ldr w9, [x22, #44] + WORD $0xaa1c03f6 // mov x22, x28 + WORD $0x29082be9 // stp w9, w10, [sp, #64] + WORD $0xb9407fe9 // ldr w9, [sp, #124] + WORD $0xf940bfea // ldr x10, [sp, #376] + WORD $0xb90029a9 // str w9, [x13, #40] + WORD $0xb9402e09 // ldr w9, [x16, #44] + WORD $0xb940294f // ldr w15, [x10, #40] + WORD $0xb90067e9 // str w9, [sp, #100] + WORD $0xb9406fe9 // ldr w9, [sp, #108] + WORD $0xb90028e9 // str w9, [x7, #40] + WORD $0xb9402f49 // ldr w9, [x26, #44] + WORD $0xf9407ffa // ldr x26, [sp, #248] + WORD $0xb9004be9 // str w9, [sp, #72] + WORD $0xb9407be9 // ldr w9, [sp, #120] + WORD $0xb9002b49 // str w9, [x26, #40] + WORD $0xb9402d49 // ldr w9, [x10, #44] + WORD $0xb90029cf // str w15, [x14, #40] + WORD $0xf940a3ea // ldr x10, [sp, #320] + WORD $0xb9002d02 // str w2, [x8, #44] + WORD $0xb9403168 // ldr w8, [x11, #48] + WORD $0xaa0c03e2 // mov x2, x12 + WORD $0xf940afef // ldr x15, [sp, #344] + WORD $0xb9004fe8 // str w8, [sp, #76] + WORD $0xb9403fe8 // ldr w8, [sp, #60] + WORD $0xb9002f28 // str w8, [x25, #44] + WORD $0xb9403148 // ldr w8, [x10, #48] + WORD $0x290a27e8 // stp w8, w9, [sp, #80] + WORD $0xb9405be8 // ldr w8, [sp, #88] + WORD $0xb9403389 // ldr w9, [x28, #48] + WORD $0xaa0503fc // mov x28, x5 + WORD $0xb9002e48 // str w8, [x18, #44] + WORD $0xf9409ff2 // ldr x18, [sp, #312] + WORD $0xb9403248 // ldr w8, [x18, #48] + WORD $0xb9005be8 // str w8, [sp, #88] + WORD $0xb94073e8 // ldr w8, [sp, #112] + WORD $0xb9002c88 // str w8, [x4, #44] + WORD $0xb9406be8 // ldr w8, [sp, #104] + WORD $0xaa0e03e4 // mov x4, x14 + WORD $0xb9002f08 // str w8, [x24, #44] + WORD $0xb94030a8 // ldr w8, [x5, #48] + WORD $0xf9408bf8 // ldr x24, [sp, #272] + WORD $0xaa1a03e5 // mov x5, x26 + WORD $0xb9006be8 // str w8, [sp, #104] + WORD $0xb94063e8 // ldr w8, [sp, #96] + WORD $0xb9002ea8 // str w8, [x21, #44] + WORD $0xb94030c8 // ldr w8, [x6, #48] + WORD $0x290f27e8 // stp w8, w9, [sp, #120] + WORD $0xb9405fe8 // ldr w8, [sp, #92] + WORD $0xb9002d88 // str w8, [x12, #44] + WORD $0xb9403368 // ldr w8, [x27, #48] + WORD $0xa952b3f5 // ldp x21, x12, [sp, #296] + WORD $0xb90073e8 // str w8, [sp, #112] + WORD $0xb94033e8 // ldr w8, [sp, #48] + WORD $0xb9002e28 // str w8, [x17, #44] + WORD $0xb94033c8 // ldr w8, [x30, #48] + WORD $0xb90033e8 // str w8, [sp, #48] + WORD $0xb94077e8 // ldr w8, [sp, #116] + WORD $0xb9002c68 // str w8, [x3, #44] + WORD $0xf940b3e8 // ldr x8, [sp, #352] + WORD $0xaa1303e3 // mov x3, x19 + WORD $0x29462109 // ldp w9, w8, [x8, #48] + WORD $0xb90077e9 // str w9, [sp, #116] + WORD $0xb9403be9 // ldr w9, [sp, #56] + WORD $0xb9002c29 // str w9, [x1, #44] + WORD $0xb94032a9 // ldr w9, [x21, #48] + WORD $0xf94077e1 // ldr x1, [sp, #232] + WORD $0xb9003fe9 // str w9, [sp, #60] + WORD $0xb94037e9 // ldr w9, [sp, #52] + WORD $0xb9002e89 // str w9, [x20, #44] + WORD $0xb9403309 // ldr w9, [x24, #48] + WORD $0xb9003be9 // str w9, [sp, #56] + WORD $0xb94047e9 // ldr w9, [sp, #68] + WORD $0xb9002e69 // str w9, [x19, #44] + WORD $0xb9403189 // ldr w9, [x12, #48] + WORD $0xb9006fe9 // str w9, [sp, #108] + WORD $0xb94043e9 // ldr w9, [sp, #64] + WORD $0xb90043e8 // str w8, [sp, #64] + WORD $0xb94077e8 // ldr w8, [sp, #116] + WORD $0xb9002da9 // str w9, [x13, #44] + WORD $0xb9403209 // ldr w9, [x16, #48] + WORD $0xb9404bed // ldr w13, [sp, #72] + WORD $0xb90047e9 // str w9, [sp, #68] + WORD $0xb94067e9 // ldr w9, [sp, #100] + WORD $0xb9002ce9 // str w9, [x7, #44] + WORD $0xf940bbe9 // ldr x9, [sp, #368] + WORD $0xb9002f4d // str w13, [x26, #44] + WORD $0xb94031ed // ldr w13, [x15, #48] + WORD $0xa94c6bf4 // ldp x20, x26, [sp, #192] + WORD $0x29464126 // ldp w6, w16, [x9, #48] + WORD $0xb90063ed // str w13, [sp, #96] + WORD $0xb9403569 // ldr w9, [x11, #52] + WORD $0xb94057ed // ldr w13, [sp, #84] + WORD $0xb940364b // ldr w11, [x18, #52] + WORD $0xb9005fe9 // str w9, [sp, #92] + WORD $0xb9404fe9 // ldr w9, [sp, #76] + WORD $0xb9002dcd // str w13, [x14, #44] + WORD $0xb9403772 // ldr w18, [x27, #52] + WORD $0xb9003346 // str w6, [x26, #48] + WORD $0xaa1603ed // mov x13, x22 + WORD $0xb9003329 // str w9, [x25, #48] + WORD $0xb9403549 // ldr w9, [x10, #52] + WORD $0xf94057ea // ldr x10, [sp, #168] + WORD $0xaa1803e6 // mov x6, x24 + WORD $0xaa0203ee // mov x14, x2 + WORD $0xb90037e9 // str w9, [sp, #52] + WORD $0xb94053e9 // ldr w9, [sp, #80] + WORD $0xb9003149 // str w9, [x10, #48] + WORD $0xb9405be9 // ldr w9, [sp, #88] + WORD $0xb9003289 // str w9, [x20, #48] + WORD $0xb94036c9 // ldr w9, [x22, #52] + WORD $0xaa1103f6 // mov x22, x17 + WORD $0x2909afe9 // stp w9, w11, [sp, #76] + WORD $0xf9404beb // ldr x11, [sp, #144] + WORD $0xb9407fe9 // ldr w9, [sp, #124] + WORD $0xb9003169 // str w9, [x11, #48] + WORD $0xb9403789 // ldr w9, [x28, #52] + WORD $0xf940c7fc // ldr x28, [sp, #392] + WORD $0xb90067e9 // str w9, [sp, #100] + WORD $0xb9406be9 // ldr w9, [sp, #104] + WORD $0xb9003029 // str w9, [x1, #48] + WORD $0xb9403789 // ldr w9, [x28, #52] + WORD $0xb9004be9 // str w9, [sp, #72] + WORD $0xb9407be9 // ldr w9, [sp, #120] + WORD $0xb9003049 // str w9, [x2, #48] + WORD $0xb94073e9 // ldr w9, [sp, #112] + WORD $0xaa0c03e2 // mov x2, x12 + WORD $0xb9003229 // str w9, [x17, #48] + WORD $0xb94037c9 // ldr w9, [x30, #52] + WORD $0xaa1703f1 // mov x17, x23 + WORD $0x290acbe9 // stp w9, w18, [sp, #84] + WORD $0xb94033e9 // ldr w9, [sp, #48] + WORD $0xf94087f2 // ldr x18, [sp, #264] + WORD $0xb90032e9 // str w9, [x23, #48] + WORD $0xb9403709 // ldr w9, [x24, #52] + WORD $0xa94ddff3 // ldp x19, x23, [sp, #216] + WORD $0xf940b7f8 // ldr x24, [sp, #360] + WORD $0xb9003268 // str w8, [x19, #48] + WORD $0xb94036a8 // ldr w8, [x21, #52] + WORD $0xb9006be8 // str w8, [sp, #104] + WORD $0xb9403fe8 // ldr w8, [sp, #60] + WORD $0xb90032e8 // str w8, [x23, #48] + WORD $0xb9403be8 // ldr w8, [sp, #56] + WORD $0xb9003068 // str w8, [x3, #48] + WORD $0xb9403588 // ldr w8, [x12, #52] + WORD $0x2904a7e8 // stp w8, w9, [sp, #36] + WORD $0xb9403709 // ldr w9, [x24, #52] + WORD $0xb9406fe8 // ldr w8, [sp, #108] + WORD $0xb90023e9 // str w9, [sp, #32] + WORD $0xb94047e9 // ldr w9, [sp, #68] + WORD $0xb9003248 // str w8, [x18, #48] + WORD $0xf940bfe8 // ldr x8, [sp, #376] + WORD $0xb90030e9 // str w9, [x7, #48] + WORD $0xb94035e9 // ldr w9, [x15, #52] + WORD $0xb940310c // ldr w12, [x8, #48] + WORD $0xaa0103ef // mov x15, x1 + WORD $0xb9003be9 // str w9, [sp, #56] + WORD $0xb94063e9 // ldr w9, [sp, #96] + WORD $0xb90030a9 // str w9, [x5, #48] + WORD $0xb9403509 // ldr w9, [x8, #52] + WORD $0xb900308c // str w12, [x4, #48] + WORD $0xaa1c03e5 // mov x5, x28 + WORD $0xb9003750 // str w16, [x26, #52] + WORD $0xf9409ffa // ldr x26, [sp, #312] + WORD $0xa95433f0 // ldp x16, x12, [sp, #320] + WORD $0xb9006fe9 // str w9, [sp, #108] + WORD $0xaa0803e9 // mov x9, x8 + WORD $0xaa1b03e4 // mov x4, x27 + WORD $0xb9403988 // ldr w8, [x12, #56] + WORD $0xb90033e8 // str w8, [sp, #48] + WORD $0xb9405fe8 // ldr w8, [sp, #92] + WORD $0xb9003728 // str w8, [x25, #52] + WORD $0xb9403a08 // ldr w8, [x16, #56] + WORD $0xaa1203f9 // mov x25, x18 + WORD $0xb9007be8 // str w8, [sp, #120] + WORD $0xb94037e8 // ldr w8, [sp, #52] + WORD $0xb9003548 // str w8, [x10, #52] + WORD $0xb9403b48 // ldr w8, [x26, #56] + WORD $0xf9408fea // ldr x10, [sp, #280] + WORD $0xb9005fe8 // str w8, [sp, #92] + WORD $0xb94053e8 // ldr w8, [sp, #80] + WORD $0xb9003688 // str w8, [x20, #52] + WORD $0xb94039a8 // ldr w8, [x13, #56] + WORD $0xaa1e03ed // mov x13, x30 + WORD $0xf94057f4 // ldr x20, [sp, #168] + WORD $0xb9007fe8 // str w8, [sp, #124] + WORD $0xb9404fe8 // ldr w8, [sp, #76] + WORD $0xb9003568 // str w8, [x11, #52] + WORD $0x29472948 // ldp w8, w10, [x10, #56] + WORD $0xb9403b8b // ldr w11, [x28, #56] + WORD $0xb90047e8 // str w8, [sp, #68] + WORD $0xb94067e8 // ldr w8, [sp, #100] + WORD $0xb9003428 // str w8, [x1, #52] + WORD $0xb9404be8 // ldr w8, [sp, #72] + WORD $0xb90035c8 // str w8, [x14, #52] + WORD $0xb9403b68 // ldr w8, [x27, #56] + WORD $0xb9003fe8 // str w8, [sp, #60] + WORD $0xb9405be8 // ldr w8, [sp, #88] + WORD $0xb90036c8 // str w8, [x22, #52] + WORD $0xb9403bc8 // ldr w8, [x30, #56] + WORD $0xa95587fe // ldp x30, x1, [sp, #344] + WORD $0xb9403e16 // ldr w22, [x16, #60] + WORD $0x290e2fe8 // stp w8, w11, [sp, #112] + WORD $0xb94057e8 // ldr w8, [sp, #84] + WORD $0xb9402beb // ldr w11, [sp, #40] + WORD $0xb9003628 // str w8, [x17, #52] + WORD $0xb9403828 // ldr w8, [x1, #56] + WORD $0xaa0603f1 // mov x17, x6 + WORD $0xb9004be8 // str w8, [sp, #72] + WORD $0xb94043e8 // ldr w8, [sp, #64] + WORD $0xb9003668 // str w8, [x19, #52] + WORD $0xb9403aa8 // ldr w8, [x21, #56] + WORD $0xa94f4ffc // ldp x28, x19, [sp, #240] + WORD $0xb90043e8 // str w8, [sp, #64] + WORD $0xb9406be8 // ldr w8, [sp, #104] + WORD $0xb90036e8 // str w8, [x23, #52] + WORD $0xb94038c8 // ldr w8, [x6, #56] + WORD $0xb900346b // str w11, [x3, #52] + WORD $0xb940384b // ldr w11, [x2, #56] + WORD $0xa94ceff7 // ldp x23, x27, [sp, #200] + WORD $0xb9002fe8 // str w8, [sp, #44] + WORD $0xaa0303e8 // mov x8, x3 + WORD $0xb90063eb // str w11, [sp, #96] + WORD $0xf94083e3 // ldr x3, [sp, #256] + WORD $0x29442fee // ldp w14, w11, [sp, #32] + WORD $0xa94943e2 // ldp x2, x16, [sp, #144] + WORD $0xb900364b // str w11, [x18, #52] + WORD $0xb9403bf2 // ldr w18, [sp, #56] + WORD $0xb90034ee // str w14, [x7, #52] + WORD $0xf940bbee // ldr x14, [sp, #368] + WORD $0xb9403b0b // ldr w11, [x24, #56] + WORD $0xb9003672 // str w18, [x19, #52] + WORD $0xb9403bd2 // ldr w18, [x30, #56] + WORD $0x294739c6 // ldp w6, w14, [x14, #56] + WORD $0xb90037eb // str w11, [sp, #52] + WORD $0xaa1803eb // mov x11, x24 + WORD $0xb9004ff2 // str w18, [sp, #76] + WORD $0xb9406ff2 // ldr w18, [sp, #108] + WORD $0xaa0703f8 // mov x24, x7 + WORD $0xf94063e7 // ldr x7, [sp, #192] + WORD $0xb9003772 // str w18, [x27, #52] + WORD $0xf94053f2 // ldr x18, [sp, #160] + WORD $0xb9003ae6 // str w6, [x23, #56] + WORD $0xb9403d86 // ldr w6, [x12, #60] + WORD $0xb94033ec // ldr w12, [sp, #48] + WORD $0xb9003b8c // str w12, [x28, #56] + WORD $0xb9407bec // ldr w12, [sp, #120] + WORD $0xb9007bea // str w10, [sp, #120] + WORD $0xb94047ea // ldr w10, [sp, #68] + WORD $0xb9003a8c // str w12, [x20, #56] + WORD $0xb9403f4c // ldr w12, [x26, #60] + WORD $0xb90053ec // str w12, [sp, #80] + WORD $0xb9405fec // ldr w12, [sp, #92] + WORD $0xb90038ec // str w12, [x7, #56] + WORD $0xf940c3ec // ldr x12, [sp, #384] + WORD $0xb9403d8c // ldr w12, [x12, #60] + WORD $0xb90057ec // str w12, [sp, #84] + WORD $0xb9407fec // ldr w12, [sp, #124] + WORD $0xb900384c // str w12, [x2, #56] + WORD $0xb940392c // ldr w12, [x9, #56] + WORD $0xb90039ea // str w10, [x15, #56] + WORD $0xb9403caa // ldr w10, [x5, #60] + WORD $0xb9403ea5 // ldr w5, [x21, #60] + WORD $0xb9005bea // str w10, [sp, #88] + WORD $0xb94077ea // ldr w10, [sp, #116] + WORD $0xb900386a // str w10, [x3, #56] + WORD $0xb9403c8a // ldr w10, [x4, #60] + WORD $0xb90067ea // str w10, [sp, #100] + WORD $0xb9403fea // ldr w10, [sp, #60] + WORD $0xb9003a4a // str w10, [x18, #56] + WORD $0xb9403daa // ldr w10, [x13, #60] + WORD $0xaa1203ed // mov x13, x18 + WORD $0xb9005fea // str w10, [sp, #92] + WORD $0xb94073ea // ldr w10, [sp, #112] + WORD $0xb9003a0a // str w10, [x16, #56] + WORD $0xb9403c2a // ldr w10, [x1, #60] + WORD $0xa94d93e1 // ldp x1, x4, [sp, #216] + WORD $0xb90073ea // str w10, [sp, #112] + WORD $0xb9404bea // ldr w10, [sp, #72] + WORD $0xb900382a // str w10, [x1, #56] + WORD $0xb94043ea // ldr w10, [sp, #64] + WORD $0xb900388a // str w10, [x4, #56] + WORD $0xb9403e2a // ldr w10, [x17, #60] + WORD $0xb9006bea // str w10, [sp, #104] + WORD $0xb9402fea // ldr w10, [sp, #44] + WORD $0xb900390a // str w10, [x8, #56] + WORD $0xf9409bea // ldr x10, [sp, #304] + WORD $0xb9403d48 // ldr w8, [x10, #60] + WORD $0xb9006fe8 // str w8, [sp, #108] + WORD $0xb94063e8 // ldr w8, [sp, #96] + WORD $0xb9003b28 // str w8, [x25, #56] + WORD $0xaa0903e8 // mov x8, x9 + WORD $0xb9403d69 // ldr w9, [x11, #60] + WORD $0xb9403fcb // ldr w11, [x30, #60] + WORD $0xb9403d08 // ldr w8, [x8, #60] + WORD $0xb90063e9 // str w9, [sp, #96] + WORD $0xb94037e9 // ldr w9, [sp, #52] + WORD $0xb90077eb // str w11, [sp, #116] + WORD $0xaa0303eb // mov x11, x3 + WORD $0xb9007fe8 // str w8, [sp, #124] + WORD $0xf940bbe8 // ldr x8, [sp, #368] + WORD $0xb9003b09 // str w9, [x24, #56] + WORD $0xb9404fe9 // ldr w9, [sp, #76] + WORD $0xf9405ffe // ldr x30, [sp, #184] + WORD $0xb9404515 // ldr w21, [x8, #68] + WORD $0xb9003a69 // str w9, [x19, #56] + WORD $0xb9404149 // ldr w9, [x10, #64] + WORD $0xb9404113 // ldr w19, [x8, #64] + WORD $0xb9003b6c // str w12, [x27, #56] + WORD $0x294a23ea // ldp w10, w8, [sp, #80] + WORD $0xb9003eee // str w14, [x23, #60] + WORD $0xb9003f86 // str w6, [x28, #60] + WORD $0xb9003e96 // str w22, [x20, #60] + WORD $0xb94073ec // ldr w12, [sp, #112] + WORD $0xb9003cea // str w10, [x7, #60] + WORD $0xb9407bea // ldr w10, [sp, #120] + WORD $0xb9003c48 // str w8, [x2, #60] + WORD $0xf940a7e8 // ldr x8, [sp, #328] + WORD $0xaa1903fc // mov x28, x25 + WORD $0xaa0203ee // mov x14, x2 + WORD $0xb9003dea // str w10, [x15, #60] + WORD $0xb94067ea // ldr w10, [sp, #100] + WORD $0x29485116 // ldp w22, w20, [x8, #64] + WORD $0xaa0403f7 // mov x23, x4 + WORD $0xb9405be8 // ldr w8, [sp, #88] + WORD $0xb940435b // ldr w27, [x26, #64] + WORD $0xb9003c68 // str w8, [x3, #60] + WORD $0xf940a3e8 // ldr x8, [sp, #320] + WORD $0xb9003e4a // str w10, [x18, #60] + WORD $0xaa1003ea // mov x10, x16 + WORD $0x29482111 // ldp w17, w8, [x8, #64] + WORD $0xb9007be8 // str w8, [sp, #120] + WORD $0xb9405fe8 // ldr w8, [sp, #92] + WORD $0xb9003e08 // str w8, [x16, #60] + WORD $0xb9406bf0 // ldr w16, [sp, #104] + WORD $0xb9003c2c // str w12, [x1, #60] + WORD $0xb940474c // ldr w12, [x26, #68] + WORD $0xb9003c85 // str w5, [x4, #60] + WORD $0xaa0103e8 // mov x8, x1 + WORD $0xb9003fd0 // str w16, [x30, #60] + WORD $0xb94063f0 // ldr w16, [sp, #96] + WORD $0xb90073ec // str w12, [sp, #112] + WORD $0xb9407fe1 // ldr w1, [sp, #124] + WORD $0xa9584bec // ldp x12, x18, [sp, #384] + WORD $0xa94cebe5 // ldp x5, x26, [sp, #200] + WORD $0x29483183 // ldp w3, w12, [x12, #64] + WORD $0xf940abe4 // ldr x4, [sp, #336] + WORD $0xb9006bec // str w12, [sp, #104] + WORD $0xb9406fec // ldr w12, [sp, #108] + WORD $0xb9003f2c // str w12, [x25, #60] + WORD $0xf9408fec // ldr x12, [sp, #280] + WORD $0xb9003f10 // str w16, [x24, #60] + WORD $0xa94f43e6 // ldp x6, x16, [sp, #240] + WORD $0x29483199 // ldp w25, w12, [x12, #64] + WORD $0xb90063ec // str w12, [sp, #96] + WORD $0xb94077ec // ldr w12, [sp, #116] + WORD $0xb9003e0c // str w12, [x16, #60] + WORD $0x29484a4c // ldp w12, w18, [x18, #64] + WORD $0xb9003f41 // str w1, [x26, #60] + WORD $0xb90040b3 // str w19, [x5, #64] + WORD $0xaa0703e1 // mov x1, x7 + WORD $0xb90040d6 // str w22, [x6, #64] + WORD $0xaa1e03f6 // mov x22, x30 + WORD $0xb9007ff2 // str w18, [sp, #124] + WORD $0xf94093f2 // ldr x18, [sp, #288] + WORD $0x29484a42 // ldp w2, w18, [x18, #64] + WORD $0xb9006ff2 // str w18, [sp, #108] + WORD $0xf94057f2 // ldr x18, [sp, #168] + WORD $0xb9004251 // str w17, [x18, #64] + WORD $0xb9404091 // ldr w17, [x4, #64] + WORD $0xb90040fb // str w27, [x7, #64] + WORD $0xb9404487 // ldr w7, [x4, #68] + WORD $0xb90041c3 // str w3, [x14, #64] + WORD $0xf940b3e4 // ldr x4, [sp, #352] + WORD $0xb90041f9 // str w25, [x15, #64] + WORD $0xaa0b03f9 // mov x25, x11 + WORD $0xb900416c // str w12, [x11, #64] + WORD $0xf94097ec // ldr x12, [sp, #296] + WORD $0xb9404083 // ldr w3, [x4, #64] + WORD $0xb90041a2 // str w2, [x13, #64] + WORD $0xb9004151 // str w17, [x10, #64] + WORD $0xf940afe2 // ldr x2, [sp, #344] + WORD $0x2948318b // ldp w11, w12, [x12, #64] + WORD $0xb9004103 // str w3, [x8, #64] + WORD $0xf940b7e3 // ldr x3, [sp, #360] + WORD $0xb90042eb // str w11, [x23, #64] + WORD $0xb9404484 // ldr w4, [x4, #68] + WORD $0xb9005fec // str w12, [sp, #92] + WORD $0xf9408bec // ldr x12, [sp, #272] + WORD $0x29480c6b // ldp w11, w3, [x3, #64] + WORD $0xb90067e4 // str w4, [sp, #100] + WORD $0x29482191 // ldp w17, w8, [x12, #64] + WORD $0xb9005be8 // str w8, [sp, #88] + WORD $0xf940bfe8 // ldr x8, [sp, #376] + WORD $0xb90043d1 // str w17, [x30, #64] + WORD $0xb9404051 // ldr w17, [x2, #64] + WORD $0xb9004389 // str w9, [x28, #64] + WORD $0xaa0e03fc // mov x28, x14 + WORD $0xb940410c // ldr w12, [x8, #64] + WORD $0xb900430b // str w11, [x24, #64] + WORD $0xb9004211 // str w17, [x16, #64] + WORD $0xb9404513 // ldr w19, [x8, #68] + WORD $0xaa0503e8 // mov x8, x5 + WORD $0xb94073f1 // ldr w17, [sp, #112] + WORD $0xb900434c // str w12, [x26, #64] + WORD $0xb9406bee // ldr w14, [sp, #104] + WORD $0xb90044b5 // str w21, [x5, #68] + WORD $0xf9409be5 // ldr x5, [sp, #304] + WORD $0xb90044d4 // str w20, [x6, #68] + WORD $0xb94063e9 // ldr w9, [sp, #96] + WORD $0xb940444b // ldr w11, [x2, #68] + WORD $0xaa0f03fe // mov x30, x15 + WORD $0x2948c0ac // ldp w12, w16, [x5, #68] + WORD $0xaa1703f5 // mov x21, x23 + WORD $0xaa0503e6 // mov x6, x5 + WORD $0xf940c3e5 // ldr x5, [sp, #384] + WORD $0xb90077f0 // str w16, [sp, #116] + WORD $0xb9407bf0 // ldr w16, [sp, #120] + WORD $0xb9004650 // str w16, [x18, #68] + WORD $0xaa1203f0 // mov x16, x18 + WORD $0xb9004431 // str w17, [x1, #68] + WORD $0xf940bbf2 // ldr x18, [sp, #368] + WORD $0xb900478e // str w14, [x28, #68] + WORD $0xf940a7ee // ldr x14, [sp, #328] + WORD $0xb90045e9 // str w9, [x15, #68] + WORD $0xb9406fe9 // ldr w9, [sp, #108] + WORD $0x29490a5b // ldp w27, w2, [x18, #72] + WORD $0xaa1903e1 // mov x1, x25 + WORD $0x294911d4 // ldp w20, w4, [x14, #72] + WORD $0xb9407fee // ldr w14, [sp, #124] + WORD $0xaa0a03f2 // mov x18, x10 + WORD $0xf940a3ef // ldr x15, [sp, #320] + WORD $0xb900472e // str w14, [x25, #68] + WORD $0xaa0d03f9 // mov x25, x13 + WORD $0xb90045a9 // str w9, [x13, #68] + WORD $0xb94067e9 // ldr w9, [sp, #100] + WORD $0xb9004547 // str w7, [x10, #68] + WORD $0xf9406fea // ldr x10, [sp, #216] + WORD $0xb9404ded // ldr w13, [x15, #76] + WORD $0xf9407fe7 // ldr x7, [sp, #248] + WORD $0xb9004549 // str w9, [x10, #68] + WORD $0xb9405fe9 // ldr w9, [sp, #92] + WORD $0xb9007bed // str w13, [sp, #120] + WORD $0xf9409fed // ldr x13, [sp, #312] + WORD $0xb94049ee // ldr w14, [x15, #72] + WORD $0xb90046e9 // str w9, [x23, #68] + WORD $0xb9405be9 // ldr w9, [sp, #88] + WORD $0xf94087f7 // ldr x23, [sp, #264] + WORD $0xb94049af // ldr w15, [x13, #72] + WORD $0xb90046c9 // str w9, [x22, #68] + WORD $0xb9404db1 // ldr w17, [x13, #76] + WORD $0xb90046ec // str w12, [x23, #68] + WORD $0xb94048ad // ldr w13, [x5, #72] + WORD $0xb9004703 // str w3, [x24, #68] + WORD $0xf940c7e3 // ldr x3, [sp, #392] + WORD $0xb9404ca9 // ldr w9, [x5, #76] + WORD $0xb90044eb // str w11, [x7, #68] + WORD $0xf9408fe5 // ldr x5, [sp, #280] + WORD $0xb9004753 // str w19, [x26, #68] + WORD $0xb940486b // ldr w11, [x3, #72] + WORD $0xb900491b // str w27, [x8, #72] + WORD $0xb9404c63 // ldr w3, [x3, #76] + WORD $0xb9006fe9 // str w9, [sp, #108] + WORD $0x294924ac // ldp w12, w9, [x5, #72] + WORD $0xaa0803fb // mov x27, x8 + WORD $0xf9407be8 // ldr x8, [sp, #240] + WORD $0xb9007fe3 // str w3, [sp, #124] + WORD $0xf94093e3 // ldr x3, [sp, #288] + WORD $0xb90063e9 // str w9, [sp, #96] + WORD $0xb9004914 // str w20, [x8, #72] + WORD $0xaa1003f4 // mov x20, x16 + WORD $0xb9404c69 // ldr w9, [x3, #76] + WORD $0xb9004a0e // str w14, [x16, #72] + WORD $0xf940abf0 // ldr x16, [sp, #336] + WORD $0xaa1a03e5 // mov x5, x26 + WORD $0xb940487a // ldr w26, [x3, #72] + WORD $0xb90073e9 // str w9, [sp, #112] + WORD $0xf94063e3 // ldr x3, [sp, #192] + WORD $0x2949260e // ldp w14, w9, [x16, #72] + WORD $0xb900486f // str w15, [x3, #72] + WORD $0xf94097ef // ldr x15, [sp, #296] + WORD $0xb90067e9 // str w9, [sp, #100] + WORD $0xf940b3e9 // ldr x9, [sp, #352] + WORD $0xb9004b8d // str w13, [x28, #72] + WORD $0xb9004bcc // str w12, [x30, #72] + WORD $0xaa1e03ec // mov x12, x30 + WORD $0xb940492d // ldr w13, [x9, #72] + WORD $0xb900482b // str w11, [x1, #72] + WORD $0xb94049eb // ldr w11, [x15, #72] + WORD $0xb9004b3a // str w26, [x25, #72] + WORD $0xb9404dfe // ldr w30, [x15, #76] + WORD $0xb9004a4e // str w14, [x18, #72] + WORD $0xf9408bef // ldr x15, [sp, #272] + WORD $0xb900494d // str w13, [x10, #72] + WORD $0xb9004aab // str w11, [x21, #72] + WORD $0xf940b7ed // ldr x13, [sp, #360] + WORD $0xaa1703fa // mov x26, x23 + WORD $0xaa1903e1 // mov x1, x25 + WORD $0x294929ee // ldp w14, w10, [x15, #72] + WORD $0xaa1403f9 // mov x25, x20 + WORD $0xaa0103f5 // mov x21, x1 + WORD $0xf940afef // ldr x15, [sp, #344] + WORD $0xb9005fea // str w10, [sp, #92] + WORD $0xb94077ea // ldr w10, [sp, #116] + WORD $0xb9004ace // str w14, [x22, #72] + WORD $0xb94049ab // ldr w11, [x13, #72] + WORD $0xb94049ee // ldr w14, [x15, #72] + WORD $0xaa0503f6 // mov x22, x5 + WORD $0xb9004aea // str w10, [x23, #72] + WORD $0xf940bfea // ldr x10, [sp, #376] + WORD $0xb9004b0b // str w11, [x24, #72] + WORD $0xb9404deb // ldr w11, [x15, #76] + WORD $0xb90048ee // str w14, [x7, #72] + WORD $0xf94083f7 // ldr x23, [sp, #256] + WORD $0x29493950 // ldp w16, w14, [x10, #72] + WORD $0xaa1203e7 // mov x7, x18 + WORD $0xaa0603ea // mov x10, x6 + WORD $0xb94063ea // ldr w10, [sp, #96] + WORD $0xb90077eb // str w11, [sp, #116] + WORD $0xb90048b0 // str w16, [x5, #72] + WORD $0xb9404d29 // ldr w9, [x9, #76] + WORD $0xb9004f62 // str w2, [x27, #76] + WORD $0xaa0303e2 // mov x2, x3 + WORD $0xb9004d04 // str w4, [x8, #76] + WORD $0x2949a0d0 // ldp w16, w8, [x6, #76] + WORD $0xaa0c03f8 // mov x24, x12 + WORD $0xb9404dad // ldr w13, [x13, #76] + WORD $0xaa1c03e6 // mov x6, x28 + WORD $0xb9006be8 // str w8, [sp, #104] + WORD $0xb9407be8 // ldr w8, [sp, #120] + WORD $0xf940c3eb // ldr x11, [sp, #384] + WORD $0xaa1603e4 // mov x4, x22 + WORD $0xb9004e88 // str w8, [x20, #76] + WORD $0xf940bbe8 // ldr x8, [sp, #368] + WORD $0xb9004c71 // str w17, [x3, #76] + WORD $0x294a4d0f // ldp w15, w19, [x8, #80] + WORD $0xb9406fe8 // ldr w8, [sp, #108] + WORD $0xb9004f88 // str w8, [x28, #76] + WORD $0xf940a7e8 // ldr x8, [sp, #328] + WORD $0xb9004d8a // str w10, [x12, #76] + WORD $0xb94073ea // ldr w10, [sp, #112] + WORD $0xaa1a03fc // mov x28, x26 + WORD $0x294a1503 // ldp w3, w5, [x8, #80] + WORD $0xb9407fe8 // ldr w8, [sp, #124] + WORD $0xb9004ee8 // str w8, [x23, #76] + WORD $0xf940a3e8 // ldr x8, [sp, #320] + WORD $0xb9004c2a // str w10, [x1, #76] + WORD $0xa94dabf4 // ldp x20, x10, [sp, #216] + WORD $0x294a2111 // ldp w17, w8, [x8, #80] + WORD $0xb9007be8 // str w8, [sp, #120] + WORD $0xb94067e8 // ldr w8, [sp, #100] + WORD $0xb9004e48 // str w8, [x18, #76] + WORD $0xf9409fe8 // ldr x8, [sp, #312] + WORD $0xb9004e89 // str w9, [x20, #76] + WORD $0xb9405fe9 // ldr w9, [sp, #92] + WORD $0xb9004d5e // str w30, [x10, #76] + WORD $0xb9405172 // ldr w18, [x11, #80] + WORD $0x294a2101 // ldp w1, w8, [x8, #80] + WORD $0xb9006fe8 // str w8, [sp, #108] + WORD $0xf9405fe8 // ldr x8, [sp, #184] + WORD $0xb9004d09 // str w9, [x8, #76] + WORD $0xb9405569 // ldr w9, [x11, #84] + WORD $0xb9004f50 // str w16, [x26, #76] + WORD $0xf9405bf0 // ldr x16, [sp, #176] + WORD $0xf9408feb // ldr x11, [sp, #280] + WORD $0xaa1703fa // mov x26, x23 + WORD $0xb90067e9 // str w9, [sp, #100] + WORD $0xb9004e0d // str w13, [x16, #76] + WORD $0xf940c7ed // ldr x13, [sp, #392] + WORD $0x294a257e // ldp w30, w9, [x11, #80] + WORD $0x294a35ac // ldp w12, w13, [x13, #80] + WORD $0xb90063e9 // str w9, [sp, #96] + WORD $0xf9407feb // ldr x11, [sp, #248] + WORD $0xb94077e9 // ldr w9, [sp, #116] + WORD $0xb9007fed // str w13, [sp, #124] + WORD $0xf94093ed // ldr x13, [sp, #288] + WORD $0xb9004d69 // str w9, [x11, #76] + WORD $0xb9004ece // str w14, [x22, #76] + WORD $0xf9407bee // ldr x14, [sp, #240] + WORD $0xb900536f // str w15, [x27, #80] + WORD $0x294a35af // ldp w15, w13, [x13, #80] + WORD $0xaa1b03f6 // mov x22, x27 + WORD $0xb90051c3 // str w3, [x14, #80] + WORD $0xaa1903e3 // mov x3, x25 + WORD $0xb9005331 // str w17, [x25, #80] + WORD $0xaa0b03fb // mov x27, x11 + WORD $0xb90073ed // str w13, [sp, #112] + WORD $0xf940abed // ldr x13, [sp, #336] + WORD $0xb9005041 // str w1, [x2, #80] + WORD $0xaa0203e1 // mov x1, x2 + WORD $0xb90050d2 // str w18, [x6, #80] + WORD $0xaa0603f9 // mov x25, x6 + WORD $0xb94051b1 // ldr w17, [x13, #80] + WORD $0xb900531e // str w30, [x24, #80] + WORD $0xb94055a9 // ldr w9, [x13, #84] + WORD $0xb90052ec // str w12, [x23, #80] + WORD $0xf940b3ed // ldr x13, [sp, #352] + WORD $0xb90052af // str w15, [x21, #80] + WORD $0xb90050f1 // str w17, [x7, #80] + WORD $0xaa0a03fe // mov x30, x10 + WORD $0xaa0703ef // mov x15, x7 + WORD $0xaa0e03e7 // mov x7, x14 + WORD $0x294a35b2 // ldp w18, w13, [x13, #80] + WORD $0xaa0103f7 // mov x23, x1 + WORD $0xb9005292 // str w18, [x20, #80] + WORD $0xb90077ed // str w13, [sp, #116] + WORD $0xf94097ed // ldr x13, [sp, #296] + WORD $0x294a35ac // ldp w12, w13, [x13, #80] + WORD $0xb900514c // str w12, [x10, #80] + WORD $0xb9406bec // ldr w12, [sp, #104] + WORD $0xb9005fed // str w13, [sp, #92] + WORD $0xf9408bed // ldr x13, [sp, #272] + WORD $0x294a35b1 // ldp w17, w13, [x13, #80] + WORD $0xb9005111 // str w17, [x8, #80] + WORD $0xf940afe8 // ldr x8, [sp, #344] + WORD $0xb9005bed // str w13, [sp, #88] + WORD $0xf940b7ed // ldr x13, [sp, #360] + WORD $0xb900538c // str w12, [x28, #80] + WORD $0xf940bfec // ldr x12, [sp, #376] + WORD $0x294a2111 // ldp w17, w8, [x8, #80] + WORD $0xaa1903fc // mov x28, x25 + WORD $0xb94051aa // ldr w10, [x13, #80] + WORD $0xb9405182 // ldr w2, [x12, #80] + WORD $0xb90057e8 // str w8, [sp, #84] + WORD $0xf9409be8 // ldr x8, [sp, #304] + WORD $0xb900520a // str w10, [x16, #80] + WORD $0xb9405586 // ldr w6, [x12, #84] + WORD $0xb9005171 // str w17, [x11, #80] + WORD $0xb94055b2 // ldr w18, [x13, #84] + WORD $0xb9005082 // str w2, [x4, #80] + WORD $0x294a890b // ldp w11, w2, [x8, #84] + WORD $0xb90056d3 // str w19, [x22, #84] + WORD $0x294ea3ed // ldp w13, w8, [sp, #116] + WORD $0xb90055c5 // str w5, [x14, #84] + WORD $0x294db3ea // ldp w10, w12, [sp, #108] + WORD $0xb9005468 // str w8, [x3, #84] + WORD $0xf940bbe8 // ldr x8, [sp, #368] + WORD $0xf9406be5 // ldr x5, [sp, #208] + WORD $0xb900542a // str w10, [x1, #84] + WORD $0x294b2110 // ldp w16, w8, [x8, #88] + WORD $0xb9006fe8 // str w8, [sp, #108] + WORD $0x294c23ea // ldp w10, w8, [sp, #96] + WORD $0xb9005728 // str w8, [x25, #84] + WORD $0xf940a7e8 // ldr x8, [sp, #328] + WORD $0xb900570a // str w10, [x24, #84] + WORD $0xaa1503ea // mov x10, x21 + WORD $0x294b1111 // ldp w17, w4, [x8, #88] + WORD $0xb9407fe8 // ldr w8, [sp, #124] + WORD $0xb9005748 // str w8, [x26, #84] + WORD $0xf940a3e8 // ldr x8, [sp, #320] + WORD $0xb90056ac // str w12, [x21, #84] + WORD $0xaa1403ec // mov x12, x20 + WORD $0xb90055e9 // str w9, [x15, #84] + WORD $0xb940590e // ldr w14, [x8, #88] + WORD $0xb900568d // str w13, [x20, #84] + WORD $0xb9405d09 // ldr w9, [x8, #92] + WORD $0xf940c3ed // ldr x13, [sp, #384] + WORD $0xf9409fe8 // ldr x8, [sp, #312] + WORD $0xb94059b4 // ldr w20, [x13, #88] + WORD $0x294b2101 // ldp w1, w8, [x8, #88] + WORD $0x290ca7e8 // stp w8, w9, [sp, #100] + WORD $0x294b23e9 // ldp w9, w8, [sp, #88] + WORD $0xb90057c8 // str w8, [x30, #84] + WORD $0xa94b23f3 // ldp x19, x8, [sp, #176] + WORD $0xb9005509 // str w9, [x8, #84] + WORD $0xb9405da9 // ldr w9, [x13, #92] + WORD $0xf94087ed // ldr x13, [sp, #264] + WORD $0xb90077e9 // str w9, [sp, #116] + WORD $0xb90055ab // str w11, [x13, #84] + WORD $0xf9408feb // ldr x11, [sp, #280] + WORD $0xb9005672 // str w18, [x19, #84] + WORD $0xf940c7f2 // ldr x18, [sp, #392] + WORD $0x294b2575 // ldp w21, w9, [x11, #88] + WORD $0xb9405a59 // ldr w25, [x18, #88] + WORD $0xb90073e9 // str w9, [sp, #112] + WORD $0xb94057e9 // ldr w9, [sp, #84] + WORD $0xb9005769 // str w9, [x27, #84] + WORD $0xb9405e49 // ldr w9, [x18, #92] + WORD $0xf94093f2 // ldr x18, [sp, #288] + WORD $0xb90054a6 // str w6, [x5, #84] + WORD $0xb9005ad0 // str w16, [x22, #88] + WORD $0xaa0a03e6 // mov x6, x10 + WORD $0xb90058f1 // str w17, [x7, #88] + WORD $0xaa1703f1 // mov x17, x23 + WORD $0xb9405a50 // ldr w16, [x18, #88] + WORD $0xb900586e // str w14, [x3, #88] + WORD $0xb9405e4b // ldr w11, [x18, #92] + WORD $0xb9005ae1 // str w1, [x23, #88] + WORD $0xf940abf2 // ldr x18, [sp, #336] + WORD $0xb9005b94 // str w20, [x28, #88] + WORD $0xb9005b15 // str w21, [x24, #88] + WORD $0xb9005b59 // str w25, [x26, #88] + WORD $0xaa0803f5 // mov x21, x8 + WORD $0xb9405a4e // ldr w14, [x18, #88] + WORD $0xb9005950 // str w16, [x10, #88] + WORD $0xb9405e52 // ldr w18, [x18, #92] + WORD $0xaa1b03f8 // mov x24, x27 + WORD $0xf9408bea // ldr x10, [sp, #272] + WORD $0xaa1e03f4 // mov x20, x30 + WORD $0xb90059ee // str w14, [x15, #88] + WORD $0xa95587f0 // ldp x16, x1, [sp, #344] + WORD $0x290f2ff2 // stp w18, w11, [sp, #120] + WORD $0x294b0432 // ldp w18, w1, [x1, #88] + WORD $0x294b294e // ldp w14, w10, [x10, #88] + WORD $0xb9005992 // str w18, [x12, #88] + WORD $0x290b87ea // stp w10, w1, [sp, #92] + WORD $0xf94097e1 // ldr x1, [sp, #296] + WORD $0xaa0603f2 // mov x18, x6 + WORD $0x294b6437 // ldp w23, w25, [x1, #88] + WORD $0xaa0f03e1 // mov x1, x15 + WORD $0xf940b7ef // ldr x15, [sp, #360] + WORD $0xb9005bd7 // str w23, [x30, #88] + WORD $0xb9405e1e // ldr w30, [x16, #92] + WORD $0xb900590e // str w14, [x8, #88] + WORD $0xf940bfe8 // ldr x8, [sp, #376] + WORD $0xb94059ea // ldr w10, [x15, #88] + WORD $0xb90059a2 // str w2, [x13, #88] + WORD $0xb9405a0e // ldr w14, [x16, #88] + WORD $0xaa1103f0 // mov x16, x17 + WORD $0xb9405902 // ldr w2, [x8, #88] + WORD $0xaa0503f7 // mov x23, x5 + WORD $0xb9005a6a // str w10, [x19, #88] + WORD $0xb9405d0a // ldr w10, [x8, #92] + WORD $0xb9406fe8 // ldr w8, [sp, #108] + WORD $0xb9005b6e // str w14, [x27, #88] + WORD $0xb90058a2 // str w2, [x5, #88] + WORD $0xaa0303fb // mov x27, x3 + WORD $0xb9407fe5 // ldr w5, [sp, #124] + WORD $0xb9005ec8 // str w8, [x22, #92] + WORD $0xf9409be8 // ldr x8, [sp, #304] + WORD $0xb9005ce4 // str w4, [x7, #92] + WORD $0xb9405def // ldr w15, [x15, #92] + WORD $0xaa1503e7 // mov x7, x21 + WORD $0x294b891a // ldp w26, w2, [x8, #92] + WORD $0x294ca3eb // ldp w11, w8, [sp, #100] + WORD $0xb9005c68 // str w8, [x3, #92] + WORD $0xf940bbe8 // ldr x8, [sp, #368] + WORD $0xb9005e2b // str w11, [x17, #92] + WORD $0xf94077eb // ldr x11, [sp, #232] + WORD $0x294c2103 // ldp w3, w8, [x8, #96] + WORD $0xb9006fe8 // str w8, [sp, #108] + WORD $0x294e23ed // ldp w13, w8, [sp, #112] + WORD $0xb9005f88 // str w8, [x28, #92] + WORD $0xb9005d6d // str w13, [x11, #92] + WORD $0xa95423ed // ldp x13, x8, [sp, #320] + WORD $0x294c110e // ldp w14, w4, [x8, #96] + WORD $0x294c35b1 // ldp w17, w13, [x13, #96] + WORD $0xf94083e8 // ldr x8, [sp, #256] + WORD $0xb90077ed // str w13, [sp, #116] + WORD $0xb9407bed // ldr w13, [sp, #120] + WORD $0xb9005d09 // str w9, [x8, #92] + WORD $0xb94063e9 // ldr w9, [sp, #96] + WORD $0xb9005cc5 // str w5, [x6, #92] + WORD $0xf940c3e5 // ldr x5, [sp, #384] + WORD $0xb9005c2d // str w13, [x1, #92] + WORD $0xf9409fed // ldr x13, [sp, #312] + WORD $0xb9005d89 // str w9, [x12, #92] + WORD $0xb9405fe9 // ldr w9, [sp, #92] + WORD $0xb9005e99 // str w25, [x20, #92] + WORD $0x294c35a6 // ldp w6, w13, [x13, #96] + WORD $0xb9005ea9 // str w9, [x21, #92] + WORD $0xf94087f5 // ldr x21, [sp, #264] + WORD $0xb9007fed // str w13, [sp, #124] + WORD $0x294c24ad // ldp w13, w9, [x5, #96] + WORD $0xf9408fe5 // ldr x5, [sp, #280] + WORD $0xb9006be9 // str w9, [sp, #104] + WORD $0xb9005eba // str w26, [x21, #92] + WORD $0xb9005e6f // str w15, [x19, #92] + WORD $0xf940c7ef // ldr x15, [sp, #392] + WORD $0xb94064a9 // ldr w9, [x5, #100] + WORD $0xb9005f1e // str w30, [x24, #92] + WORD $0xb9005eea // str w10, [x23, #92] + WORD $0xf9407bea // ldr x10, [sp, #240] + WORD $0xb94061f9 // ldr w25, [x15, #96] + WORD $0xb90062c3 // str w3, [x22, #96] + WORD $0xb90067e9 // str w9, [sp, #100] + WORD $0xb94065e9 // ldr w9, [x15, #100] + WORD $0xb900614e // str w14, [x10, #96] + WORD $0xb9006371 // str w17, [x27, #96] + WORD $0xb94060ba // ldr w26, [x5, #96] + WORD $0xb9006206 // str w6, [x16, #96] + WORD $0xa9521bef // ldp x15, x6, [sp, #288] + WORD $0xb94061e3 // ldr w3, [x15, #96] + WORD $0xb900638d // str w13, [x28, #96] + WORD $0xb94065ee // ldr w14, [x15, #100] + WORD $0xb900617a // str w26, [x11, #96] + WORD $0xf940abef // ldr x15, [sp, #336] + WORD $0xb9006119 // str w25, [x8, #96] + WORD $0xb94060cb // ldr w11, [x6, #96] + WORD $0xb9006243 // str w3, [x18, #96] + WORD $0xf9408be8 // ldr x8, [sp, #272] + WORD $0xaa1803e5 // mov x5, x24 + WORD $0x294c3df1 // ldp w17, w15, [x15, #96] + WORD $0xb9007bee // str w14, [sp, #120] + WORD $0xaa1b03ee // mov x14, x27 + WORD $0xb9406510 // ldr w16, [x8, #100] + WORD $0xb90063e9 // str w9, [sp, #96] + WORD $0xb9006031 // str w17, [x1, #96] + WORD $0xb9406111 // ldr w17, [x8, #96] + WORD $0xb90073ef // str w15, [sp, #112] + WORD $0xa955bfe8 // ldp x8, x15, [sp, #344] + WORD $0xaa0503fe // mov x30, x5 + WORD $0xaa1203e3 // mov x3, x18 + WORD $0xaa1503f8 // mov x24, x21 + WORD $0x294c25ed // ldp w13, w9, [x15, #96] + WORD $0xaa1703f2 // mov x18, x23 + WORD $0xaa0603fc // mov x28, x6 + WORD $0xf94063ef // ldr x15, [sp, #192] + WORD $0xaa1403fa // mov x26, x20 + WORD $0xb900618d // str w13, [x12, #96] + WORD $0xf940b7ec // ldr x12, [sp, #360] + WORD $0xb900628b // str w11, [x20, #96] + WORD $0xf940bfed // ldr x13, [sp, #376] + WORD $0xb90060f1 // str w17, [x7, #96] + WORD $0xb9406111 // ldr w17, [x8, #96] + WORD $0xb940618b // ldr w11, [x12, #96] + WORD $0xb90062a2 // str w2, [x21, #96] + WORD $0xb940658c // ldr w12, [x12, #100] + WORD $0xaa0703f4 // mov x20, x7 + WORD $0xb94061a2 // ldr w2, [x13, #96] + WORD $0xaa0103e7 // mov x7, x1 + WORD $0xb900626b // str w11, [x19, #96] + WORD $0xb94065b9 // ldr w25, [x13, #100] + WORD $0x290b33f0 // stp w16, w12, [sp, #88] + WORD $0xb940650c // ldr w12, [x8, #100] + WORD $0xb9406fe8 // ldr w8, [sp, #108] + WORD $0xb90060b1 // str w17, [x5, #96] + WORD $0xb90062e2 // str w2, [x23, #96] + WORD $0xaa0a03f1 // mov x17, x10 + WORD $0xaa0e03e5 // mov x5, x14 + WORD $0xf940a7eb // ldr x11, [sp, #328] + WORD $0xb90066c8 // str w8, [x22, #100] + WORD $0xf9409be8 // ldr x8, [sp, #304] + WORD $0xb9006544 // str w4, [x10, #100] + WORD $0xb9407fea // ldr w10, [sp, #124] + WORD $0xf94077f7 // ldr x23, [sp, #232] + WORD $0x294c8910 // ldp w16, w2, [x8, #100] + WORD $0xb94077e8 // ldr w8, [sp, #116] + WORD $0xb9406d64 // ldr w4, [x11, #108] + WORD $0xf94083f5 // ldr x21, [sp, #256] + WORD $0xb90065c8 // str w8, [x14, #100] + WORD $0xf940bbe8 // ldr x8, [sp, #368] + WORD $0xb90065ea // str w10, [x15, #100] + WORD $0xf9404bea // ldr x10, [sp, #144] + WORD $0xb94064db // ldr w27, [x6, #100] + WORD $0xaa1303e6 // mov x6, x19 + WORD $0x294d210d // ldp w13, w8, [x8, #104] + WORD $0xaa0303f3 // mov x19, x3 + WORD $0xb9407be3 // ldr w3, [sp, #120] + WORD $0xf9406ff6 // ldr x22, [sp, #216] + WORD $0xb9006fe8 // str w8, [sp, #108] + WORD $0x294ca3ee // ldp w14, w8, [sp, #100] + WORD $0xb9006548 // str w8, [x10, #100] + WORD $0xb9406968 // ldr w8, [x11, #104] + WORD $0xb94063eb // ldr w11, [sp, #96] + WORD $0xb90066ee // str w14, [x23, #100] + WORD $0xb90066ab // str w11, [x21, #100] + WORD $0xf940a3eb // ldr x11, [sp, #320] + WORD $0xb9006663 // str w3, [x19, #100] + WORD $0x294d2d6e // ldp w14, w11, [x11, #104] + WORD $0xb9007feb // str w11, [sp, #124] + WORD $0xb94073eb // ldr w11, [sp, #112] + WORD $0xb900642b // str w11, [x1, #100] + WORD $0xf9409feb // ldr x11, [sp, #312] + WORD $0xb90066c9 // str w9, [x22, #100] + WORD $0xb9405be9 // ldr w9, [sp, #88] + WORD $0xb900675b // str w27, [x26, #100] + WORD $0x294d2d61 // ldp w1, w11, [x11, #104] + WORD $0xb9006689 // str w9, [x20, #100] + WORD $0xb9006710 // str w16, [x24, #100] + WORD $0xb9007beb // str w11, [sp, #120] + WORD $0xaa1a03eb // mov x11, x26 + WORD $0xf940c3fa // ldr x26, [sp, #384] + WORD $0x294d2743 // ldp w3, w9, [x26, #104] + WORD $0xf9408ffa // ldr x26, [sp, #280] + WORD $0xb90073e9 // str w9, [sp, #112] + WORD $0xb9405fe9 // ldr w9, [sp, #92] + WORD $0xb9406b50 // ldr w16, [x26, #104] + WORD $0xb90064c9 // str w9, [x6, #100] + WORD $0xb9406f49 // ldr w9, [x26, #108] + WORD $0xb90067cc // str w12, [x30, #100] + WORD $0xf940c7ec // ldr x12, [sp, #392] + WORD $0xb9006659 // str w25, [x18, #100] + WORD $0xf94093f9 // ldr x25, [sp, #288] + WORD $0xb90067e9 // str w9, [sp, #100] + WORD $0xaa1503fa // mov x26, x21 + WORD $0x294d259b // ldp w27, w9, [x12, #104] + WORD $0xaa1e03fa // mov x26, x30 + WORD $0xb9006be9 // str w9, [sp, #104] + WORD $0xf94067e9 // ldr x9, [sp, #200] + WORD $0xb900692d // str w13, [x9, #104] + WORD $0xb9406b2d // ldr w13, [x25, #104] + WORD $0xb9006a28 // str w8, [x17, #104] + WORD $0xb9406f28 // ldr w8, [x25, #108] + WORD $0xb90068ae // str w14, [x5, #104] + WORD $0xaa1303f9 // mov x25, x19 + WORD $0xb90069e1 // str w1, [x15, #104] + WORD $0xaa0a03e1 // mov x1, x10 + WORD $0xb90063e8 // str w8, [sp, #96] + WORD $0xf940abe8 // ldr x8, [sp, #336] + WORD $0xb9006943 // str w3, [x10, #104] + WORD $0xb9406b8a // ldr w10, [x28, #104] + WORD $0xb9006af0 // str w16, [x23, #104] + WORD $0xb940690e // ldr w14, [x8, #104] + WORD $0xb9006abb // str w27, [x21, #104] + WORD $0xb9406d08 // ldr w8, [x8, #108] + WORD $0xb9006a6d // str w13, [x19, #104] + WORD $0xaa0703fb // mov x27, x7 + WORD $0xb9406f8d // ldr w13, [x28, #108] + WORD $0xb90068ee // str w14, [x7, #104] + WORD $0xaa0103e7 // mov x7, x1 + WORD $0xb90077e8 // str w8, [sp, #116] + WORD $0xf940b3e8 // ldr x8, [sp, #352] + WORD $0xaa1403f3 // mov x19, x20 + WORD $0x294d4103 // ldp w3, w16, [x8, #104] + WORD $0xaa1c03e8 // mov x8, x28 + WORD $0xf9408be8 // ldr x8, [sp, #272] + WORD $0xaa1603fc // mov x28, x22 + WORD $0xb9006ac3 // str w3, [x22, #104] + WORD $0xf940bfe3 // ldr x3, [sp, #376] + WORD $0xb900696a // str w10, [x11, #104] + WORD $0xaa1803eb // mov x11, x24 + WORD $0x294d210e // ldp w14, w8, [x8, #104] + WORD $0xaa1103f6 // mov x22, x17 + WORD $0xf9405beb // ldr x11, [sp, #176] + WORD $0xb9006a8e // str w14, [x20, #104] + WORD $0xf94073f4 // ldr x20, [sp, #224] + WORD $0x290a23f0 // stp w16, w8, [sp, #80] + WORD $0xf940afe8 // ldr x8, [sp, #344] + WORD $0xf940b7f0 // ldr x16, [sp, #360] + WORD $0xb9006b02 // str w2, [x24, #104] + WORD $0xb9406862 // ldr w2, [x3, #104] + WORD $0x294d210e // ldp w14, w8, [x8, #104] + WORD $0x294d320a // ldp w10, w12, [x16, #104] + WORD $0xaa0503f0 // mov x16, x5 + WORD $0xb9005fe8 // str w8, [sp, #92] + WORD $0xb9406fe8 // ldr w8, [sp, #108] + WORD $0xb90068ca // str w10, [x6, #104] + WORD $0xaa0f03e6 // mov x6, x15 + WORD $0xb9006bce // str w14, [x30, #104] + WORD $0xb9406c6e // ldr w14, [x3, #108] + WORD $0xb9006a42 // str w2, [x18, #104] + WORD $0xaa1203e3 // mov x3, x18 + WORD $0xb9006d28 // str w8, [x9, #108] + WORD $0xf9409be8 // ldr x8, [sp, #304] + WORD $0xb9004bec // str w12, [sp, #72] + WORD $0xaa1503e2 // mov x2, x21 + WORD $0xb9006e24 // str w4, [x17, #108] + WORD $0xaa1903e4 // mov x4, x25 + WORD $0x294da50a // ldp w10, w9, [x8, #108] + WORD $0x294f23ec // ldp w12, w8, [sp, #120] + WORD $0xb9006ca8 // str w8, [x5, #108] + WORD $0xf940bbe8 // ldr x8, [sp, #368] + WORD $0xb9006dec // str w12, [x15, #108] + WORD $0xb94067ef // ldr w15, [sp, #100] + WORD $0xa95433e5 // ldp x5, x12, [sp, #320] + WORD $0x294e2112 // ldp w18, w8, [x8, #112] + WORD $0xb94070b1 // ldr w17, [x5, #112] + WORD $0xb9005be8 // str w8, [sp, #88] + WORD $0xb94073e8 // ldr w8, [sp, #112] + WORD $0xb9006c28 // str w8, [x1, #108] + WORD $0x294e3188 // ldp w8, w12, [x12, #112] + WORD $0xb9006eef // str w15, [x23, #108] + WORD $0xb94053ef // ldr w15, [sp, #80] + WORD $0xb9004fec // str w12, [sp, #76] + WORD $0xb9406bec // ldr w12, [sp, #104] + WORD $0xb9006eac // str w12, [x21, #108] + WORD $0xb94063ec // ldr w12, [sp, #96] + WORD $0xb9006f2c // str w12, [x25, #108] + WORD $0xb94074ac // ldr w12, [x5, #116] + WORD $0xaa1b03f9 // mov x25, x27 + WORD $0xb9007fec // str w12, [sp, #124] + WORD $0xb94077ec // ldr w12, [sp, #116] + WORD $0xb9006f6c // str w12, [x27, #108] + WORD $0xf9409fec // ldr x12, [sp, #312] + WORD $0xb9006f8f // str w15, [x28, #108] + WORD $0xb94057ef // ldr w15, [sp, #84] + WORD $0xb9006e8d // str w13, [x20, #108] + WORD $0xaa1c03fb // mov x27, x28 + WORD $0x294e3181 // ldp w1, w12, [x12, #112] + WORD $0xaa1603fc // mov x28, x22 + WORD $0xb9006e6f // str w15, [x19, #108] + WORD $0xb9006f0a // str w10, [x24, #108] + WORD $0xf9408fea // ldr x10, [sp, #280] + WORD $0xb9404bef // ldr w15, [sp, #72] + WORD $0xb90067ec // str w12, [sp, #100] + WORD $0xb9006d6f // str w15, [x11, #108] + WORD $0xa9583fec // ldp x12, x15, [sp, #384] + WORD $0x294e318d // ldp w13, w12, [x12, #112] + WORD $0xb9007bec // str w12, [sp, #120] + WORD $0x294e294c // ldp w12, w10, [x10, #112] + WORD $0xb90077ea // str w10, [sp, #116] + WORD $0xb9405fea // ldr w10, [sp, #92] + WORD $0xb9006fca // str w10, [x30, #108] + WORD $0xb94071ea // ldr w10, [x15, #112] + WORD $0xb9006c6e // str w14, [x3, #108] + WORD $0xb94075ee // ldr w14, [x15, #116] + WORD $0xf94067ef // ldr x15, [sp, #200] + WORD $0xb90057ee // str w14, [sp, #84] + WORD $0xf94093ee // ldr x14, [sp, #288] + WORD $0xb90071f2 // str w18, [x15, #112] + WORD $0xb90072c8 // str w8, [x22, #112] + WORD $0xaa1703f6 // mov x22, x23 + WORD $0xb94075c8 // ldr w8, [x14, #116] + WORD $0xb9007211 // str w17, [x16, #112] + WORD $0xb90070c1 // str w1, [x6, #112] + WORD $0xb94071d2 // ldr w18, [x14, #112] + WORD $0xb90070ed // str w13, [x7, #112] + WORD $0xaa0603ee // mov x14, x6 + WORD $0xb90073e8 // str w8, [sp, #112] + WORD $0xb90072ec // str w12, [x23, #112] + WORD $0xaa0703e1 // mov x1, x7 + WORD $0xb90072aa // str w10, [x21, #112] + WORD $0xa9552be8 // ldp x8, x10, [sp, #336] + WORD $0xb9407111 // ldr w17, [x8, #112] + WORD $0xb9007092 // str w18, [x4, #112] + WORD $0xb9407508 // ldr w8, [x8, #116] + WORD $0xaa1903f2 // mov x18, x25 + WORD $0xaa0403f7 // mov x23, x4 + WORD $0xaa1803e7 // mov x7, x24 + WORD $0xb9007331 // str w17, [x25, #112] + WORD $0xaa1403f9 // mov x25, x20 + WORD $0xb9006fe8 // str w8, [sp, #108] + WORD $0xf940b3e8 // ldr x8, [sp, #352] + WORD $0xaa1003e4 // mov x4, x16 + WORD $0xaa1303e6 // mov x6, x19 + WORD $0x294e210d // ldp w13, w8, [x8, #112] + WORD $0xb900736d // str w13, [x27, #112] + WORD $0xb9404fed // ldr w13, [sp, #76] + WORD $0xb90053e8 // str w8, [sp, #80] + WORD $0xf94097e8 // ldr x8, [sp, #296] + WORD $0x294e210c // ldp w12, w8, [x8, #112] + WORD $0xb900728c // str w12, [x20, #112] + WORD $0xaa0303f4 // mov x20, x3 + WORD $0xb9005fe8 // str w8, [sp, #92] + WORD $0xf9408be8 // ldr x8, [sp, #272] + WORD $0x294e2111 // ldp w17, w8, [x8, #112] + WORD $0xb9007271 // str w17, [x19, #112] + WORD $0xb9407151 // ldr w17, [x10, #112] + WORD $0xb9006be8 // str w8, [sp, #104] + WORD $0xf940b7e8 // ldr x8, [sp, #360] + WORD $0xb9007309 // str w9, [x24, #112] + WORD $0xf940bfe9 // ldr x9, [sp, #376] + WORD $0xb940754a // ldr w10, [x10, #116] + WORD $0xaa1c03f8 // mov x24, x28 + WORD $0x294e210c // ldp w12, w8, [x8, #112] + WORD $0xb9407122 // ldr w2, [x9, #112] + WORD $0xb900716c // str w12, [x11, #112] + WORD $0xb90063e8 // str w8, [sp, #96] + WORD $0xb9407528 // ldr w8, [x9, #116] + WORD $0xb90073d1 // str w17, [x30, #112] + WORD $0xaa0f03fe // mov x30, x15 + WORD $0xb9007062 // str w2, [x3, #112] + WORD $0xb94078a3 // ldr w3, [x5, #120] + WORD $0xb9004be8 // str w8, [sp, #72] + WORD $0xb9405be8 // ldr w8, [sp, #88] + WORD $0xb90075e8 // str w8, [x15, #116] + WORD $0xf940bbe8 // ldr x8, [sp, #368] + WORD $0xb900778d // str w13, [x28, #116] + WORD $0xf940a7ed // ldr x13, [sp, #328] + WORD $0xf940c3ef // ldr x15, [sp, #384] + WORD $0xaa1a03fc // mov x28, x26 + WORD $0x294f210c // ldp w12, w8, [x8, #120] + WORD $0x294f35b1 // ldp w17, w13, [x13, #120] + WORD $0xb90173e8 // str w8, [sp, #368] + WORD $0xb9014bed // str w13, [sp, #328] + WORD $0x294f23ed // ldp w13, w8, [sp, #120] + WORD $0xb9007608 // str w8, [x16, #116] + WORD $0xaa0e03e8 // mov x8, x14 + WORD $0xb94067ee // ldr w14, [sp, #100] + WORD $0xb9405ff0 // ldr w16, [sp, #92] + WORD $0xb900750e // str w14, [x8, #116] + WORD $0xb900742d // str w13, [x1, #116] + WORD $0x294e37ee // ldp w14, w13, [sp, #112] + WORD $0xb90076cd // str w13, [x22, #116] + WORD $0xb9407cad // ldr w13, [x5, #124] + WORD $0xb90143ed // str w13, [sp, #320] + WORD $0xb94057ed // ldr w13, [sp, #84] + WORD $0xb90076ad // str w13, [x21, #116] + WORD $0xa95337e5 // ldp x5, x13, [sp, #304] + WORD $0xb90076ee // str w14, [x23, #116] + WORD $0xb94074ae // ldr w14, [x5, #116] + WORD $0x294f35a2 // ldp w2, w13, [x13, #120] + WORD $0xb9007fed // str w13, [sp, #124] + WORD $0xb9406fed // ldr w13, [sp, #108] + WORD $0xb900764d // str w13, [x18, #116] + WORD $0xb94053ed // ldr w13, [sp, #80] + WORD $0xb900776d // str w13, [x27, #116] + WORD $0x294f3ded // ldp w13, w15, [x15, #120] + WORD $0xb9007730 // str w16, [x25, #116] + WORD $0xb9013bef // str w15, [sp, #312] + WORD $0xb9406bef // ldr w15, [sp, #104] + WORD $0xb900766f // str w15, [x19, #116] + WORD $0xb94078b3 // ldr w19, [x5, #120] + WORD $0xb90074ee // str w14, [x7, #116] + WORD $0xf9408fee // ldr x14, [sp, #280] + WORD $0xb94063ef // ldr w15, [sp, #96] + WORD $0xf940c7e5 // ldr x5, [sp, #392] + WORD $0x294f39d0 // ldp w16, w14, [x14, #120] + WORD $0xb900756f // str w15, [x11, #116] + WORD $0xb9404bef // ldr w15, [sp, #72] + WORD $0xb900774a // str w10, [x26, #116] + WORD $0xaa1403ea // mov x10, x20 + WORD $0xb90183ee // str w14, [sp, #384] + WORD $0x294f68ae // ldp w14, w26, [x5, #120] + WORD $0xb900768f // str w15, [x20, #116] + WORD $0xf94093e5 // ldr x5, [sp, #288] + WORD $0xb9007bcc // str w12, [x30, #120] + WORD $0xaa1e03ef // mov x15, x30 + WORD $0xb9007b11 // str w17, [x24, #120] + WORD $0xf940abf1 // ldr x17, [sp, #336] + WORD $0xb9007883 // str w3, [x4, #120] + WORD $0xb94078ac // ldr w12, [x5, #120] + WORD $0xb9007902 // str w2, [x8, #120] + WORD $0xaa0803e2 // mov x2, x8 + WORD $0xb900782d // str w13, [x1, #120] + WORD $0xf940b3e8 // ldr x8, [sp, #352] + WORD $0xb9007ad0 // str w16, [x22, #120] + WORD $0xaa1803fe // mov x30, x24 + WORD $0xb9007aae // str w14, [x21, #120] + WORD $0xf94097ee // ldr x14, [sp, #296] + WORD $0xb9407cb8 // ldr w24, [x5, #124] + WORD $0xb9007aec // str w12, [x23, #120] + WORD $0x294f5223 // ldp w3, w20, [x17, #120] + WORD $0x294f150d // ldp w13, w5, [x8, #120] + WORD $0xb9007a43 // str w3, [x18, #120] + WORD $0x294f45c8 // ldp w8, w17, [x14, #120] + WORD $0xb9007b6d // str w13, [x27, #120] + WORD $0xf9408bee // ldr x14, [sp, #272] + WORD $0xf940b7f0 // ldr x16, [sp, #360] + WORD $0xb9007b28 // str w8, [x25, #120] + WORD $0xf940afe8 // ldr x8, [sp, #344] + WORD $0xb94079c3 // ldr w3, [x14, #120] + WORD $0xb9407a0c // ldr w12, [x16, #120] + WORD $0xb940792d // ldr w13, [x9, #120] + WORD $0xb90078c3 // str w3, [x6, #120] + WORD $0xb9407903 // ldr w3, [x8, #120] + WORD $0xb90078f3 // str w19, [x7, #120] + WORD $0xb9407e13 // ldr w19, [x16, #124] + WORD $0xb900796c // str w12, [x11, #120] + WORD $0xaa0b03f0 // mov x16, x11 + WORD $0xb9407d0b // ldr w11, [x8, #124] + WORD $0xb9007b83 // str w3, [x28, #120] + WORD $0xb94173e8 // ldr w8, [sp, #368] + WORD $0xb900794d // str w13, [x10, #120] + WORD $0xb9407dce // ldr w14, [x14, #124] + WORD $0xb9407d23 // ldr w3, [x9, #124] + WORD $0xb9007de8 // str w8, [x15, #124] + WORD $0xb9414be8 // ldr w8, [sp, #328] + WORD $0xb9007fc8 // str w8, [x30, #124] + WORD $0xb94143e8 // ldr w8, [sp, #320] + WORD $0xb9007c88 // str w8, [x4, #124] + WORD $0xb9407fe8 // ldr w8, [sp, #124] + WORD $0xb9007c48 // str w8, [x2, #124] + WORD $0xb9413be8 // ldr w8, [sp, #312] + WORD $0xb9007c28 // str w8, [x1, #124] + WORD $0xb94183e8 // ldr w8, [sp, #384] + WORD $0xb9007ec8 // str w8, [x22, #124] + WORD $0xf9409be8 // ldr x8, [sp, #304] + WORD $0xb9007eba // str w26, [x21, #124] + WORD $0xa9486bec // ldp x12, x26, [sp, #128] + WORD $0xb9007ef8 // str w24, [x23, #124] + WORD $0xb9407d08 // ldr w8, [x8, #124] + WORD $0xb9007e54 // str w20, [x18, #124] + WORD $0xb9007f65 // str w5, [x27, #124] + WORD $0xb9007f31 // str w17, [x25, #124] + WORD $0x9100418c // add x12, x12, #16 + WORD $0xb9007cce // str w14, [x6, #124] + WORD $0xb9007ce8 // str w8, [x7, #124] + WORD $0xf9400fe8 // ldr x8, [sp, #24] + WORD $0xb9007e13 // str w19, [x16, #124] + WORD $0xb9007f8b // str w11, [x28, #124] + WORD $0xeb08019f // cmp x12, x8 + WORD $0xb9007d43 // str w3, [x10, #124] + BNE LBB0_158 + + // %bb.159: + WORD $0xa94123f3 // ldp x19, x8, [sp, #16] + WORD $0xf94007e0 // ldr x0, [sp, #8] + WORD $0xeb13011f // cmp x8, x19 + BEQ LBB0_156 + JMP LBB0_12 +LBB0_156: + WORD $0x531b6a60 // lsl w0, w19, #5 + WORD $0x910003bf // mov sp, x29 + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0xa9416ffc // ldp x28, x27, [sp, #16] + WORD $0xa8c67bfd // ldp x29, x30, [sp], #96 + MOVD R0, num+32(FP) + RET diff --git a/go/parquet/internal/utils/clib_amd64.s b/go/parquet/internal/utils/clib_amd64.s index 07258bd2f9652..b1534d4cf18f6 100644 --- a/go/parquet/internal/utils/clib_amd64.s +++ b/go/parquet/internal/utils/clib_amd64.s @@ -44,6 +44,15 @@ MEMCPY_BYTE_DONE: POPQ R8 RET +// func _ClibMemcpy(dst, src unsafe.Pointer, n uint) unsafe.Pointer +TEXT ·_ClibMemcpy(SB), NOSPLIT|NOFRAME, $16-24 + MOVQ arg1+0(FP), DI + MOVQ arg2+8(FP), SI + MOVQ arg3+16(FP), DX + CALL clib·_memcpy(SB) + MOVQ AX, ret+24(FP) + RET + // void *memset(void *str, int c, size_t n) // DI = str, SI = c, DX = size TEXT clib·_memset(SB), $16-0 @@ -85,3 +94,12 @@ MEMSET_BYTE_DONE: MOVQ DI, AX // set return value POPQ CX RET + +// func _ClibMemset(dst unsafe.Pointer, c int, n uint) unsafe.Pointer +TEXT ·_ClibMemset(SB), NOSPLIT|NOFRAME, $16-24 + MOVQ arg1+0(FP), DI + MOVQ arg2+8(FP), SI + MOVQ arg3+16(FP), DX + CALL clib·_memset(SB) + MOVQ AX, ret+24(FP) + RET diff --git a/java/adapter/avro/src/test/resources/logback.xml b/java/adapter/avro/src/test/resources/logback.xml new file mode 100644 index 0000000000000..4c54d18a210ff --- /dev/null +++ b/java/adapter/avro/src/test/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + diff --git a/java/algorithm/src/test/resources/logback.xml b/java/algorithm/src/test/resources/logback.xml new file mode 100644 index 0000000000000..4c54d18a210ff --- /dev/null +++ b/java/algorithm/src/test/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + diff --git a/java/compression/src/test/resources/logback.xml b/java/compression/src/test/resources/logback.xml new file mode 100644 index 0000000000000..4c54d18a210ff --- /dev/null +++ b/java/compression/src/test/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + diff --git a/java/flight/flight-grpc/src/test/resources/logback.xml b/java/flight/flight-grpc/src/test/resources/logback.xml new file mode 100644 index 0000000000000..4c54d18a210ff --- /dev/null +++ b/java/flight/flight-grpc/src/test/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + diff --git a/java/flight/flight-integration-tests/src/test/resources/logback.xml b/java/flight/flight-integration-tests/src/test/resources/logback.xml new file mode 100644 index 0000000000000..95fb0b37dc5d3 --- /dev/null +++ b/java/flight/flight-integration-tests/src/test/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + diff --git a/java/flight/flight-sql/src/test/resources/logback.xml b/java/flight/flight-sql/src/test/resources/logback.xml new file mode 100644 index 0000000000000..4c54d18a210ff --- /dev/null +++ b/java/flight/flight-sql/src/test/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + diff --git a/java/memory/memory-core/src/test/resources/logback.xml b/java/memory/memory-core/src/test/resources/logback.xml new file mode 100644 index 0000000000000..4c54d18a210ff --- /dev/null +++ b/java/memory/memory-core/src/test/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + diff --git a/java/memory/memory-unsafe/src/test/resources/logback.xml b/java/memory/memory-unsafe/src/test/resources/logback.xml new file mode 100644 index 0000000000000..4c54d18a210ff --- /dev/null +++ b/java/memory/memory-unsafe/src/test/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + diff --git a/python/pyarrow/__init__.py b/python/pyarrow/__init__.py index ee0d07bb2c811..cd66abcb44840 100644 --- a/python/pyarrow/__init__.py +++ b/python/pyarrow/__init__.py @@ -66,10 +66,10 @@ def parse_git(root, **kwargs): if _gc_enabled: _gc.enable() -from pyarrow.lib import (BuildInfo, RuntimeInfo, MonthDayNano, - VersionInfo, cpp_build_info, cpp_version, - cpp_version_info, runtime_info, cpu_count, - set_cpu_count, enable_signal_handlers, +from pyarrow.lib import (BuildInfo, RuntimeInfo, set_timezone_db_path, + MonthDayNano, VersionInfo, cpp_build_info, + cpp_version, cpp_version_info, runtime_info, + cpu_count, set_cpu_count, enable_signal_handlers, io_thread_count, set_io_thread_count) diff --git a/python/pyarrow/_dataset_parquet.pyx b/python/pyarrow/_dataset_parquet.pyx index 6aea14c8ad0ed..6da4b7efe6bfc 100644 --- a/python/pyarrow/_dataset_parquet.pyx +++ b/python/pyarrow/_dataset_parquet.pyx @@ -804,10 +804,13 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions): Disabled by default. buffer_size : int, default 8192 Size of buffered stream, if enabled. Default is 8KB. - pre_buffer : bool, default False + pre_buffer : bool, default True If enabled, pre-buffer the raw Parquet data instead of issuing one read per column chunk. This can improve performance on high-latency - filesystems. + filesystems (e.g. S3, GCS) by coalesing and issuing file reads in + parallel using a background I/O thread pool. + Set to False if you want to prioritize minimal memory usage + over maximum speed. thrift_string_size_limit : int, default None If not None, override the maximum total string size allocated when decoding Thrift structures. The default limit should be @@ -830,7 +833,7 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions): def __init__(self, *, bint use_buffered_stream=False, buffer_size=8192, - bint pre_buffer=False, + bint pre_buffer=True, thrift_string_size_limit=None, thrift_container_size_limit=None, decryption_config=None): diff --git a/python/pyarrow/acero.py b/python/pyarrow/acero.py index 63da0a37864b2..0609e45753f0d 100644 --- a/python/pyarrow/acero.py +++ b/python/pyarrow/acero.py @@ -299,10 +299,10 @@ def _sort_source(table_or_dataset, sort_keys, output_type=Table, **kwargs): raise TypeError("Unsupported output type") -def _group_by(table, aggregates, keys): +def _group_by(table, aggregates, keys, use_threads=True): decl = Declaration.from_sequence([ Declaration("table_source", TableSourceNodeOptions(table)), Declaration("aggregate", AggregateNodeOptions(aggregates, keys=keys)) ]) - return decl.to_table(use_threads=True) + return decl.to_table(use_threads=use_threads) diff --git a/python/pyarrow/config.pxi b/python/pyarrow/config.pxi index fb9526ba89735..cf751b810cad1 100644 --- a/python/pyarrow/config.pxi +++ b/python/pyarrow/config.pxi @@ -18,6 +18,7 @@ from pyarrow.includes.libarrow cimport GetBuildInfo from collections import namedtuple +import os VersionInfo = namedtuple('VersionInfo', ('major', 'minor', 'patch')) @@ -74,3 +75,21 @@ def runtime_info(): return RuntimeInfo( simd_level=frombytes(c_info.simd_level), detected_simd_level=frombytes(c_info.detected_simd_level)) + + +def set_timezone_db_path(path): + """ + Configure the path to text timezone database on Windows. + + Parameters + ---------- + path : str + Path to text timezone database. + """ + cdef: + CGlobalOptions options + + if path is not None: + options.timezone_db_path = tobytes(path) + + check_status(Initialize(options)) diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd index f4d6541fa724c..482a6e91ba929 100644 --- a/python/pyarrow/includes/libarrow.pxd +++ b/python/pyarrow/includes/libarrow.pxd @@ -80,6 +80,11 @@ cdef extern from "arrow/config.h" namespace "arrow" nogil: CRuntimeInfo GetRuntimeInfo() + cdef cppclass CGlobalOptions" arrow::GlobalOptions": + optional[c_string] timezone_db_path + + CStatus Initialize(const CGlobalOptions& options) + cdef extern from "arrow/util/future.h" namespace "arrow" nogil: cdef cppclass CFuture_Void" arrow::Future<>": diff --git a/python/pyarrow/interchange/from_dataframe.py b/python/pyarrow/interchange/from_dataframe.py index 1d41aa8d7eef3..e97e91e44fb52 100644 --- a/python/pyarrow/interchange/from_dataframe.py +++ b/python/pyarrow/interchange/from_dataframe.py @@ -19,6 +19,7 @@ from typing import ( Any, + Tuple, ) from pyarrow.interchange.column import ( @@ -53,7 +54,8 @@ DtypeKind.FLOAT: {16: pa.float16(), 32: pa.float32(), 64: pa.float64()}, - DtypeKind.BOOL: {8: pa.uint8()}, + DtypeKind.BOOL: {1: pa.bool_(), + 8: pa.uint8()}, DtypeKind.STRING: {8: pa.string()}, } @@ -204,7 +206,9 @@ def column_to_array( pa.Array """ buffers = col.get_buffers() - data = buffers_to_array(buffers, col.size(), + data_type = col.dtype + data = buffers_to_array(buffers, data_type, + col.size(), col.describe_null, col.offset, allow_copy) @@ -229,17 +233,23 @@ def bool_column_to_array( ------- pa.Array """ - if not allow_copy: + buffers = col.get_buffers() + size = buffers["data"][1][1] + + # If booleans are byte-packed a copy to bit-packed will be made + if size == 8 and not allow_copy: raise RuntimeError( "Boolean column will be casted from uint8 and a copy " "is required which is forbidden by allow_copy=False" ) - buffers = col.get_buffers() - data = buffers_to_array(buffers, col.size(), + data_type = col.dtype + data = buffers_to_array(buffers, data_type, + col.size(), col.describe_null, col.offset) - data = pc.cast(data, pa.bool_()) + if size == 8: + data = pc.cast(data, pa.bool_()) return data @@ -274,11 +284,15 @@ def categorical_column_to_dictionary( raise NotImplementedError( "Non-dictionary categoricals not supported yet") + # We need to first convert the dictionary column cat_column = categorical["categories"] dictionary = column_to_array(cat_column) - + # Then we need to convert the indices + # Here we need to use the buffer data type! buffers = col.get_buffers() - indices = buffers_to_array(buffers, col.size(), + _, data_type = buffers["data"] + indices = buffers_to_array(buffers, data_type, + col.size(), col.describe_null, col.offset) @@ -326,6 +340,7 @@ def map_date_type(data_type): def buffers_to_array( buffers: ColumnBuffers, + data_type: Tuple[DtypeKind, int, str, str], length: int, describe_null: ColumnNullType, offset: int = 0, @@ -339,6 +354,9 @@ def buffers_to_array( buffer : ColumnBuffers Dictionary containing tuples of underlying buffers and their associated dtype. + data_type : Tuple[DtypeKind, int, str, str], + Dtype description of the column as a tuple ``(kind, bit-width, format string, + endianness)``. length : int The number of values in the array. describe_null: ColumnNullType @@ -360,7 +378,7 @@ def buffers_to_array( is responsible for keeping the memory owner object alive as long as the returned PyArrow array is being used. """ - data_buff, data_type = buffers["data"] + data_buff, _ = buffers["data"] try: validity_buff, validity_dtype = buffers["validity"] except TypeError: diff --git a/python/pyarrow/pandas_compat.py b/python/pyarrow/pandas_compat.py index 4e5c868efd4c8..e232603ba45ac 100644 --- a/python/pyarrow/pandas_compat.py +++ b/python/pyarrow/pandas_compat.py @@ -31,6 +31,7 @@ import warnings import numpy as np +from numpy.core.numerictypes import sctypes as _np_sctypes import pyarrow as pa from pyarrow.lib import _pandas_api, frombytes # noqa @@ -98,7 +99,7 @@ def get_logical_type(arrow_type): np.float32: 'float32', np.float64: 'float64', 'datetime64[D]': 'date', - np.unicode_: 'string', + np.str_: 'string', np.bytes_: 'bytes', } @@ -780,7 +781,7 @@ def table_to_blockmanager(options, table, categories=None, # dataframe (complex not included since not supported by Arrow) _pandas_supported_numpy_types = { str(np.dtype(typ)) - for typ in (np.sctypes['int'] + np.sctypes['uint'] + np.sctypes['float'] + + for typ in (_np_sctypes['int'] + _np_sctypes['uint'] + _np_sctypes['float'] + ['object', 'bool']) } @@ -1010,7 +1011,7 @@ def _is_generated_index_name(name): 'date': 'datetime64[D]', 'datetime': 'datetime64[ns]', 'datetimetz': 'datetime64[ns]', - 'unicode': np.unicode_, + 'unicode': np.str_, 'bytes': np.bytes_, 'string': np.str_, 'integer': np.int64, diff --git a/python/pyarrow/parquet/core.py b/python/pyarrow/parquet/core.py index e0cdfee62ef4b..a3e5ef76c99b6 100644 --- a/python/pyarrow/parquet/core.py +++ b/python/pyarrow/parquet/core.py @@ -1742,11 +1742,12 @@ class ParquetDataset: different partitioning schemes, etc. pre_buffer : bool, default True Coalesce and issue file reads in parallel to improve performance on - high-latency filesystems (e.g. S3). If True, Arrow will use a + high-latency filesystems (e.g. S3, GCS). If True, Arrow will use a background I/O thread pool. This option is only supported for use_legacy_dataset=False. If using a filesystem layer that itself performs readahead (e.g. fsspec's S3FS), disable readahead for best - results. + results. Set to False if you want to prioritize minimal memory usage + over maximum speed. coerce_int96_timestamp_unit : str, default None Cast timestamps that are stored in INT96 format to a particular resolution (e.g. 'ms'). Setting to None is equivalent to 'ns' and therefore INT96 diff --git a/python/pyarrow/table.pxi b/python/pyarrow/table.pxi index 2eae38485dca4..36601130b3f12 100644 --- a/python/pyarrow/table.pxi +++ b/python/pyarrow/table.pxi @@ -4599,8 +4599,9 @@ cdef class Table(_Tabular): """ return self.drop_columns(columns) - def group_by(self, keys): - """Declare a grouping over the columns of the table. + def group_by(self, keys, use_threads=True): + """ + Declare a grouping over the columns of the table. Resulting grouping can then be used to perform aggregations with a subsequent ``aggregate()`` method. @@ -4609,6 +4610,9 @@ cdef class Table(_Tabular): ---------- keys : str or list[str] Name of the columns that should be used as the grouping key. + use_threads : bool, default True + Whether to use multithreading or not. When set to True (the + default), no stable ordering of the output is guaranteed. Returns ------- @@ -4635,7 +4639,7 @@ cdef class Table(_Tabular): year: [[2020,2022,2021,2019]] n_legs_sum: [[2,6,104,5]] """ - return TableGroupBy(self, keys) + return TableGroupBy(self, keys, use_threads=use_threads) def join(self, right_table, keys, right_keys=None, join_type="left outer", left_suffix=None, right_suffix=None, coalesce_keys=True, @@ -5183,6 +5187,9 @@ class TableGroupBy: Input table to execute the aggregation on. keys : str or list[str] Name of the grouped columns. + use_threads : bool, default True + Whether to use multithreading or not. When set to True (the default), + no stable ordering of the output is guaranteed. Examples -------- @@ -5208,12 +5215,13 @@ class TableGroupBy: values_sum: [[3,7,5]] """ - def __init__(self, table, keys): + def __init__(self, table, keys, use_threads=True): if isinstance(keys, str): keys = [keys] self._table = table self.keys = keys + self._use_threads = use_threads def aggregate(self, aggregations): """ @@ -5328,4 +5336,6 @@ list[tuple(str, str, FunctionOptions)] aggr_name = "_".join(target) + "_" + func_nohash group_by_aggrs.append((target, func, opt, aggr_name)) - return _pac()._group_by(self._table, group_by_aggrs, self.keys) + return _pac()._group_by( + self._table, group_by_aggrs, self.keys, use_threads=self._use_threads + ) diff --git a/python/pyarrow/tests/conftest.py b/python/pyarrow/tests/conftest.py index 241ae4814a5ae..a5941e8c8d1a8 100644 --- a/python/pyarrow/tests/conftest.py +++ b/python/pyarrow/tests/conftest.py @@ -28,6 +28,7 @@ import hypothesis as h from ..conftest import groups, defaults +from pyarrow import set_timezone_db_path from pyarrow.util import find_free_port @@ -48,6 +49,12 @@ os.environ['AWS_CONFIG_FILE'] = "/dev/null" +if sys.platform == 'win32': + tzdata_set_path = os.environ.get('PYARROW_TZDATA_PATH', None) + if tzdata_set_path: + set_timezone_db_path(tzdata_set_path) + + def pytest_addoption(parser): # Create options to selectively enable test groups def bool_env(name, default=None): diff --git a/python/pyarrow/tests/test_array.py b/python/pyarrow/tests/test_array.py index fca094b519fa5..cd565a72bc19f 100644 --- a/python/pyarrow/tests/test_array.py +++ b/python/pyarrow/tests/test_array.py @@ -2020,6 +2020,7 @@ def test_array_pickle_dictionary(pickle_module): assert array.equals(result) +@h.settings(suppress_health_check=(h.HealthCheck.too_slow,)) @h.given( past.arrays( past.all_types, diff --git a/python/pyarrow/tests/test_dataset.py b/python/pyarrow/tests/test_dataset.py index 39c3c43daea37..671405d1ee6a0 100644 --- a/python/pyarrow/tests/test_dataset.py +++ b/python/pyarrow/tests/test_dataset.py @@ -784,28 +784,28 @@ def test_parquet_scan_options(): opts2 = ds.ParquetFragmentScanOptions(buffer_size=4096) opts3 = ds.ParquetFragmentScanOptions( buffer_size=2**13, use_buffered_stream=True) - opts4 = ds.ParquetFragmentScanOptions(buffer_size=2**13, pre_buffer=True) + opts4 = ds.ParquetFragmentScanOptions(buffer_size=2**13, pre_buffer=False) opts5 = ds.ParquetFragmentScanOptions( thrift_string_size_limit=123456, thrift_container_size_limit=987654,) assert opts1.use_buffered_stream is False assert opts1.buffer_size == 2**13 - assert opts1.pre_buffer is False + assert opts1.pre_buffer is True assert opts1.thrift_string_size_limit == 100_000_000 # default in C++ assert opts1.thrift_container_size_limit == 1_000_000 # default in C++ assert opts2.use_buffered_stream is False assert opts2.buffer_size == 2**12 - assert opts2.pre_buffer is False + assert opts2.pre_buffer is True assert opts3.use_buffered_stream is True assert opts3.buffer_size == 2**13 - assert opts3.pre_buffer is False + assert opts3.pre_buffer is True assert opts4.use_buffered_stream is False assert opts4.buffer_size == 2**13 - assert opts4.pre_buffer is True + assert opts4.pre_buffer is False assert opts5.thrift_string_size_limit == 123456 assert opts5.thrift_container_size_limit == 987654 diff --git a/python/pyarrow/tests/test_exec_plan.py b/python/pyarrow/tests/test_exec_plan.py index 58c618179b601..d85a2c2152481 100644 --- a/python/pyarrow/tests/test_exec_plan.py +++ b/python/pyarrow/tests/test_exec_plan.py @@ -321,3 +321,17 @@ def test_join_extension_array_column(): result = _perform_join( "left outer", t1, ["colB"], t3, ["colC"]) assert result["colB"] == pa.chunked_array(ext_array) + + +def test_group_by_ordering(): + # GH-36709 - preserve ordering in groupby by setting use_threads=False + table1 = pa.table({'a': [1, 2, 3, 4], 'b': ['a'] * 4}) + table2 = pa.table({'a': [1, 2, 3, 4], 'b': ['b'] * 4}) + table = pa.concat_tables([table1, table2]) + + for _ in range(50): + # 50 seems to consistently cause errors when order is not preserved. + # If the order problem is reintroduced this test will become flaky + # which is still a signal that the order is not preserved. + result = table.group_by("b", use_threads=False).aggregate([]) + assert result["b"] == pa.chunked_array([["a"], ["b"]]) diff --git a/python/pyarrow/tests/test_extension_type.py b/python/pyarrow/tests/test_extension_type.py index 1eb7d5fa76188..ce575d984e41c 100644 --- a/python/pyarrow/tests/test_extension_type.py +++ b/python/pyarrow/tests/test_extension_type.py @@ -1351,3 +1351,22 @@ def test_tensor_type_is_picklable(pickle_module): result = pickle_module.loads(pickle_module.dumps(expected_arr)) assert result == expected_arr + + +@pytest.mark.parametrize(("tensor_type", "text"), [ + ( + pa.fixed_shape_tensor(pa.int8(), [2, 2, 3]), + 'fixed_shape_tensor[value_type=int8, shape=[2,2,3]]' + ), + ( + pa.fixed_shape_tensor(pa.int32(), [2, 2, 3], permutation=[0, 2, 1]), + 'fixed_shape_tensor[value_type=int32, shape=[2,2,3], permutation=[0,2,1]]' + ), + ( + pa.fixed_shape_tensor(pa.int64(), [2, 2, 3], dim_names=['C', 'H', 'W']), + 'fixed_shape_tensor[value_type=int64, shape=[2,2,3], dim_names=[C,H,W]]' + ) +]) +def test_tensor_type_str(tensor_type, text): + tensor_type_str = tensor_type.__str__() + assert text in tensor_type_str diff --git a/python/pyarrow/tests/test_misc.py b/python/pyarrow/tests/test_misc.py index 86cbf013cd5b4..9b9dfdd554806 100644 --- a/python/pyarrow/tests/test_misc.py +++ b/python/pyarrow/tests/test_misc.py @@ -22,6 +22,7 @@ import pytest import pyarrow as pa +from pyarrow.lib import ArrowInvalid def test_get_include(): @@ -116,6 +117,17 @@ def test_runtime_info(): subprocess.check_call([sys.executable, "-c", code], env=env) +@pytest.mark.skipif(sys.platform == "win32", + reason="Path to timezone database is not configurable " + "on non-Windows platforms") +def test_set_timezone_db_path_non_windows(): + # set_timezone_db_path raises an error on non-Windows platforms + with pytest.raises(ArrowInvalid, + match="Arrow was set to use OS timezone " + "database at compile time"): + pa.set_timezone_db_path("path") + + @pytest.mark.parametrize('klass', [ pa.Field, pa.Schema, diff --git a/python/pyarrow/tests/test_pandas.py b/python/pyarrow/tests/test_pandas.py index 67502af443302..0d01928f44734 100644 --- a/python/pyarrow/tests/test_pandas.py +++ b/python/pyarrow/tests/test_pandas.py @@ -50,6 +50,14 @@ pass +try: + _np_VisibleDeprecationWarning = np.VisibleDeprecationWarning +except AttributeError: + from numpy.exceptions import ( + VisibleDeprecationWarning as _np_VisibleDeprecationWarning + ) + + # Marks all of the tests in this module pytestmark = pytest.mark.pandas @@ -706,7 +714,7 @@ def test_float_nulls(self): def test_float_nulls_to_ints(self): # ARROW-2135 - df = pd.DataFrame({"a": [1.0, 2.0, np.NaN]}) + df = pd.DataFrame({"a": [1.0, 2.0, np.nan]}) schema = pa.schema([pa.field("a", pa.int16(), nullable=True)]) table = pa.Table.from_pandas(df, schema=schema, safe=False) assert table[0].to_pylist() == [1, 2, None] @@ -2329,7 +2337,7 @@ def test_nested_large_list(self): with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Creating an ndarray from ragged nested", - np.VisibleDeprecationWarning) + _np_VisibleDeprecationWarning) warnings.filterwarnings("ignore", "elementwise comparison failed", DeprecationWarning) tm.assert_series_equal( @@ -2441,26 +2449,26 @@ def test_list_no_duplicate_base(self): np_arr = chunked_arr.to_numpy() expected = np.array([[1., 2.], [3., 4., 5.], None, - [6., np.NaN]], dtype="object") + [6., np.nan]], dtype="object") for left, right in zip(np_arr, expected): if right is None: assert left == right else: npt.assert_array_equal(left, right) - expected_base = np.array([[1., 2., 3., 4., 5., 6., np.NaN]]) + expected_base = np.array([[1., 2., 3., 4., 5., 6., np.nan]]) npt.assert_array_equal(np_arr[0].base, expected_base) np_arr_sliced = chunked_arr.slice(1, 3).to_numpy() - expected = np.array([[3, 4, 5], None, [6, np.NaN]], dtype="object") + expected = np.array([[3, 4, 5], None, [6, np.nan]], dtype="object") for left, right in zip(np_arr_sliced, expected): if right is None: assert left == right else: npt.assert_array_equal(left, right) - expected_base = np.array([[3., 4., 5., 6., np.NaN]]) + expected_base = np.array([[3., 4., 5., 6., np.nan]]) npt.assert_array_equal(np_arr_sliced[0].base, expected_base) def test_list_values_behind_null(self): @@ -2471,7 +2479,7 @@ def test_list_values_behind_null(self): ) np_arr = arr.to_numpy(zero_copy_only=False) - expected = np.array([[1., 2.], None, [3., np.NaN]], dtype="object") + expected = np.array([[1., 2.], None, [3., np.nan]], dtype="object") for left, right in zip(np_arr, expected): if right is None: assert left == right diff --git a/python/pyarrow/tests/test_scalars.py b/python/pyarrow/tests/test_scalars.py index 8a1dcfb057f74..1d8d77f50dac8 100644 --- a/python/pyarrow/tests/test_scalars.py +++ b/python/pyarrow/tests/test_scalars.py @@ -204,7 +204,9 @@ def test_numerics(): # float16 s = pa.scalar(np.float16(0.5), type='float16') assert isinstance(s, pa.HalfFloatScalar) - assert repr(s) == "" + # on numpy2 repr(np.float16(0.5)) == "np.float16(0.5)" + # on numpy1 repr(np.float16(0.5)) == "0.5" + assert repr(s) == f"" assert str(s) == "0.5" assert s.as_py() == 0.5 diff --git a/python/pyarrow/tests/test_table.py b/python/pyarrow/tests/test_table.py index f93c6bbc2c204..b9e0d692196fb 100644 --- a/python/pyarrow/tests/test_table.py +++ b/python/pyarrow/tests/test_table.py @@ -2175,6 +2175,21 @@ def sorted_by_keys(d): } +@pytest.mark.acero +def test_table_group_by_first(): + # "first" is an ordered aggregation -> requires to specify use_threads=False + table1 = pa.table({'a': [1, 2, 3, 4], 'b': ['a', 'b'] * 2}) + table2 = pa.table({'a': [1, 2, 3, 4], 'b': ['b', 'a'] * 2}) + table = pa.concat_tables([table1, table2]) + + with pytest.raises(NotImplementedError): + table.group_by("b").aggregate([("a", "first")]) + + result = table.group_by("b", use_threads=False).aggregate([("a", "first")]) + expected = pa.table({"b": ["a", "b"], "a_first": [1, 2]}) + assert result.equals(expected) + + def test_table_to_recordbatchreader(): table = pa.Table.from_pydict({'x': [1, 2, 3]}) reader = table.to_reader() diff --git a/python/pyarrow/tests/test_types.py b/python/pyarrow/tests/test_types.py index f3b6001003d9c..660765f3361ae 100644 --- a/python/pyarrow/tests/test_types.py +++ b/python/pyarrow/tests/test_types.py @@ -1184,6 +1184,7 @@ def test_is_boolean_value(): assert pa.types.is_boolean_value(np.bool_(False)) +@h.settings(suppress_health_check=(h.HealthCheck.too_slow,)) @h.given( past.all_types | past.all_fields | diff --git a/python/pyarrow/tests/util.py b/python/pyarrow/tests/util.py index 0b69deb73ba28..638eee9807335 100644 --- a/python/pyarrow/tests/util.py +++ b/python/pyarrow/tests/util.py @@ -455,5 +455,11 @@ def windows_has_tzdata(): This is the default location where tz.cpp will look for (until we make this configurable at run-time) """ - tzdata_path = os.path.expandvars(r"%USERPROFILE%\Downloads\tzdata") - return os.path.exists(tzdata_path) + tzdata_bool = False + if "PYARROW_TZDATA_PATH" in os.environ: + tzdata_bool = os.path.exists(os.environ['PYARROW_TZDATA_PATH']) + if not tzdata_bool: + tzdata_path = os.path.expandvars(r"%USERPROFILE%\Downloads\tzdata") + tzdata_bool = os.path.exists(tzdata_path) + + return tzdata_bool diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi index 9f8b347d56294..bd34726adb0db 100644 --- a/python/pyarrow/types.pxi +++ b/python/pyarrow/types.pxi @@ -1558,7 +1558,7 @@ cdef class FixedShapeTensorType(BaseExtensionType): >>> import pyarrow as pa >>> pa.fixed_shape_tensor(pa.int32(), [2, 2]) - FixedShapeTensorType(extension) + FixedShapeTensorType(extension) Create an instance of fixed shape tensor extension type with permutation: @@ -4746,7 +4746,7 @@ def fixed_shape_tensor(DataType value_type, shape, dim_names=None, permutation=N >>> import pyarrow as pa >>> tensor_type = pa.fixed_shape_tensor(pa.int32(), [2, 2]) >>> tensor_type - FixedShapeTensorType(extension) + FixedShapeTensorType(extension) Inspect the data type: @@ -4762,7 +4762,7 @@ def fixed_shape_tensor(DataType value_type, shape, dim_names=None, permutation=N >>> tensor = pa.ExtensionArray.from_storage(tensor_type, storage) >>> pa.table([tensor], names=["tensor_array"]) pyarrow.Table - tensor_array: extension + tensor_array: extension ---- tensor_array: [[[1,2,3,4],[10,20,30,40],[100,200,300,400]]] diff --git a/python/pyproject.toml b/python/pyproject.toml index a1de6ac4f1c7e..437de105ab8e7 100644 --- a/python/pyproject.toml +++ b/python/pyproject.toml @@ -17,7 +17,7 @@ [build-system] requires = [ - "cython >= 0.29.31,<3", + "cython >= 0.29.31", "oldest-supported-numpy>=0.14", "setuptools_scm < 8.0.0", "setuptools >= 40.1.0", diff --git a/python/requirements-build.txt b/python/requirements-build.txt index efd653ec470d5..56e9d479ee9ba 100644 --- a/python/requirements-build.txt +++ b/python/requirements-build.txt @@ -1,4 +1,4 @@ -cython>=0.29.31,<3 +cython>=0.29.31 oldest-supported-numpy>=0.14 setuptools_scm<8.0.0 setuptools>=38.6.0 diff --git a/python/requirements-wheel-build.txt b/python/requirements-wheel-build.txt index 00504b0c731a1..f42ee4a018f3c 100644 --- a/python/requirements-wheel-build.txt +++ b/python/requirements-wheel-build.txt @@ -1,4 +1,4 @@ -cython>=0.29.31,<3 +cython>=0.29.31 oldest-supported-numpy>=0.14 setuptools_scm<8.0.0 setuptools>=58 diff --git a/python/setup.py b/python/setup.py index 062aac307b1e4..6934161fe6d2c 100755 --- a/python/setup.py +++ b/python/setup.py @@ -40,9 +40,9 @@ # Check if we're running 64-bit Python is_64_bit = sys.maxsize > 2**32 -if Cython.__version__ < '0.29.31' or Cython.__version__ >= '3.0': +if Cython.__version__ < '0.29.31': raise Exception( - 'Please update your Cython version. Supported Cython >= 0.29.31, < 3.0') + 'Please update your Cython version. Supported Cython >= 0.29.31') setup_dir = os.path.abspath(os.path.dirname(__file__)) @@ -492,7 +492,7 @@ def has_ext_modules(foo): 'pyarrow/_generated_version.py'), 'version_scheme': guess_next_dev_version }, - setup_requires=['setuptools_scm < 8.0.0', 'cython >= 0.29.31,<3'] + setup_requires, + setup_requires=['setuptools_scm < 8.0.0', 'cython >= 0.29.31'] + setup_requires, install_requires=install_requires, tests_require=['pytest', 'pandas', 'hypothesis'], python_requires='>=3.8', diff --git a/r/.Rbuildignore b/r/.Rbuildignore index b8f768a8372b6..f5eeba4117454 100644 --- a/r/.Rbuildignore +++ b/r/.Rbuildignore @@ -20,8 +20,6 @@ clang_format.sh ^Makefile$ ^.*\.orig$ ^.*\.cmd$ -^autobrew$ -^apache-arrow.rb$ ^.*\.Rhistory$ ^extra-tests STYLE.md diff --git a/r/NAMESPACE b/r/NAMESPACE index d49255f781f94..b675952d01a30 100644 --- a/r/NAMESPACE +++ b/r/NAMESPACE @@ -308,6 +308,10 @@ export(contains) export(copy_files) export(cpu_count) export(create_package_with_all_dependencies) +export(csv_convert_options) +export(csv_parse_options) +export(csv_read_options) +export(csv_write_options) export(dataset_factory) export(date32) export(date64) diff --git a/r/PACKAGING.md b/r/PACKAGING.md index edfca651e9d38..64423b4d8eb9b 100644 --- a/r/PACKAGING.md +++ b/r/PACKAGING.md @@ -38,32 +38,8 @@ For a high-level overview of the release process see the Wait for the release candidate to be cut: ## After release candidate has been cut -- [ ] Create a CRAN-release branch from the release candidate commit -## Optional: PRs for autobrew and rtools (release candidate) - -Make pull requests into the [autobrew](https://github.com/autobrew) and -[rtools-packages](https://github.com/r-windows/rtools-packages) repositories -used by the configure script on MacOS and Windows. These pull requests will -use the release candidate as the source. - -- [ ] Pull request to modify - [the apache-arrow autobrew formula]( https://github.com/autobrew/homebrew-core/blob/high-sierra/Formula/apache-arrow.rb) - to update the release version, SHA256 checksum of the release source file (which can be found in the same directory as the release source file), and any changes to dependencies and build steps that have changed in the - [copy of the formula we have of that formula in the Arrow repo](https://github.com/apache/arrow/blob/main/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb) -- [ ] Pull request to modify - [the apache-arrow-static autobrew formula](https://github.com/autobrew/homebrew-cran/blob/master/Formula/apache-arrow-static.rb) - to update the version, SHA, and any changes to dependencies and build steps that have changed in the - [copy of the formula we have of that formula in the Arrow repo](https://github.com/apache/arrow/blob/main/dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb) -- [ ] Pull request to modify the - [autobrew script](https://github.com/autobrew/scripts/blob/master/apache-arrow) - to include any additions made to - [r/tools/autobrew](https://github.com/apache/arrow/blob/main/r/tools/autobrew). -- [ ] Pull request to modify the - [RTools PKGBUILD script](https://github.com/r-windows/rtools-packages/blob/master/mingw-w64-arrow/PKGBUILD) - to reflect changes in - [ci/PKGBUILD](https://github.com/apache/arrow/blob/main/ci/scripts/PKGBUILD), - uncommenting the line that says "uncomment to test the rc". +- [ ] Create a CRAN-release branch from the release candidate commit ## Prepare and check the .tar.gz that will be released to CRAN. @@ -77,19 +53,11 @@ use the release candidate as the source. - [ ] Run reverse dependency checks using `archery docker run r-revdepcheck`. ## Release vote -- [ ] Release vote passed! - -## PRs for autobrew and rtools (official release) -Create new autobrew and r-windows PRs such that they use the *release* -instead of the *release candidate*: - -- [ ] PR into autobrew/homebrew-core (apache-arrow autobrew formula) -- [ ] PR into autobrew/homebrew-core (apache-arrow-static autobrew formula) -- [ ] PR into autobrew/scripts -- [ ] PR into r-windows/rtools-packages +- [ ] Release vote passed! ## Generate R package to submit to CRAN + - [ ] If the release candidate commit updated, rebase the CRAN release branch on that commit. - [ ] Pick any commits that were made to main since the release commit that @@ -107,6 +75,7 @@ Ensure linux binary packages are available: https://apache.jfrog.io/ui/repos/tree/General/arrow/r ## Check binary Arrow C++ distributions specific to the R package + - [ ] Upload the .tar.gz to [win-builder](https://win-builder.r-project.org/upload.aspx) (r-devel only) and confirm (with Nic, who will automatically receive an email about the results) that the check is clean. This step cannot be completed before Jeroen has put the binaries in the MinGW repository, i.e. [here](https://ftp.opencpu.org/rtools/ucrt64/), [here](https://ftp.opencpu.org/rtools/mingw64/), and [here](https://ftp.opencpu.org/rtools/mingw32/). diff --git a/r/R/arrow-package.R b/r/R/arrow-package.R index 09183250ba3e0..8655bf5a1cc68 100644 --- a/r/R/arrow-package.R +++ b/r/R/arrow-package.R @@ -183,7 +183,7 @@ configure_tzdb <- function() { # Just to be extra safe, let's wrap this in a try(); # we don't want a failed startup message to prevent the package from loading try({ - # On MacOS only, Check if we are running in under emulation, and warn this will not work + # On MacOS only, Check if we are running in under emulation, and warn this will not work if (on_rosetta()) { packageStartupMessage( paste( @@ -242,8 +242,9 @@ on_macos_10_13_or_lower <- function() { } on_rosetta <- function() { + # make sure to suppress warnings and ignore the stdout + stderr so that this is silent identical(tolower(Sys.info()[["sysname"]]), "darwin") && - identical(system("sysctl -n sysctl.proc_translated", intern = TRUE), "1") + identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)), "1") } option_use_threads <- function() { diff --git a/r/R/csv.R b/r/R/csv.R index 116c620f83490..e68a05720da64 100644 --- a/r/R/csv.R +++ b/r/R/csv.R @@ -122,11 +122,11 @@ #' - `NULL`: the default, which uses the ISO-8601 parser #' - a character vector of [strptime][base::strptime()] parse strings #' - a list of [TimestampParser] objects -#' @param parse_options see [file reader options][CsvReadOptions]. +#' @param parse_options see [CSV parsing options][csv_parse_options()]. #' If given, this overrides any #' parsing options provided in other arguments (e.g. `delim`, `quote`, etc.). -#' @param convert_options see [file reader options][CsvReadOptions] -#' @param read_options see [file reader options][CsvReadOptions] +#' @param convert_options see [CSV conversion options][csv_convert_options()] +#' @param read_options see [CSV reading options][csv_read_options()] #' @param as_data_frame Should the function return a `tibble` (default) or #' an Arrow [Table]? #' @@ -337,22 +337,22 @@ CsvTableReader <- R6Class("CsvTableReader", ) ) CsvTableReader$create <- function(file, - read_options = CsvReadOptions$create(), - parse_options = CsvParseOptions$create(), - convert_options = CsvConvertOptions$create(), + read_options = csv_read_options(), + parse_options = csv_parse_options(), + convert_options = csv_convert_options(), ...) { assert_is(file, "InputStream") if (is.list(read_options)) { - read_options <- do.call(CsvReadOptions$create, read_options) + read_options <- do.call(csv_read_options, read_options) } if (is.list(parse_options)) { - parse_options <- do.call(CsvParseOptions$create, parse_options) + parse_options <- do.call(csv_parse_options, parse_options) } if (is.list(convert_options)) { - convert_options <- do.call(CsvConvertOptions$create, convert_options) + convert_options <- do.call(csv_convert_options, convert_options) } if (!(tolower(read_options$encoding) %in% c("utf-8", "utf8"))) { @@ -362,6 +362,58 @@ CsvTableReader$create <- function(file, csv___TableReader__Make(file, read_options, parse_options, convert_options) } +#' CSV Reading Options +#' +#' @param use_threads Whether to use the global CPU thread pool +#' @param block_size Block size we request from the IO layer; also determines +#' the size of chunks when use_threads is `TRUE`. +#' @param skip_rows Number of lines to skip before reading data (default 0). +#' @param column_names Character vector to supply column names. If length-0 +#' (the default), the first non-skipped row will be parsed to generate column +#' names, unless `autogenerate_column_names` is `TRUE`. +#' @param autogenerate_column_names Logical: generate column names instead of +#' using the first non-skipped row (the default)? If `TRUE`, column names will +#' be "f0", "f1", ..., "fN". +#' @param encoding The file encoding. (default `"UTF-8"`) +#' @param skip_rows_after_names Number of lines to skip after the column names (default 0). +#' This number can be larger than the number of rows in one block, and empty rows are counted. +#' The order of application is as follows: +#' - `skip_rows` is applied (if non-zero); +#' - column names are read (unless `column_names` is set); +#' - `skip_rows_after_names` is applied (if non-zero). +#' +#' @examples +#' tf <- tempfile() +#' on.exit(unlink(tf)) +#' writeLines("my file has a non-data header\nx\n1\n2", tf) +#' read_csv_arrow(tf, read_options = csv_read_options(skip_rows = 1)) +#' open_csv_dataset(tf, read_options = csv_read_options(skip_rows = 1)) +#' @export +csv_read_options <- function(use_threads = option_use_threads(), + block_size = 1048576L, + skip_rows = 0L, + column_names = character(0), + autogenerate_column_names = FALSE, + encoding = "UTF-8", + skip_rows_after_names = 0L) { + assert_that(is.string(encoding)) + + options <- csv___ReadOptions__initialize( + list( + use_threads = use_threads, + block_size = block_size, + skip_rows = skip_rows, + skip_rows_after_names = skip_rows_after_names, + column_names = column_names, + autogenerate_column_names = autogenerate_column_names + ) + ) + + options$encoding <- encoding + + options +} + #' @title File reader options #' @rdname CsvReadOptions #' @name CsvReadOptions @@ -455,6 +507,11 @@ CsvTableReader$create <- function(file, #' - `batch_size` Maximum number of rows processed at a time. Default is 1024. #' - `null_string` The string to be written for null values. Must not contain #' quotation marks. Default is an empty string (`""`). +#' - `eol` The end of line character to use for ending rows. +#' - `delimiter` Field delimiter +#' - `quoting_style` Quoting style: "Needed" (Only enclose values in quotes which need them, because their CSV +#' rendering can contain quotes itself (e.g. strings or binary values)), "AllValid" (Enclose all valid values in +#' quotes), or "None" (Do not enclose any values in quotes). #' #' @section Active bindings: #' @@ -485,30 +542,8 @@ CsvReadOptions <- R6Class("CsvReadOptions", skip_rows_after_names = function() csv___ReadOptions__skip_rows_after_names(self) ) ) -CsvReadOptions$create <- function(use_threads = option_use_threads(), - block_size = 1048576L, - skip_rows = 0L, - column_names = character(0), - autogenerate_column_names = FALSE, - encoding = "UTF-8", - skip_rows_after_names = 0L) { - assert_that(is.string(encoding)) - options <- csv___ReadOptions__initialize( - list( - use_threads = use_threads, - block_size = block_size, - skip_rows = skip_rows, - skip_rows_after_names = skip_rows_after_names, - column_names = column_names, - autogenerate_column_names = autogenerate_column_names - ) - ) - - options$encoding <- encoding - - options -} +CsvReadOptions$create <- csv_read_options readr_to_csv_write_options <- function(col_names = TRUE, batch_size = 1024L, @@ -520,7 +555,7 @@ readr_to_csv_write_options <- function(col_names = TRUE, quote <- match(match.arg(quote), c("needed", "all", "none")) quote <- quoting_style_arrow_opts[quote] - CsvWriteOptions$create( + csv_write_options( include_header = col_names, batch_size = batch_size, delimiter = delim, @@ -530,15 +565,28 @@ readr_to_csv_write_options <- function(col_names = TRUE, ) } -#' @rdname CsvReadOptions +#' CSV Writing Options +#' +#' @param include_header Whether to write an initial header line with column names +#' @param batch_size Maximum number of rows processed at a time. +#' @param null_string The string to be written for null values. Must not contain quotation marks. +#' @param delimiter Field delimiter +#' @param eol The end of line character to use for ending rows +#' @param quoting_style How to handle quotes. "Needed" (Only enclose values in quotes which need them, because their CSV +#' rendering can contain quotes itself (e.g. strings or binary values)), "AllValid" (Enclose all valid values in +#' quotes), or "None" (Do not enclose any values in quotes). +#' +#' @examples +#' tf <- tempfile() +#' on.exit(unlink(tf)) +#' write_csv_arrow(airquality, tf, write_options = csv_write_options(null_string = "-99")) #' @export -CsvWriteOptions <- R6Class("CsvWriteOptions", inherit = ArrowObject) -CsvWriteOptions$create <- function(include_header = TRUE, - batch_size = 1024L, - null_string = "", - delimiter = ",", - eol = "\n", - quoting_style = c("Needed", "AllValid", "None")) { +csv_write_options <- function(include_header = TRUE, + batch_size = 1024L, + null_string = "", + delimiter = ",", + eol = "\n", + quoting_style = c("Needed", "AllValid", "None")) { quoting_style <- match.arg(quoting_style) quoting_style_opts <- c("Needed", "AllValid", "None") quoting_style <- match(quoting_style, quoting_style_opts) - 1L @@ -564,32 +612,50 @@ CsvWriteOptions$create <- function(include_header = TRUE, ) } +#' @rdname CsvReadOptions +#' @export +CsvWriteOptions <- R6Class("CsvWriteOptions", inherit = ArrowObject) +CsvWriteOptions$create <- csv_write_options + readr_to_csv_read_options <- function(skip = 0, col_names = TRUE) { if (isTRUE(col_names)) { # C++ default to parse is 0-length string array col_names <- character(0) } if (identical(col_names, FALSE)) { - CsvReadOptions$create(skip_rows = skip, autogenerate_column_names = TRUE) + csv_read_options(skip_rows = skip, autogenerate_column_names = TRUE) } else { - CsvReadOptions$create(skip_rows = skip, column_names = col_names) + csv_read_options(skip_rows = skip, column_names = col_names) } } -#' @rdname CsvReadOptions -#' @usage NULL -#' @format NULL -#' @docType class +#' CSV Parsing Options +#' +#' @param delimiter Field delimiting character +#' @param quoting Logical: are strings quoted? +#' @param quote_char Quoting character, if `quoting` is `TRUE` +#' @param double_quote Logical: are quotes inside values double-quoted? +#' @param escaping Logical: whether escaping is used +#' @param escape_char Escaping character, if `escaping` is `TRUE` +#' @param newlines_in_values Logical: are values allowed to contain CR (`0x0d`) +#' and LF (`0x0a`) characters? +#' @param ignore_empty_lines Logical: should empty lines be ignored (default) or +#' generate a row of missing values (if `FALSE`)? +#' @examples +#' tf <- tempfile() +#' on.exit(unlink(tf)) +#' writeLines("x\n1\n\n2", tf) +#' read_csv_arrow(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE)) +#' open_csv_dataset(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE)) #' @export -CsvParseOptions <- R6Class("CsvParseOptions", inherit = ArrowObject) -CsvParseOptions$create <- function(delimiter = ",", - quoting = TRUE, - quote_char = '"', - double_quote = TRUE, - escaping = FALSE, - escape_char = "\\", - newlines_in_values = FALSE, - ignore_empty_lines = TRUE) { +csv_parse_options <- function(delimiter = ",", + quoting = TRUE, + quote_char = '"', + double_quote = TRUE, + escaping = FALSE, + escape_char = "\\", + newlines_in_values = FALSE, + ignore_empty_lines = TRUE) { csv___ParseOptions__initialize( list( delimiter = delimiter, @@ -604,6 +670,14 @@ CsvParseOptions$create <- function(delimiter = ",", ) } +#' @rdname CsvReadOptions +#' @usage NULL +#' @format NULL +#' @docType class +#' @export +CsvParseOptions <- R6Class("CsvParseOptions", inherit = ArrowObject) +CsvParseOptions$create <- csv_parse_options + readr_to_csv_parse_options <- function(delim = ",", quote = '"', escape_double = TRUE, @@ -611,7 +685,7 @@ readr_to_csv_parse_options <- function(delim = ",", skip_empty_rows = TRUE) { # This function translates from the readr argument list to the arrow arg names # TODO: validate inputs - CsvParseOptions$create( + csv_parse_options( delimiter = delim, quoting = nzchar(quote), quote_char = quote, @@ -643,23 +717,55 @@ TimestampParser$create <- function(format = NULL) { } } -#' @rdname CsvReadOptions -#' @usage NULL -#' @format NULL -#' @docType class + +#' CSV Convert Options +#' +#' @param check_utf8 Logical: check UTF8 validity of string columns? +#' @param null_values Character vector of recognized spellings for null values. +#' Analogous to the `na.strings` argument to +#' [`read.csv()`][utils::read.csv()] or `na` in [readr::read_csv()]. +#' @param strings_can_be_null Logical: can string / binary columns have +#' null values? Similar to the `quoted_na` argument to [readr::read_csv()] +#' @param true_values Character vector of recognized spellings for `TRUE` values +#' @param false_values Character vector of recognized spellings for `FALSE` values +#' @param col_types A `Schema` or `NULL` to infer types +#' @param auto_dict_encode Logical: Whether to try to automatically +#' dictionary-encode string / binary data (think `stringsAsFactors`). +#' This setting is ignored for non-inferred columns (those in `col_types`). +#' @param auto_dict_max_cardinality If `auto_dict_encode`, string/binary columns +#' are dictionary-encoded up to this number of unique values (default 50), +#' after which it switches to regular encoding. +#' @param include_columns If non-empty, indicates the names of columns from the +#' CSV file that should be actually read and converted (in the vector's order). +#' @param include_missing_columns Logical: if `include_columns` is provided, should +#' columns named in it but not found in the data be included as a column of +#' type `null()`? The default (`FALSE`) means that the reader will instead +#' raise an error. +#' @param timestamp_parsers User-defined timestamp parsers. If more than one +#' parser is specified, the CSV conversion logic will try parsing values +#' starting from the beginning of this vector. Possible values are +#' (a) `NULL`, the default, which uses the ISO-8601 parser; +#' (b) a character vector of [strptime][base::strptime()] parse strings; or +#' (c) a list of [TimestampParser] objects. +#' +#' @examples +#' tf <- tempfile() +#' on.exit(unlink(tf)) +#' writeLines("x\n1\nNULL\n2\nNA", tf) +#' read_csv_arrow(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL"))) +#' open_csv_dataset(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL"))) #' @export -CsvConvertOptions <- R6Class("CsvConvertOptions", inherit = ArrowObject) -CsvConvertOptions$create <- function(check_utf8 = TRUE, - null_values = c("", "NA"), - true_values = c("T", "true", "TRUE"), - false_values = c("F", "false", "FALSE"), - strings_can_be_null = FALSE, - col_types = NULL, - auto_dict_encode = FALSE, - auto_dict_max_cardinality = 50L, - include_columns = character(), - include_missing_columns = FALSE, - timestamp_parsers = NULL) { +csv_convert_options <- function(check_utf8 = TRUE, + null_values = c("", "NA"), + true_values = c("T", "true", "TRUE"), + false_values = c("F", "false", "FALSE"), + strings_can_be_null = FALSE, + col_types = NULL, + auto_dict_encode = FALSE, + auto_dict_max_cardinality = 50L, + include_columns = character(), + include_missing_columns = FALSE, + timestamp_parsers = NULL) { if (!is.null(col_types) && !inherits(col_types, "Schema")) { abort(c( "Unsupported `col_types` specification.", @@ -684,6 +790,14 @@ CsvConvertOptions$create <- function(check_utf8 = TRUE, ) } +#' @rdname CsvReadOptions +#' @usage NULL +#' @format NULL +#' @docType class +#' @export +CsvConvertOptions <- R6Class("CsvConvertOptions", inherit = ArrowObject) +CsvConvertOptions$create <- csv_convert_options + readr_to_csv_convert_options <- function(na, quoted_na, col_types = NULL, @@ -732,7 +846,7 @@ readr_to_csv_convert_options <- function(na, include_columns <- setdiff(col_names, names(col_types)[nulls]) } } - CsvConvertOptions$create( + csv_convert_options( null_values = na, strings_can_be_null = quoted_na, col_types = col_types, @@ -753,7 +867,7 @@ readr_to_csv_convert_options <- function(na, #' @param batch_size Maximum number of rows processed at a time. Default is 1024. #' @param na value to write for NA values. Must not contain quote marks. Default #' is `""`. -#' @param write_options see [file reader options][CsvWriteOptions] +#' @param write_options see [CSV write options][csv_write_options] #' @param ... additional parameters #' #' @return The input `x`, invisibly. Note that if `sink` is an [OutputStream], diff --git a/r/R/dataset-format.R b/r/R/dataset-format.R index cdaaf08827bfd..c25a505f89403 100644 --- a/r/R/dataset-format.R +++ b/r/R/dataset-format.R @@ -217,19 +217,19 @@ check_csv_file_format_args <- function(args, partitioning = NULL) { if (is.null(args$parse_options)) { options$parse_options <- do.call(csv_file_format_parse_opts, args) } else if (is.list(args$parse_options)) { - options$parse_options <- do.call(CsvParseOptions$create, args$parse_options) + options$parse_options <- do.call(csv_parse_options, args$parse_options) } if (is.null(args$convert_options)) { options$convert_options <- do.call(csv_file_format_convert_opts, args) } else if (is.list(args$convert_options)) { - options$convert_options <- do.call(CsvConvertOptions$create, args$convert_options) + options$convert_options <- do.call(csv_convert_options, args$convert_options) } if (is.null(args$read_options)) { options$read_options <- do.call(csv_file_format_read_opts, c(args, list(partitioning = partitioning))) } else if (is.list(args$read_options)) { - options$read_options <- do.call(CsvReadOptions$create, args$read_options) + options$read_options <- do.call(csv_read_options, args$read_options) } options @@ -239,16 +239,16 @@ check_unsupported_args <- function(args) { opt_names <- get_opt_names(args) # Filter out arguments meant for CsvConvertOptions/CsvReadOptions - supported_convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na") + supported_convert_opts <- c(names(formals(csv_convert_options)), "na", "quoted_na") supported_read_opts <- c( - names(formals(CsvReadOptions$create)), + names(formals(csv_read_options)), names(formals(readr_to_csv_read_options)) ) # We only currently support all of the readr options for parseoptions supported_parse_opts <- c( - names(formals(CsvParseOptions$create)), + names(formals(csv_parse_options)), names(formals(readr_to_csv_parse_options)) ) @@ -303,9 +303,9 @@ check_unrecognised_args <- function(opts) { opt_names <- get_opt_names(opts) arrow_opts <- c( - names(formals(CsvParseOptions$create)), - names(formals(CsvReadOptions$create)), - names(formals(CsvConvertOptions$create)), + names(formals(csv_parse_options)), + names(formals(csv_read_options)), + names(formals(csv_convert_options)), "schema" ) @@ -395,9 +395,9 @@ check_schema <- function(schema, partitioning, column_names) { csv_file_format_parse_opts <- function(...) { opts <- list(...) # Filter out arguments meant for CsvConvertOptions/CsvReadOptions - convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na", "convert_options") + convert_opts <- c(names(formals(csv_convert_options)), "na", "quoted_na", "convert_options") read_opts <- c( - names(formals(CsvReadOptions$create)), + names(formals(csv_read_options)), names(formals(readr_to_csv_read_options)), "read_options" ) @@ -407,7 +407,7 @@ csv_file_format_parse_opts <- function(...) { opts[["parse_options"]] <- NULL opt_names <- get_opt_names(opts) - arrow_opts <- c(names(formals(CsvParseOptions$create))) + arrow_opts <- c(names(formals(csv_parse_options))) readr_opts <- c(names(formals(readr_to_csv_parse_options))) is_arrow_opt <- !is.na(pmatch(opt_names, arrow_opts)) @@ -427,17 +427,17 @@ csv_file_format_parse_opts <- function(...) { } do.call(readr_to_csv_parse_options, opts) # all options have readr-style names } else { - do.call(CsvParseOptions$create, opts) # all options have Arrow C++ names + do.call(csv_parse_options, opts) # all options have Arrow C++ names } } csv_file_format_convert_opts <- function(...) { opts <- list(...) # Filter out arguments meant for CsvParseOptions/CsvReadOptions - arrow_opts <- c(names(formals(CsvParseOptions$create)), "parse_options") + arrow_opts <- c(names(formals(csv_parse_options)), "parse_options") readr_opts <- names(formals(readr_to_csv_parse_options)) read_opts <- c( - names(formals(CsvReadOptions$create)), + names(formals(csv_read_options)), names(formals(readr_to_csv_read_options)), "read_options" ) @@ -458,23 +458,23 @@ csv_file_format_convert_opts <- function(...) { opts[["quoted_na"]] <- NULL } - do.call(CsvConvertOptions$create, opts) + do.call(csv_convert_options, opts) } csv_file_format_read_opts <- function(schema = NULL, partitioning = NULL, ...) { opts <- list(...) # Filter out arguments meant for CsvParseOptions/CsvConvertOptions - arrow_opts <- c(names(formals(CsvParseOptions$create)), "parse_options") + arrow_opts <- c(names(formals(csv_parse_options)), "parse_options") readr_opts <- names(formals(readr_to_csv_parse_options)) - convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na", "convert_options") + convert_opts <- c(names(formals(csv_convert_options)), "na", "quoted_na", "convert_options") opts[arrow_opts] <- NULL opts[readr_opts] <- NULL opts[convert_opts] <- NULL opts[["read_options"]] <- NULL opt_names <- names(opts) - arrow_opts <- c(names(formals(CsvReadOptions$create))) + arrow_opts <- c(names(formals(csv_read_options))) readr_opts <- c(names(formals(readr_to_csv_read_options))) is_arrow_opt <- !is.na(match(opt_names, arrow_opts)) @@ -505,7 +505,7 @@ csv_file_format_read_opts <- function(schema = NULL, partitioning = NULL, ...) { } do.call(readr_to_csv_read_options, opts) # all options have readr-style names } else { - do.call(CsvReadOptions$create, opts) # all options have Arrow C++ names + do.call(csv_read_options, opts) # all options have Arrow C++ names } } @@ -648,7 +648,7 @@ FileWriteOptions <- R6Class("FileWriteOptions", ) } else if (format %in% c("csv", "tsv", "txt", "text")) { supported_args <- c( - names(formals(CsvWriteOptions$create)), + names(formals(csv_write_options)), names(formals(readr_to_csv_write_options)) ) } @@ -703,7 +703,7 @@ FileWriteOptions <- R6Class("FileWriteOptions", ) } } else if (self$type %in% c("csv", "tsv", "txt", "text")) { - arrow_opts <- names(formals(CsvWriteOptions$create)) + arrow_opts <- names(formals(csv_write_options)) readr_opts <- names(formals(readr_to_csv_write_options)) readr_only_opts <- setdiff(readr_opts, arrow_opts) arrow_only_opts <- setdiff(arrow_opts, readr_opts) @@ -727,7 +727,7 @@ FileWriteOptions <- R6Class("FileWriteOptions", } else { dataset___CsvFileWriteOptions__update( self, - do.call(CsvWriteOptions$create, args[is_arrow_opt]) + do.call(csv_write_options, args[is_arrow_opt]) ) } } diff --git a/r/R/dataset.R b/r/R/dataset.R index 9d91839c220bb..90e6516927e5d 100644 --- a/r/R/dataset.R +++ b/r/R/dataset.R @@ -276,7 +276,8 @@ open_delim_dataset <- function(sources, convert_options = NULL, read_options = NULL, timestamp_parsers = NULL, - quoted_na = TRUE) { + quoted_na = TRUE, + parse_options = NULL) { open_dataset( sources = sources, schema = schema, @@ -297,7 +298,8 @@ open_delim_dataset <- function(sources, convert_options = convert_options, read_options = read_options, timestamp_parsers = timestamp_parsers, - quoted_na = quoted_na + quoted_na = quoted_na, + parse_options = parse_options ) } @@ -320,7 +322,8 @@ open_csv_dataset <- function(sources, convert_options = NULL, read_options = NULL, timestamp_parsers = NULL, - quoted_na = TRUE) { + quoted_na = TRUE, + parse_options = NULL) { mc <- match.call() mc$delim <- "," mc[[1]] <- get("open_delim_dataset", envir = asNamespace("arrow")) @@ -346,7 +349,8 @@ open_tsv_dataset <- function(sources, convert_options = NULL, read_options = NULL, timestamp_parsers = NULL, - quoted_na = TRUE) { + quoted_na = TRUE, + parse_options = NULL) { mc <- match.call() mc$delim <- "\t" mc[[1]] <- get("open_delim_dataset", envir = asNamespace("arrow")) diff --git a/r/R/parquet.R b/r/R/parquet.R index a58f7810b6ec7..74f51767a29c4 100644 --- a/r/R/parquet.R +++ b/r/R/parquet.R @@ -22,6 +22,7 @@ #' #' @inheritParams read_feather #' @param props [ParquetArrowReaderProperties] +#' @param mmap Use TRUE to use memory mapping where possible #' @param ... Additional arguments passed to `ParquetFileReader$create()` #' #' @return A `tibble` if `as_data_frame` is `TRUE` (the default), or an @@ -43,14 +44,15 @@ read_parquet <- function(file, # Assembling `props` yourself is something you do with # ParquetFileReader but not here. props = ParquetArrowReaderProperties$create(), + mmap = TRUE, ...) { if (!inherits(file, "RandomAccessFile")) { # Compression is handled inside the parquet file format, so we don't need # to detect from the file extension and wrap in a CompressedInputStream - file <- make_readable_file(file) + file <- make_readable_file(file, mmap = mmap) on.exit(file$close()) } - reader <- ParquetFileReader$create(file, props = props, ...) + reader <- ParquetFileReader$create(file, props = props, mmap = mmap, ...) col_select <- enquo(col_select) if (!quo_is_null(col_select)) { diff --git a/r/_pkgdown.yml b/r/_pkgdown.yml index 57c21e3c0f2cb..84111e599c457 100644 --- a/r/_pkgdown.yml +++ b/r/_pkgdown.yml @@ -146,6 +146,10 @@ reference: - open_delim_dataset - open_csv_dataset - open_tsv_dataset + - csv_read_options + - csv_parse_options + - csv_convert_options + - title: Write datasets desc: > @@ -155,6 +159,7 @@ reference: - write_delim_dataset - write_csv_dataset - write_tsv_dataset + - csv_write_options - title: Read files desc: > diff --git a/r/configure b/r/configure index 593f60bbddad9..ced3b40a68901 100755 --- a/r/configure +++ b/r/configure @@ -39,8 +39,8 @@ # # * Installing a released version from source, as from CRAN, with # no other prior setup -# * On macOS, autobrew is used to retrieve libarrow and dependencies -# * On Linux, the nixlibs.R build script will download or build +# * On macOS and Linux, the nixlibs.R build script will download +# or build libarrow and dependencies # * Installing a released version but first installing libarrow. # It will use pkg-config and brew to search for libraries. # * Installing a development version from source as a user. @@ -65,8 +65,6 @@ PKG_TEST_HEADER="" # Some env vars that control the build (all logical, case insensitive) # Development mode, also increases verbosity in the bundled build ARROW_R_DEV=`echo $ARROW_R_DEV | tr '[:upper:]' '[:lower:]'` -# autobrew is how mac binaries are built on CRAN; FORCE ensures we use it here -FORCE_AUTOBREW=`echo $FORCE_AUTOBREW | tr '[:upper:]' '[:lower:]'` # The bundled build compiles arrow C++ from source; FORCE ensures we don't pick up # any other packages that may be found on the system FORCE_BUNDLED_BUILD=`echo $FORCE_BUNDLED_BUILD | tr '[:upper:]' '[:lower:]'` @@ -141,19 +139,11 @@ fi find_or_build_libarrow () { if [ "$FORCE_BUNDLED_BUILD" = "true" ]; then do_bundled_build - elif [ "$FORCE_AUTOBREW" = "true" ]; then - do_autobrew else find_arrow if [ "$_LIBARROW_FOUND" = "false" ]; then # If we haven't found a suitable version of libarrow, build it - if [ "$UNAME" = "Darwin" ] && ! echo $VERSION | grep -q "000"; then - # Only autobrew on release version (for testing, use FORCE_AUTOBREW above) - # (dev versions end in .9000, and nightly gets something like .10000xxx) - do_autobrew - else - do_bundled_build - fi + do_bundled_build fi fi } @@ -175,12 +165,6 @@ find_arrow () { # 2. Use pkg-config to find arrow on the system _LIBARROW_FOUND="`${PKG_CONFIG} --variable=prefix --silence-errors ${PKG_CONFIG_NAME}`" echo "*** Trying Arrow C++ found by pkg-config: $_LIBARROW_FOUND" - elif brew --prefix ${PKG_BREW_NAME} > /dev/null 2>&1; then - # 3. On macOS, look for Homebrew apache-arrow - # (note that if you have pkg-config, homebrew arrow may have already been found) - _LIBARROW_FOUND=`brew --prefix ${PKG_BREW_NAME}` - echo "*** Trying Arrow C++ found by Homebrew: ${_LIBARROW_FOUND}" - export PKG_CONFIG_PATH="${_LIBARROW_FOUND}/lib/pkgconfig${PKG_CONFIG_PATH:+:${PKG_CONFIG_PATH}}" else _LIBARROW_FOUND="false" fi @@ -247,34 +231,6 @@ do_bundled_build () { fi } -do_autobrew () { - echo "*** Downloading ${PKG_BREW_NAME}" - - # Setup for local autobrew testing - if [ -f "tools/apache-arrow.rb" ]; then - # If you want to use a local apache-arrow.rb formula, do - # $ cp ../dev/tasks/homebrew-formulae/autobrew/apache-arrow*.rb tools - # before R CMD build or INSTALL (assuming a local checkout of the apache/arrow repository). - # If you have this, you should use the local autobrew script so they match. - cp tools/autobrew . - fi - - if [ -f "autobrew" ]; then - echo "**** Using local manifest for ${PKG_BREW_NAME}" - else - if ! curl -sfL "https://autobrew.github.io/scripts/$PKG_BREW_NAME" > autobrew; then - echo "Failed to download manifest for ${PKG_BREW_NAME}" - # Fall back to the local copy - cp tools/autobrew . - fi - fi - if ! . autobrew; then - echo "Failed to retrieve binary for ${PKG_BREW_NAME}" - fi - # autobrew sets `PKG_LIBS`, `PKG_DIRS`, and `PKG_CFLAGS` - # TODO: move PKG_LIBS and PKG_CFLAGS out of autobrew and use set_pkg_vars -} - # Once libarrow is obtained, this function sets `PKG_LIBS`, `PKG_DIRS`, and `PKG_CFLAGS` # either from pkg-config or by inferring things about the directory in $1 set_pkg_vars () { @@ -298,6 +254,11 @@ set_pkg_vars () { if [ "$ARROW_R_CXXFLAGS" ]; then PKG_CFLAGS="$PKG_CFLAGS $ARROW_R_CXXFLAGS" fi + + if [ "$UNAME" = "Darwin" ] && expr $(sw_vers -productVersion) : '10\.13'; then + # avoid C++17 availability warnings on macOS < 11 + PKG_CFLAGS="$PKG_CFLAGS -D_LIBCPP_DISABLE_AVAILABILITY" + fi } # If we have pkg-config, it will tell us what libarrow needs @@ -412,8 +373,6 @@ find_or_build_libarrow # We should have a valid libarrow build in $_LIBARROW_FOUND # Now set `PKG_LIBS`, `PKG_DIRS`, and `PKG_CFLAGS` based on that. -# _LIBARROW_FOUND should only be unset in the FORCE_AUTOBREW case, -# and autobrew sets its own PKG_* vars. (See the TODO about changing that.) if [ "$_LIBARROW_FOUND" != "false" ] && [ "$_LIBARROW_FOUND" != "" ]; then set_pkg_vars ${_LIBARROW_FOUND} fi diff --git a/r/man/CsvReadOptions.Rd b/r/man/CsvReadOptions.Rd index 6ebb2355184c1..32742280cc4d9 100644 --- a/r/man/CsvReadOptions.Rd +++ b/r/man/CsvReadOptions.Rd @@ -106,6 +106,11 @@ The \code{CsvWriteOptions$create()} factory method takes the following arguments \item \code{batch_size} Maximum number of rows processed at a time. Default is 1024. \item \code{null_string} The string to be written for null values. Must not contain quotation marks. Default is an empty string (\code{""}). +\item \code{eol} The end of line character to use for ending rows. +\item \code{delimiter} Field delimiter +\item \code{quoting_style} Quoting style: "Needed" (Only enclose values in quotes which need them, because their CSV +rendering can contain quotes itself (e.g. strings or binary values)), "AllValid" (Enclose all valid values in +quotes), or "None" (Do not enclose any values in quotes). } } diff --git a/r/man/csv_convert_options.Rd b/r/man/csv_convert_options.Rd new file mode 100644 index 0000000000000..4fd6eac1c3e82 --- /dev/null +++ b/r/man/csv_convert_options.Rd @@ -0,0 +1,69 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/csv.R +\name{csv_convert_options} +\alias{csv_convert_options} +\title{CSV Convert Options} +\usage{ +csv_convert_options( + check_utf8 = TRUE, + null_values = c("", "NA"), + true_values = c("T", "true", "TRUE"), + false_values = c("F", "false", "FALSE"), + strings_can_be_null = FALSE, + col_types = NULL, + auto_dict_encode = FALSE, + auto_dict_max_cardinality = 50L, + include_columns = character(), + include_missing_columns = FALSE, + timestamp_parsers = NULL +) +} +\arguments{ +\item{check_utf8}{Logical: check UTF8 validity of string columns?} + +\item{null_values}{Character vector of recognized spellings for null values. +Analogous to the \code{na.strings} argument to +\code{\link[utils:read.table]{read.csv()}} or \code{na} in \code{\link[readr:read_delim]{readr::read_csv()}}.} + +\item{true_values}{Character vector of recognized spellings for \code{TRUE} values} + +\item{false_values}{Character vector of recognized spellings for \code{FALSE} values} + +\item{strings_can_be_null}{Logical: can string / binary columns have +null values? Similar to the \code{quoted_na} argument to \code{\link[readr:read_delim]{readr::read_csv()}}} + +\item{col_types}{A \code{Schema} or \code{NULL} to infer types} + +\item{auto_dict_encode}{Logical: Whether to try to automatically +dictionary-encode string / binary data (think \code{stringsAsFactors}). +This setting is ignored for non-inferred columns (those in \code{col_types}).} + +\item{auto_dict_max_cardinality}{If \code{auto_dict_encode}, string/binary columns +are dictionary-encoded up to this number of unique values (default 50), +after which it switches to regular encoding.} + +\item{include_columns}{If non-empty, indicates the names of columns from the +CSV file that should be actually read and converted (in the vector's order).} + +\item{include_missing_columns}{Logical: if \code{include_columns} is provided, should +columns named in it but not found in the data be included as a column of +type \code{null()}? The default (\code{FALSE}) means that the reader will instead +raise an error.} + +\item{timestamp_parsers}{User-defined timestamp parsers. If more than one +parser is specified, the CSV conversion logic will try parsing values +starting from the beginning of this vector. Possible values are +(a) \code{NULL}, the default, which uses the ISO-8601 parser; +(b) a character vector of \link[base:strptime]{strptime} parse strings; or +(c) a list of \link{TimestampParser} objects.} +} +\description{ +CSV Convert Options +} +\examples{ +tf <- tempfile() +on.exit(unlink(tf)) +writeLines('x\n1\nNULL\n2\nNA', tf) +read_csv_arrow(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL"))) +open_csv_dataset(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL"))) +} diff --git a/r/man/csv_parse_options.Rd b/r/man/csv_parse_options.Rd new file mode 100644 index 0000000000000..e2e8fd19a5916 --- /dev/null +++ b/r/man/csv_parse_options.Rd @@ -0,0 +1,46 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/csv.R +\name{csv_parse_options} +\alias{csv_parse_options} +\title{CSV Parsing Options} +\usage{ +csv_parse_options( + delimiter = ",", + quoting = TRUE, + quote_char = "\\"", + double_quote = TRUE, + escaping = FALSE, + escape_char = "\\\\", + newlines_in_values = FALSE, + ignore_empty_lines = TRUE +) +} +\arguments{ +\item{delimiter}{Field delimiting character} + +\item{quoting}{Logical: are strings quoted?} + +\item{quote_char}{Quoting character, if \code{quoting} is \code{TRUE}} + +\item{double_quote}{Logical: are quotes inside values double-quoted?} + +\item{escaping}{Logical: whether escaping is used} + +\item{escape_char}{Escaping character, if \code{escaping} is \code{TRUE}} + +\item{newlines_in_values}{Logical: are values allowed to contain CR (\code{0x0d}) +and LF (\code{0x0a}) characters?} + +\item{ignore_empty_lines}{Logical: should empty lines be ignored (default) or +generate a row of missing values (if \code{FALSE})?} +} +\description{ +CSV Parsing Options +} +\examples{ +tf <- tempfile() +on.exit(unlink(tf)) +writeLines('x\n1\n\n2', tf) +read_csv_arrow(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE)) +open_csv_dataset(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE)) +} diff --git a/r/man/csv_read_options.Rd b/r/man/csv_read_options.Rd new file mode 100644 index 0000000000000..ed2436f316f57 --- /dev/null +++ b/r/man/csv_read_options.Rd @@ -0,0 +1,51 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/csv.R +\name{csv_read_options} +\alias{csv_read_options} +\title{CSV Reading Options} +\usage{ +csv_read_options( + use_threads = option_use_threads(), + block_size = 1048576L, + skip_rows = 0L, + column_names = character(0), + autogenerate_column_names = FALSE, + encoding = "UTF-8", + skip_rows_after_names = 0L +) +} +\arguments{ +\item{use_threads}{Whether to use the global CPU thread pool} + +\item{block_size}{Block size we request from the IO layer; also determines +the size of chunks when use_threads is \code{TRUE}.} + +\item{skip_rows}{Number of lines to skip before reading data (default 0).} + +\item{column_names}{Character vector to supply column names. If length-0 +(the default), the first non-skipped row will be parsed to generate column +names, unless \code{autogenerate_column_names} is \code{TRUE}.} + +\item{autogenerate_column_names}{Logical: generate column names instead of +using the first non-skipped row (the default)? If \code{TRUE}, column names will +be "f0", "f1", ..., "fN".} + +\item{encoding}{The file encoding. (default \code{"UTF-8"})} + +\item{skip_rows_after_names}{Number of lines to skip after the column names (default 0). +This number can be larger than the number of rows in one block, and empty rows are counted. +The order of application is as follows: +- \code{skip_rows} is applied (if non-zero); +- column names are read (unless \code{column_names} is set); +- \code{skip_rows_after_names} is applied (if non-zero).} +} +\description{ +CSV Reading Options +} +\examples{ +tf <- tempfile() +on.exit(unlink(tf)) +writeLines('my file has a non-data header\nx\n1\n2', tf) +read_csv_arrow(tf, read_options = csv_read_options(skip_rows = 1)) +open_csv_dataset(tf, read_options = csv_read_options(skip_rows = 1)) +} diff --git a/r/man/csv_write_options.Rd b/r/man/csv_write_options.Rd new file mode 100644 index 0000000000000..a42905dd18d3a --- /dev/null +++ b/r/man/csv_write_options.Rd @@ -0,0 +1,38 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/csv.R +\name{csv_write_options} +\alias{csv_write_options} +\title{CSV Writing Options} +\usage{ +csv_write_options( + include_header = TRUE, + batch_size = 1024L, + null_string = "", + delimiter = ",", + eol = "\\n", + quoting_style = c("Needed", "AllValid", "None") +) +} +\arguments{ +\item{include_header}{Whether to write an initial header line with column names} + +\item{batch_size}{Maximum number of rows processed at a time.} + +\item{null_string}{The string to be written for null values. Must not contain quotation marks.} + +\item{delimiter}{Field delimiter} + +\item{eol}{The end of line character to use for ending rows} + +\item{quoting_style}{How to handle quotes. "Needed" (Only enclose values in quotes which need them, because their CSV +rendering can contain quotes itself (e.g. strings or binary values)), "AllValid" (Enclose all valid values in +quotes), or "None" (Do not enclose any values in quotes).} +} +\description{ +CSV Writing Options +} +\examples{ +tf <- tempfile() +on.exit(unlink(tf)) +write_csv_arrow(airquality, tf, write_options = csv_write_options(null_string = "-99")) +} diff --git a/r/man/open_delim_dataset.Rd b/r/man/open_delim_dataset.Rd index cf08302cc6436..7b81f0033ea35 100644 --- a/r/man/open_delim_dataset.Rd +++ b/r/man/open_delim_dataset.Rd @@ -25,7 +25,8 @@ open_delim_dataset( convert_options = NULL, read_options = NULL, timestamp_parsers = NULL, - quoted_na = TRUE + quoted_na = TRUE, + parse_options = NULL ) open_csv_dataset( @@ -46,7 +47,8 @@ open_csv_dataset( convert_options = NULL, read_options = NULL, timestamp_parsers = NULL, - quoted_na = TRUE + quoted_na = TRUE, + parse_options = NULL ) open_tsv_dataset( @@ -67,7 +69,8 @@ open_tsv_dataset( convert_options = NULL, read_options = NULL, timestamp_parsers = NULL, - quoted_na = TRUE + quoted_na = TRUE, + parse_options = NULL ) } \arguments{ @@ -169,9 +172,9 @@ filled with missings.} \item{skip}{Number of lines to skip before reading data.} -\item{convert_options}{see \link[=CsvReadOptions]{file reader options}} +\item{convert_options}{see \link[=csv_convert_options]{CSV conversion options}} -\item{read_options}{see \link[=CsvReadOptions]{file reader options}} +\item{read_options}{see \link[=csv_read_options]{CSV reading options}} \item{timestamp_parsers}{User-defined timestamp parsers. If more than one parser is specified, the CSV conversion logic will try parsing values @@ -186,6 +189,10 @@ starting from the beginning of this vector. Possible values are: values (the default) or strings. (Note that this is different from the the Arrow C++ default for the corresponding convert option, \code{strings_can_be_null}.)} + +\item{parse_options}{see \link[=csv_parse_options]{CSV parsing options}. +If given, this overrides any +parsing options provided in other arguments (e.g. \code{delim}, \code{quote}, etc.).} } \description{ A wrapper around \link{open_dataset} which explicitly includes parameters mirroring \code{\link[=read_csv_arrow]{read_csv_arrow()}}, diff --git a/r/man/read_delim_arrow.Rd b/r/man/read_delim_arrow.Rd index cd07c8ad07e5f..09c20fa0139af 100644 --- a/r/man/read_delim_arrow.Rd +++ b/r/man/read_delim_arrow.Rd @@ -120,13 +120,13 @@ filled with missings.} \item{skip}{Number of lines to skip before reading data.} -\item{parse_options}{see \link[=CsvReadOptions]{file reader options}. +\item{parse_options}{see \link[=csv_parse_options]{CSV parsing options}. If given, this overrides any parsing options provided in other arguments (e.g. \code{delim}, \code{quote}, etc.).} -\item{convert_options}{see \link[=CsvReadOptions]{file reader options}} +\item{convert_options}{see \link[=csv_convert_options]{CSV conversion options}} -\item{read_options}{see \link[=CsvReadOptions]{file reader options}} +\item{read_options}{see \link[=csv_read_options]{CSV reading options}} \item{as_data_frame}{Should the function return a \code{tibble} (default) or an Arrow \link{Table}?} diff --git a/r/man/read_parquet.Rd b/r/man/read_parquet.Rd index 3bb76cc2e30ca..4f1936529531a 100644 --- a/r/man/read_parquet.Rd +++ b/r/man/read_parquet.Rd @@ -9,6 +9,7 @@ read_parquet( col_select = NULL, as_data_frame = TRUE, props = ParquetArrowReaderProperties$create(), + mmap = TRUE, ... ) } @@ -29,6 +30,8 @@ an Arrow \link{Table}?} \item{props}{\link{ParquetArrowReaderProperties}} +\item{mmap}{Use TRUE to use memory mapping where possible} + \item{...}{Additional arguments passed to \code{ParquetFileReader$create()}} } \value{ diff --git a/r/man/write_csv_arrow.Rd b/r/man/write_csv_arrow.Rd index 2b0d09ba748c9..9fcca49fadc05 100644 --- a/r/man/write_csv_arrow.Rd +++ b/r/man/write_csv_arrow.Rd @@ -34,7 +34,7 @@ system (\code{SubTreeFileSystem})} \item{na}{value to write for NA values. Must not contain quote marks. Default is \code{""}.} -\item{write_options}{see \link[=CsvWriteOptions]{file reader options}} +\item{write_options}{see \link[=csv_write_options]{CSV write options}} \item{...}{additional parameters} } diff --git a/r/tests/testthat/test-arrow-pacakge.R b/r/tests/testthat/test-arrow-pacakge.R new file mode 100644 index 0000000000000..2d79467fa30a9 --- /dev/null +++ b/r/tests/testthat/test-arrow-pacakge.R @@ -0,0 +1,21 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +test_that("on_rosetta() does not warn", { + # There is no warning + expect_warning(on_rosetta(), NA) +}) diff --git a/r/tests/testthat/test-csv.R b/r/tests/testthat/test-csv.R index 38f79c63979f1..22ccc7950f7ea 100644 --- a/r/tests/testthat/test-csv.R +++ b/r/tests/testthat/test-csv.R @@ -336,7 +336,7 @@ test_that("CSV reader works on files with non-UTF-8 encoding", { fs <- LocalFileSystem$create() reader <- CsvTableReader$create( fs$OpenInputStream(tf), - read_options = CsvReadOptions$create(encoding = "UTF-16LE") + read_options = csv_read_options(encoding = "UTF-16LE") ) table <- reader$Read() @@ -435,7 +435,7 @@ test_that("Write a CSV with custom NA value", { # Also can use null_value in CsvWriteOptions tbl_out1 <- write_csv_arrow(tbl_no_dates, csv_file, - write_options = CsvWriteOptions$create(null_string = "another_null") + write_options = csv_write_options(null_string = "another_null") ) csv_contents <- readLines(csv_file) expect_true(any(grepl("another_null", csv_contents))) @@ -680,9 +680,9 @@ test_that("CSV reading/parsing/convert options can be passed in as lists", { tab2 <- read_csv_arrow( tf, - convert_options = CsvConvertOptions$create(null_values = c(NA, "NA", "NULL"), strings_can_be_null = TRUE), - parse_options = CsvParseOptions$create(ignore_empty_lines = FALSE), - read_options = CsvReadOptions$create(skip_rows = 1L) + convert_options = csv_convert_options(null_values = c(NA, "NA", "NULL"), strings_can_be_null = TRUE), + parse_options = csv_parse_options(ignore_empty_lines = FALSE), + read_options = csv_read_options(skip_rows = 1L) ) expect_equal(tab1, tab2) diff --git a/r/tests/testthat/test-dataset-csv.R b/r/tests/testthat/test-dataset-csv.R index e8e7c61fc8848..bee701e5ef9f9 100644 --- a/r/tests/testthat/test-dataset-csv.R +++ b/r/tests/testthat/test-dataset-csv.R @@ -206,7 +206,7 @@ test_that("Other text delimited dataset", { }) test_that("readr parse options", { - arrow_opts <- names(formals(CsvParseOptions$create)) + arrow_opts <- names(formals(csv_parse_options)) readr_opts <- names(formals(readr_to_csv_parse_options)) # Arrow and readr parse options must be mutually exclusive, or else the code @@ -469,8 +469,8 @@ test_that("CSV reading/parsing/convert options can be passed in as lists", { ds2 <- open_dataset( tf, format = "csv", - convert_options = CsvConvertOptions$create(null_values = c(NA, "NA", "NULL"), strings_can_be_null = TRUE), - read_options = CsvReadOptions$create(skip_rows = 1L) + convert_options = csv_convert_options(null_values = c(NA, "NA", "NULL"), strings_can_be_null = TRUE), + read_options = csv_read_options(skip_rows = 1L) ) %>% collect() @@ -571,6 +571,16 @@ test_that("open_delim_dataset params passed through to open_dataset", { ds <- open_csv_dataset(dst_dir, quoted_na = FALSE) %>% collect() expect_equal(ds$text, c("one", "two", "", "four")) + # parse_options + dst_dir <- make_temp_dir() + dst_file <- file.path(dst_dir, "data.csv") + writeLines("x\n\n1\n\n\n2\n\n3", dst_file) + ds <- open_csv_dataset( + dst_dir, + parse_options = csv_parse_options(ignore_empty_lines = FALSE) + ) %>% collect() + expect_equal(ds$x, c(NA, 1L, NA, NA, 2L, NA, 3L)) + # timestamp_parsers skip("GH-33708: timestamp_parsers don't appear to be working properly") @@ -586,15 +596,15 @@ test_that("open_delim_dataset params passed through to open_dataset", { }) test_that("CSVReadOptions printing", { - default_read_options <- CsvReadOptions$create() - custom_read_options <- CsvReadOptions$create(skip_rows = 102) + default_read_options <- csv_read_options() + custom_read_options <- csv_read_options(skip_rows = 102) expect_output(print(default_read_options), "skip_rows: 0") expect_output(print(custom_read_options), "skip_rows: 102") }) test_that("CSVReadOptions field access", { - options <- CsvReadOptions$create() + options <- csv_read_options() expect_equal(options$skip_rows, 0) expect_equal(options$autogenerate_column_names, FALSE) expect_equal(options$skip_rows_after_names, 0) diff --git a/r/tests/testthat/test-parquet.R b/r/tests/testthat/test-parquet.R index dbc4a0473561f..f2359116fdaf1 100644 --- a/r/tests/testthat/test-parquet.R +++ b/r/tests/testthat/test-parquet.R @@ -32,7 +32,7 @@ test_that("simple int column roundtrip", { pq_tmp_file <- tempfile() # You can specify the .parquet here but that's probably not necessary write_parquet(df, pq_tmp_file) - df_read <- read_parquet(pq_tmp_file) + df_read <- read_parquet(pq_tmp_file, mmap = FALSE) expect_equal(df, df_read) # Make sure file connection is cleaned up expect_error(file.remove(pq_tmp_file), NA) @@ -288,15 +288,21 @@ test_that("write_parquet() returns its input", { test_that("write_parquet() handles version argument", { df <- tibble::tibble(x = 1:5) - tf <- tempfile() - on.exit(unlink(tf)) - purrr::walk(list("1.0", "2.4", "2.6", "latest", 1.0, 2.4, 2.6, 1L), ~ { - write_parquet(df, tf, version = .x) + versions <- list("1.0", "2.4", "2.6", "latest", 1.0, 2.4, 2.6, 1L) + purrr::walk(versions, function(x) { + tf <- tempfile() + on.exit(unlink(tf)) + + write_parquet(df, tf, version = x) expect_identical(read_parquet(tf), df) }) - purrr::walk(list("3.0", 3.0, 3L, "A"), ~ { - expect_error(write_parquet(df, tf, version = .x)) + + invalid_versions <- list("3.0", 3.0, 3L, "A") + purrr::walk(invalid_versions, function(x) { + tf <- tempfile() + on.exit(unlink(tf)) + expect_error(write_parquet(df, tf, version = x)) }) }) diff --git a/r/tests/testthat/test-read-record-batch.R b/r/tests/testthat/test-read-record-batch.R index ba109da6c6b0a..f62330ae0e039 100644 --- a/r/tests/testthat/test-read-record-batch.R +++ b/r/tests/testthat/test-read-record-batch.R @@ -38,7 +38,7 @@ test_that("RecordBatchFileWriter / RecordBatchFileReader roundtrips", { writer$close() stream$close() - expect_equal(read_feather(tf, as_data_frame = FALSE), tab) + expect_equal(read_feather(tf, as_data_frame = FALSE, mmap = FALSE), tab) # Make sure connections are closed expect_error(file.remove(tf), NA) skip_on_os("windows") # This should pass, we've closed the stream diff --git a/r/tools/autobrew b/r/tools/autobrew deleted file mode 100644 index 35ffebcab3796..0000000000000 --- a/r/tools/autobrew +++ /dev/null @@ -1,80 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# https://github.com/jeroen/autobrew/blob/gh-pages/apache-arrow -export HOMEBREW_NO_ANALYTICS=1 -export HOMEBREW_NO_AUTO_UPDATE=1 - -if [[ ${OSTYPE:6} -ge 20 ]]; then - # We are on a modern enough macOS, we can use the real brew - UPSTREAM_ORG="homebrew" - PKG_BREW_NAME="$PKG_BREW_NAME-static" -else - # Official Homebrew no longer supports El-Capitan - # so we need to use the forked autobrew version of brew that supports old macOSes - UPSTREAM_ORG="autobrew" -fi - -if [ "$DISABLE_AUTOBREW" ]; then return 0; fi -AUTOBREW=${TMPDIR-/tmp} -export HOMEBREW_TEMP="$AUTOBREW/hbtmp" -BREWDIR="$AUTOBREW/build-$PKG_BREW_NAME" -BREW="$BREWDIR/bin/brew" -rm -Rf $BREWDIR -mkdir -p $BREWDIR -echo "$(date): Auto-brewing $PKG_BREW_NAME in $BREWDIR..." -curl -fsSL https://github.com/$UPSTREAM_ORG/brew/tarball/master | tar xz --strip 1 -C $BREWDIR - -# Install bottle + dependencies -export HOMEBREW_CACHE="$AUTOBREW" -LOCAL_FORMULA="tools/${PKG_BREW_NAME}.rb" -if [ -f "$LOCAL_FORMULA" ]; then - if [[ ${OSTYPE:6} -ge 20 ]]; then - $BREW tap - - # Tap https://github.com/autobrew/homebrew-cran so that we can get dependencies from there - $BREW tap autobrew/cran - fi - - # Use the local brew formula and install --HEAD - $BREW deps -n "$LOCAL_FORMULA" 2>/dev/null - BREW_DEPS=$($BREW deps -n "$LOCAL_FORMULA" 2>/dev/null) - $BREW install --force-bottle $BREW_DEPS 2>&1 | perl -pe 's/Warning/Note/gi' - $BREW install -v --build-from-source --HEAD "$LOCAL_FORMULA" 2>&1 | perl -pe 's/Warning/Note/gi' -else - $BREW install --force-bottle $BREW_DEPS $PKG_BREW_NAME 2>&1 | perl -pe 's/Warning/Note/gi' -fi - -# Hardcode this for my custom autobrew build -rm -f $BREWDIR/lib/*.dylib -AWS_LIBS="-laws-cpp-sdk-config -laws-cpp-sdk-transfer -laws-cpp-sdk-identity-management -laws-cpp-sdk-cognito-identity -laws-cpp-sdk-sts -laws-cpp-sdk-s3 -laws-cpp-sdk-core -laws-c-event-stream -laws-checksums -laws-c-common -laws-crt-cpp -laws-c-io -laws-c-s3 -laws-c-auth -laws-c-http -laws-c-cal -laws-c-compression -laws-c-mqtt -lpthread -lcurl" -PKG_LIBS="-lparquet -larrow_dataset -larrow_acero -larrow -larrow_bundled_dependencies -lthrift -lbrotlienc-static -lbrotlidec-static -lbrotlicommon-static -llz4 -lsnappy -lzstd $AWS_LIBS -lssl -lcrypto" -PKG_DIRS="-L$BREWDIR/lib" - -# Prevent CRAN builder from linking against old libs in /usr/local/lib -for FILE in $BREWDIR/Cellar/*/*/lib/*.a; do - BASENAME=`basename $FILE` - LIBNAME=`echo "${BASENAME%.*}" | cut -c4-` - cp -f $FILE $BREWDIR/lib/libbrew$LIBNAME.a - echo "created $BREWDIR/lib/libbrew$LIBNAME.a" - PKG_LIBS=`echo $PKG_LIBS | sed "s/-l$LIBNAME/-lbrew$LIBNAME/g"` -done - -PKG_CFLAGS="-I$BREWDIR/opt/$PKG_BREW_NAME/include -DARROW_R_WITH_PARQUET -DARROW_R_WITH_ACERO -DARROW_R_WITH_DATASET -DARROW_R_WITH_JSON -DARROW_R_WITH_S3 -DARROW_R_WITH_GCS -D_LIBCPP_DISABLE_AVAILABILITY" - -unset HOMEBREW_NO_ANALYTICS -unset HOMEBREW_NO_AUTO_UPDATE diff --git a/r/tools/nixlibs-allowlist.txt b/r/tools/nixlibs-allowlist.txt index bd9f0c1b2c084..9c368e6ed15a2 100644 --- a/r/tools/nixlibs-allowlist.txt +++ b/r/tools/nixlibs-allowlist.txt @@ -2,3 +2,4 @@ ubuntu centos redhat rhel +darwin diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R index 3d908c05cab07..60deca05cd172 100644 --- a/r/tools/nixlibs.R +++ b/r/tools/nixlibs.R @@ -28,6 +28,8 @@ if (test_mode && is.na(VERSION)) { } dev_version <- package_version(VERSION)[1, 4] +on_macos <- tolower(Sys.info()[["sysname"]]) == "darwin" + # Small dev versions are added for R-only changes during CRAN submission. if (is.na(dev_version) || dev_version < "100") { @@ -94,8 +96,10 @@ download_binary <- function(lib) { } } else { if (!quietly) { - cat(sprintf("*** Downloading libarrow binary failed for version %s (%s)\n at %s\n", - VERSION, lib, binary_url)) + cat(sprintf( + "*** Downloading libarrow binary failed for version %s (%s)\n at %s\n", + VERSION, lib, binary_url + )) } libfile <- NULL } @@ -114,6 +118,10 @@ download_binary <- function(lib) { # * "linux-openssl-1.0" (OpenSSL 1.0) # * "linux-openssl-1.1" (OpenSSL 1.1) # * "linux-openssl-3.0" (OpenSSL 3.0) +# * "macos-amd64-openssl-1.1" (OpenSSL 1.1) +# * "macos-amd64-openssl-3.0" (OpenSSL 3.0) +# * "macos-arm64-openssl-1.1" (OpenSSL 1.1) +# * "macos-arm64-openssl-3.0" (OpenSSL 3.0) # These string values, along with `NULL`, are the potential return values of # this function. identify_binary <- function(lib = Sys.getenv("LIBARROW_BINARY"), info = distro()) { @@ -142,7 +150,7 @@ check_allowlist <- function(os, allowed = "https://raw.githubusercontent.com/apa # Try a remote allowlist so that we can add/remove without a release suppressWarnings(readLines(allowed)), # Fallback to default: allowed only on Ubuntu and CentOS/RHEL - error = function(e) c("ubuntu", "centos", "redhat", "rhel") + error = function(e) c("ubuntu", "centos", "redhat", "rhel", "darwin") ) # allowlist should contain valid regular expressions (plain strings ok too) any(grepl(paste(allowlist, collapse = "|"), os)) @@ -151,14 +159,16 @@ check_allowlist <- function(os, allowed = "https://raw.githubusercontent.com/apa select_binary <- function(os = tolower(Sys.info()[["sysname"]]), arch = tolower(Sys.info()[["machine"]]), test_program = test_for_curl_and_openssl) { - if (identical(os, "linux") && identical(arch, "x86_64")) { - # We only host x86 linux binaries today - tryCatch( + if (identical(os, "darwin") || (identical(os, "linux") && identical(arch, "x86_64"))) { + # We only host x86 linux binaries and x86 & arm64 macos today + binary <- tryCatch( # Somehow the test program system2 call errors on the sanitizer builds # so globally handle the possibility that this could fail { errs <- compile_test_program(test_program) - determine_binary_from_stderr(errs) + openssl_version <- determine_binary_from_stderr(errs) + arch <- ifelse(identical(os, "darwin"), paste0("-", arch, "-"), "-") + ifelse(is.null(openssl_version), NULL, paste0(os, arch, openssl_version)) }, error = function(e) { cat("*** Unable to find libcurl and openssl\n") @@ -168,17 +178,20 @@ select_binary <- function(os = tolower(Sys.info()[["sysname"]]), } else { # No binary available for arch cat(sprintf("*** Building on %s %s\n", os, arch)) - NULL + binary <- NULL } + return(binary) } # This tests that curl and OpenSSL are present (bc we can include their headers) # and it checks for other versions/features and raises errors that we grep for test_for_curl_and_openssl <- " +#ifndef __APPLE__ #include #ifdef _LIBCPP_VERSION #error Using libc++ #endif +#endif #include #include @@ -194,11 +207,14 @@ test_for_curl_and_openssl <- " " compile_test_program <- function(code) { - # Note: if we wanted to check for openssl on macOS, we'd have to set the brew - # path as a -I directory. But since we (currently) only run this code to - # determine whether we can download a Linux binary, it's not relevant. + openssl_dir <- "" + if (on_macos) { + openssl_root_dir <- get_macos_openssl_dir() + openssl_dir <- paste0("-I", openssl_root_dir, "/include") + } runner <- paste( R_CMD_config("CXX17"), + openssl_dir, R_CMD_config("CPPFLAGS"), R_CMD_config("CXX17FLAGS"), R_CMD_config("CXX17STD"), @@ -208,17 +224,34 @@ compile_test_program <- function(code) { suppressWarnings(system2("echo", sprintf('"%s" | %s -', code, runner), stdout = FALSE, stderr = TRUE)) } +get_macos_openssl_dir <- function() { + openssl_root_dir <- Sys.getenv("OPENSSL_ROOT_DIR", NA) + header <- "openssl/opensslv.h" + if (is.na(openssl_root_dir) || !file.exists(file.path(openssl_root_dir, "include", header))) { + # try to guess default openssl include dir based on CRAN's build script + # https://github.com/R-macos/recipes/blob/master/build.sh#L35 + if (identical(Sys.info()["machine"], "arm64") && file.exists(file.path("/opt/R/arm64/include", header))) { + openssl_root_dir <- "/opt/R/arm64" + } else if (identical(Sys.info()["machine"], "x86_64") && file.exists(file.path("/opt/R/x86_64/include", header))) { + openssl_root_dir <- "/opt/R/x86_64" + } else { + openssl_root_dir <- "/usr/local" + } + } + return(openssl_root_dir) +} + # (built with newer devtoolset but older glibc (2.17) for broader compatibility,# like manylinux2014) determine_binary_from_stderr <- function(errs) { if (is.null(attr(errs, "status"))) { # There was no error in compiling: so we found libcurl and OpenSSL >= 1.1, # openssl is < 3.0 cat("*** Found libcurl and OpenSSL >= 1.1\n") - return("linux-openssl-1.1") + return("openssl-1.1") # Else, check for dealbreakers: - } else if (any(grepl("Using libc++", errs, fixed = TRUE))) { - # Our binaries are all built with GNU stdlib so they fail with libc++ - cat("*** Found libc++\n") + } else if (!on_macos && any(grepl("Using libc++", errs, fixed = TRUE))) { + # Our linux binaries are all built with GNU stdlib so they fail with libc++ + cat("*** Linux binaries incompatible with libc++\n") return(NULL) } else if (header_not_found("curl/curl", errs)) { cat("*** libcurl not found\n") @@ -231,11 +264,15 @@ determine_binary_from_stderr <- function(errs) { return(NULL) # Else, determine which other binary will work } else if (any(grepl("Using OpenSSL version 1.0", errs))) { + if (on_macos) { + cat("*** OpenSSL 1.0 is not supported on macOS\n") + return(NULL) + } cat("*** Found libcurl and OpenSSL < 1.1\n") - return("linux-openssl-1.0") + return("openssl-1.0") } else if (any(grepl("Using OpenSSL version 3", errs))) { cat("*** Found libcurl and OpenSSL >= 3.0.0\n") - return("linux-openssl-3.0") + return("openssl-3.0") } NULL } @@ -248,6 +285,11 @@ header_not_found <- function(header, errs) { #### start distro #### distro <- function() { + # This is not part of distro but needed to enable prebuilt binaries on macos + if (on_macos) { + return(list(id = "darwin", arch = tolower(Sys.info()[["machine"]]))) + } + # The code in this script is a (potentially stale) copy of the distro package if (requireNamespace("distro", quietly = TRUE)) { # Use the version from the package, which may be updated from this @@ -487,8 +529,10 @@ build_libarrow <- function(src_dir, dst_dir) { # It failed :( cat("**** Error building Arrow C++.", "\n") if (quietly) { - cat("**** Printing contents of build log because the build failed", - "while ARROW_R_DEV was set to FALSE\n") + cat( + "**** Printing contents of build log because the build failed", + "while ARROW_R_DEV was set to FALSE\n" + ) cat(readLines(build_log_path), sep = "\n") cat("**** Complete build log may still be present at", build_log_path, "\n") } @@ -503,7 +547,7 @@ ensure_cmake <- function(cmake_minimum_required = "3.16") { # If not found, download it cat("**** cmake\n") CMAKE_VERSION <- Sys.getenv("CMAKE_VERSION", "3.26.4") - if (tolower(Sys.info()[["sysname"]]) %in% "darwin") { + if (on_macos) { postfix <- "-macos-universal.tar.gz" } else if (tolower(Sys.info()[["machine"]]) %in% c("arm64", "aarch64")) { postfix <- "-linux-aarch64.tar.gz" diff --git a/r/tools/test-nixlibs.R b/r/tools/test-nixlibs.R index e099dcdad4acf..c9571b58b7bbf 100644 --- a/r/tools/test-nixlibs.R +++ b/r/tools/test-nixlibs.R @@ -21,8 +21,10 @@ # Flag so that we just load the functions and don't evaluate them like we do # when called from configure.R TESTING <- TRUE - -source("nixlibs.R", local = TRUE) +# The functions use `on_macos` from the env they were sourced in, so we need tool +# explicitly set it in that environment. +nixlibs_env <- environment() +source("nixlibs.R", local = nixlibs_env) test_that("identify_binary() based on LIBARROW_BINARY", { expect_null(identify_binary("FALSE")) @@ -31,10 +33,6 @@ test_that("identify_binary() based on LIBARROW_BINARY", { }) test_that("select_binary() based on system", { - expect_output( - expect_null(select_binary("darwin", "x86_64")), # Not built today - "Building on darwin x86_64" - ) expect_output( expect_null(select_binary("linux", arch = "aarch64")), # Not built today "Building on linux aarch64" @@ -52,21 +50,30 @@ test_that("determine_binary_from_stderr", { expect_output( expect_identical( determine_binary_from_stderr(compile_test_program("int a;")), - "linux-openssl-1.1" + "openssl-1.1" ), "Found libcurl and OpenSSL >= 1.1" ) + + nixlibs_env$on_macos <- FALSE expect_output( expect_identical( determine_binary_from_stderr(compile_test_program("#error Using OpenSSL version 1.0")), - "linux-openssl-1.0" + "openssl-1.0" ), "Found libcurl and OpenSSL < 1.1" ) + nixlibs_env$on_macos <- TRUE + expect_output( + expect_null( + determine_binary_from_stderr(compile_test_program("#error Using OpenSSL version 1.0")) + ), + "OpenSSL 1.0 is not supported on macOS" + ) expect_output( expect_identical( determine_binary_from_stderr(compile_test_program("#error Using OpenSSL version 3")), - "linux-openssl-3.0" + "openssl-3.0" ), "Found libcurl and OpenSSL >= 3.0.0" ) @@ -79,6 +86,7 @@ test_that("determine_binary_from_stderr", { }) test_that("select_binary() with test program", { + nixlibs_env$on_macos <- FALSE expect_output( expect_identical( select_binary("linux", "x86_64", "int a;"), @@ -100,13 +108,49 @@ test_that("select_binary() with test program", { ), "Found libcurl and OpenSSL >= 3.0.0" ) + nixlibs_env$on_macos <- TRUE + expect_output( + expect_identical( + select_binary("darwin", "x86_64", "int a;"), + "darwin-x86_64-openssl-1.1" + ), + "Found libcurl and OpenSSL >= 1.1" + ) + expect_output( + expect_identical( + select_binary("darwin", "x86_64", "#error Using OpenSSL version 3"), + "darwin-x86_64-openssl-3.0" + ), + "Found libcurl and OpenSSL >= 3.0.0" + ) + expect_output( + expect_identical( + select_binary("darwin", "arm64", "int a;"), + "darwin-arm64-openssl-1.1" + ), + "Found libcurl and OpenSSL >= 1.1" + ) + expect_output( + expect_identical( + select_binary("darwin", "arm64", "#error Using OpenSSL version 3"), + "darwin-arm64-openssl-3.0" + ), + "Found libcurl and OpenSSL >= 3.0.0" + ) + expect_output( + expect_null( + select_binary("darwin", "x86_64", "#error Using OpenSSL version 1.0") + ), + "OpenSSL 1.0 is not supported on macOS" + ) }) test_that("check_allowlist", { tf <- tempfile() - cat("tu$\n^cent\n", file = tf) + cat("tu$\n^cent\n^dar\n", file = tf) expect_true(check_allowlist("ubuntu", tf)) expect_true(check_allowlist("centos", tf)) + expect_true(check_allowlist("darwin", tf)) expect_false(check_allowlist("redhat", tf)) # remote allowlist doesn't have this expect_true(check_allowlist("redhat", tempfile())) # remote allowlist doesn't exist, so we fall back to the default list, which contains redhat expect_false(check_allowlist("debian", tempfile()))