MDEV-22641: Provide SIMD optimized wrapper for zlib crc32() (#1558)

Existing implementation used my_checksum (from mysys)
for calculating table checksum and binlog checksum.

This implementation was optimized for powerpc only and lacked
SIMD implementation for x86 (using clmul) and ARM
(using ACLE) instead used zlib-crc32.

mariabackup had its own copy of the crc32 implementation
using hardware optimized implementation only for x86 and lagged
hardware based implementation for powerpc and ARM.

Patch helps unifies all such calls and help aggregate all of them
using an unified interface my_checksum().

Said unification also enables hardware optimized calls for all
architecture viz. x86, ARM, POWERPC.
Default always fallback to zlib crc32.

Thanks to Daniel Black for reviewing, fixing and testing
PowerPC changes. Thanks to Marko and Daniel for early code feedback.

9 files changed, 4143 insertions, 19 deletions

diff --git a/mysys/CMakeLists.txt b/mysys/CMakeLists.txt
index ef159748092..ecb4166802f 100644
--- a/mysys/CMakeLists.txt
+++ b/mysys/CMakeLists.txt
@@ -58,6 +58,59 @@ IF (WIN32)
     my_win_popen.cc)
 ENDIF()
 
+IF(NOT MSVC AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
+  #Check for PCLMUL instruction (x86)
+  CHECK_C_SOURCE_COMPILES("
+  int main()
+  {
+    asm volatile (\"pclmulqdq \\$0x00, %%xmm1, %%xmm0\":::\"cc\");
+    return 0;
+  }" HAVE_CLMUL_INSTRUCTION)
+
+  IF(HAVE_CLMUL_INSTRUCTION)
+    SET(MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32_x86.c)
+  ENDIF()
+ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64")
+  IF(CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
+    include(CheckCXXSourceCompiles)
+
+    CHECK_CXX_SOURCE_COMPILES("
+    #define CRC32CX(crc, value) __asm__(\"crc32cx %w[c], %w[c], %x[v]\":[c]\"+r\"(crc):[v]\"r\"(value))
+    asm(\".arch_extension crc\");
+    unsigned int foo(unsigned int ret) {
+      CRC32CX(ret, 0);
+      return ret;
+    }
+    #include <sys/auxv.h>
+    int main() { foo(0); getauxval(AT_HWCAP); }" HAVE_ARMV8_CRC)
+
+    CHECK_CXX_SOURCE_COMPILES("
+    asm(\".arch_extension crypto\");
+    unsigned int foo(unsigned int ret) {
+      __asm__(\"pmull  v2.1q,          v2.1d,  v1.1d\");
+      return ret;
+    }
+    int main() { foo(0); }" HAVE_ARMV8_CRYPTO)
+
+    CHECK_C_COMPILER_FLAG(-march=armv8-a+crc+crypto HAVE_ARMV8_CRC_CRYPTO_INTRINSICS)
+    IF(HAVE_ARMV8_CRC_CRYPTO_INTRINSICS)
+      SET(MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32_arm64.c)
+      SET_SOURCE_FILES_PROPERTIES(crc32/crc32_arm64.c PROPERTIES
+        COMPILE_FLAGS "-march=armv8-a+crc+crypto")
+    ENDIF()
+  ENDIF()
+ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64")
+  SET(HAVE_CRC32_VPMSUM 1)
+  SET(MYSYS_SOURCES ${MYSYS_SOURCES} $<TARGET_OBJECTS:crc32c> $<TARGET_OBJECTS:crc32ieee>)
+
+  ADD_LIBRARY(crc32c OBJECT crc32/crc32_ppc64.c)
+  ADD_LIBRARY(crc32ieee OBJECT crc32/crc32_ppc64.c)
+
+  SET_TARGET_PROPERTIES(crc32c crc32ieee PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -maltivec -mvsx -mpower8-vector -mcrypto -mpower8-vector")
+  SET_TARGET_PROPERTIES(crc32ieee PROPERTIES COMPILE_DEFINITIONS "CRC32_FUNCTION=my_checksum;CRC32_CONSTANTS_HEADER=\"pcc_crc32_constants.h\"")
+  SET_TARGET_PROPERTIES(crc32c PROPERTIES COMPILE_DEFINITIONS "CRC32_FUNCTION=crc32c_vpmsum;CRC32_CONSTANTS_HEADER=\"pcc_crc32c_constants.h\"")
+ENDIF()
+
 IF(UNIX)
  SET (MYSYS_SOURCES ${MYSYS_SOURCES} my_addr_resolve.c my_setuser.c)
 ENDIF()
@@ -73,7 +126,7 @@ ENDIF()
 ADD_CONVENIENCE_LIBRARY(mysys ${MYSYS_SOURCES})
 MAYBE_DISABLE_IPO(mysys)
 TARGET_LINK_LIBRARIES(mysys dbug strings ${ZLIB_LIBRARY}
- ${LIBNSL} ${LIBM} ${LIBRT} ${LIBDL} ${LIBSOCKET} ${LIBEXECINFO} ${CRC32_LIBRARY})
+ ${LIBNSL} ${LIBM} ${LIBRT} ${LIBDL} ${LIBSOCKET} ${LIBEXECINFO})
 DTRACE_INSTRUMENT(mysys)
 
 IF(HAVE_BFD_H)
diff --git a/mysys/checksum.c b/mysys/checksum.c
index 91e681d0db4..e86c2726722 100644
--- a/mysys/checksum.c
+++ b/mysys/checksum.c
@@ -18,25 +18,41 @@
 #include <my_sys.h>
 #include <zlib.h>
 
-/*
-  Calculate a long checksum for a memoryblock.
+/* TODO: remove this once zlib adds inherent support for hardware accelerated
+crc32 for all architectures. */
+static unsigned int my_crc32_zlib(unsigned int crc, const void *data,
+                                  size_t len)
+{
+  return (unsigned int) crc32(crc, data, (unsigned int) len);
+}
+
+#if !defined(HAVE_CRC32_VPMSUM)
+my_crc32_t my_checksum= my_crc32_zlib;
+#endif
+
+#if __GNUC__ >= 4 && defined(__x86_64__)
 
-  SYNOPSIS
-    my_checksum()
-      crc       start value for crc
-      pos       pointer to memory block
-      length    length of the block
-*/
+extern int crc32_pclmul_enabled();
+extern unsigned int crc32_pclmul(unsigned int, const void *, size_t);
 
-ha_checksum my_checksum(ha_checksum crc, const uchar *pos, size_t length)
+/*----------------------------- x86_64 ---------------------------------*/
+void my_checksum_init(void)
 {
-#ifdef HAVE_CRC32_VPMSUM
-  extern unsigned int crc32ieee_vpmsum(unsigned int crc, const unsigned char *p,
-                                    unsigned long len);
-  crc= (ha_checksum) crc32ieee_vpmsum((uint) crc, pos, (uint) length);
+  if (crc32_pclmul_enabled())
+    my_checksum= crc32_pclmul;
+}
+#elif defined(__GNUC__) && defined(HAVE_ARMV8_CRC)
+/*----------------------------- aarch64 --------------------------------*/
+
+extern unsigned int crc32_aarch64(unsigned int, const void *, size_t);
+
+/* Ideally all ARM 64 bit processor should support crc32 but if some model
+doesn't support better to find it out through auxillary vector. */
+void my_checksum_init(void)
+{
+  if (crc32_aarch64_available())
+    my_checksum= crc32_aarch64;
+}
 #else
-  crc= (ha_checksum) crc32((uint)crc, pos, (uint) length);
+void my_checksum_init(void) {}
 #endif
-  DBUG_PRINT("info", ("crc: %lu", (ulong) crc));
-  return crc;
-}
diff --git a/mysys/crc32/clang_workaround.h b/mysys/crc32/clang_workaround.h
new file mode 100644
index 00000000000..915f7e5282f
--- /dev/null
+++ b/mysys/crc32/clang_workaround.h
@@ -0,0 +1,87 @@
+#ifndef CLANG_WORKAROUNDS_H
+#define CLANG_WORKAROUNDS_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/mysys/crc32/crc32_arm64.c b/mysys/crc32/crc32_arm64.c
new file mode 100644
index 00000000000..09ac7a12a66
--- /dev/null
+++ b/mysys/crc32/crc32_arm64.c
@@ -0,0 +1,334 @@
+#include <my_global.h>
+#include <string.h>
+#include <stdint.h>
+
+#if defined(__GNUC__) && defined(HAVE_ARMV8_CRC)
+
+#include <sys/auxv.h>
+#include <asm/hwcap.h>
+
+#ifndef HWCAP_CRC32
+#define HWCAP_CRC32 (1 << 7)
+#endif
+
+/* ARM made crc32 default from ARMv8.1 but optional in ARMv8A
+so the runtime check. */
+int crc32_aarch64_available(void)
+{
+  unsigned long auxv= getauxval(AT_HWCAP);
+  return (auxv & HWCAP_CRC32) != 0;
+}
+#endif
+
+#ifndef HAVE_ARMV8_CRC_CRYPTO_INTRINSICS
+
+/* Request crc extension capabilities from the assembler */
+asm(".arch_extension crc");
+
+#ifdef HAVE_ARMV8_CRYPTO
+/* crypto extension  */
+asm(".arch_extension crypto");
+#endif
+
+#define CRC32CX(crc, value) __asm__("crc32cx %w[c], %w[c], %x[v]":[c]"+r"(crc):[v]"r"(value))
+#define CRC32CW(crc, value) __asm__("crc32cw %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
+#define CRC32CH(crc, value) __asm__("crc32ch %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
+#define CRC32CB(crc, value) __asm__("crc32cb %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
+
+#define CRC32C3X8(buffer, ITR) \
+	__asm__("crc32cx %w[c1], %w[c1], %x[v]":[c1]"+r"(crc1):[v]"r"(*((const uint64_t *)buffer + 42*1 + (ITR))));\
+	__asm__("crc32cx %w[c2], %w[c2], %x[v]":[c2]"+r"(crc2):[v]"r"(*((const uint64_t *)buffer + 42*2 + (ITR))));\
+	__asm__("crc32cx %w[c0], %w[c0], %x[v]":[c0]"+r"(crc0):[v]"r"(*((const uint64_t *)buffer + 42*0 + (ITR))));
+
+#define CRC32C3X8_ZERO \
+	__asm__("crc32cx %w[c0], %w[c0], xzr":[c0]"+r"(crc0));
+
+#else /* HAVE_ARMV8_CRC_CRYPTO_INTRINSICS  */
+
+/* Intrinsics header*/
+#include <arm_acle.h>
+#include <arm_neon.h>
+
+#define CRC32CX(crc, value) (crc) = __crc32cd((crc), (value))
+#define CRC32CW(crc, value) (crc) = __crc32cw((crc), (value))
+#define CRC32CH(crc, value) (crc) = __crc32ch((crc), (value))
+#define CRC32CB(crc, value) (crc) = __crc32cb((crc), (value))
+
+#define CRC32C3X8(buffer, ITR) \
+	crc1 = __crc32cd(crc1, *((const uint64_t *)buffer + 42*1 + (ITR)));\
+	crc2 = __crc32cd(crc2, *((const uint64_t *)buffer + 42*2 + (ITR)));\
+	crc0 = __crc32cd(crc0, *((const uint64_t *)buffer + 42*0 + (ITR)));
+
+#define CRC32C3X8_ZERO \
+	crc0 = __crc32cd(crc0, (const uint64_t)0);
+
+#endif /* HAVE_ARMV8_CRC_CRYPTO_INTRINSICS */
+
+#define CRC32C7X3X8(buffer, ITR) do {\
+	CRC32C3X8(buffer, ((ITR) * 7 + 0)) \
+	CRC32C3X8(buffer, ((ITR) * 7 + 1)) \
+	CRC32C3X8(buffer, ((ITR) * 7 + 2)) \
+	CRC32C3X8(buffer, ((ITR) * 7 + 3)) \
+	CRC32C3X8(buffer, ((ITR) * 7 + 4)) \
+	CRC32C3X8(buffer, ((ITR) * 7 + 5)) \
+	CRC32C3X8(buffer, ((ITR) * 7 + 6)) \
+	} while(0)
+
+#define CRC32C7X3X8_ZERO do {\
+	CRC32C3X8_ZERO \
+	CRC32C3X8_ZERO \
+	CRC32C3X8_ZERO \
+	CRC32C3X8_ZERO \
+	CRC32C3X8_ZERO \
+	CRC32C3X8_ZERO \
+	CRC32C3X8_ZERO \
+	} while(0)
+
+#define PREF4X64L1(buffer, PREF_OFFSET, ITR) \
+	__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 0)*64));\
+	__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 1)*64));\
+	__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 2)*64));\
+	__asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 3)*64));
+
+#define PREF1KL1(buffer, PREF_OFFSET) \
+	PREF4X64L1(buffer,(PREF_OFFSET), 0) \
+	PREF4X64L1(buffer,(PREF_OFFSET), 4) \
+	PREF4X64L1(buffer,(PREF_OFFSET), 8) \
+	PREF4X64L1(buffer,(PREF_OFFSET), 12)
+
+#define PREF4X64L2(buffer, PREF_OFFSET, ITR) \
+	__asm__("PRFM PLDL2KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 0)*64));\
+	__asm__("PRFM PLDL2KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 1)*64));\
+	__asm__("PRFM PLDL2KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 2)*64));\
+	__asm__("PRFM PLDL2KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 3)*64));
+
+#define PREF1KL2(buffer, PREF_OFFSET) \
+	PREF4X64L2(buffer,(PREF_OFFSET), 0) \
+	PREF4X64L2(buffer,(PREF_OFFSET), 4) \
+	PREF4X64L2(buffer,(PREF_OFFSET), 8) \
+	PREF4X64L2(buffer,(PREF_OFFSET), 12)
+
+
+uint32_t crc32c_aarch64(uint32_t crc, const unsigned char *buffer, uint64_t len)
+{
+	uint32_t crc0, crc1, crc2;
+	int64_t length = (int64_t)len;
+
+	crc = 0xFFFFFFFFU;
+
+	if (buffer) {
+
+/* Crypto extension Support
+ * Process 1024 Bytes (per block)
+ */
+#ifdef HAVE_ARMV8_CRYPTO
+
+/* Intrinsics Support  */
+#ifdef HAVE_ARMV8_CRC_CRYPTO_INTRINSICS
+		const poly64_t k1 = 0xe417f38a, k2 = 0x8f158014;
+		uint64_t t0, t1;
+
+		/* Process per block size of 1024 Bytes
+		 * A block size = 8 + 42*3*sizeof(uint64_t) + 8
+                 */
+		while ((length -= 1024) >= 0) {
+			/* Prefetch 3*1024 data for avoiding L2 cache miss */
+			PREF1KL2(buffer, 1024*3);
+			/* Do first 8 bytes here for better pipelining */
+			crc0 = __crc32cd(crc, *(const uint64_t *)buffer);
+			crc1 = 0;
+			crc2 = 0;
+			buffer += sizeof(uint64_t);
+
+			/* Process block inline
+			 * Process crc0 last to avoid dependency with above
+                         */
+			CRC32C7X3X8(buffer, 0);
+			CRC32C7X3X8(buffer, 1);
+			CRC32C7X3X8(buffer, 2);
+			CRC32C7X3X8(buffer, 3);
+			CRC32C7X3X8(buffer, 4);
+			CRC32C7X3X8(buffer, 5);
+
+			buffer += 42*3*sizeof(uint64_t);
+			/* Prefetch data for following block to avoid L1 cache miss */
+			PREF1KL1(buffer, 1024);
+
+			/* Last 8 bytes
+			 * Merge crc0 and crc1 into crc2
+			 * crc1 multiply by K2
+			 * crc0 multiply by K1
+			 */
+			t1 = (uint64_t)vmull_p64(crc1, k2);
+			t0 = (uint64_t)vmull_p64(crc0, k1);
+			crc = __crc32cd(crc2, *(const uint64_t *)buffer);
+			crc1 = __crc32cd(0, t1);
+			crc ^= crc1;
+			crc0 = __crc32cd(0, t0);
+			crc ^= crc0;
+
+			buffer += sizeof(uint64_t);
+		}
+
+#else /* HAVE_ARMV8_CRC_CRYPTO_INTRINSICS */
+
+		/*No intrinsics*/
+		__asm__("mov    x16,            #0xf38a         \n\t"
+			"movk   x16,            #0xe417, lsl 16 \n\t"
+			"mov    v1.2d[0],       x16             \n\t"
+			"mov    x16,            #0x8014         \n\t"
+			"movk   x16,            #0x8f15, lsl 16 \n\t"
+			"mov    v0.2d[0],       x16             \n\t"
+			:::"x16");
+
+		while ((length -= 1024) >= 0) {
+			PREF1KL2(buffer, 1024*3);
+			__asm__("crc32cx %w[c0], %w[c], %x[v]\n\t"
+				:[c0]"=r"(crc0):[c]"r"(crc), [v]"r"(*(const uint64_t *)buffer):);
+			crc1 = 0;
+			crc2 = 0;
+			buffer += sizeof(uint64_t);
+
+			CRC32C7X3X8(buffer, 0);
+			CRC32C7X3X8(buffer, 1);
+			CRC32C7X3X8(buffer, 2);
+			CRC32C7X3X8(buffer, 3);
+			CRC32C7X3X8(buffer, 4);
+			CRC32C7X3X8(buffer, 5);
+
+			buffer += 42*3*sizeof(uint64_t);
+			PREF1KL1(buffer, 1024);
+			__asm__("mov            v2.2d[0],       %x[c1]          \n\t"
+				"pmull          v2.1q,          v2.1d,  v0.1d   \n\t"
+				"mov            v3.2d[0],       %x[c0]          \n\t"
+				"pmull          v3.1q,          v3.1d,  v1.1d   \n\t"
+				"crc32cx        %w[c],          %w[c2], %x[v]   \n\t"
+				"mov            %x[c1],         v2.2d[0]        \n\t"
+				"crc32cx        %w[c1],         wzr,    %x[c1]  \n\t"
+				"eor            %w[c],          %w[c],  %w[c1]  \n\t"
+				"mov            %x[c0],         v3.2d[0]        \n\t"
+				"crc32cx        %w[c0],         wzr,    %x[c0]  \n\t"
+				"eor            %w[c],          %w[c],  %w[c0]  \n\t"
+				:[c1]"+r"(crc1), [c0]"+r"(crc0), [c2]"+r"(crc2), [c]"+r"(crc)
+				:[v]"r"(*((const uint64_t *)buffer)));
+			buffer += sizeof(uint64_t);
+		}
+#endif /* HAVE_ARMV8_CRC_CRYPTO_INTRINSICS */
+
+		/* Done if Input data size is aligned with 1024  */
+		if(!(length += 1024))
+			return (~crc);
+
+#endif /* HAVE_ARMV8_CRYPTO */
+
+		while ((length -= sizeof(uint64_t)) >= 0) {
+			CRC32CX(crc, *(uint64_t *)buffer);
+			buffer += sizeof(uint64_t);
+		}
+		/* The following is more efficient than the straight loop */
+		if (length & sizeof(uint32_t)) {
+			CRC32CW(crc, *(uint32_t *)buffer);
+			buffer += sizeof(uint32_t);
+		}
+		if (length & sizeof(uint16_t)) {
+			CRC32CH(crc, *(uint16_t *)buffer);
+			buffer += sizeof(uint16_t);
+		}
+		if (length & sizeof(uint8_t))
+			CRC32CB(crc, *buffer);
+
+	} else {
+#ifdef HAVE_ARMV8_CRYPTO
+#ifdef HAVE_ARMV8_CRC_CRYPTO_INTRINSICS
+		const poly64_t k1 = 0xe417f38a;
+		uint64_t t0;
+		while ((length -= 1024) >= 0) {
+			crc0 = __crc32cd(crc, 0);
+
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+
+			/* Merge crc0 into crc: crc0 multiply by K1 */
+			t0 = (uint64_t)vmull_p64(crc0, k1);
+			crc = __crc32cd(0, t0);
+		}
+#else /* !HAVE_ARMV8_CRC_CRYPTO_INTRINSICS */
+		__asm__("mov    x16,            #0xf38a         \n\t"
+			"movk   x16,            #0xe417, lsl 16 \n\t"
+			"mov    v1.2d[0],       x16             \n\t"
+			:::"x16");
+
+		while ((length -= 1024) >= 0) {
+			__asm__("crc32cx %w[c0], %w[c], xzr\n\t"
+				:[c0]"=r"(crc0):[c]"r"(crc));
+
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+			CRC32C7X3X8_ZERO;
+
+			__asm__("mov            v3.2d[0],       %x[c0]          \n\t"
+				"pmull          v3.1q,          v3.1d,  v1.1d   \n\t"
+				"mov            %x[c0],         v3.2d[0]        \n\t"
+				"crc32cx        %w[c],          wzr,    %x[c0]  \n\t"
+				:[c]"=r"(crc)
+				:[c0]"r"(crc0));
+		}
+#endif /* HAVE_ARMV8_CRC_CRYPTO_INTRINSICS */
+		if(!(length += 1024))
+			return (~crc);
+#endif /* HAVE_ARMV8_CRYPTO */
+		while ((length -= sizeof(uint64_t)) >= 0)
+			CRC32CX(crc, 0);
+
+		/* The following is more efficient than the straight loop */
+		if (length & sizeof(uint32_t))
+			CRC32CW(crc, 0);
+
+		if (length & sizeof(uint16_t))
+			CRC32CH(crc, 0);
+
+		if (length & sizeof(uint8_t))
+			CRC32CB(crc, 0);
+	}
+
+	return (~crc);
+}
+
+/* There are multiple approaches to calculate crc.
+Approach-1: Process 8 bytes then 4 bytes then 2 bytes and then 1 bytes
+Approach-2: Process 8 bytes and remaining workload using 1 bytes
+Apporach-3: Process 64 bytes at once by issuing 8 crc call and remaining
+            using 8/1 combination.
+
+Based on micro-benchmark testing we found that Approach-2 works best especially
+given small chunk of variable data. */
+unsigned int crc32_aarch64(unsigned int crc, const void *buf, size_t len)
+{
+  const uint8_t *buf1= buf;
+  const uint64_t *buf8= (const uint64_t *) (((uintptr_t) buf + 7) & ~7);
+
+  crc= ~crc;
+
+  /* if start pointer is not 8 bytes aligned */
+  while ((buf1 != (const uint8_t *) buf8) && len)
+  {
+    crc= __crc32b(crc, *buf1++);
+    len--;
+  }
+
+  for (; len >= 8; len-= 8)
+    crc= __crc32d(crc, *buf8++);
+
+  buf1= (const uint8_t *) buf8;
+  while (len--)
+    crc= __crc32b(crc, *buf1++);
+
+  return ~crc;
+}
diff --git a/mysys/crc32/crc32_ppc64.c b/mysys/crc32/crc32_ppc64.c
new file mode 100644
index 00000000000..2e8b9fc1b12
--- /dev/null
+++ b/mysys/crc32/crc32_ppc64.c
@@ -0,0 +1,675 @@
+/*
+ * 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@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
+
+#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, 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  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;
+#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 "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
+	__vector unsigned char vsht_splat;
+	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 */
+	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/mysys/crc32/crc32_x86.c b/mysys/crc32/crc32_x86.c
new file mode 100644
index 00000000000..3f176a6c145
--- /dev/null
+++ b/mysys/crc32/crc32_x86.c
@@ -0,0 +1,545 @@
+/******************************************************
+Copyright (c) 2017 Percona LLC and/or its affiliates.
+
+CRC32 using Intel's PCLMUL instruction.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1335  USA
+
+*******************************************************/
+
+/* crc-intel-pclmul.c - Intel PCLMUL accelerated CRC implementation
+ * Copyright (C) 2016 Jussi Kivilinna <jussi.kivilinna@iki.fi>
+ *
+ * This file is part of Libgcrypt.
+ *
+ * Libgcrypt is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * Libgcrypt is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
+ *
+ */
+
+#include <my_global.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#  define U64_C(c) (c ## UL)
+
+typedef uint32_t u32;
+typedef uint16_t u16;
+typedef uint64_t u64;
+#ifndef byte
+typedef uint8_t byte;
+#endif
+
+# define _gcry_bswap32 __builtin_bswap32
+
+#if __GNUC__ >= 4 && defined(__x86_64__)
+
+#if defined(_GCRY_GCC_VERSION) && _GCRY_GCC_VERSION >= 40400 /* 4.4 */
+/* Prevent compiler from issuing SSE instructions between asm blocks. */
+#  pragma GCC target("no-sse")
+#endif
+
+
+#define ALIGNED_16 __attribute__ ((aligned (16)))
+
+
+struct u16_unaligned_s
+{
+  u16 a;
+} __attribute__((packed, aligned (1), may_alias));
+
+
+/* Constants structure for generic reflected/non-reflected CRC32 CLMUL
+ * functions. */
+struct crc32_consts_s
+{
+  /* k: { x^(32*17), x^(32*15), x^(32*5), x^(32*3), x^(32*2), 0 } mod P(x) */
+  u64 k[6];
+  /* my_p: { floor(x^64 / P(x)), P(x) } */
+  u64 my_p[2];
+};
+
+
+/* CLMUL constants for CRC32 and CRC32RFC1510. */
+static const struct crc32_consts_s crc32_consts ALIGNED_16 =
+{
+  { /* k[6] = reverse_33bits( x^(32*y) mod P(x) ) */
+    U64_C(0x154442bd4), U64_C(0x1c6e41596), /* y = { 17, 15 } */
+    U64_C(0x1751997d0), U64_C(0x0ccaa009e), /* y = { 5, 3 } */
+    U64_C(0x163cd6124), 0                   /* y = 2 */
+  },
+  { /* my_p[2] = reverse_33bits ( { floor(x^64 / P(x)), P(x) } ) */
+    U64_C(0x1f7011641), U64_C(0x1db710641)
+  }
+};
+
+/* Common constants for CRC32 algorithms. */
+static const byte crc32_refl_shuf_shift[3 * 16] ALIGNED_16 =
+  {
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  };
+static const byte crc32_partial_fold_input_mask[16 + 16] ALIGNED_16 =
+  {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  };
+static const u64 crc32_merge9to15_shuf[15 - 9 + 1][2] ALIGNED_16 =
+  {
+    { U64_C(0x0706050403020100), U64_C(0xffffffffffffff0f) }, /* 9 */
+    { U64_C(0x0706050403020100), U64_C(0xffffffffffff0f0e) },
+    { U64_C(0x0706050403020100), U64_C(0xffffffffff0f0e0d) },
+    { U64_C(0x0706050403020100), U64_C(0xffffffff0f0e0d0c) },
+    { U64_C(0x0706050403020100), U64_C(0xffffff0f0e0d0c0b) },
+    { U64_C(0x0706050403020100), U64_C(0xffff0f0e0d0c0b0a) },
+    { U64_C(0x0706050403020100), U64_C(0xff0f0e0d0c0b0a09) }, /* 15 */
+  };
+static const u64 crc32_merge5to7_shuf[7 - 5 + 1][2] ALIGNED_16 =
+  {
+    { U64_C(0xffffff0703020100), U64_C(0xffffffffffffffff) }, /* 5 */
+    { U64_C(0xffff070603020100), U64_C(0xffffffffffffffff) },
+    { U64_C(0xff07060503020100), U64_C(0xffffffffffffffff) }, /* 7 */
+  };
+
+/* PCLMUL functions for reflected CRC32. */
+static inline void
+crc32_reflected_bulk (u32 *pcrc, const byte *inbuf, size_t inlen,
+		      const struct crc32_consts_s *consts)
+{
+  if (inlen >= 8 * 16)
+    {
+      asm volatile ("movd %[crc], %%xmm4\n\t"
+		    "movdqu %[inbuf_0], %%xmm0\n\t"
+		    "movdqu %[inbuf_1], %%xmm1\n\t"
+		    "movdqu %[inbuf_2], %%xmm2\n\t"
+		    "movdqu %[inbuf_3], %%xmm3\n\t"
+		    "pxor %%xmm4, %%xmm0\n\t"
+		    :
+		    : [inbuf_0] "m" (inbuf[0 * 16]),
+		      [inbuf_1] "m" (inbuf[1 * 16]),
+		      [inbuf_2] "m" (inbuf[2 * 16]),
+		      [inbuf_3] "m" (inbuf[3 * 16]),
+		      [crc] "m" (*pcrc)
+		    );
+
+      inbuf += 4 * 16;
+      inlen -= 4 * 16;
+
+      asm volatile ("movdqa %[k1k2], %%xmm4\n\t"
+		    :
+		    : [k1k2] "m" (consts->k[1 - 1])
+		    );
+
+      /* Fold by 4. */
+      while (inlen >= 4 * 16)
+	{
+	  asm volatile ("movdqu %[inbuf_0], %%xmm5\n\t"
+			"movdqa %%xmm0, %%xmm6\n\t"
+			"pclmulqdq $0x00, %%xmm4, %%xmm0\n\t"
+			"pclmulqdq $0x11, %%xmm4, %%xmm6\n\t"
+			"pxor %%xmm5, %%xmm0\n\t"
+			"pxor %%xmm6, %%xmm0\n\t"
+
+			"movdqu %[inbuf_1], %%xmm5\n\t"
+			"movdqa %%xmm1, %%xmm6\n\t"
+			"pclmulqdq $0x00, %%xmm4, %%xmm1\n\t"
+			"pclmulqdq $0x11, %%xmm4, %%xmm6\n\t"
+			"pxor %%xmm5, %%xmm1\n\t"
+			"pxor %%xmm6, %%xmm1\n\t"
+
+			"movdqu %[inbuf_2], %%xmm5\n\t"
+			"movdqa %%xmm2, %%xmm6\n\t"
+			"pclmulqdq $0x00, %%xmm4, %%xmm2\n\t"
+			"pclmulqdq $0x11, %%xmm4, %%xmm6\n\t"
+			"pxor %%xmm5, %%xmm2\n\t"
+			"pxor %%xmm6, %%xmm2\n\t"
+
+			"movdqu %[inbuf_3], %%xmm5\n\t"
+			"movdqa %%xmm3, %%xmm6\n\t"
+			"pclmulqdq $0x00, %%xmm4, %%xmm3\n\t"
+			"pclmulqdq $0x11, %%xmm4, %%xmm6\n\t"
+			"pxor %%xmm5, %%xmm3\n\t"
+			"pxor %%xmm6, %%xmm3\n\t"
+			:
+			: [inbuf_0] "m" (inbuf[0 * 16]),
+			  [inbuf_1] "m" (inbuf[1 * 16]),
+			  [inbuf_2] "m" (inbuf[2 * 16]),
+			  [inbuf_3] "m" (inbuf[3 * 16])
+			);
+
+	  inbuf += 4 * 16;
+	  inlen -= 4 * 16;
+	}
+
+      asm volatile ("movdqa %[k3k4], %%xmm6\n\t"
+		    "movdqa %[my_p], %%xmm5\n\t"
+		    :
+		    : [k3k4] "m" (consts->k[3 - 1]),
+		      [my_p] "m" (consts->my_p[0])
+		    );
+
+      /* Fold 4 to 1. */
+
+      asm volatile ("movdqa %%xmm0, %%xmm4\n\t"
+		    "pclmulqdq $0x00, %%xmm6, %%xmm0\n\t"
+		    "pclmulqdq $0x11, %%xmm6, %%xmm4\n\t"
+		    "pxor %%xmm1, %%xmm0\n\t"
+		    "pxor %%xmm4, %%xmm0\n\t"
+
+		    "movdqa %%xmm0, %%xmm4\n\t"
+		    "pclmulqdq $0x00, %%xmm6, %%xmm0\n\t"
+		    "pclmulqdq $0x11, %%xmm6, %%xmm4\n\t"
+		    "pxor %%xmm2, %%xmm0\n\t"
+		    "pxor %%xmm4, %%xmm0\n\t"
+
+		    "movdqa %%xmm0, %%xmm4\n\t"
+		    "pclmulqdq $0x00, %%xmm6, %%xmm0\n\t"
+		    "pclmulqdq $0x11, %%xmm6, %%xmm4\n\t"
+		    "pxor %%xmm3, %%xmm0\n\t"
+		    "pxor %%xmm4, %%xmm0\n\t"
+		    :
+		    :
+		    );
+    }
+  else
+    {
+      asm volatile ("movd %[crc], %%xmm1\n\t"
+		    "movdqu %[inbuf], %%xmm0\n\t"
+		    "movdqa %[k3k4], %%xmm6\n\t"
+		    "pxor %%xmm1, %%xmm0\n\t"
+		    "movdqa %[my_p], %%xmm5\n\t"
+		    :
+		    : [inbuf] "m" (*inbuf),
+		      [crc] "m" (*pcrc),
+		      [k3k4] "m" (consts->k[3 - 1]),
+		      [my_p] "m" (consts->my_p[0])
+		    );
+
+      inbuf += 16;
+      inlen -= 16;
+    }
+
+  /* Fold by 1. */
+  if (inlen >= 16)
+    {
+      while (inlen >= 16)
+	{
+	  /* Load next block to XMM2. Fold XMM0 to XMM0:XMM1. */
+	  asm volatile ("movdqu %[inbuf], %%xmm2\n\t"
+			"movdqa %%xmm0, %%xmm1\n\t"
+			"pclmulqdq $0x00, %%xmm6, %%xmm0\n\t"
+			"pclmulqdq $0x11, %%xmm6, %%xmm1\n\t"
+			"pxor %%xmm2, %%xmm0\n\t"
+			"pxor %%xmm1, %%xmm0\n\t"
+			:
+			: [inbuf] "m" (*inbuf)
+			);
+
+	  inbuf += 16;
+	  inlen -= 16;
+	}
+    }
+
+  /* Partial fold. */
+  if (inlen)
+    {
+      /* Load last input and add padding zeros. */
+      asm volatile ("movdqu %[shr_shuf], %%xmm3\n\t"
+		    "movdqu %[shl_shuf], %%xmm4\n\t"
+		    "movdqu %[mask], %%xmm2\n\t"
+
+		    "movdqa %%xmm0, %%xmm1\n\t"
+		    "pshufb %%xmm4, %%xmm0\n\t"
+		    "movdqu %[inbuf], %%xmm4\n\t"
+		    "pshufb %%xmm3, %%xmm1\n\t"
+		    "pand %%xmm4, %%xmm2\n\t"
+		    "por %%xmm1, %%xmm2\n\t"
+
+		    "movdqa %%xmm0, %%xmm1\n\t"
+		    "pclmulqdq $0x00, %%xmm6, %%xmm0\n\t"
+		    "pclmulqdq $0x11, %%xmm6, %%xmm1\n\t"
+		    "pxor %%xmm2, %%xmm0\n\t"
+		    "pxor %%xmm1, %%xmm0\n\t"
+		    :
+		    : [inbuf] "m" (*(inbuf - 16 + inlen)),
+		      [mask] "m" (crc32_partial_fold_input_mask[inlen]),
+		      [shl_shuf] "m" (crc32_refl_shuf_shift[inlen]),
+		      [shr_shuf] "m" (crc32_refl_shuf_shift[inlen + 16])
+		    );
+
+      inbuf += inlen;
+      inlen -= inlen;
+    }
+
+  /* Final fold. */
+  asm volatile (/* reduce 128-bits to 96-bits */
+		"movdqa %%xmm0, %%xmm1\n\t"
+		"pclmulqdq $0x10, %%xmm6, %%xmm0\n\t"
+		"psrldq $8, %%xmm1\n\t"
+		"pxor %%xmm1, %%xmm0\n\t"
+
+		/* reduce 96-bits to 64-bits */
+		"pshufd $0xfc, %%xmm0, %%xmm1\n\t" /* [00][00][00][x] */
+		"pshufd $0xf9, %%xmm0, %%xmm0\n\t" /* [00][00][x>>64][x>>32] */
+		"pclmulqdq $0x00, %[k5], %%xmm1\n\t" /* [00][00][xx][xx] */
+		"pxor %%xmm1, %%xmm0\n\t" /* top 64-bit are zero */
+
+		/* barrett reduction */
+		"pshufd $0xf3, %%xmm0, %%xmm1\n\t" /* [00][00][x>>32][00] */
+		"pslldq $4, %%xmm0\n\t" /* [??][x>>32][??][??] */
+		"pclmulqdq $0x00, %%xmm5, %%xmm1\n\t" /* [00][xx][xx][00] */
+		"pclmulqdq $0x10, %%xmm5, %%xmm1\n\t" /* [00][xx][xx][00] */
+		"pxor %%xmm1, %%xmm0\n\t"
+
+		/* store CRC */
+		"pextrd $2, %%xmm0, %[out]\n\t"
+		: [out] "=m" (*pcrc)
+		: [k5] "m" (consts->k[5 - 1])
+	        );
+}
+
+static inline void
+crc32_reflected_less_than_16 (u32 *pcrc, const byte *inbuf, size_t inlen,
+			      const struct crc32_consts_s *consts)
+{
+  if (inlen < 4)
+    {
+      u32 crc = *pcrc;
+      u32 data;
+
+      asm volatile ("movdqa %[my_p], %%xmm5\n\t"
+		    :
+		    : [my_p] "m" (consts->my_p[0])
+		    );
+
+      if (inlen == 1)
+	{
+	  data = inbuf[0];
+	  data ^= crc;
+	  data <<= 24;
+	  crc >>= 8;
+	}
+      else if (inlen == 2)
+	{
+	  data = ((const struct u16_unaligned_s *)inbuf)->a;
+	  data ^= crc;
+	  data <<= 16;
+	  crc >>= 16;
+	}
+      else
+	{
+	  data = ((const struct u16_unaligned_s *)inbuf)->a;
+	  data |= ((u32) inbuf[2]) << 16;
+	  data ^= crc;
+	  data <<= 8;
+	  crc >>= 24;
+	}
+
+      /* Barrett reduction */
+      asm volatile ("movd %[in], %%xmm0\n\t"
+		    "movd %[crc], %%xmm1\n\t"
+
+		    "pclmulqdq $0x00, %%xmm5, %%xmm0\n\t" /* [00][00][xx][xx] */
+		    "psllq $32, %%xmm1\n\t"
+		    "pshufd $0xfc, %%xmm0, %%xmm0\n\t" /* [00][00][00][x] */
+		    "pclmulqdq $0x10, %%xmm5, %%xmm0\n\t" /* [00][00][xx][xx] */
+		    "pxor %%xmm1, %%xmm0\n\t"
+
+		    "pextrd $1, %%xmm0, %[out]\n\t"
+		    : [out] "=m" (*pcrc)
+		    : [in] "rm" (data),
+		      [crc] "rm" (crc)
+		    );
+    }
+  else if (inlen == 4)
+    {
+      /* Barrett reduction */
+      asm volatile ("movd %[crc], %%xmm1\n\t"
+		    "movd %[in], %%xmm0\n\t"
+		    "movdqa %[my_p], %%xmm5\n\t"
+		    "pxor %%xmm1, %%xmm0\n\t"
+
+		    "pclmulqdq $0x00, %%xmm5, %%xmm0\n\t" /* [00][00][xx][xx] */
+		    "pshufd $0xfc, %%xmm0, %%xmm0\n\t" /* [00][00][00][x] */
+		    "pclmulqdq $0x10, %%xmm5, %%xmm0\n\t" /* [00][00][xx][xx] */
+
+		    "pextrd $1, %%xmm0, %[out]\n\t"
+		    : [out] "=m" (*pcrc)
+		    : [in] "m" (*inbuf),
+		      [crc] "m" (*pcrc),
+		      [my_p] "m" (consts->my_p[0])
+		    );
+    }
+  else
+    {
+      asm volatile ("movdqu %[shuf], %%xmm4\n\t"
+		    "movd %[crc], %%xmm1\n\t"
+		    "movdqa %[my_p], %%xmm5\n\t"
+		    "movdqa %[k3k4], %%xmm6\n\t"
+		    :
+		    : [shuf] "m" (crc32_refl_shuf_shift[inlen]),
+		      [crc] "m" (*pcrc),
+		      [my_p] "m" (consts->my_p[0]),
+		      [k3k4] "m" (consts->k[3 - 1])
+		    );
+
+      if (inlen >= 8)
+	{
+	  asm volatile ("movq %[inbuf], %%xmm0\n\t"
+			:
+			: [inbuf] "m" (*inbuf)
+			);
+	  if (inlen > 8)
+	    {
+	      asm volatile (/*"pinsrq $1, %[inbuf_tail], %%xmm0\n\t"*/
+			    "movq %[inbuf_tail], %%xmm2\n\t"
+			    "punpcklqdq %%xmm2, %%xmm0\n\t"
+			    "pshufb %[merge_shuf], %%xmm0\n\t"
+			    :
+			    : [inbuf_tail] "m" (inbuf[inlen - 8]),
+			      [merge_shuf] "m"
+				(*crc32_merge9to15_shuf[inlen - 9])
+			    );
+	    }
+	}
+      else
+	{
+	  asm volatile ("movd %[inbuf], %%xmm0\n\t"
+			"pinsrd $1, %[inbuf_tail], %%xmm0\n\t"
+			"pshufb %[merge_shuf], %%xmm0\n\t"
+			:
+			: [inbuf] "m" (*inbuf),
+			  [inbuf_tail] "m" (inbuf[inlen - 4]),
+			  [merge_shuf] "m"
+			    (*crc32_merge5to7_shuf[inlen - 5])
+			);
+	}
+
+      /* Final fold. */
+      asm volatile ("pxor %%xmm1, %%xmm0\n\t"
+		    "pshufb %%xmm4, %%xmm0\n\t"
+
+		    /* reduce 128-bits to 96-bits */
+		    "movdqa %%xmm0, %%xmm1\n\t"
+		    "pclmulqdq $0x10, %%xmm6, %%xmm0\n\t"
+		    "psrldq $8, %%xmm1\n\t"
+		    "pxor %%xmm1, %%xmm0\n\t" /* top 32-bit are zero */
+
+		    /* reduce 96-bits to 64-bits */
+		    "pshufd $0xfc, %%xmm0, %%xmm1\n\t" /* [00][00][00][x] */
+		    "pshufd $0xf9, %%xmm0, %%xmm0\n\t" /* [00][00][x>>64][x>>32] */
+		    "pclmulqdq $0x00, %[k5], %%xmm1\n\t" /* [00][00][xx][xx] */
+		    "pxor %%xmm1, %%xmm0\n\t" /* top 64-bit are zero */
+
+		    /* barrett reduction */
+		    "pshufd $0xf3, %%xmm0, %%xmm1\n\t" /* [00][00][x>>32][00] */
+		    "pslldq $4, %%xmm0\n\t" /* [??][x>>32][??][??] */
+		    "pclmulqdq $0x00, %%xmm5, %%xmm1\n\t" /* [00][xx][xx][00] */
+		    "pclmulqdq $0x10, %%xmm5, %%xmm1\n\t" /* [00][xx][xx][00] */
+		    "pxor %%xmm1, %%xmm0\n\t"
+
+		    /* store CRC */
+		    "pextrd $2, %%xmm0, %[out]\n\t"
+		    : [out] "=m" (*pcrc)
+		    : [k5] "m" (consts->k[5 - 1])
+		    );
+    }
+}
+
+void
+crc32_intel_pclmul (u32 *pcrc, const byte *inbuf, size_t inlen)
+{
+  const struct crc32_consts_s *consts = &crc32_consts;
+#if defined(__x86_64__) && defined(__WIN64__)
+  char win64tmp[2 * 16];
+
+  /* XMM6-XMM7 need to be restored after use. */
+  asm volatile ("movdqu %%xmm6, 0*16(%0)\n\t"
+                "movdqu %%xmm7, 1*16(%0)\n\t"
+                :
+                : "r" (win64tmp)
+                : "memory");
+#endif
+
+  if (!inlen)
+    return;
+
+  if (inlen >= 16)
+    crc32_reflected_bulk(pcrc, inbuf, inlen, consts);
+  else
+    crc32_reflected_less_than_16(pcrc, inbuf, inlen, consts);
+
+#if defined(__x86_64__) && defined(__WIN64__)
+  /* Restore used registers. */
+  asm volatile("movdqu 0*16(%0), %%xmm6\n\t"
+               "movdqu 1*16(%0), %%xmm7\n\t"
+               :
+               : "r" (win64tmp)
+               : "memory");
+#endif
+}
+
+#ifdef __GNUC__
+int crc32_pclmul_enabled(void)
+{
+  int eax, ecx;
+  /* We assume that the CPUID instruction and its parameter 1 are available.
+  We do not support any precursors of the Intel 80486. */
+  asm("cpuid" : "=a"(eax), "=c"(ecx) : "0"(1) : "ebx", "edx");
+  return !(~ecx & (1 << 19 | 1 << 1));
+}
+#elif 0 /* defined _MSC_VER */ /* FIXME: implement the pclmul interface */
+#include <intrin.h>
+int crc32_pclmul_enabled(void)
+{
+  /* We assume that the CPUID instruction and its parameter 1 are available.
+  We do not support any precursors of the Intel 80486. */
+  int regs[4];
+  __cpuid(regs, 1);
+  return !(~regs[2] & (1 << 19 | 1 << 1));
+}
+#else
+int crc32_pclmul_enabled(void)
+{
+  return 0;
+}
+#endif
+
+unsigned int crc32_pclmul(unsigned int crc32, const void *buf, size_t len)
+{
+  crc32= ~crc32;
+  crc32_intel_pclmul(&crc32, buf, len);
+  return ~crc32;
+}
+#endif
diff --git a/mysys/crc32/pcc_crc32_constants.h b/mysys/crc32/pcc_crc32_constants.h
new file mode 100644
index 00000000000..2e07d2576ed
--- /dev/null
+++ b/mysys/crc32/pcc_crc32_constants.h
@@ -0,0 +1,1206 @@
+/*
+*
+* THIS FILE IS GENERATED WITH
+./crc32_constants -c -x -r 0x4c11db7 
+
+* This is from https://github.com/antonblanchard/crc32-vpmsum/
+* DO NOT MODIFY IT MANUALLY!
+*
+*/
+
+#define CRC 0x4c11db7
+#define CRC_XOR
+#define REFLECT
+#define MAX_SIZE    32768
+
+#ifndef __ASSEMBLER__
+#ifdef CRC_TABLE
+static const unsigned int crc_table[] = {
+	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+	0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+	0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+	0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+	0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+	0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+	0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+	0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+	0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+	0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+	0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+	0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+	0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+	0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+	0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+	0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+	0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+	0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+	0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+	0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+	0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+	0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+	0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+	0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+	0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+	0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+	0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+	0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+	0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+	0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+	0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+	0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+	0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+	0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+	0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+	0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+	0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+	0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+	0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+	0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+	0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+	0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+	0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+	0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+	0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+	0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+	0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+	0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+	0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+	0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+	0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+	0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+	0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+	0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+	0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+	0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+	0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+	0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+	0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+	0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+	0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,};
+
+#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 */
+		{ 0x0000000099ea94a8, 0x00000001651797d2 },
+		/* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
+		{ 0x00000000945a8420, 0x0000000021e0d56c },
+		/* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
+		{ 0x0000000030762706, 0x000000000f95ecaa },
+		/* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
+		{ 0x00000001a52fc582, 0x00000001ebd224ac },
+		/* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
+		{ 0x00000001a4a7167a, 0x000000000ccb97ca },
+		/* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
+		{ 0x000000000c18249a, 0x00000001006ec8a8 },
+		/* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
+		{ 0x00000000a924ae7c, 0x000000014f58f196 },
+		/* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
+		{ 0x00000001e12ccc12, 0x00000001a7192ca6 },
+		/* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
+		{ 0x00000000a0b9d4ac, 0x000000019a64bab2 },
+		/* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
+		{ 0x0000000095e8ddfe, 0x0000000014f4ed2e },
+		/* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
+		{ 0x00000000233fddc4, 0x000000011092b6a2 },
+		/* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
+		{ 0x00000001b4529b62, 0x00000000c8a1629c },
+		/* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
+		{ 0x00000001a7fa0e64, 0x000000017bf32e8e },
+		/* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
+		{ 0x00000001b5334592, 0x00000001f8cc6582 },
+		/* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
+		{ 0x000000011f8ee1b4, 0x000000008631ddf0 },
+		/* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
+		{ 0x000000006252e632, 0x000000007e5a76d0 },
+		/* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
+		{ 0x00000000ab973e84, 0x000000002b09b31c },
+		/* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
+		{ 0x000000007734f5ec, 0x00000001b2df1f84 },
+		/* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
+		{ 0x000000007c547798, 0x00000001d6f56afc },
+		/* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
+		{ 0x000000007ec40210, 0x00000001b9b5e70c },
+		/* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
+		{ 0x00000001ab1695a8, 0x0000000034b626d2 },
+		/* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
+		{ 0x0000000090494bba, 0x000000014c53479a },
+		/* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
+		{ 0x00000001123fb816, 0x00000001a6d179a4 },
+		/* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
+		{ 0x00000001e188c74c, 0x000000015abd16b4 },
+		/* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
+		{ 0x00000001c2d3451c, 0x00000000018f9852 },
+		/* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
+		{ 0x00000000f55cf1ca, 0x000000001fb3084a },
+		/* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
+		{ 0x00000001a0531540, 0x00000000c53dfb04 },
+		/* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
+		{ 0x0000000132cd7ebc, 0x00000000e10c9ad6 },
+		/* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
+		{ 0x0000000073ab7f36, 0x0000000025aa994a },
+		/* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
+		{ 0x0000000041aed1c2, 0x00000000fa3a74c4 },
+		/* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
+		{ 0x0000000136c53800, 0x0000000033eb3f40 },
+		/* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
+		{ 0x0000000126835a30, 0x000000017193f296 },
+		/* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
+		{ 0x000000006241b502, 0x0000000043f6c86a },
+		/* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
+		{ 0x00000000d5196ad4, 0x000000016b513ec6 },
+		/* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
+		{ 0x000000009cfa769a, 0x00000000c8f25b4e },
+		/* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
+		{ 0x00000000920e5df4, 0x00000001a45048ec },
+		/* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
+		{ 0x0000000169dc310e, 0x000000000c441004 },
+		/* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
+		{ 0x0000000009fc331c, 0x000000000e17cad6 },
+		/* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
+		{ 0x000000010d94a81e, 0x00000001253ae964 },
+		/* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
+		{ 0x0000000027a20ab2, 0x00000001d7c88ebc },
+		/* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
+		{ 0x0000000114f87504, 0x00000001e7ca913a },
+		/* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
+		{ 0x000000004b076d96, 0x0000000033ed078a },
+		/* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
+		{ 0x00000000da4d1e74, 0x00000000e1839c78 },
+		/* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
+		{ 0x000000001b81f672, 0x00000001322b267e },
+		/* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
+		{ 0x000000009367c988, 0x00000000638231b6 },
+		/* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
+		{ 0x00000001717214ca, 0x00000001ee7f16f4 },
+		/* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
+		{ 0x000000009f47d820, 0x0000000117d9924a },
+		/* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
+		{ 0x000000010d9a47d2, 0x00000000e1a9e0c4 },
+		/* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
+		{ 0x00000000a696c58c, 0x00000001403731dc },
+		/* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
+		{ 0x000000002aa28ec6, 0x00000001a5ea9682 },
+		/* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
+		{ 0x00000001fe18fd9a, 0x0000000101c5c578 },
+		/* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
+		{ 0x000000019d4fc1ae, 0x00000000dddf6494 },
+		/* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
+		{ 0x00000001ba0e3dea, 0x00000000f1c3db28 },
+		/* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
+		{ 0x0000000074b59a5e, 0x000000013112fb9c },
+		/* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
+		{ 0x00000000f2b5ea98, 0x00000000b680b906 },
+		/* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
+		{ 0x0000000187132676, 0x000000001a282932 },
+		/* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
+		{ 0x000000010a8c6ad4, 0x0000000089406e7e },
+		/* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
+		{ 0x00000001e21dfe70, 0x00000001def6be8c },
+		/* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
+		{ 0x00000001da0050e4, 0x0000000075258728 },
+		/* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
+		{ 0x00000000772172ae, 0x000000019536090a },
+		/* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
+		{ 0x00000000e47724aa, 0x00000000f2455bfc },
+		/* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
+		{ 0x000000003cd63ac4, 0x000000018c40baf4 },
+		/* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
+		{ 0x00000001bf47d352, 0x000000004cd390d4 },
+		/* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
+		{ 0x000000018dc1d708, 0x00000001e4ece95a },
+		/* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
+		{ 0x000000002d4620a4, 0x000000001a3ee918 },
+		/* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
+		{ 0x0000000058fd1740, 0x000000007c652fb8 },
+		/* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
+		{ 0x00000000dadd9bfc, 0x000000011c67842c },
+		/* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
+		{ 0x00000001ea2140be, 0x00000000254f759c },
+		/* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
+		{ 0x000000009de128ba, 0x000000007ece94ca },
+		/* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
+		{ 0x000000013ac3aa8e, 0x0000000038f258c2 },
+		/* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
+		{ 0x0000000099980562, 0x00000001cdf17b00 },
+		/* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
+		{ 0x00000001c1579c86, 0x000000011f882c16 },
+		/* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
+		{ 0x0000000068dbbf94, 0x0000000100093fc8 },
+		/* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
+		{ 0x000000004509fb04, 0x00000001cd684f16 },
+		/* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
+		{ 0x00000001202f6398, 0x000000004bc6a70a },
+		/* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
+		{ 0x000000013aea243e, 0x000000004fc7e8e4 },
+		/* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
+		{ 0x00000001b4052ae6, 0x0000000130103f1c },
+		/* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
+		{ 0x00000001cd2a0ae8, 0x0000000111b0024c },
+		/* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
+		{ 0x00000001fe4aa8b4, 0x000000010b3079da },
+		/* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
+		{ 0x00000001d1559a42, 0x000000010192bcc2 },
+		/* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
+		{ 0x00000001f3e05ecc, 0x0000000074838d50 },
+		/* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
+		{ 0x0000000104ddd2cc, 0x000000001b20f520 },
+		/* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
+		{ 0x000000015393153c, 0x0000000050c3590a },
+		/* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
+		{ 0x0000000057e942c6, 0x00000000b41cac8e },
+		/* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
+		{ 0x000000012c633850, 0x000000000c72cc78 },
+		/* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
+		{ 0x00000000ebcaae4c, 0x0000000030cdb032 },
+		/* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
+		{ 0x000000013ee532a6, 0x000000013e09fc32 },
+		/* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
+		{ 0x00000001bf0cbc7e, 0x000000001ed624d2 },
+		/* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
+		{ 0x00000000d50b7a5a, 0x00000000781aee1a },
+		/* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
+		{ 0x0000000002fca6e8, 0x00000001c4d8348c },
+		/* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
+		{ 0x000000007af40044, 0x0000000057a40336 },
+		/* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
+		{ 0x0000000016178744, 0x0000000085544940 },
+		/* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
+		{ 0x000000014c177458, 0x000000019cd21e80 },
+		/* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
+		{ 0x000000011b6ddf04, 0x000000013eb95bc0 },
+		/* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
+		{ 0x00000001f3e29ccc, 0x00000001dfc9fdfc },
+		/* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
+		{ 0x0000000135ae7562, 0x00000000cd028bc2 },
+		/* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
+		{ 0x0000000190ef812c, 0x0000000090db8c44 },
+		/* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
+		{ 0x0000000067a2c786, 0x000000010010a4ce },
+		/* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
+		{ 0x0000000048b9496c, 0x00000001c8f4c72c },
+		/* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
+		{ 0x000000015a422de6, 0x000000001c26170c },
+		/* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
+		{ 0x00000001ef0e3640, 0x00000000e3fccf68 },
+		/* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
+		{ 0x00000001006d2d26, 0x00000000d513ed24 },
+		/* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
+		{ 0x00000001170d56d6, 0x00000000141beada },
+		/* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
+		{ 0x00000000a5fb613c, 0x000000011071aea0 },
+		/* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
+		{ 0x0000000040bbf7fc, 0x000000012e19080a },
+		/* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
+		{ 0x000000016ac3a5b2, 0x0000000100ecf826 },
+		/* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
+		{ 0x00000000abf16230, 0x0000000069b09412 },
+		/* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
+		{ 0x00000001ebe23fac, 0x0000000122297bac },
+		/* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
+		{ 0x000000008b6a0894, 0x00000000e9e4b068 },
+		/* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
+		{ 0x00000001288ea478, 0x000000004b38651a },
+		/* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
+		{ 0x000000016619c442, 0x00000001468360e2 },
+		/* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
+		{ 0x0000000086230038, 0x00000000121c2408 },
+		/* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
+		{ 0x000000017746a756, 0x00000000da7e7d08 },
+		/* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
+		{ 0x0000000191b8f8f8, 0x00000001058d7652 },
+		/* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
+		{ 0x000000008e167708, 0x000000014a098a90 },
+		/* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
+		{ 0x0000000148b22d54, 0x0000000020dbe72e },
+		/* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
+		{ 0x0000000044ba2c3c, 0x000000011e7323e8 },
+		/* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
+		{ 0x00000000b54d2b52, 0x00000000d5d4bf94 },
+		/* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
+		{ 0x0000000005a4fd8a, 0x0000000199d8746c },
+		/* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
+		{ 0x0000000139f9fc46, 0x00000000ce9ca8a0 },
+		/* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
+		{ 0x000000015a1fa824, 0x00000000136edece },
+		/* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
+		{ 0x000000000a61ae4c, 0x000000019b92a068 },
+		/* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
+		{ 0x0000000145e9113e, 0x0000000071d62206 },
+		/* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
+		{ 0x000000006a348448, 0x00000000dfc50158 },
+		/* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
+		{ 0x000000004d80a08c, 0x00000001517626bc },
+		/* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
+		{ 0x000000014b6837a0, 0x0000000148d1e4fa },
+		/* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
+		{ 0x000000016896a7fc, 0x0000000094d8266e },
+		/* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
+		{ 0x000000014f187140, 0x00000000606c5e34 },
+		/* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
+		{ 0x000000019581b9da, 0x000000019766beaa },
+		/* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
+		{ 0x00000001091bc984, 0x00000001d80c506c },
+		/* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
+		{ 0x000000001067223c, 0x000000001e73837c },
+		/* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
+		{ 0x00000001ab16ea02, 0x0000000064d587de },
+		/* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
+		{ 0x000000013c4598a8, 0x00000000f4a507b0 },
+		/* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
+		{ 0x00000000b3735430, 0x0000000040e342fc },
+		/* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
+		{ 0x00000001bb3fc0c0, 0x00000001d5ad9c3a },
+		/* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
+		{ 0x00000001570ae19c, 0x0000000094a691a4 },
+		/* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
+		{ 0x00000001ea910712, 0x00000001271ecdfa },
+		/* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
+		{ 0x0000000167127128, 0x000000009e54475a },
+		/* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
+		{ 0x0000000019e790a2, 0x00000000c9c099ee },
+		/* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
+		{ 0x000000003788f710, 0x000000009a2f736c },
+		/* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
+		{ 0x00000001682a160e, 0x00000000bb9f4996 },
+		/* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
+		{ 0x000000007f0ebd2e, 0x00000001db688050 },
+		/* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
+		{ 0x000000002b032080, 0x00000000e9b10af4 },
+		/* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
+		{ 0x00000000cfd1664a, 0x000000012d4545e4 },
+		/* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
+		{ 0x00000000aa1181c2, 0x000000000361139c },
+		/* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
+		{ 0x00000000ddd08002, 0x00000001a5a1a3a8 },
+		/* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
+		{ 0x00000000e8dd0446, 0x000000006844e0b0 },
+		/* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
+		{ 0x00000001bbd94a00, 0x00000000c3762f28 },
+		/* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
+		{ 0x00000000ab6cd180, 0x00000001d26287a2 },
+		/* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
+		{ 0x0000000031803ce2, 0x00000001f6f0bba8 },
+		/* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
+		{ 0x0000000024f40b0c, 0x000000002ffabd62 },
+		/* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
+		{ 0x00000001ba1d9834, 0x00000000fb4516b8 },
+		/* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
+		{ 0x0000000104de61aa, 0x000000018cfa961c },
+		/* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
+		{ 0x0000000113e40d46, 0x000000019e588d52 },
+		/* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
+		{ 0x00000001415598a0, 0x00000001180f0bbc },
+		/* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
+		{ 0x00000000bf6c8c90, 0x00000000e1d9177a },
+		/* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
+		{ 0x00000001788b0504, 0x0000000105abc27c },
+		/* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
+		{ 0x0000000038385d02, 0x00000000972e4a58 },
+		/* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
+		{ 0x00000001b6c83844, 0x0000000183499a5e },
+		/* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
+		{ 0x0000000051061a8a, 0x00000001c96a8cca },
+		/* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
+		{ 0x000000017351388a, 0x00000001a1a5b60c },
+		/* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
+		{ 0x0000000132928f92, 0x00000000e4b6ac9c },
+		/* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
+		{ 0x00000000e6b4f48a, 0x00000001807e7f5a },
+		/* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
+		{ 0x0000000039d15e90, 0x000000017a7e3bc8 },
+		/* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
+		{ 0x00000000312d6074, 0x00000000d73975da },
+		/* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
+		{ 0x000000017bbb2cc4, 0x000000017375d038 },
+		/* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
+		{ 0x000000016ded3e18, 0x00000000193680bc },
+		/* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
+		{ 0x00000000f1638b16, 0x00000000999b06f6 },
+		/* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
+		{ 0x00000001d38b9ecc, 0x00000001f685d2b8 },
+		/* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
+		{ 0x000000018b8d09dc, 0x00000001f4ecbed2 },
+		/* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
+		{ 0x00000000e7bc27d2, 0x00000000ba16f1a0 },
+		/* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
+		{ 0x00000000275e1e96, 0x0000000115aceac4 },
+		/* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
+		{ 0x00000000e2e3031e, 0x00000001aeff6292 },
+		/* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
+		{ 0x00000001041c84d8, 0x000000009640124c },
+		/* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
+		{ 0x00000000706ce672, 0x0000000114f41f02 },
+		/* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
+		{ 0x000000015d5070da, 0x000000009c5f3586 },
+		/* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
+		{ 0x0000000038f9493a, 0x00000001878275fa },
+		/* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
+		{ 0x00000000a3348a76, 0x00000000ddc42ce8 },
+		/* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
+		{ 0x00000001ad0aab92, 0x0000000181d2c73a },
+		/* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
+		{ 0x000000019e85f712, 0x0000000141c9320a },
+		/* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
+		{ 0x000000005a871e76, 0x000000015235719a },
+		/* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
+		{ 0x000000017249c662, 0x00000000be27d804 },
+		/* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
+		{ 0x000000003a084712, 0x000000006242d45a },
+		/* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
+		{ 0x00000000ed438478, 0x000000009a53638e },
+		/* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
+		{ 0x00000000abac34cc, 0x00000001001ecfb6 },
+		/* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
+		{ 0x000000005f35ef3e, 0x000000016d7c2d64 },
+		/* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
+		{ 0x0000000047d6608c, 0x00000001d0ce46c0 },
+		/* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
+		{ 0x000000002d01470e, 0x0000000124c907b4 },
+		/* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
+		{ 0x0000000158bbc7b0, 0x0000000018a555ca },
+		/* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
+		{ 0x00000000c0a23e8e, 0x000000006b0980bc },
+		/* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
+		{ 0x00000001ebd85c88, 0x000000008bbba964 },
+		/* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
+		{ 0x000000019ee20bb2, 0x00000001070a5a1e },
+		/* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
+		{ 0x00000001acabf2d6, 0x000000002204322a },
+		/* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
+		{ 0x00000001b7963d56, 0x00000000a27524d0 },
+		/* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
+		{ 0x000000017bffa1fe, 0x0000000020b1e4ba },
+		/* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
+		{ 0x000000001f15333e, 0x0000000032cc27fc },
+		/* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
+		{ 0x000000018593129e, 0x0000000044dd22b8 },
+		/* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
+		{ 0x000000019cb32602, 0x00000000dffc9e0a },
+		/* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
+		{ 0x0000000142b05cc8, 0x00000001b7a0ed14 },
+		/* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
+		{ 0x00000001be49e7a4, 0x00000000c7842488 },
+		/* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
+		{ 0x0000000108f69d6c, 0x00000001c02a4fee },
+		/* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
+		{ 0x000000006c0971f0, 0x000000003c273778 },
+		/* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
+		{ 0x000000005b16467a, 0x00000001d63f8894 },
+		/* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
+		{ 0x00000001551a628e, 0x000000006be557d6 },
+		/* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
+		{ 0x000000019e42ea92, 0x000000006a7806ea },
+		/* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
+		{ 0x000000012fa83ff2, 0x000000016155aa0c },
+		/* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
+		{ 0x000000011ca9cde0, 0x00000000908650ac },
+		/* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
+		{ 0x00000000c8e5cd74, 0x00000000aa5a8084 },
+		/* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
+		{ 0x0000000096c27f0c, 0x0000000191bb500a },
+		/* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
+		{ 0x000000002baed926, 0x0000000064e9bed0 },
+		/* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
+		{ 0x000000017c8de8d2, 0x000000009444f302 },
+		/* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
+		{ 0x00000000d43d6068, 0x000000019db07d3c },
+		/* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
+		{ 0x00000000cb2c4b26, 0x00000001359e3e6e },
+		/* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
+		{ 0x0000000145b8da26, 0x00000001e4f10dd2 },
+		/* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
+		{ 0x000000018fff4b08, 0x0000000124f5735e },
+		/* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
+		{ 0x0000000150b58ed0, 0x0000000124760a4c },
+		/* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
+		{ 0x00000001549f39bc, 0x000000000f1fc186 },
+		/* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
+		{ 0x00000000ef4d2f42, 0x00000000150e4cc4 },
+		/* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
+		{ 0x00000001b1468572, 0x000000002a6204e8 },
+		/* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
+		{ 0x000000013d7403b2, 0x00000000beb1d432 },
+		/* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
+		{ 0x00000001a4681842, 0x0000000135f3f1f0 },
+		/* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
+		{ 0x0000000167714492, 0x0000000074fe2232 },
+		/* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
+		{ 0x00000001e599099a, 0x000000001ac6e2ba },
+		/* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
+		{ 0x00000000fe128194, 0x0000000013fca91e },
+		/* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
+		{ 0x0000000077e8b990, 0x0000000183f4931e },
+		/* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
+		{ 0x00000001a267f63a, 0x00000000b6d9b4e4 },
+		/* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
+		{ 0x00000001945c245a, 0x00000000b5188656 },
+		/* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
+		{ 0x0000000149002e76, 0x0000000027a81a84 },
+		/* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
+		{ 0x00000001bb8310a4, 0x0000000125699258 },
+		/* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
+		{ 0x000000019ec60bcc, 0x00000001b23de796 },
+		/* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
+		{ 0x000000012d8590ae, 0x00000000fe4365dc },
+		/* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
+		{ 0x0000000065b00684, 0x00000000c68f497a },
+		/* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
+		{ 0x000000015e5aeadc, 0x00000000fbf521ee },
+		/* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
+		{ 0x00000000b77ff2b0, 0x000000015eac3378 },
+		/* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
+		{ 0x0000000188da2ff6, 0x0000000134914b90 },
+		/* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
+		{ 0x0000000063da929a, 0x0000000016335cfe },
+		/* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
+		{ 0x00000001389caa80, 0x000000010372d10c },
+		/* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
+		{ 0x000000013db599d2, 0x000000015097b908 },
+		/* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
+		{ 0x0000000122505a86, 0x00000001227a7572 },
+		/* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
+		{ 0x000000016bd72746, 0x000000009a8f75c0 },
+		/* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
+		{ 0x00000001c3faf1d4, 0x00000000682c77a2 },
+		/* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
+		{ 0x00000001111c826c, 0x00000000231f091c },
+		/* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
+		{ 0x00000000153e9fb2, 0x000000007d4439f2 },
+		/* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
+		{ 0x000000002b1f7b60, 0x000000017e221efc },
+		/* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
+		{ 0x00000000b1dba570, 0x0000000167457c38 },
+		/* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
+		{ 0x00000001f6397b76, 0x00000000bdf081c4 },
+		/* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
+		{ 0x0000000156335214, 0x000000016286d6b0 },
+		/* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
+		{ 0x00000001d70e3986, 0x00000000c84f001c },
+		/* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
+		{ 0x000000003701a774, 0x0000000064efe7c0 },
+		/* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
+		{ 0x00000000ac81ef72, 0x000000000ac2d904 },
+		/* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
+		{ 0x0000000133212464, 0x00000000fd226d14 },
+		/* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
+		{ 0x00000000e4e45610, 0x000000011cfd42e0 },
+		/* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
+		{ 0x000000000c1bd370, 0x000000016e5a5678 },
+		/* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
+		{ 0x00000001a7b9e7a6, 0x00000001d888fe22 },
+		/* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
+		{ 0x000000007d657a10, 0x00000001af77fcd4 }
+#else /* __LITTLE_ENDIAN__ */
+		/* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
+		{ 0x00000001651797d2, 0x0000000099ea94a8 },
+		/* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
+		{ 0x0000000021e0d56c, 0x00000000945a8420 },
+		/* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
+		{ 0x000000000f95ecaa, 0x0000000030762706 },
+		/* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
+		{ 0x00000001ebd224ac, 0x00000001a52fc582 },
+		/* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
+		{ 0x000000000ccb97ca, 0x00000001a4a7167a },
+		/* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
+		{ 0x00000001006ec8a8, 0x000000000c18249a },
+		/* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
+		{ 0x000000014f58f196, 0x00000000a924ae7c },
+		/* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
+		{ 0x00000001a7192ca6, 0x00000001e12ccc12 },
+		/* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
+		{ 0x000000019a64bab2, 0x00000000a0b9d4ac },
+		/* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
+		{ 0x0000000014f4ed2e, 0x0000000095e8ddfe },
+		/* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
+		{ 0x000000011092b6a2, 0x00000000233fddc4 },
+		/* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
+		{ 0x00000000c8a1629c, 0x00000001b4529b62 },
+		/* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
+		{ 0x000000017bf32e8e, 0x00000001a7fa0e64 },
+		/* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
+		{ 0x00000001f8cc6582, 0x00000001b5334592 },
+		/* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
+		{ 0x000000008631ddf0, 0x000000011f8ee1b4 },
+		/* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
+		{ 0x000000007e5a76d0, 0x000000006252e632 },
+		/* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
+		{ 0x000000002b09b31c, 0x00000000ab973e84 },
+		/* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
+		{ 0x00000001b2df1f84, 0x000000007734f5ec },
+		/* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
+		{ 0x00000001d6f56afc, 0x000000007c547798 },
+		/* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
+		{ 0x00000001b9b5e70c, 0x000000007ec40210 },
+		/* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
+		{ 0x0000000034b626d2, 0x00000001ab1695a8 },
+		/* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
+		{ 0x000000014c53479a, 0x0000000090494bba },
+		/* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
+		{ 0x00000001a6d179a4, 0x00000001123fb816 },
+		/* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
+		{ 0x000000015abd16b4, 0x00000001e188c74c },
+		/* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
+		{ 0x00000000018f9852, 0x00000001c2d3451c },
+		/* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
+		{ 0x000000001fb3084a, 0x00000000f55cf1ca },
+		/* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
+		{ 0x00000000c53dfb04, 0x00000001a0531540 },
+		/* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
+		{ 0x00000000e10c9ad6, 0x0000000132cd7ebc },
+		/* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
+		{ 0x0000000025aa994a, 0x0000000073ab7f36 },
+		/* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
+		{ 0x00000000fa3a74c4, 0x0000000041aed1c2 },
+		/* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
+		{ 0x0000000033eb3f40, 0x0000000136c53800 },
+		/* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
+		{ 0x000000017193f296, 0x0000000126835a30 },
+		/* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
+		{ 0x0000000043f6c86a, 0x000000006241b502 },
+		/* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
+		{ 0x000000016b513ec6, 0x00000000d5196ad4 },
+		/* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
+		{ 0x00000000c8f25b4e, 0x000000009cfa769a },
+		/* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
+		{ 0x00000001a45048ec, 0x00000000920e5df4 },
+		/* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
+		{ 0x000000000c441004, 0x0000000169dc310e },
+		/* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
+		{ 0x000000000e17cad6, 0x0000000009fc331c },
+		/* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
+		{ 0x00000001253ae964, 0x000000010d94a81e },
+		/* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
+		{ 0x00000001d7c88ebc, 0x0000000027a20ab2 },
+		/* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
+		{ 0x00000001e7ca913a, 0x0000000114f87504 },
+		/* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
+		{ 0x0000000033ed078a, 0x000000004b076d96 },
+		/* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
+		{ 0x00000000e1839c78, 0x00000000da4d1e74 },
+		/* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
+		{ 0x00000001322b267e, 0x000000001b81f672 },
+		/* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
+		{ 0x00000000638231b6, 0x000000009367c988 },
+		/* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
+		{ 0x00000001ee7f16f4, 0x00000001717214ca },
+		/* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
+		{ 0x0000000117d9924a, 0x000000009f47d820 },
+		/* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
+		{ 0x00000000e1a9e0c4, 0x000000010d9a47d2 },
+		/* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
+		{ 0x00000001403731dc, 0x00000000a696c58c },
+		/* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
+		{ 0x00000001a5ea9682, 0x000000002aa28ec6 },
+		/* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
+		{ 0x0000000101c5c578, 0x00000001fe18fd9a },
+		/* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
+		{ 0x00000000dddf6494, 0x000000019d4fc1ae },
+		/* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
+		{ 0x00000000f1c3db28, 0x00000001ba0e3dea },
+		/* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
+		{ 0x000000013112fb9c, 0x0000000074b59a5e },
+		/* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
+		{ 0x00000000b680b906, 0x00000000f2b5ea98 },
+		/* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
+		{ 0x000000001a282932, 0x0000000187132676 },
+		/* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
+		{ 0x0000000089406e7e, 0x000000010a8c6ad4 },
+		/* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
+		{ 0x00000001def6be8c, 0x00000001e21dfe70 },
+		/* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
+		{ 0x0000000075258728, 0x00000001da0050e4 },
+		/* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
+		{ 0x000000019536090a, 0x00000000772172ae },
+		/* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
+		{ 0x00000000f2455bfc, 0x00000000e47724aa },
+		/* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
+		{ 0x000000018c40baf4, 0x000000003cd63ac4 },
+		/* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
+		{ 0x000000004cd390d4, 0x00000001bf47d352 },
+		/* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
+		{ 0x00000001e4ece95a, 0x000000018dc1d708 },
+		/* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
+		{ 0x000000001a3ee918, 0x000000002d4620a4 },
+		/* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
+		{ 0x000000007c652fb8, 0x0000000058fd1740 },
+		/* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
+		{ 0x000000011c67842c, 0x00000000dadd9bfc },
+		/* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
+		{ 0x00000000254f759c, 0x00000001ea2140be },
+		/* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
+		{ 0x000000007ece94ca, 0x000000009de128ba },
+		/* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
+		{ 0x0000000038f258c2, 0x000000013ac3aa8e },
+		/* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
+		{ 0x00000001cdf17b00, 0x0000000099980562 },
+		/* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
+		{ 0x000000011f882c16, 0x00000001c1579c86 },
+		/* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
+		{ 0x0000000100093fc8, 0x0000000068dbbf94 },
+		/* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
+		{ 0x00000001cd684f16, 0x000000004509fb04 },
+		/* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
+		{ 0x000000004bc6a70a, 0x00000001202f6398 },
+		/* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
+		{ 0x000000004fc7e8e4, 0x000000013aea243e },
+		/* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
+		{ 0x0000000130103f1c, 0x00000001b4052ae6 },
+		/* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
+		{ 0x0000000111b0024c, 0x00000001cd2a0ae8 },
+		/* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
+		{ 0x000000010b3079da, 0x00000001fe4aa8b4 },
+		/* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
+		{ 0x000000010192bcc2, 0x00000001d1559a42 },
+		/* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
+		{ 0x0000000074838d50, 0x00000001f3e05ecc },
+		/* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
+		{ 0x000000001b20f520, 0x0000000104ddd2cc },
+		/* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
+		{ 0x0000000050c3590a, 0x000000015393153c },
+		/* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
+		{ 0x00000000b41cac8e, 0x0000000057e942c6 },
+		/* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
+		{ 0x000000000c72cc78, 0x000000012c633850 },
+		/* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
+		{ 0x0000000030cdb032, 0x00000000ebcaae4c },
+		/* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
+		{ 0x000000013e09fc32, 0x000000013ee532a6 },
+		/* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
+		{ 0x000000001ed624d2, 0x00000001bf0cbc7e },
+		/* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
+		{ 0x00000000781aee1a, 0x00000000d50b7a5a },
+		/* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
+		{ 0x00000001c4d8348c, 0x0000000002fca6e8 },
+		/* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
+		{ 0x0000000057a40336, 0x000000007af40044 },
+		/* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
+		{ 0x0000000085544940, 0x0000000016178744 },
+		/* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
+		{ 0x000000019cd21e80, 0x000000014c177458 },
+		/* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
+		{ 0x000000013eb95bc0, 0x000000011b6ddf04 },
+		/* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
+		{ 0x00000001dfc9fdfc, 0x00000001f3e29ccc },
+		/* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
+		{ 0x00000000cd028bc2, 0x0000000135ae7562 },
+		/* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
+		{ 0x0000000090db8c44, 0x0000000190ef812c },
+		/* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
+		{ 0x000000010010a4ce, 0x0000000067a2c786 },
+		/* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
+		{ 0x00000001c8f4c72c, 0x0000000048b9496c },
+		/* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
+		{ 0x000000001c26170c, 0x000000015a422de6 },
+		/* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
+		{ 0x00000000e3fccf68, 0x00000001ef0e3640 },
+		/* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
+		{ 0x00000000d513ed24, 0x00000001006d2d26 },
+		/* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
+		{ 0x00000000141beada, 0x00000001170d56d6 },
+		/* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
+		{ 0x000000011071aea0, 0x00000000a5fb613c },
+		/* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
+		{ 0x000000012e19080a, 0x0000000040bbf7fc },
+		/* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
+		{ 0x0000000100ecf826, 0x000000016ac3a5b2 },
+		/* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
+		{ 0x0000000069b09412, 0x00000000abf16230 },
+		/* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
+		{ 0x0000000122297bac, 0x00000001ebe23fac },
+		/* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
+		{ 0x00000000e9e4b068, 0x000000008b6a0894 },
+		/* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
+		{ 0x000000004b38651a, 0x00000001288ea478 },
+		/* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
+		{ 0x00000001468360e2, 0x000000016619c442 },
+		/* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
+		{ 0x00000000121c2408, 0x0000000086230038 },
+		/* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
+		{ 0x00000000da7e7d08, 0x000000017746a756 },
+		/* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
+		{ 0x00000001058d7652, 0x0000000191b8f8f8 },
+		/* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
+		{ 0x000000014a098a90, 0x000000008e167708 },
+		/* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
+		{ 0x0000000020dbe72e, 0x0000000148b22d54 },
+		/* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
+		{ 0x000000011e7323e8, 0x0000000044ba2c3c },
+		/* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
+		{ 0x00000000d5d4bf94, 0x00000000b54d2b52 },
+		/* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
+		{ 0x0000000199d8746c, 0x0000000005a4fd8a },
+		/* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
+		{ 0x00000000ce9ca8a0, 0x0000000139f9fc46 },
+		/* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
+		{ 0x00000000136edece, 0x000000015a1fa824 },
+		/* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
+		{ 0x000000019b92a068, 0x000000000a61ae4c },
+		/* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
+		{ 0x0000000071d62206, 0x0000000145e9113e },
+		/* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
+		{ 0x00000000dfc50158, 0x000000006a348448 },
+		/* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
+		{ 0x00000001517626bc, 0x000000004d80a08c },
+		/* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
+		{ 0x0000000148d1e4fa, 0x000000014b6837a0 },
+		/* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
+		{ 0x0000000094d8266e, 0x000000016896a7fc },
+		/* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
+		{ 0x00000000606c5e34, 0x000000014f187140 },
+		/* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
+		{ 0x000000019766beaa, 0x000000019581b9da },
+		/* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
+		{ 0x00000001d80c506c, 0x00000001091bc984 },
+		/* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
+		{ 0x000000001e73837c, 0x000000001067223c },
+		/* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
+		{ 0x0000000064d587de, 0x00000001ab16ea02 },
+		/* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
+		{ 0x00000000f4a507b0, 0x000000013c4598a8 },
+		/* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
+		{ 0x0000000040e342fc, 0x00000000b3735430 },
+		/* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
+		{ 0x00000001d5ad9c3a, 0x00000001bb3fc0c0 },
+		/* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
+		{ 0x0000000094a691a4, 0x00000001570ae19c },
+		/* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
+		{ 0x00000001271ecdfa, 0x00000001ea910712 },
+		/* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
+		{ 0x000000009e54475a, 0x0000000167127128 },
+		/* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
+		{ 0x00000000c9c099ee, 0x0000000019e790a2 },
+		/* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
+		{ 0x000000009a2f736c, 0x000000003788f710 },
+		/* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
+		{ 0x00000000bb9f4996, 0x00000001682a160e },
+		/* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
+		{ 0x00000001db688050, 0x000000007f0ebd2e },
+		/* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
+		{ 0x00000000e9b10af4, 0x000000002b032080 },
+		/* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
+		{ 0x000000012d4545e4, 0x00000000cfd1664a },
+		/* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
+		{ 0x000000000361139c, 0x00000000aa1181c2 },
+		/* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
+		{ 0x00000001a5a1a3a8, 0x00000000ddd08002 },
+		/* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
+		{ 0x000000006844e0b0, 0x00000000e8dd0446 },
+		/* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
+		{ 0x00000000c3762f28, 0x00000001bbd94a00 },
+		/* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
+		{ 0x00000001d26287a2, 0x00000000ab6cd180 },
+		/* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
+		{ 0x00000001f6f0bba8, 0x0000000031803ce2 },
+		/* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
+		{ 0x000000002ffabd62, 0x0000000024f40b0c },
+		/* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
+		{ 0x00000000fb4516b8, 0x00000001ba1d9834 },
+		/* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
+		{ 0x000000018cfa961c, 0x0000000104de61aa },
+		/* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
+		{ 0x000000019e588d52, 0x0000000113e40d46 },
+		/* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
+		{ 0x00000001180f0bbc, 0x00000001415598a0 },
+		/* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
+		{ 0x00000000e1d9177a, 0x00000000bf6c8c90 },
+		/* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
+		{ 0x0000000105abc27c, 0x00000001788b0504 },
+		/* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
+		{ 0x00000000972e4a58, 0x0000000038385d02 },
+		/* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
+		{ 0x0000000183499a5e, 0x00000001b6c83844 },
+		/* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
+		{ 0x00000001c96a8cca, 0x0000000051061a8a },
+		/* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
+		{ 0x00000001a1a5b60c, 0x000000017351388a },
+		/* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
+		{ 0x00000000e4b6ac9c, 0x0000000132928f92 },
+		/* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
+		{ 0x00000001807e7f5a, 0x00000000e6b4f48a },
+		/* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
+		{ 0x000000017a7e3bc8, 0x0000000039d15e90 },
+		/* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
+		{ 0x00000000d73975da, 0x00000000312d6074 },
+		/* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
+		{ 0x000000017375d038, 0x000000017bbb2cc4 },
+		/* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
+		{ 0x00000000193680bc, 0x000000016ded3e18 },
+		/* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
+		{ 0x00000000999b06f6, 0x00000000f1638b16 },
+		/* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
+		{ 0x00000001f685d2b8, 0x00000001d38b9ecc },
+		/* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
+		{ 0x00000001f4ecbed2, 0x000000018b8d09dc },
+		/* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
+		{ 0x00000000ba16f1a0, 0x00000000e7bc27d2 },
+		/* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
+		{ 0x0000000115aceac4, 0x00000000275e1e96 },
+		/* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
+		{ 0x00000001aeff6292, 0x00000000e2e3031e },
+		/* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
+		{ 0x000000009640124c, 0x00000001041c84d8 },
+		/* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
+		{ 0x0000000114f41f02, 0x00000000706ce672 },
+		/* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
+		{ 0x000000009c5f3586, 0x000000015d5070da },
+		/* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
+		{ 0x00000001878275fa, 0x0000000038f9493a },
+		/* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
+		{ 0x00000000ddc42ce8, 0x00000000a3348a76 },
+		/* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
+		{ 0x0000000181d2c73a, 0x00000001ad0aab92 },
+		/* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
+		{ 0x0000000141c9320a, 0x000000019e85f712 },
+		/* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
+		{ 0x000000015235719a, 0x000000005a871e76 },
+		/* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
+		{ 0x00000000be27d804, 0x000000017249c662 },
+		/* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
+		{ 0x000000006242d45a, 0x000000003a084712 },
+		/* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
+		{ 0x000000009a53638e, 0x00000000ed438478 },
+		/* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
+		{ 0x00000001001ecfb6, 0x00000000abac34cc },
+		/* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
+		{ 0x000000016d7c2d64, 0x000000005f35ef3e },
+		/* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
+		{ 0x00000001d0ce46c0, 0x0000000047d6608c },
+		/* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
+		{ 0x0000000124c907b4, 0x000000002d01470e },
+		/* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
+		{ 0x0000000018a555ca, 0x0000000158bbc7b0 },
+		/* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
+		{ 0x000000006b0980bc, 0x00000000c0a23e8e },
+		/* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
+		{ 0x000000008bbba964, 0x00000001ebd85c88 },
+		/* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
+		{ 0x00000001070a5a1e, 0x000000019ee20bb2 },
+		/* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
+		{ 0x000000002204322a, 0x00000001acabf2d6 },
+		/* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
+		{ 0x00000000a27524d0, 0x00000001b7963d56 },
+		/* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
+		{ 0x0000000020b1e4ba, 0x000000017bffa1fe },
+		/* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
+		{ 0x0000000032cc27fc, 0x000000001f15333e },
+		/* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
+		{ 0x0000000044dd22b8, 0x000000018593129e },
+		/* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
+		{ 0x00000000dffc9e0a, 0x000000019cb32602 },
+		/* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
+		{ 0x00000001b7a0ed14, 0x0000000142b05cc8 },
+		/* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
+		{ 0x00000000c7842488, 0x00000001be49e7a4 },
+		/* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
+		{ 0x00000001c02a4fee, 0x0000000108f69d6c },
+		/* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
+		{ 0x000000003c273778, 0x000000006c0971f0 },
+		/* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
+		{ 0x00000001d63f8894, 0x000000005b16467a },
+		/* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
+		{ 0x000000006be557d6, 0x00000001551a628e },
+		/* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
+		{ 0x000000006a7806ea, 0x000000019e42ea92 },
+		/* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
+		{ 0x000000016155aa0c, 0x000000012fa83ff2 },
+		/* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
+		{ 0x00000000908650ac, 0x000000011ca9cde0 },
+		/* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
+		{ 0x00000000aa5a8084, 0x00000000c8e5cd74 },
+		/* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
+		{ 0x0000000191bb500a, 0x0000000096c27f0c },
+		/* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
+		{ 0x0000000064e9bed0, 0x000000002baed926 },
+		/* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
+		{ 0x000000009444f302, 0x000000017c8de8d2 },
+		/* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
+		{ 0x000000019db07d3c, 0x00000000d43d6068 },
+		/* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
+		{ 0x00000001359e3e6e, 0x00000000cb2c4b26 },
+		/* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
+		{ 0x00000001e4f10dd2, 0x0000000145b8da26 },
+		/* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
+		{ 0x0000000124f5735e, 0x000000018fff4b08 },
+		/* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
+		{ 0x0000000124760a4c, 0x0000000150b58ed0 },
+		/* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
+		{ 0x000000000f1fc186, 0x00000001549f39bc },
+		/* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
+		{ 0x00000000150e4cc4, 0x00000000ef4d2f42 },
+		/* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
+		{ 0x000000002a6204e8, 0x00000001b1468572 },
+		/* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
+		{ 0x00000000beb1d432, 0x000000013d7403b2 },
+		/* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
+		{ 0x0000000135f3f1f0, 0x00000001a4681842 },
+		/* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
+		{ 0x0000000074fe2232, 0x0000000167714492 },
+		/* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
+		{ 0x000000001ac6e2ba, 0x00000001e599099a },
+		/* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
+		{ 0x0000000013fca91e, 0x00000000fe128194 },
+		/* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
+		{ 0x0000000183f4931e, 0x0000000077e8b990 },
+		/* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
+		{ 0x00000000b6d9b4e4, 0x00000001a267f63a },
+		/* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
+		{ 0x00000000b5188656, 0x00000001945c245a },
+		/* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
+		{ 0x0000000027a81a84, 0x0000000149002e76 },
+		/* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
+		{ 0x0000000125699258, 0x00000001bb8310a4 },
+		/* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
+		{ 0x00000001b23de796, 0x000000019ec60bcc },
+		/* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
+		{ 0x00000000fe4365dc, 0x000000012d8590ae },
+		/* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
+		{ 0x00000000c68f497a, 0x0000000065b00684 },
+		/* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
+		{ 0x00000000fbf521ee, 0x000000015e5aeadc },
+		/* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
+		{ 0x000000015eac3378, 0x00000000b77ff2b0 },
+		/* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
+		{ 0x0000000134914b90, 0x0000000188da2ff6 },
+		/* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
+		{ 0x0000000016335cfe, 0x0000000063da929a },
+		/* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
+		{ 0x000000010372d10c, 0x00000001389caa80 },
+		/* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
+		{ 0x000000015097b908, 0x000000013db599d2 },
+		/* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
+		{ 0x00000001227a7572, 0x0000000122505a86 },
+		/* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
+		{ 0x000000009a8f75c0, 0x000000016bd72746 },
+		/* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
+		{ 0x00000000682c77a2, 0x00000001c3faf1d4 },
+		/* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
+		{ 0x00000000231f091c, 0x00000001111c826c },
+		/* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
+		{ 0x000000007d4439f2, 0x00000000153e9fb2 },
+		/* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
+		{ 0x000000017e221efc, 0x000000002b1f7b60 },
+		/* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
+		{ 0x0000000167457c38, 0x00000000b1dba570 },
+		/* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
+		{ 0x00000000bdf081c4, 0x00000001f6397b76 },
+		/* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
+		{ 0x000000016286d6b0, 0x0000000156335214 },
+		/* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
+		{ 0x00000000c84f001c, 0x00000001d70e3986 },
+		/* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
+		{ 0x0000000064efe7c0, 0x000000003701a774 },
+		/* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
+		{ 0x000000000ac2d904, 0x00000000ac81ef72 },
+		/* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
+		{ 0x00000000fd226d14, 0x0000000133212464 },
+		/* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
+		{ 0x000000011cfd42e0, 0x00000000e4e45610 },
+		/* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
+		{ 0x000000016e5a5678, 0x000000000c1bd370 },
+		/* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
+		{ 0x00000001d888fe22, 0x00000001a7b9e7a6 },
+		/* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
+		{ 0x00000001af77fcd4, 0x000000007d657a10 }
+#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)  */
+		{ 0x99168a18ec447f11, 0xed837b2613e8221e },
+		/* x^1824 mod p(x) , x^1856 mod p(x) , x^1888 mod p(x) , x^1920 mod p(x)  */
+		{ 0xe23e954e8fd2cd3c, 0xc8acdd8147b9ce5a },
+		/* x^1696 mod p(x) , x^1728 mod p(x) , x^1760 mod p(x) , x^1792 mod p(x)  */
+		{ 0x92f8befe6b1d2b53, 0xd9ad6d87d4277e25 },
+		/* x^1568 mod p(x) , x^1600 mod p(x) , x^1632 mod p(x) , x^1664 mod p(x)  */
+		{ 0xf38a3556291ea462, 0xc10ec5e033fbca3b },
+		/* x^1440 mod p(x) , x^1472 mod p(x) , x^1504 mod p(x) , x^1536 mod p(x)  */
+		{ 0x974ac56262b6ca4b, 0xc0b55b0e82e02e2f },
+		/* x^1312 mod p(x) , x^1344 mod p(x) , x^1376 mod p(x) , x^1408 mod p(x)  */
+		{ 0x855712b3784d2a56, 0x71aa1df0e172334d },
+		/* x^1184 mod p(x) , x^1216 mod p(x) , x^1248 mod p(x) , x^1280 mod p(x)  */
+		{ 0xa5abe9f80eaee722, 0xfee3053e3969324d },
+		/* x^1056 mod p(x) , x^1088 mod p(x) , x^1120 mod p(x) , x^1152 mod p(x)  */
+		{ 0x1fa0943ddb54814c, 0xf44779b93eb2bd08 },
+		/* x^928 mod p(x) , x^960 mod p(x) , x^992 mod p(x) , x^1024 mod p(x)  */
+		{ 0xa53ff440d7bbfe6a, 0xf5449b3f00cc3374 },
+		/* x^800 mod p(x) , x^832 mod p(x) , x^864 mod p(x) , x^896 mod p(x)  */
+		{ 0xebe7e3566325605c, 0x6f8346e1d777606e },
+		/* x^672 mod p(x) , x^704 mod p(x) , x^736 mod p(x) , x^768 mod p(x)  */
+		{ 0xc65a272ce5b592b8, 0xe3ab4f2ac0b95347 },
+		/* x^544 mod p(x) , x^576 mod p(x) , x^608 mod p(x) , x^640 mod p(x)  */
+		{ 0x5705a9ca4721589f, 0xaa2215ea329ecc11 },
+		/* x^416 mod p(x) , x^448 mod p(x) , x^480 mod p(x) , x^512 mod p(x)  */
+		{ 0xe3720acb88d14467, 0x1ed8f66ed95efd26 },
+		/* x^288 mod p(x) , x^320 mod p(x) , x^352 mod p(x) , x^384 mod p(x)  */
+		{ 0xba1aca0315141c31, 0x78ed02d5a700e96a },
+		/* x^160 mod p(x) , x^192 mod p(x) , x^224 mod p(x) , x^256 mod p(x)  */
+		{ 0xad2a31b3ed627dae, 0xba8ccbe832b39da3 },
+		/* x^32 mod p(x) , x^64 mod p(x) , x^96 mod p(x) , x^128 mod p(x)  */
+		{ 0x6655004fa06a2517, 0xedb88320b1e6b092 }
+#else /* __LITTLE_ENDIAN__ */
+		/* x^1952 mod p(x) , x^1984 mod p(x) , x^2016 mod p(x) , x^2048 mod p(x)  */
+		{ 0xed837b2613e8221e, 0x99168a18ec447f11 },
+		/* x^1824 mod p(x) , x^1856 mod p(x) , x^1888 mod p(x) , x^1920 mod p(x)  */
+		{ 0xc8acdd8147b9ce5a, 0xe23e954e8fd2cd3c },
+		/* x^1696 mod p(x) , x^1728 mod p(x) , x^1760 mod p(x) , x^1792 mod p(x)  */
+		{ 0xd9ad6d87d4277e25, 0x92f8befe6b1d2b53 },
+		/* x^1568 mod p(x) , x^1600 mod p(x) , x^1632 mod p(x) , x^1664 mod p(x)  */
+		{ 0xc10ec5e033fbca3b, 0xf38a3556291ea462 },
+		/* x^1440 mod p(x) , x^1472 mod p(x) , x^1504 mod p(x) , x^1536 mod p(x)  */
+		{ 0xc0b55b0e82e02e2f, 0x974ac56262b6ca4b },
+		/* x^1312 mod p(x) , x^1344 mod p(x) , x^1376 mod p(x) , x^1408 mod p(x)  */
+		{ 0x71aa1df0e172334d, 0x855712b3784d2a56 },
+		/* x^1184 mod p(x) , x^1216 mod p(x) , x^1248 mod p(x) , x^1280 mod p(x)  */
+		{ 0xfee3053e3969324d, 0xa5abe9f80eaee722 },
+		/* x^1056 mod p(x) , x^1088 mod p(x) , x^1120 mod p(x) , x^1152 mod p(x)  */
+		{ 0xf44779b93eb2bd08, 0x1fa0943ddb54814c },
+		/* x^928 mod p(x) , x^960 mod p(x) , x^992 mod p(x) , x^1024 mod p(x)  */
+		{ 0xf5449b3f00cc3374, 0xa53ff440d7bbfe6a },
+		/* x^800 mod p(x) , x^832 mod p(x) , x^864 mod p(x) , x^896 mod p(x)  */
+		{ 0x6f8346e1d777606e, 0xebe7e3566325605c },
+		/* x^672 mod p(x) , x^704 mod p(x) , x^736 mod p(x) , x^768 mod p(x)  */
+		{ 0xe3ab4f2ac0b95347, 0xc65a272ce5b592b8 },
+		/* x^544 mod p(x) , x^576 mod p(x) , x^608 mod p(x) , x^640 mod p(x)  */
+		{ 0xaa2215ea329ecc11, 0x5705a9ca4721589f },
+		/* x^416 mod p(x) , x^448 mod p(x) , x^480 mod p(x) , x^512 mod p(x)  */
+		{ 0x1ed8f66ed95efd26, 0xe3720acb88d14467 },
+		/* x^288 mod p(x) , x^320 mod p(x) , x^352 mod p(x) , x^384 mod p(x)  */
+		{ 0x78ed02d5a700e96a, 0xba1aca0315141c31 },
+		/* x^160 mod p(x) , x^192 mod p(x) , x^224 mod p(x) , x^256 mod p(x)  */
+		{ 0xba8ccbe832b39da3, 0xad2a31b3ed627dae },
+		/* x^32 mod p(x) , x^64 mod p(x) , x^96 mod p(x) , x^128 mod p(x)  */
+		{ 0xedb88320b1e6b092, 0x6655004fa06a2517 }
+#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__
+		{ 0x00000001f7011641, 0x0000000000000000 },
+		{ 0x00000001db710641, 0x0000000000000000 }
+#else /* __LITTLE_ENDIAN__ */
+		{ 0x0000000000000000, 0x00000001f7011641 },
+		{ 0x0000000000000000, 0x00000001db710641 }
+#endif /* __LITTLE_ENDIAN__ */
+	};
+#endif /* POWER8_INTRINSICS */
+
+#endif /* __ASSEMBLER__ */
diff --git a/mysys/crc32/pcc_crc32c_constants.h b/mysys/crc32/pcc_crc32c_constants.h
new file mode 100644
index 00000000000..40b216b6057
--- /dev/null
+++ b/mysys/crc32/pcc_crc32c_constants.h
@@ -0,0 +1,1206 @@
+/*
+*
+* THIS FILE IS GENERATED WITH
+./crc32_constants -c -x -r 0x1edc6f41 
+
+* This is from https://github.com/antonblanchard/crc32-vpmsum/
+* DO NOT MODIFY IT MANUALLY!
+*
+*/
+
+#define CRC 0x1edc6f41
+#define CRC_XOR
+#define REFLECT
+#define MAX_SIZE    32768
+
+#ifndef __ASSEMBLER__
+#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 /* 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 */
+
+#endif /* __ASSEMBLER__ */
diff --git a/mysys/my_init.c b/mysys/my_init.c
index 4ae0cb9966c..cd9875017f0 100644
--- a/mysys/my_init.c
+++ b/mysys/my_init.c
@@ -59,7 +59,6 @@ static ulong atoi_octal(const char *str)
 MYSQL_FILE *mysql_stdin= NULL;
 static MYSQL_FILE instrumented_stdin;
 
-
 /**
   Initialize my_sys functions, resources and variables
 
@@ -101,6 +100,9 @@ my_bool my_init(void)
   /* Initialize our mutex handling */
   my_mutex_init();
 
+  /* Initialize CPU architecture specific hardware based crc32 optimization */
+  my_checksum_init();
+
   if (my_thread_global_init())
     return 1;