[Buildroot] [PATCH 1/1] package/rocksdb: bump to version 6.13.3

Fabrice Fontaine fontaine.fabrice at gmail.com
Thu Nov 5 19:59:05 UTC 2020


- Refresh first patch
- Replace second patch (this new iteration of previous patch has not
  been merged and does not apply cleanly on current version)
- Update hash of README.md (CircleCI gadget added with
  https://github.com/facebook/rocksdb/commit/63b59f21d9971fc941e3ee2244783a3c16bd5ad4)
- LTO is supported since version 6.12.6 and
  https://github.com/facebook/rocksdb/commit/c0c33a4854587e412742841f199edd4616be6c00
- DESTDIR and PREFIX are supported since version 6.13.2 and
  https://github.com/facebook/rocksdb/commit/1e59800718b29d4a762b8ac356767a701f968a4d

https://github.com/facebook/rocksdb/releases/tag/v6.13.3

Fixes:
 - http://autobuild.buildroot.org/results/a9798bb279a668a266c472fb026b68dbccf50431

Signed-off-by: Fabrice Fontaine <fontaine.fabrice at gmail.com>
---
 ...ls-build_detect_platform-fix-C-tests.patch |   67 +-
 ...patiblity-fix-CRC32-C-implementation.patch | 3787 +++++++++++++++
 ...e-POWER-crc32c-with-C-implementation.patch | 4058 -----------------
 package/rocksdb/rocksdb.hash                  |    4 +-
 package/rocksdb/rocksdb.mk                    |   16 +-
 5 files changed, 3857 insertions(+), 4075 deletions(-)
 create mode 100644 package/rocksdb/0002-POWER7-8-compatiblity-fix-CRC32-C-implementation.patch
 delete mode 100644 package/rocksdb/0002-replace-POWER-crc32c-with-C-implementation.patch

diff --git a/package/rocksdb/0001-build_tools-build_detect_platform-fix-C-tests.patch b/package/rocksdb/0001-build_tools-build_detect_platform-fix-C-tests.patch
index 05f6bbde79..77ac9f90a1 100644
--- a/package/rocksdb/0001-build_tools-build_detect_platform-fix-C-tests.patch
+++ b/package/rocksdb/0001-build_tools-build_detect_platform-fix-C-tests.patch
@@ -16,13 +16,22 @@ EOF
 Signed-off-by: Fabrice Fontaine <fontaine.fabrice at gmail.com>
 [Upstream status: https://github.com/facebook/rocksdb/pull/6479]
 ---
- build_tools/build_detect_platform | 58 +++++++++++++++----------------
- 1 file changed, 29 insertions(+), 29 deletions(-)
+ build_tools/build_detect_platform | 66 +++++++++++++++----------------
+ 1 file changed, 33 insertions(+), 33 deletions(-)
 
 diff --git a/build_tools/build_detect_platform b/build_tools/build_detect_platform
 index 2535d8124..64a0ae76c 100755
 --- a/build_tools/build_detect_platform
 +++ b/build_tools/build_detect_platform
+@@ -172,7 +172,7 @@ case "$TARGET_OS" in
+         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -ldl"
+         if test $ROCKSDB_USE_IO_URING; then
+             # check for liburing
+-            $CXX $CFLAGS -x c++ - -luring -o /dev/null 2>/dev/null  <<EOF
++            $CXX $CFLAGS -x c++ - -luring -o test.o 2>/dev/null  <<EOF
+               #include <liburing.h>
+               int main() {
+                 struct io_uring ring;
 @@ -245,7 +245,7 @@ if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then
  else
      if ! test $ROCKSDB_DISABLE_FALLOCATE; then
@@ -45,17 +54,26 @@ index 2535d8124..64a0ae76c 100755
          # Test whether gflags library is installed
          # http://gflags.github.io/gflags/
          # check if the namespace is gflags
--        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
-+        $CXX $CFLAGS -x c++ - -o test.o 2>/dev/null << EOF
+-        if $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
++        if $CXX $CFLAGS -x c++ - -o test.o 2>/dev/null << EOF
            #include <gflags/gflags.h>
+           using namespace GFLAGS_NAMESPACE;
            int main() {}
- EOF
+@@ -323,7 +323,7 @@ EOF
+           COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1"
+           PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
+         # check if namespace is gflags
+-        elif $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
++        elif $CXX $CFLAGS -x c++ - -o test.o 2>/dev/null << EOF
+             #include <gflags/gflags.h>
+             using namespace gflags;
+             int main() {}
 @@ -285,7 +285,7 @@ EOF
-             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
-         else
-           # check if namespace is google
--          $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
-+          $CXX $CFLAGS -x c++ - -o test.o 2>/dev/null << EOF
+           COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1 -DGFLAGS_NAMESPACE=gflags"
+           PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
+         # check if namespace is google
+-        elif $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
++        elif $CXX $CFLAGS -x c++ - -o test.o 2>/dev/null << EOF
              #include <gflags/gflags.h>
              using namespace google;
              int main() {}
@@ -142,6 +160,15 @@ index 2535d8124..64a0ae76c 100755
              size_t res = malloc_usable_size(0);
 @@ -424,7 +424,7 @@ EOF
  
+     if ! test $ROCKSDB_DISABLE_MEMKIND; then
+         # Test whether memkind library is installed
+-        $CXX $CFLAGS $COMMON_FLAGS -lmemkind -x c++ - -o /dev/null 2>/dev/null  <<EOF
++        $CXX $CFLAGS $COMMON_FLAGS -lmemkind -x c++ - -o test.o 2>/dev/null  <<EOF
+           #include <memkind.h>
+           int main() {
+             memkind_malloc(MEMKIND_DAX_KMEM, 1024);
+@@ -486,7 +486,7 @@ EOF
+ 
      if ! test $ROCKSDB_DISABLE_PTHREAD_MUTEX_ADAPTIVE_NP; then
          # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available
 -        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
@@ -222,7 +249,7 @@ index 2535d8124..64a0ae76c 100755
  EOF
    if [ "$?" = 0 ]; then
 @@ -603,7 +603,7 @@ if test "$TRY_SSE_ETC"; then
-   TRY_AVX2="-mavx2"
+   TRY_LZCNT="-mlzcnt"
  fi
  
 -$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o /dev/null 2>/dev/null <<EOF
@@ -252,6 +279,24 @@ index 2535d8124..64a0ae76c 100755
    echo "warning: USE_SSE specified but compiler could not use AVX2 intrinsics, disabling" >&2
  fi
  
+-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_BMI -x c++ - -o /dev/null 2>/dev/null <<EOF
++$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_BMI -x c++ - -o test.o 2>/dev/null <<EOF
+   #include <cstdint>
+   #include <immintrin.h>
+   int main(int argc, char *argv[]) {
+@@ -739,7 +739,7 @@ elif test "$USE_SSE"; then
+   echo "warning: USE_SSE specified but compiler could not use BMI intrinsics, disabling" >&2
+ fi
+ 
+-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_LZCNT -x c++ - -o /dev/null 2>/dev/null <<EOF
++$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_LZCNT -x c++ - -o test.o 2>/dev/null <<EOF
+   #include <cstdint>
+   #include <immintrin.h>
+   int main(int argc, char *argv[]) {
+@@ -753,7 +753,7 @@ elif test "$USE_SSE"; then
+   echo "warning: USE_SSE specified but compiler could not use LZCNT intrinsics, disabling" >&2
+ fi
+ 
 -$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF
 +$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null <<EOF
    #include <cstdint>
diff --git a/package/rocksdb/0002-POWER7-8-compatiblity-fix-CRC32-C-implementation.patch b/package/rocksdb/0002-POWER7-8-compatiblity-fix-CRC32-C-implementation.patch
new file mode 100644
index 0000000000..bb7a2bed5e
--- /dev/null
+++ b/package/rocksdb/0002-POWER7-8-compatiblity-fix-CRC32-C-implementation.patch
@@ -0,0 +1,3787 @@
+From 7eab5c3bf8449673de7bf0d3446a669694f71f1a Mon Sep 17 00:00:00 2001
+From: Daniel Black <daniel at linux.ibm.com>
+Date: Thu, 16 Apr 2020 12:23:02 +1000
+Subject: [PATCH] POWER7/8 compatiblity fix + CRC32 C implementation
+
+When running on a POWER7/8, the compiler will successfully
+report being able to compile for POWER9 compatibility. It will
+however fail to run due to POWER9+ only instructions being used.
+
+To preserve the goals of ensuring an optimization for the
+local hardware, -mcpu=native is used, but only if we don't
+already have C{,XX}_FLAGS with cpu/arch/tune set. PORTABLE
+flag that was added for x86 is reused to ensure that the minimum
+viable cpu is selected, POWER7 if compiling on big endian and
+POWER8 if on little endian.
+
+This ensures that if a binary distributor compiles on a
+POWER9, and aims to support POWER8 packages, then hopefully
+they will have the correct C{,XX}_FLAGS, and as such, will
+not result in a broken package on POWER8.
+
+Fixes: 8fc20ac468b266a53083175025375985ec04b796
+
+We also replace POWER crc32c with C implementation.
+The presence of clang compile failures on POWER due to
+missing ppc-asm.h prompted the replacement of the ASM
+CRC32 implementation with the C implementation.
+
+We include this when the compile flags enable it to be build.
+For example on POWER7 the optimized crc32 will be built,
+however it won't be used because of the runtime detection.
+If the executable is moved to a POWER8 big endian it will
+work correctly.
+
+https://github.com/antonblanchard/crc32-vpmsum/blob/master/vec_crc32.c
+is used with only small include path change with the local copyright header
+maintained.
+
+util/crc32c.cc removes arch_ppc_crc32 which was only ever
+used in a local context. Also incorporated significant advice from
+tchaikov in #2869. Replace all compile time checks with runtime checks.
+
+Corrects getauxval detection from 8bbd76edbf by including the header from the
+right directory.
+
+[Retrieved (and slightly updated for 6.13.3) from:
+https://github.com/facebook/rocksdb/pull/7079/commits/7eab5c3bf8449673de7bf0d3446a669694f71f1a]
+Signed-off-by: Fabrice Fontaine <fontaine.fabrice at gmail.com>
+---
+ CMakeLists.txt                     |   59 +-
+ Makefile                           |   35 +-
+ src.mk                             |   11 +-
+ util/crc32c.cc                     |   63 +-
+ util/crc32c_ppc.c                  |   94 --
+ util/crc32c_ppc.cc                 |  662 +++++++++++++
+ util/crc32c_ppc.h                  |   19 -
+ util/crc32c_ppc_asm.S              |  752 --------------
+ util/crc32c_ppc_clang_workaround.h |   85 ++
+ util/crc32c_ppc_constants.h        | 1457 +++++++++++++++++-----------
+ util/crc32c_test.cc                |    3 +
+ 11 files changed, 1684 insertions(+), 1556 deletions(-)
+ delete mode 100644 util/crc32c_ppc.c
+ create mode 100644 util/crc32c_ppc.cc
+ delete mode 100644 util/crc32c_ppc.h
+ delete mode 100644 util/crc32c_ppc_asm.S
+ create mode 100644 util/crc32c_ppc_clang_workaround.h
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 91647d83bb..5adf0cf3a5 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -39,7 +39,7 @@ include(ReadVersion)
+ get_rocksdb_version(rocksdb_VERSION)
+ project(rocksdb
+   VERSION ${rocksdb_VERSION}
+-  LANGUAGES CXX C ASM)
++  LANGUAGES CXX C)
+ 
+ if(POLICY CMP0042)
+   cmake_policy(SET CMP0042 NEW)
+@@ -223,26 +223,6 @@ else()
+ endif()
+ 
+ include(CheckCCompilerFlag)
+-if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
+-  CHECK_C_COMPILER_FLAG("-mcpu=power9" HAS_POWER9)
+-  if(HAS_POWER9)
+-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mcpu=power9 -mtune=power9")
+-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=power9 -mtune=power9")
+-  else()
+-    CHECK_C_COMPILER_FLAG("-mcpu=power8" HAS_POWER8)
+-    if(HAS_POWER8)
+-      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mcpu=power8 -mtune=power8")
+-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=power8 -mtune=power8")
+-    endif(HAS_POWER8)
+-  endif(HAS_POWER9)
+-  CHECK_C_COMPILER_FLAG("-maltivec" HAS_ALTIVEC)
+-  if(HAS_ALTIVEC)
+-    message(STATUS " HAS_ALTIVEC yes")
+-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maltivec")
+-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maltivec")
+-  endif(HAS_ALTIVEC)
+-endif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
+-
+ if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64")
+         CHECK_C_COMPILER_FLAG("-march=armv8-a+crc+crypto" HAS_ARMV8_CRC)
+   if(HAS_ARMV8_CRC)
+@@ -260,21 +240,40 @@ if(PORTABLE)
+   if(FORCE_SSE42 AND NOT MSVC)
+     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2 -mpclmul")
+   endif()
++  if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
++    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64le")
++      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=power8")
++    else()
++      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=power7")
++    endif()
++  endif()
+ else()
+   if(MSVC)
+     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2")
+   else()
+-    if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64" AND NOT HAS_ARMV8_CRC)
+-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
++    if(NOT CMAKE_CXX_FLAGS MATCHES "m(cpu|tune|arch)")
++      if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
++        # Power doesn't have a march option - https://gcc.gnu.org/onlinedocs/gcc/RS_002f6000-and-PowerPC-Options.html
++        # -mcpu activates all available options
++        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=native")
++      else()
++        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
++      endif()
+     endif()
+   endif()
+ endif()
+ 
+-include(CheckCXXSourceCompiles)
++if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
++  include(CheckCXXCompilerFlag)
++  SET(POWER_CRC32_FLAGS "-mcrypto -mpower8-vector -maltivec -mvsx")
++  CHECK_CXX_COMPILER_FLAG("${POWER_CRC32_FLAGS}" HAS_POWER_CRC32_FLAGS)
++endif()
++
+ if(NOT MSVC)
+   set(CMAKE_REQUIRED_FLAGS "-msse4.2 -mpclmul")
+ endif()
+ 
++include(CheckCXXSourceCompiles)
+ CHECK_CXX_SOURCE_COMPILES("
+ #include <cstdint>
+ #include <nmmintrin.h>
+@@ -525,7 +524,7 @@ if(HAVE_SCHED_GETCPU)
+   add_definitions(-DROCKSDB_SCHED_GETCPU_PRESENT)
+ endif()
+ 
+-check_cxx_symbol_exists(getauxval auvx.h HAVE_AUXV_GETAUXVAL)
++check_cxx_symbol_exists(getauxval sys/auxv.h HAVE_AUXV_GETAUXVAL)
+ if(HAVE_AUXV_GETAUXVAL)
+   add_definitions(-DROCKSDB_AUXV_GETAUXVAL_PRESENT)
+ endif()
+@@ -796,11 +795,13 @@ if(HAVE_SSE42 AND NOT MSVC)
+     PROPERTIES COMPILE_FLAGS "-msse4.2 -mpclmul")
+ endif()
+ 
+-if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
++if(HAS_POWER_CRC32_FLAGS)
+   list(APPEND SOURCES
+-    util/crc32c_ppc.c
+-    util/crc32c_ppc_asm.S)
+-endif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
++    util/crc32c_ppc.cc)
++  set_source_files_properties(
++    util/crc32c_ppc.cc
++    PROPERTIES COMPILE_FLAGS "${POWER_CRC32_FLAGS}")
++endif()
+ 
+ if(HAS_ARMV8_CRC)
+   list(APPEND SOURCES
+diff --git a/Makefile b/Makefile
+index a19d2ff964..7da8f71085 100644
+--- a/Makefile
++++ b/Makefile
+@@ -144,16 +144,9 @@ OPT += -momit-leaf-frame-pointer
+ endif
+ endif
+ 
+-ifeq (,$(shell $(CXX) -fsyntax-only -maltivec -xc /dev/null 2>&1))
+-CXXFLAGS += -DHAS_ALTIVEC
+-CFLAGS += -DHAS_ALTIVEC
+-HAS_ALTIVEC=1
+-endif
+-
+-ifeq (,$(shell $(CXX) -fsyntax-only -mcpu=power8 -xc /dev/null 2>&1))
+-CXXFLAGS += -DHAVE_POWER8
+-CFLAGS +=  -DHAVE_POWER8
+-HAVE_POWER8=1
++ifeq (,$(shell $(CXX) -fsyntax-only  -mcrypto -mpower8-vector -maltivec -mvsx -xc /dev/null 2>&1))
++POWER_CRC32_FLAGS=-mcrypto -mpower8-vector -maltivec -mvsx
++HAVE_POWER_CRC32_FLAGS=1
+ endif
+ 
+ ifeq (,$(shell $(CXX) -fsyntax-only -march=armv8-a+crc+crypto -xc /dev/null 2>&1))
+@@ -461,10 +454,6 @@ endif
+ 
+ OBJ_DIR?=.
+ LIB_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(LIB_SOURCES))
+-ifeq ($(HAVE_POWER8),1)
+-LIB_OBJECTS += $(patsubst %.c, $(OBJ_DIR)/%.o, $(LIB_SOURCES_C))
+-LIB_OBJECTS += $(patsubst %.S, $(OBJ_DIR)/%.o, $(LIB_SOURCES_ASM))
+-endif
+ 
+ ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
+   LIB_OBJECTS += $(patsubst %.cpp, $(OBJ_DIR)/%.o, $(FOLLY_SOURCES))
+@@ -2254,13 +2242,12 @@ IOSVERSION=$(shell defaults read $(PLATFORMSROOT)/iPhoneOS.platform/version CFBu
+ 	lipo ios-x86/$@ ios-arm/$@ -create -output $@
+ 
+ else
+-ifeq ($(HAVE_POWER8),1)
+-$(OBJ_DIR)/util/crc32c_ppc.o: util/crc32c_ppc.c
+-	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
++ifeq ($(HAVE_POWER_CRC32_FLAGS),1)
++$(OBJ_DIR)/util/crc32c_ppc.o: util/crc32c_ppc.cc
++	$(AM_V_CC)$(CC) $(CFLAGS) $(POWER_CRC32_FLAGS) -c $< -o $@
+ 
+-$(OBJ_DIR)/util/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
+-	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
+ endif
++
+ $(OBJ_DIR)/%.o: %.cc
+ 	$(AM_V_CC)mkdir -p $(@D) && $(CXX) $(CXXFLAGS) -c $< -o $@ $(COVERAGEFLAGS)
+ 
+diff --git a/src.mk b/src.mk
+index c4fec346e4..0f6a19a17c 100644
+--- a/src.mk
++++ b/src.mk
+@@ -255,14 +255,9 @@ LIB_SOURCES +=\
+   util/crc32c_arm64.cc
+ endif
+ 
+-ifeq (,$(shell $(CXX) -fsyntax-only -maltivec -xc /dev/null 2>&1))
+-LIB_SOURCES_ASM =\
+-  util/crc32c_ppc_asm.S
+-LIB_SOURCES_C = \
+-  util/crc32c_ppc.c
+-else
+-LIB_SOURCES_ASM =
+-LIB_SOURCES_C =
++ifeq ($(HAVE_POWER_CRC32_FLAGS),1)
++LIB_SOURCES += \
++  util/crc32c_ppc.cc
+ endif
+ 
+ TOOL_LIB_SOURCES =                                              \
+diff --git a/util/crc32c.cc b/util/crc32c.cc
+index a709e9b1ce..b24a4f0e0f 100644
+--- a/util/crc32c.cc
++++ b/util/crc32c.cc
+@@ -20,15 +20,13 @@
+ 
+ #include "util/crc32c_arm64.h"
+ 
+-#ifdef __powerpc64__
+-#include "util/crc32c_ppc.h"
+-#include "util/crc32c_ppc_constants.h"
+-
+-#if __linux__
+ #ifdef ROCKSDB_AUXV_GETAUXVAL_PRESENT
+ #include <sys/auxv.h>
+ #endif
+ 
++#ifdef __powerpc64__
++extern uint32_t crc32c_ppc(uint32_t crc, unsigned char const* buffer,
++                           unsigned long len);
+ #ifndef PPC_FEATURE2_VEC_CRYPTO
+ #define PPC_FEATURE2_VEC_CRYPTO 0x02000000
+ #endif
+@@ -37,19 +35,11 @@
+ #define AT_HWCAP2 26
+ #endif
+ 
+-#endif /* __linux__ */
+-
+ #endif
+ 
+ namespace ROCKSDB_NAMESPACE {
+ namespace crc32c {
+ 
+-#if defined(HAVE_POWER8) && defined(HAS_ALTIVEC)
+-#ifdef __powerpc64__
+-static int arch_ppc_crc32 = 0;
+-#endif /* __powerpc64__ */
+-#endif
+-
+ static const uint32_t table0_[256] = {
+   0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4,
+   0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
+@@ -342,6 +332,7 @@ static inline void Slow_CRC32(uint64_t* l, uint8_t const **p) {
+   table0_[c >> 24];
+ }
+ 
++#if !defined(HAVE_ARM64_CRC) && !defined(__powerpc64__)
+ static inline void Fast_CRC32(uint64_t* l, uint8_t const **p) {
+ #ifndef HAVE_SSE42
+   Slow_CRC32(l, p);
+@@ -355,6 +346,7 @@ static inline void Fast_CRC32(uint64_t* l, uint8_t const **p) {
+   *p += 4;
+ #endif
+ }
++#endif
+ 
+ template<void (*CRC32)(uint64_t*, uint8_t const**)>
+ uint32_t ExtendImpl(uint32_t crc, const char* buf, size_t size) {
+@@ -400,10 +392,8 @@ uint32_t ExtendImpl(uint32_t crc, const char* buf, size_t size) {
+   return static_cast<uint32_t>(l ^ 0xffffffffu);
+ }
+ 
+-// Detect if ARM64 CRC or not.
+-#ifndef HAVE_ARM64_CRC
++#if !defined(HAVE_ARM64_CRC) && !defined(__powerpc64__)
+ // Detect if SS42 or not.
+-#ifndef HAVE_POWER8
+ 
+ static bool isSSE42() {
+ #ifndef HAVE_SSE42
+@@ -439,36 +429,22 @@ static bool isPCLMULQDQ() {
+ #endif
+ }
+ 
+-#endif  // HAVE_POWER8
+-#endif  // HAVE_ARM64_CRC
++#endif  // !__power64__ && !HAVE_ARM64_CRC
+ 
+ typedef uint32_t (*Function)(uint32_t, const char*, size_t);
+ 
+-#if defined(HAVE_POWER8) && defined(HAS_ALTIVEC)
++#if defined(__powerpc64__)
+ uint32_t ExtendPPCImpl(uint32_t crc, const char *buf, size_t size) {
+   return crc32c_ppc(crc, (const unsigned char *)buf, size);
+ }
+ 
+-#if __linux__
+-static int arch_ppc_probe(void) {
+-  arch_ppc_crc32 = 0;
+-
+-#if defined(__powerpc64__) && defined(ROCKSDB_AUXV_GETAUXVAL_PRESENT)
+-  if (getauxval(AT_HWCAP2) & PPC_FEATURE2_VEC_CRYPTO) arch_ppc_crc32 = 1;
+-#endif /* __powerpc64__ */
+-
+-  return arch_ppc_crc32;
+-}
+-#endif  // __linux__
+-
+ static bool isAltiVec() {
+-  if (arch_ppc_probe()) {
+-    return true;
+-  } else {
+-    return false;
+-  }
+-}
++#if defined(__linux__) && defined(ROCKSDB_AUXV_GETAUXVAL_PRESENT)
++  if (getauxval(AT_HWCAP2) & PPC_FEATURE2_VEC_CRYPTO) return true;
+ #endif
++  return false;
++}
++#endif  // __power64__:
+ 
+ #if defined(__linux__) && defined(HAVE_ARM64_CRC)
+ uint32_t ExtendARMImpl(uint32_t crc, const char *buf, size_t size) {
+@@ -480,16 +456,9 @@ std::string IsFastCrc32Supported() {
+   bool has_fast_crc = false;
+   std::string fast_zero_msg;
+   std::string arch;
+-#ifdef HAVE_POWER8
+-#ifdef HAS_ALTIVEC
+-  if (arch_ppc_probe()) {
+-    has_fast_crc = true;
+-    arch = "PPC";
+-  }
+-#else
+-  has_fast_crc = false;
++#ifdef __powerpc64__
++  has_fast_crc = isAltiVec();
+   arch = "PPC";
+-#endif
+ #elif defined(__linux__) && defined(HAVE_ARM64_CRC)
+   if (crc32c_runtime_check()) {
+     has_fast_crc = true;
+@@ -1220,7 +1189,7 @@ uint32_t crc32c_3way(uint32_t crc, const char* buf, size_t len) {
+ #endif //HAVE_SSE42 && HAVE_PCLMUL
+ 
+ static inline Function Choose_Extend() {
+-#ifdef HAVE_POWER8
++#ifdef __powerpc64__
+   return isAltiVec() ? ExtendPPCImpl : ExtendImpl<Slow_CRC32>;
+ #elif defined(__linux__) && defined(HAVE_ARM64_CRC)
+   if(crc32c_runtime_check()) {
+diff --git a/util/crc32c_ppc.c b/util/crc32c_ppc.c
+deleted file mode 100644
+index 888a4943ea..0000000000
+--- a/util/crc32c_ppc.c
++++ /dev/null
+@@ -1,94 +0,0 @@
+-//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+-//  Copyright (c) 2017 International Business Machines Corp.
+-//  All rights reserved.
+-//  This source code is licensed under both the GPLv2 (found in the
+-//  COPYING file in the root directory) and Apache 2.0 License
+-//  (found in the LICENSE.Apache file in the root directory).
+-
+-#define CRC_TABLE
+-#include <stdint.h>
+-#include <stdlib.h>
+-#include <strings.h>
+-#include "util/crc32c_ppc_constants.h"
+-
+-#define VMX_ALIGN 16
+-#define VMX_ALIGN_MASK (VMX_ALIGN - 1)
+-
+-#ifdef REFLECT
+-static unsigned int crc32_align(unsigned int crc, unsigned char const *p,
+-                                unsigned long len) {
+-  while (len--) crc = crc_table[(crc ^ *p++) & 0xff] ^ (crc >> 8);
+-  return crc;
+-}
+-#endif
+-
+-#ifdef HAVE_POWER8
+-unsigned int __crc32_vpmsum(unsigned int crc, unsigned char const *p,
+-                            unsigned long len);
+-
+-static uint32_t crc32_vpmsum(uint32_t crc, unsigned char const *data,
+-                             unsigned len) {
+-  unsigned int prealign;
+-  unsigned int tail;
+-
+-#ifdef CRC_XOR
+-  crc ^= 0xffffffff;
+-#endif
+-
+-  if (len < VMX_ALIGN + VMX_ALIGN_MASK) {
+-    crc = crc32_align(crc, data, (unsigned long)len);
+-    goto out;
+-  }
+-
+-  if ((unsigned long)data & VMX_ALIGN_MASK) {
+-    prealign = VMX_ALIGN - ((unsigned long)data & VMX_ALIGN_MASK);
+-    crc = crc32_align(crc, data, prealign);
+-    len -= prealign;
+-    data += prealign;
+-  }
+-
+-  crc = __crc32_vpmsum(crc, data, (unsigned long)len & ~VMX_ALIGN_MASK);
+-
+-  tail = len & VMX_ALIGN_MASK;
+-  if (tail) {
+-    data += len & ~VMX_ALIGN_MASK;
+-    crc = crc32_align(crc, data, tail);
+-  }
+-
+-out:
+-#ifdef CRC_XOR
+-  crc ^= 0xffffffff;
+-#endif
+-
+-  return crc;
+-}
+-
+-/* This wrapper function works around the fact that crc32_vpmsum
+- * does not gracefully handle the case where the data pointer is NULL.  There
+- * may be room for performance improvement here.
+- */
+-uint32_t crc32c_ppc(uint32_t crc, unsigned char const *data, unsigned len) {
+-  unsigned char *buf2;
+-
+-  if (!data) {
+-    buf2 = (unsigned char *)malloc(len);
+-    bzero(buf2, len);
+-    crc = crc32_vpmsum(crc, buf2, len);
+-    free(buf2);
+-  } else {
+-    crc = crc32_vpmsum(crc, data, (unsigned long)len);
+-  }
+-  return crc;
+-}
+-
+-#else /* HAVE_POWER8 */
+-
+-/* This symbol has to exist on non-ppc architectures (and on legacy
+- * ppc systems using power7 or below) in order to compile properly
+- * there, even though it won't be called.
+- */
+-uint32_t crc32c_ppc(uint32_t crc, unsigned char const *data, unsigned len) {
+-  return 0;
+-}
+-
+-#endif /* HAVE_POWER8 */
+diff --git a/util/crc32c_ppc.cc b/util/crc32c_ppc.cc
+new file mode 100644
+index 0000000000..44487eb80b
+--- /dev/null
++++ b/util/crc32c_ppc.cc
+@@ -0,0 +1,662 @@
++/*
++ * Calculate the checksum of data that is 16 byte aligned and a multiple of
++ * 16 bytes.
++ *
++ * The first step is to reduce it to 1024 bits. We do this in 8 parallel
++ * chunks in order to mask the latency of the vpmsum instructions. If we
++ * have more than 32 kB of data to checksum we repeat this step multiple
++ * times, passing in the previous 1024 bits.
++ *
++ * The next step is to reduce the 1024 bits to 64 bits. This step adds
++ * 32 bits of 0s to the end - this matches what a CRC does. We just
++ * calculate constants that land the data in this 32 bits.
++ *
++ * We then use fixed point Barrett reduction to compute a mod n over GF(2)
++ * for n = CRC using POWER8 instructions. We use x = 32.
++ *
++ * http://en.wikipedia.org/wiki/Barrett_reduction
++ *
++ * This code uses gcc vector builtins instead using assembly directly.
++ *
++ * Copyright (C) 2017 Rogerio Alves <rogealve at br.ibm.com>, IBM
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of either:
++ *
++ *  a) the GNU General Public License as published by the Free Software
++ *     Foundation; either version 2 of the License, or (at your option)
++ *     any later version, or
++ *  b) the Apache License, Version 2.0
++ */
++
++#include <altivec.h>
++
++#define POWER8_INTRINSICS
++#define CRC_TABLE
++
++#include "crc32c_ppc_constants.h"
++
++#define VMX_ALIGN 16
++#define VMX_ALIGN_MASK (VMX_ALIGN - 1)
++
++#ifdef REFLECT
++static unsigned int crc32_align(unsigned int crc, const unsigned char *p,
++                                unsigned long len) {
++  while (len--) crc = crc_table[(crc ^ *p++) & 0xff] ^ (crc >> 8);
++  return crc;
++}
++#else
++static unsigned int crc32_align(unsigned int crc, const unsigned char *p,
++                                unsigned long len) {
++  while (len--) crc = crc_table[((crc >> 24) ^ *p++) & 0xff] ^ (crc << 8);
++  return crc;
++}
++#endif
++
++static unsigned int __attribute__((aligned(32)))
++__crc32_vpmsum(unsigned int crc, const void *p, unsigned long len);
++
++#ifndef CRC32_FUNCTION
++#define CRC32_FUNCTION crc32c_ppc
++#endif
++
++unsigned int CRC32_FUNCTION(unsigned int crc, const unsigned char *p,
++                            unsigned long len) {
++  unsigned int prealign;
++  unsigned int tail;
++
++#ifdef CRC_XOR
++  crc ^= 0xffffffff;
++#endif
++
++  if (len < VMX_ALIGN + VMX_ALIGN_MASK) {
++    crc = crc32_align(crc, p, len);
++    goto out;
++  }
++
++  if ((unsigned long)p & VMX_ALIGN_MASK) {
++    prealign = VMX_ALIGN - ((unsigned long)p & VMX_ALIGN_MASK);
++    crc = crc32_align(crc, p, prealign);
++    len -= prealign;
++    p += prealign;
++  }
++
++  crc = __crc32_vpmsum(crc, p, len & ~VMX_ALIGN_MASK);
++
++  tail = len & VMX_ALIGN_MASK;
++  if (tail) {
++    p += len & ~VMX_ALIGN_MASK;
++    crc = crc32_align(crc, p, tail);
++  }
++
++out:
++#ifdef CRC_XOR
++  crc ^= 0xffffffff;
++#endif
++
++  return crc;
++}
++
++#if defined(__clang__)
++#include "crc32c_ppc_clang_workaround.h"
++#else
++#define __builtin_pack_vector(a, b) __builtin_pack_vector_int128((a), (b))
++#define __builtin_unpack_vector_0(a) \
++  __builtin_unpack_vector_int128((vector __int128_t)(a), 0)
++#define __builtin_unpack_vector_1(a) \
++  __builtin_unpack_vector_int128((vector __int128_t)(a), 1)
++#endif
++
++/* When we have a load-store in a single-dispatch group and address overlap
++ * such that foward is not allowed (load-hit-store) the group must be flushed.
++ * A group ending NOP prevents the flush.
++ */
++#define GROUP_ENDING_NOP asm("ori 2,2,0" ::: "memory")
++
++#if defined(__BIG_ENDIAN__) && defined(REFLECT)
++#define BYTESWAP_DATA
++#elif defined(__LITTLE_ENDIAN__) && !defined(REFLECT)
++#define BYTESWAP_DATA
++#endif
++
++#ifdef BYTESWAP_DATA
++#define VEC_PERM(vr, va, vb, vc) \
++  vr = vec_perm(va, vb, (__vector unsigned char)vc)
++#if defined(__LITTLE_ENDIAN__)
++/* Byte reverse permute constant LE. */
++static const __vector unsigned long long vperm_const
++    __attribute__((aligned(16))) = {0x08090A0B0C0D0E0FUL, 0x0001020304050607UL};
++#else
++static const __vector unsigned long long vperm_const
++    __attribute__((aligned(16))) = {0x0F0E0D0C0B0A0908UL, 0X0706050403020100UL};
++#endif
++#else
++#define VEC_PERM(vr, va, vb, vc)
++#endif
++
++static unsigned int __attribute__((aligned(32)))
++__crc32_vpmsum(unsigned int crc, const void *p, unsigned long len) {
++  const __vector unsigned long long vzero = {0, 0};
++  const __vector unsigned long long vones = {0xffffffffffffffffUL,
++                                             0xffffffffffffffffUL};
++
++#ifdef REFLECT
++  const __vector unsigned long long vmask_32bit =
++      (__vector unsigned long long)vec_sld((__vector unsigned char)vzero,
++                                           (__vector unsigned char)vones, 4);
++#endif
++
++  const __vector unsigned long long vmask_64bit =
++      (__vector unsigned long long)vec_sld((__vector unsigned char)vzero,
++                                           (__vector unsigned char)vones, 8);
++
++  __vector unsigned long long vcrc;
++
++  __vector unsigned long long vconst1, vconst2;
++
++  /* vdata0-vdata7 will contain our data (p). */
++  __vector unsigned long long vdata0, vdata1, vdata2, vdata3, vdata4, vdata5,
++      vdata6, vdata7;
++
++  /* v0-v7 will contain our checksums */
++  __vector unsigned long long v0 = {0, 0};
++  __vector unsigned long long v1 = {0, 0};
++  __vector unsigned long long v2 = {0, 0};
++  __vector unsigned long long v3 = {0, 0};
++  __vector unsigned long long v4 = {0, 0};
++  __vector unsigned long long v5 = {0, 0};
++  __vector unsigned long long v6 = {0, 0};
++  __vector unsigned long long v7 = {0, 0};
++
++  /* Vector auxiliary variables. */
++  __vector unsigned long long va0, va1, va2, va3, va4, va5, va6, va7;
++
++  unsigned int result = 0;
++  unsigned int offset; /* Constant table offset. */
++
++  unsigned long i; /* Counter. */
++  unsigned long chunks;
++
++  unsigned long block_size;
++  int next_block = 0;
++
++  /* Align by 128 bits. The last 128 bit block will be processed at end. */
++  unsigned long length = len & 0xFFFFFFFFFFFFFF80UL;
++
++#ifdef REFLECT
++  vcrc = (__vector unsigned long long)__builtin_pack_vector(0UL, crc);
++#else
++  vcrc = (__vector unsigned long long)__builtin_pack_vector(crc, 0UL);
++
++  /* Shift into top 32 bits */
++  vcrc = (__vector unsigned long long)vec_sld((__vector unsigned char)vcrc,
++                                              (__vector unsigned char)vzero, 4);
++#endif
++
++  /* Short version. */
++  if (len < 256) {
++    /* Calculate where in the constant table we need to start. */
++    offset = 256 - len;
++
++    vconst1 = vec_ld(offset, vcrc_short_const);
++    vdata0 = vec_ld(0, (__vector unsigned long long *)p);
++    VEC_PERM(vdata0, vdata0, vconst1, vperm_const);
++
++    /* xor initial value*/
++    vdata0 = vec_xor(vdata0, vcrc);
++
++    vdata0 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata0, (__vector unsigned int)vconst1);
++    v0 = vec_xor(v0, vdata0);
++
++    for (i = 16; i < len; i += 16) {
++      vconst1 = vec_ld(offset + i, vcrc_short_const);
++      vdata0 = vec_ld(i, (__vector unsigned long long *)p);
++      VEC_PERM(vdata0, vdata0, vconst1, vperm_const);
++      vdata0 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++          (__vector unsigned int)vdata0, (__vector unsigned int)vconst1);
++      v0 = vec_xor(v0, vdata0);
++    }
++  } else {
++    /* Load initial values. */
++    vdata0 = vec_ld(0, (__vector unsigned long long *)p);
++    vdata1 = vec_ld(16, (__vector unsigned long long *)p);
++
++    VEC_PERM(vdata0, vdata0, vdata0, vperm_const);
++    VEC_PERM(vdata1, vdata1, vdata1, vperm_const);
++
++    vdata2 = vec_ld(32, (__vector unsigned long long *)p);
++    vdata3 = vec_ld(48, (__vector unsigned long long *)p);
++
++    VEC_PERM(vdata2, vdata2, vdata2, vperm_const);
++    VEC_PERM(vdata3, vdata3, vdata3, vperm_const);
++
++    vdata4 = vec_ld(64, (__vector unsigned long long *)p);
++    vdata5 = vec_ld(80, (__vector unsigned long long *)p);
++
++    VEC_PERM(vdata4, vdata4, vdata4, vperm_const);
++    VEC_PERM(vdata5, vdata5, vdata5, vperm_const);
++
++    vdata6 = vec_ld(96, (__vector unsigned long long *)p);
++    vdata7 = vec_ld(112, (__vector unsigned long long *)p);
++
++    VEC_PERM(vdata6, vdata6, vdata6, vperm_const);
++    VEC_PERM(vdata7, vdata7, vdata7, vperm_const);
++
++    /* xor in initial value */
++    vdata0 = vec_xor(vdata0, vcrc);
++
++    p = (char *)p + 128;
++
++    do {
++      /* Checksum in blocks of MAX_SIZE. */
++      block_size = length;
++      if (block_size > MAX_SIZE) {
++        block_size = MAX_SIZE;
++      }
++
++      length = length - block_size;
++
++      /*
++       * Work out the offset into the constants table to start at. Each
++       * constant is 16 bytes, and it is used against 128 bytes of input
++       * data - 128 / 16 = 8
++       */
++      offset = (MAX_SIZE / 8) - (block_size / 8);
++      /* We reduce our final 128 bytes in a separate step */
++      chunks = (block_size / 128) - 1;
++
++      vconst1 = vec_ld(offset, vcrc_const);
++
++      va0 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata0,
++                                     (__vector unsigned long long)vconst1);
++      va1 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata1,
++                                     (__vector unsigned long long)vconst1);
++      va2 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata2,
++                                     (__vector unsigned long long)vconst1);
++      va3 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata3,
++                                     (__vector unsigned long long)vconst1);
++      va4 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata4,
++                                     (__vector unsigned long long)vconst1);
++      va5 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata5,
++                                     (__vector unsigned long long)vconst1);
++      va6 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata6,
++                                     (__vector unsigned long long)vconst1);
++      va7 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata7,
++                                     (__vector unsigned long long)vconst1);
++
++      if (chunks > 1) {
++        offset += 16;
++        vconst2 = vec_ld(offset, vcrc_const);
++        GROUP_ENDING_NOP;
++
++        vdata0 = vec_ld(0, (__vector unsigned long long *)p);
++        VEC_PERM(vdata0, vdata0, vdata0, vperm_const);
++
++        vdata1 = vec_ld(16, (__vector unsigned long long *)p);
++        VEC_PERM(vdata1, vdata1, vdata1, vperm_const);
++
++        vdata2 = vec_ld(32, (__vector unsigned long long *)p);
++        VEC_PERM(vdata2, vdata2, vdata2, vperm_const);
++
++        vdata3 = vec_ld(48, (__vector unsigned long long *)p);
++        VEC_PERM(vdata3, vdata3, vdata3, vperm_const);
++
++        vdata4 = vec_ld(64, (__vector unsigned long long *)p);
++        VEC_PERM(vdata4, vdata4, vdata4, vperm_const);
++
++        vdata5 = vec_ld(80, (__vector unsigned long long *)p);
++        VEC_PERM(vdata5, vdata5, vdata5, vperm_const);
++
++        vdata6 = vec_ld(96, (__vector unsigned long long *)p);
++        VEC_PERM(vdata6, vdata6, vdata6, vperm_const);
++
++        vdata7 = vec_ld(112, (__vector unsigned long long *)p);
++        VEC_PERM(vdata7, vdata7, vdata7, vperm_const);
++
++        p = (char *)p + 128;
++
++        /*
++         * main loop. We modulo schedule it such that it takes three
++         * iterations to complete - first iteration load, second
++         * iteration vpmsum, third iteration xor.
++         */
++        for (i = 0; i < chunks - 2; i++) {
++          vconst1 = vec_ld(offset, vcrc_const);
++          offset += 16;
++          GROUP_ENDING_NOP;
++
++          v0 = vec_xor(v0, va0);
++          va0 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata0,
++                                         (__vector unsigned long long)vconst2);
++          vdata0 = vec_ld(0, (__vector unsigned long long *)p);
++          VEC_PERM(vdata0, vdata0, vdata0, vperm_const);
++          GROUP_ENDING_NOP;
++
++          v1 = vec_xor(v1, va1);
++          va1 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata1,
++                                         (__vector unsigned long long)vconst2);
++          vdata1 = vec_ld(16, (__vector unsigned long long *)p);
++          VEC_PERM(vdata1, vdata1, vdata1, vperm_const);
++          GROUP_ENDING_NOP;
++
++          v2 = vec_xor(v2, va2);
++          va2 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata2,
++                                         (__vector unsigned long long)vconst2);
++          vdata2 = vec_ld(32, (__vector unsigned long long *)p);
++          VEC_PERM(vdata2, vdata2, vdata2, vperm_const);
++          GROUP_ENDING_NOP;
++
++          v3 = vec_xor(v3, va3);
++          va3 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata3,
++                                         (__vector unsigned long long)vconst2);
++          vdata3 = vec_ld(48, (__vector unsigned long long *)p);
++          VEC_PERM(vdata3, vdata3, vdata3, vperm_const);
++
++          vconst2 = vec_ld(offset, vcrc_const);
++          GROUP_ENDING_NOP;
++
++          v4 = vec_xor(v4, va4);
++          va4 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata4,
++                                         (__vector unsigned long long)vconst1);
++          vdata4 = vec_ld(64, (__vector unsigned long long *)p);
++          VEC_PERM(vdata4, vdata4, vdata4, vperm_const);
++          GROUP_ENDING_NOP;
++
++          v5 = vec_xor(v5, va5);
++          va5 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata5,
++                                         (__vector unsigned long long)vconst1);
++          vdata5 = vec_ld(80, (__vector unsigned long long *)p);
++          VEC_PERM(vdata5, vdata5, vdata5, vperm_const);
++          GROUP_ENDING_NOP;
++
++          v6 = vec_xor(v6, va6);
++          va6 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata6,
++                                         (__vector unsigned long long)vconst1);
++          vdata6 = vec_ld(96, (__vector unsigned long long *)p);
++          VEC_PERM(vdata6, vdata6, vdata6, vperm_const);
++          GROUP_ENDING_NOP;
++
++          v7 = vec_xor(v7, va7);
++          va7 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata7,
++                                         (__vector unsigned long long)vconst1);
++          vdata7 = vec_ld(112, (__vector unsigned long long *)p);
++          VEC_PERM(vdata7, vdata7, vdata7, vperm_const);
++
++          p = (char *)p + 128;
++        }
++
++        /* First cool down*/
++        vconst1 = vec_ld(offset, vcrc_const);
++        offset += 16;
++
++        v0 = vec_xor(v0, va0);
++        va0 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata0,
++                                       (__vector unsigned long long)vconst1);
++        GROUP_ENDING_NOP;
++
++        v1 = vec_xor(v1, va1);
++        va1 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata1,
++                                       (__vector unsigned long long)vconst1);
++        GROUP_ENDING_NOP;
++
++        v2 = vec_xor(v2, va2);
++        va2 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata2,
++                                       (__vector unsigned long long)vconst1);
++        GROUP_ENDING_NOP;
++
++        v3 = vec_xor(v3, va3);
++        va3 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata3,
++                                       (__vector unsigned long long)vconst1);
++        GROUP_ENDING_NOP;
++
++        v4 = vec_xor(v4, va4);
++        va4 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata4,
++                                       (__vector unsigned long long)vconst1);
++        GROUP_ENDING_NOP;
++
++        v5 = vec_xor(v5, va5);
++        va5 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata5,
++                                       (__vector unsigned long long)vconst1);
++        GROUP_ENDING_NOP;
++
++        v6 = vec_xor(v6, va6);
++        va6 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata6,
++                                       (__vector unsigned long long)vconst1);
++        GROUP_ENDING_NOP;
++
++        v7 = vec_xor(v7, va7);
++        va7 = __builtin_crypto_vpmsumd((__vector unsigned long long)vdata7,
++                                       (__vector unsigned long long)vconst1);
++      } /* else */
++
++      /* Second cool down. */
++      v0 = vec_xor(v0, va0);
++      v1 = vec_xor(v1, va1);
++      v2 = vec_xor(v2, va2);
++      v3 = vec_xor(v3, va3);
++      v4 = vec_xor(v4, va4);
++      v5 = vec_xor(v5, va5);
++      v6 = vec_xor(v6, va6);
++      v7 = vec_xor(v7, va7);
++
++#ifdef REFLECT
++      /*
++       * vpmsumd produces a 96 bit result in the least significant bits
++       * of the register. Since we are bit reflected we have to shift it
++       * left 32 bits so it occupies the least significant bits in the
++       * bit reflected domain.
++       */
++      v0 = (__vector unsigned long long)vec_sld(
++          (__vector unsigned char)v0, (__vector unsigned char)vzero, 4);
++      v1 = (__vector unsigned long long)vec_sld(
++          (__vector unsigned char)v1, (__vector unsigned char)vzero, 4);
++      v2 = (__vector unsigned long long)vec_sld(
++          (__vector unsigned char)v2, (__vector unsigned char)vzero, 4);
++      v3 = (__vector unsigned long long)vec_sld(
++          (__vector unsigned char)v3, (__vector unsigned char)vzero, 4);
++      v4 = (__vector unsigned long long)vec_sld(
++          (__vector unsigned char)v4, (__vector unsigned char)vzero, 4);
++      v5 = (__vector unsigned long long)vec_sld(
++          (__vector unsigned char)v5, (__vector unsigned char)vzero, 4);
++      v6 = (__vector unsigned long long)vec_sld(
++          (__vector unsigned char)v6, (__vector unsigned char)vzero, 4);
++      v7 = (__vector unsigned long long)vec_sld(
++          (__vector unsigned char)v7, (__vector unsigned char)vzero, 4);
++#endif
++
++      /* xor with the last 1024 bits. */
++      va0 = vec_ld(0, (__vector unsigned long long *)p);
++      VEC_PERM(va0, va0, va0, vperm_const);
++
++      va1 = vec_ld(16, (__vector unsigned long long *)p);
++      VEC_PERM(va1, va1, va1, vperm_const);
++
++      va2 = vec_ld(32, (__vector unsigned long long *)p);
++      VEC_PERM(va2, va2, va2, vperm_const);
++
++      va3 = vec_ld(48, (__vector unsigned long long *)p);
++      VEC_PERM(va3, va3, va3, vperm_const);
++
++      va4 = vec_ld(64, (__vector unsigned long long *)p);
++      VEC_PERM(va4, va4, va4, vperm_const);
++
++      va5 = vec_ld(80, (__vector unsigned long long *)p);
++      VEC_PERM(va5, va5, va5, vperm_const);
++
++      va6 = vec_ld(96, (__vector unsigned long long *)p);
++      VEC_PERM(va6, va6, va6, vperm_const);
++
++      va7 = vec_ld(112, (__vector unsigned long long *)p);
++      VEC_PERM(va7, va7, va7, vperm_const);
++
++      p = (char *)p + 128;
++
++      vdata0 = vec_xor(v0, va0);
++      vdata1 = vec_xor(v1, va1);
++      vdata2 = vec_xor(v2, va2);
++      vdata3 = vec_xor(v3, va3);
++      vdata4 = vec_xor(v4, va4);
++      vdata5 = vec_xor(v5, va5);
++      vdata6 = vec_xor(v6, va6);
++      vdata7 = vec_xor(v7, va7);
++
++      /* Check if we have more blocks to process */
++      next_block = 0;
++      if (length != 0) {
++        next_block = 1;
++
++        /* zero v0-v7 */
++        v0 = vec_xor(v0, v0);
++        v1 = vec_xor(v1, v1);
++        v2 = vec_xor(v2, v2);
++        v3 = vec_xor(v3, v3);
++        v4 = vec_xor(v4, v4);
++        v5 = vec_xor(v5, v5);
++        v6 = vec_xor(v6, v6);
++        v7 = vec_xor(v7, v7);
++      }
++      length = length + 128;
++
++    } while (next_block);
++
++    /* Calculate how many bytes we have left. */
++    length = (len & 127);
++
++    /* Calculate where in (short) constant table we need to start. */
++    offset = 128 - length;
++
++    v0 = vec_ld(offset, vcrc_short_const);
++    v1 = vec_ld(offset + 16, vcrc_short_const);
++    v2 = vec_ld(offset + 32, vcrc_short_const);
++    v3 = vec_ld(offset + 48, vcrc_short_const);
++    v4 = vec_ld(offset + 64, vcrc_short_const);
++    v5 = vec_ld(offset + 80, vcrc_short_const);
++    v6 = vec_ld(offset + 96, vcrc_short_const);
++    v7 = vec_ld(offset + 112, vcrc_short_const);
++
++    offset += 128;
++
++    v0 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata0, (__vector unsigned int)v0);
++    v1 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata1, (__vector unsigned int)v1);
++    v2 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata2, (__vector unsigned int)v2);
++    v3 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata3, (__vector unsigned int)v3);
++    v4 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata4, (__vector unsigned int)v4);
++    v5 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata5, (__vector unsigned int)v5);
++    v6 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata6, (__vector unsigned int)v6);
++    v7 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++        (__vector unsigned int)vdata7, (__vector unsigned int)v7);
++
++    /* Now reduce the tail (0-112 bytes). */
++    for (i = 0; i < length; i += 16) {
++      vdata0 = vec_ld(i, (__vector unsigned long long *)p);
++      VEC_PERM(vdata0, vdata0, vdata0, vperm_const);
++      va0 = vec_ld(offset + i, vcrc_short_const);
++      va0 = (__vector unsigned long long)__builtin_crypto_vpmsumw(
++          (__vector unsigned int)vdata0, (__vector unsigned int)va0);
++      v0 = vec_xor(v0, va0);
++    }
++
++    /* xor all parallel chunks together. */
++    v0 = vec_xor(v0, v1);
++    v2 = vec_xor(v2, v3);
++    v4 = vec_xor(v4, v5);
++    v6 = vec_xor(v6, v7);
++
++    v0 = vec_xor(v0, v2);
++    v4 = vec_xor(v4, v6);
++
++    v0 = vec_xor(v0, v4);
++  }
++
++  /* Barrett Reduction */
++  vconst1 = vec_ld(0, v_Barrett_const);
++  vconst2 = vec_ld(16, v_Barrett_const);
++
++  v1 = (__vector unsigned long long)vec_sld((__vector unsigned char)v0,
++                                            (__vector unsigned char)v0, 8);
++  v0 = vec_xor(v1, v0);
++
++#ifdef REFLECT
++  /* shift left one bit */
++  __vector unsigned char vsht_splat = vec_splat_u8(1);
++  v0 = (__vector unsigned long long)vec_sll((__vector unsigned char)v0,
++                                            vsht_splat);
++#endif
++
++  v0 = vec_and(v0, vmask_64bit);
++
++#ifndef REFLECT
++
++  /*
++   * Now for the actual algorithm. The idea is to calculate q,
++   * the multiple of our polynomial that we need to subtract. By
++   * doing the computation 2x bits higher (ie 64 bits) and shifting the
++   * result back down 2x bits, we round down to the nearest multiple.
++   */
++
++  /* ma */
++  v1 = __builtin_crypto_vpmsumd((__vector unsigned long long)v0,
++                                (__vector unsigned long long)vconst1);
++  /* q = floor(ma/(2^64)) */
++  v1 = (__vector unsigned long long)vec_sld((__vector unsigned char)vzero,
++                                            (__vector unsigned char)v1, 8);
++  /* qn */
++  v1 = __builtin_crypto_vpmsumd((__vector unsigned long long)v1,
++                                (__vector unsigned long long)vconst2);
++  /* a - qn, subtraction is xor in GF(2) */
++  v0 = vec_xor(v0, v1);
++  /*
++   * Get the result into r3. We need to shift it left 8 bytes:
++   * V0 [ 0 1 2 X ]
++   * V0 [ 0 X 2 3 ]
++   */
++  result = __builtin_unpack_vector_1(v0);
++#else
++
++  /*
++   * The reflected version of Barrett reduction. Instead of bit
++   * reflecting our data (which is expensive to do), we bit reflect our
++   * constants and our algorithm, which means the intermediate data in
++   * our vector registers goes from 0-63 instead of 63-0. We can reflect
++   * the algorithm because we don't carry in mod 2 arithmetic.
++   */
++
++  /* bottom 32 bits of a */
++  v1 = vec_and(v0, vmask_32bit);
++
++  /* ma */
++  v1 = __builtin_crypto_vpmsumd((__vector unsigned long long)v1,
++                                (__vector unsigned long long)vconst1);
++
++  /* bottom 32bits of ma */
++  v1 = vec_and(v1, vmask_32bit);
++  /* qn */
++  v1 = __builtin_crypto_vpmsumd((__vector unsigned long long)v1,
++                                (__vector unsigned long long)vconst2);
++  /* a - qn, subtraction is xor in GF(2) */
++  v0 = vec_xor(v0, v1);
++
++  /*
++   * Since we are bit reflected, the result (ie the low 32 bits) is in
++   * the high 32 bits. We just need to shift it left 4 bytes
++   * V0 [ 0 1 X 3 ]
++   * V0 [ 0 X 2 3 ]
++   */
++
++  /* shift result into top 64 bits of */
++  v0 = (__vector unsigned long long)vec_sld((__vector unsigned char)v0,
++                                            (__vector unsigned char)vzero, 4);
++
++  result = __builtin_unpack_vector_0(v0);
++#endif
++
++  return result;
++}
+diff --git a/util/crc32c_ppc.h b/util/crc32c_ppc.h
+deleted file mode 100644
+index c359061c61..0000000000
+--- a/util/crc32c_ppc.h
++++ /dev/null
+@@ -1,19 +0,0 @@
+-//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+-//  Copyright (c) 2017 International Business Machines Corp.
+-//  All rights reserved.
+-//  This source code is licensed under both the GPLv2 (found in the
+-//  COPYING file in the root directory) and Apache 2.0 License
+-//  (found in the LICENSE.Apache file in the root directory).
+-
+-#pragma once
+-
+-#ifdef __cplusplus
+-extern "C" {
+-#endif
+-
+-extern uint32_t crc32c_ppc(uint32_t crc, unsigned char const *buffer,
+-                           unsigned len);
+-
+-#ifdef __cplusplus
+-}
+-#endif
+diff --git a/util/crc32c_ppc_asm.S b/util/crc32c_ppc_asm.S
+deleted file mode 100644
+index a317bf96b8..0000000000
+--- a/util/crc32c_ppc_asm.S
++++ /dev/null
+@@ -1,752 +0,0 @@
+-//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+-//  Copyright (c) 2015 Anton Blanchard <anton at au.ibm.com>, IBM
+-//  Copyright (c) 2017 International Business Machines Corp.
+-//  All rights reserved.
+-//  This source code is licensed under both the GPLv2 (found in the
+-//  COPYING file in the root directory) and Apache 2.0 License
+-//  (found in the LICENSE.Apache file in the root directory).
+-
+-#include <ppc-asm.h>
+-#include "ppc-opcode.h"
+-
+-#undef toc
+-
+-#ifndef r1
+-#define r1 1
+-#endif
+-
+-#ifndef r2
+-#define r2 2
+-#endif
+-
+-	.section	.rodata
+-.balign 16
+-
+-.byteswap_constant:
+-	/* byte reverse permute constant */
+-	.octa 0x0F0E0D0C0B0A09080706050403020100
+-
+-#define __ASSEMBLY__
+-#include "crc32c_ppc_constants.h"
+-
+-	.text
+-
+-#if defined(__BIG_ENDIAN__) && defined(REFLECT)
+-#define BYTESWAP_DATA
+-#elif defined(__LITTLE_ENDIAN__) && !defined(REFLECT)
+-#define BYTESWAP_DATA
+-#else
+-#undef BYTESWAP_DATA
+-#endif
+-
+-#define off16		r25
+-#define off32		r26
+-#define off48		r27
+-#define off64		r28
+-#define off80		r29
+-#define off96		r30
+-#define off112		r31
+-
+-#define const1		v24
+-#define const2		v25
+-
+-#define byteswap	v26
+-#define	mask_32bit	v27
+-#define	mask_64bit	v28
+-#define zeroes		v29
+-
+-#ifdef BYTESWAP_DATA
+-#define VPERM(A, B, C, D) vperm	A, B, C, D
+-#else
+-#define VPERM(A, B, C, D)
+-#endif
+-
+-/* unsigned int __crc32_vpmsum(unsigned int crc, void *p, unsigned long len) */
+-FUNC_START(__crc32_vpmsum)
+-	std	r31,-8(r1)
+-	std	r30,-16(r1)
+-	std	r29,-24(r1)
+-	std	r28,-32(r1)
+-	std	r27,-40(r1)
+-	std	r26,-48(r1)
+-	std	r25,-56(r1)
+-
+-	li	off16,16
+-	li	off32,32
+-	li	off48,48
+-	li	off64,64
+-	li	off80,80
+-	li	off96,96
+-	li	off112,112
+-	li	r0,0
+-
+-	/* Enough room for saving 10 non volatile VMX registers */
+-	subi	r6,r1,56+10*16
+-	subi	r7,r1,56+2*16
+-
+-	stvx	v20,0,r6
+-	stvx	v21,off16,r6
+-	stvx	v22,off32,r6
+-	stvx	v23,off48,r6
+-	stvx	v24,off64,r6
+-	stvx	v25,off80,r6
+-	stvx	v26,off96,r6
+-	stvx	v27,off112,r6
+-	stvx	v28,0,r7
+-	stvx	v29,off16,r7
+-
+-	mr	r10,r3
+-
+-	vxor	zeroes,zeroes,zeroes
+-	vspltisw v0,-1
+-
+-	vsldoi	mask_32bit,zeroes,v0,4
+-	vsldoi	mask_64bit,zeroes,v0,8
+-
+-	/* Get the initial value into v8 */
+-	vxor	v8,v8,v8
+-	MTVRD(v8, r3)
+-#ifdef REFLECT
+-	vsldoi	v8,zeroes,v8,8	/* shift into bottom 32 bits */
+-#else
+-	vsldoi	v8,v8,zeroes,4	/* shift into top 32 bits */
+-#endif
+-
+-#ifdef BYTESWAP_DATA
+-	addis	r3,r2,.byteswap_constant at toc@ha
+-	addi	r3,r3,.byteswap_constant at toc@l
+-
+-	lvx	byteswap,0,r3
+-	addi	r3,r3,16
+-#endif
+-
+-	cmpdi	r5,256
+-	blt	.Lshort
+-
+-	rldicr	r6,r5,0,56
+-
+-	/* Checksum in blocks of MAX_SIZE */
+-1:	lis	r7,MAX_SIZE at h
+-	ori	r7,r7,MAX_SIZE at l
+-	mr	r9,r7
+-	cmpd	r6,r7
+-	bgt	2f
+-	mr	r7,r6
+-2:	subf	r6,r7,r6
+-
+-	/* our main loop does 128 bytes at a time */
+-	srdi	r7,r7,7
+-
+-	/*
+-	 * Work out the offset into the constants table to start at. Each
+-	 * constant is 16 bytes, and it is used against 128 bytes of input
+-	 * data - 128 / 16 = 8
+-	 */
+-	sldi	r8,r7,4
+-	srdi	r9,r9,3
+-	subf	r8,r8,r9
+-
+-	/* We reduce our final 128 bytes in a separate step */
+-	addi	r7,r7,-1
+-	mtctr	r7
+-
+-	addis	r3,r2,.constants at toc@ha
+-	addi	r3,r3,.constants at toc@l
+-
+-	/* Find the start of our constants */
+-	add	r3,r3,r8
+-
+-	/* zero v0-v7 which will contain our checksums */
+-	vxor	v0,v0,v0
+-	vxor	v1,v1,v1
+-	vxor	v2,v2,v2
+-	vxor	v3,v3,v3
+-	vxor	v4,v4,v4
+-	vxor	v5,v5,v5
+-	vxor	v6,v6,v6
+-	vxor	v7,v7,v7
+-
+-	lvx	const1,0,r3
+-
+-	/*
+-	 * If we are looping back to consume more data we use the values
+-	 * already in v16-v23.
+-	 */
+-	cmpdi	r0,1
+-	beq	2f
+-
+-	/* First warm up pass */
+-	lvx	v16,0,r4
+-	lvx	v17,off16,r4
+-	VPERM(v16,v16,v16,byteswap)
+-	VPERM(v17,v17,v17,byteswap)
+-	lvx	v18,off32,r4
+-	lvx	v19,off48,r4
+-	VPERM(v18,v18,v18,byteswap)
+-	VPERM(v19,v19,v19,byteswap)
+-	lvx	v20,off64,r4
+-	lvx	v21,off80,r4
+-	VPERM(v20,v20,v20,byteswap)
+-	VPERM(v21,v21,v21,byteswap)
+-	lvx	v22,off96,r4
+-	lvx	v23,off112,r4
+-	VPERM(v22,v22,v22,byteswap)
+-	VPERM(v23,v23,v23,byteswap)
+-	addi	r4,r4,8*16
+-
+-	/* xor in initial value */
+-	vxor	v16,v16,v8
+-
+-2:	bdz	.Lfirst_warm_up_done
+-
+-	addi	r3,r3,16
+-	lvx	const2,0,r3
+-
+-	/* Second warm up pass */
+-	VPMSUMD(v8,v16,const1)
+-	lvx	v16,0,r4
+-	VPERM(v16,v16,v16,byteswap)
+-	ori	r2,r2,0
+-
+-	VPMSUMD(v9,v17,const1)
+-	lvx	v17,off16,r4
+-	VPERM(v17,v17,v17,byteswap)
+-	ori	r2,r2,0
+-
+-	VPMSUMD(v10,v18,const1)
+-	lvx	v18,off32,r4
+-	VPERM(v18,v18,v18,byteswap)
+-	ori	r2,r2,0
+-
+-	VPMSUMD(v11,v19,const1)
+-	lvx	v19,off48,r4
+-	VPERM(v19,v19,v19,byteswap)
+-	ori	r2,r2,0
+-
+-	VPMSUMD(v12,v20,const1)
+-	lvx	v20,off64,r4
+-	VPERM(v20,v20,v20,byteswap)
+-	ori	r2,r2,0
+-
+-	VPMSUMD(v13,v21,const1)
+-	lvx	v21,off80,r4
+-	VPERM(v21,v21,v21,byteswap)
+-	ori	r2,r2,0
+-
+-	VPMSUMD(v14,v22,const1)
+-	lvx	v22,off96,r4
+-	VPERM(v22,v22,v22,byteswap)
+-	ori	r2,r2,0
+-
+-	VPMSUMD(v15,v23,const1)
+-	lvx	v23,off112,r4
+-	VPERM(v23,v23,v23,byteswap)
+-
+-	addi	r4,r4,8*16
+-
+-	bdz	.Lfirst_cool_down
+-
+-	/*
+-	 * main loop. We modulo schedule it such that it takes three iterations
+-	 * to complete - first iteration load, second iteration vpmsum, third
+-	 * iteration xor.
+-	 */
+-	.balign	16
+-4:	lvx	const1,0,r3
+-	addi	r3,r3,16
+-	ori	r2,r2,0
+-
+-	vxor	v0,v0,v8
+-	VPMSUMD(v8,v16,const2)
+-	lvx	v16,0,r4
+-	VPERM(v16,v16,v16,byteswap)
+-	ori	r2,r2,0
+-
+-	vxor	v1,v1,v9
+-	VPMSUMD(v9,v17,const2)
+-	lvx	v17,off16,r4
+-	VPERM(v17,v17,v17,byteswap)
+-	ori	r2,r2,0
+-
+-	vxor	v2,v2,v10
+-	VPMSUMD(v10,v18,const2)
+-	lvx	v18,off32,r4
+-	VPERM(v18,v18,v18,byteswap)
+-	ori	r2,r2,0
+-
+-	vxor	v3,v3,v11
+-	VPMSUMD(v11,v19,const2)
+-	lvx	v19,off48,r4
+-	VPERM(v19,v19,v19,byteswap)
+-	lvx	const2,0,r3
+-	ori	r2,r2,0
+-
+-	vxor	v4,v4,v12
+-	VPMSUMD(v12,v20,const1)
+-	lvx	v20,off64,r4
+-	VPERM(v20,v20,v20,byteswap)
+-	ori	r2,r2,0
+-
+-	vxor	v5,v5,v13
+-	VPMSUMD(v13,v21,const1)
+-	lvx	v21,off80,r4
+-	VPERM(v21,v21,v21,byteswap)
+-	ori	r2,r2,0
+-
+-	vxor	v6,v6,v14
+-	VPMSUMD(v14,v22,const1)
+-	lvx	v22,off96,r4
+-	VPERM(v22,v22,v22,byteswap)
+-	ori	r2,r2,0
+-
+-	vxor	v7,v7,v15
+-	VPMSUMD(v15,v23,const1)
+-	lvx	v23,off112,r4
+-	VPERM(v23,v23,v23,byteswap)
+-
+-	addi	r4,r4,8*16
+-
+-	bdnz	4b
+-
+-.Lfirst_cool_down:
+-	/* First cool down pass */
+-	lvx	const1,0,r3
+-	addi	r3,r3,16
+-
+-	vxor	v0,v0,v8
+-	VPMSUMD(v8,v16,const1)
+-	ori	r2,r2,0
+-
+-	vxor	v1,v1,v9
+-	VPMSUMD(v9,v17,const1)
+-	ori	r2,r2,0
+-
+-	vxor	v2,v2,v10
+-	VPMSUMD(v10,v18,const1)
+-	ori	r2,r2,0
+-
+-	vxor	v3,v3,v11
+-	VPMSUMD(v11,v19,const1)
+-	ori	r2,r2,0
+-
+-	vxor	v4,v4,v12
+-	VPMSUMD(v12,v20,const1)
+-	ori	r2,r2,0
+-
+-	vxor	v5,v5,v13
+-	VPMSUMD(v13,v21,const1)
+-	ori	r2,r2,0
+-
+-	vxor	v6,v6,v14
+-	VPMSUMD(v14,v22,const1)
+-	ori	r2,r2,0
+-
+-	vxor	v7,v7,v15
+-	VPMSUMD(v15,v23,const1)
+-	ori	r2,r2,0
+-
+-.Lsecond_cool_down:
+-	/* Second cool down pass */
+-	vxor	v0,v0,v8
+-	vxor	v1,v1,v9
+-	vxor	v2,v2,v10
+-	vxor	v3,v3,v11
+-	vxor	v4,v4,v12
+-	vxor	v5,v5,v13
+-	vxor	v6,v6,v14
+-	vxor	v7,v7,v15
+-
+-#ifdef REFLECT
+-	/*
+-	 * vpmsumd produces a 96 bit result in the least significant bits
+-	 * of the register. Since we are bit reflected we have to shift it
+-	 * left 32 bits so it occupies the least significant bits in the
+-	 * bit reflected domain.
+-	 */
+-	vsldoi	v0,v0,zeroes,4
+-	vsldoi	v1,v1,zeroes,4
+-	vsldoi	v2,v2,zeroes,4
+-	vsldoi	v3,v3,zeroes,4
+-	vsldoi	v4,v4,zeroes,4
+-	vsldoi	v5,v5,zeroes,4
+-	vsldoi	v6,v6,zeroes,4
+-	vsldoi	v7,v7,zeroes,4
+-#endif
+-
+-	/* xor with last 1024 bits */
+-	lvx	v8,0,r4
+-	lvx	v9,off16,r4
+-	VPERM(v8,v8,v8,byteswap)
+-	VPERM(v9,v9,v9,byteswap)
+-	lvx	v10,off32,r4
+-	lvx	v11,off48,r4
+-	VPERM(v10,v10,v10,byteswap)
+-	VPERM(v11,v11,v11,byteswap)
+-	lvx	v12,off64,r4
+-	lvx	v13,off80,r4
+-	VPERM(v12,v12,v12,byteswap)
+-	VPERM(v13,v13,v13,byteswap)
+-	lvx	v14,off96,r4
+-	lvx	v15,off112,r4
+-	VPERM(v14,v14,v14,byteswap)
+-	VPERM(v15,v15,v15,byteswap)
+-
+-	addi	r4,r4,8*16
+-
+-	vxor	v16,v0,v8
+-	vxor	v17,v1,v9
+-	vxor	v18,v2,v10
+-	vxor	v19,v3,v11
+-	vxor	v20,v4,v12
+-	vxor	v21,v5,v13
+-	vxor	v22,v6,v14
+-	vxor	v23,v7,v15
+-
+-	li	r0,1
+-	cmpdi	r6,0
+-	addi	r6,r6,128
+-	bne	1b
+-
+-	/* Work out how many bytes we have left */
+-	andi.	r5,r5,127
+-
+-	/* Calculate where in the constant table we need to start */
+-	subfic	r6,r5,128
+-	add	r3,r3,r6
+-
+-	/* How many 16 byte chunks are in the tail */
+-	srdi	r7,r5,4
+-	mtctr	r7
+-
+-	/*
+-	 * Reduce the previously calculated 1024 bits to 64 bits, shifting
+-	 * 32 bits to include the trailing 32 bits of zeros
+-	 */
+-	lvx	v0,0,r3
+-	lvx	v1,off16,r3
+-	lvx	v2,off32,r3
+-	lvx	v3,off48,r3
+-	lvx	v4,off64,r3
+-	lvx	v5,off80,r3
+-	lvx	v6,off96,r3
+-	lvx	v7,off112,r3
+-	addi	r3,r3,8*16
+-
+-	VPMSUMW(v0,v16,v0)
+-	VPMSUMW(v1,v17,v1)
+-	VPMSUMW(v2,v18,v2)
+-	VPMSUMW(v3,v19,v3)
+-	VPMSUMW(v4,v20,v4)
+-	VPMSUMW(v5,v21,v5)
+-	VPMSUMW(v6,v22,v6)
+-	VPMSUMW(v7,v23,v7)
+-
+-	/* Now reduce the tail (0 - 112 bytes) */
+-	cmpdi	r7,0
+-	beq	1f
+-
+-	lvx	v16,0,r4
+-	lvx	v17,0,r3
+-	VPERM(v16,v16,v16,byteswap)
+-	VPMSUMW(v16,v16,v17)
+-	vxor	v0,v0,v16
+-	bdz	1f
+-
+-	lvx	v16,off16,r4
+-	lvx	v17,off16,r3
+-	VPERM(v16,v16,v16,byteswap)
+-	VPMSUMW(v16,v16,v17)
+-	vxor	v0,v0,v16
+-	bdz	1f
+-
+-	lvx	v16,off32,r4
+-	lvx	v17,off32,r3
+-	VPERM(v16,v16,v16,byteswap)
+-	VPMSUMW(v16,v16,v17)
+-	vxor	v0,v0,v16
+-	bdz	1f
+-
+-	lvx	v16,off48,r4
+-	lvx	v17,off48,r3
+-	VPERM(v16,v16,v16,byteswap)
+-	VPMSUMW(v16,v16,v17)
+-	vxor	v0,v0,v16
+-	bdz	1f
+-
+-	lvx	v16,off64,r4
+-	lvx	v17,off64,r3
+-	VPERM(v16,v16,v16,byteswap)
+-	VPMSUMW(v16,v16,v17)
+-	vxor	v0,v0,v16
+-	bdz	1f
+-
+-	lvx	v16,off80,r4
+-	lvx	v17,off80,r3
+-	VPERM(v16,v16,v16,byteswap)
+-	VPMSUMW(v16,v16,v17)
+-	vxor	v0,v0,v16
+-	bdz	1f
+-
+-	lvx	v16,off96,r4
+-	lvx	v17,off96,r3
+-	VPERM(v16,v16,v16,byteswap)
+-	VPMSUMW(v16,v16,v17)
+-	vxor	v0,v0,v16
+-
+-	/* Now xor all the parallel chunks together */
+-1:	vxor	v0,v0,v1
+-	vxor	v2,v2,v3
+-	vxor	v4,v4,v5
+-	vxor	v6,v6,v7
+-
+-	vxor	v0,v0,v2
+-	vxor	v4,v4,v6
+-
+-	vxor	v0,v0,v4
+-
+-.Lbarrett_reduction:
+-	/* Barrett constants */
+-	addis	r3,r2,.barrett_constants at toc@ha
+-	addi	r3,r3,.barrett_constants at toc@l
+-
+-	lvx	const1,0,r3
+-	lvx	const2,off16,r3
+-
+-	vsldoi	v1,v0,v0,8
+-	vxor	v0,v0,v1		/* xor two 64 bit results together */
+-
+-#ifdef REFLECT
+-	/* shift left one bit */
+-	vspltisb v1,1
+-	vsl	v0,v0,v1
+-#endif
+-
+-	vand	v0,v0,mask_64bit
+-
+-#ifndef REFLECT
+-	/*
+-	 * Now for the Barrett reduction algorithm. The idea is to calculate q,
+-	 * the multiple of our polynomial that we need to subtract. By
+-	 * doing the computation 2x bits higher (ie 64 bits) and shifting the
+-	 * result back down 2x bits, we round down to the nearest multiple.
+-	 */
+-	VPMSUMD(v1,v0,const1)	/* ma */
+-	vsldoi	v1,zeroes,v1,8	/* q = floor(ma/(2^64)) */
+-	VPMSUMD(v1,v1,const2)	/* qn */
+-	vxor	v0,v0,v1	/* a - qn, subtraction is xor in GF(2) */
+-
+-	/*
+-	 * Get the result into r3. We need to shift it left 8 bytes:
+-	 * V0 [ 0 1 2 X ]
+-	 * V0 [ 0 X 2 3 ]
+-	 */
+-	vsldoi	v0,v0,zeroes,8	/* shift result into top 64 bits */
+-#else
+-	/*
+-	 * The reflected version of Barrett reduction. Instead of bit
+-	 * reflecting our data (which is expensive to do), we bit reflect our
+-	 * constants and our algorithm, which means the intermediate data in
+-	 * our vector registers goes from 0-63 instead of 63-0. We can reflect
+-	 * the algorithm because we don't carry in mod 2 arithmetic.
+-	 */
+-	vand	v1,v0,mask_32bit	/* bottom 32 bits of a */
+-	VPMSUMD(v1,v1,const1)		/* ma */
+-	vand	v1,v1,mask_32bit	/* bottom 32bits of ma */
+-	VPMSUMD(v1,v1,const2)		/* qn */
+-	vxor	v0,v0,v1		/* a - qn, subtraction is xor in GF(2) */
+-
+-	/*
+-	 * Since we are bit reflected, the result (ie the low 32 bits) is in
+-	 * the high 32 bits. We just need to shift it left 4 bytes
+-	 * V0 [ 0 1 X 3 ]
+-	 * V0 [ 0 X 2 3 ]
+-	 */
+-	vsldoi	v0,v0,zeroes,4		/* shift result into top 64 bits of */
+-#endif
+-
+-	/* Get it into r3 */
+-	MFVRD(r3, v0)
+-
+-.Lout:
+-	subi	r6,r1,56+10*16
+-	subi	r7,r1,56+2*16
+-
+-	lvx	v20,0,r6
+-	lvx	v21,off16,r6
+-	lvx	v22,off32,r6
+-	lvx	v23,off48,r6
+-	lvx	v24,off64,r6
+-	lvx	v25,off80,r6
+-	lvx	v26,off96,r6
+-	lvx	v27,off112,r6
+-	lvx	v28,0,r7
+-	lvx	v29,off16,r7
+-
+-	ld	r31,-8(r1)
+-	ld	r30,-16(r1)
+-	ld	r29,-24(r1)
+-	ld	r28,-32(r1)
+-	ld	r27,-40(r1)
+-	ld	r26,-48(r1)
+-	ld	r25,-56(r1)
+-
+-	blr
+-
+-.Lfirst_warm_up_done:
+-	lvx	const1,0,r3
+-	addi	r3,r3,16
+-
+-	VPMSUMD(v8,v16,const1)
+-	VPMSUMD(v9,v17,const1)
+-	VPMSUMD(v10,v18,const1)
+-	VPMSUMD(v11,v19,const1)
+-	VPMSUMD(v12,v20,const1)
+-	VPMSUMD(v13,v21,const1)
+-	VPMSUMD(v14,v22,const1)
+-	VPMSUMD(v15,v23,const1)
+-
+-	b	.Lsecond_cool_down
+-
+-.Lshort:
+-	cmpdi	r5,0
+-	beq	.Lzero
+-
+-	addis	r3,r2,.short_constants at toc@ha
+-	addi	r3,r3,.short_constants at toc@l
+-
+-	/* Calculate where in the constant table we need to start */
+-	subfic	r6,r5,256
+-	add	r3,r3,r6
+-
+-	/* How many 16 byte chunks? */
+-	srdi	r7,r5,4
+-	mtctr	r7
+-
+-	vxor	v19,v19,v19
+-	vxor	v20,v20,v20
+-
+-	lvx	v0,0,r4
+-	lvx	v16,0,r3
+-	VPERM(v0,v0,v16,byteswap)
+-	vxor	v0,v0,v8	/* xor in initial value */
+-	VPMSUMW(v0,v0,v16)
+-	bdz	.Lv0
+-
+-	lvx	v1,off16,r4
+-	lvx	v17,off16,r3
+-	VPERM(v1,v1,v17,byteswap)
+-	VPMSUMW(v1,v1,v17)
+-	bdz	.Lv1
+-
+-	lvx	v2,off32,r4
+-	lvx	v16,off32,r3
+-	VPERM(v2,v2,v16,byteswap)
+-	VPMSUMW(v2,v2,v16)
+-	bdz	.Lv2
+-
+-	lvx	v3,off48,r4
+-	lvx	v17,off48,r3
+-	VPERM(v3,v3,v17,byteswap)
+-	VPMSUMW(v3,v3,v17)
+-	bdz	.Lv3
+-
+-	lvx	v4,off64,r4
+-	lvx	v16,off64,r3
+-	VPERM(v4,v4,v16,byteswap)
+-	VPMSUMW(v4,v4,v16)
+-	bdz	.Lv4
+-
+-	lvx	v5,off80,r4
+-	lvx	v17,off80,r3
+-	VPERM(v5,v5,v17,byteswap)
+-	VPMSUMW(v5,v5,v17)
+-	bdz	.Lv5
+-
+-	lvx	v6,off96,r4
+-	lvx	v16,off96,r3
+-	VPERM(v6,v6,v16,byteswap)
+-	VPMSUMW(v6,v6,v16)
+-	bdz	.Lv6
+-
+-	lvx	v7,off112,r4
+-	lvx	v17,off112,r3
+-	VPERM(v7,v7,v17,byteswap)
+-	VPMSUMW(v7,v7,v17)
+-	bdz	.Lv7
+-
+-	addi	r3,r3,128
+-	addi	r4,r4,128
+-
+-	lvx	v8,0,r4
+-	lvx	v16,0,r3
+-	VPERM(v8,v8,v16,byteswap)
+-	VPMSUMW(v8,v8,v16)
+-	bdz	.Lv8
+-
+-	lvx	v9,off16,r4
+-	lvx	v17,off16,r3
+-	VPERM(v9,v9,v17,byteswap)
+-	VPMSUMW(v9,v9,v17)
+-	bdz	.Lv9
+-
+-	lvx	v10,off32,r4
+-	lvx	v16,off32,r3
+-	VPERM(v10,v10,v16,byteswap)
+-	VPMSUMW(v10,v10,v16)
+-	bdz	.Lv10
+-
+-	lvx	v11,off48,r4
+-	lvx	v17,off48,r3
+-	VPERM(v11,v11,v17,byteswap)
+-	VPMSUMW(v11,v11,v17)
+-	bdz	.Lv11
+-
+-	lvx	v12,off64,r4
+-	lvx	v16,off64,r3
+-	VPERM(v12,v12,v16,byteswap)
+-	VPMSUMW(v12,v12,v16)
+-	bdz	.Lv12
+-
+-	lvx	v13,off80,r4
+-	lvx	v17,off80,r3
+-	VPERM(v13,v13,v17,byteswap)
+-	VPMSUMW(v13,v13,v17)
+-	bdz	.Lv13
+-
+-	lvx	v14,off96,r4
+-	lvx	v16,off96,r3
+-	VPERM(v14,v14,v16,byteswap)
+-	VPMSUMW(v14,v14,v16)
+-	bdz	.Lv14
+-
+-	lvx	v15,off112,r4
+-	lvx	v17,off112,r3
+-	VPERM(v15,v15,v17,byteswap)
+-	VPMSUMW(v15,v15,v17)
+-
+-.Lv15:	vxor	v19,v19,v15
+-.Lv14:	vxor	v20,v20,v14
+-.Lv13:	vxor	v19,v19,v13
+-.Lv12:	vxor	v20,v20,v12
+-.Lv11:	vxor	v19,v19,v11
+-.Lv10:	vxor	v20,v20,v10
+-.Lv9:	vxor	v19,v19,v9
+-.Lv8:	vxor	v20,v20,v8
+-.Lv7:	vxor	v19,v19,v7
+-.Lv6:	vxor	v20,v20,v6
+-.Lv5:	vxor	v19,v19,v5
+-.Lv4:	vxor	v20,v20,v4
+-.Lv3:	vxor	v19,v19,v3
+-.Lv2:	vxor	v20,v20,v2
+-.Lv1:	vxor	v19,v19,v1
+-.Lv0:	vxor	v20,v20,v0
+-
+-	vxor	v0,v19,v20
+-
+-	b	.Lbarrett_reduction
+-
+-.Lzero:
+-	mr	r3,r10
+-	b	.Lout
+-
+-FUNC_END(__crc32_vpmsum)
+diff --git a/util/crc32c_ppc_clang_workaround.h b/util/crc32c_ppc_clang_workaround.h
+new file mode 100644
+index 0000000000..110cb31782
+--- /dev/null
++++ b/util/crc32c_ppc_clang_workaround.h
+@@ -0,0 +1,85 @@
++//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
++//  Copyright (C) 2015, 2017 International Business Machines Corp.
++//  All rights reserved.
++//  This source code is licensed under both the GPLv2 (found in the
++//  COPYING file in the root directory) and Apache 2.0 License
++//  (found in the LICENSE.Apache file in the root directory).
++#ifndef CLANG_WORKAROUND_H
++#define CLANG_WORKAROUND_H
++
++/*
++ * These stubs fix clang incompatibilities with GCC builtins.
++ */
++
++#ifndef __builtin_crypto_vpmsumw
++#define __builtin_crypto_vpmsumw __builtin_crypto_vpmsumb
++#endif
++#ifndef __builtin_crypto_vpmsumd
++#define __builtin_crypto_vpmsumd __builtin_crypto_vpmsumb
++#endif
++
++static inline __vector unsigned long long __attribute__((overloadable))
++vec_ld(int __a, const __vector unsigned long long* __b) {
++  return (__vector unsigned long long)__builtin_altivec_lvx(__a, __b);
++}
++
++/*
++ * GCC __builtin_pack_vector_int128 returns a vector __int128_t but Clang
++ * does not recognize this type. On GCC this builtin is translated to a
++ * xxpermdi instruction that only moves the registers __a, __b instead generates
++ * a load.
++ *
++ * Clang has vec_xxpermdi intrinsics. It was implemented in 4.0.0.
++ */
++static inline __vector unsigned long long __builtin_pack_vector(
++    unsigned long __a, unsigned long __b) {
++#if defined(__BIG_ENDIAN__)
++  __vector unsigned long long __v = {__a, __b};
++#else
++  __vector unsigned long long __v = {__b, __a};
++#endif
++  return __v;
++}
++
++/*
++ * Clang 7 changed the behavior of vec_xxpermdi in order to provide the same
++ * behavior of GCC. That means code adapted to Clang >= 7 does not work on
++ * Clang <= 6.  So, fallback to __builtin_unpack_vector() on Clang <= 6.
++ */
++#if !defined vec_xxpermdi || __clang_major__ <= 6
++
++static inline unsigned long __builtin_unpack_vector(
++    __vector unsigned long long __v, int __o) {
++  return __v[__o];
++}
++
++#if defined(__BIG_ENDIAN__)
++#define __builtin_unpack_vector_0(a) __builtin_unpack_vector((a), 0)
++#define __builtin_unpack_vector_1(a) __builtin_unpack_vector((a), 1)
++#else
++#define __builtin_unpack_vector_0(a) __builtin_unpack_vector((a), 1)
++#define __builtin_unpack_vector_1(a) __builtin_unpack_vector((a), 0)
++#endif
++
++#else
++
++static inline unsigned long __builtin_unpack_vector_0(
++    __vector unsigned long long __v) {
++#if defined(__BIG_ENDIAN__)
++  return vec_xxpermdi(__v, __v, 0x0)[0];
++#else
++  return vec_xxpermdi(__v, __v, 0x3)[0];
++#endif
++}
++
++static inline unsigned long __builtin_unpack_vector_1(
++    __vector unsigned long long __v) {
++#if defined(__BIG_ENDIAN__)
++  return vec_xxpermdi(__v, __v, 0x3)[0];
++#else
++  return vec_xxpermdi(__v, __v, 0x0)[0];
++#endif
++}
++#endif /* vec_xxpermdi */
++
++#endif
+diff --git a/util/crc32c_ppc_constants.h b/util/crc32c_ppc_constants.h
+index f6494cd01c..14df7ccda5 100644
+--- a/util/crc32c_ppc_constants.h
++++ b/util/crc32c_ppc_constants.h
+@@ -5,13 +5,21 @@
+ //  COPYING file in the root directory) and Apache 2.0 License
+ //  (found in the LICENSE.Apache file in the root directory).
+ 
+-#pragma once
++/*
++*
++* THIS FILE IS GENERATED WITH
++./crc32_constants -r -x 0x1edc6f41
++
++* This is from https://github.com/antonblanchard/crc32-vpmsum/
++* DO NOT MODIFY IT MANUALLY!
++*
++*/
+ 
+ #define CRC 0x1edc6f41
+-#define REFLECT
+ #define CRC_XOR
++#define REFLECT
++#define MAX_SIZE 32768
+ 
+-#ifndef __ASSEMBLY__
+ #ifdef CRC_TABLE
+ static const unsigned int crc_table[] = {
+     0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c,
+@@ -59,842 +67,1125 @@ static const unsigned int crc_table[] = {
+     0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351,
+ };
+ 
+-#endif
++#endif /* CRC_TABLE */
++#ifdef POWER8_INTRINSICS
+ 
+-#else
+-#define MAX_SIZE 32768
+-.constants :
++/* Constants */
+ 
+-        /* Reduce 262144 kbits to 1024 bits */
++/* Reduce 262144 kbits to 1024 bits */
++static const __vector unsigned long long vcrc_const[255]
++    __attribute__((aligned(16))) = {
++#ifdef __LITTLE_ENDIAN__
+         /* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
+-        .octa 0x00000000b6ca9e20000000009c37c408
+-
++        {0x000000009c37c408, 0x00000000b6ca9e20},
+         /* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
+-        .octa 0x00000000350249a800000001b51df26c
+-
++        {0x00000001b51df26c, 0x00000000350249a8},
+         /* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
+-        .octa 0x00000001862dac54000000000724b9d0
+-
++        {0x000000000724b9d0, 0x00000001862dac54},
+         /* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
+-        .octa 0x00000001d87fb48c00000001c00532fe
+-
++        {0x00000001c00532fe, 0x00000001d87fb48c},
+         /* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
+-        .octa 0x00000001f39b699e00000000f05a9362
+-
++        {0x00000000f05a9362, 0x00000001f39b699e},
+         /* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
+-        .octa 0x0000000101da11b400000001e1007970
+-
++        {0x00000001e1007970, 0x0000000101da11b4},
+         /* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
+-        .octa 0x00000001cab571e000000000a57366ee
+-
++        {0x00000000a57366ee, 0x00000001cab571e0},
+         /* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
+-        .octa 0x00000000c7020cfe0000000192011284
+-
++        {0x0000000192011284, 0x00000000c7020cfe},
+         /* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
+-        .octa 0x00000000cdaed1ae0000000162716d9a
+-
++        {0x0000000162716d9a, 0x00000000cdaed1ae},
+         /* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
+-        .octa 0x00000001e804effc00000000cd97ecde
+-
++        {0x00000000cd97ecde, 0x00000001e804effc},
+         /* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
+-        .octa 0x0000000077c3ea3a0000000058812bc0
+-
++        {0x0000000058812bc0, 0x0000000077c3ea3a},
+         /* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
+-        .octa 0x0000000068df31b40000000088b8c12e
+-
++        {0x0000000088b8c12e, 0x0000000068df31b4},
+         /* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
+-        .octa 0x00000000b059b6c200000001230b234c
+-
++        {0x00000001230b234c, 0x00000000b059b6c2},
+         /* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
+-        .octa 0x0000000145fb8ed800000001120b416e
+-
++        {0x00000001120b416e, 0x0000000145fb8ed8},
+         /* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
+-        .octa 0x00000000cbc0916800000001974aecb0
+-
++        {0x00000001974aecb0, 0x00000000cbc09168},
+         /* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
+-        .octa 0x000000005ceeedc2000000008ee3f226
+-
++        {0x000000008ee3f226, 0x000000005ceeedc2},
+         /* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
+-        .octa 0x0000000047d74e8600000001089aba9a
+-
++        {0x00000001089aba9a, 0x0000000047d74e86},
+         /* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
+-        .octa 0x00000001407e9e220000000065113872
+-
++        {0x0000000065113872, 0x00000001407e9e22},
+         /* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
+-        .octa 0x00000001da967bda000000005c07ec10
+-
++        {0x000000005c07ec10, 0x00000001da967bda},
+         /* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
+-        .octa 0x000000006c8983680000000187590924
+-
++        {0x0000000187590924, 0x000000006c898368},
+         /* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
+-        .octa 0x00000000f2d14c9800000000e35da7c6
+-
++        {0x00000000e35da7c6, 0x00000000f2d14c98},
+         /* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
+-        .octa 0x00000001993c6ad4000000000415855a
+-
++        {0x000000000415855a, 0x00000001993c6ad4},
+         /* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
+-        .octa 0x000000014683d1ac0000000073617758
+-
++        {0x0000000073617758, 0x000000014683d1ac},
+         /* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
+-        .octa 0x00000001a7c93e6c0000000176021d28
+-
++        {0x0000000176021d28, 0x00000001a7c93e6c},
+         /* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
+-        .octa 0x000000010211e90a00000001c358fd0a
+-
++        {0x00000001c358fd0a, 0x000000010211e90a},
+         /* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
+-        .octa 0x000000001119403e00000001ff7a2c18
+-
++        {0x00000001ff7a2c18, 0x000000001119403e},
+         /* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
+-        .octa 0x000000001c3261aa00000000f2d9f7e4
+-
++        {0x00000000f2d9f7e4, 0x000000001c3261aa},
+         /* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
+-        .octa 0x000000014e37a634000000016cf1f9c8
+-
++        {0x000000016cf1f9c8, 0x000000014e37a634},
+         /* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
+-        .octa 0x0000000073786c0c000000010af9279a
+-
++        {0x000000010af9279a, 0x0000000073786c0c},
+         /* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
+-        .octa 0x000000011dc037f80000000004f101e8
+-
++        {0x0000000004f101e8, 0x000000011dc037f8},
+         /* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
+-        .octa 0x0000000031433dfc0000000070bcf184
+-
++        {0x0000000070bcf184, 0x0000000031433dfc},
+         /* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
+-        .octa 0x000000009cde8348000000000a8de642
+-
++        {0x000000000a8de642, 0x000000009cde8348},
+         /* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
+-        .octa 0x0000000038d3c2a60000000062ea130c
+-
++        {0x0000000062ea130c, 0x0000000038d3c2a6},
+         /* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
+-        .octa 0x000000011b25f26000000001eb31cbb2
+-
++        {0x00000001eb31cbb2, 0x000000011b25f260},
+         /* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
+-        .octa 0x000000001629e6f00000000170783448
+-
++        {0x0000000170783448, 0x000000001629e6f0},
+         /* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
+-        .octa 0x0000000160838b4c00000001a684b4c6
+-
++        {0x00000001a684b4c6, 0x0000000160838b4c},
+         /* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
+-        .octa 0x000000007a44011c00000000253ca5b4
+-
++        {0x00000000253ca5b4, 0x000000007a44011c},
+         /* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
+-        .octa 0x00000000226f417a0000000057b4b1e2
+-
++        {0x0000000057b4b1e2, 0x00000000226f417a},
+         /* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
+-        .octa 0x0000000045eb2eb400000000b6bd084c
+-
++        {0x00000000b6bd084c, 0x0000000045eb2eb4},
+         /* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
+-        .octa 0x000000014459d70c0000000123c2d592
+-
++        {0x0000000123c2d592, 0x000000014459d70c},
+         /* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
+-        .octa 0x00000001d406ed8200000000159dafce
+-
++        {0x00000000159dafce, 0x00000001d406ed82},
+         /* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
+-        .octa 0x0000000160c8e1a80000000127e1a64e
+-
++        {0x0000000127e1a64e, 0x0000000160c8e1a8},
+         /* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
+-        .octa 0x0000000027ba80980000000056860754
+-
++        {0x0000000056860754, 0x0000000027ba8098},
+         /* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
+-        .octa 0x000000006d92d01800000001e661aae8
+-
++        {0x00000001e661aae8, 0x000000006d92d018},
+         /* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
+-        .octa 0x000000012ed7e3f200000000f82c6166
+-
++        {0x00000000f82c6166, 0x000000012ed7e3f2},
+         /* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
+-        .octa 0x000000002dc8778800000000c4f9c7ae
+-
++        {0x00000000c4f9c7ae, 0x000000002dc87788},
+         /* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
+-        .octa 0x0000000018240bb80000000074203d20
+-
++        {0x0000000074203d20, 0x0000000018240bb8},
+         /* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
+-        .octa 0x000000001ad381580000000198173052
+-
++        {0x0000000198173052, 0x000000001ad38158},
+         /* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
+-        .octa 0x00000001396b78f200000001ce8aba54
+-
++        {0x00000001ce8aba54, 0x00000001396b78f2},
+         /* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
+-        .octa 0x000000011a68133400000001850d5d94
+-
++        {0x00000001850d5d94, 0x000000011a681334},
+         /* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
+-        .octa 0x000000012104732e00000001d609239c
+-
++        {0x00000001d609239c, 0x000000012104732e},
+         /* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
+-        .octa 0x00000000a140d90c000000001595f048
+-
++        {0x000000001595f048, 0x00000000a140d90c},
+         /* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
+-        .octa 0x00000001b7215eda0000000042ccee08
+-
++        {0x0000000042ccee08, 0x00000001b7215eda},
+         /* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
+-        .octa 0x00000001aaf1df3c000000010a389d74
+-
++        {0x000000010a389d74, 0x00000001aaf1df3c},
+         /* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
+-        .octa 0x0000000029d15b8a000000012a840da6
+-
++        {0x000000012a840da6, 0x0000000029d15b8a},
+         /* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
+-        .octa 0x00000000f1a96922000000001d181c0c
+-
++        {0x000000001d181c0c, 0x00000000f1a96922},
+         /* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
+-        .octa 0x00000001ac80d03c0000000068b7d1f6
+-
++        {0x0000000068b7d1f6, 0x00000001ac80d03c},
+         /* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
+-        .octa 0x000000000f11d56a000000005b0f14fc
+-
++        {0x000000005b0f14fc, 0x000000000f11d56a},
+         /* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
+-        .octa 0x00000001f1c022a20000000179e9e730
+-
++        {0x0000000179e9e730, 0x00000001f1c022a2},
+         /* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
+-        .octa 0x0000000173d00ae200000001ce1368d6
+-
++        {0x00000001ce1368d6, 0x0000000173d00ae2},
+         /* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
+-        .octa 0x00000001d4ffe4ac0000000112c3a84c
+-
++        {0x0000000112c3a84c, 0x00000001d4ffe4ac},
+         /* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
+-        .octa 0x000000016edc5ae400000000de940fee
+-
++        {0x00000000de940fee, 0x000000016edc5ae4},
+         /* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
+-        .octa 0x00000001f1a0214000000000fe896b7e
+-
++        {0x00000000fe896b7e, 0x00000001f1a02140},
+         /* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
+-        .octa 0x00000000ca0b28a000000001f797431c
+-
++        {0x00000001f797431c, 0x00000000ca0b28a0},
+         /* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
+-        .octa 0x00000001928e30a20000000053e989ba
+-
++        {0x0000000053e989ba, 0x00000001928e30a2},
+         /* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
+-        .octa 0x0000000097b1b002000000003920cd16
+-
++        {0x000000003920cd16, 0x0000000097b1b002},
+         /* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
+-        .octa 0x00000000b15bf90600000001e6f579b8
+-
++        {0x00000001e6f579b8, 0x00000000b15bf906},
+         /* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
+-        .octa 0x00000000411c5d52000000007493cb0a
+-
++        {0x000000007493cb0a, 0x00000000411c5d52},
+         /* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
+-        .octa 0x00000001c36f330000000001bdd376d8
+-
++        {0x00000001bdd376d8, 0x00000001c36f3300},
+         /* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
+-        .octa 0x00000001119227e0000000016badfee6
+-
++        {0x000000016badfee6, 0x00000001119227e0},
+         /* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
+-        .octa 0x00000000114d47020000000071de5c58
+-
++        {0x0000000071de5c58, 0x00000000114d4702},
+         /* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
+-        .octa 0x00000000458b5b9800000000453f317c
+-
++        {0x00000000453f317c, 0x00000000458b5b98},
+         /* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
+-        .octa 0x000000012e31fb8e0000000121675cce
+-
++        {0x0000000121675cce, 0x000000012e31fb8e},
+         /* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
+-        .octa 0x000000005cf619d800000001f409ee92
+-
++        {0x00000001f409ee92, 0x000000005cf619d8},
+         /* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
+-        .octa 0x0000000063f4d8b200000000f36b9c88
+-
++        {0x00000000f36b9c88, 0x0000000063f4d8b2},
+         /* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
+-        .octa 0x000000004138dc8a0000000036b398f4
+-
++        {0x0000000036b398f4, 0x000000004138dc8a},
+         /* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
+-        .octa 0x00000001d29ee8e000000001748f9adc
+-
++        {0x00000001748f9adc, 0x00000001d29ee8e0},
+         /* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
+-        .octa 0x000000006a08ace800000001be94ec00
+-
++        {0x00000001be94ec00, 0x000000006a08ace8},
+         /* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
+-        .octa 0x0000000127d4201000000000b74370d6
+-
++        {0x00000000b74370d6, 0x0000000127d42010},
+         /* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
+-        .octa 0x0000000019d76b6200000001174d0b98
+-
++        {0x00000001174d0b98, 0x0000000019d76b62},
+         /* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
+-        .octa 0x00000001b1471f6e00000000befc06a4
+-
++        {0x00000000befc06a4, 0x00000001b1471f6e},
+         /* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
+-        .octa 0x00000001f64c19cc00000001ae125288
+-
++        {0x00000001ae125288, 0x00000001f64c19cc},
+         /* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
+-        .octa 0x00000000003c0ea00000000095c19b34
+-
++        {0x0000000095c19b34, 0x00000000003c0ea0},
+         /* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
+-        .octa 0x000000014d73abf600000001a78496f2
+-
++        {0x00000001a78496f2, 0x000000014d73abf6},
+         /* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
+-        .octa 0x00000001620eb84400000001ac5390a0
+-
++        {0x00000001ac5390a0, 0x00000001620eb844},
+         /* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
+-        .octa 0x0000000147655048000000002a80ed6e
+-
++        {0x000000002a80ed6e, 0x0000000147655048},
+         /* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
+-        .octa 0x0000000067b5077e00000001fa9b0128
+-
++        {0x00000001fa9b0128, 0x0000000067b5077e},
+         /* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
+-        .octa 0x0000000010ffe20600000001ea94929e
+-
++        {0x00000001ea94929e, 0x0000000010ffe206},
+         /* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
+-        .octa 0x000000000fee8f1e0000000125f4305c
+-
++        {0x0000000125f4305c, 0x000000000fee8f1e},
+         /* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
+-        .octa 0x00000001da26fbae00000001471e2002
+-
++        {0x00000001471e2002, 0x00000001da26fbae},
+         /* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
+-        .octa 0x00000001b3a8bd880000000132d2253a
+-
++        {0x0000000132d2253a, 0x00000001b3a8bd88},
+         /* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
+-        .octa 0x00000000e8f3898e00000000f26b3592
+-
++        {0x00000000f26b3592, 0x00000000e8f3898e},
+         /* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
+-        .octa 0x00000000b0d0d28c00000000bc8b67b0
+-
++        {0x00000000bc8b67b0, 0x00000000b0d0d28c},
+         /* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
+-        .octa 0x0000000030f2a798000000013a826ef2
+-
++        {0x000000013a826ef2, 0x0000000030f2a798},
+         /* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
+-        .octa 0x000000000fba10020000000081482c84
+-
++        {0x0000000081482c84, 0x000000000fba1002},
+         /* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
+-        .octa 0x00000000bdb9bd7200000000e77307c2
+-
++        {0x00000000e77307c2, 0x00000000bdb9bd72},
+         /* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
+-        .octa 0x0000000075d3bf5a00000000d4a07ec8
+-
++        {0x00000000d4a07ec8, 0x0000000075d3bf5a},
+         /* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
+-        .octa 0x00000000ef1f98a00000000017102100
+-
++        {0x0000000017102100, 0x00000000ef1f98a0},
+         /* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
+-        .octa 0x00000000689c760200000000db406486
+-
++        {0x00000000db406486, 0x00000000689c7602},
+         /* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
+-        .octa 0x000000016d5fa5fe0000000192db7f88
+-
++        {0x0000000192db7f88, 0x000000016d5fa5fe},
+         /* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
+-        .octa 0x00000001d0d2b9ca000000018bf67b1e
+-
++        {0x000000018bf67b1e, 0x00000001d0d2b9ca},
+         /* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
+-        .octa 0x0000000041e7b470000000007c09163e
+-
++        {0x000000007c09163e, 0x0000000041e7b470},
+         /* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
+-        .octa 0x00000001cbb6495e000000000adac060
+-
++        {0x000000000adac060, 0x00000001cbb6495e},
+         /* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
+-        .octa 0x000000010052a0b000000000bd8316ae
+-
++        {0x00000000bd8316ae, 0x000000010052a0b0},
+         /* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
+-        .octa 0x00000001d8effb5c000000019f09ab54
+-
++        {0x000000019f09ab54, 0x00000001d8effb5c},
+         /* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
+-        .octa 0x00000001d969853c0000000125155542
+-
++        {0x0000000125155542, 0x00000001d969853c},
+         /* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
+-        .octa 0x00000000523ccce2000000018fdb5882
+-
++        {0x000000018fdb5882, 0x00000000523ccce2},
+         /* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
+-        .octa 0x000000001e2436bc00000000e794b3f4
+-
++        {0x00000000e794b3f4, 0x000000001e2436bc},
+         /* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
+-        .octa 0x00000000ddd1c3a2000000016f9bb022
+-
++        {0x000000016f9bb022, 0x00000000ddd1c3a2},
+         /* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
+-        .octa 0x0000000019fcfe3800000000290c9978
+-
++        {0x00000000290c9978, 0x0000000019fcfe38},
+         /* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
+-        .octa 0x00000001ce95db640000000083c0f350
+-
++        {0x0000000083c0f350, 0x00000001ce95db64},
+         /* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
+-        .octa 0x00000000af5828060000000173ea6628
+-
++        {0x0000000173ea6628, 0x00000000af582806},
+         /* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
+-        .octa 0x00000001006388f600000001c8b4e00a
+-
++        {0x00000001c8b4e00a, 0x00000001006388f6},
+         /* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
+-        .octa 0x0000000179eca00a00000000de95d6aa
+-
++        {0x00000000de95d6aa, 0x0000000179eca00a},
+         /* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
+-        .octa 0x0000000122410a6a000000010b7f7248
+-
++        {0x000000010b7f7248, 0x0000000122410a6a},
+         /* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
+-        .octa 0x000000004288e87c00000001326e3a06
+-
++        {0x00000001326e3a06, 0x000000004288e87c},
+         /* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
+-        .octa 0x000000016c5490da00000000bb62c2e6
+-
++        {0x00000000bb62c2e6, 0x000000016c5490da},
+         /* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
+-        .octa 0x00000000d1c71f6e0000000156a4b2c2
+-
++        {0x0000000156a4b2c2, 0x00000000d1c71f6e},
+         /* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
+-        .octa 0x00000001b4ce08a6000000011dfe763a
+-
++        {0x000000011dfe763a, 0x00000001b4ce08a6},
+         /* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
+-        .octa 0x00000001466ba60c000000007bcca8e2
+-
++        {0x000000007bcca8e2, 0x00000001466ba60c},
+         /* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
+-        .octa 0x00000001f6c488a40000000186118faa
+-
++        {0x0000000186118faa, 0x00000001f6c488a4},
+         /* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
+-        .octa 0x000000013bfb06820000000111a65a88
+-
++        {0x0000000111a65a88, 0x000000013bfb0682},
+         /* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
+-        .octa 0x00000000690e9e54000000003565e1c4
+-
++        {0x000000003565e1c4, 0x00000000690e9e54},
+         /* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
+-        .octa 0x00000000281346b6000000012ed02a82
+-
++        {0x000000012ed02a82, 0x00000000281346b6},
+         /* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
+-        .octa 0x000000015646402400000000c486ecfc
+-
++        {0x00000000c486ecfc, 0x0000000156464024},
+         /* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
+-        .octa 0x000000016063a8dc0000000001b951b2
+-
++        {0x0000000001b951b2, 0x000000016063a8dc},
+         /* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
+-        .octa 0x0000000116a663620000000048143916
+-
++        {0x0000000048143916, 0x0000000116a66362},
+         /* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
+-        .octa 0x000000017e8aa4d200000001dc2ae124
+-
++        {0x00000001dc2ae124, 0x000000017e8aa4d2},
+         /* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
+-        .octa 0x00000001728eb10c00000001416c58d6
+-
++        {0x00000001416c58d6, 0x00000001728eb10c},
+         /* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
+-        .octa 0x00000001b08fd7fa00000000a479744a
+-
++        {0x00000000a479744a, 0x00000001b08fd7fa},
+         /* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
+-        .octa 0x00000001092a16e80000000096ca3a26
+-
++        {0x0000000096ca3a26, 0x00000001092a16e8},
+         /* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
+-        .octa 0x00000000a505637c00000000ff223d4e
+-
++        {0x00000000ff223d4e, 0x00000000a505637c},
+         /* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
+-        .octa 0x00000000d94869b2000000010e84da42
+-
++        {0x000000010e84da42, 0x00000000d94869b2},
+         /* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
+-        .octa 0x00000001c8b203ae00000001b61ba3d0
+-
++        {0x00000001b61ba3d0, 0x00000001c8b203ae},
+         /* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
+-        .octa 0x000000005704aea000000000680f2de8
+-
++        {0x00000000680f2de8, 0x000000005704aea0},
+         /* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
+-        .octa 0x000000012e295fa2000000008772a9a8
+-
++        {0x000000008772a9a8, 0x000000012e295fa2},
+         /* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
+-        .octa 0x000000011d0908bc0000000155f295bc
+-
++        {0x0000000155f295bc, 0x000000011d0908bc},
+         /* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
+-        .octa 0x0000000193ed97ea00000000595f9282
+-
++        {0x00000000595f9282, 0x0000000193ed97ea},
+         /* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
+-        .octa 0x000000013a0f1c520000000164b1c25a
+-
++        {0x0000000164b1c25a, 0x000000013a0f1c52},
+         /* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
+-        .octa 0x000000010c2c40c000000000fbd67c50
+-
++        {0x00000000fbd67c50, 0x000000010c2c40c0},
+         /* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
+-        .octa 0x00000000ff6fac3e0000000096076268
+-
++        {0x0000000096076268, 0x00000000ff6fac3e},
+         /* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
+-        .octa 0x000000017b3609c000000001d288e4cc
+-
++        {0x00000001d288e4cc, 0x000000017b3609c0},
+         /* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
+-        .octa 0x0000000088c8c92200000001eaac1bdc
+-
++        {0x00000001eaac1bdc, 0x0000000088c8c922},
+         /* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
+-        .octa 0x00000001751baae600000001f1ea39e2
+-
++        {0x00000001f1ea39e2, 0x00000001751baae6},
+         /* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
+-        .octa 0x000000010795297200000001eb6506fc
+-
++        {0x00000001eb6506fc, 0x0000000107952972},
+         /* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
+-        .octa 0x0000000162b00abe000000010f806ffe
+-
++        {0x000000010f806ffe, 0x0000000162b00abe},
+         /* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
+-        .octa 0x000000000d7b404c000000010408481e
+-
++        {0x000000010408481e, 0x000000000d7b404c},
+         /* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
+-        .octa 0x00000000763b13d40000000188260534
+-
++        {0x0000000188260534, 0x00000000763b13d4},
+         /* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
+-        .octa 0x00000000f6dc22d80000000058fc73e0
+-
++        {0x0000000058fc73e0, 0x00000000f6dc22d8},
+         /* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
+-        .octa 0x000000007daae06000000000391c59b8
+-
++        {0x00000000391c59b8, 0x000000007daae060},
+         /* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
+-        .octa 0x000000013359ab7c000000018b638400
+-
++        {0x000000018b638400, 0x000000013359ab7c},
+         /* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
+-        .octa 0x000000008add438a000000011738f5c4
+-
++        {0x000000011738f5c4, 0x000000008add438a},
+         /* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
+-        .octa 0x00000001edbefdea000000008cf7c6da
+-
++        {0x000000008cf7c6da, 0x00000001edbefdea},
+         /* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
+-        .octa 0x000000004104e0f800000001ef97fb16
+-
++        {0x00000001ef97fb16, 0x000000004104e0f8},
+         /* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
+-        .octa 0x00000000b48a82220000000102130e20
+-
++        {0x0000000102130e20, 0x00000000b48a8222},
+         /* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
+-        .octa 0x00000001bcb4684400000000db968898
+-
++        {0x00000000db968898, 0x00000001bcb46844},
+         /* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
+-        .octa 0x000000013293ce0a00000000b5047b5e
+-
++        {0x00000000b5047b5e, 0x000000013293ce0a},
+         /* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
+-        .octa 0x00000001710d0844000000010b90fdb2
+-
++        {0x000000010b90fdb2, 0x00000001710d0844},
+         /* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
+-        .octa 0x0000000117907f6e000000004834a32e
+-
++        {0x000000004834a32e, 0x0000000117907f6e},
+         /* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
+-        .octa 0x0000000087ddf93e0000000059c8f2b0
+-
++        {0x0000000059c8f2b0, 0x0000000087ddf93e},
+         /* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
+-        .octa 0x000000005970e9b00000000122cec508
+-
++        {0x0000000122cec508, 0x000000005970e9b0},
+         /* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
+-        .octa 0x0000000185b2b7d0000000000a330cda
+-
++        {0x000000000a330cda, 0x0000000185b2b7d0},
+         /* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
+-        .octa 0x00000001dcee0efc000000014a47148c
+-
++        {0x000000014a47148c, 0x00000001dcee0efc},
+         /* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
+-        .octa 0x0000000030da27220000000042c61cb8
+-
++        {0x0000000042c61cb8, 0x0000000030da2722},
+         /* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
+-        .octa 0x000000012f925a180000000012fe6960
+-
++        {0x0000000012fe6960, 0x000000012f925a18},
+         /* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
+-        .octa 0x00000000dd2e357c00000000dbda2c20
+-
++        {0x00000000dbda2c20, 0x00000000dd2e357c},
+         /* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
+-        .octa 0x00000000071c80de000000011122410c
+-
++        {0x000000011122410c, 0x00000000071c80de},
+         /* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
+-        .octa 0x000000011513140a00000000977b2070
+-
++        {0x00000000977b2070, 0x000000011513140a},
+         /* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
+-        .octa 0x00000001df876e8e000000014050438e
+-
++        {0x000000014050438e, 0x00000001df876e8e},
+         /* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
+-        .octa 0x000000015f81d6ce0000000147c840e8
+-
++        {0x0000000147c840e8, 0x000000015f81d6ce},
+         /* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
+-        .octa 0x000000019dd94dbe00000001cc7c88ce
+-
++        {0x00000001cc7c88ce, 0x000000019dd94dbe},
+         /* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
+-        .octa 0x00000001373d206e00000001476b35a4
+-
++        {0x00000001476b35a4, 0x00000001373d206e},
+         /* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
+-        .octa 0x00000000668ccade000000013d52d508
+-
++        {0x000000013d52d508, 0x00000000668ccade},
+         /* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
+-        .octa 0x00000001b192d268000000008e4be32e
+-
++        {0x000000008e4be32e, 0x00000001b192d268},
+         /* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
+-        .octa 0x00000000e30f3a7800000000024120fe
+-
++        {0x00000000024120fe, 0x00000000e30f3a78},
+         /* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
+-        .octa 0x000000010ef1f7bc00000000ddecddb4
+-
++        {0x00000000ddecddb4, 0x000000010ef1f7bc},
+         /* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
+-        .octa 0x00000001f5ac738000000000d4d403bc
+-
++        {0x00000000d4d403bc, 0x00000001f5ac7380},
+         /* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
+-        .octa 0x000000011822ea7000000001734b89aa
+-
++        {0x00000001734b89aa, 0x000000011822ea70},
+         /* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
+-        .octa 0x00000000c3a33848000000010e7a58d6
+-
++        {0x000000010e7a58d6, 0x00000000c3a33848},
+         /* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
+-        .octa 0x00000001bd151c2400000001f9f04e9c
+-
++        {0x00000001f9f04e9c, 0x00000001bd151c24},
+         /* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
+-        .octa 0x0000000056002d7600000000b692225e
+-
++        {0x00000000b692225e, 0x0000000056002d76},
+         /* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
+-        .octa 0x000000014657c4f4000000019b8d3f3e
+-
++        {0x000000019b8d3f3e, 0x000000014657c4f4},
+         /* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
+-        .octa 0x0000000113742d7c00000001a874f11e
+-
++        {0x00000001a874f11e, 0x0000000113742d7c},
+         /* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
+-        .octa 0x000000019c5920ba000000010d5a4254
+-
++        {0x000000010d5a4254, 0x000000019c5920ba},
+         /* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
+-        .octa 0x000000005216d2d600000000bbb2f5d6
+-
++        {0x00000000bbb2f5d6, 0x000000005216d2d6},
+         /* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
+-        .octa 0x0000000136f5ad8a0000000179cc0e36
+-
++        {0x0000000179cc0e36, 0x0000000136f5ad8a},
+         /* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
+-        .octa 0x000000018b07beb600000001dca1da4a
+-
++        {0x00000001dca1da4a, 0x000000018b07beb6},
+         /* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
+-        .octa 0x00000000db1e93b000000000feb1a192
+-
++        {0x00000000feb1a192, 0x00000000db1e93b0},
+         /* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
+-        .octa 0x000000000b96fa3a00000000d1eeedd6
+-
++        {0x00000000d1eeedd6, 0x000000000b96fa3a},
+         /* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
+-        .octa 0x00000001d9968af0000000008fad9bb4
+-
++        {0x000000008fad9bb4, 0x00000001d9968af0},
+         /* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
+-        .octa 0x000000000e4a77a200000001884938e4
+-
++        {0x00000001884938e4, 0x000000000e4a77a2},
+         /* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
+-        .octa 0x00000000508c2ac800000001bc2e9bc0
+-
++        {0x00000001bc2e9bc0, 0x00000000508c2ac8},
+         /* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
+-        .octa 0x0000000021572a8000000001f9658a68
+-
++        {0x00000001f9658a68, 0x0000000021572a80},
+         /* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
+-        .octa 0x00000001b859daf2000000001b9224fc
+-
++        {0x000000001b9224fc, 0x00000001b859daf2},
+         /* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
+-        .octa 0x000000016f7884740000000055b2fb84
+-
++        {0x0000000055b2fb84, 0x000000016f788474},
+         /* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
+-        .octa 0x00000001b438810e000000018b090348
+-
++        {0x000000018b090348, 0x00000001b438810e},
+         /* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
+-        .octa 0x0000000095ddc6f2000000011ccbd5ea
+-
++        {0x000000011ccbd5ea, 0x0000000095ddc6f2},
+         /* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
+-        .octa 0x00000001d977c20c0000000007ae47f8
+-
++        {0x0000000007ae47f8, 0x00000001d977c20c},
+         /* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
+-        .octa 0x00000000ebedb99a0000000172acbec0
+-
++        {0x0000000172acbec0, 0x00000000ebedb99a},
+         /* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
+-        .octa 0x00000001df9e9e9200000001c6e3ff20
+-
++        {0x00000001c6e3ff20, 0x00000001df9e9e92},
+         /* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
+-        .octa 0x00000001a4a3f95200000000e1b38744
+-
++        {0x00000000e1b38744, 0x00000001a4a3f952},
+         /* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
+-        .octa 0x00000000e2f5122000000000791585b2
+-
++        {0x00000000791585b2, 0x00000000e2f51220},
+         /* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
+-        .octa 0x000000004aa01f3e00000000ac53b894
+-
++        {0x00000000ac53b894, 0x000000004aa01f3e},
+         /* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
+-        .octa 0x00000000b3e90a5800000001ed5f2cf4
+-
++        {0x00000001ed5f2cf4, 0x00000000b3e90a58},
+         /* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
+-        .octa 0x000000000c9ca2aa00000001df48b2e0
+-
++        {0x00000001df48b2e0, 0x000000000c9ca2aa},
+         /* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
+-        .octa 0x000000015168231600000000049c1c62
+-
++        {0x00000000049c1c62, 0x0000000151682316},
+         /* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
+-        .octa 0x0000000036fce78c000000017c460c12
+-
++        {0x000000017c460c12, 0x0000000036fce78c},
+         /* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
+-        .octa 0x000000009037dc10000000015be4da7e
+-
++        {0x000000015be4da7e, 0x000000009037dc10},
+         /* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
+-        .octa 0x00000000d3298582000000010f38f668
+-
++        {0x000000010f38f668, 0x00000000d3298582},
+         /* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
+-        .octa 0x00000001b42e8ad60000000039f40a00
+-
++        {0x0000000039f40a00, 0x00000001b42e8ad6},
+         /* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
+-        .octa 0x00000000142a983800000000bd4c10c4
+-
++        {0x00000000bd4c10c4, 0x00000000142a9838},
+         /* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
+-        .octa 0x0000000109c7f1900000000042db1d98
+-
++        {0x0000000042db1d98, 0x0000000109c7f190},
+         /* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
+-        .octa 0x0000000056ff931000000001c905bae6
+-
++        {0x00000001c905bae6, 0x0000000056ff9310},
+         /* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
+-        .octa 0x00000001594513aa00000000069d40ea
+-
++        {0x00000000069d40ea, 0x00000001594513aa},
+         /* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
+-        .octa 0x00000001e3b5b1e8000000008e4fbad0
+-
++        {0x000000008e4fbad0, 0x00000001e3b5b1e8},
+         /* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
+-        .octa 0x000000011dd5fc080000000047bedd46
+-
++        {0x0000000047bedd46, 0x000000011dd5fc08},
+         /* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
+-        .octa 0x00000001675f0cc20000000026396bf8
+-
++        {0x0000000026396bf8, 0x00000001675f0cc2},
+         /* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
+-        .octa 0x00000000d1c8dd4400000000379beb92
+-
++        {0x00000000379beb92, 0x00000000d1c8dd44},
+         /* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
+-        .octa 0x0000000115ebd3d8000000000abae54a
+-
++        {0x000000000abae54a, 0x0000000115ebd3d8},
+         /* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
+-        .octa 0x00000001ecbd0dac0000000007e6a128
+-
++        {0x0000000007e6a128, 0x00000001ecbd0dac},
+         /* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
+-        .octa 0x00000000cdf67af2000000000ade29d2
+-
++        {0x000000000ade29d2, 0x00000000cdf67af2},
+         /* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
+-        .octa 0x000000004c01ff4c00000000f974c45c
+-
++        {0x00000000f974c45c, 0x000000004c01ff4c},
+         /* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
+-        .octa 0x00000000f2d8657e00000000e77ac60a
+-
++        {0x00000000e77ac60a, 0x00000000f2d8657e},
+         /* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
+-        .octa 0x000000006bae74c40000000145895816
+-
++        {0x0000000145895816, 0x000000006bae74c4},
+         /* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
+-        .octa 0x0000000152af8aa00000000038e362be
+-
++        {0x0000000038e362be, 0x0000000152af8aa0},
+         /* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
+-        .octa 0x0000000004663802000000007f991a64
+-
++        {0x000000007f991a64, 0x0000000004663802},
+         /* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
+-        .octa 0x00000001ab2f5afc00000000fa366d3a
+-
++        {0x00000000fa366d3a, 0x00000001ab2f5afc},
+         /* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
+-        .octa 0x0000000074a4ebd400000001a2bb34f0
+-
++        {0x00000001a2bb34f0, 0x0000000074a4ebd4},
+         /* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
+-        .octa 0x00000001d7ab3a4c0000000028a9981e
+-
++        {0x0000000028a9981e, 0x00000001d7ab3a4c},
+         /* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
+-        .octa 0x00000001a8da60c600000001dbc672be
+-
++        {0x00000001dbc672be, 0x00000001a8da60c6},
+         /* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
+-        .octa 0x000000013cf6382000000000b04d77f6
+-
++        {0x00000000b04d77f6, 0x000000013cf63820},
+         /* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
+-        .octa 0x00000000bec12e1e0000000124400d96
+-
++        {0x0000000124400d96, 0x00000000bec12e1e},
+         /* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
+-        .octa 0x00000001c6368010000000014ca4b414
+-
++        {0x000000014ca4b414, 0x00000001c6368010},
+         /* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
+-        .octa 0x00000001e6e78758000000012fe2c938
+-
++        {0x000000012fe2c938, 0x00000001e6e78758},
+         /* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
+-        .octa 0x000000008d7f2b3c00000001faed01e6
+-
++        {0x00000001faed01e6, 0x000000008d7f2b3c},
+         /* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
+-        .octa 0x000000016b4a156e000000007e80ecfe
+-
++        {0x000000007e80ecfe, 0x000000016b4a156e},
+         /* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
+-        .octa 0x00000001c63cfeb60000000098daee94
+-
++        {0x0000000098daee94, 0x00000001c63cfeb6},
+         /* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
+-        .octa 0x000000015f902670000000010a04edea
+-
++        {0x000000010a04edea, 0x000000015f902670},
+         /* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
+-        .octa 0x00000001cd5de11e00000001c00b4524
+-
++        {0x00000001c00b4524, 0x00000001cd5de11e},
+         /* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
+-        .octa 0x000000001acaec540000000170296550
+-
++        {0x0000000170296550, 0x000000001acaec54},
+         /* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
+-        .octa 0x000000002bd0ca780000000181afaa48
+-
++        {0x0000000181afaa48, 0x000000002bd0ca78},
+         /* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
+-        .octa 0x0000000032d63d5c0000000185a31ffa
+-
++        {0x0000000185a31ffa, 0x0000000032d63d5c},
+         /* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
+-        .octa 0x000000001c6d4e4c000000002469f608
+-
++        {0x000000002469f608, 0x000000001c6d4e4c},
+         /* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
+-        .octa 0x0000000106a60b92000000006980102a
+-
++        {0x000000006980102a, 0x0000000106a60b92},
+         /* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
+-        .octa 0x00000000d3855e120000000111ea9ca8
+-
++        {0x0000000111ea9ca8, 0x00000000d3855e12},
+         /* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
+-        .octa 0x00000000e312563600000001bd1d29ce
+-
++        {0x00000001bd1d29ce, 0x00000000e3125636},
+         /* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
+-        .octa 0x000000009e8f7ea400000001b34b9580
+-
++        {0x00000001b34b9580, 0x000000009e8f7ea4},
+         /* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
+-        .octa 0x00000001c82e562c000000003076054e
+-
++        {0x000000003076054e, 0x00000001c82e562c},
+         /* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
+-        .octa 0x00000000ca9f09ce000000012a608ea4
+-
++        {0x000000012a608ea4, 0x00000000ca9f09ce},
+         /* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
+-        .octa 0x00000000c63764e600000000784d05fe
+-
++        {0x00000000784d05fe, 0x00000000c63764e6},
+         /* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
+-        .octa 0x0000000168d2e49e000000016ef0d82a
+-
++        {0x000000016ef0d82a, 0x0000000168d2e49e},
+         /* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
+-        .octa 0x00000000e986c1480000000075bda454
+-
++        {0x0000000075bda454, 0x00000000e986c148},
+         /* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
+-        .octa 0x00000000cfb65894000000003dc0a1c4
+-
++        {0x000000003dc0a1c4, 0x00000000cfb65894},
+         /* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
+-        .octa 0x0000000111cadee400000000e9a5d8be
+-
++        {0x00000000e9a5d8be, 0x0000000111cadee4},
+         /* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
+-        .octa 0x0000000171fb63ce00000001609bc4b4
+-
+-        .short_constants :
+-
+-        /* Reduce final 1024-2048 bits to 64 bits, shifting 32 bits to include
+-           the trailing 32 bits of zeros */
+-        /* x^1952 mod p(x)`, x^1984 mod p(x)`, x^2016 mod p(x)`, x^2048 mod
+-           p(x)` */
+-        .octa 0x7fec2963e5bf80485cf015c388e56f72
+-
+-        /* x^1824 mod p(x)`, x^1856 mod p(x)`, x^1888 mod p(x)`, x^1920 mod
+-           p(x)` */
+-        .octa 0x38e888d4844752a9963a18920246e2e6
+-
+-        /* x^1696 mod p(x)`, x^1728 mod p(x)`, x^1760 mod p(x)`, x^1792 mod
+-           p(x)` */
+-        .octa 0x42316c00730206ad419a441956993a31
+-
+-        /* x^1568 mod p(x)`, x^1600 mod p(x)`, x^1632 mod p(x)`, x^1664 mod
+-           p(x)` */
+-        .octa 0x543d5c543e65ddf9924752ba2b830011
+-
+-        /* x^1440 mod p(x)`, x^1472 mod p(x)`, x^1504 mod p(x)`, x^1536 mod
+-           p(x)` */
+-        .octa 0x78e87aaf56767c9255bd7f9518e4a304
+-
+-        /* x^1312 mod p(x)`, x^1344 mod p(x)`, x^1376 mod p(x)`, x^1408 mod
+-           p(x)` */
+-        .octa 0x8f68fcec1903da7f6d76739fe0553f1e
+-
+-        /* x^1184 mod p(x)`, x^1216 mod p(x)`, x^1248 mod p(x)`, x^1280 mod
+-           p(x)` */
+-        .octa 0x3f4840246791d588c133722b1fe0b5c3
+-
+-        /* x^1056 mod p(x)`, x^1088 mod p(x)`, x^1120 mod p(x)`, x^1152 mod
+-           p(x)` */
+-        .octa 0x34c96751b04de25a64b67ee0e55ef1f3
+-
+-        /* x^928 mod p(x)`, x^960 mod p(x)`, x^992 mod p(x)`, x^1024 mod p(x)`
+-         */
+-        .octa 0x156c8e180b4a395b069db049b8fdb1e7
+-
+-        /* x^800 mod p(x)`, x^832 mod p(x)`, x^864 mod p(x)`, x^896 mod p(x)` */
+-        .octa 0xe0b99ccbe661f7bea11bfaf3c9e90b9e
+-
+-        /* x^672 mod p(x)`, x^704 mod p(x)`, x^736 mod p(x)`, x^768 mod p(x)` */
+-        .octa 0x041d37768cd75659817cdc5119b29a35
+-
+-        /* x^544 mod p(x)`, x^576 mod p(x)`, x^608 mod p(x)`, x^640 mod p(x)` */
+-        .octa 0x3a0777818cfaa9651ce9d94b36c41f1c
+-
+-        /* x^416 mod p(x)`, x^448 mod p(x)`, x^480 mod p(x)`, x^512 mod p(x)` */
+-        .octa 0x0e148e8252377a554f256efcb82be955
+-
+-        /* x^288 mod p(x)`, x^320 mod p(x)`, x^352 mod p(x)`, x^384 mod p(x)` */
+-        .octa 0x9c25531d19e65ddeec1631edb2dea967
+-
+-        /* x^160 mod p(x)`, x^192 mod p(x)`, x^224 mod p(x)`, x^256 mod p(x)` */
+-        .octa 0x790606ff9957c0a65d27e147510ac59a
++        {0x00000001609bc4b4, 0x0000000171fb63ce}
++#else  /* __LITTLE_ENDIAN__ */
++        /* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
++        {0x00000000b6ca9e20, 0x000000009c37c408},
++        /* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
++        {0x00000000350249a8, 0x00000001b51df26c},
++        /* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
++        {0x00000001862dac54, 0x000000000724b9d0},
++        /* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
++        {0x00000001d87fb48c, 0x00000001c00532fe},
++        /* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
++        {0x00000001f39b699e, 0x00000000f05a9362},
++        /* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
++        {0x0000000101da11b4, 0x00000001e1007970},
++        /* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
++        {0x00000001cab571e0, 0x00000000a57366ee},
++        /* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
++        {0x00000000c7020cfe, 0x0000000192011284},
++        /* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
++        {0x00000000cdaed1ae, 0x0000000162716d9a},
++        /* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
++        {0x00000001e804effc, 0x00000000cd97ecde},
++        /* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
++        {0x0000000077c3ea3a, 0x0000000058812bc0},
++        /* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
++        {0x0000000068df31b4, 0x0000000088b8c12e},
++        /* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
++        {0x00000000b059b6c2, 0x00000001230b234c},
++        /* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
++        {0x0000000145fb8ed8, 0x00000001120b416e},
++        /* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
++        {0x00000000cbc09168, 0x00000001974aecb0},
++        /* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
++        {0x000000005ceeedc2, 0x000000008ee3f226},
++        /* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
++        {0x0000000047d74e86, 0x00000001089aba9a},
++        /* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
++        {0x00000001407e9e22, 0x0000000065113872},
++        /* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
++        {0x00000001da967bda, 0x000000005c07ec10},
++        /* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
++        {0x000000006c898368, 0x0000000187590924},
++        /* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
++        {0x00000000f2d14c98, 0x00000000e35da7c6},
++        /* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
++        {0x00000001993c6ad4, 0x000000000415855a},
++        /* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
++        {0x000000014683d1ac, 0x0000000073617758},
++        /* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
++        {0x00000001a7c93e6c, 0x0000000176021d28},
++        /* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
++        {0x000000010211e90a, 0x00000001c358fd0a},
++        /* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
++        {0x000000001119403e, 0x00000001ff7a2c18},
++        /* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
++        {0x000000001c3261aa, 0x00000000f2d9f7e4},
++        /* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
++        {0x000000014e37a634, 0x000000016cf1f9c8},
++        /* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
++        {0x0000000073786c0c, 0x000000010af9279a},
++        /* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
++        {0x000000011dc037f8, 0x0000000004f101e8},
++        /* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
++        {0x0000000031433dfc, 0x0000000070bcf184},
++        /* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
++        {0x000000009cde8348, 0x000000000a8de642},
++        /* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
++        {0x0000000038d3c2a6, 0x0000000062ea130c},
++        /* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
++        {0x000000011b25f260, 0x00000001eb31cbb2},
++        /* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
++        {0x000000001629e6f0, 0x0000000170783448},
++        /* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
++        {0x0000000160838b4c, 0x00000001a684b4c6},
++        /* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
++        {0x000000007a44011c, 0x00000000253ca5b4},
++        /* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
++        {0x00000000226f417a, 0x0000000057b4b1e2},
++        /* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
++        {0x0000000045eb2eb4, 0x00000000b6bd084c},
++        /* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
++        {0x000000014459d70c, 0x0000000123c2d592},
++        /* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
++        {0x00000001d406ed82, 0x00000000159dafce},
++        /* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
++        {0x0000000160c8e1a8, 0x0000000127e1a64e},
++        /* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
++        {0x0000000027ba8098, 0x0000000056860754},
++        /* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
++        {0x000000006d92d018, 0x00000001e661aae8},
++        /* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
++        {0x000000012ed7e3f2, 0x00000000f82c6166},
++        /* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
++        {0x000000002dc87788, 0x00000000c4f9c7ae},
++        /* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
++        {0x0000000018240bb8, 0x0000000074203d20},
++        /* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
++        {0x000000001ad38158, 0x0000000198173052},
++        /* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
++        {0x00000001396b78f2, 0x00000001ce8aba54},
++        /* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
++        {0x000000011a681334, 0x00000001850d5d94},
++        /* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
++        {0x000000012104732e, 0x00000001d609239c},
++        /* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
++        {0x00000000a140d90c, 0x000000001595f048},
++        /* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
++        {0x00000001b7215eda, 0x0000000042ccee08},
++        /* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
++        {0x00000001aaf1df3c, 0x000000010a389d74},
++        /* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
++        {0x0000000029d15b8a, 0x000000012a840da6},
++        /* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
++        {0x00000000f1a96922, 0x000000001d181c0c},
++        /* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
++        {0x00000001ac80d03c, 0x0000000068b7d1f6},
++        /* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
++        {0x000000000f11d56a, 0x000000005b0f14fc},
++        /* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
++        {0x00000001f1c022a2, 0x0000000179e9e730},
++        /* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
++        {0x0000000173d00ae2, 0x00000001ce1368d6},
++        /* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
++        {0x00000001d4ffe4ac, 0x0000000112c3a84c},
++        /* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
++        {0x000000016edc5ae4, 0x00000000de940fee},
++        /* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
++        {0x00000001f1a02140, 0x00000000fe896b7e},
++        /* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
++        {0x00000000ca0b28a0, 0x00000001f797431c},
++        /* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
++        {0x00000001928e30a2, 0x0000000053e989ba},
++        /* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
++        {0x0000000097b1b002, 0x000000003920cd16},
++        /* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
++        {0x00000000b15bf906, 0x00000001e6f579b8},
++        /* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
++        {0x00000000411c5d52, 0x000000007493cb0a},
++        /* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
++        {0x00000001c36f3300, 0x00000001bdd376d8},
++        /* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
++        {0x00000001119227e0, 0x000000016badfee6},
++        /* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
++        {0x00000000114d4702, 0x0000000071de5c58},
++        /* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
++        {0x00000000458b5b98, 0x00000000453f317c},
++        /* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
++        {0x000000012e31fb8e, 0x0000000121675cce},
++        /* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
++        {0x000000005cf619d8, 0x00000001f409ee92},
++        /* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
++        {0x0000000063f4d8b2, 0x00000000f36b9c88},
++        /* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
++        {0x000000004138dc8a, 0x0000000036b398f4},
++        /* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
++        {0x00000001d29ee8e0, 0x00000001748f9adc},
++        /* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
++        {0x000000006a08ace8, 0x00000001be94ec00},
++        /* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
++        {0x0000000127d42010, 0x00000000b74370d6},
++        /* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
++        {0x0000000019d76b62, 0x00000001174d0b98},
++        /* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
++        {0x00000001b1471f6e, 0x00000000befc06a4},
++        /* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
++        {0x00000001f64c19cc, 0x00000001ae125288},
++        /* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
++        {0x00000000003c0ea0, 0x0000000095c19b34},
++        /* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
++        {0x000000014d73abf6, 0x00000001a78496f2},
++        /* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
++        {0x00000001620eb844, 0x00000001ac5390a0},
++        /* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
++        {0x0000000147655048, 0x000000002a80ed6e},
++        /* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
++        {0x0000000067b5077e, 0x00000001fa9b0128},
++        /* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
++        {0x0000000010ffe206, 0x00000001ea94929e},
++        /* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
++        {0x000000000fee8f1e, 0x0000000125f4305c},
++        /* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
++        {0x00000001da26fbae, 0x00000001471e2002},
++        /* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
++        {0x00000001b3a8bd88, 0x0000000132d2253a},
++        /* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
++        {0x00000000e8f3898e, 0x00000000f26b3592},
++        /* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
++        {0x00000000b0d0d28c, 0x00000000bc8b67b0},
++        /* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
++        {0x0000000030f2a798, 0x000000013a826ef2},
++        /* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
++        {0x000000000fba1002, 0x0000000081482c84},
++        /* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
++        {0x00000000bdb9bd72, 0x00000000e77307c2},
++        /* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
++        {0x0000000075d3bf5a, 0x00000000d4a07ec8},
++        /* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
++        {0x00000000ef1f98a0, 0x0000000017102100},
++        /* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
++        {0x00000000689c7602, 0x00000000db406486},
++        /* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
++        {0x000000016d5fa5fe, 0x0000000192db7f88},
++        /* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
++        {0x00000001d0d2b9ca, 0x000000018bf67b1e},
++        /* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
++        {0x0000000041e7b470, 0x000000007c09163e},
++        /* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
++        {0x00000001cbb6495e, 0x000000000adac060},
++        /* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
++        {0x000000010052a0b0, 0x00000000bd8316ae},
++        /* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
++        {0x00000001d8effb5c, 0x000000019f09ab54},
++        /* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
++        {0x00000001d969853c, 0x0000000125155542},
++        /* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
++        {0x00000000523ccce2, 0x000000018fdb5882},
++        /* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
++        {0x000000001e2436bc, 0x00000000e794b3f4},
++        /* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
++        {0x00000000ddd1c3a2, 0x000000016f9bb022},
++        /* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
++        {0x0000000019fcfe38, 0x00000000290c9978},
++        /* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
++        {0x00000001ce95db64, 0x0000000083c0f350},
++        /* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
++        {0x00000000af582806, 0x0000000173ea6628},
++        /* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
++        {0x00000001006388f6, 0x00000001c8b4e00a},
++        /* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
++        {0x0000000179eca00a, 0x00000000de95d6aa},
++        /* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
++        {0x0000000122410a6a, 0x000000010b7f7248},
++        /* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
++        {0x000000004288e87c, 0x00000001326e3a06},
++        /* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
++        {0x000000016c5490da, 0x00000000bb62c2e6},
++        /* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
++        {0x00000000d1c71f6e, 0x0000000156a4b2c2},
++        /* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
++        {0x00000001b4ce08a6, 0x000000011dfe763a},
++        /* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
++        {0x00000001466ba60c, 0x000000007bcca8e2},
++        /* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
++        {0x00000001f6c488a4, 0x0000000186118faa},
++        /* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
++        {0x000000013bfb0682, 0x0000000111a65a88},
++        /* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
++        {0x00000000690e9e54, 0x000000003565e1c4},
++        /* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
++        {0x00000000281346b6, 0x000000012ed02a82},
++        /* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
++        {0x0000000156464024, 0x00000000c486ecfc},
++        /* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
++        {0x000000016063a8dc, 0x0000000001b951b2},
++        /* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
++        {0x0000000116a66362, 0x0000000048143916},
++        /* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
++        {0x000000017e8aa4d2, 0x00000001dc2ae124},
++        /* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
++        {0x00000001728eb10c, 0x00000001416c58d6},
++        /* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
++        {0x00000001b08fd7fa, 0x00000000a479744a},
++        /* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
++        {0x00000001092a16e8, 0x0000000096ca3a26},
++        /* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
++        {0x00000000a505637c, 0x00000000ff223d4e},
++        /* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
++        {0x00000000d94869b2, 0x000000010e84da42},
++        /* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
++        {0x00000001c8b203ae, 0x00000001b61ba3d0},
++        /* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
++        {0x000000005704aea0, 0x00000000680f2de8},
++        /* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
++        {0x000000012e295fa2, 0x000000008772a9a8},
++        /* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
++        {0x000000011d0908bc, 0x0000000155f295bc},
++        /* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
++        {0x0000000193ed97ea, 0x00000000595f9282},
++        /* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
++        {0x000000013a0f1c52, 0x0000000164b1c25a},
++        /* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
++        {0x000000010c2c40c0, 0x00000000fbd67c50},
++        /* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
++        {0x00000000ff6fac3e, 0x0000000096076268},
++        /* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
++        {0x000000017b3609c0, 0x00000001d288e4cc},
++        /* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
++        {0x0000000088c8c922, 0x00000001eaac1bdc},
++        /* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
++        {0x00000001751baae6, 0x00000001f1ea39e2},
++        /* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
++        {0x0000000107952972, 0x00000001eb6506fc},
++        /* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
++        {0x0000000162b00abe, 0x000000010f806ffe},
++        /* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
++        {0x000000000d7b404c, 0x000000010408481e},
++        /* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
++        {0x00000000763b13d4, 0x0000000188260534},
++        /* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
++        {0x00000000f6dc22d8, 0x0000000058fc73e0},
++        /* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
++        {0x000000007daae060, 0x00000000391c59b8},
++        /* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
++        {0x000000013359ab7c, 0x000000018b638400},
++        /* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
++        {0x000000008add438a, 0x000000011738f5c4},
++        /* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
++        {0x00000001edbefdea, 0x000000008cf7c6da},
++        /* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
++        {0x000000004104e0f8, 0x00000001ef97fb16},
++        /* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
++        {0x00000000b48a8222, 0x0000000102130e20},
++        /* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
++        {0x00000001bcb46844, 0x00000000db968898},
++        /* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
++        {0x000000013293ce0a, 0x00000000b5047b5e},
++        /* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
++        {0x00000001710d0844, 0x000000010b90fdb2},
++        /* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
++        {0x0000000117907f6e, 0x000000004834a32e},
++        /* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
++        {0x0000000087ddf93e, 0x0000000059c8f2b0},
++        /* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
++        {0x000000005970e9b0, 0x0000000122cec508},
++        /* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
++        {0x0000000185b2b7d0, 0x000000000a330cda},
++        /* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
++        {0x00000001dcee0efc, 0x000000014a47148c},
++        /* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
++        {0x0000000030da2722, 0x0000000042c61cb8},
++        /* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
++        {0x000000012f925a18, 0x0000000012fe6960},
++        /* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
++        {0x00000000dd2e357c, 0x00000000dbda2c20},
++        /* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
++        {0x00000000071c80de, 0x000000011122410c},
++        /* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
++        {0x000000011513140a, 0x00000000977b2070},
++        /* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
++        {0x00000001df876e8e, 0x000000014050438e},
++        /* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
++        {0x000000015f81d6ce, 0x0000000147c840e8},
++        /* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
++        {0x000000019dd94dbe, 0x00000001cc7c88ce},
++        /* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
++        {0x00000001373d206e, 0x00000001476b35a4},
++        /* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
++        {0x00000000668ccade, 0x000000013d52d508},
++        /* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
++        {0x00000001b192d268, 0x000000008e4be32e},
++        /* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
++        {0x00000000e30f3a78, 0x00000000024120fe},
++        /* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
++        {0x000000010ef1f7bc, 0x00000000ddecddb4},
++        /* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
++        {0x00000001f5ac7380, 0x00000000d4d403bc},
++        /* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
++        {0x000000011822ea70, 0x00000001734b89aa},
++        /* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
++        {0x00000000c3a33848, 0x000000010e7a58d6},
++        /* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
++        {0x00000001bd151c24, 0x00000001f9f04e9c},
++        /* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
++        {0x0000000056002d76, 0x00000000b692225e},
++        /* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
++        {0x000000014657c4f4, 0x000000019b8d3f3e},
++        /* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
++        {0x0000000113742d7c, 0x00000001a874f11e},
++        /* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
++        {0x000000019c5920ba, 0x000000010d5a4254},
++        /* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
++        {0x000000005216d2d6, 0x00000000bbb2f5d6},
++        /* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
++        {0x0000000136f5ad8a, 0x0000000179cc0e36},
++        /* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
++        {0x000000018b07beb6, 0x00000001dca1da4a},
++        /* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
++        {0x00000000db1e93b0, 0x00000000feb1a192},
++        /* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
++        {0x000000000b96fa3a, 0x00000000d1eeedd6},
++        /* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
++        {0x00000001d9968af0, 0x000000008fad9bb4},
++        /* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
++        {0x000000000e4a77a2, 0x00000001884938e4},
++        /* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
++        {0x00000000508c2ac8, 0x00000001bc2e9bc0},
++        /* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
++        {0x0000000021572a80, 0x00000001f9658a68},
++        /* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
++        {0x00000001b859daf2, 0x000000001b9224fc},
++        /* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
++        {0x000000016f788474, 0x0000000055b2fb84},
++        /* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
++        {0x00000001b438810e, 0x000000018b090348},
++        /* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
++        {0x0000000095ddc6f2, 0x000000011ccbd5ea},
++        /* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
++        {0x00000001d977c20c, 0x0000000007ae47f8},
++        /* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
++        {0x00000000ebedb99a, 0x0000000172acbec0},
++        /* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
++        {0x00000001df9e9e92, 0x00000001c6e3ff20},
++        /* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
++        {0x00000001a4a3f952, 0x00000000e1b38744},
++        /* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
++        {0x00000000e2f51220, 0x00000000791585b2},
++        /* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
++        {0x000000004aa01f3e, 0x00000000ac53b894},
++        /* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
++        {0x00000000b3e90a58, 0x00000001ed5f2cf4},
++        /* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
++        {0x000000000c9ca2aa, 0x00000001df48b2e0},
++        /* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
++        {0x0000000151682316, 0x00000000049c1c62},
++        /* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
++        {0x0000000036fce78c, 0x000000017c460c12},
++        /* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
++        {0x000000009037dc10, 0x000000015be4da7e},
++        /* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
++        {0x00000000d3298582, 0x000000010f38f668},
++        /* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
++        {0x00000001b42e8ad6, 0x0000000039f40a00},
++        /* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
++        {0x00000000142a9838, 0x00000000bd4c10c4},
++        /* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
++        {0x0000000109c7f190, 0x0000000042db1d98},
++        /* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
++        {0x0000000056ff9310, 0x00000001c905bae6},
++        /* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
++        {0x00000001594513aa, 0x00000000069d40ea},
++        /* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
++        {0x00000001e3b5b1e8, 0x000000008e4fbad0},
++        /* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
++        {0x000000011dd5fc08, 0x0000000047bedd46},
++        /* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
++        {0x00000001675f0cc2, 0x0000000026396bf8},
++        /* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
++        {0x00000000d1c8dd44, 0x00000000379beb92},
++        /* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
++        {0x0000000115ebd3d8, 0x000000000abae54a},
++        /* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
++        {0x00000001ecbd0dac, 0x0000000007e6a128},
++        /* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
++        {0x00000000cdf67af2, 0x000000000ade29d2},
++        /* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
++        {0x000000004c01ff4c, 0x00000000f974c45c},
++        /* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
++        {0x00000000f2d8657e, 0x00000000e77ac60a},
++        /* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
++        {0x000000006bae74c4, 0x0000000145895816},
++        /* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
++        {0x0000000152af8aa0, 0x0000000038e362be},
++        /* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
++        {0x0000000004663802, 0x000000007f991a64},
++        /* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
++        {0x00000001ab2f5afc, 0x00000000fa366d3a},
++        /* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
++        {0x0000000074a4ebd4, 0x00000001a2bb34f0},
++        /* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
++        {0x00000001d7ab3a4c, 0x0000000028a9981e},
++        /* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
++        {0x00000001a8da60c6, 0x00000001dbc672be},
++        /* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
++        {0x000000013cf63820, 0x00000000b04d77f6},
++        /* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
++        {0x00000000bec12e1e, 0x0000000124400d96},
++        /* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
++        {0x00000001c6368010, 0x000000014ca4b414},
++        /* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
++        {0x00000001e6e78758, 0x000000012fe2c938},
++        /* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
++        {0x000000008d7f2b3c, 0x00000001faed01e6},
++        /* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
++        {0x000000016b4a156e, 0x000000007e80ecfe},
++        /* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
++        {0x00000001c63cfeb6, 0x0000000098daee94},
++        /* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
++        {0x000000015f902670, 0x000000010a04edea},
++        /* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
++        {0x00000001cd5de11e, 0x00000001c00b4524},
++        /* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
++        {0x000000001acaec54, 0x0000000170296550},
++        /* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
++        {0x000000002bd0ca78, 0x0000000181afaa48},
++        /* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
++        {0x0000000032d63d5c, 0x0000000185a31ffa},
++        /* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
++        {0x000000001c6d4e4c, 0x000000002469f608},
++        /* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
++        {0x0000000106a60b92, 0x000000006980102a},
++        /* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
++        {0x00000000d3855e12, 0x0000000111ea9ca8},
++        /* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
++        {0x00000000e3125636, 0x00000001bd1d29ce},
++        /* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
++        {0x000000009e8f7ea4, 0x00000001b34b9580},
++        /* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
++        {0x00000001c82e562c, 0x000000003076054e},
++        /* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
++        {0x00000000ca9f09ce, 0x000000012a608ea4},
++        /* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
++        {0x00000000c63764e6, 0x00000000784d05fe},
++        /* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
++        {0x0000000168d2e49e, 0x000000016ef0d82a},
++        /* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
++        {0x00000000e986c148, 0x0000000075bda454},
++        /* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
++        {0x00000000cfb65894, 0x000000003dc0a1c4},
++        /* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
++        {0x0000000111cadee4, 0x00000000e9a5d8be},
++        /* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
++        {0x0000000171fb63ce, 0x00000001609bc4b4}
++#endif /* __LITTLE_ENDIAN__ */
++};
+ 
+-        /* x^32 mod p(x)`, x^64 mod p(x)`, x^96 mod p(x)`, x^128 mod p(x)` */
+-        .octa 0x82f63b786ea2d55ca66805eb18b8ea18
++/* Reduce final 1024-2048 bits to 64 bits, shifting 32 bits to include the
++ * trailing 32 bits of zeros */
++
++static const __vector unsigned long long vcrc_short_const[16] __attribute__((
++    aligned(16))) = {
++#ifdef __LITTLE_ENDIAN__
++    /* x^1952 mod p(x) , x^1984 mod p(x) , x^2016 mod p(x) , x^2048 mod p(x)  */
++    {0x5cf015c388e56f72, 0x7fec2963e5bf8048},
++    /* x^1824 mod p(x) , x^1856 mod p(x) , x^1888 mod p(x) , x^1920 mod p(x)  */
++    {0x963a18920246e2e6, 0x38e888d4844752a9},
++    /* x^1696 mod p(x) , x^1728 mod p(x) , x^1760 mod p(x) , x^1792 mod p(x)  */
++    {0x419a441956993a31, 0x42316c00730206ad},
++    /* x^1568 mod p(x) , x^1600 mod p(x) , x^1632 mod p(x) , x^1664 mod p(x)  */
++    {0x924752ba2b830011, 0x543d5c543e65ddf9},
++    /* x^1440 mod p(x) , x^1472 mod p(x) , x^1504 mod p(x) , x^1536 mod p(x)  */
++    {0x55bd7f9518e4a304, 0x78e87aaf56767c92},
++    /* x^1312 mod p(x) , x^1344 mod p(x) , x^1376 mod p(x) , x^1408 mod p(x)  */
++    {0x6d76739fe0553f1e, 0x8f68fcec1903da7f},
++    /* x^1184 mod p(x) , x^1216 mod p(x) , x^1248 mod p(x) , x^1280 mod p(x)  */
++    {0xc133722b1fe0b5c3, 0x3f4840246791d588},
++    /* x^1056 mod p(x) , x^1088 mod p(x) , x^1120 mod p(x) , x^1152 mod p(x)  */
++    {0x64b67ee0e55ef1f3, 0x34c96751b04de25a},
++    /* x^928 mod p(x) , x^960 mod p(x) , x^992 mod p(x) , x^1024 mod p(x)  */
++    {0x069db049b8fdb1e7, 0x156c8e180b4a395b},
++    /* x^800 mod p(x) , x^832 mod p(x) , x^864 mod p(x) , x^896 mod p(x)  */
++    {0xa11bfaf3c9e90b9e, 0xe0b99ccbe661f7be},
++    /* x^672 mod p(x) , x^704 mod p(x) , x^736 mod p(x) , x^768 mod p(x)  */
++    {0x817cdc5119b29a35, 0x041d37768cd75659},
++    /* x^544 mod p(x) , x^576 mod p(x) , x^608 mod p(x) , x^640 mod p(x)  */
++    {0x1ce9d94b36c41f1c, 0x3a0777818cfaa965},
++    /* x^416 mod p(x) , x^448 mod p(x) , x^480 mod p(x) , x^512 mod p(x)  */
++    {0x4f256efcb82be955, 0x0e148e8252377a55},
++    /* x^288 mod p(x) , x^320 mod p(x) , x^352 mod p(x) , x^384 mod p(x)  */
++    {0xec1631edb2dea967, 0x9c25531d19e65dde},
++    /* x^160 mod p(x) , x^192 mod p(x) , x^224 mod p(x) , x^256 mod p(x)  */
++    {0x5d27e147510ac59a, 0x790606ff9957c0a6},
++    /* x^32 mod p(x) , x^64 mod p(x) , x^96 mod p(x) , x^128 mod p(x)  */
++    {0xa66805eb18b8ea18, 0x82f63b786ea2d55c}
++#else  /* __LITTLE_ENDIAN__ */
++    /* x^1952 mod p(x) , x^1984 mod p(x) , x^2016 mod p(x) , x^2048 mod p(x)  */
++    {0x7fec2963e5bf8048, 0x5cf015c388e56f72},
++    /* x^1824 mod p(x) , x^1856 mod p(x) , x^1888 mod p(x) , x^1920 mod p(x)  */
++    {0x38e888d4844752a9, 0x963a18920246e2e6},
++    /* x^1696 mod p(x) , x^1728 mod p(x) , x^1760 mod p(x) , x^1792 mod p(x)  */
++    {0x42316c00730206ad, 0x419a441956993a31},
++    /* x^1568 mod p(x) , x^1600 mod p(x) , x^1632 mod p(x) , x^1664 mod p(x)  */
++    {0x543d5c543e65ddf9, 0x924752ba2b830011},
++    /* x^1440 mod p(x) , x^1472 mod p(x) , x^1504 mod p(x) , x^1536 mod p(x)  */
++    {0x78e87aaf56767c92, 0x55bd7f9518e4a304},
++    /* x^1312 mod p(x) , x^1344 mod p(x) , x^1376 mod p(x) , x^1408 mod p(x)  */
++    {0x8f68fcec1903da7f, 0x6d76739fe0553f1e},
++    /* x^1184 mod p(x) , x^1216 mod p(x) , x^1248 mod p(x) , x^1280 mod p(x)  */
++    {0x3f4840246791d588, 0xc133722b1fe0b5c3},
++    /* x^1056 mod p(x) , x^1088 mod p(x) , x^1120 mod p(x) , x^1152 mod p(x)  */
++    {0x34c96751b04de25a, 0x64b67ee0e55ef1f3},
++    /* x^928 mod p(x) , x^960 mod p(x) , x^992 mod p(x) , x^1024 mod p(x)  */
++    {0x156c8e180b4a395b, 0x069db049b8fdb1e7},
++    /* x^800 mod p(x) , x^832 mod p(x) , x^864 mod p(x) , x^896 mod p(x)  */
++    {0xe0b99ccbe661f7be, 0xa11bfaf3c9e90b9e},
++    /* x^672 mod p(x) , x^704 mod p(x) , x^736 mod p(x) , x^768 mod p(x)  */
++    {0x041d37768cd75659, 0x817cdc5119b29a35},
++    /* x^544 mod p(x) , x^576 mod p(x) , x^608 mod p(x) , x^640 mod p(x)  */
++    {0x3a0777818cfaa965, 0x1ce9d94b36c41f1c},
++    /* x^416 mod p(x) , x^448 mod p(x) , x^480 mod p(x) , x^512 mod p(x)  */
++    {0x0e148e8252377a55, 0x4f256efcb82be955},
++    /* x^288 mod p(x) , x^320 mod p(x) , x^352 mod p(x) , x^384 mod p(x)  */
++    {0x9c25531d19e65dde, 0xec1631edb2dea967},
++    /* x^160 mod p(x) , x^192 mod p(x) , x^224 mod p(x) , x^256 mod p(x)  */
++    {0x790606ff9957c0a6, 0x5d27e147510ac59a},
++    /* x^32 mod p(x) , x^64 mod p(x) , x^96 mod p(x) , x^128 mod p(x)  */
++    {0x82f63b786ea2d55c, 0xa66805eb18b8ea18}
++#endif /* __LITTLE_ENDIAN__ */
++};
+ 
+-        .barrett_constants :
+-        /* 33 bit reflected Barrett constant m - (4^32)/n */
+-        .octa 0x000000000000000000000000dea713f1 /* x^64 div p(x)` */
+-        /* 33 bit reflected Barrett constant n */
+-        .octa 0x00000000000000000000000105ec76f1
+-#endif
++/* Barrett constants */
++/* 33 bit reflected Barrett constant m - (4^32)/n */
++
++static const __vector unsigned long long v_Barrett_const[2]
++    __attribute__((aligned(16))) = {
++/* x^64 div p(x)  */
++#ifdef __LITTLE_ENDIAN__
++        {0x00000000dea713f1, 0x0000000000000000},
++        {0x0000000105ec76f1, 0x0000000000000000}
++#else  /* __LITTLE_ENDIAN__ */
++        {0x0000000000000000, 0x00000000dea713f1},
++        {0x0000000000000000, 0x0000000105ec76f1}
++#endif /* __LITTLE_ENDIAN__ */
++};
++#endif /* POWER8_INTRINSICS */
+diff --git a/util/crc32c_test.cc b/util/crc32c_test.cc
+index 3e4f7396e7..546c6a4401 100644
+--- a/util/crc32c_test.cc
++++ b/util/crc32c_test.cc
+@@ -108,6 +108,9 @@ TEST(CRC, StandardResults) {
+     EXPECT_EQ(~expected.crc32c, result);
+   }
+ 
++  // NULL buffer
++  EXPECT_EQ((uint32_t)0, Value(NULL, 0));
++
+   // Test 2: stitching two computations
+   for (auto expected : expectedResults) {
+     size_t partialLength = expected.length / 2;
diff --git a/package/rocksdb/0002-replace-POWER-crc32c-with-C-implementation.patch b/package/rocksdb/0002-replace-POWER-crc32c-with-C-implementation.patch
deleted file mode 100644
index f0f4097369..0000000000
--- a/package/rocksdb/0002-replace-POWER-crc32c-with-C-implementation.patch
+++ /dev/null
@@ -1,4058 +0,0 @@
-From 085e4dcf8173e91311fbf9037d8bc9393f254c6f Mon Sep 17 00:00:00 2001
-From: Daniel Black <daniel at linux.ibm.com>
-Date: Fri, 17 Apr 2020 18:54:37 +1000
-Subject: [PATCH] replace POWER crc32c with C implementation
-
-The presence of clang compile failures on POWER due to
-missing ppc-asm.h prompted the replacement of the ASM
-CRC32 implementation with the C implementation.
-
-https://github.com/antonblanchard/crc32-vpmsum/blob/master/vec_crc32.c
-is used with only small include path change with the local copyright header
-maintained.
-
-crc32c_ppc_constants.h per upstream generated, with assembler
-compatible code removed. #pragma once per 64324e329eb0a9b4e77241a425a1615ff524c7f1
-removed unnecessary header wasn't used in util/crc32c.cc.
-
-util/crc32c.cc removes arch_ppc_crc32 which was only ever
-used in a local context. Also incorporated significant advice from
-tchaikov in #2869. HAVE_POWER was never passed from cmake, so replaced
-with the architected _ARCH_PWR8 directive. Altivec overloading removed.
-
-Replaced arch_ppc_probe wrapper to used isAltivec directly.
-
-Corrects getauxval detection from 8bbd76edbf by including the header from the
-right directory.
-
-From the crc32c_ppc.c (now replaced) comment:
-
-  This wrapper function works around the fact that crc32_vpmsum
-  does not gracefully handle the case where the data pointer is NULL.  There
-  may be room for performance improvement here.
-
-This isn't applicable provided the length is 0. Added test case for
-this.
-
-[Retrieved from:
-https://github.com/facebook/rocksdb/commit/085e4dcf8173e91311fbf9037d8bc9393f254c6f]
-Signed-off-by: Fabrice Fontaine <fontaine.fabrice at gmail.com>
----
- CMakeLists.txt                     |   19 +-
- Makefile                           |   44 +-
- util/crc32c.cc                     |   59 +-
- util/crc32c_ppc.c                  |  679 ++++++++-
- util/crc32c_ppc_asm.S              |  752 ----------
- util/crc32c_ppc_clang_workaround.h |   93 ++
- util/crc32c_ppc_constants.h        | 2084 ++++++++++++++++------------
- util/crc32c_test.cc                |    3 +
- 8 files changed, 1943 insertions(+), 1790 deletions(-)
- delete mode 100644 util/crc32c_ppc_asm.S
- create mode 100644 util/crc32c_ppc_clang_workaround.h
-
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 7a9bc71f80..5f8b226d51 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -39,7 +39,7 @@ include(ReadVersion)
- get_rocksdb_version(rocksdb_VERSION)
- project(rocksdb
-   VERSION ${rocksdb_VERSION}
--  LANGUAGES CXX C ASM)
-+  LANGUAGES CXX C)
- 
- if(POLICY CMP0042)
-   cmake_policy(SET CMP0042 NEW)
-@@ -215,12 +215,6 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
-       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=power8 -mtune=power8")
-     endif(HAS_POWER8)
-   endif(HAS_POWER9)
--  CHECK_C_COMPILER_FLAG("-maltivec" HAS_ALTIVEC)
--  if(HAS_ALTIVEC)
--    message(STATUS " HAS_ALTIVEC yes")
--    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maltivec")
--    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maltivec")
--  endif(HAS_ALTIVEC)
- endif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
- 
- if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64")
-@@ -490,7 +484,7 @@ if(HAVE_SCHED_GETCPU)
-   add_definitions(-DROCKSDB_SCHED_GETCPU_PRESENT)
- endif()
- 
--check_cxx_symbol_exists(getauxval auvx.h HAVE_AUXV_GETAUXVAL)
-+check_cxx_symbol_exists(getauxval sys/auxv.h HAVE_AUXV_GETAUXVAL)
- if(HAVE_AUXV_GETAUXVAL)
-   add_definitions(-DROCKSDB_AUXV_GETAUXVAL_PRESENT)
- endif()
-@@ -761,11 +755,14 @@ if(HAVE_SSE42 AND NOT MSVC)
-     PROPERTIES COMPILE_FLAGS "-msse4.2 -mpclmul")
- endif()
- 
--if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
-+if(HAS_POWER8)
-   list(APPEND SOURCES
-+    util/crc32c_ppc.c)
-+  set_source_files_properties(
-     util/crc32c_ppc.c
--    util/crc32c_ppc_asm.S)
--endif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
-+    PROPERTIES COMPILE_FLAGS "-maltivec"
-+      COMPILE_DEFINITIONS "CRC32_FUNCTION=crc32c_ppc;CRC32_CONSTANTS_HEADER=\"crc32c_ppc_constants.h\"")
-+endif(HAS_POWER8)
- 
- if(HAS_ARMV8_CRC)
-   list(APPEND SOURCES
-diff --git a/Makefile b/Makefile
-index a258819f82..0249ce84bc 100644
---- a/Makefile
-+++ b/Makefile
-@@ -132,16 +132,9 @@ OPT += -momit-leaf-frame-pointer
- endif
- endif
- 
--ifeq (,$(shell $(CXX) -fsyntax-only -maltivec -xc /dev/null 2>&1))
--CXXFLAGS += -DHAS_ALTIVEC
--CFLAGS += -DHAS_ALTIVEC
--HAS_ALTIVEC=1
--endif
--
- ifeq (,$(shell $(CXX) -fsyntax-only -mcpu=power8 -xc /dev/null 2>&1))
--CXXFLAGS += -DHAVE_POWER8
--CFLAGS +=  -DHAVE_POWER8
- HAVE_POWER8=1
-+POWER8_CFLAGS=-maltivec -DCRC32_CONSTANTS_HEADER='"crc32c_ppc_constants.h"' -DCRC32_FUNCTION=crc32c_ppc
- endif
- 
- ifeq (,$(shell $(CXX) -fsyntax-only -march=armv8-a+crc+crypto -xc /dev/null 2>&1))
-@@ -418,7 +411,6 @@ LIBOBJECTS = $(LIB_SOURCES:.cc=.o)
- ifeq ($(HAVE_POWER8),1)
- LIB_CC_OBJECTS = $(LIB_SOURCES:.cc=.o)
- LIBOBJECTS += $(LIB_SOURCES_C:.c=.o)
--LIBOBJECTS += $(LIB_SOURCES_ASM:.S=.o)
- else
- LIB_CC_OBJECTS = $(LIB_SOURCES:.cc=.o)
- endif
-@@ -730,9 +722,7 @@ $(SHARED3): $(SHARED4)
- endif
- ifeq ($(HAVE_POWER8),1)
- SHARED_C_OBJECTS = $(LIB_SOURCES_C:.c=.o)
--SHARED_ASM_OBJECTS = $(LIB_SOURCES_ASM:.S=.o)
- SHARED_C_LIBOBJECTS = $(patsubst %.o,shared-objects/%.o,$(SHARED_C_OBJECTS))
--SHARED_ASM_LIBOBJECTS = $(patsubst %.o,shared-objects/%.o,$(SHARED_ASM_OBJECTS))
- shared_libobjects = $(patsubst %,shared-objects/%,$(LIB_CC_OBJECTS))
- else
- shared_libobjects = $(patsubst %,shared-objects/%,$(LIBOBJECTS))
-@@ -742,13 +732,10 @@ CLEAN_FILES += shared-objects
- shared_all_libobjects = $(shared_libobjects)
- 
- ifeq ($(HAVE_POWER8),1)
--shared-ppc-objects = $(SHARED_C_LIBOBJECTS) $(SHARED_ASM_LIBOBJECTS)
-+shared-ppc-objects = $(SHARED_C_LIBOBJECTS)
- 
- shared-objects/util/crc32c_ppc.o: util/crc32c_ppc.c
--	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
--
--shared-objects/util/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
--	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-+	$(AM_V_CC)$(CC) $(CFLAGS) $(POWER8_CFLAGS) -c $< -o $@
- endif
- $(shared_libobjects): shared-objects/%.o: %.cc
- 	$(AM_V_CC)mkdir -p $(@D) && $(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) -c $< -o $@
-@@ -1981,15 +1968,11 @@ JAVA_STATIC_INCLUDES = -I./zlib-$(ZLIB_VER) -I./bzip2-$(BZIP2_VER) -I./snappy-$(
- 
- ifeq ($(HAVE_POWER8),1)
- JAVA_STATIC_C_LIBOBJECTS = $(patsubst %.c.o,jls/%.c.o,$(LIB_SOURCES_C:.c=.o))
--JAVA_STATIC_ASM_LIBOBJECTS = $(patsubst %.S.o,jls/%.S.o,$(LIB_SOURCES_ASM:.S=.o))
- 
--java_static_ppc_libobjects = $(JAVA_STATIC_C_LIBOBJECTS) $(JAVA_STATIC_ASM_LIBOBJECTS)
-+java_static_ppc_libobjects = $(JAVA_STATIC_C_LIBOBJECTS)
- 
- jls/util/crc32c_ppc.o: util/crc32c_ppc.c
--	$(AM_V_CC)$(CC) $(CFLAGS) $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES) -c $< -o $@
--
--jls/util/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
--	$(AM_V_CC)$(CC) $(CFLAGS) $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES) -c $< -o $@
-+	$(AM_V_CC)$(CC) $(CFLAGS) $(POWER8_CFLAGS) $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES) -c $< -o $@
- 
- java_static_all_libobjects += $(java_static_ppc_libobjects)
- endif
-@@ -2075,10 +2058,8 @@ rocksdbjavastaticpublishcentral:
- ifeq ($(HAVE_POWER8),1)
- JAVA_CC_OBJECTS = $(SHARED_CC_OBJECTS)
- JAVA_C_OBJECTS = $(SHARED_C_OBJECTS)
--JAVA_ASM_OBJECTS = $(SHARED_ASM_OBJECTS)
- 
- JAVA_C_LIBOBJECTS = $(patsubst %.c.o,jl/%.c.o,$(JAVA_C_OBJECTS))
--JAVA_ASM_LIBOBJECTS = $(patsubst %.S.o,jl/%.S.o,$(JAVA_ASM_OBJECTS))
- endif
- 
- java_libobjects = $(patsubst %,jl/%,$(LIB_CC_OBJECTS))
-@@ -2086,13 +2067,11 @@ CLEAN_FILES += jl
- java_all_libobjects = $(java_libobjects)
- 
- ifeq ($(HAVE_POWER8),1)
--java_ppc_libobjects = $(JAVA_C_LIBOBJECTS) $(JAVA_ASM_LIBOBJECTS)
-+java_ppc_libobjects = $(JAVA_C_LIBOBJECTS)
- 
- jl/crc32c_ppc.o: util/crc32c_ppc.c
--	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-+	$(AM_V_CC)$(CC) $(CFLAGS) $(POWER8_CFLAGS) -c $< -o $@
- 
--jl/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
--	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
- java_all_libobjects += $(java_ppc_libobjects)
- endif
- 
-@@ -2160,10 +2139,7 @@ IOSVERSION=$(shell defaults read $(PLATFORMSROOT)/iPhoneOS.platform/version CFBu
- else
- ifeq ($(HAVE_POWER8),1)
- util/crc32c_ppc.o: util/crc32c_ppc.c
--	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
--
--util/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
--	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-+	$(AM_V_CC)$(CC) $(CFLAGS) $(POWER8_CFLAGS) -c $< -o $@
- endif
- .cc.o:
- 	$(AM_V_CC)$(CXX) $(CXXFLAGS) -c $< -o $@ $(COVERAGEFLAGS)
-@@ -2200,7 +2176,6 @@ endif
- 
- ifeq ($(HAVE_POWER8),1)
- DEPFILES_C = $(LIB_SOURCES_C:.c=.c.d)
--DEPFILES_ASM = $(LIB_SOURCES_ASM:.S=.S.d)
- 
- %.c.d: %.c
- 	@$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) \
-@@ -2212,8 +2187,7 @@ DEPFILES_ASM = $(LIB_SOURCES_ASM:.S=.S.d)
- 
- $(DEPFILES_C): %.c.d
- 
--$(DEPFILES_ASM): %.S.d
--depend: $(DEPFILES) $(DEPFILES_C) $(DEPFILES_ASM)
-+depend: $(DEPFILES) $(DEPFILES_C)
- else
- depend: $(DEPFILES)
- endif
-diff --git a/util/crc32c.cc b/util/crc32c.cc
-index fa70d23ff5..ce16cb777e 100644
---- a/util/crc32c.cc
-+++ b/util/crc32c.cc
-@@ -20,15 +20,12 @@
- 
- #include "util/crc32c_arm64.h"
- 
--#ifdef __powerpc64__
--#include "util/crc32c_ppc.h"
--#include "util/crc32c_ppc_constants.h"
--
--#if __linux__
- #ifdef ROCKSDB_AUXV_GETAUXVAL_PRESENT
- #include <sys/auxv.h>
- #endif
- 
-+#ifdef __powerpc64__
-+#include "util/crc32c_ppc.h"
- #ifndef PPC_FEATURE2_VEC_CRYPTO
- #define PPC_FEATURE2_VEC_CRYPTO 0x02000000
- #endif
-@@ -37,19 +34,11 @@
- #define AT_HWCAP2 26
- #endif
- 
--#endif /* __linux__ */
--
- #endif
- 
- namespace ROCKSDB_NAMESPACE {
- namespace crc32c {
- 
--#if defined(HAVE_POWER8) && defined(HAS_ALTIVEC)
--#ifdef __powerpc64__
--static int arch_ppc_crc32 = 0;
--#endif /* __powerpc64__ */
--#endif
--
- static const uint32_t table0_[256] = {
-   0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4,
-   0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
-@@ -342,6 +331,7 @@ static inline void Slow_CRC32(uint64_t* l, uint8_t const **p) {
-   table0_[c >> 24];
- }
- 
-+#ifndef _ARCH_PWR8
- static inline void Fast_CRC32(uint64_t* l, uint8_t const **p) {
- #ifndef HAVE_SSE42
-   Slow_CRC32(l, p);
-@@ -355,6 +345,7 @@ static inline void Fast_CRC32(uint64_t* l, uint8_t const **p) {
-   *p += 4;
- #endif
- }
-+#endif
- 
- template<void (*CRC32)(uint64_t*, uint8_t const**)>
- uint32_t ExtendImpl(uint32_t crc, const char* buf, size_t size) {
-@@ -403,7 +394,7 @@ uint32_t ExtendImpl(uint32_t crc, const char* buf, size_t size) {
- // Detect if ARM64 CRC or not.
- #ifndef HAVE_ARM64_CRC
- // Detect if SS42 or not.
--#ifndef HAVE_POWER8
-+#ifndef _ARCH_PWR8
- 
- static bool isSSE42() {
- #ifndef HAVE_SSE42
-@@ -439,36 +430,23 @@ static bool isPCLMULQDQ() {
- #endif
- }
- 
--#endif  // HAVE_POWER8
-+#endif  // _ARCH_PWR8
- #endif  // HAVE_ARM64_CRC
- 
- typedef uint32_t (*Function)(uint32_t, const char*, size_t);
- 
--#if defined(HAVE_POWER8) && defined(HAS_ALTIVEC)
-+#if defined(__powerpc64__)
- uint32_t ExtendPPCImpl(uint32_t crc, const char *buf, size_t size) {
-   return crc32c_ppc(crc, (const unsigned char *)buf, size);
- }
- 
--#if __linux__
--static int arch_ppc_probe(void) {
--  arch_ppc_crc32 = 0;
--
--#if defined(__powerpc64__) && defined(ROCKSDB_AUXV_GETAUXVAL_PRESENT)
--  if (getauxval(AT_HWCAP2) & PPC_FEATURE2_VEC_CRYPTO) arch_ppc_crc32 = 1;
--#endif /* __powerpc64__ */
--
--  return arch_ppc_crc32;
--}
--#endif  // __linux__
--
- static bool isAltiVec() {
--  if (arch_ppc_probe()) {
--    return true;
--  } else {
--    return false;
--  }
--}
-+#if defined(__linux__) && defined(ROCKSDB_AUXV_GETAUXVAL_PRESENT)
-+  if (getauxval(AT_HWCAP2) & PPC_FEATURE2_VEC_CRYPTO) return true;
- #endif
-+  return false;
-+}
-+#endif  // __power64__
- 
- #if defined(__linux__) && defined(HAVE_ARM64_CRC)
- uint32_t ExtendARMImpl(uint32_t crc, const char *buf, size_t size) {
-@@ -480,16 +458,9 @@ std::string IsFastCrc32Supported() {
-   bool has_fast_crc = false;
-   std::string fast_zero_msg;
-   std::string arch;
--#ifdef HAVE_POWER8
--#ifdef HAS_ALTIVEC
--  if (arch_ppc_probe()) {
--    has_fast_crc = true;
--    arch = "PPC";
--  }
--#else
--  has_fast_crc = false;
-+#ifdef __powerpc64__
-+  has_fast_crc = isAltiVec();
-   arch = "PPC";
--#endif
- #elif defined(__linux__) && defined(HAVE_ARM64_CRC)
-   if (crc32c_runtime_check()) {
-     has_fast_crc = true;
-@@ -1220,7 +1191,7 @@ uint32_t crc32c_3way(uint32_t crc, const char* buf, size_t len) {
- #endif //HAVE_SSE42 && HAVE_PCLMUL
- 
- static inline Function Choose_Extend() {
--#ifdef HAVE_POWER8
-+#ifdef __powerpc64__
-   return isAltiVec() ? ExtendPPCImpl : ExtendImpl<Slow_CRC32>;
- #elif defined(__linux__) && defined(HAVE_ARM64_CRC)
-   if(crc32c_runtime_check()) {
-diff --git a/util/crc32c_ppc.c b/util/crc32c_ppc.c
-index 888a4943ea..a8914e8fbd 100644
---- a/util/crc32c_ppc.c
-+++ b/util/crc32c_ppc.c
-@@ -4,91 +4,648 @@
- //  This source code is licensed under both the GPLv2 (found in the
- //  COPYING file in the root directory) and Apache 2.0 License
- //  (found in the LICENSE.Apache file in the root directory).
-+//  From: https://github.com/antonblanchard/crc32-vpmsum/blob/master/vec_crc32.c
- 
-+#include <altivec.h>
-+
-+#define POWER8_INTRINSICS
- #define CRC_TABLE
--#include <stdint.h>
--#include <stdlib.h>
--#include <strings.h>
--#include "util/crc32c_ppc_constants.h"
- 
--#define VMX_ALIGN 16
--#define VMX_ALIGN_MASK (VMX_ALIGN - 1)
-+#ifdef CRC32_CONSTANTS_HEADER
-+#include CRC32_CONSTANTS_HEADER
-+#else
-+#include "crc32_constants.h"
-+#endif
-+
-+#define VMX_ALIGN	16
-+#define VMX_ALIGN_MASK	(VMX_ALIGN-1)
- 
- #ifdef REFLECT
--static unsigned int crc32_align(unsigned int crc, unsigned char const *p,
--                                unsigned long len) {
--  while (len--) crc = crc_table[(crc ^ *p++) & 0xff] ^ (crc >> 8);
--  return crc;
-+static unsigned int crc32_align(unsigned int crc, const unsigned char *p,
-+			       unsigned long len)
-+{
-+	while (len--)
-+		crc = crc_table[(crc ^ *p++) & 0xff] ^ (crc >> 8);
-+	return crc;
-+}
-+#else
-+static unsigned int crc32_align(unsigned int crc, const unsigned char *p,
-+				unsigned long len)
-+{
-+	while (len--)
-+		crc = crc_table[((crc >> 24) ^ *p++) & 0xff] ^ (crc << 8);
-+	return crc;
- }
- #endif
- 
--#ifdef HAVE_POWER8
--unsigned int __crc32_vpmsum(unsigned int crc, unsigned char const *p,
--                            unsigned long len);
-+static unsigned int __attribute__ ((aligned (32)))
-+__crc32_vpmsum(unsigned int crc, const void* p, unsigned long len);
- 
--static uint32_t crc32_vpmsum(uint32_t crc, unsigned char const *data,
--                             unsigned len) {
--  unsigned int prealign;
--  unsigned int tail;
-+#ifndef CRC32_FUNCTION
-+#define CRC32_FUNCTION  crc32_vpmsum
-+#endif
-+
-+unsigned int CRC32_FUNCTION(unsigned int crc, const unsigned char *p,
-+			    unsigned long len)
-+{
-+	unsigned int prealign;
-+	unsigned int tail;
- 
- #ifdef CRC_XOR
--  crc ^= 0xffffffff;
-+	crc ^= 0xffffffff;
- #endif
- 
--  if (len < VMX_ALIGN + VMX_ALIGN_MASK) {
--    crc = crc32_align(crc, data, (unsigned long)len);
--    goto out;
--  }
-+	if (len < VMX_ALIGN + VMX_ALIGN_MASK) {
-+		crc = crc32_align(crc, p, len);
-+		goto out;
-+	}
- 
--  if ((unsigned long)data & VMX_ALIGN_MASK) {
--    prealign = VMX_ALIGN - ((unsigned long)data & VMX_ALIGN_MASK);
--    crc = crc32_align(crc, data, prealign);
--    len -= prealign;
--    data += prealign;
--  }
-+	if ((unsigned long)p & VMX_ALIGN_MASK) {
-+		prealign = VMX_ALIGN - ((unsigned long)p & VMX_ALIGN_MASK);
-+		crc = crc32_align(crc, p, prealign);
-+		len -= prealign;
-+		p += prealign;
-+	}
- 
--  crc = __crc32_vpmsum(crc, data, (unsigned long)len & ~VMX_ALIGN_MASK);
-+	crc = __crc32_vpmsum(crc, p, len & ~VMX_ALIGN_MASK);
- 
--  tail = len & VMX_ALIGN_MASK;
--  if (tail) {
--    data += len & ~VMX_ALIGN_MASK;
--    crc = crc32_align(crc, data, tail);
--  }
-+	tail = len & VMX_ALIGN_MASK;
-+	if (tail) {
-+		p += len & ~VMX_ALIGN_MASK;
-+		crc = crc32_align(crc, p, tail);
-+	}
- 
- out:
- #ifdef CRC_XOR
--  crc ^= 0xffffffff;
-+	crc ^= 0xffffffff;
- #endif
- 
--  return crc;
-+	return crc;
- }
- 
--/* This wrapper function works around the fact that crc32_vpmsum
-- * does not gracefully handle the case where the data pointer is NULL.  There
-- * may be room for performance improvement here.
-+#if defined (__clang__)
-+#include "crc32c_ppc_clang_workaround.h"
-+#else
-+#define __builtin_pack_vector(a, b)  __builtin_pack_vector_int128 ((a), (b))
-+#define __builtin_unpack_vector_0(a) __builtin_unpack_vector_int128 ((vector __int128_t)(a), 0)
-+#define __builtin_unpack_vector_1(a) __builtin_unpack_vector_int128 ((vector __int128_t)(a), 1)
-+#endif
-+
-+/* When we have a load-store in a single-dispatch group and address overlap
-+ * such that foward is not allowed (load-hit-store) the group must be flushed.
-+ * A group ending NOP prevents the flush.
-  */
--uint32_t crc32c_ppc(uint32_t crc, unsigned char const *data, unsigned len) {
--  unsigned char *buf2;
--
--  if (!data) {
--    buf2 = (unsigned char *)malloc(len);
--    bzero(buf2, len);
--    crc = crc32_vpmsum(crc, buf2, len);
--    free(buf2);
--  } else {
--    crc = crc32_vpmsum(crc, data, (unsigned long)len);
--  }
--  return crc;
--}
-+#define GROUP_ENDING_NOP asm("ori 2,2,0" ::: "memory")
- 
--#else /* HAVE_POWER8 */
-+#if defined(__BIG_ENDIAN__) && defined (REFLECT)
-+#define BYTESWAP_DATA
-+#elif defined(__LITTLE_ENDIAN__) && !defined(REFLECT)
-+#define BYTESWAP_DATA
-+#endif
- 
--/* This symbol has to exist on non-ppc architectures (and on legacy
-- * ppc systems using power7 or below) in order to compile properly
-- * there, even though it won't be called.
-- */
--uint32_t crc32c_ppc(uint32_t crc, unsigned char const *data, unsigned len) {
--  return 0;
--}
-+#ifdef BYTESWAP_DATA
-+#define VEC_PERM(vr, va, vb, vc) vr = vec_perm(va, vb,\
-+			(__vector unsigned char) vc)
-+#if defined(__LITTLE_ENDIAN__)
-+/* Byte reverse permute constant LE. */
-+static const __vector unsigned long long vperm_const
-+	__attribute__ ((aligned(16))) = { 0x08090A0B0C0D0E0FUL,
-+			0x0001020304050607UL };
-+#else
-+static const __vector unsigned long long vperm_const
-+	__attribute__ ((aligned(16))) = { 0x0F0E0D0C0B0A0908UL,
-+			0X0706050403020100UL };
-+#endif
-+#else
-+#define VEC_PERM(vr, va, vb, vc)
-+#endif
-+
-+static unsigned int __attribute__ ((aligned (32)))
-+__crc32_vpmsum(unsigned int crc, const void* p, unsigned long len) {
-+
-+	const __vector unsigned long long vzero = {0,0};
-+	const __vector unsigned long long vones = {0xffffffffffffffffUL,
-+		0xffffffffffffffffUL};
-+
-+#ifdef REFLECT
-+	const __vector unsigned long long vmask_32bit =
-+		(__vector unsigned long long)vec_sld((__vector unsigned char)vzero,
-+			(__vector unsigned char)vones, 4);
-+#endif
-+
-+	const __vector unsigned long long vmask_64bit =
-+		(__vector unsigned long long)vec_sld((__vector unsigned char)vzero,
-+			(__vector unsigned char)vones, 8);
-+
-+	__vector unsigned long long vcrc;
-+
-+	__vector unsigned long long vconst1, vconst2;
-+
-+	/* vdata0-vdata7 will contain our data (p). */
-+	__vector unsigned long long vdata0, vdata1, vdata2, vdata3, vdata4,
-+		vdata5, vdata6, vdata7;
-+
-+	/* v0-v7 will contain our checksums */
-+	__vector unsigned long long v0 = {0,0};
-+	__vector unsigned long long v1 = {0,0};
-+	__vector unsigned long long v2 = {0,0};
-+	__vector unsigned long long v3 = {0,0};
-+	__vector unsigned long long v4 = {0,0};
-+	__vector unsigned long long v5 = {0,0};
-+	__vector unsigned long long v6 = {0,0};
-+	__vector unsigned long long v7 = {0,0};
-+
-+
-+	/* Vector auxiliary variables. */
-+	__vector unsigned long long va0, va1, va2, va3, va4, va5, va6, va7;
-+
-+	unsigned int result = 0;
-+	unsigned int offset; /* Constant table offset. */
-+
-+	unsigned long i; /* Counter. */
-+	unsigned long chunks;
-+
-+	unsigned long block_size;
-+	int next_block = 0;
-+
-+	/* Align by 128 bits. The last 128 bit block will be processed at end. */
-+	unsigned long length = len & 0xFFFFFFFFFFFFFF80UL;
-+
-+#ifdef REFLECT
-+	vcrc = (__vector unsigned long long)__builtin_pack_vector(0UL, crc);
-+#else
-+	vcrc = (__vector unsigned long long)__builtin_pack_vector(crc, 0UL);
-+
-+	/* Shift into top 32 bits */
-+	vcrc = (__vector unsigned long long)vec_sld((__vector unsigned char)vcrc,
-+        (__vector unsigned char)vzero, 4);
-+#endif
-+
-+	/* Short version. */
-+	if (len < 256) {
-+		/* Calculate where in the constant table we need to start. */
-+		offset = 256 - len;
-+
-+		vconst1 = vec_ld(offset, vcrc_short_const);
-+		vdata0 = vec_ld(0, (__vector unsigned long long*) p);
-+		VEC_PERM(vdata0, vdata0, vconst1, vperm_const);
-+
-+		/* xor initial value*/
-+		vdata0 = vec_xor(vdata0, vcrc);
-+
-+		vdata0 = (__vector unsigned long long) __builtin_crypto_vpmsumw
-+				((__vector unsigned int)vdata0, (__vector unsigned int)vconst1);
-+		v0 = vec_xor(v0, vdata0);
-+
-+		for (i = 16; i < len; i += 16) {
-+			vconst1 = vec_ld(offset + i, vcrc_short_const);
-+			vdata0 = vec_ld(i, (__vector unsigned long long*) p);
-+			VEC_PERM(vdata0, vdata0, vconst1, vperm_const);
-+			vdata0 = (__vector unsigned long long) __builtin_crypto_vpmsumw
-+				((__vector unsigned int)vdata0, (__vector unsigned int)vconst1);
-+			v0 = vec_xor(v0, vdata0);
-+		}
-+	} else {
-+
-+		/* Load initial values. */
-+		vdata0 = vec_ld(0, (__vector unsigned long long*) p);
-+		vdata1 = vec_ld(16, (__vector unsigned long long*) p);
-+
-+		VEC_PERM(vdata0, vdata0, vdata0, vperm_const);
-+		VEC_PERM(vdata1, vdata1, vdata1, vperm_const);
-+
-+		vdata2 = vec_ld(32, (__vector unsigned long long*) p);
-+		vdata3 = vec_ld(48, (__vector unsigned long long*) p);
-+
-+		VEC_PERM(vdata2, vdata2, vdata2, vperm_const);
-+		VEC_PERM(vdata3, vdata3, vdata3, vperm_const);
-+
-+		vdata4 = vec_ld(64, (__vector unsigned long long*) p);
-+		vdata5 = vec_ld(80, (__vector unsigned long long*) p);
-+
-+		VEC_PERM(vdata4, vdata4, vdata4, vperm_const);
-+		VEC_PERM(vdata5, vdata5, vdata5, vperm_const);
-+
-+		vdata6 = vec_ld(96, (__vector unsigned long long*) p);
-+		vdata7 = vec_ld(112, (__vector unsigned long long*) p);
-+
-+		VEC_PERM(vdata6, vdata6, vdata6, vperm_const);
-+		VEC_PERM(vdata7, vdata7, vdata7, vperm_const);
-+
-+		/* xor in initial value */
-+		vdata0 = vec_xor(vdata0, vcrc);
-+
-+		p = (char *)p + 128;
-+
-+		do {
-+			/* Checksum in blocks of MAX_SIZE. */
-+			block_size = length;
-+			if (block_size > MAX_SIZE) {
-+				block_size = MAX_SIZE;
-+			}
-+
-+			length = length - block_size;
-+
-+			/*
-+			* Work out the offset into the constants table to start at. Each
-+			* constant is 16 bytes, and it is used against 128 bytes of input
-+			* data - 128 / 16 = 8
-+			*/
-+			offset = (MAX_SIZE/8) - (block_size/8);
-+			/* We reduce our final 128 bytes in a separate step */
-+			chunks = (block_size/128)-1;
-+
-+		    vconst1 = vec_ld(offset, vcrc_const);
-+
-+			va0 = __builtin_crypto_vpmsumd ((__vector unsigned long long)vdata0,
-+						(__vector unsigned long long)vconst1);
-+			va1 = __builtin_crypto_vpmsumd ((__vector unsigned long long)vdata1,
-+						(__vector unsigned long long)vconst1);
-+			va2 = __builtin_crypto_vpmsumd ((__vector unsigned long long)vdata2,
-+						(__vector unsigned long long)vconst1);
-+			va3 = __builtin_crypto_vpmsumd ((__vector unsigned long long)vdata3,
-+						(__vector unsigned long long)vconst1);
-+			va4 = __builtin_crypto_vpmsumd ((__vector unsigned long long)vdata4,
-+						(__vector unsigned long long)vconst1);
-+			va5 = __builtin_crypto_vpmsumd ((__vector unsigned long long)vdata5,
-+						(__vector unsigned long long)vconst1);
-+			va6 = __builtin_crypto_vpmsumd ((__vector unsigned long long)vdata6,
-+						(__vector unsigned long long)vconst1);
-+			va7 = __builtin_crypto_vpmsumd ((__vector unsigned long long)vdata7,
-+						(__vector unsigned long long)vconst1);
-+
-+			if (chunks > 1) {
-+				offset += 16;
-+				vconst2 = vec_ld(offset, vcrc_const);
-+				GROUP_ENDING_NOP;
-+
-+				vdata0 = vec_ld(0, (__vector unsigned long long*) p);
-+				VEC_PERM(vdata0, vdata0, vdata0, vperm_const);
-+
-+				vdata1 = vec_ld(16, (__vector unsigned long long*) p);
-+				VEC_PERM(vdata1, vdata1, vdata1, vperm_const);
-+
-+				vdata2 = vec_ld(32, (__vector unsigned long long*) p);
-+				VEC_PERM(vdata2, vdata2, vdata2, vperm_const);
-+
-+				vdata3 = vec_ld(48, (__vector unsigned long long*) p);
-+				VEC_PERM(vdata3, vdata3, vdata3, vperm_const);
-+
-+				vdata4 = vec_ld(64, (__vector unsigned long long*) p);
-+				VEC_PERM(vdata4, vdata4, vdata4, vperm_const);
-+
-+				vdata5 = vec_ld(80, (__vector unsigned long long*) p);
-+				VEC_PERM(vdata5, vdata5, vdata5, vperm_const);
-+
-+				vdata6 = vec_ld(96, (__vector unsigned long long*) p);
-+				VEC_PERM(vdata6, vdata6, vdata6, vperm_const);
-+
-+				vdata7 = vec_ld(112, (__vector unsigned long long*) p);
-+				VEC_PERM(vdata7, vdata7, vdata7, vperm_const);
-+
-+				p = (char *)p + 128;
- 
--#endif /* HAVE_POWER8 */
-+				/*
-+				 * main loop. We modulo schedule it such that it takes three
-+				 * iterations to complete - first iteration load, second
-+				 * iteration vpmsum, third iteration xor.
-+				 */
-+				for (i = 0; i < chunks-2; i++) {
-+					vconst1 = vec_ld(offset, vcrc_const);
-+					offset += 16;
-+					GROUP_ENDING_NOP;
-+
-+					v0 = vec_xor(v0, va0);
-+					va0 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata0, (__vector unsigned long long)vconst2);
-+					vdata0 = vec_ld(0, (__vector unsigned long long*) p);
-+					VEC_PERM(vdata0, vdata0, vdata0, vperm_const);
-+					GROUP_ENDING_NOP;
-+
-+					v1 = vec_xor(v1, va1);
-+					va1 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata1, (__vector unsigned long long)vconst2);
-+					vdata1 = vec_ld(16, (__vector unsigned long long*) p);
-+					VEC_PERM(vdata1, vdata1, vdata1, vperm_const);
-+					GROUP_ENDING_NOP;
-+
-+					v2 = vec_xor(v2, va2);
-+					va2 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata2, (__vector unsigned long long)vconst2);
-+					vdata2 = vec_ld(32, (__vector unsigned long long*) p);
-+					VEC_PERM(vdata2, vdata2, vdata2, vperm_const);
-+					GROUP_ENDING_NOP;
-+
-+					v3 = vec_xor(v3, va3);
-+					va3 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata3, (__vector unsigned long long)vconst2);
-+					vdata3 = vec_ld(48, (__vector unsigned long long*) p);
-+					VEC_PERM(vdata3, vdata3, vdata3, vperm_const);
-+
-+					vconst2 = vec_ld(offset, vcrc_const);
-+					GROUP_ENDING_NOP;
-+
-+					v4 = vec_xor(v4, va4);
-+					va4 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata4, (__vector unsigned long long)vconst1);
-+					vdata4 = vec_ld(64, (__vector unsigned long long*) p);
-+					VEC_PERM(vdata4, vdata4, vdata4, vperm_const);
-+					GROUP_ENDING_NOP;
-+
-+					v5 = vec_xor(v5, va5);
-+					va5 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata5, (__vector unsigned long long)vconst1);
-+					vdata5 = vec_ld(80, (__vector unsigned long long*) p);
-+					VEC_PERM(vdata5, vdata5, vdata5, vperm_const);
-+					GROUP_ENDING_NOP;
-+
-+					v6 = vec_xor(v6, va6);
-+					va6 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata6, (__vector unsigned long long)vconst1);
-+					vdata6 = vec_ld(96, (__vector unsigned long long*) p);
-+					VEC_PERM(vdata6, vdata6, vdata6, vperm_const);
-+					GROUP_ENDING_NOP;
-+
-+					v7 = vec_xor(v7, va7);
-+					va7 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata7, (__vector unsigned long long)vconst1);
-+					vdata7 = vec_ld(112, (__vector unsigned long long*) p);
-+					VEC_PERM(vdata7, vdata7, vdata7, vperm_const);
-+
-+					p = (char *)p + 128;
-+				}
-+
-+				/* First cool down*/
-+				vconst1 = vec_ld(offset, vcrc_const);
-+				offset += 16;
-+
-+				v0 = vec_xor(v0, va0);
-+				va0 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata0, (__vector unsigned long long)vconst1);
-+				GROUP_ENDING_NOP;
-+
-+				v1 = vec_xor(v1, va1);
-+				va1 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata1, (__vector unsigned long long)vconst1);
-+				GROUP_ENDING_NOP;
-+
-+				v2 = vec_xor(v2, va2);
-+				va2 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata2, (__vector unsigned long long)vconst1);
-+				GROUP_ENDING_NOP;
-+
-+				v3 = vec_xor(v3, va3);
-+				va3 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata3, (__vector unsigned long long)vconst1);
-+				GROUP_ENDING_NOP;
-+
-+				v4 = vec_xor(v4, va4);
-+				va4 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata4, (__vector unsigned long long)vconst1);
-+				GROUP_ENDING_NOP;
-+
-+				v5 = vec_xor(v5, va5);
-+				va5 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata5, (__vector unsigned long long)vconst1);
-+				GROUP_ENDING_NOP;
-+
-+				v6 = vec_xor(v6, va6);
-+				va6 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata6, (__vector unsigned long long)vconst1);
-+				GROUP_ENDING_NOP;
-+
-+				v7 = vec_xor(v7, va7);
-+				va7 = __builtin_crypto_vpmsumd ((__vector unsigned long
-+							long)vdata7, (__vector unsigned long long)vconst1);
-+			}/* else */
-+
-+			/* Second cool down. */
-+			v0 = vec_xor(v0, va0);
-+			v1 = vec_xor(v1, va1);
-+			v2 = vec_xor(v2, va2);
-+			v3 = vec_xor(v3, va3);
-+			v4 = vec_xor(v4, va4);
-+			v5 = vec_xor(v5, va5);
-+			v6 = vec_xor(v6, va6);
-+			v7 = vec_xor(v7, va7);
-+
-+#ifdef REFLECT
-+			/*
-+			 * vpmsumd produces a 96 bit result in the least significant bits
-+			 * of the register. Since we are bit reflected we have to shift it
-+			 * left 32 bits so it occupies the least significant bits in the
-+			 * bit reflected domain.
-+			 */
-+			v0 = (__vector unsigned long long)vec_sld((__vector unsigned char)v0,
-+					(__vector unsigned char)vzero, 4);
-+			v1 = (__vector unsigned long long)vec_sld((__vector unsigned char)v1,
-+					(__vector unsigned char)vzero, 4);
-+			v2 = (__vector unsigned long long)vec_sld((__vector unsigned char)v2,
-+					(__vector unsigned char)vzero, 4);
-+			v3 = (__vector unsigned long long)vec_sld((__vector unsigned char)v3,
-+					(__vector unsigned char)vzero, 4);
-+			v4 = (__vector unsigned long long)vec_sld((__vector unsigned char)v4,
-+					(__vector unsigned char)vzero, 4);
-+			v5 = (__vector unsigned long long)vec_sld((__vector unsigned char)v5,
-+					(__vector unsigned char)vzero, 4);
-+			v6 = (__vector unsigned long long)vec_sld((__vector unsigned char)v6,
-+					(__vector unsigned char)vzero, 4);
-+			v7 = (__vector unsigned long long)vec_sld((__vector unsigned char)v7,
-+					(__vector unsigned char)vzero, 4);
-+#endif
-+
-+			/* xor with the last 1024 bits. */
-+			va0 = vec_ld(0, (__vector unsigned long long*) p);
-+			VEC_PERM(va0, va0, va0, vperm_const);
-+
-+			va1 = vec_ld(16, (__vector unsigned long long*) p);
-+			VEC_PERM(va1, va1, va1, vperm_const);
-+
-+			va2 = vec_ld(32, (__vector unsigned long long*) p);
-+			VEC_PERM(va2, va2, va2, vperm_const);
-+
-+			va3 = vec_ld(48, (__vector unsigned long long*) p);
-+			VEC_PERM(va3, va3, va3, vperm_const);
-+
-+			va4 = vec_ld(64, (__vector unsigned long long*) p);
-+			VEC_PERM(va4, va4, va4, vperm_const);
-+
-+			va5 = vec_ld(80, (__vector unsigned long long*) p);
-+			VEC_PERM(va5, va5, va5, vperm_const);
-+
-+			va6 = vec_ld(96, (__vector unsigned long long*) p);
-+			VEC_PERM(va6, va6, va6, vperm_const);
-+
-+			va7 = vec_ld(112, (__vector unsigned long long*) p);
-+			VEC_PERM(va7, va7, va7, vperm_const);
-+
-+			p = (char *)p + 128;
-+
-+			vdata0 = vec_xor(v0, va0);
-+			vdata1 = vec_xor(v1, va1);
-+			vdata2 = vec_xor(v2, va2);
-+			vdata3 = vec_xor(v3, va3);
-+			vdata4 = vec_xor(v4, va4);
-+			vdata5 = vec_xor(v5, va5);
-+			vdata6 = vec_xor(v6, va6);
-+			vdata7 = vec_xor(v7, va7);
-+
-+			/* Check if we have more blocks to process */
-+			next_block = 0;
-+			if (length != 0) {
-+				next_block = 1;
-+
-+			    /* zero v0-v7 */
-+				v0 = vec_xor(v0, v0);
-+				v1 = vec_xor(v1, v1);
-+				v2 = vec_xor(v2, v2);
-+				v3 = vec_xor(v3, v3);
-+				v4 = vec_xor(v4, v4);
-+				v5 = vec_xor(v5, v5);
-+				v6 = vec_xor(v6, v6);
-+				v7 = vec_xor(v7, v7);
-+			}
-+			length = length + 128;
-+
-+		} while (next_block);
-+
-+		/* Calculate how many bytes we have left. */
-+		length = (len & 127);
-+
-+		/* Calculate where in (short) constant table we need to start. */
-+		offset = 128 - length;
-+
-+		v0 = vec_ld(offset, vcrc_short_const);
-+		v1 = vec_ld(offset + 16, vcrc_short_const);
-+		v2 = vec_ld(offset + 32, vcrc_short_const);
-+		v3 = vec_ld(offset + 48, vcrc_short_const);
-+		v4 = vec_ld(offset + 64, vcrc_short_const);
-+		v5 = vec_ld(offset + 80, vcrc_short_const);
-+		v6 = vec_ld(offset + 96, vcrc_short_const);
-+		v7 = vec_ld(offset + 112, vcrc_short_const);
-+
-+		offset += 128;
-+
-+		v0 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata0,(__vector unsigned int)v0);
-+		v1 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata1,(__vector unsigned int)v1);
-+		v2 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata2,(__vector unsigned int)v2);
-+		v3 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata3,(__vector unsigned int)v3);
-+		v4 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata4,(__vector unsigned int)v4);
-+		v5 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata5,(__vector unsigned int)v5);
-+		v6 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata6,(__vector unsigned int)v6);
-+		v7 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata7,(__vector unsigned int)v7);
-+
-+		/* Now reduce the tail (0-112 bytes). */
-+		for (i = 0; i < length; i+=16) {
-+			vdata0 = vec_ld(i,(__vector unsigned long long*)p);
-+			VEC_PERM(vdata0, vdata0, vdata0, vperm_const);
-+			va0 = vec_ld(offset + i,vcrc_short_const);
-+			va0 = (__vector unsigned long long)__builtin_crypto_vpmsumw (
-+			(__vector unsigned int)vdata0,(__vector unsigned int)va0);
-+			v0 = vec_xor(v0, va0);
-+		}
-+
-+		/* xor all parallel chunks together. */
-+		v0 = vec_xor(v0, v1);
-+		v2 = vec_xor(v2, v3);
-+		v4 = vec_xor(v4, v5);
-+		v6 = vec_xor(v6, v7);
-+
-+		v0 = vec_xor(v0, v2);
-+		v4 = vec_xor(v4, v6);
-+
-+		v0 = vec_xor(v0, v4);
-+	}
-+
-+	/* Barrett Reduction */
-+	vconst1 = vec_ld(0, v_Barrett_const);
-+	vconst2 = vec_ld(16, v_Barrett_const);
-+
-+	v1 = (__vector unsigned long long)vec_sld((__vector unsigned char)v0,
-+			(__vector unsigned char)v0, 8);
-+	v0 = vec_xor(v1,v0);
-+
-+#ifdef REFLECT
-+	/* shift left one bit */
-+	__vector unsigned char vsht_splat = vec_splat_u8 (1);
-+	v0 = (__vector unsigned long long)vec_sll ((__vector unsigned char)v0,
-+			vsht_splat);
-+#endif
-+
-+	v0 = vec_and(v0, vmask_64bit);
-+
-+#ifndef REFLECT
-+
-+	/*
-+	 * Now for the actual algorithm. The idea is to calculate q,
-+	 * the multiple of our polynomial that we need to subtract. By
-+	 * doing the computation 2x bits higher (ie 64 bits) and shifting the
-+	 * result back down 2x bits, we round down to the nearest multiple.
-+	 */
-+
-+	/* ma */
-+	v1 = __builtin_crypto_vpmsumd ((__vector unsigned long long)v0,
-+			(__vector unsigned long long)vconst1);
-+	/* q = floor(ma/(2^64)) */
-+	v1 = (__vector unsigned long long)vec_sld ((__vector unsigned char)vzero,
-+			(__vector unsigned char)v1, 8);
-+	/* qn */
-+	v1 = __builtin_crypto_vpmsumd ((__vector unsigned long long)v1,
-+			(__vector unsigned long long)vconst2);
-+	/* a - qn, subtraction is xor in GF(2) */
-+	v0 = vec_xor (v0, v1);
-+	/*
-+	 * Get the result into r3. We need to shift it left 8 bytes:
-+	 * V0 [ 0 1 2 X ]
-+	 * V0 [ 0 X 2 3 ]
-+	 */
-+	result = __builtin_unpack_vector_1 (v0);
-+#else
-+
-+	/*
-+	 * The reflected version of Barrett reduction. Instead of bit
-+	 * reflecting our data (which is expensive to do), we bit reflect our
-+	 * constants and our algorithm, which means the intermediate data in
-+	 * our vector registers goes from 0-63 instead of 63-0. We can reflect
-+	 * the algorithm because we don't carry in mod 2 arithmetic.
-+	 */
-+
-+	/* bottom 32 bits of a */
-+	v1 = vec_and(v0, vmask_32bit);
-+
-+	/* ma */
-+	v1 = __builtin_crypto_vpmsumd ((__vector unsigned long long)v1,
-+			(__vector unsigned long long)vconst1);
-+
-+	/* bottom 32bits of ma */
-+	v1 = vec_and(v1, vmask_32bit);
-+	/* qn */
-+	v1 = __builtin_crypto_vpmsumd ((__vector unsigned long long)v1,
-+			(__vector unsigned long long)vconst2);
-+	/* a - qn, subtraction is xor in GF(2) */
-+	v0 = vec_xor (v0, v1);
-+
-+	/*
-+	 * Since we are bit reflected, the result (ie the low 32 bits) is in
-+	 * the high 32 bits. We just need to shift it left 4 bytes
-+	 * V0 [ 0 1 X 3 ]
-+	 * V0 [ 0 X 2 3 ]
-+	 */
-+
-+	/* shift result into top 64 bits of */
-+	v0 = (__vector unsigned long long)vec_sld((__vector unsigned char)v0,
-+        (__vector unsigned char)vzero, 4);
-+
-+	result = __builtin_unpack_vector_0 (v0);
-+#endif
-+
-+	return result;
-+}
-diff --git a/util/crc32c_ppc_asm.S b/util/crc32c_ppc_asm.S
-deleted file mode 100644
-index a317bf96b8..0000000000
---- a/util/crc32c_ppc_asm.S
-+++ /dev/null
-@@ -1,752 +0,0 @@
--//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
--//  Copyright (c) 2015 Anton Blanchard <anton at au.ibm.com>, IBM
--//  Copyright (c) 2017 International Business Machines Corp.
--//  All rights reserved.
--//  This source code is licensed under both the GPLv2 (found in the
--//  COPYING file in the root directory) and Apache 2.0 License
--//  (found in the LICENSE.Apache file in the root directory).
--
--#include <ppc-asm.h>
--#include "ppc-opcode.h"
--
--#undef toc
--
--#ifndef r1
--#define r1 1
--#endif
--
--#ifndef r2
--#define r2 2
--#endif
--
--	.section	.rodata
--.balign 16
--
--.byteswap_constant:
--	/* byte reverse permute constant */
--	.octa 0x0F0E0D0C0B0A09080706050403020100
--
--#define __ASSEMBLY__
--#include "crc32c_ppc_constants.h"
--
--	.text
--
--#if defined(__BIG_ENDIAN__) && defined(REFLECT)
--#define BYTESWAP_DATA
--#elif defined(__LITTLE_ENDIAN__) && !defined(REFLECT)
--#define BYTESWAP_DATA
--#else
--#undef BYTESWAP_DATA
--#endif
--
--#define off16		r25
--#define off32		r26
--#define off48		r27
--#define off64		r28
--#define off80		r29
--#define off96		r30
--#define off112		r31
--
--#define const1		v24
--#define const2		v25
--
--#define byteswap	v26
--#define	mask_32bit	v27
--#define	mask_64bit	v28
--#define zeroes		v29
--
--#ifdef BYTESWAP_DATA
--#define VPERM(A, B, C, D) vperm	A, B, C, D
--#else
--#define VPERM(A, B, C, D)
--#endif
--
--/* unsigned int __crc32_vpmsum(unsigned int crc, void *p, unsigned long len) */
--FUNC_START(__crc32_vpmsum)
--	std	r31,-8(r1)
--	std	r30,-16(r1)
--	std	r29,-24(r1)
--	std	r28,-32(r1)
--	std	r27,-40(r1)
--	std	r26,-48(r1)
--	std	r25,-56(r1)
--
--	li	off16,16
--	li	off32,32
--	li	off48,48
--	li	off64,64
--	li	off80,80
--	li	off96,96
--	li	off112,112
--	li	r0,0
--
--	/* Enough room for saving 10 non volatile VMX registers */
--	subi	r6,r1,56+10*16
--	subi	r7,r1,56+2*16
--
--	stvx	v20,0,r6
--	stvx	v21,off16,r6
--	stvx	v22,off32,r6
--	stvx	v23,off48,r6
--	stvx	v24,off64,r6
--	stvx	v25,off80,r6
--	stvx	v26,off96,r6
--	stvx	v27,off112,r6
--	stvx	v28,0,r7
--	stvx	v29,off16,r7
--
--	mr	r10,r3
--
--	vxor	zeroes,zeroes,zeroes
--	vspltisw v0,-1
--
--	vsldoi	mask_32bit,zeroes,v0,4
--	vsldoi	mask_64bit,zeroes,v0,8
--
--	/* Get the initial value into v8 */
--	vxor	v8,v8,v8
--	MTVRD(v8, r3)
--#ifdef REFLECT
--	vsldoi	v8,zeroes,v8,8	/* shift into bottom 32 bits */
--#else
--	vsldoi	v8,v8,zeroes,4	/* shift into top 32 bits */
--#endif
--
--#ifdef BYTESWAP_DATA
--	addis	r3,r2,.byteswap_constant at toc@ha
--	addi	r3,r3,.byteswap_constant at toc@l
--
--	lvx	byteswap,0,r3
--	addi	r3,r3,16
--#endif
--
--	cmpdi	r5,256
--	blt	.Lshort
--
--	rldicr	r6,r5,0,56
--
--	/* Checksum in blocks of MAX_SIZE */
--1:	lis	r7,MAX_SIZE at h
--	ori	r7,r7,MAX_SIZE at l
--	mr	r9,r7
--	cmpd	r6,r7
--	bgt	2f
--	mr	r7,r6
--2:	subf	r6,r7,r6
--
--	/* our main loop does 128 bytes at a time */
--	srdi	r7,r7,7
--
--	/*
--	 * Work out the offset into the constants table to start at. Each
--	 * constant is 16 bytes, and it is used against 128 bytes of input
--	 * data - 128 / 16 = 8
--	 */
--	sldi	r8,r7,4
--	srdi	r9,r9,3
--	subf	r8,r8,r9
--
--	/* We reduce our final 128 bytes in a separate step */
--	addi	r7,r7,-1
--	mtctr	r7
--
--	addis	r3,r2,.constants at toc@ha
--	addi	r3,r3,.constants at toc@l
--
--	/* Find the start of our constants */
--	add	r3,r3,r8
--
--	/* zero v0-v7 which will contain our checksums */
--	vxor	v0,v0,v0
--	vxor	v1,v1,v1
--	vxor	v2,v2,v2
--	vxor	v3,v3,v3
--	vxor	v4,v4,v4
--	vxor	v5,v5,v5
--	vxor	v6,v6,v6
--	vxor	v7,v7,v7
--
--	lvx	const1,0,r3
--
--	/*
--	 * If we are looping back to consume more data we use the values
--	 * already in v16-v23.
--	 */
--	cmpdi	r0,1
--	beq	2f
--
--	/* First warm up pass */
--	lvx	v16,0,r4
--	lvx	v17,off16,r4
--	VPERM(v16,v16,v16,byteswap)
--	VPERM(v17,v17,v17,byteswap)
--	lvx	v18,off32,r4
--	lvx	v19,off48,r4
--	VPERM(v18,v18,v18,byteswap)
--	VPERM(v19,v19,v19,byteswap)
--	lvx	v20,off64,r4
--	lvx	v21,off80,r4
--	VPERM(v20,v20,v20,byteswap)
--	VPERM(v21,v21,v21,byteswap)
--	lvx	v22,off96,r4
--	lvx	v23,off112,r4
--	VPERM(v22,v22,v22,byteswap)
--	VPERM(v23,v23,v23,byteswap)
--	addi	r4,r4,8*16
--
--	/* xor in initial value */
--	vxor	v16,v16,v8
--
--2:	bdz	.Lfirst_warm_up_done
--
--	addi	r3,r3,16
--	lvx	const2,0,r3
--
--	/* Second warm up pass */
--	VPMSUMD(v8,v16,const1)
--	lvx	v16,0,r4
--	VPERM(v16,v16,v16,byteswap)
--	ori	r2,r2,0
--
--	VPMSUMD(v9,v17,const1)
--	lvx	v17,off16,r4
--	VPERM(v17,v17,v17,byteswap)
--	ori	r2,r2,0
--
--	VPMSUMD(v10,v18,const1)
--	lvx	v18,off32,r4
--	VPERM(v18,v18,v18,byteswap)
--	ori	r2,r2,0
--
--	VPMSUMD(v11,v19,const1)
--	lvx	v19,off48,r4
--	VPERM(v19,v19,v19,byteswap)
--	ori	r2,r2,0
--
--	VPMSUMD(v12,v20,const1)
--	lvx	v20,off64,r4
--	VPERM(v20,v20,v20,byteswap)
--	ori	r2,r2,0
--
--	VPMSUMD(v13,v21,const1)
--	lvx	v21,off80,r4
--	VPERM(v21,v21,v21,byteswap)
--	ori	r2,r2,0
--
--	VPMSUMD(v14,v22,const1)
--	lvx	v22,off96,r4
--	VPERM(v22,v22,v22,byteswap)
--	ori	r2,r2,0
--
--	VPMSUMD(v15,v23,const1)
--	lvx	v23,off112,r4
--	VPERM(v23,v23,v23,byteswap)
--
--	addi	r4,r4,8*16
--
--	bdz	.Lfirst_cool_down
--
--	/*
--	 * main loop. We modulo schedule it such that it takes three iterations
--	 * to complete - first iteration load, second iteration vpmsum, third
--	 * iteration xor.
--	 */
--	.balign	16
--4:	lvx	const1,0,r3
--	addi	r3,r3,16
--	ori	r2,r2,0
--
--	vxor	v0,v0,v8
--	VPMSUMD(v8,v16,const2)
--	lvx	v16,0,r4
--	VPERM(v16,v16,v16,byteswap)
--	ori	r2,r2,0
--
--	vxor	v1,v1,v9
--	VPMSUMD(v9,v17,const2)
--	lvx	v17,off16,r4
--	VPERM(v17,v17,v17,byteswap)
--	ori	r2,r2,0
--
--	vxor	v2,v2,v10
--	VPMSUMD(v10,v18,const2)
--	lvx	v18,off32,r4
--	VPERM(v18,v18,v18,byteswap)
--	ori	r2,r2,0
--
--	vxor	v3,v3,v11
--	VPMSUMD(v11,v19,const2)
--	lvx	v19,off48,r4
--	VPERM(v19,v19,v19,byteswap)
--	lvx	const2,0,r3
--	ori	r2,r2,0
--
--	vxor	v4,v4,v12
--	VPMSUMD(v12,v20,const1)
--	lvx	v20,off64,r4
--	VPERM(v20,v20,v20,byteswap)
--	ori	r2,r2,0
--
--	vxor	v5,v5,v13
--	VPMSUMD(v13,v21,const1)
--	lvx	v21,off80,r4
--	VPERM(v21,v21,v21,byteswap)
--	ori	r2,r2,0
--
--	vxor	v6,v6,v14
--	VPMSUMD(v14,v22,const1)
--	lvx	v22,off96,r4
--	VPERM(v22,v22,v22,byteswap)
--	ori	r2,r2,0
--
--	vxor	v7,v7,v15
--	VPMSUMD(v15,v23,const1)
--	lvx	v23,off112,r4
--	VPERM(v23,v23,v23,byteswap)
--
--	addi	r4,r4,8*16
--
--	bdnz	4b
--
--.Lfirst_cool_down:
--	/* First cool down pass */
--	lvx	const1,0,r3
--	addi	r3,r3,16
--
--	vxor	v0,v0,v8
--	VPMSUMD(v8,v16,const1)
--	ori	r2,r2,0
--
--	vxor	v1,v1,v9
--	VPMSUMD(v9,v17,const1)
--	ori	r2,r2,0
--
--	vxor	v2,v2,v10
--	VPMSUMD(v10,v18,const1)
--	ori	r2,r2,0
--
--	vxor	v3,v3,v11
--	VPMSUMD(v11,v19,const1)
--	ori	r2,r2,0
--
--	vxor	v4,v4,v12
--	VPMSUMD(v12,v20,const1)
--	ori	r2,r2,0
--
--	vxor	v5,v5,v13
--	VPMSUMD(v13,v21,const1)
--	ori	r2,r2,0
--
--	vxor	v6,v6,v14
--	VPMSUMD(v14,v22,const1)
--	ori	r2,r2,0
--
--	vxor	v7,v7,v15
--	VPMSUMD(v15,v23,const1)
--	ori	r2,r2,0
--
--.Lsecond_cool_down:
--	/* Second cool down pass */
--	vxor	v0,v0,v8
--	vxor	v1,v1,v9
--	vxor	v2,v2,v10
--	vxor	v3,v3,v11
--	vxor	v4,v4,v12
--	vxor	v5,v5,v13
--	vxor	v6,v6,v14
--	vxor	v7,v7,v15
--
--#ifdef REFLECT
--	/*
--	 * vpmsumd produces a 96 bit result in the least significant bits
--	 * of the register. Since we are bit reflected we have to shift it
--	 * left 32 bits so it occupies the least significant bits in the
--	 * bit reflected domain.
--	 */
--	vsldoi	v0,v0,zeroes,4
--	vsldoi	v1,v1,zeroes,4
--	vsldoi	v2,v2,zeroes,4
--	vsldoi	v3,v3,zeroes,4
--	vsldoi	v4,v4,zeroes,4
--	vsldoi	v5,v5,zeroes,4
--	vsldoi	v6,v6,zeroes,4
--	vsldoi	v7,v7,zeroes,4
--#endif
--
--	/* xor with last 1024 bits */
--	lvx	v8,0,r4
--	lvx	v9,off16,r4
--	VPERM(v8,v8,v8,byteswap)
--	VPERM(v9,v9,v9,byteswap)
--	lvx	v10,off32,r4
--	lvx	v11,off48,r4
--	VPERM(v10,v10,v10,byteswap)
--	VPERM(v11,v11,v11,byteswap)
--	lvx	v12,off64,r4
--	lvx	v13,off80,r4
--	VPERM(v12,v12,v12,byteswap)
--	VPERM(v13,v13,v13,byteswap)
--	lvx	v14,off96,r4
--	lvx	v15,off112,r4
--	VPERM(v14,v14,v14,byteswap)
--	VPERM(v15,v15,v15,byteswap)
--
--	addi	r4,r4,8*16
--
--	vxor	v16,v0,v8
--	vxor	v17,v1,v9
--	vxor	v18,v2,v10
--	vxor	v19,v3,v11
--	vxor	v20,v4,v12
--	vxor	v21,v5,v13
--	vxor	v22,v6,v14
--	vxor	v23,v7,v15
--
--	li	r0,1
--	cmpdi	r6,0
--	addi	r6,r6,128
--	bne	1b
--
--	/* Work out how many bytes we have left */
--	andi.	r5,r5,127
--
--	/* Calculate where in the constant table we need to start */
--	subfic	r6,r5,128
--	add	r3,r3,r6
--
--	/* How many 16 byte chunks are in the tail */
--	srdi	r7,r5,4
--	mtctr	r7
--
--	/*
--	 * Reduce the previously calculated 1024 bits to 64 bits, shifting
--	 * 32 bits to include the trailing 32 bits of zeros
--	 */
--	lvx	v0,0,r3
--	lvx	v1,off16,r3
--	lvx	v2,off32,r3
--	lvx	v3,off48,r3
--	lvx	v4,off64,r3
--	lvx	v5,off80,r3
--	lvx	v6,off96,r3
--	lvx	v7,off112,r3
--	addi	r3,r3,8*16
--
--	VPMSUMW(v0,v16,v0)
--	VPMSUMW(v1,v17,v1)
--	VPMSUMW(v2,v18,v2)
--	VPMSUMW(v3,v19,v3)
--	VPMSUMW(v4,v20,v4)
--	VPMSUMW(v5,v21,v5)
--	VPMSUMW(v6,v22,v6)
--	VPMSUMW(v7,v23,v7)
--
--	/* Now reduce the tail (0 - 112 bytes) */
--	cmpdi	r7,0
--	beq	1f
--
--	lvx	v16,0,r4
--	lvx	v17,0,r3
--	VPERM(v16,v16,v16,byteswap)
--	VPMSUMW(v16,v16,v17)
--	vxor	v0,v0,v16
--	bdz	1f
--
--	lvx	v16,off16,r4
--	lvx	v17,off16,r3
--	VPERM(v16,v16,v16,byteswap)
--	VPMSUMW(v16,v16,v17)
--	vxor	v0,v0,v16
--	bdz	1f
--
--	lvx	v16,off32,r4
--	lvx	v17,off32,r3
--	VPERM(v16,v16,v16,byteswap)
--	VPMSUMW(v16,v16,v17)
--	vxor	v0,v0,v16
--	bdz	1f
--
--	lvx	v16,off48,r4
--	lvx	v17,off48,r3
--	VPERM(v16,v16,v16,byteswap)
--	VPMSUMW(v16,v16,v17)
--	vxor	v0,v0,v16
--	bdz	1f
--
--	lvx	v16,off64,r4
--	lvx	v17,off64,r3
--	VPERM(v16,v16,v16,byteswap)
--	VPMSUMW(v16,v16,v17)
--	vxor	v0,v0,v16
--	bdz	1f
--
--	lvx	v16,off80,r4
--	lvx	v17,off80,r3
--	VPERM(v16,v16,v16,byteswap)
--	VPMSUMW(v16,v16,v17)
--	vxor	v0,v0,v16
--	bdz	1f
--
--	lvx	v16,off96,r4
--	lvx	v17,off96,r3
--	VPERM(v16,v16,v16,byteswap)
--	VPMSUMW(v16,v16,v17)
--	vxor	v0,v0,v16
--
--	/* Now xor all the parallel chunks together */
--1:	vxor	v0,v0,v1
--	vxor	v2,v2,v3
--	vxor	v4,v4,v5
--	vxor	v6,v6,v7
--
--	vxor	v0,v0,v2
--	vxor	v4,v4,v6
--
--	vxor	v0,v0,v4
--
--.Lbarrett_reduction:
--	/* Barrett constants */
--	addis	r3,r2,.barrett_constants at toc@ha
--	addi	r3,r3,.barrett_constants at toc@l
--
--	lvx	const1,0,r3
--	lvx	const2,off16,r3
--
--	vsldoi	v1,v0,v0,8
--	vxor	v0,v0,v1		/* xor two 64 bit results together */
--
--#ifdef REFLECT
--	/* shift left one bit */
--	vspltisb v1,1
--	vsl	v0,v0,v1
--#endif
--
--	vand	v0,v0,mask_64bit
--
--#ifndef REFLECT
--	/*
--	 * Now for the Barrett reduction algorithm. The idea is to calculate q,
--	 * the multiple of our polynomial that we need to subtract. By
--	 * doing the computation 2x bits higher (ie 64 bits) and shifting the
--	 * result back down 2x bits, we round down to the nearest multiple.
--	 */
--	VPMSUMD(v1,v0,const1)	/* ma */
--	vsldoi	v1,zeroes,v1,8	/* q = floor(ma/(2^64)) */
--	VPMSUMD(v1,v1,const2)	/* qn */
--	vxor	v0,v0,v1	/* a - qn, subtraction is xor in GF(2) */
--
--	/*
--	 * Get the result into r3. We need to shift it left 8 bytes:
--	 * V0 [ 0 1 2 X ]
--	 * V0 [ 0 X 2 3 ]
--	 */
--	vsldoi	v0,v0,zeroes,8	/* shift result into top 64 bits */
--#else
--	/*
--	 * The reflected version of Barrett reduction. Instead of bit
--	 * reflecting our data (which is expensive to do), we bit reflect our
--	 * constants and our algorithm, which means the intermediate data in
--	 * our vector registers goes from 0-63 instead of 63-0. We can reflect
--	 * the algorithm because we don't carry in mod 2 arithmetic.
--	 */
--	vand	v1,v0,mask_32bit	/* bottom 32 bits of a */
--	VPMSUMD(v1,v1,const1)		/* ma */
--	vand	v1,v1,mask_32bit	/* bottom 32bits of ma */
--	VPMSUMD(v1,v1,const2)		/* qn */
--	vxor	v0,v0,v1		/* a - qn, subtraction is xor in GF(2) */
--
--	/*
--	 * Since we are bit reflected, the result (ie the low 32 bits) is in
--	 * the high 32 bits. We just need to shift it left 4 bytes
--	 * V0 [ 0 1 X 3 ]
--	 * V0 [ 0 X 2 3 ]
--	 */
--	vsldoi	v0,v0,zeroes,4		/* shift result into top 64 bits of */
--#endif
--
--	/* Get it into r3 */
--	MFVRD(r3, v0)
--
--.Lout:
--	subi	r6,r1,56+10*16
--	subi	r7,r1,56+2*16
--
--	lvx	v20,0,r6
--	lvx	v21,off16,r6
--	lvx	v22,off32,r6
--	lvx	v23,off48,r6
--	lvx	v24,off64,r6
--	lvx	v25,off80,r6
--	lvx	v26,off96,r6
--	lvx	v27,off112,r6
--	lvx	v28,0,r7
--	lvx	v29,off16,r7
--
--	ld	r31,-8(r1)
--	ld	r30,-16(r1)
--	ld	r29,-24(r1)
--	ld	r28,-32(r1)
--	ld	r27,-40(r1)
--	ld	r26,-48(r1)
--	ld	r25,-56(r1)
--
--	blr
--
--.Lfirst_warm_up_done:
--	lvx	const1,0,r3
--	addi	r3,r3,16
--
--	VPMSUMD(v8,v16,const1)
--	VPMSUMD(v9,v17,const1)
--	VPMSUMD(v10,v18,const1)
--	VPMSUMD(v11,v19,const1)
--	VPMSUMD(v12,v20,const1)
--	VPMSUMD(v13,v21,const1)
--	VPMSUMD(v14,v22,const1)
--	VPMSUMD(v15,v23,const1)
--
--	b	.Lsecond_cool_down
--
--.Lshort:
--	cmpdi	r5,0
--	beq	.Lzero
--
--	addis	r3,r2,.short_constants at toc@ha
--	addi	r3,r3,.short_constants at toc@l
--
--	/* Calculate where in the constant table we need to start */
--	subfic	r6,r5,256
--	add	r3,r3,r6
--
--	/* How many 16 byte chunks? */
--	srdi	r7,r5,4
--	mtctr	r7
--
--	vxor	v19,v19,v19
--	vxor	v20,v20,v20
--
--	lvx	v0,0,r4
--	lvx	v16,0,r3
--	VPERM(v0,v0,v16,byteswap)
--	vxor	v0,v0,v8	/* xor in initial value */
--	VPMSUMW(v0,v0,v16)
--	bdz	.Lv0
--
--	lvx	v1,off16,r4
--	lvx	v17,off16,r3
--	VPERM(v1,v1,v17,byteswap)
--	VPMSUMW(v1,v1,v17)
--	bdz	.Lv1
--
--	lvx	v2,off32,r4
--	lvx	v16,off32,r3
--	VPERM(v2,v2,v16,byteswap)
--	VPMSUMW(v2,v2,v16)
--	bdz	.Lv2
--
--	lvx	v3,off48,r4
--	lvx	v17,off48,r3
--	VPERM(v3,v3,v17,byteswap)
--	VPMSUMW(v3,v3,v17)
--	bdz	.Lv3
--
--	lvx	v4,off64,r4
--	lvx	v16,off64,r3
--	VPERM(v4,v4,v16,byteswap)
--	VPMSUMW(v4,v4,v16)
--	bdz	.Lv4
--
--	lvx	v5,off80,r4
--	lvx	v17,off80,r3
--	VPERM(v5,v5,v17,byteswap)
--	VPMSUMW(v5,v5,v17)
--	bdz	.Lv5
--
--	lvx	v6,off96,r4
--	lvx	v16,off96,r3
--	VPERM(v6,v6,v16,byteswap)
--	VPMSUMW(v6,v6,v16)
--	bdz	.Lv6
--
--	lvx	v7,off112,r4
--	lvx	v17,off112,r3
--	VPERM(v7,v7,v17,byteswap)
--	VPMSUMW(v7,v7,v17)
--	bdz	.Lv7
--
--	addi	r3,r3,128
--	addi	r4,r4,128
--
--	lvx	v8,0,r4
--	lvx	v16,0,r3
--	VPERM(v8,v8,v16,byteswap)
--	VPMSUMW(v8,v8,v16)
--	bdz	.Lv8
--
--	lvx	v9,off16,r4
--	lvx	v17,off16,r3
--	VPERM(v9,v9,v17,byteswap)
--	VPMSUMW(v9,v9,v17)
--	bdz	.Lv9
--
--	lvx	v10,off32,r4
--	lvx	v16,off32,r3
--	VPERM(v10,v10,v16,byteswap)
--	VPMSUMW(v10,v10,v16)
--	bdz	.Lv10
--
--	lvx	v11,off48,r4
--	lvx	v17,off48,r3
--	VPERM(v11,v11,v17,byteswap)
--	VPMSUMW(v11,v11,v17)
--	bdz	.Lv11
--
--	lvx	v12,off64,r4
--	lvx	v16,off64,r3
--	VPERM(v12,v12,v16,byteswap)
--	VPMSUMW(v12,v12,v16)
--	bdz	.Lv12
--
--	lvx	v13,off80,r4
--	lvx	v17,off80,r3
--	VPERM(v13,v13,v17,byteswap)
--	VPMSUMW(v13,v13,v17)
--	bdz	.Lv13
--
--	lvx	v14,off96,r4
--	lvx	v16,off96,r3
--	VPERM(v14,v14,v16,byteswap)
--	VPMSUMW(v14,v14,v16)
--	bdz	.Lv14
--
--	lvx	v15,off112,r4
--	lvx	v17,off112,r3
--	VPERM(v15,v15,v17,byteswap)
--	VPMSUMW(v15,v15,v17)
--
--.Lv15:	vxor	v19,v19,v15
--.Lv14:	vxor	v20,v20,v14
--.Lv13:	vxor	v19,v19,v13
--.Lv12:	vxor	v20,v20,v12
--.Lv11:	vxor	v19,v19,v11
--.Lv10:	vxor	v20,v20,v10
--.Lv9:	vxor	v19,v19,v9
--.Lv8:	vxor	v20,v20,v8
--.Lv7:	vxor	v19,v19,v7
--.Lv6:	vxor	v20,v20,v6
--.Lv5:	vxor	v19,v19,v5
--.Lv4:	vxor	v20,v20,v4
--.Lv3:	vxor	v19,v19,v3
--.Lv2:	vxor	v20,v20,v2
--.Lv1:	vxor	v19,v19,v1
--.Lv0:	vxor	v20,v20,v0
--
--	vxor	v0,v19,v20
--
--	b	.Lbarrett_reduction
--
--.Lzero:
--	mr	r3,r10
--	b	.Lout
--
--FUNC_END(__crc32_vpmsum)
-diff --git a/util/crc32c_ppc_clang_workaround.h b/util/crc32c_ppc_clang_workaround.h
-new file mode 100644
-index 0000000000..fc4391a603
---- /dev/null
-+++ b/util/crc32c_ppc_clang_workaround.h
-@@ -0,0 +1,93 @@
-+//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-+//  Copyright (C) 2015, 2017 International Business Machines Corp.
-+//  All rights reserved.
-+//  This source code is licensed under both the GPLv2 (found in the
-+//  COPYING file in the root directory) and Apache 2.0 License
-+//  (found in the LICENSE.Apache file in the root directory).
-+#ifndef CLANG_WORKAROUND_H
-+#define CLANG_WORKAROUND_H
-+
-+/*
-+ * These stubs fix clang incompatibilities with GCC builtins.
-+ */
-+
-+#ifndef __builtin_crypto_vpmsumw
-+#define __builtin_crypto_vpmsumw __builtin_crypto_vpmsumb
-+#endif
-+#ifndef __builtin_crypto_vpmsumd
-+#define __builtin_crypto_vpmsumd __builtin_crypto_vpmsumb
-+#endif
-+
-+static inline
-+__vector unsigned long long __attribute__((overloadable))
-+vec_ld(int __a, const __vector unsigned long long* __b)
-+{
-+	return (__vector unsigned long long)__builtin_altivec_lvx(__a, __b);
-+}
-+
-+/*
-+ * GCC __builtin_pack_vector_int128 returns a vector __int128_t but Clang
-+ * does not recognize this type. On GCC this builtin is translated to a
-+ * xxpermdi instruction that only moves the registers __a, __b instead generates
-+ * a load.
-+ *
-+ * Clang has vec_xxpermdi intrinsics. It was implemented in 4.0.0.
-+ */
-+static inline
-+__vector unsigned long long  __builtin_pack_vector (unsigned long __a,
-+						    unsigned long __b)
-+{
-+	#if defined(__BIG_ENDIAN__)
-+	__vector unsigned long long __v = {__a, __b};
-+	#else
-+	__vector unsigned long long __v = {__b, __a};
-+	#endif
-+	return __v;
-+}
-+
-+/*
-+ * Clang 7 changed the behavior of vec_xxpermdi in order to provide the same
-+ * behavior of GCC. That means code adapted to Clang >= 7 does not work on
-+ * Clang <= 6.  So, fallback to __builtin_unpack_vector() on Clang <= 6.
-+ */
-+#if !defined vec_xxpermdi || __clang_major__ <= 6
-+
-+static inline
-+unsigned long __builtin_unpack_vector (__vector unsigned long long __v,
-+				       int __o)
-+{
-+	return __v[__o];
-+}
-+
-+#if defined(__BIG_ENDIAN__)
-+#define __builtin_unpack_vector_0(a) __builtin_unpack_vector ((a), 0)
-+#define __builtin_unpack_vector_1(a) __builtin_unpack_vector ((a), 1)
-+#else
-+#define __builtin_unpack_vector_0(a) __builtin_unpack_vector ((a), 1)
-+#define __builtin_unpack_vector_1(a) __builtin_unpack_vector ((a), 0)
-+#endif
-+
-+#else
-+
-+static inline
-+unsigned long __builtin_unpack_vector_0 (__vector unsigned long long __v)
-+{
-+	#if defined(__BIG_ENDIAN__)
-+	return vec_xxpermdi(__v, __v, 0x0)[0];
-+	#else
-+	return vec_xxpermdi(__v, __v, 0x3)[0];
-+	#endif
-+}
-+
-+static inline
-+unsigned long __builtin_unpack_vector_1 (__vector unsigned long long __v)
-+{
-+	#if defined(__BIG_ENDIAN__)
-+	return vec_xxpermdi(__v, __v, 0x3)[0];
-+	#else
-+	return vec_xxpermdi(__v, __v, 0x0)[0];
-+	#endif
-+}
-+#endif /* vec_xxpermdi */
-+
-+#endif
-diff --git a/util/crc32c_ppc_constants.h b/util/crc32c_ppc_constants.h
-index f6494cd01c..b558d46777 100644
---- a/util/crc32c_ppc_constants.h
-+++ b/util/crc32c_ppc_constants.h
-@@ -5,896 +5,1206 @@
- //  COPYING file in the root directory) and Apache 2.0 License
- //  (found in the LICENSE.Apache file in the root directory).
- 
--#pragma once
-+/*
-+*
-+* THIS FILE IS GENERATED WITH
-+./crc32_constants -r -x 0x1edc6f41 
-+
-+* This is from https://github.com/antonblanchard/crc32-vpmsum/
-+* DO NOT MODIFY IT MANUALLY!
-+*
-+*/
- 
- #define CRC 0x1edc6f41
--#define REFLECT
- #define CRC_XOR
-+#define REFLECT
-+#define MAX_SIZE    32768
- 
--#ifndef __ASSEMBLY__
- #ifdef CRC_TABLE
- static const unsigned int crc_table[] = {
--    0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c,
--    0x26a1e7e8, 0xd4ca64eb, 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b,
--    0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24, 0x105ec76f, 0xe235446c,
--    0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
--    0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54, 0x5d1d08bf, 0xaf768bbc,
--    0xbc267848, 0x4e4dfb4b, 0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a,
--    0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35, 0xaa64d611, 0x580f5512,
--    0x4b5fa6e6, 0xb93425e5, 0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
--    0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad,
--    0x1642ae59, 0xe4292d5a, 0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a,
--    0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595, 0x417b1dbc, 0xb3109ebf,
--    0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
--    0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c, 0xfe53516f,
--    0xed03a29b, 0x1f682198, 0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927,
--    0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38, 0xdbfc821c, 0x2997011f,
--    0x3ac7f2eb, 0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
--    0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096, 0xa65c047d, 0x5437877e,
--    0x4767748a, 0xb50cf789, 0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859,
--    0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46, 0x7198540d, 0x83f3d70e,
--    0x90a324fa, 0x62c8a7f9, 0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
--    0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de,
--    0xdde0eb2a, 0x2f8b6829, 0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c,
--    0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93, 0x082f63b7, 0xfa44e0b4,
--    0xe9141340, 0x1b7f9043, 0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
--    0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x55326b08, 0xa759e80b,
--    0xb4091bff, 0x466298fc, 0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c,
--    0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033, 0xa24bb5a6, 0x502036a5,
--    0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
--    0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 0xef087a76, 0x1d63f975,
--    0x0e330a81, 0xfc588982, 0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d,
--    0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622, 0x38cc2a06, 0xcaa7a905,
--    0xd9f75af1, 0x2b9cd9f2, 0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed,
--    0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530, 0x0417b1db, 0xf67c32d8,
--    0xe52cc12c, 0x1747422f, 0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff,
--    0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0, 0xd3d3e1ab, 0x21b862a8,
--    0x32e8915c, 0xc083125f, 0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
--    0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90, 0x9e902e7b, 0x6cfbad78,
--    0x7fab5e8c, 0x8dc0dd8f, 0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee,
--    0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1, 0x69e9f0d5, 0x9b8273d6,
--    0x88d28022, 0x7ab90321, 0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e,
--    0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81, 0x34f4f86a, 0xc69f7b69,
--    0xd5cf889d, 0x27a40b9e, 0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e,
--    0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351,
--};
--
--#endif
--
--#else
--#define MAX_SIZE 32768
--.constants :
--
--        /* Reduce 262144 kbits to 1024 bits */
--        /* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
--        .octa 0x00000000b6ca9e20000000009c37c408
--
--        /* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
--        .octa 0x00000000350249a800000001b51df26c
--
--        /* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
--        .octa 0x00000001862dac54000000000724b9d0
--
--        /* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
--        .octa 0x00000001d87fb48c00000001c00532fe
--
--        /* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
--        .octa 0x00000001f39b699e00000000f05a9362
--
--        /* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
--        .octa 0x0000000101da11b400000001e1007970
--
--        /* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
--        .octa 0x00000001cab571e000000000a57366ee
--
--        /* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
--        .octa 0x00000000c7020cfe0000000192011284
--
--        /* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
--        .octa 0x00000000cdaed1ae0000000162716d9a
--
--        /* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
--        .octa 0x00000001e804effc00000000cd97ecde
--
--        /* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
--        .octa 0x0000000077c3ea3a0000000058812bc0
--
--        /* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
--        .octa 0x0000000068df31b40000000088b8c12e
--
--        /* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
--        .octa 0x00000000b059b6c200000001230b234c
--
--        /* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
--        .octa 0x0000000145fb8ed800000001120b416e
--
--        /* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
--        .octa 0x00000000cbc0916800000001974aecb0
--
--        /* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
--        .octa 0x000000005ceeedc2000000008ee3f226
--
--        /* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
--        .octa 0x0000000047d74e8600000001089aba9a
--
--        /* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
--        .octa 0x00000001407e9e220000000065113872
--
--        /* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
--        .octa 0x00000001da967bda000000005c07ec10
--
--        /* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
--        .octa 0x000000006c8983680000000187590924
--
--        /* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
--        .octa 0x00000000f2d14c9800000000e35da7c6
--
--        /* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
--        .octa 0x00000001993c6ad4000000000415855a
--
--        /* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
--        .octa 0x000000014683d1ac0000000073617758
--
--        /* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
--        .octa 0x00000001a7c93e6c0000000176021d28
--
--        /* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
--        .octa 0x000000010211e90a00000001c358fd0a
--
--        /* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
--        .octa 0x000000001119403e00000001ff7a2c18
--
--        /* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
--        .octa 0x000000001c3261aa00000000f2d9f7e4
--
--        /* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
--        .octa 0x000000014e37a634000000016cf1f9c8
--
--        /* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
--        .octa 0x0000000073786c0c000000010af9279a
--
--        /* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
--        .octa 0x000000011dc037f80000000004f101e8
--
--        /* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
--        .octa 0x0000000031433dfc0000000070bcf184
--
--        /* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
--        .octa 0x000000009cde8348000000000a8de642
--
--        /* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
--        .octa 0x0000000038d3c2a60000000062ea130c
--
--        /* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
--        .octa 0x000000011b25f26000000001eb31cbb2
--
--        /* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
--        .octa 0x000000001629e6f00000000170783448
--
--        /* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
--        .octa 0x0000000160838b4c00000001a684b4c6
--
--        /* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
--        .octa 0x000000007a44011c00000000253ca5b4
--
--        /* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
--        .octa 0x00000000226f417a0000000057b4b1e2
--
--        /* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
--        .octa 0x0000000045eb2eb400000000b6bd084c
--
--        /* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
--        .octa 0x000000014459d70c0000000123c2d592
--
--        /* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
--        .octa 0x00000001d406ed8200000000159dafce
--
--        /* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
--        .octa 0x0000000160c8e1a80000000127e1a64e
--
--        /* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
--        .octa 0x0000000027ba80980000000056860754
--
--        /* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
--        .octa 0x000000006d92d01800000001e661aae8
--
--        /* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
--        .octa 0x000000012ed7e3f200000000f82c6166
--
--        /* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
--        .octa 0x000000002dc8778800000000c4f9c7ae
--
--        /* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
--        .octa 0x0000000018240bb80000000074203d20
--
--        /* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
--        .octa 0x000000001ad381580000000198173052
--
--        /* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
--        .octa 0x00000001396b78f200000001ce8aba54
--
--        /* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
--        .octa 0x000000011a68133400000001850d5d94
--
--        /* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
--        .octa 0x000000012104732e00000001d609239c
--
--        /* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
--        .octa 0x00000000a140d90c000000001595f048
--
--        /* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
--        .octa 0x00000001b7215eda0000000042ccee08
--
--        /* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
--        .octa 0x00000001aaf1df3c000000010a389d74
--
--        /* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
--        .octa 0x0000000029d15b8a000000012a840da6
--
--        /* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
--        .octa 0x00000000f1a96922000000001d181c0c
--
--        /* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
--        .octa 0x00000001ac80d03c0000000068b7d1f6
--
--        /* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
--        .octa 0x000000000f11d56a000000005b0f14fc
--
--        /* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
--        .octa 0x00000001f1c022a20000000179e9e730
--
--        /* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
--        .octa 0x0000000173d00ae200000001ce1368d6
--
--        /* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
--        .octa 0x00000001d4ffe4ac0000000112c3a84c
--
--        /* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
--        .octa 0x000000016edc5ae400000000de940fee
--
--        /* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
--        .octa 0x00000001f1a0214000000000fe896b7e
--
--        /* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
--        .octa 0x00000000ca0b28a000000001f797431c
--
--        /* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
--        .octa 0x00000001928e30a20000000053e989ba
--
--        /* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
--        .octa 0x0000000097b1b002000000003920cd16
--
--        /* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
--        .octa 0x00000000b15bf90600000001e6f579b8
--
--        /* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
--        .octa 0x00000000411c5d52000000007493cb0a
--
--        /* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
--        .octa 0x00000001c36f330000000001bdd376d8
--
--        /* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
--        .octa 0x00000001119227e0000000016badfee6
--
--        /* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
--        .octa 0x00000000114d47020000000071de5c58
--
--        /* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
--        .octa 0x00000000458b5b9800000000453f317c
--
--        /* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
--        .octa 0x000000012e31fb8e0000000121675cce
--
--        /* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
--        .octa 0x000000005cf619d800000001f409ee92
--
--        /* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
--        .octa 0x0000000063f4d8b200000000f36b9c88
--
--        /* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
--        .octa 0x000000004138dc8a0000000036b398f4
--
--        /* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
--        .octa 0x00000001d29ee8e000000001748f9adc
--
--        /* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
--        .octa 0x000000006a08ace800000001be94ec00
--
--        /* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
--        .octa 0x0000000127d4201000000000b74370d6
--
--        /* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
--        .octa 0x0000000019d76b6200000001174d0b98
--
--        /* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
--        .octa 0x00000001b1471f6e00000000befc06a4
--
--        /* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
--        .octa 0x00000001f64c19cc00000001ae125288
--
--        /* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
--        .octa 0x00000000003c0ea00000000095c19b34
--
--        /* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
--        .octa 0x000000014d73abf600000001a78496f2
--
--        /* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
--        .octa 0x00000001620eb84400000001ac5390a0
--
--        /* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
--        .octa 0x0000000147655048000000002a80ed6e
--
--        /* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
--        .octa 0x0000000067b5077e00000001fa9b0128
--
--        /* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
--        .octa 0x0000000010ffe20600000001ea94929e
--
--        /* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
--        .octa 0x000000000fee8f1e0000000125f4305c
--
--        /* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
--        .octa 0x00000001da26fbae00000001471e2002
--
--        /* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
--        .octa 0x00000001b3a8bd880000000132d2253a
--
--        /* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
--        .octa 0x00000000e8f3898e00000000f26b3592
--
--        /* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
--        .octa 0x00000000b0d0d28c00000000bc8b67b0
--
--        /* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
--        .octa 0x0000000030f2a798000000013a826ef2
--
--        /* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
--        .octa 0x000000000fba10020000000081482c84
--
--        /* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
--        .octa 0x00000000bdb9bd7200000000e77307c2
--
--        /* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
--        .octa 0x0000000075d3bf5a00000000d4a07ec8
--
--        /* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
--        .octa 0x00000000ef1f98a00000000017102100
--
--        /* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
--        .octa 0x00000000689c760200000000db406486
--
--        /* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
--        .octa 0x000000016d5fa5fe0000000192db7f88
--
--        /* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
--        .octa 0x00000001d0d2b9ca000000018bf67b1e
--
--        /* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
--        .octa 0x0000000041e7b470000000007c09163e
--
--        /* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
--        .octa 0x00000001cbb6495e000000000adac060
--
--        /* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
--        .octa 0x000000010052a0b000000000bd8316ae
--
--        /* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
--        .octa 0x00000001d8effb5c000000019f09ab54
--
--        /* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
--        .octa 0x00000001d969853c0000000125155542
--
--        /* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
--        .octa 0x00000000523ccce2000000018fdb5882
--
--        /* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
--        .octa 0x000000001e2436bc00000000e794b3f4
--
--        /* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
--        .octa 0x00000000ddd1c3a2000000016f9bb022
--
--        /* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
--        .octa 0x0000000019fcfe3800000000290c9978
--
--        /* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
--        .octa 0x00000001ce95db640000000083c0f350
--
--        /* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
--        .octa 0x00000000af5828060000000173ea6628
--
--        /* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
--        .octa 0x00000001006388f600000001c8b4e00a
--
--        /* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
--        .octa 0x0000000179eca00a00000000de95d6aa
--
--        /* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
--        .octa 0x0000000122410a6a000000010b7f7248
--
--        /* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
--        .octa 0x000000004288e87c00000001326e3a06
--
--        /* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
--        .octa 0x000000016c5490da00000000bb62c2e6
--
--        /* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
--        .octa 0x00000000d1c71f6e0000000156a4b2c2
--
--        /* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
--        .octa 0x00000001b4ce08a6000000011dfe763a
--
--        /* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
--        .octa 0x00000001466ba60c000000007bcca8e2
--
--        /* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
--        .octa 0x00000001f6c488a40000000186118faa
--
--        /* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
--        .octa 0x000000013bfb06820000000111a65a88
--
--        /* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
--        .octa 0x00000000690e9e54000000003565e1c4
--
--        /* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
--        .octa 0x00000000281346b6000000012ed02a82
--
--        /* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
--        .octa 0x000000015646402400000000c486ecfc
--
--        /* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
--        .octa 0x000000016063a8dc0000000001b951b2
--
--        /* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
--        .octa 0x0000000116a663620000000048143916
--
--        /* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
--        .octa 0x000000017e8aa4d200000001dc2ae124
--
--        /* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
--        .octa 0x00000001728eb10c00000001416c58d6
--
--        /* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
--        .octa 0x00000001b08fd7fa00000000a479744a
--
--        /* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
--        .octa 0x00000001092a16e80000000096ca3a26
--
--        /* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
--        .octa 0x00000000a505637c00000000ff223d4e
--
--        /* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
--        .octa 0x00000000d94869b2000000010e84da42
--
--        /* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
--        .octa 0x00000001c8b203ae00000001b61ba3d0
--
--        /* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
--        .octa 0x000000005704aea000000000680f2de8
--
--        /* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
--        .octa 0x000000012e295fa2000000008772a9a8
--
--        /* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
--        .octa 0x000000011d0908bc0000000155f295bc
--
--        /* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
--        .octa 0x0000000193ed97ea00000000595f9282
--
--        /* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
--        .octa 0x000000013a0f1c520000000164b1c25a
--
--        /* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
--        .octa 0x000000010c2c40c000000000fbd67c50
--
--        /* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
--        .octa 0x00000000ff6fac3e0000000096076268
--
--        /* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
--        .octa 0x000000017b3609c000000001d288e4cc
--
--        /* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
--        .octa 0x0000000088c8c92200000001eaac1bdc
--
--        /* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
--        .octa 0x00000001751baae600000001f1ea39e2
--
--        /* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
--        .octa 0x000000010795297200000001eb6506fc
--
--        /* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
--        .octa 0x0000000162b00abe000000010f806ffe
--
--        /* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
--        .octa 0x000000000d7b404c000000010408481e
--
--        /* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
--        .octa 0x00000000763b13d40000000188260534
--
--        /* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
--        .octa 0x00000000f6dc22d80000000058fc73e0
--
--        /* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
--        .octa 0x000000007daae06000000000391c59b8
--
--        /* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
--        .octa 0x000000013359ab7c000000018b638400
--
--        /* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
--        .octa 0x000000008add438a000000011738f5c4
--
--        /* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
--        .octa 0x00000001edbefdea000000008cf7c6da
--
--        /* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
--        .octa 0x000000004104e0f800000001ef97fb16
--
--        /* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
--        .octa 0x00000000b48a82220000000102130e20
--
--        /* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
--        .octa 0x00000001bcb4684400000000db968898
--
--        /* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
--        .octa 0x000000013293ce0a00000000b5047b5e
--
--        /* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
--        .octa 0x00000001710d0844000000010b90fdb2
--
--        /* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
--        .octa 0x0000000117907f6e000000004834a32e
--
--        /* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
--        .octa 0x0000000087ddf93e0000000059c8f2b0
--
--        /* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
--        .octa 0x000000005970e9b00000000122cec508
--
--        /* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
--        .octa 0x0000000185b2b7d0000000000a330cda
--
--        /* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
--        .octa 0x00000001dcee0efc000000014a47148c
--
--        /* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
--        .octa 0x0000000030da27220000000042c61cb8
--
--        /* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
--        .octa 0x000000012f925a180000000012fe6960
--
--        /* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
--        .octa 0x00000000dd2e357c00000000dbda2c20
--
--        /* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
--        .octa 0x00000000071c80de000000011122410c
--
--        /* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
--        .octa 0x000000011513140a00000000977b2070
--
--        /* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
--        .octa 0x00000001df876e8e000000014050438e
--
--        /* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
--        .octa 0x000000015f81d6ce0000000147c840e8
--
--        /* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
--        .octa 0x000000019dd94dbe00000001cc7c88ce
--
--        /* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
--        .octa 0x00000001373d206e00000001476b35a4
--
--        /* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
--        .octa 0x00000000668ccade000000013d52d508
--
--        /* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
--        .octa 0x00000001b192d268000000008e4be32e
--
--        /* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
--        .octa 0x00000000e30f3a7800000000024120fe
--
--        /* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
--        .octa 0x000000010ef1f7bc00000000ddecddb4
--
--        /* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
--        .octa 0x00000001f5ac738000000000d4d403bc
--
--        /* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
--        .octa 0x000000011822ea7000000001734b89aa
--
--        /* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
--        .octa 0x00000000c3a33848000000010e7a58d6
--
--        /* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
--        .octa 0x00000001bd151c2400000001f9f04e9c
--
--        /* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
--        .octa 0x0000000056002d7600000000b692225e
--
--        /* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
--        .octa 0x000000014657c4f4000000019b8d3f3e
--
--        /* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
--        .octa 0x0000000113742d7c00000001a874f11e
--
--        /* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
--        .octa 0x000000019c5920ba000000010d5a4254
--
--        /* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
--        .octa 0x000000005216d2d600000000bbb2f5d6
--
--        /* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
--        .octa 0x0000000136f5ad8a0000000179cc0e36
--
--        /* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
--        .octa 0x000000018b07beb600000001dca1da4a
--
--        /* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
--        .octa 0x00000000db1e93b000000000feb1a192
--
--        /* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
--        .octa 0x000000000b96fa3a00000000d1eeedd6
--
--        /* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
--        .octa 0x00000001d9968af0000000008fad9bb4
--
--        /* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
--        .octa 0x000000000e4a77a200000001884938e4
--
--        /* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
--        .octa 0x00000000508c2ac800000001bc2e9bc0
--
--        /* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
--        .octa 0x0000000021572a8000000001f9658a68
--
--        /* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
--        .octa 0x00000001b859daf2000000001b9224fc
--
--        /* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
--        .octa 0x000000016f7884740000000055b2fb84
--
--        /* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
--        .octa 0x00000001b438810e000000018b090348
--
--        /* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
--        .octa 0x0000000095ddc6f2000000011ccbd5ea
--
--        /* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
--        .octa 0x00000001d977c20c0000000007ae47f8
--
--        /* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
--        .octa 0x00000000ebedb99a0000000172acbec0
--
--        /* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
--        .octa 0x00000001df9e9e9200000001c6e3ff20
--
--        /* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
--        .octa 0x00000001a4a3f95200000000e1b38744
--
--        /* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
--        .octa 0x00000000e2f5122000000000791585b2
--
--        /* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
--        .octa 0x000000004aa01f3e00000000ac53b894
--
--        /* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
--        .octa 0x00000000b3e90a5800000001ed5f2cf4
--
--        /* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
--        .octa 0x000000000c9ca2aa00000001df48b2e0
--
--        /* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
--        .octa 0x000000015168231600000000049c1c62
--
--        /* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
--        .octa 0x0000000036fce78c000000017c460c12
--
--        /* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
--        .octa 0x000000009037dc10000000015be4da7e
--
--        /* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
--        .octa 0x00000000d3298582000000010f38f668
--
--        /* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
--        .octa 0x00000001b42e8ad60000000039f40a00
--
--        /* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
--        .octa 0x00000000142a983800000000bd4c10c4
--
--        /* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
--        .octa 0x0000000109c7f1900000000042db1d98
--
--        /* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
--        .octa 0x0000000056ff931000000001c905bae6
--
--        /* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
--        .octa 0x00000001594513aa00000000069d40ea
--
--        /* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
--        .octa 0x00000001e3b5b1e8000000008e4fbad0
--
--        /* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
--        .octa 0x000000011dd5fc080000000047bedd46
--
--        /* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
--        .octa 0x00000001675f0cc20000000026396bf8
--
--        /* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
--        .octa 0x00000000d1c8dd4400000000379beb92
--
--        /* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
--        .octa 0x0000000115ebd3d8000000000abae54a
--
--        /* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
--        .octa 0x00000001ecbd0dac0000000007e6a128
--
--        /* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
--        .octa 0x00000000cdf67af2000000000ade29d2
--
--        /* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
--        .octa 0x000000004c01ff4c00000000f974c45c
--
--        /* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
--        .octa 0x00000000f2d8657e00000000e77ac60a
--
--        /* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
--        .octa 0x000000006bae74c40000000145895816
--
--        /* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
--        .octa 0x0000000152af8aa00000000038e362be
--
--        /* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
--        .octa 0x0000000004663802000000007f991a64
--
--        /* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
--        .octa 0x00000001ab2f5afc00000000fa366d3a
--
--        /* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
--        .octa 0x0000000074a4ebd400000001a2bb34f0
--
--        /* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
--        .octa 0x00000001d7ab3a4c0000000028a9981e
--
--        /* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
--        .octa 0x00000001a8da60c600000001dbc672be
--
--        /* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
--        .octa 0x000000013cf6382000000000b04d77f6
--
--        /* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
--        .octa 0x00000000bec12e1e0000000124400d96
--
--        /* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
--        .octa 0x00000001c6368010000000014ca4b414
--
--        /* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
--        .octa 0x00000001e6e78758000000012fe2c938
--
--        /* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
--        .octa 0x000000008d7f2b3c00000001faed01e6
--
--        /* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
--        .octa 0x000000016b4a156e000000007e80ecfe
--
--        /* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
--        .octa 0x00000001c63cfeb60000000098daee94
--
--        /* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
--        .octa 0x000000015f902670000000010a04edea
--
--        /* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
--        .octa 0x00000001cd5de11e00000001c00b4524
--
--        /* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
--        .octa 0x000000001acaec540000000170296550
--
--        /* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
--        .octa 0x000000002bd0ca780000000181afaa48
--
--        /* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
--        .octa 0x0000000032d63d5c0000000185a31ffa
--
--        /* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
--        .octa 0x000000001c6d4e4c000000002469f608
--
--        /* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
--        .octa 0x0000000106a60b92000000006980102a
--
--        /* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
--        .octa 0x00000000d3855e120000000111ea9ca8
--
--        /* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
--        .octa 0x00000000e312563600000001bd1d29ce
--
--        /* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
--        .octa 0x000000009e8f7ea400000001b34b9580
--
--        /* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
--        .octa 0x00000001c82e562c000000003076054e
--
--        /* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
--        .octa 0x00000000ca9f09ce000000012a608ea4
--
--        /* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
--        .octa 0x00000000c63764e600000000784d05fe
--
--        /* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
--        .octa 0x0000000168d2e49e000000016ef0d82a
--
--        /* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
--        .octa 0x00000000e986c1480000000075bda454
--
--        /* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
--        .octa 0x00000000cfb65894000000003dc0a1c4
--
--        /* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
--        .octa 0x0000000111cadee400000000e9a5d8be
--
--        /* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
--        .octa 0x0000000171fb63ce00000001609bc4b4
--
--        .short_constants :
--
--        /* Reduce final 1024-2048 bits to 64 bits, shifting 32 bits to include
--           the trailing 32 bits of zeros */
--        /* x^1952 mod p(x)`, x^1984 mod p(x)`, x^2016 mod p(x)`, x^2048 mod
--           p(x)` */
--        .octa 0x7fec2963e5bf80485cf015c388e56f72
--
--        /* x^1824 mod p(x)`, x^1856 mod p(x)`, x^1888 mod p(x)`, x^1920 mod
--           p(x)` */
--        .octa 0x38e888d4844752a9963a18920246e2e6
--
--        /* x^1696 mod p(x)`, x^1728 mod p(x)`, x^1760 mod p(x)`, x^1792 mod
--           p(x)` */
--        .octa 0x42316c00730206ad419a441956993a31
--
--        /* x^1568 mod p(x)`, x^1600 mod p(x)`, x^1632 mod p(x)`, x^1664 mod
--           p(x)` */
--        .octa 0x543d5c543e65ddf9924752ba2b830011
--
--        /* x^1440 mod p(x)`, x^1472 mod p(x)`, x^1504 mod p(x)`, x^1536 mod
--           p(x)` */
--        .octa 0x78e87aaf56767c9255bd7f9518e4a304
--
--        /* x^1312 mod p(x)`, x^1344 mod p(x)`, x^1376 mod p(x)`, x^1408 mod
--           p(x)` */
--        .octa 0x8f68fcec1903da7f6d76739fe0553f1e
--
--        /* x^1184 mod p(x)`, x^1216 mod p(x)`, x^1248 mod p(x)`, x^1280 mod
--           p(x)` */
--        .octa 0x3f4840246791d588c133722b1fe0b5c3
--
--        /* x^1056 mod p(x)`, x^1088 mod p(x)`, x^1120 mod p(x)`, x^1152 mod
--           p(x)` */
--        .octa 0x34c96751b04de25a64b67ee0e55ef1f3
--
--        /* x^928 mod p(x)`, x^960 mod p(x)`, x^992 mod p(x)`, x^1024 mod p(x)`
--         */
--        .octa 0x156c8e180b4a395b069db049b8fdb1e7
--
--        /* x^800 mod p(x)`, x^832 mod p(x)`, x^864 mod p(x)`, x^896 mod p(x)` */
--        .octa 0xe0b99ccbe661f7bea11bfaf3c9e90b9e
--
--        /* x^672 mod p(x)`, x^704 mod p(x)`, x^736 mod p(x)`, x^768 mod p(x)` */
--        .octa 0x041d37768cd75659817cdc5119b29a35
--
--        /* x^544 mod p(x)`, x^576 mod p(x)`, x^608 mod p(x)`, x^640 mod p(x)` */
--        .octa 0x3a0777818cfaa9651ce9d94b36c41f1c
--
--        /* x^416 mod p(x)`, x^448 mod p(x)`, x^480 mod p(x)`, x^512 mod p(x)` */
--        .octa 0x0e148e8252377a554f256efcb82be955
--
--        /* x^288 mod p(x)`, x^320 mod p(x)`, x^352 mod p(x)`, x^384 mod p(x)` */
--        .octa 0x9c25531d19e65ddeec1631edb2dea967
--
--        /* x^160 mod p(x)`, x^192 mod p(x)`, x^224 mod p(x)`, x^256 mod p(x)` */
--        .octa 0x790606ff9957c0a65d27e147510ac59a
--
--        /* x^32 mod p(x)`, x^64 mod p(x)`, x^96 mod p(x)`, x^128 mod p(x)` */
--        .octa 0x82f63b786ea2d55ca66805eb18b8ea18
--
--        .barrett_constants :
--        /* 33 bit reflected Barrett constant m - (4^32)/n */
--        .octa 0x000000000000000000000000dea713f1 /* x^64 div p(x)` */
--        /* 33 bit reflected Barrett constant n */
--        .octa 0x00000000000000000000000105ec76f1
--#endif
-+	0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4,
-+	0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
-+	0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b,
-+	0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
-+	0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b,
-+	0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
-+	0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54,
-+	0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b,
-+	0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a,
-+	0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35,
-+	0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5,
-+	0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
-+	0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45,
-+	0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a,
-+	0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a,
-+	0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595,
-+	0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48,
-+	0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
-+	0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687,
-+	0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198,
-+	0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927,
-+	0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38,
-+	0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8,
-+	0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
-+	0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096,
-+	0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789,
-+	0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859,
-+	0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46,
-+	0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9,
-+	0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
-+	0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36,
-+	0x3cdb9bdd, 0xceb018de, 0xdde0eb2a, 0x2f8b6829,
-+	0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c,
-+	0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93,
-+	0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043,
-+	0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
-+	0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3,
-+	0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc,
-+	0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c,
-+	0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033,
-+	0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652,
-+	0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
-+	0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d,
-+	0xef087a76, 0x1d63f975, 0x0e330a81, 0xfc588982,
-+	0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d,
-+	0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622,
-+	0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2,
-+	0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed,
-+	0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530,
-+	0x0417b1db, 0xf67c32d8, 0xe52cc12c, 0x1747422f,
-+	0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff,
-+	0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0,
-+	0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f,
-+	0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
-+	0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90,
-+	0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f,
-+	0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee,
-+	0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1,
-+	0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321,
-+	0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e,
-+	0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81,
-+	0x34f4f86a, 0xc69f7b69, 0xd5cf889d, 0x27a40b9e,
-+	0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e,
-+	0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351,};
-+
-+#endif /* CRC_TABLE */
-+#ifdef POWER8_INTRINSICS
-+
-+/* Constants */
-+
-+/* Reduce 262144 kbits to 1024 bits */
-+static const __vector unsigned long long vcrc_const[255]
-+	__attribute__((aligned (16))) = {
-+#ifdef __LITTLE_ENDIAN__
-+		/* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
-+		{ 0x000000009c37c408, 0x00000000b6ca9e20 },
-+		/* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
-+		{ 0x00000001b51df26c, 0x00000000350249a8 },
-+		/* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
-+		{ 0x000000000724b9d0, 0x00000001862dac54 },
-+		/* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
-+		{ 0x00000001c00532fe, 0x00000001d87fb48c },
-+		/* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
-+		{ 0x00000000f05a9362, 0x00000001f39b699e },
-+		/* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
-+		{ 0x00000001e1007970, 0x0000000101da11b4 },
-+		/* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
-+		{ 0x00000000a57366ee, 0x00000001cab571e0 },
-+		/* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
-+		{ 0x0000000192011284, 0x00000000c7020cfe },
-+		/* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
-+		{ 0x0000000162716d9a, 0x00000000cdaed1ae },
-+		/* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
-+		{ 0x00000000cd97ecde, 0x00000001e804effc },
-+		/* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
-+		{ 0x0000000058812bc0, 0x0000000077c3ea3a },
-+		/* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
-+		{ 0x0000000088b8c12e, 0x0000000068df31b4 },
-+		/* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
-+		{ 0x00000001230b234c, 0x00000000b059b6c2 },
-+		/* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
-+		{ 0x00000001120b416e, 0x0000000145fb8ed8 },
-+		/* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
-+		{ 0x00000001974aecb0, 0x00000000cbc09168 },
-+		/* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
-+		{ 0x000000008ee3f226, 0x000000005ceeedc2 },
-+		/* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
-+		{ 0x00000001089aba9a, 0x0000000047d74e86 },
-+		/* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
-+		{ 0x0000000065113872, 0x00000001407e9e22 },
-+		/* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
-+		{ 0x000000005c07ec10, 0x00000001da967bda },
-+		/* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
-+		{ 0x0000000187590924, 0x000000006c898368 },
-+		/* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
-+		{ 0x00000000e35da7c6, 0x00000000f2d14c98 },
-+		/* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
-+		{ 0x000000000415855a, 0x00000001993c6ad4 },
-+		/* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
-+		{ 0x0000000073617758, 0x000000014683d1ac },
-+		/* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
-+		{ 0x0000000176021d28, 0x00000001a7c93e6c },
-+		/* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
-+		{ 0x00000001c358fd0a, 0x000000010211e90a },
-+		/* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
-+		{ 0x00000001ff7a2c18, 0x000000001119403e },
-+		/* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
-+		{ 0x00000000f2d9f7e4, 0x000000001c3261aa },
-+		/* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
-+		{ 0x000000016cf1f9c8, 0x000000014e37a634 },
-+		/* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
-+		{ 0x000000010af9279a, 0x0000000073786c0c },
-+		/* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
-+		{ 0x0000000004f101e8, 0x000000011dc037f8 },
-+		/* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
-+		{ 0x0000000070bcf184, 0x0000000031433dfc },
-+		/* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
-+		{ 0x000000000a8de642, 0x000000009cde8348 },
-+		/* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
-+		{ 0x0000000062ea130c, 0x0000000038d3c2a6 },
-+		/* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
-+		{ 0x00000001eb31cbb2, 0x000000011b25f260 },
-+		/* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
-+		{ 0x0000000170783448, 0x000000001629e6f0 },
-+		/* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
-+		{ 0x00000001a684b4c6, 0x0000000160838b4c },
-+		/* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
-+		{ 0x00000000253ca5b4, 0x000000007a44011c },
-+		/* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
-+		{ 0x0000000057b4b1e2, 0x00000000226f417a },
-+		/* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
-+		{ 0x00000000b6bd084c, 0x0000000045eb2eb4 },
-+		/* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
-+		{ 0x0000000123c2d592, 0x000000014459d70c },
-+		/* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
-+		{ 0x00000000159dafce, 0x00000001d406ed82 },
-+		/* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
-+		{ 0x0000000127e1a64e, 0x0000000160c8e1a8 },
-+		/* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
-+		{ 0x0000000056860754, 0x0000000027ba8098 },
-+		/* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
-+		{ 0x00000001e661aae8, 0x000000006d92d018 },
-+		/* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
-+		{ 0x00000000f82c6166, 0x000000012ed7e3f2 },
-+		/* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
-+		{ 0x00000000c4f9c7ae, 0x000000002dc87788 },
-+		/* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
-+		{ 0x0000000074203d20, 0x0000000018240bb8 },
-+		/* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
-+		{ 0x0000000198173052, 0x000000001ad38158 },
-+		/* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
-+		{ 0x00000001ce8aba54, 0x00000001396b78f2 },
-+		/* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
-+		{ 0x00000001850d5d94, 0x000000011a681334 },
-+		/* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
-+		{ 0x00000001d609239c, 0x000000012104732e },
-+		/* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
-+		{ 0x000000001595f048, 0x00000000a140d90c },
-+		/* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
-+		{ 0x0000000042ccee08, 0x00000001b7215eda },
-+		/* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
-+		{ 0x000000010a389d74, 0x00000001aaf1df3c },
-+		/* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
-+		{ 0x000000012a840da6, 0x0000000029d15b8a },
-+		/* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
-+		{ 0x000000001d181c0c, 0x00000000f1a96922 },
-+		/* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
-+		{ 0x0000000068b7d1f6, 0x00000001ac80d03c },
-+		/* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
-+		{ 0x000000005b0f14fc, 0x000000000f11d56a },
-+		/* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
-+		{ 0x0000000179e9e730, 0x00000001f1c022a2 },
-+		/* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
-+		{ 0x00000001ce1368d6, 0x0000000173d00ae2 },
-+		/* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
-+		{ 0x0000000112c3a84c, 0x00000001d4ffe4ac },
-+		/* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
-+		{ 0x00000000de940fee, 0x000000016edc5ae4 },
-+		/* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
-+		{ 0x00000000fe896b7e, 0x00000001f1a02140 },
-+		/* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
-+		{ 0x00000001f797431c, 0x00000000ca0b28a0 },
-+		/* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
-+		{ 0x0000000053e989ba, 0x00000001928e30a2 },
-+		/* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
-+		{ 0x000000003920cd16, 0x0000000097b1b002 },
-+		/* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
-+		{ 0x00000001e6f579b8, 0x00000000b15bf906 },
-+		/* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
-+		{ 0x000000007493cb0a, 0x00000000411c5d52 },
-+		/* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
-+		{ 0x00000001bdd376d8, 0x00000001c36f3300 },
-+		/* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
-+		{ 0x000000016badfee6, 0x00000001119227e0 },
-+		/* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
-+		{ 0x0000000071de5c58, 0x00000000114d4702 },
-+		/* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
-+		{ 0x00000000453f317c, 0x00000000458b5b98 },
-+		/* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
-+		{ 0x0000000121675cce, 0x000000012e31fb8e },
-+		/* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
-+		{ 0x00000001f409ee92, 0x000000005cf619d8 },
-+		/* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
-+		{ 0x00000000f36b9c88, 0x0000000063f4d8b2 },
-+		/* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
-+		{ 0x0000000036b398f4, 0x000000004138dc8a },
-+		/* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
-+		{ 0x00000001748f9adc, 0x00000001d29ee8e0 },
-+		/* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
-+		{ 0x00000001be94ec00, 0x000000006a08ace8 },
-+		/* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
-+		{ 0x00000000b74370d6, 0x0000000127d42010 },
-+		/* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
-+		{ 0x00000001174d0b98, 0x0000000019d76b62 },
-+		/* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
-+		{ 0x00000000befc06a4, 0x00000001b1471f6e },
-+		/* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
-+		{ 0x00000001ae125288, 0x00000001f64c19cc },
-+		/* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
-+		{ 0x0000000095c19b34, 0x00000000003c0ea0 },
-+		/* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
-+		{ 0x00000001a78496f2, 0x000000014d73abf6 },
-+		/* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
-+		{ 0x00000001ac5390a0, 0x00000001620eb844 },
-+		/* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
-+		{ 0x000000002a80ed6e, 0x0000000147655048 },
-+		/* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
-+		{ 0x00000001fa9b0128, 0x0000000067b5077e },
-+		/* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
-+		{ 0x00000001ea94929e, 0x0000000010ffe206 },
-+		/* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
-+		{ 0x0000000125f4305c, 0x000000000fee8f1e },
-+		/* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
-+		{ 0x00000001471e2002, 0x00000001da26fbae },
-+		/* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
-+		{ 0x0000000132d2253a, 0x00000001b3a8bd88 },
-+		/* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
-+		{ 0x00000000f26b3592, 0x00000000e8f3898e },
-+		/* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
-+		{ 0x00000000bc8b67b0, 0x00000000b0d0d28c },
-+		/* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
-+		{ 0x000000013a826ef2, 0x0000000030f2a798 },
-+		/* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
-+		{ 0x0000000081482c84, 0x000000000fba1002 },
-+		/* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
-+		{ 0x00000000e77307c2, 0x00000000bdb9bd72 },
-+		/* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
-+		{ 0x00000000d4a07ec8, 0x0000000075d3bf5a },
-+		/* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
-+		{ 0x0000000017102100, 0x00000000ef1f98a0 },
-+		/* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
-+		{ 0x00000000db406486, 0x00000000689c7602 },
-+		/* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
-+		{ 0x0000000192db7f88, 0x000000016d5fa5fe },
-+		/* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
-+		{ 0x000000018bf67b1e, 0x00000001d0d2b9ca },
-+		/* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
-+		{ 0x000000007c09163e, 0x0000000041e7b470 },
-+		/* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
-+		{ 0x000000000adac060, 0x00000001cbb6495e },
-+		/* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
-+		{ 0x00000000bd8316ae, 0x000000010052a0b0 },
-+		/* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
-+		{ 0x000000019f09ab54, 0x00000001d8effb5c },
-+		/* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
-+		{ 0x0000000125155542, 0x00000001d969853c },
-+		/* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
-+		{ 0x000000018fdb5882, 0x00000000523ccce2 },
-+		/* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
-+		{ 0x00000000e794b3f4, 0x000000001e2436bc },
-+		/* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
-+		{ 0x000000016f9bb022, 0x00000000ddd1c3a2 },
-+		/* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
-+		{ 0x00000000290c9978, 0x0000000019fcfe38 },
-+		/* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
-+		{ 0x0000000083c0f350, 0x00000001ce95db64 },
-+		/* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
-+		{ 0x0000000173ea6628, 0x00000000af582806 },
-+		/* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
-+		{ 0x00000001c8b4e00a, 0x00000001006388f6 },
-+		/* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
-+		{ 0x00000000de95d6aa, 0x0000000179eca00a },
-+		/* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
-+		{ 0x000000010b7f7248, 0x0000000122410a6a },
-+		/* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
-+		{ 0x00000001326e3a06, 0x000000004288e87c },
-+		/* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
-+		{ 0x00000000bb62c2e6, 0x000000016c5490da },
-+		/* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
-+		{ 0x0000000156a4b2c2, 0x00000000d1c71f6e },
-+		/* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
-+		{ 0x000000011dfe763a, 0x00000001b4ce08a6 },
-+		/* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
-+		{ 0x000000007bcca8e2, 0x00000001466ba60c },
-+		/* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
-+		{ 0x0000000186118faa, 0x00000001f6c488a4 },
-+		/* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
-+		{ 0x0000000111a65a88, 0x000000013bfb0682 },
-+		/* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
-+		{ 0x000000003565e1c4, 0x00000000690e9e54 },
-+		/* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
-+		{ 0x000000012ed02a82, 0x00000000281346b6 },
-+		/* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
-+		{ 0x00000000c486ecfc, 0x0000000156464024 },
-+		/* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
-+		{ 0x0000000001b951b2, 0x000000016063a8dc },
-+		/* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
-+		{ 0x0000000048143916, 0x0000000116a66362 },
-+		/* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
-+		{ 0x00000001dc2ae124, 0x000000017e8aa4d2 },
-+		/* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
-+		{ 0x00000001416c58d6, 0x00000001728eb10c },
-+		/* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
-+		{ 0x00000000a479744a, 0x00000001b08fd7fa },
-+		/* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
-+		{ 0x0000000096ca3a26, 0x00000001092a16e8 },
-+		/* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
-+		{ 0x00000000ff223d4e, 0x00000000a505637c },
-+		/* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
-+		{ 0x000000010e84da42, 0x00000000d94869b2 },
-+		/* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
-+		{ 0x00000001b61ba3d0, 0x00000001c8b203ae },
-+		/* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
-+		{ 0x00000000680f2de8, 0x000000005704aea0 },
-+		/* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
-+		{ 0x000000008772a9a8, 0x000000012e295fa2 },
-+		/* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
-+		{ 0x0000000155f295bc, 0x000000011d0908bc },
-+		/* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
-+		{ 0x00000000595f9282, 0x0000000193ed97ea },
-+		/* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
-+		{ 0x0000000164b1c25a, 0x000000013a0f1c52 },
-+		/* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
-+		{ 0x00000000fbd67c50, 0x000000010c2c40c0 },
-+		/* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
-+		{ 0x0000000096076268, 0x00000000ff6fac3e },
-+		/* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
-+		{ 0x00000001d288e4cc, 0x000000017b3609c0 },
-+		/* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
-+		{ 0x00000001eaac1bdc, 0x0000000088c8c922 },
-+		/* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
-+		{ 0x00000001f1ea39e2, 0x00000001751baae6 },
-+		/* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
-+		{ 0x00000001eb6506fc, 0x0000000107952972 },
-+		/* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
-+		{ 0x000000010f806ffe, 0x0000000162b00abe },
-+		/* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
-+		{ 0x000000010408481e, 0x000000000d7b404c },
-+		/* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
-+		{ 0x0000000188260534, 0x00000000763b13d4 },
-+		/* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
-+		{ 0x0000000058fc73e0, 0x00000000f6dc22d8 },
-+		/* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
-+		{ 0x00000000391c59b8, 0x000000007daae060 },
-+		/* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
-+		{ 0x000000018b638400, 0x000000013359ab7c },
-+		/* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
-+		{ 0x000000011738f5c4, 0x000000008add438a },
-+		/* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
-+		{ 0x000000008cf7c6da, 0x00000001edbefdea },
-+		/* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
-+		{ 0x00000001ef97fb16, 0x000000004104e0f8 },
-+		/* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
-+		{ 0x0000000102130e20, 0x00000000b48a8222 },
-+		/* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
-+		{ 0x00000000db968898, 0x00000001bcb46844 },
-+		/* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
-+		{ 0x00000000b5047b5e, 0x000000013293ce0a },
-+		/* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
-+		{ 0x000000010b90fdb2, 0x00000001710d0844 },
-+		/* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
-+		{ 0x000000004834a32e, 0x0000000117907f6e },
-+		/* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
-+		{ 0x0000000059c8f2b0, 0x0000000087ddf93e },
-+		/* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
-+		{ 0x0000000122cec508, 0x000000005970e9b0 },
-+		/* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
-+		{ 0x000000000a330cda, 0x0000000185b2b7d0 },
-+		/* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
-+		{ 0x000000014a47148c, 0x00000001dcee0efc },
-+		/* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
-+		{ 0x0000000042c61cb8, 0x0000000030da2722 },
-+		/* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
-+		{ 0x0000000012fe6960, 0x000000012f925a18 },
-+		/* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
-+		{ 0x00000000dbda2c20, 0x00000000dd2e357c },
-+		/* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
-+		{ 0x000000011122410c, 0x00000000071c80de },
-+		/* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
-+		{ 0x00000000977b2070, 0x000000011513140a },
-+		/* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
-+		{ 0x000000014050438e, 0x00000001df876e8e },
-+		/* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
-+		{ 0x0000000147c840e8, 0x000000015f81d6ce },
-+		/* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
-+		{ 0x00000001cc7c88ce, 0x000000019dd94dbe },
-+		/* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
-+		{ 0x00000001476b35a4, 0x00000001373d206e },
-+		/* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
-+		{ 0x000000013d52d508, 0x00000000668ccade },
-+		/* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
-+		{ 0x000000008e4be32e, 0x00000001b192d268 },
-+		/* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
-+		{ 0x00000000024120fe, 0x00000000e30f3a78 },
-+		/* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
-+		{ 0x00000000ddecddb4, 0x000000010ef1f7bc },
-+		/* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
-+		{ 0x00000000d4d403bc, 0x00000001f5ac7380 },
-+		/* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
-+		{ 0x00000001734b89aa, 0x000000011822ea70 },
-+		/* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
-+		{ 0x000000010e7a58d6, 0x00000000c3a33848 },
-+		/* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
-+		{ 0x00000001f9f04e9c, 0x00000001bd151c24 },
-+		/* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
-+		{ 0x00000000b692225e, 0x0000000056002d76 },
-+		/* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
-+		{ 0x000000019b8d3f3e, 0x000000014657c4f4 },
-+		/* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
-+		{ 0x00000001a874f11e, 0x0000000113742d7c },
-+		/* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
-+		{ 0x000000010d5a4254, 0x000000019c5920ba },
-+		/* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
-+		{ 0x00000000bbb2f5d6, 0x000000005216d2d6 },
-+		/* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
-+		{ 0x0000000179cc0e36, 0x0000000136f5ad8a },
-+		/* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
-+		{ 0x00000001dca1da4a, 0x000000018b07beb6 },
-+		/* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
-+		{ 0x00000000feb1a192, 0x00000000db1e93b0 },
-+		/* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
-+		{ 0x00000000d1eeedd6, 0x000000000b96fa3a },
-+		/* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
-+		{ 0x000000008fad9bb4, 0x00000001d9968af0 },
-+		/* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
-+		{ 0x00000001884938e4, 0x000000000e4a77a2 },
-+		/* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
-+		{ 0x00000001bc2e9bc0, 0x00000000508c2ac8 },
-+		/* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
-+		{ 0x00000001f9658a68, 0x0000000021572a80 },
-+		/* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
-+		{ 0x000000001b9224fc, 0x00000001b859daf2 },
-+		/* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
-+		{ 0x0000000055b2fb84, 0x000000016f788474 },
-+		/* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
-+		{ 0x000000018b090348, 0x00000001b438810e },
-+		/* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
-+		{ 0x000000011ccbd5ea, 0x0000000095ddc6f2 },
-+		/* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
-+		{ 0x0000000007ae47f8, 0x00000001d977c20c },
-+		/* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
-+		{ 0x0000000172acbec0, 0x00000000ebedb99a },
-+		/* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
-+		{ 0x00000001c6e3ff20, 0x00000001df9e9e92 },
-+		/* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
-+		{ 0x00000000e1b38744, 0x00000001a4a3f952 },
-+		/* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
-+		{ 0x00000000791585b2, 0x00000000e2f51220 },
-+		/* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
-+		{ 0x00000000ac53b894, 0x000000004aa01f3e },
-+		/* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
-+		{ 0x00000001ed5f2cf4, 0x00000000b3e90a58 },
-+		/* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
-+		{ 0x00000001df48b2e0, 0x000000000c9ca2aa },
-+		/* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
-+		{ 0x00000000049c1c62, 0x0000000151682316 },
-+		/* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
-+		{ 0x000000017c460c12, 0x0000000036fce78c },
-+		/* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
-+		{ 0x000000015be4da7e, 0x000000009037dc10 },
-+		/* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
-+		{ 0x000000010f38f668, 0x00000000d3298582 },
-+		/* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
-+		{ 0x0000000039f40a00, 0x00000001b42e8ad6 },
-+		/* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
-+		{ 0x00000000bd4c10c4, 0x00000000142a9838 },
-+		/* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
-+		{ 0x0000000042db1d98, 0x0000000109c7f190 },
-+		/* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
-+		{ 0x00000001c905bae6, 0x0000000056ff9310 },
-+		/* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
-+		{ 0x00000000069d40ea, 0x00000001594513aa },
-+		/* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
-+		{ 0x000000008e4fbad0, 0x00000001e3b5b1e8 },
-+		/* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
-+		{ 0x0000000047bedd46, 0x000000011dd5fc08 },
-+		/* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
-+		{ 0x0000000026396bf8, 0x00000001675f0cc2 },
-+		/* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
-+		{ 0x00000000379beb92, 0x00000000d1c8dd44 },
-+		/* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
-+		{ 0x000000000abae54a, 0x0000000115ebd3d8 },
-+		/* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
-+		{ 0x0000000007e6a128, 0x00000001ecbd0dac },
-+		/* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
-+		{ 0x000000000ade29d2, 0x00000000cdf67af2 },
-+		/* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
-+		{ 0x00000000f974c45c, 0x000000004c01ff4c },
-+		/* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
-+		{ 0x00000000e77ac60a, 0x00000000f2d8657e },
-+		/* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
-+		{ 0x0000000145895816, 0x000000006bae74c4 },
-+		/* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
-+		{ 0x0000000038e362be, 0x0000000152af8aa0 },
-+		/* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
-+		{ 0x000000007f991a64, 0x0000000004663802 },
-+		/* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
-+		{ 0x00000000fa366d3a, 0x00000001ab2f5afc },
-+		/* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
-+		{ 0x00000001a2bb34f0, 0x0000000074a4ebd4 },
-+		/* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
-+		{ 0x0000000028a9981e, 0x00000001d7ab3a4c },
-+		/* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
-+		{ 0x00000001dbc672be, 0x00000001a8da60c6 },
-+		/* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
-+		{ 0x00000000b04d77f6, 0x000000013cf63820 },
-+		/* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
-+		{ 0x0000000124400d96, 0x00000000bec12e1e },
-+		/* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
-+		{ 0x000000014ca4b414, 0x00000001c6368010 },
-+		/* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
-+		{ 0x000000012fe2c938, 0x00000001e6e78758 },
-+		/* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
-+		{ 0x00000001faed01e6, 0x000000008d7f2b3c },
-+		/* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
-+		{ 0x000000007e80ecfe, 0x000000016b4a156e },
-+		/* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
-+		{ 0x0000000098daee94, 0x00000001c63cfeb6 },
-+		/* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
-+		{ 0x000000010a04edea, 0x000000015f902670 },
-+		/* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
-+		{ 0x00000001c00b4524, 0x00000001cd5de11e },
-+		/* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
-+		{ 0x0000000170296550, 0x000000001acaec54 },
-+		/* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
-+		{ 0x0000000181afaa48, 0x000000002bd0ca78 },
-+		/* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
-+		{ 0x0000000185a31ffa, 0x0000000032d63d5c },
-+		/* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
-+		{ 0x000000002469f608, 0x000000001c6d4e4c },
-+		/* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
-+		{ 0x000000006980102a, 0x0000000106a60b92 },
-+		/* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
-+		{ 0x0000000111ea9ca8, 0x00000000d3855e12 },
-+		/* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
-+		{ 0x00000001bd1d29ce, 0x00000000e3125636 },
-+		/* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
-+		{ 0x00000001b34b9580, 0x000000009e8f7ea4 },
-+		/* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
-+		{ 0x000000003076054e, 0x00000001c82e562c },
-+		/* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
-+		{ 0x000000012a608ea4, 0x00000000ca9f09ce },
-+		/* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
-+		{ 0x00000000784d05fe, 0x00000000c63764e6 },
-+		/* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
-+		{ 0x000000016ef0d82a, 0x0000000168d2e49e },
-+		/* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
-+		{ 0x0000000075bda454, 0x00000000e986c148 },
-+		/* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
-+		{ 0x000000003dc0a1c4, 0x00000000cfb65894 },
-+		/* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
-+		{ 0x00000000e9a5d8be, 0x0000000111cadee4 },
-+		/* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
-+		{ 0x00000001609bc4b4, 0x0000000171fb63ce }
-+#else /* __LITTLE_ENDIAN__ */
-+		/* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
-+		{ 0x00000000b6ca9e20, 0x000000009c37c408 },
-+		/* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
-+		{ 0x00000000350249a8, 0x00000001b51df26c },
-+		/* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
-+		{ 0x00000001862dac54, 0x000000000724b9d0 },
-+		/* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
-+		{ 0x00000001d87fb48c, 0x00000001c00532fe },
-+		/* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
-+		{ 0x00000001f39b699e, 0x00000000f05a9362 },
-+		/* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
-+		{ 0x0000000101da11b4, 0x00000001e1007970 },
-+		/* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
-+		{ 0x00000001cab571e0, 0x00000000a57366ee },
-+		/* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
-+		{ 0x00000000c7020cfe, 0x0000000192011284 },
-+		/* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
-+		{ 0x00000000cdaed1ae, 0x0000000162716d9a },
-+		/* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
-+		{ 0x00000001e804effc, 0x00000000cd97ecde },
-+		/* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
-+		{ 0x0000000077c3ea3a, 0x0000000058812bc0 },
-+		/* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
-+		{ 0x0000000068df31b4, 0x0000000088b8c12e },
-+		/* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
-+		{ 0x00000000b059b6c2, 0x00000001230b234c },
-+		/* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
-+		{ 0x0000000145fb8ed8, 0x00000001120b416e },
-+		/* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
-+		{ 0x00000000cbc09168, 0x00000001974aecb0 },
-+		/* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
-+		{ 0x000000005ceeedc2, 0x000000008ee3f226 },
-+		/* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
-+		{ 0x0000000047d74e86, 0x00000001089aba9a },
-+		/* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
-+		{ 0x00000001407e9e22, 0x0000000065113872 },
-+		/* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
-+		{ 0x00000001da967bda, 0x000000005c07ec10 },
-+		/* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
-+		{ 0x000000006c898368, 0x0000000187590924 },
-+		/* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
-+		{ 0x00000000f2d14c98, 0x00000000e35da7c6 },
-+		/* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
-+		{ 0x00000001993c6ad4, 0x000000000415855a },
-+		/* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
-+		{ 0x000000014683d1ac, 0x0000000073617758 },
-+		/* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
-+		{ 0x00000001a7c93e6c, 0x0000000176021d28 },
-+		/* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
-+		{ 0x000000010211e90a, 0x00000001c358fd0a },
-+		/* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
-+		{ 0x000000001119403e, 0x00000001ff7a2c18 },
-+		/* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
-+		{ 0x000000001c3261aa, 0x00000000f2d9f7e4 },
-+		/* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
-+		{ 0x000000014e37a634, 0x000000016cf1f9c8 },
-+		/* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
-+		{ 0x0000000073786c0c, 0x000000010af9279a },
-+		/* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
-+		{ 0x000000011dc037f8, 0x0000000004f101e8 },
-+		/* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
-+		{ 0x0000000031433dfc, 0x0000000070bcf184 },
-+		/* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
-+		{ 0x000000009cde8348, 0x000000000a8de642 },
-+		/* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
-+		{ 0x0000000038d3c2a6, 0x0000000062ea130c },
-+		/* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
-+		{ 0x000000011b25f260, 0x00000001eb31cbb2 },
-+		/* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
-+		{ 0x000000001629e6f0, 0x0000000170783448 },
-+		/* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
-+		{ 0x0000000160838b4c, 0x00000001a684b4c6 },
-+		/* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
-+		{ 0x000000007a44011c, 0x00000000253ca5b4 },
-+		/* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
-+		{ 0x00000000226f417a, 0x0000000057b4b1e2 },
-+		/* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
-+		{ 0x0000000045eb2eb4, 0x00000000b6bd084c },
-+		/* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
-+		{ 0x000000014459d70c, 0x0000000123c2d592 },
-+		/* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
-+		{ 0x00000001d406ed82, 0x00000000159dafce },
-+		/* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
-+		{ 0x0000000160c8e1a8, 0x0000000127e1a64e },
-+		/* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
-+		{ 0x0000000027ba8098, 0x0000000056860754 },
-+		/* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
-+		{ 0x000000006d92d018, 0x00000001e661aae8 },
-+		/* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
-+		{ 0x000000012ed7e3f2, 0x00000000f82c6166 },
-+		/* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
-+		{ 0x000000002dc87788, 0x00000000c4f9c7ae },
-+		/* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
-+		{ 0x0000000018240bb8, 0x0000000074203d20 },
-+		/* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
-+		{ 0x000000001ad38158, 0x0000000198173052 },
-+		/* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
-+		{ 0x00000001396b78f2, 0x00000001ce8aba54 },
-+		/* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
-+		{ 0x000000011a681334, 0x00000001850d5d94 },
-+		/* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
-+		{ 0x000000012104732e, 0x00000001d609239c },
-+		/* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
-+		{ 0x00000000a140d90c, 0x000000001595f048 },
-+		/* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
-+		{ 0x00000001b7215eda, 0x0000000042ccee08 },
-+		/* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
-+		{ 0x00000001aaf1df3c, 0x000000010a389d74 },
-+		/* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
-+		{ 0x0000000029d15b8a, 0x000000012a840da6 },
-+		/* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
-+		{ 0x00000000f1a96922, 0x000000001d181c0c },
-+		/* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
-+		{ 0x00000001ac80d03c, 0x0000000068b7d1f6 },
-+		/* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
-+		{ 0x000000000f11d56a, 0x000000005b0f14fc },
-+		/* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
-+		{ 0x00000001f1c022a2, 0x0000000179e9e730 },
-+		/* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
-+		{ 0x0000000173d00ae2, 0x00000001ce1368d6 },
-+		/* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
-+		{ 0x00000001d4ffe4ac, 0x0000000112c3a84c },
-+		/* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
-+		{ 0x000000016edc5ae4, 0x00000000de940fee },
-+		/* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
-+		{ 0x00000001f1a02140, 0x00000000fe896b7e },
-+		/* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
-+		{ 0x00000000ca0b28a0, 0x00000001f797431c },
-+		/* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
-+		{ 0x00000001928e30a2, 0x0000000053e989ba },
-+		/* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
-+		{ 0x0000000097b1b002, 0x000000003920cd16 },
-+		/* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
-+		{ 0x00000000b15bf906, 0x00000001e6f579b8 },
-+		/* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
-+		{ 0x00000000411c5d52, 0x000000007493cb0a },
-+		/* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
-+		{ 0x00000001c36f3300, 0x00000001bdd376d8 },
-+		/* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
-+		{ 0x00000001119227e0, 0x000000016badfee6 },
-+		/* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
-+		{ 0x00000000114d4702, 0x0000000071de5c58 },
-+		/* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
-+		{ 0x00000000458b5b98, 0x00000000453f317c },
-+		/* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
-+		{ 0x000000012e31fb8e, 0x0000000121675cce },
-+		/* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
-+		{ 0x000000005cf619d8, 0x00000001f409ee92 },
-+		/* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
-+		{ 0x0000000063f4d8b2, 0x00000000f36b9c88 },
-+		/* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
-+		{ 0x000000004138dc8a, 0x0000000036b398f4 },
-+		/* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
-+		{ 0x00000001d29ee8e0, 0x00000001748f9adc },
-+		/* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
-+		{ 0x000000006a08ace8, 0x00000001be94ec00 },
-+		/* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
-+		{ 0x0000000127d42010, 0x00000000b74370d6 },
-+		/* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
-+		{ 0x0000000019d76b62, 0x00000001174d0b98 },
-+		/* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
-+		{ 0x00000001b1471f6e, 0x00000000befc06a4 },
-+		/* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
-+		{ 0x00000001f64c19cc, 0x00000001ae125288 },
-+		/* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
-+		{ 0x00000000003c0ea0, 0x0000000095c19b34 },
-+		/* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
-+		{ 0x000000014d73abf6, 0x00000001a78496f2 },
-+		/* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
-+		{ 0x00000001620eb844, 0x00000001ac5390a0 },
-+		/* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
-+		{ 0x0000000147655048, 0x000000002a80ed6e },
-+		/* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
-+		{ 0x0000000067b5077e, 0x00000001fa9b0128 },
-+		/* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
-+		{ 0x0000000010ffe206, 0x00000001ea94929e },
-+		/* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
-+		{ 0x000000000fee8f1e, 0x0000000125f4305c },
-+		/* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
-+		{ 0x00000001da26fbae, 0x00000001471e2002 },
-+		/* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
-+		{ 0x00000001b3a8bd88, 0x0000000132d2253a },
-+		/* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
-+		{ 0x00000000e8f3898e, 0x00000000f26b3592 },
-+		/* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
-+		{ 0x00000000b0d0d28c, 0x00000000bc8b67b0 },
-+		/* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
-+		{ 0x0000000030f2a798, 0x000000013a826ef2 },
-+		/* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
-+		{ 0x000000000fba1002, 0x0000000081482c84 },
-+		/* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
-+		{ 0x00000000bdb9bd72, 0x00000000e77307c2 },
-+		/* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
-+		{ 0x0000000075d3bf5a, 0x00000000d4a07ec8 },
-+		/* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
-+		{ 0x00000000ef1f98a0, 0x0000000017102100 },
-+		/* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
-+		{ 0x00000000689c7602, 0x00000000db406486 },
-+		/* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
-+		{ 0x000000016d5fa5fe, 0x0000000192db7f88 },
-+		/* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
-+		{ 0x00000001d0d2b9ca, 0x000000018bf67b1e },
-+		/* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
-+		{ 0x0000000041e7b470, 0x000000007c09163e },
-+		/* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
-+		{ 0x00000001cbb6495e, 0x000000000adac060 },
-+		/* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
-+		{ 0x000000010052a0b0, 0x00000000bd8316ae },
-+		/* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
-+		{ 0x00000001d8effb5c, 0x000000019f09ab54 },
-+		/* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
-+		{ 0x00000001d969853c, 0x0000000125155542 },
-+		/* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
-+		{ 0x00000000523ccce2, 0x000000018fdb5882 },
-+		/* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
-+		{ 0x000000001e2436bc, 0x00000000e794b3f4 },
-+		/* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
-+		{ 0x00000000ddd1c3a2, 0x000000016f9bb022 },
-+		/* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
-+		{ 0x0000000019fcfe38, 0x00000000290c9978 },
-+		/* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
-+		{ 0x00000001ce95db64, 0x0000000083c0f350 },
-+		/* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
-+		{ 0x00000000af582806, 0x0000000173ea6628 },
-+		/* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
-+		{ 0x00000001006388f6, 0x00000001c8b4e00a },
-+		/* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
-+		{ 0x0000000179eca00a, 0x00000000de95d6aa },
-+		/* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
-+		{ 0x0000000122410a6a, 0x000000010b7f7248 },
-+		/* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
-+		{ 0x000000004288e87c, 0x00000001326e3a06 },
-+		/* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
-+		{ 0x000000016c5490da, 0x00000000bb62c2e6 },
-+		/* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
-+		{ 0x00000000d1c71f6e, 0x0000000156a4b2c2 },
-+		/* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
-+		{ 0x00000001b4ce08a6, 0x000000011dfe763a },
-+		/* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
-+		{ 0x00000001466ba60c, 0x000000007bcca8e2 },
-+		/* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
-+		{ 0x00000001f6c488a4, 0x0000000186118faa },
-+		/* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
-+		{ 0x000000013bfb0682, 0x0000000111a65a88 },
-+		/* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
-+		{ 0x00000000690e9e54, 0x000000003565e1c4 },
-+		/* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
-+		{ 0x00000000281346b6, 0x000000012ed02a82 },
-+		/* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
-+		{ 0x0000000156464024, 0x00000000c486ecfc },
-+		/* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
-+		{ 0x000000016063a8dc, 0x0000000001b951b2 },
-+		/* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
-+		{ 0x0000000116a66362, 0x0000000048143916 },
-+		/* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
-+		{ 0x000000017e8aa4d2, 0x00000001dc2ae124 },
-+		/* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
-+		{ 0x00000001728eb10c, 0x00000001416c58d6 },
-+		/* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
-+		{ 0x00000001b08fd7fa, 0x00000000a479744a },
-+		/* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
-+		{ 0x00000001092a16e8, 0x0000000096ca3a26 },
-+		/* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
-+		{ 0x00000000a505637c, 0x00000000ff223d4e },
-+		/* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
-+		{ 0x00000000d94869b2, 0x000000010e84da42 },
-+		/* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
-+		{ 0x00000001c8b203ae, 0x00000001b61ba3d0 },
-+		/* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
-+		{ 0x000000005704aea0, 0x00000000680f2de8 },
-+		/* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
-+		{ 0x000000012e295fa2, 0x000000008772a9a8 },
-+		/* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
-+		{ 0x000000011d0908bc, 0x0000000155f295bc },
-+		/* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
-+		{ 0x0000000193ed97ea, 0x00000000595f9282 },
-+		/* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
-+		{ 0x000000013a0f1c52, 0x0000000164b1c25a },
-+		/* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
-+		{ 0x000000010c2c40c0, 0x00000000fbd67c50 },
-+		/* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
-+		{ 0x00000000ff6fac3e, 0x0000000096076268 },
-+		/* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
-+		{ 0x000000017b3609c0, 0x00000001d288e4cc },
-+		/* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
-+		{ 0x0000000088c8c922, 0x00000001eaac1bdc },
-+		/* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
-+		{ 0x00000001751baae6, 0x00000001f1ea39e2 },
-+		/* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
-+		{ 0x0000000107952972, 0x00000001eb6506fc },
-+		/* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
-+		{ 0x0000000162b00abe, 0x000000010f806ffe },
-+		/* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
-+		{ 0x000000000d7b404c, 0x000000010408481e },
-+		/* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
-+		{ 0x00000000763b13d4, 0x0000000188260534 },
-+		/* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
-+		{ 0x00000000f6dc22d8, 0x0000000058fc73e0 },
-+		/* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
-+		{ 0x000000007daae060, 0x00000000391c59b8 },
-+		/* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
-+		{ 0x000000013359ab7c, 0x000000018b638400 },
-+		/* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
-+		{ 0x000000008add438a, 0x000000011738f5c4 },
-+		/* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
-+		{ 0x00000001edbefdea, 0x000000008cf7c6da },
-+		/* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
-+		{ 0x000000004104e0f8, 0x00000001ef97fb16 },
-+		/* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
-+		{ 0x00000000b48a8222, 0x0000000102130e20 },
-+		/* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
-+		{ 0x00000001bcb46844, 0x00000000db968898 },
-+		/* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
-+		{ 0x000000013293ce0a, 0x00000000b5047b5e },
-+		/* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
-+		{ 0x00000001710d0844, 0x000000010b90fdb2 },
-+		/* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
-+		{ 0x0000000117907f6e, 0x000000004834a32e },
-+		/* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
-+		{ 0x0000000087ddf93e, 0x0000000059c8f2b0 },
-+		/* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
-+		{ 0x000000005970e9b0, 0x0000000122cec508 },
-+		/* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
-+		{ 0x0000000185b2b7d0, 0x000000000a330cda },
-+		/* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
-+		{ 0x00000001dcee0efc, 0x000000014a47148c },
-+		/* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
-+		{ 0x0000000030da2722, 0x0000000042c61cb8 },
-+		/* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
-+		{ 0x000000012f925a18, 0x0000000012fe6960 },
-+		/* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
-+		{ 0x00000000dd2e357c, 0x00000000dbda2c20 },
-+		/* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
-+		{ 0x00000000071c80de, 0x000000011122410c },
-+		/* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
-+		{ 0x000000011513140a, 0x00000000977b2070 },
-+		/* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
-+		{ 0x00000001df876e8e, 0x000000014050438e },
-+		/* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
-+		{ 0x000000015f81d6ce, 0x0000000147c840e8 },
-+		/* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
-+		{ 0x000000019dd94dbe, 0x00000001cc7c88ce },
-+		/* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
-+		{ 0x00000001373d206e, 0x00000001476b35a4 },
-+		/* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
-+		{ 0x00000000668ccade, 0x000000013d52d508 },
-+		/* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
-+		{ 0x00000001b192d268, 0x000000008e4be32e },
-+		/* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
-+		{ 0x00000000e30f3a78, 0x00000000024120fe },
-+		/* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
-+		{ 0x000000010ef1f7bc, 0x00000000ddecddb4 },
-+		/* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
-+		{ 0x00000001f5ac7380, 0x00000000d4d403bc },
-+		/* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
-+		{ 0x000000011822ea70, 0x00000001734b89aa },
-+		/* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
-+		{ 0x00000000c3a33848, 0x000000010e7a58d6 },
-+		/* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
-+		{ 0x00000001bd151c24, 0x00000001f9f04e9c },
-+		/* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
-+		{ 0x0000000056002d76, 0x00000000b692225e },
-+		/* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
-+		{ 0x000000014657c4f4, 0x000000019b8d3f3e },
-+		/* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
-+		{ 0x0000000113742d7c, 0x00000001a874f11e },
-+		/* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
-+		{ 0x000000019c5920ba, 0x000000010d5a4254 },
-+		/* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
-+		{ 0x000000005216d2d6, 0x00000000bbb2f5d6 },
-+		/* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
-+		{ 0x0000000136f5ad8a, 0x0000000179cc0e36 },
-+		/* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
-+		{ 0x000000018b07beb6, 0x00000001dca1da4a },
-+		/* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
-+		{ 0x00000000db1e93b0, 0x00000000feb1a192 },
-+		/* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
-+		{ 0x000000000b96fa3a, 0x00000000d1eeedd6 },
-+		/* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
-+		{ 0x00000001d9968af0, 0x000000008fad9bb4 },
-+		/* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
-+		{ 0x000000000e4a77a2, 0x00000001884938e4 },
-+		/* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
-+		{ 0x00000000508c2ac8, 0x00000001bc2e9bc0 },
-+		/* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
-+		{ 0x0000000021572a80, 0x00000001f9658a68 },
-+		/* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
-+		{ 0x00000001b859daf2, 0x000000001b9224fc },
-+		/* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
-+		{ 0x000000016f788474, 0x0000000055b2fb84 },
-+		/* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
-+		{ 0x00000001b438810e, 0x000000018b090348 },
-+		/* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
-+		{ 0x0000000095ddc6f2, 0x000000011ccbd5ea },
-+		/* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
-+		{ 0x00000001d977c20c, 0x0000000007ae47f8 },
-+		/* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
-+		{ 0x00000000ebedb99a, 0x0000000172acbec0 },
-+		/* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
-+		{ 0x00000001df9e9e92, 0x00000001c6e3ff20 },
-+		/* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
-+		{ 0x00000001a4a3f952, 0x00000000e1b38744 },
-+		/* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
-+		{ 0x00000000e2f51220, 0x00000000791585b2 },
-+		/* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
-+		{ 0x000000004aa01f3e, 0x00000000ac53b894 },
-+		/* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
-+		{ 0x00000000b3e90a58, 0x00000001ed5f2cf4 },
-+		/* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
-+		{ 0x000000000c9ca2aa, 0x00000001df48b2e0 },
-+		/* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
-+		{ 0x0000000151682316, 0x00000000049c1c62 },
-+		/* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
-+		{ 0x0000000036fce78c, 0x000000017c460c12 },
-+		/* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
-+		{ 0x000000009037dc10, 0x000000015be4da7e },
-+		/* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
-+		{ 0x00000000d3298582, 0x000000010f38f668 },
-+		/* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
-+		{ 0x00000001b42e8ad6, 0x0000000039f40a00 },
-+		/* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
-+		{ 0x00000000142a9838, 0x00000000bd4c10c4 },
-+		/* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
-+		{ 0x0000000109c7f190, 0x0000000042db1d98 },
-+		/* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
-+		{ 0x0000000056ff9310, 0x00000001c905bae6 },
-+		/* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
-+		{ 0x00000001594513aa, 0x00000000069d40ea },
-+		/* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
-+		{ 0x00000001e3b5b1e8, 0x000000008e4fbad0 },
-+		/* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
-+		{ 0x000000011dd5fc08, 0x0000000047bedd46 },
-+		/* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
-+		{ 0x00000001675f0cc2, 0x0000000026396bf8 },
-+		/* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
-+		{ 0x00000000d1c8dd44, 0x00000000379beb92 },
-+		/* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
-+		{ 0x0000000115ebd3d8, 0x000000000abae54a },
-+		/* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
-+		{ 0x00000001ecbd0dac, 0x0000000007e6a128 },
-+		/* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
-+		{ 0x00000000cdf67af2, 0x000000000ade29d2 },
-+		/* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
-+		{ 0x000000004c01ff4c, 0x00000000f974c45c },
-+		/* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
-+		{ 0x00000000f2d8657e, 0x00000000e77ac60a },
-+		/* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
-+		{ 0x000000006bae74c4, 0x0000000145895816 },
-+		/* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
-+		{ 0x0000000152af8aa0, 0x0000000038e362be },
-+		/* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
-+		{ 0x0000000004663802, 0x000000007f991a64 },
-+		/* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
-+		{ 0x00000001ab2f5afc, 0x00000000fa366d3a },
-+		/* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
-+		{ 0x0000000074a4ebd4, 0x00000001a2bb34f0 },
-+		/* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
-+		{ 0x00000001d7ab3a4c, 0x0000000028a9981e },
-+		/* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
-+		{ 0x00000001a8da60c6, 0x00000001dbc672be },
-+		/* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
-+		{ 0x000000013cf63820, 0x00000000b04d77f6 },
-+		/* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
-+		{ 0x00000000bec12e1e, 0x0000000124400d96 },
-+		/* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
-+		{ 0x00000001c6368010, 0x000000014ca4b414 },
-+		/* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
-+		{ 0x00000001e6e78758, 0x000000012fe2c938 },
-+		/* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
-+		{ 0x000000008d7f2b3c, 0x00000001faed01e6 },
-+		/* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
-+		{ 0x000000016b4a156e, 0x000000007e80ecfe },
-+		/* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
-+		{ 0x00000001c63cfeb6, 0x0000000098daee94 },
-+		/* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
-+		{ 0x000000015f902670, 0x000000010a04edea },
-+		/* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
-+		{ 0x00000001cd5de11e, 0x00000001c00b4524 },
-+		/* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
-+		{ 0x000000001acaec54, 0x0000000170296550 },
-+		/* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
-+		{ 0x000000002bd0ca78, 0x0000000181afaa48 },
-+		/* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
-+		{ 0x0000000032d63d5c, 0x0000000185a31ffa },
-+		/* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
-+		{ 0x000000001c6d4e4c, 0x000000002469f608 },
-+		/* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
-+		{ 0x0000000106a60b92, 0x000000006980102a },
-+		/* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
-+		{ 0x00000000d3855e12, 0x0000000111ea9ca8 },
-+		/* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
-+		{ 0x00000000e3125636, 0x00000001bd1d29ce },
-+		/* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
-+		{ 0x000000009e8f7ea4, 0x00000001b34b9580 },
-+		/* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
-+		{ 0x00000001c82e562c, 0x000000003076054e },
-+		/* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
-+		{ 0x00000000ca9f09ce, 0x000000012a608ea4 },
-+		/* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
-+		{ 0x00000000c63764e6, 0x00000000784d05fe },
-+		/* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
-+		{ 0x0000000168d2e49e, 0x000000016ef0d82a },
-+		/* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
-+		{ 0x00000000e986c148, 0x0000000075bda454 },
-+		/* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
-+		{ 0x00000000cfb65894, 0x000000003dc0a1c4 },
-+		/* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
-+		{ 0x0000000111cadee4, 0x00000000e9a5d8be },
-+		/* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
-+		{ 0x0000000171fb63ce, 0x00000001609bc4b4 }
-+#endif /* __LITTLE_ENDIAN__ */
-+	};
-+
-+/* Reduce final 1024-2048 bits to 64 bits, shifting 32 bits to include the trailing 32 bits of zeros */
-+
-+static const __vector unsigned long long vcrc_short_const[16]
-+	__attribute__((aligned (16))) = {
-+#ifdef __LITTLE_ENDIAN__
-+		/* x^1952 mod p(x) , x^1984 mod p(x) , x^2016 mod p(x) , x^2048 mod p(x)  */
-+		{ 0x5cf015c388e56f72, 0x7fec2963e5bf8048 },
-+		/* x^1824 mod p(x) , x^1856 mod p(x) , x^1888 mod p(x) , x^1920 mod p(x)  */
-+		{ 0x963a18920246e2e6, 0x38e888d4844752a9 },
-+		/* x^1696 mod p(x) , x^1728 mod p(x) , x^1760 mod p(x) , x^1792 mod p(x)  */
-+		{ 0x419a441956993a31, 0x42316c00730206ad },
-+		/* x^1568 mod p(x) , x^1600 mod p(x) , x^1632 mod p(x) , x^1664 mod p(x)  */
-+		{ 0x924752ba2b830011, 0x543d5c543e65ddf9 },
-+		/* x^1440 mod p(x) , x^1472 mod p(x) , x^1504 mod p(x) , x^1536 mod p(x)  */
-+		{ 0x55bd7f9518e4a304, 0x78e87aaf56767c92 },
-+		/* x^1312 mod p(x) , x^1344 mod p(x) , x^1376 mod p(x) , x^1408 mod p(x)  */
-+		{ 0x6d76739fe0553f1e, 0x8f68fcec1903da7f },
-+		/* x^1184 mod p(x) , x^1216 mod p(x) , x^1248 mod p(x) , x^1280 mod p(x)  */
-+		{ 0xc133722b1fe0b5c3, 0x3f4840246791d588 },
-+		/* x^1056 mod p(x) , x^1088 mod p(x) , x^1120 mod p(x) , x^1152 mod p(x)  */
-+		{ 0x64b67ee0e55ef1f3, 0x34c96751b04de25a },
-+		/* x^928 mod p(x) , x^960 mod p(x) , x^992 mod p(x) , x^1024 mod p(x)  */
-+		{ 0x069db049b8fdb1e7, 0x156c8e180b4a395b },
-+		/* x^800 mod p(x) , x^832 mod p(x) , x^864 mod p(x) , x^896 mod p(x)  */
-+		{ 0xa11bfaf3c9e90b9e, 0xe0b99ccbe661f7be },
-+		/* x^672 mod p(x) , x^704 mod p(x) , x^736 mod p(x) , x^768 mod p(x)  */
-+		{ 0x817cdc5119b29a35, 0x041d37768cd75659 },
-+		/* x^544 mod p(x) , x^576 mod p(x) , x^608 mod p(x) , x^640 mod p(x)  */
-+		{ 0x1ce9d94b36c41f1c, 0x3a0777818cfaa965 },
-+		/* x^416 mod p(x) , x^448 mod p(x) , x^480 mod p(x) , x^512 mod p(x)  */
-+		{ 0x4f256efcb82be955, 0x0e148e8252377a55 },
-+		/* x^288 mod p(x) , x^320 mod p(x) , x^352 mod p(x) , x^384 mod p(x)  */
-+		{ 0xec1631edb2dea967, 0x9c25531d19e65dde },
-+		/* x^160 mod p(x) , x^192 mod p(x) , x^224 mod p(x) , x^256 mod p(x)  */
-+		{ 0x5d27e147510ac59a, 0x790606ff9957c0a6 },
-+		/* x^32 mod p(x) , x^64 mod p(x) , x^96 mod p(x) , x^128 mod p(x)  */
-+		{ 0xa66805eb18b8ea18, 0x82f63b786ea2d55c }
-+#else /* __LITTLE_ENDIAN__ */
-+		/* x^1952 mod p(x) , x^1984 mod p(x) , x^2016 mod p(x) , x^2048 mod p(x)  */
-+		{ 0x7fec2963e5bf8048, 0x5cf015c388e56f72 },
-+		/* x^1824 mod p(x) , x^1856 mod p(x) , x^1888 mod p(x) , x^1920 mod p(x)  */
-+		{ 0x38e888d4844752a9, 0x963a18920246e2e6 },
-+		/* x^1696 mod p(x) , x^1728 mod p(x) , x^1760 mod p(x) , x^1792 mod p(x)  */
-+		{ 0x42316c00730206ad, 0x419a441956993a31 },
-+		/* x^1568 mod p(x) , x^1600 mod p(x) , x^1632 mod p(x) , x^1664 mod p(x)  */
-+		{ 0x543d5c543e65ddf9, 0x924752ba2b830011 },
-+		/* x^1440 mod p(x) , x^1472 mod p(x) , x^1504 mod p(x) , x^1536 mod p(x)  */
-+		{ 0x78e87aaf56767c92, 0x55bd7f9518e4a304 },
-+		/* x^1312 mod p(x) , x^1344 mod p(x) , x^1376 mod p(x) , x^1408 mod p(x)  */
-+		{ 0x8f68fcec1903da7f, 0x6d76739fe0553f1e },
-+		/* x^1184 mod p(x) , x^1216 mod p(x) , x^1248 mod p(x) , x^1280 mod p(x)  */
-+		{ 0x3f4840246791d588, 0xc133722b1fe0b5c3 },
-+		/* x^1056 mod p(x) , x^1088 mod p(x) , x^1120 mod p(x) , x^1152 mod p(x)  */
-+		{ 0x34c96751b04de25a, 0x64b67ee0e55ef1f3 },
-+		/* x^928 mod p(x) , x^960 mod p(x) , x^992 mod p(x) , x^1024 mod p(x)  */
-+		{ 0x156c8e180b4a395b, 0x069db049b8fdb1e7 },
-+		/* x^800 mod p(x) , x^832 mod p(x) , x^864 mod p(x) , x^896 mod p(x)  */
-+		{ 0xe0b99ccbe661f7be, 0xa11bfaf3c9e90b9e },
-+		/* x^672 mod p(x) , x^704 mod p(x) , x^736 mod p(x) , x^768 mod p(x)  */
-+		{ 0x041d37768cd75659, 0x817cdc5119b29a35 },
-+		/* x^544 mod p(x) , x^576 mod p(x) , x^608 mod p(x) , x^640 mod p(x)  */
-+		{ 0x3a0777818cfaa965, 0x1ce9d94b36c41f1c },
-+		/* x^416 mod p(x) , x^448 mod p(x) , x^480 mod p(x) , x^512 mod p(x)  */
-+		{ 0x0e148e8252377a55, 0x4f256efcb82be955 },
-+		/* x^288 mod p(x) , x^320 mod p(x) , x^352 mod p(x) , x^384 mod p(x)  */
-+		{ 0x9c25531d19e65dde, 0xec1631edb2dea967 },
-+		/* x^160 mod p(x) , x^192 mod p(x) , x^224 mod p(x) , x^256 mod p(x)  */
-+		{ 0x790606ff9957c0a6, 0x5d27e147510ac59a },
-+		/* x^32 mod p(x) , x^64 mod p(x) , x^96 mod p(x) , x^128 mod p(x)  */
-+		{ 0x82f63b786ea2d55c, 0xa66805eb18b8ea18 }
-+#endif /* __LITTLE_ENDIAN__ */
-+	};
-+
-+/* Barrett constants */
-+/* 33 bit reflected Barrett constant m - (4^32)/n */
-+
-+static const __vector unsigned long long v_Barrett_const[2]
-+	__attribute__((aligned (16))) = {
-+		/* x^64 div p(x)  */
-+#ifdef __LITTLE_ENDIAN__
-+		{ 0x00000000dea713f1, 0x0000000000000000 },
-+		{ 0x0000000105ec76f1, 0x0000000000000000 }
-+#else /* __LITTLE_ENDIAN__ */
-+		{ 0x0000000000000000, 0x00000000dea713f1 },
-+		{ 0x0000000000000000, 0x0000000105ec76f1 }
-+#endif /* __LITTLE_ENDIAN__ */
-+	};
-+#endif /* POWER8_INTRINSICS */
-diff --git a/util/crc32c_test.cc b/util/crc32c_test.cc
-index 3e4f7396e7..6fd7d34876 100644
---- a/util/crc32c_test.cc
-+++ b/util/crc32c_test.cc
-@@ -108,6 +108,9 @@ TEST(CRC, StandardResults) {
-     EXPECT_EQ(~expected.crc32c, result);
-   }
- 
-+  // NULL buffer
-+  EXPECT_EQ((uint32_t) 0, Value(NULL, 0));
-+
-   // Test 2: stitching two computations
-   for (auto expected : expectedResults) {
-     size_t partialLength = expected.length / 2;
diff --git a/package/rocksdb/rocksdb.hash b/package/rocksdb/rocksdb.hash
index d404488322..35c4a702b5 100644
--- a/package/rocksdb/rocksdb.hash
+++ b/package/rocksdb/rocksdb.hash
@@ -1,8 +1,8 @@
 # Locally computed:
-sha256  d573d2f15cdda883714f7e0bc87b814a8d4a53a82edde558f08f940e905541ee  rocksdb-6.10.1.tar.gz
+sha256  b86741983c5842716128efc2eecc1a2f3bc86ba5125cf3111fb58d26fb195ff0  rocksdb-6.13.3.tar.gz
 
 # Hash for license files:
 sha256  8177f97513213526df2cf6184d8ff986c675afb514d4e68a404010521b880643  COPYING
 sha256  cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  LICENSE.Apache
 sha256  b568f1f37a5a1d37a3e981e7c8b7fc4856ca33b2ca0a45bc8e847aaaf7afe485  LICENSE.leveldb
-sha256  054f4b04473dd7003fcd9e48b75c61fd257e50beb418c501099c651c0356a556  README.md
+sha256  5791f5e0a4569112a97183581a8550e18db9fdf666479485fb98be10489ed5ca  README.md
diff --git a/package/rocksdb/rocksdb.mk b/package/rocksdb/rocksdb.mk
index 2288c406a6..3b8583131c 100644
--- a/package/rocksdb/rocksdb.mk
+++ b/package/rocksdb/rocksdb.mk
@@ -4,13 +4,15 @@
 #
 ################################################################################
 
-ROCKSDB_VERSION = 6.10.1
+ROCKSDB_VERSION = 6.13.3
 ROCKSDB_SITE = $(call github,facebook,rocksdb,v$(ROCKSDB_VERSION))
 ROCKSDB_LICENSE = GPL-2.0 or Apache-2.0
 ROCKSDB_LICENSE_FILES = COPYING LICENSE.Apache LICENSE.leveldb README.md
 ROCKSDB_INSTALL_STAGING = YES
 
-ROCKSDB_MAKE_OPTS = PORTABLE=1
+ROCKSDB_MAKE_OPTS = \
+	PORTABLE=1 \
+	PREFIX=/usr
 
 # Internal error, aborting at dwarf2cfi.c:2802 in connect_traces
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58864
@@ -67,6 +69,12 @@ else
 ROCKSDB_MAKE_OPTS += ROCKSDB_DISABLE_ZSTD=1
 endif
 
+ifeq ($(BR2_GCC_ENABLE_LTO),y)
+ROCKSDB_MAKE_OPTS += USE_LTO=1
+else
+ROCKSDB_MAKE_OPTS += USE_LTO=0
+endif
+
 ifeq ($(BR2_STATIC_LIBS),y)
 ROCKSDB_BUILD_TARGETS += static_lib
 ROCKSDB_INSTALL_TARGETS += install-static
@@ -88,12 +96,12 @@ endef
 
 define ROCKSDB_INSTALL_STAGING_CMDS
 	$(TARGET_CONFIGURE_OPTS) $(MAKE) $(ROCKSDB_MAKE_OPTS) -C $(@D) \
-		INSTALL_PATH=$(STAGING_DIR) $(ROCKSDB_INSTALL_TARGETS)
+		DESTDIR=$(STAGING_DIR) $(ROCKSDB_INSTALL_TARGETS)
 endef
 
 define ROCKSDB_INSTALL_TARGET_CMDS
 	$(TARGET_CONFIGURE_OPTS) $(MAKE) $(ROCKSDB_MAKE_OPTS) -C $(@D) \
-		INSTALL_PATH=$(TARGET_DIR) $(ROCKSDB_INSTALL_TARGETS)
+		DESTDIR=$(TARGET_DIR) $(ROCKSDB_INSTALL_TARGETS)
 endef
 
 $(eval $(generic-package))
-- 
2.28.0



More information about the buildroot mailing list