From 47c25acae2f51219326e1a4e79ef57ed99ab197a Mon Sep 17 00:00:00 2001
From: Gvozden Neskovic <neskovic@gmail.com>
Date: Mon, 15 Feb 2016 19:18:39 +0100
Subject: [PATCH] Implementation of vdev_raidz parity generate and reconstruct
 routines

- specialized gen/rec routines for all RAIDZ levels,
- new scalar raidz implementation (unrolled),
- two x86_64 SIMD implementations (SSE and AVX2 instructions sets),
- fastest routines selected on module load (benchmark).
- cmd/raidz_test - verify and benchmark all implementations against original

New zfs module parameters:
- zfs_raidz_math_impl (str): selects the implementation to use
    "fastest" - use the fastest math available
    "original" - use the original raidz code
    "cycle" - cycle trough all available impl for each new vdev_raidz
    "scalar" - new scalar impl
    "sse" - new SSE impl if available
    "avx2" - new AVX2 impl if available

see contents of /sys/module/zfs/parameters/zfs_raidz_math_impl to get list of supported
options.
---
 cmd/Makefile.am                      |    2 +-
 cmd/raidz_test/.gitignore            |    1 +
 cmd/raidz_test/Makefile.am           |   20 +
 cmd/raidz_test/raidz_bench.c         |  288 ++++
 cmd/raidz_test/raidz_test.c          |  606 +++++++
 cmd/raidz_test/raidz_test.h          |   80 +
 cmd/zdb/zdb.c                        |    1 +
 cmd/ztest/ztest.c                    |    1 +
 configure.ac                         |    1 +
 include/sys/Makefile.am              |    2 +
 include/sys/vdev_raidz.h             |   64 +
 include/sys/vdev_raidz_impl.h        |  262 +++
 lib/libspl/include/umem.h            |   17 +-
 lib/libzpool/Makefile.am             |    4 +
 module/zfs/Makefile.in               |    5 +
 module/zfs/spa_misc.c                |    3 +
 module/zfs/vdev_raidz.c              |  185 +-
 module/zfs/vdev_raidz_math.c         |  616 +++++++
 module/zfs/vdev_raidz_math_avx2.c    |  313 ++++
 module/zfs/vdev_raidz_math_impl.h    |  410 +++++
 module/zfs/vdev_raidz_math_scalar.c  |  659 +++++++
 module/zfs/vdev_raidz_math_sse.c     | 2385 ++++++++++++++++++++++++++
 module/zfs/vdev_raidz_math_x86simd.h |  512 ++++++
 23 files changed, 6280 insertions(+), 157 deletions(-)
 create mode 100644 cmd/raidz_test/.gitignore
 create mode 100644 cmd/raidz_test/Makefile.am
 create mode 100644 cmd/raidz_test/raidz_bench.c
 create mode 100644 cmd/raidz_test/raidz_test.c
 create mode 100644 cmd/raidz_test/raidz_test.h
 create mode 100644 include/sys/vdev_raidz.h
 create mode 100644 include/sys/vdev_raidz_impl.h
 create mode 100644 module/zfs/vdev_raidz_math.c
 create mode 100644 module/zfs/vdev_raidz_math_avx2.c
 create mode 100644 module/zfs/vdev_raidz_math_impl.h
 create mode 100644 module/zfs/vdev_raidz_math_scalar.c
 create mode 100644 module/zfs/vdev_raidz_math_sse.c
 create mode 100644 module/zfs/vdev_raidz_math_x86simd.h

diff --git a/cmd/Makefile.am b/cmd/Makefile.am
index 05f42a556bb5..04aa7c6333da 100644
--- a/cmd/Makefile.am
+++ b/cmd/Makefile.am
@@ -1,3 +1,3 @@
 SUBDIRS  = zfs zpool zdb zhack zinject zstreamdump ztest zpios
 SUBDIRS += mount_zfs fsck_zfs zvol_id vdev_id arcstat dbufstat zed
-SUBDIRS += arc_summary
+SUBDIRS += arc_summary raidz_test
diff --git a/cmd/raidz_test/.gitignore b/cmd/raidz_test/.gitignore
new file mode 100644
index 000000000000..f8b83d9cce03
--- /dev/null
+++ b/cmd/raidz_test/.gitignore
@@ -0,0 +1 @@
+/raidz_test
diff --git a/cmd/raidz_test/Makefile.am b/cmd/raidz_test/Makefile.am
new file mode 100644
index 000000000000..02cc746ec926
--- /dev/null
+++ b/cmd/raidz_test/Makefile.am
@@ -0,0 +1,20 @@
+include $(top_srcdir)/config/Rules.am
+
+AM_CFLAGS += $(DEBUG_STACKFLAGS) $(FRAME_LARGER_THAN)
+AM_CPPFLAGS += -DDEBUG
+
+DEFAULT_INCLUDES += \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/lib/libspl/include
+
+bin_PROGRAMS = raidz_test
+
+raidz_test_SOURCES = \
+	raidz_test.h \
+	raidz_test.c \
+	raidz_bench.c
+
+raidz_test_LDADD = \
+	$(top_builddir)/lib/libzpool/libzpool.la
+
+raidz_test_LDADD += -lm -ldl
diff --git a/cmd/raidz_test/raidz_bench.c b/cmd/raidz_test/raidz_bench.c
new file mode 100644
index 000000000000..d1e817250eb4
--- /dev/null
+++ b/cmd/raidz_test/raidz_bench.c
@@ -0,0 +1,288 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#include <sys/zfs_context.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/zio.h>
+#include <sys/vdev_raidz_impl.h>
+#include <stdio.h>
+
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include "raidz_test.h"
+
+#define	GEN_BENCH_MEMORY	(1ULL<<32)
+#define	REC_BENCH_MEMORY	(1ULL<<30)
+
+static zio_t zio_bench;
+static raidz_map_t *rm_bench;
+static size_t max_data_size;
+
+static void
+bench_init_raidz_map(void)
+{
+	max_data_size = (1ULL<<24) * rto_opts.rto_dcols;
+
+	if (rto_opts.rto_verbose) {
+		PRINT(DBLSEP);
+		PRINT("Initializing benchmark data ...\n\n");
+	}
+
+	zio_bench.io_offset = 0;
+	zio_bench.io_size = max_data_size;
+
+	/*
+	 * To permit larger column sizes these have to be done
+	 * allocated using aligned alloc instead of zio_data_buf_alloc
+	 */
+	zio_bench.io_data = umem_alloc_aligned(max_data_size, 512, UMEM_NOFAIL);
+
+	init_zio_data(&zio_bench);
+}
+
+static void
+bench_fini_raidz_maps(void)
+{
+	/* tear down golden zio */
+	umem_free(zio_bench.io_data, max_data_size);
+	bzero(&zio_bench, sizeof (zio_t));
+}
+
+static double
+get_time_diff(struct rusage *start, struct rusage *stop)
+{
+	return (((double)stop->ru_utime.tv_sec*1e6 +
+		(double)stop->ru_utime.tv_usec) -
+		((double)start->ru_utime.tv_sec*1e6 +
+		(double)start->ru_utime.tv_usec)) / 1e6;
+}
+
+static void
+run_gen_bench(void)
+{
+	raidz_math_ops_t *c_ops;
+	struct rusage start, stop;
+	size_t impl, fn, ds, iter_cnt, iter;
+	double elapsed, d_bw;
+
+	if (rto_opts.rto_verbose) {
+		PRINT(DBLSEP);
+		PRINT("Benchmarking parity generation...\n\n");
+	}
+
+	PRINT("impl, math, dcols, dsize, disk_bw, total_bw, iter\n");
+
+	/* benchmark original impl */
+	zfs_raidz_math_impl_set("original", NULL);
+
+	/* Benchmark generate functions */
+	for (fn = 0; fn < RAIDZ_GEN_NUM; fn++) {
+
+		for (ds = 9; ds <= MAX_DCSIZE; ds++) {
+
+			/* create suitable raidz_map */
+			zio_bench.io_size = (1ULL<<ds) * rto_opts.rto_dcols;
+			rm_bench = vdev_raidz_map_alloc(&zio_bench, 9,
+				rto_opts.rto_dcols + fn+1, fn+1);
+
+			/* guess iteration count */
+			iter_cnt = (GEN_BENCH_MEMORY) / zio_bench.io_size;
+
+			getrusage(RUSAGE_THREAD, &start);
+			for (iter = 0; iter < iter_cnt; iter++) {
+				vdev_raidz_generate_parity(rm_bench);
+			}
+			getrusage(RUSAGE_THREAD, &stop);
+
+			elapsed = get_time_diff(&start, &stop);
+			d_bw = (double)iter_cnt * (double)(1ULL<<ds);
+			d_bw /= (1024. * 1024. * elapsed);
+
+			PRINT("%10s, %8s, %zu, %10llu, %lf, %lf, %zu\n",
+				"original",
+				raidz_gen_name[fn],
+				rto_opts.rto_dcols,
+				(1ULL<<ds),
+				d_bw,
+				d_bw * (double)(rto_opts.rto_dcols+fn+1),
+				iter_cnt);
+
+			vdev_raidz_map_free(rm_bench);
+		}
+	}
+
+	/* benchmark new impl */
+	for (impl = 0; impl < raidz_supp_maths_cnt; impl++) {
+		c_ops = raidz_supp_maths[impl];
+
+		for (fn = 0; fn < RAIDZ_GEN_NUM; fn++) {
+
+			for (ds = 9; ds <= MAX_DCSIZE; ds++) {
+
+				/* create suitable raidz_map */
+				zio_bench.io_size = (1ULL<<ds);
+				zio_bench.io_size *= rto_opts.rto_dcols;
+				rm_bench = vdev_raidz_map_alloc(&zio_bench, 9,
+					rto_opts.rto_dcols + fn+1, fn+1);
+
+				/* guess iteration count */
+				iter_cnt = (GEN_BENCH_MEMORY) /
+					zio_bench.io_size;
+
+				getrusage(RUSAGE_THREAD, &start);
+				for (iter = 0; iter < iter_cnt; iter++) {
+					c_ops->gen[fn](rm_bench);
+				}
+				getrusage(RUSAGE_THREAD, &stop);
+
+				elapsed = get_time_diff(&start, &stop);
+				d_bw = (double)iter_cnt * (double)(1ULL<<ds);
+				d_bw /= (1024. * 1024. * elapsed);
+
+				PRINT("%10s, %8s, %zu, %10llu, %lf, %lf, %zu\n",
+					c_ops->name,
+					raidz_gen_name[fn],
+					rto_opts.rto_dcols,
+					(1ULL<<ds),
+					d_bw,
+					d_bw * (rto_opts.rto_dcols+fn+1),
+					iter_cnt);
+			}
+		}
+	}
+}
+
+static void
+run_rec_bench(void)
+{
+	raidz_math_ops_t *c_ops;
+	struct rusage start, stop;
+	size_t impl, fn, ds, iter_cnt, iter;
+	double elapsed, d_bw;
+	int tgx[3] = { 3, 4, 5};
+	size_t rec_disks[7] = {1, 1, 1, 2, 2, 2, 3};
+	int bench_rec_orig[7][3] = {
+		{1, 2, 3},
+		{0, 2, 3},
+		{0, 1, 3},
+		{2, 3, 4},
+		{1, 3, 4},
+		{0, 3, 4},
+		{3, 4, 5}
+	};
+
+	if (rto_opts.rto_verbose) {
+		PRINT(DBLSEP);
+		PRINT("Benchmarking data reconstruction...\n\n");
+	}
+
+	for (fn = 0; fn < RAIDZ_REC_NUM; fn++) {
+		for (ds = 9; ds <= MAX_DCSIZE; ds++) {
+			/* create suitable raidz_map */
+			zio_bench.io_size = (1ULL<<ds) * rto_opts.rto_dcols;
+			rm_bench = vdev_raidz_map_alloc(&zio_bench, 9,
+				rto_opts.rto_dcols + CODE_PQR, CODE_PQR);
+
+			/* guess iteration count */
+			iter_cnt = (REC_BENCH_MEMORY) / zio_bench.io_size;
+
+			getrusage(RUSAGE_THREAD, &start);
+			for (iter = 0; iter < iter_cnt; iter++) {
+				vdev_raidz_reconstruct(rm_bench,
+					bench_rec_orig[fn], 3);
+			}
+			getrusage(RUSAGE_THREAD, &stop);
+
+			elapsed = get_time_diff(&start, &stop);
+			d_bw = (double)iter_cnt * (double)(1ULL<<ds);
+			d_bw /= (1024. * 1024. * elapsed);
+
+			PRINT("%10s, %8s, %zu, %10llu, %lf, %lf, %zu\n",
+				"original",
+				raidz_rec_name[fn],
+				rto_opts.rto_dcols,
+				(1ULL<<ds),
+				d_bw,
+				d_bw * (rto_opts.rto_dcols+rec_disks[fn]),
+				iter_cnt);
+
+			vdev_raidz_map_free(rm_bench);
+		}
+	}
+
+	for (impl = 0; impl < raidz_supp_maths_cnt; impl++) {
+		c_ops = raidz_supp_maths[impl];
+
+		for (fn = 0; fn < RAIDZ_REC_NUM; fn++) {
+			for (ds = 9; ds <= MAX_DCSIZE; ds++) {
+				/* create suitable raidz_map */
+				zio_bench.io_size = (1ULL<<ds) *
+					rto_opts.rto_dcols;
+				rm_bench = vdev_raidz_map_alloc(&zio_bench, 9,
+					rto_opts.rto_dcols + CODE_PQR,
+					CODE_PQR);
+
+				/* guess iteration count */
+				iter_cnt = (REC_BENCH_MEMORY) /
+					zio_bench.io_size;
+
+				getrusage(RUSAGE_THREAD, &start);
+				for (iter = 0; iter < iter_cnt; iter++) {
+					c_ops->rec[fn](rm_bench, tgx);
+				}
+				getrusage(RUSAGE_THREAD, &stop);
+
+				elapsed = get_time_diff(&start, &stop);
+				d_bw = (double)iter_cnt * (double)(1ULL<<ds);
+				d_bw /= (1024. * 1024. * elapsed);
+
+				PRINT("%10s, %8s, %zu, %10llu, %lf, %lf, %zu\n",
+					c_ops->name,
+					raidz_rec_name[fn],
+					rto_opts.rto_dcols,
+					(1ULL<<ds),
+					d_bw,
+					d_bw * (rto_opts.rto_dcols +
+						rec_disks[fn]),
+					iter_cnt);
+
+				vdev_raidz_map_free(rm_bench);
+			}
+		}
+	}
+}
+
+void
+run_raidz_benchmark(void)
+{
+	bench_init_raidz_map();
+
+	run_gen_bench();
+	run_rec_bench();
+
+	bench_fini_raidz_maps();
+}
diff --git a/cmd/raidz_test/raidz_test.c b/cmd/raidz_test/raidz_test.c
new file mode 100644
index 000000000000..4b2503812e84
--- /dev/null
+++ b/cmd/raidz_test/raidz_test.c
@@ -0,0 +1,606 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#include <sys/zfs_context.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/zio.h>
+#include <sys/vdev_raidz_impl.h>
+#include <stdio.h>
+#ifdef __GNUC__
+#include <execinfo.h> /* for backtrace() */
+#endif
+#include "raidz_test.h"
+
+#define	BACKTRACE_SZ	100
+
+static void sig_handler(int signo)
+{
+	struct sigaction action;
+#ifdef __GNUC__ /* backtrace() is a GNU extension */
+	int nptrs;
+	void *buffer[BACKTRACE_SZ];
+
+	nptrs = backtrace(buffer, BACKTRACE_SZ);
+	backtrace_symbols_fd(buffer, nptrs, STDERR_FILENO);
+#endif
+
+	/*
+	 * Restore default action and re-raise signal so SIGSEGV and
+	 * SIGABRT can trigger a core dump.
+	 */
+	action.sa_handler = SIG_DFL;
+	sigemptyset(&action.sa_mask);
+	action.sa_flags = 0;
+	(void) sigaction(signo, &action, NULL);
+	raise(signo);
+}
+
+raidz_test_opts_t rto_opts;
+
+static void print_opts(void)
+{
+	char *verbose;
+	switch (rto_opts.rto_verbose) {
+		case 0:
+			verbose = "no";
+			break;
+		case 1:
+			verbose = "info";
+			break;
+		default:
+			verbose = "debug";
+			break;
+	}
+
+	PRINT(DBLSEP);
+	PRINT("Running with options:\n"
+	"  (-a) zio ashift              : %zu\n"
+	"  (-o) zio offset              : 1 << %zu\n"
+	"  (-d) number of DATA columns  : %zu\n"
+	"  (-s) size of DATA column     : 1 << %zu\n"
+	"  (-S) sweep parameters        : %s \n"
+	"  (-v) verbose                 : %s \n\n",
+	rto_opts.rto_ashift,				/* -a */
+	ilog2(rto_opts.rto_offset),			/* -o */
+	rto_opts.rto_dcols,					/* -d */
+	ilog2(rto_opts.rto_dcolsize),		/* -s */
+	rto_opts.rto_sweep ? "yes" : "no",	/* -S */
+	verbose 							/* -v */
+	);
+}
+
+static void usage(boolean_t requested)
+{
+	const raidz_test_opts_t *o = &rto_opts_defaults;
+
+	FILE *fp = requested ? stdout : stderr;
+
+	(void) fprintf(fp, "Usage:\n"
+	"\t[-a zio ashift (default: %zu)]\n"
+	"\t[-o zio offset, exponent radix 2 (default: %zu)]\n"
+	"\t[-d number of DATA columns (default: %zu)]\n"
+	"\t[-s size of single DATA column, exponent radix 2 (default: %zu)]\n"
+	"\t[-S parameter space sweep (default: %s)]\n"
+	"\t[-B benchmark all raidz implementations]\n"
+	"\t[-v increase verbosity (default: %zu)]\n"
+	"\t[-h] (print help)\n"
+	"",
+	o->rto_ashift,						/* -a */
+	ilog2(o->rto_offset),				/* -o */
+	o->rto_dcols,						/* -d */
+	ilog2(o->rto_dcolsize),				/* -s */
+	rto_opts.rto_sweep ? "yes" : "no",	/* -S */
+	o->rto_verbose						/* -d */
+	);
+
+	exit(requested ? 0 : 1);
+}
+
+static void process_options(int argc, char **argv)
+{
+	char *end;
+	size_t value;
+	int opt;
+
+	raidz_test_opts_t *o = &rto_opts;
+
+	bcopy(&rto_opts_defaults, o, sizeof (*o));
+
+	while ((opt = getopt(argc, argv,
+	    "BSvha:o:d:s:")) != EOF) {
+		value = 0;
+		switch (opt) {
+		case 'a':
+		case 'o':
+		case 'd':
+		case 's':
+			value = strtoull(optarg, &end, 0);
+		}
+
+		switch (opt) {
+		case 'a':
+			o->rto_ashift = MIN(12, MAX(9, value));
+			break;
+		case 'o':
+			o->rto_offset = ((1ULL << MIN(12, value)) >> 9) << 9;
+			break;
+		case 'd':
+			o->rto_dcols = MIN(255, MAX(1, value));
+			break;
+		case 's':
+			o->rto_dcolsize = 1ULL <<  MIN(24, MAX(9, value));
+			break;
+		case 'v':
+			o->rto_verbose++;
+			break;
+		case 'S':
+			o->rto_sweep++;
+			break;
+		case 'B':
+			o->rto_benchmark++;
+			break;
+		case 'h':
+			usage(B_TRUE);
+			break;
+		case '?':
+		default:
+			usage(B_FALSE);
+			break;
+		}
+	}
+}
+
+static zio_t zio_golden;
+static zio_t zio_test;
+static raidz_map_t *rm_golden;
+static raidz_map_t *rm_test;
+
+#define	D_INFO 1
+#define	D_DEBUG 2
+
+#define	DATA_COL(rm, i) ((rm)->rm_col[raidz_parity(rm) + (i)].rc_data)
+#define	DATA_COL_SIZE(rm, i) ((rm)->rm_col[raidz_parity(rm) + (i)].rc_size)
+
+#define	CODE_COL(rm, i) ((rm)->rm_col[(i)].rc_data)
+#define	CODE_COL_SIZE(rm, i) ((rm)->rm_col[(i)].rc_size)
+
+static int
+compare_raidz_maps_code(const raidz_map_t *rma, const raidz_map_t *rmb,
+	const int code)
+{
+	int i, eret = 0;
+
+	for (i = 0; i < code; i++) {
+		if (0 != memcmp(CODE_COL(rma, i), CODE_COL(rmb, i),
+			CODE_COL_SIZE(rma, i))) {
+			eret++;
+			if (rto_opts.rto_verbose > D_INFO) {
+				PRINT("\nparity block [%d] different!\n", i);
+			}
+		}
+	}
+	return (eret);
+}
+
+static int
+compare_raidz_maps_data(raidz_map_t *rm_golden, raidz_map_t *rm)
+{
+	int i, j, eret = 0;
+
+	for (i = 0; i < rto_opts.rto_dcols; i++) {
+		if (0 != memcmp(DATA_COL(rm_golden, i), DATA_COL(rm, i),
+			DATA_COL_SIZE(rm_golden, i))) {
+			eret++;
+			if (rto_opts.rto_verbose > D_INFO) {
+				PRINT("data block [%d] different!\n", i);
+			}
+			if (rto_opts.rto_verbose >= D_DEBUG) {
+				PRINT("golden: data blocks [%d]:\n", i);
+				for (j = 0; j < 16; j++)
+					PRINT("%.2x ",
+					((uint8_t *)DATA_COL(rm_golden, i))[j]);
+				PRINT("\ntest: data blocks [%d]:\n", i);
+				for (j = 0; j < 16; j++)
+					PRINT("%.2x ",
+					((uint8_t *)DATA_COL(rm, i))[j]);
+				PRINT("\n");
+			}
+		}
+	}
+	return (eret);
+}
+
+static void
+corrupt_raidz_map_data_colum(raidz_map_t *rm, int col)
+{
+	size_t i;
+
+	srand(getpid() - 1);
+
+	for (i = 0; i < DATA_COL_SIZE(rm, col) / sizeof (int); i++) {
+		((int *)(DATA_COL(rm, col)))[i] = rand();
+	}
+}
+
+void
+init_zio_data(zio_t *zio)
+{
+	size_t i;
+
+	srand(getpid());
+
+	for (i = 0; i < zio->io_size / sizeof (int); i++) {
+		((int *)(zio->io_data))[i] = rand();
+	}
+}
+
+static void
+init_raidz_maps(void)
+{
+	unsigned err = 0;
+	const size_t alloc_dsize = rto_opts.rto_dcolsize * rto_opts.rto_dcols;
+	const size_t total_ncols = rto_opts.rto_dcols + CODE_PQR;
+
+	PRINT(DBLSEP);
+	PRINT("initializing the golden copy ... ");
+
+	zio_golden.io_offset = zio_test.io_offset = 0;
+	zio_golden.io_size = zio_test.io_size = alloc_dsize;
+
+	/*
+	 * To permit larger column sizes these have to be done
+	 * allocated using aligned alloc instead of zio_data_buf_alloc
+	 */
+	zio_golden.io_data = umem_alloc_aligned(alloc_dsize, 32, UMEM_NOFAIL);
+	zio_test.io_data = umem_alloc_aligned(alloc_dsize, 32, UMEM_NOFAIL);
+
+	init_zio_data(&zio_golden);
+	init_zio_data(&zio_test);
+
+	zfs_raidz_math_impl_set("original", NULL);
+
+	rm_golden = vdev_raidz_map_alloc(&zio_golden, rto_opts.rto_ashift,
+		total_ncols, CODE_PQR);
+	rm_test = vdev_raidz_map_alloc(&zio_test, rto_opts.rto_ashift,
+		total_ncols, CODE_PQR);
+
+	vdev_raidz_generate_parity(rm_golden);
+	vdev_raidz_generate_parity(rm_test);
+
+	/* sanity check */
+	err |= compare_raidz_maps_data(rm_test, rm_golden);
+	err |= compare_raidz_maps_code(rm_test, rm_golden, CODE_PQR);
+
+	if (!err) {
+		PRINT("SUCCESS!\n");
+	} else {
+		PRINT("ERROR!\n");
+		exit(-1);
+	}
+
+	/* tear down raidz_map of test zio */
+	vdev_raidz_map_free(rm_test);
+}
+
+static void
+fini_raidz_maps(void)
+{
+	/* tear down golden zio */
+	vdev_raidz_map_free(rm_golden);
+	umem_free(zio_golden.io_data, zio_golden.io_size);
+	bzero(&zio_golden, sizeof (zio_t));
+
+	/* tear down test zio */
+	umem_free(zio_test.io_data, zio_test.io_size);
+	bzero(&zio_test, sizeof (zio_t));
+}
+
+
+static int
+run_gen_check(void)
+{
+	int impl, fn;
+	raidz_math_ops_t *c_ops;
+	int err = 0;
+
+	PRINT(DBLSEP);
+	PRINT("Testing parity generation...\n");
+
+	for (impl = 0; impl < raidz_supp_maths_cnt; impl++) {
+		c_ops = raidz_supp_maths[impl];
+
+	PRINT(SEP);
+		PRINT("\tTesting [%s] implementation...\n",
+			c_ops->name);
+
+
+		for (fn = 0; fn < RAIDZ_GEN_NUM; fn++) {
+
+			/* create suitable raidz_map */
+			rm_test = vdev_raidz_map_alloc(&zio_test,
+				rto_opts.rto_ashift, rto_opts.rto_dcols + fn+1,
+				fn+1);
+
+			PRINT("\t\tTesting method [%s] ...",
+				raidz_gen_name[fn]);
+
+			c_ops->gen[fn](rm_test);
+
+			if (0 == compare_raidz_maps_code(rm_test, rm_golden,
+				fn)) {
+				PRINT("SUCCESS\n");
+			} else {
+				PRINT("ERROR!\n");
+				err++;
+			}
+
+			vdev_raidz_map_free(rm_test);
+		}
+	}
+
+	return (err);
+}
+
+unsigned
+__run_rec_check(raidz_map_t *rm, const raidz_math_ops_t *impl,
+	const int fn)
+{
+	int x0, x1, x2;
+	int tgtidx[3];
+	int err = 0;
+
+	if (fn < RAIDZ_REC_PQ) {
+		/* can reconstruct 1 failed data disk */
+		for (x0 = 0; x0 < rto_opts.rto_dcols; x0++) {
+			tgtidx[0] = x0 + raidz_parity(rm);
+
+			if (rto_opts.rto_verbose >= D_INFO) {
+				PRINT("[%d] ", x0);
+			}
+
+			corrupt_raidz_map_data_colum(rm, x0);
+
+			impl->rec[fn](rm, tgtidx);
+
+			if (compare_raidz_maps_data(rm_golden, rm_test)) {
+				err++;
+				init_zio_data(&zio_test);
+
+				PRINT("\nReconstruction of data block [%d]"
+					" FAILED!\n", x0);
+			}
+		}
+
+	} else if (fn < RAIDZ_REC_PQR) {
+		/* can reconstruct 2 failed data disk */
+		for (x0 = 0; x0 < rto_opts.rto_dcols; x0++) {
+			for (x1 = x0 + 1; x1 < rto_opts.rto_dcols; x1++) {
+				tgtidx[0] = x0 + raidz_parity(rm);
+				tgtidx[1] = x1 + raidz_parity(rm);
+
+				if (rto_opts.rto_verbose >= D_INFO) {
+					PRINT("[%d %d] ",
+						x0, x1);
+				}
+
+				corrupt_raidz_map_data_colum(rm, x0);
+				corrupt_raidz_map_data_colum(rm, x1);
+
+				impl->rec[fn](rm, tgtidx);
+
+				err += compare_raidz_maps_data(rm_golden,
+					rm_test);
+				if (compare_raidz_maps_data(rm_golden,
+					rm_test)) {
+					err++;
+					init_zio_data(&zio_test);
+
+					(void) fprintf(stderr,
+						"\nReconstruction of data "
+						"blocks [%d %d] FAILED!\n",
+						x0, x1);
+				}
+			}
+		}
+	} else {
+		/* can reconstruct 3 failed data disk */
+		for (x0 = 0;
+			x0 < rto_opts.rto_dcols; x0++) {
+			for (x1 = x0 + 1;
+				x1 < rto_opts.rto_dcols; x1++) {
+				for (x2 = x1 + 1;
+					x2 < rto_opts.rto_dcols; x2++) {
+					tgtidx[0] = x0 + raidz_parity(rm);
+					tgtidx[1] = x1 + raidz_parity(rm);
+					tgtidx[2] = x2 + raidz_parity(rm);
+
+					if (rto_opts.rto_verbose >= D_INFO) {
+						PRINT("[%d %d %d]",
+							x0, x1, x2);
+					}
+
+					corrupt_raidz_map_data_colum(rm, x0);
+					corrupt_raidz_map_data_colum(rm, x1);
+					corrupt_raidz_map_data_colum(rm, x2);
+
+					impl->rec[fn](rm, tgtidx);
+
+					if (compare_raidz_maps_data(rm_golden,
+						rm_test)) {
+						err++;
+						init_zio_data(&zio_test);
+
+						PRINT("\nReconstruction of "
+							"data blocks [%d %d %d]"
+							" FAILED!\n",
+							x0, x1, x2);
+					}
+				}
+			}
+		}
+	}
+	return (err);
+}
+
+static int
+run_rec_check(void)
+{
+	int impl, fn;
+	raidz_math_ops_t *c_ops;
+	unsigned err = 0;
+
+	PRINT(DBLSEP);
+	PRINT("Testing data reconstruction...\n");
+
+	/* create suitable raidz_map */
+	rm_test = vdev_raidz_map_alloc(&zio_test, rto_opts.rto_ashift,
+		rto_opts.rto_dcols + CODE_PQR, CODE_PQR);
+	/* generate parity */
+	vdev_raidz_generate_parity(rm_test);
+
+	for (impl = 0; impl < raidz_supp_maths_cnt; impl++) {
+		c_ops = raidz_supp_maths[impl];
+
+		PRINT(SEP);
+		PRINT("\tTesting [%s] implementation...\n", c_ops->name);
+
+		for (fn = 0; fn < RAIDZ_REC_NUM; fn++) {
+
+			PRINT("\t\tTesting method [%s] ...",
+				raidz_rec_name[fn]);
+
+			if (0 == __run_rec_check(rm_test, c_ops, fn)) {
+				PRINT("SUCCESS\n");
+			} else {
+				err++;
+				PRINT("ERROR!\n");
+			}
+		}
+	}
+
+	/* tear down test raidz_map */
+	vdev_raidz_map_free(rm_test);
+
+	return (err);
+}
+
+static int
+run_test(void)
+{
+	int err = 0;
+
+	print_opts();
+	init_raidz_maps();
+
+	err |= run_gen_check();
+	err |= run_rec_check();
+
+	fini_raidz_maps();
+
+	return (err);
+}
+
+
+int
+main(int argc, char **argv)
+{
+	size_t zashift, zoffset, dcols, dcsize;
+	struct sigaction action;
+
+	action.sa_handler = sig_handler;
+	sigemptyset(&action.sa_mask);
+	action.sa_flags = 0;
+
+	if (sigaction(SIGSEGV, &action, NULL) < 0) {
+		(void) fprintf(stderr, "ztest: cannot catch SIGSEGV: %s.\n",
+		    strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	if (sigaction(SIGABRT, &action, NULL) < 0) {
+		(void) fprintf(stderr, "ztest: cannot catch SIGABRT: %s.\n",
+		    strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	(void) setvbuf(stdout, NULL, _IOLBF, 0);
+
+	dprintf_setup(&argc, argv);
+
+	process_options(argc, argv);
+
+	kernel_init(FREAD);
+
+	if (rto_opts.rto_benchmark) {
+		run_raidz_benchmark();
+		return (0);
+	}
+
+	if (rto_opts.rto_sweep) {
+		for (dcols = MIN_DCOLS;
+			dcols <= MAX_DCOLS;
+			dcols++) {
+			rto_opts.rto_dcols = dcols;
+			for (zashift = MIN_ASHIFT;
+				zashift <= MAX_ASHIFT;
+				zashift += 3) {
+				rto_opts.rto_ashift = zashift;
+				for (zoffset = MIN_OFFSET;
+					zoffset <= MAX_OFFSET;
+					zoffset += 1) {
+
+					rto_opts.rto_offset = 1ULL << zoffset;
+					if (rto_opts.rto_offset < 512)
+						rto_opts.rto_offset = 0;
+
+					for (dcsize = MIN_DCSIZE;
+						dcsize <= MAX_DCSIZE;
+						dcsize++) {
+						rto_opts.rto_dcolsize =
+							1ULL << dcsize;
+
+						if ((dcsize <
+							rto_opts.rto_ashift) ||
+							(rto_opts.rto_dcolsize <
+							rto_opts.rto_offset))
+							continue;
+
+						if (0 != run_test()) {
+							PRINT("\n Parameter "
+							"sweep test FAILED! "
+							"Exiting...\n");
+							exit(-1);
+						}
+					}
+				}
+			}
+		}
+	} else {
+		return (run_test());
+	}
+
+	return (0);
+}
diff --git a/cmd/raidz_test/raidz_test.h b/cmd/raidz_test/raidz_test.h
new file mode 100644
index 000000000000..2f589fd52430
--- /dev/null
+++ b/cmd/raidz_test/raidz_test.h
@@ -0,0 +1,80 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#ifndef	RAIDZ_TEST_H
+#define	RAIDZ_TEST_H
+
+#include <sys/spa.h>
+
+#define	MIN_ASHIFT	9
+#define	MAX_ASHIFT	12
+
+#define	MIN_OFFSET	8
+#define	MAX_OFFSET	12
+
+#define	MIN_DCOLS	1
+#define	MAX_DCOLS	16
+
+#define	MIN_DCSIZE	9
+#define	MAX_DCSIZE	24
+
+typedef struct raidz_test_opts {
+	size_t rto_ashift;
+	size_t rto_offset;
+	size_t rto_dcols;
+	size_t rto_dcolsize;
+	size_t rto_verbose;
+	size_t rto_sweep;
+
+	size_t rto_benchmark;
+} raidz_test_opts_t;
+
+static const raidz_test_opts_t rto_opts_defaults = {
+	.rto_ashift = 9,
+	.rto_offset = 1ULL << 0,
+	.rto_dcols = 8,
+	.rto_dcolsize = 1<<19,
+	.rto_verbose = 0,
+	.rto_sweep = 0,
+	.rto_benchmark = 0
+};
+
+extern raidz_test_opts_t rto_opts;
+
+static inline size_t ilog2(size_t a)
+{
+	return (a > 1 ? 1 + ilog2(a >> 1) : 0);
+}
+
+#define	PRINT(a...) (void) fprintf(stderr, a)
+#define	DBLSEP "================\n"
+#define	SEP    "----------------\n"
+
+
+void init_zio_data(zio_t *zio);
+
+void run_raidz_benchmark(void);
+
+#endif /* RAIDZ_TEST_H */
diff --git a/cmd/zdb/zdb.c b/cmd/zdb/zdb.c
index cbc98d24c2f8..37b128476986 100644
--- a/cmd/zdb/zdb.c
+++ b/cmd/zdb/zdb.c
@@ -42,6 +42,7 @@
 #include <sys/sa_impl.h>
 #include <sys/vdev.h>
 #include <sys/vdev_impl.h>
+#include <sys/vdev_raidz.h>
 #include <sys/metaslab_impl.h>
 #include <sys/dmu_objset.h>
 #include <sys/dsl_dir.h>
diff --git a/cmd/ztest/ztest.c b/cmd/ztest/ztest.c
index 42643ef5d063..cbab1638a0ff 100644
--- a/cmd/ztest/ztest.c
+++ b/cmd/ztest/ztest.c
@@ -103,6 +103,7 @@
 #include <sys/zil_impl.h>
 #include <sys/vdev_impl.h>
 #include <sys/vdev_file.h>
+#include <sys/vdev_raidz.h>
 #include <sys/spa_impl.h>
 #include <sys/metaslab_impl.h>
 #include <sys/dsl_prop.h>
diff --git a/configure.ac b/configure.ac
index 41cd00758119..23de633c6f3f 100644
--- a/configure.ac
+++ b/configure.ac
@@ -111,6 +111,7 @@ AC_CONFIG_FILES([
 	cmd/dbufstat/Makefile
 	cmd/arc_summary/Makefile
 	cmd/zed/Makefile
+	cmd/raidz_test/Makefile
 	contrib/Makefile
 	contrib/bash_completion.d/Makefile
 	contrib/dracut/Makefile
diff --git a/include/sys/Makefile.am b/include/sys/Makefile.am
index 73e86d03bb38..83cf5720220b 100644
--- a/include/sys/Makefile.am
+++ b/include/sys/Makefile.am
@@ -73,6 +73,8 @@ COMMON_H = \
 	$(top_srcdir)/include/sys/vdev_file.h \
 	$(top_srcdir)/include/sys/vdev.h \
 	$(top_srcdir)/include/sys/vdev_impl.h \
+	$(top_srcdir)/include/sys/vdev_raidz.h \
+	$(top_srcdir)/include/sys/vdev_raidz_impl.h \
 	$(top_srcdir)/include/sys/xvattr.h \
 	$(top_srcdir)/include/sys/zap.h \
 	$(top_srcdir)/include/sys/zap_impl.h \
diff --git a/include/sys/vdev_raidz.h b/include/sys/vdev_raidz.h
new file mode 100644
index 000000000000..0c136edb82ae
--- /dev/null
+++ b/include/sys/vdev_raidz.h
@@ -0,0 +1,64 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (C) 2016 Gvozden Neskovic <neskovic@compeng.uni-frankfurt.de>.
+ */
+
+#ifndef _SYS_VDEV_RAIDZ_H
+#define	_SYS_VDEV_RAIDZ_H
+
+#include <sys/isa_defs.h>
+
+#if defined(HAVE_SSE)
+#define	RAIDZ_SSE			1
+#if defined(__i386)
+#define	RAIDZ_SSE_x86		1
+#elif defined(__x86_64)
+#define	RAIDZ_SSE_x86_64	1
+#else
+#error "Unknown RAIDZ SSE implementation"
+#endif
+#endif /* defined(HAVE_SSE) */
+
+#if defined(HAVE_AVX2)
+#define	RAIDZ_AVX2			1
+#if defined(__i386)
+#define	RAIDZ_AVX2_x86		1
+#elif defined(__x86_64)
+#define	RAIDZ_AVX2_x86_64	1
+#else
+#error "Unknown RAIDZ AVX2 implementation"
+#endif
+#endif /* defined(HAVE_AVX2) */
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_VDEV_RAIDZ_H */
diff --git a/include/sys/vdev_raidz_impl.h b/include/sys/vdev_raidz_impl.h
new file mode 100644
index 000000000000..0f27cb6e1853
--- /dev/null
+++ b/include/sys/vdev_raidz_impl.h
@@ -0,0 +1,262 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#ifndef _VDEV_RAIDZ_H
+#define	_VDEV_RAIDZ_H
+
+#define	raidz_inline inline __attribute__((always_inline))
+
+#include <sys/types.h>
+#include <sys/debug.h>
+#include <sys/kstat.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#define	CODE_P	(0U)
+#define	CODE_Q	(1U)
+#define	CODE_R	(2U)
+
+#define	CODE_PQ		(CODE_P | CODE_Q)
+#define	CODE_PQR	(CODE_P | CODE_Q | CODE_R)
+
+enum raidz_math_gen_op {
+	RAIDZ_GEN_P = 0,
+	RAIDZ_GEN_PQ,
+	RAIDZ_GEN_PQR,
+	RAIDZ_GEN_NUM = 3
+};
+enum raidz_rec_op {
+	RAIDZ_REC_P = 0,
+	RAIDZ_REC_Q,
+	RAIDZ_REC_R,
+	RAIDZ_REC_PQ,
+	RAIDZ_REC_PR,
+	RAIDZ_REC_QR,
+	RAIDZ_REC_PQR,
+	RAIDZ_REC_NUM = 7
+};
+
+typedef struct raidz_math_ops raidz_math_ops_t_;
+
+typedef struct raidz_col {
+	size_t rc_devidx;	/* child device index for I/O */
+	size_t rc_offset;	/* device offset */
+	size_t rc_size;	/* I/O size */
+	void *rc_data;			/* I/O data */
+	void *rc_gdata;			/* used to store the "good" version */
+	int rc_error;			/* I/O error for this device */
+	unsigned int rc_tried;	/* Did we attempt this I/O column? */
+	unsigned int rc_skipped;	/* Did we skip this I/O column? */
+} raidz_col_t;
+
+typedef struct raidz_map {
+	size_t rm_cols;		/* Regular column count */
+	size_t rm_scols;		/* Count including skipped columns */
+	size_t rm_bigcols;	/* Number of oversized columns */
+	size_t rm_asize;		/* Actual total I/O size */
+	size_t rm_missingdata;	/* Count of missing data devices */
+	size_t rm_missingparity;	/* Count of missing parity devices */
+	size_t rm_firstdatacol;	/* First data column/parity count */
+	size_t rm_nskip;		/* Skipped sectors for padding */
+	size_t rm_skipstart;	/* Column index of padding start */
+	void *rm_datacopy;		/* rm_asize-buffer of copied data */
+	size_t rm_reports;	/* # of referencing checksum reports */
+	unsigned int rm_freed;		/* map no longer has referencing ZIO */
+	unsigned int rm_ecksuminjected;	/* checksum error was injected */
+	raidz_math_ops_t_ *rm_ops;	/* RAIDZ math operations */
+	raidz_col_t rm_col[1];		/* Flexible array of I/O columns */
+} raidz_map_t;
+
+
+typedef struct zio zio_t_;
+
+raidz_map_t * vdev_raidz_map_alloc(zio_t_ *zio, uint64_t unit_shift,
+	uint64_t dcols, uint64_t nparity);
+void vdev_raidz_map_free(raidz_map_t *rm);
+void vdev_raidz_generate_parity(raidz_map_t *rm);
+int vdev_raidz_reconstruct(raidz_map_t *rm, int *t, int nt);
+
+/* parity of the raidz block */
+static raidz_inline size_t raidz_parity(const raidz_map_t *rm)
+{
+	return (rm->rm_firstdatacol);
+}
+
+/* total number of columns */
+static raidz_inline size_t raidz_ncols(const raidz_map_t *rm)
+{
+	return (rm->rm_cols);
+}
+
+/* size of code columns */
+static raidz_inline size_t raidz_csize(const raidz_map_t *rm)
+{
+	ASSERT(rm->rm_col[0].rc_size ==
+		rm->rm_col[rm->rm_firstdatacol].rc_size);
+	return (rm->rm_col[0].rc_size);
+}
+
+/* size of the first data column */
+static raidz_inline size_t raidz_dsize(const raidz_map_t *rm)
+{
+	ASSERT(raidz_csize(rm) ==
+		rm->rm_col[rm->rm_firstdatacol].rc_size);
+	return (raidz_csize(rm));
+}
+
+/* size of the last data dolumn */
+static raidz_inline size_t raidz_ldsize(const raidz_map_t *rm)
+{
+	return (rm->rm_col[rm->rm_cols - 1].rc_size);
+}
+
+/* number of bigger data columns */
+static raidz_inline size_t raidz_nbigcols(const raidz_map_t *rm)
+{
+	size_t nbigdcols = 0;
+
+	if (rm->rm_bigcols == 0) {
+		nbigdcols = 0; /* all same size */
+	} else if (rm->rm_bigcols == rm->rm_cols) {
+		nbigdcols = 0; /* data doesn't span all columns */
+	} else if (rm->rm_bigcols < rm->rm_cols) {
+		nbigdcols = rm->rm_bigcols - raidz_parity(rm);
+
+		ASSERT(rm->rm_col[rm->rm_bigcols - 1].rc_size ==
+			raidz_csize(rm));
+		ASSERT(rm->rm_col[rm->rm_firstdatacol].rc_size ==
+			raidz_csize(rm));
+	} else {
+		nbigdcols = 0;
+	}
+
+	ASSERT((nbigdcols + raidz_parity(rm)) < raidz_ncols(rm));
+	return (nbigdcols + raidz_parity(rm));
+}
+
+#if !defined(_KERNEL)
+struct kernel_param {};
+#endif
+
+void vdev_raidz_math_init(void);
+void vdev_raidz_math_fini(void);
+int zfs_raidz_math_impl_set(const char *math, struct kernel_param *kp);
+
+/* testing interface for userspace */
+#if !defined(_KERNEL)
+void vdev_raidz_cycle_impl(unsigned int v);
+#endif
+
+void raidz_math_ops_init(raidz_map_t *rm);
+void raidz_math_generate(raidz_map_t *rm);
+int raidz_math_reconstruct(raidz_map_t *rm, const int *parity_valid,
+	const int *dt, const int nbaddata);
+
+extern const char *raidz_gen_name[RAIDZ_GEN_NUM];
+extern const char *raidz_rec_name[RAIDZ_REC_NUM];
+
+typedef struct raidz_math_ops_kstat {
+	kstat_named_t gen_kstat[RAIDZ_GEN_NUM];
+	kstat_named_t rec_kstat[RAIDZ_REC_NUM];
+} raidz_math_ops_kstat_t;
+
+typedef void (*raidz_gen_f)(raidz_map_t *rm);
+typedef int (*raidz_rec_f)(raidz_map_t *rm, const int *);
+typedef boolean_t (*will_work_f)(void);
+
+typedef struct raidz_math_ops {
+	raidz_gen_f gen[RAIDZ_GEN_NUM];
+	raidz_rec_f rec[RAIDZ_REC_NUM];
+	will_work_f is_supported;
+	char *name;
+} raidz_math_ops_t;
+
+extern size_t raidz_supp_maths_cnt;
+extern raidz_math_ops_t *raidz_supp_maths[];
+
+#define	RAIDZ_SCALAR_GEN_WRAP(code, impl) \
+static void	\
+impl ## _gen_ ## code(raidz_map_t *rm)\
+{\
+	raidz_generate_## code ## _impl(rm); \
+}
+
+#define	RAIDZ_SCALAR_REC_WRAP(code, impl) \
+static int \
+impl ## _rec_ ## code(raidz_map_t *rm, const int *tgtidx)	\
+{	\
+	return (raidz_reconstruct_## code ## _impl(rm, tgtidx));	\
+}
+
+
+#define	RAIDZ_x86SIMD_GEN_WRAP(code, impl) \
+static void	\
+impl ## _gen_ ## code(raidz_map_t *rm)\
+{\
+	kfpu_begin();\
+	raidz_generate_## code ## _impl(rm); \
+	kfpu_end();\
+}
+
+#define	RAIDZ_x86SIMD_REC_WRAP(code, impl) \
+static int \
+impl ## _rec_ ## code(raidz_map_t *rm, const int *tgtidx)\
+{	\
+	int code;\
+	kfpu_begin();\
+	code = raidz_reconstruct_## code ## _impl(rm, tgtidx);	\
+	kfpu_end();\
+	return (code);\
+}
+
+/*
+ * Powers of 2 in the Galois field defined above.
+ * Elements are repeated to seepd up vdev_raidz_exp2 function,
+ * (used in scalar reconstruction).
+ */
+extern const unsigned char vdev_raidz_pow2[511] __attribute__((aligned(256)));
+/* Logs of 2 in the Galois field defined above. */
+extern const unsigned char vdev_raidz_log2[256] __attribute__((aligned(256)));
+
+/*
+ * Multiply a given number by 2 raised to the given power.
+ */
+static inline unsigned char
+vdev_raidz_exp2(const unsigned char a, const unsigned char exp)
+{
+	if (a == 0) {
+		return (0);
+	} else {
+		return (vdev_raidz_pow2[exp + vdev_raidz_log2[a]]);
+	}
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* _VDEV_RAIDZ_H */
diff --git a/lib/libspl/include/umem.h b/lib/libspl/include/umem.h
index a89cb4950db2..30b0dc9607fe 100644
--- a/lib/libspl/include/umem.h
+++ b/lib/libspl/include/umem.h
@@ -79,17 +79,6 @@ typedef struct umem_cache {
 	int			cache_cflags;
 } umem_cache_t;
 
-static inline void *
-umem_alloc(size_t size, int flags)
-{
-	void *ptr = NULL;
-
-	do {
-		ptr = malloc(size);
-	} while (ptr == NULL && (flags & UMEM_NOFAIL));
-
-	return (ptr);
-}
 
 static inline void *
 umem_alloc_aligned(size_t size, size_t align, int flags)
@@ -112,6 +101,12 @@ umem_alloc_aligned(size_t size, size_t align, int flags)
 	return (ptr);
 }
 
+static inline void *
+umem_alloc(size_t size, int flags)
+{
+	return (umem_alloc_aligned(size, 32, flags));
+}
+
 static inline void *
 umem_zalloc(size_t size, int flags)
 {
diff --git a/lib/libzpool/Makefile.am b/lib/libzpool/Makefile.am
index f45a57d71fdf..ed17ccb0460e 100644
--- a/lib/libzpool/Makefile.am
+++ b/lib/libzpool/Makefile.am
@@ -90,6 +90,10 @@ KERNEL_C = \
 	vdev_missing.c \
 	vdev_queue.c \
 	vdev_raidz.c \
+	vdev_raidz_math.c \
+	vdev_raidz_math_scalar.c \
+	vdev_raidz_math_sse.c \
+	vdev_raidz_math_avx2.c \
 	vdev_root.c \
 	zap.c \
 	zap_leaf.c \
diff --git a/module/zfs/Makefile.in b/module/zfs/Makefile.in
index d3a0206c9f7a..39e58ebc6e22 100644
--- a/module/zfs/Makefile.in
+++ b/module/zfs/Makefile.in
@@ -69,6 +69,8 @@ $(MODULE)-objs += vdev_mirror.o
 $(MODULE)-objs += vdev_missing.o
 $(MODULE)-objs += vdev_queue.o
 $(MODULE)-objs += vdev_raidz.o
+$(MODULE)-objs += vdev_raidz_math.o
+$(MODULE)-objs += vdev_raidz_math_scalar.o
 $(MODULE)-objs += vdev_root.o
 $(MODULE)-objs += zap.o
 $(MODULE)-objs += zap_leaf.o
@@ -107,3 +109,6 @@ $(MODULE)-objs += zrlock.o
 $(MODULE)-objs += zvol.o
 $(MODULE)-objs += dsl_destroy.o
 $(MODULE)-objs += dsl_userhold.o
+
+$(MODULE)-$(CONFIG_X86) += vdev_raidz_math_sse.o
+$(MODULE)-$(CONFIG_X86) += vdev_raidz_math_avx2.o
diff --git a/module/zfs/spa_misc.c b/module/zfs/spa_misc.c
index 6f2ba52f4e3e..e1a662b796af 100644
--- a/module/zfs/spa_misc.c
+++ b/module/zfs/spa_misc.c
@@ -36,6 +36,7 @@
 #include <sys/zil.h>
 #include <sys/vdev_impl.h>
 #include <sys/vdev_file.h>
+#include <sys/vdev_raidz_impl.h>
 #include <sys/metaslab.h>
 #include <sys/uberblock_impl.h>
 #include <sys/txg.h>
@@ -1831,6 +1832,7 @@ spa_init(int mode)
 	dmu_init();
 	zil_init();
 	vdev_cache_stat_init();
+	vdev_raidz_math_init();
 	zfs_prop_init();
 	zpool_prop_init();
 	zpool_feature_init();
@@ -1846,6 +1848,7 @@ spa_fini(void)
 	spa_evict_all();
 
 	vdev_cache_stat_fini();
+	vdev_raidz_math_fini();
 	zil_fini();
 	dmu_fini();
 	zio_fini();
diff --git a/module/zfs/vdev_raidz.c b/module/zfs/vdev_raidz.c
index b9479092c842..e8c11038485d 100644
--- a/module/zfs/vdev_raidz.c
+++ b/module/zfs/vdev_raidz.c
@@ -22,6 +22,7 @@
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
  */
 
 #include <sys/zfs_context.h>
@@ -31,6 +32,7 @@
 #include <sys/zio_checksum.h>
 #include <sys/fs/zfs.h>
 #include <sys/fm/fs/zfs.h>
+#include <sys/vdev_raidz_impl.h>
 
 /*
  * Virtual device vector for RAID-Z.
@@ -99,33 +101,6 @@
  * or in concert to recover missing data columns.
  */
 
-typedef struct raidz_col {
-	uint64_t rc_devidx;		/* child device index for I/O */
-	uint64_t rc_offset;		/* device offset */
-	uint64_t rc_size;		/* I/O size */
-	void *rc_data;			/* I/O data */
-	void *rc_gdata;			/* used to store the "good" version */
-	int rc_error;			/* I/O error for this device */
-	uint8_t rc_tried;		/* Did we attempt this I/O column? */
-	uint8_t rc_skipped;		/* Did we skip this I/O column? */
-} raidz_col_t;
-
-typedef struct raidz_map {
-	uint64_t rm_cols;		/* Regular column count */
-	uint64_t rm_scols;		/* Count including skipped columns */
-	uint64_t rm_bigcols;		/* Number of oversized columns */
-	uint64_t rm_asize;		/* Actual total I/O size */
-	uint64_t rm_missingdata;	/* Count of missing data devices */
-	uint64_t rm_missingparity;	/* Count of missing parity devices */
-	uint64_t rm_firstdatacol;	/* First data column/parity count */
-	uint64_t rm_nskip;		/* Skipped sectors for padding */
-	uint64_t rm_skipstart;		/* Column index of padding start */
-	void *rm_datacopy;		/* rm_asize-buffer of copied data */
-	uintptr_t rm_reports;		/* # of referencing checksum reports */
-	uint8_t	rm_freed;		/* map no longer has referencing ZIO */
-	uint8_t	rm_ecksuminjected;	/* checksum error was injected */
-	raidz_col_t rm_col[1];		/* Flexible array of I/O columns */
-} raidz_map_t;
 
 #define	VDEV_RAIDZ_P		0
 #define	VDEV_RAIDZ_Q		1
@@ -154,104 +129,9 @@ typedef struct raidz_map {
 	VDEV_RAIDZ_64MUL_2((x), mask); \
 }
 
-/*
- * Force reconstruction to use the general purpose method.
- */
-int vdev_raidz_default_to_general;
-
-/* Powers of 2 in the Galois field defined above. */
-static const uint8_t vdev_raidz_pow2[256] = {
-	0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
-	0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
-	0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9,
-	0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
-	0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35,
-	0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
-	0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0,
-	0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
-	0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc,
-	0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
-	0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f,
-	0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
-	0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88,
-	0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
-	0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93,
-	0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
-	0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9,
-	0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
-	0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa,
-	0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
-	0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e,
-	0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
-	0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4,
-	0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
-	0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e,
-	0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
-	0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef,
-	0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
-	0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5,
-	0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
-	0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83,
-	0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01
-};
-/* Logs of 2 in the Galois field defined above. */
-static const uint8_t vdev_raidz_log2[256] = {
-	0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6,
-	0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
-	0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81,
-	0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
-	0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21,
-	0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
-	0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9,
-	0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
-	0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd,
-	0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
-	0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd,
-	0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
-	0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e,
-	0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
-	0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b,
-	0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
-	0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d,
-	0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
-	0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c,
-	0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
-	0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd,
-	0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
-	0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e,
-	0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
-	0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76,
-	0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
-	0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa,
-	0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
-	0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51,
-	0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
-	0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8,
-	0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf,
-};
+void vdev_raidz_generate_parity(raidz_map_t *rm);
 
-static void vdev_raidz_generate_parity(raidz_map_t *rm);
-
-/*
- * Multiply a given number by 2 raised to the given power.
- */
-static uint8_t
-vdev_raidz_exp2(uint_t a, int exp)
-{
-	if (a == 0)
-		return (0);
-
-	ASSERT(exp >= 0);
-	ASSERT(vdev_raidz_log2[a] > 0 || a == 1);
-
-	exp += vdev_raidz_log2[a];
-	if (exp > 255)
-		exp -= 255;
-
-	return (vdev_raidz_pow2[exp]);
-}
-
-static void
+void
 vdev_raidz_map_free(raidz_map_t *rm)
 {
 	int c;
@@ -437,7 +317,7 @@ static const zio_vsd_ops_t vdev_raidz_vsd_ops = {
  * Avoid inlining the function to keep vdev_raidz_io_start(), which
  * is this functions only caller, as small as possible on the stack.
  */
-noinline static raidz_map_t *
+noinline raidz_map_t *
 vdev_raidz_map_alloc(zio_t *zio, uint64_t unit_shift, uint64_t dcols,
     uint64_t nparity)
 {
@@ -579,6 +459,10 @@ vdev_raidz_map_alloc(zio_t *zio, uint64_t unit_shift, uint64_t dcols,
 
 	zio->io_vsd = rm;
 	zio->io_vsd_ops = &vdev_raidz_vsd_ops;
+
+	/* RAIDZ ops init */
+	raidz_math_ops_init(rm);
+
 	return (rm);
 }
 
@@ -726,9 +610,14 @@ vdev_raidz_generate_parity_pqr(raidz_map_t *rm)
  * Generate RAID parity in the first virtual columns according to the number of
  * parity columns available.
  */
-static void
+void
 vdev_raidz_generate_parity(raidz_map_t *rm)
 {
+	if (rm->rm_ops) {
+		raidz_math_generate(rm);
+		return;
+	}
+
 	switch (rm->rm_firstdatacol) {
 	case 1:
 		vdev_raidz_generate_parity_p(rm);
@@ -1392,7 +1281,7 @@ vdev_raidz_reconstruct_general(raidz_map_t *rm, int *tgts, int ntgts)
 	return (code);
 }
 
-static int
+int
 vdev_raidz_reconstruct(raidz_map_t *rm, int *t, int nt)
 {
 	int tgts[VDEV_RAIDZ_MAXPARITY], *dt;
@@ -1435,34 +1324,40 @@ vdev_raidz_reconstruct(raidz_map_t *rm, int *t, int nt)
 
 	dt = &tgts[nbadparity];
 
+	/*
+	 * Reconstruct using the new math implementation if
+	 * rm_ops is set.
+	 */
+	if (rm->rm_ops) {
+		return (raidz_math_reconstruct(rm, parity_valid, dt, nbaddata));
+	}
+
 	/*
 	 * See if we can use any of our optimized reconstruction routines.
 	 */
-	if (!vdev_raidz_default_to_general) {
-		switch (nbaddata) {
-		case 1:
-			if (parity_valid[VDEV_RAIDZ_P])
-				return (vdev_raidz_reconstruct_p(rm, dt, 1));
+	switch (nbaddata) {
+	case 1:
+		if (parity_valid[VDEV_RAIDZ_P])
+			return (vdev_raidz_reconstruct_p(rm, dt, 1));
 
-			ASSERT(rm->rm_firstdatacol > 1);
+		ASSERT(rm->rm_firstdatacol > 1);
 
-			if (parity_valid[VDEV_RAIDZ_Q])
-				return (vdev_raidz_reconstruct_q(rm, dt, 1));
+		if (parity_valid[VDEV_RAIDZ_Q])
+			return (vdev_raidz_reconstruct_q(rm, dt, 1));
 
-			ASSERT(rm->rm_firstdatacol > 2);
-			break;
+		ASSERT(rm->rm_firstdatacol > 2);
+		break;
 
-		case 2:
-			ASSERT(rm->rm_firstdatacol > 1);
+	case 2:
+		ASSERT(rm->rm_firstdatacol > 1);
 
-			if (parity_valid[VDEV_RAIDZ_P] &&
-			    parity_valid[VDEV_RAIDZ_Q])
-				return (vdev_raidz_reconstruct_pq(rm, dt, 2));
+		if (parity_valid[VDEV_RAIDZ_P] &&
+		    parity_valid[VDEV_RAIDZ_Q])
+			return (vdev_raidz_reconstruct_pq(rm, dt, 2));
 
-			ASSERT(rm->rm_firstdatacol > 2);
+		ASSERT(rm->rm_firstdatacol > 2);
 
-			break;
-		}
+		break;
 	}
 
 	code = vdev_raidz_reconstruct_general(rm, tgts, ntgts);
diff --git a/module/zfs/vdev_raidz_math.c b/module/zfs/vdev_raidz_math.c
new file mode 100644
index 000000000000..76d6f5306c21
--- /dev/null
+++ b/module/zfs/vdev_raidz_math.c
@@ -0,0 +1,616 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#include <sys/resource.h>
+#include <sys/vdev_raidz.h>
+
+#include <sys/vdev_raidz_impl.h>
+#include <sys/types.h>
+
+#include <sys/zfs_context.h>
+#include <sys/zio.h>
+#include <sys/debug.h>
+#include <sys/zfs_debug.h>
+
+#define	ARR_LEN(x) (sizeof (x) / sizeof (x[0]))
+
+extern const raidz_math_ops_t vdev_raidz_scalar_impl;
+extern const raidz_math_ops_t vdev_raidz_sse_impl;
+extern const raidz_math_ops_t vdev_raidz_avx2_impl;
+
+/*
+ * Select the math impl
+ */
+typedef enum math_impl_sel {
+	MATH_IMPL_FASTEST	= -1,
+	MATH_IMPL_ORIGINAL	= -2,
+	MATH_IMPL_CYCLE		= -3
+	/*
+	 * between 0 and raidz_supp_maths_cnt values
+	 * are index in raidz_supp_maths
+	 */
+} math_impl_sel_t;
+
+int zfs_raidz_math_impl = MATH_IMPL_FASTEST;
+
+const char *raidz_gen_name[] = {
+	"gen_p", "gen_pq", "gen_pqr"
+};
+const char *raidz_rec_name[] = {
+	"rec_p", "rec_q", "rec_r",
+	"rec_pq", "rec_pr", "rec_qr", "rec_pqr"
+};
+
+/* RAIDZ op that contain the fastest routines (can have mixed impl) */
+raidz_math_ops_t vdev_raidz_fastest_impl = {
+	.name = "fastest"
+};
+
+/* selected implementation and its lock */
+static raidz_math_ops_t *vdev_raidz_used_impl = &vdev_raidz_fastest_impl;
+static krwlock_t vdev_raidz_used_impl_lock;
+
+/* All compiled in implementations */
+const raidz_math_ops_t *raidz_all_maths[] = {
+	&vdev_raidz_scalar_impl,
+#if defined(RAIDZ_SSE_x86_64) /* only x86_64 for now */
+	&vdev_raidz_sse_impl,
+#endif
+#if defined(RAIDZ_AVX2_x86_64) /* only x86_64 for now */
+	&vdev_raidz_avx2_impl
+#endif
+};
+
+/* Hold all impl available in runtime */
+size_t raidz_supp_maths_cnt = 0;
+raidz_math_ops_t *raidz_supp_maths[ARR_LEN(raidz_all_maths)];
+
+/* Holding kstats for all algos + original methods */
+raidz_math_ops_kstat_t raidz_math_kstats[ARR_LEN(raidz_all_maths)+1];
+/* kstat for benchmarked algos */
+kstat_t *raidz_math_kstat = NULL;
+
+void
+raidz_math_ops_init(raidz_map_t *rm)
+{
+	static int raidz_curr_impl = 0;
+	/*
+	 * Set raidz implementation
+	 */
+	rw_enter(&vdev_raidz_used_impl_lock, RW_READER);
+
+	rm->rm_ops = vdev_raidz_used_impl;
+
+	if (zfs_raidz_math_impl == MATH_IMPL_CYCLE) {
+		raidz_curr_impl = (raidz_curr_impl+1) %
+			(raidz_supp_maths_cnt+1);
+		if (raidz_curr_impl == raidz_supp_maths_cnt) {
+			rm->rm_ops = NULL; /* original math */
+		} else {
+			rm->rm_ops = raidz_supp_maths[raidz_curr_impl];
+		}
+	}
+
+	rw_exit(&vdev_raidz_used_impl_lock);
+}
+
+void
+raidz_math_generate(raidz_map_t *rm)
+{
+	raidz_gen_f gen_parity = NULL;
+
+	switch (raidz_parity(rm)) {
+		case 1:
+			gen_parity = rm->rm_ops->gen[RAIDZ_GEN_P];
+			break;
+		case 2:
+			gen_parity = rm->rm_ops->gen[RAIDZ_GEN_PQ];
+			break;
+		case 3:
+			gen_parity = rm->rm_ops->gen[RAIDZ_GEN_PQR];
+			break;
+		default:
+			gen_parity = NULL;
+			cmn_err(CE_PANIC, "invalid RAID-Z configuration %d",
+				raidz_parity(rm));
+			break;
+	}
+
+	ASSERT(gen_parity != NULL);
+
+	gen_parity(rm);
+}
+
+static raidz_rec_f
+_reconstruct_fun_raidz1(raidz_map_t *rm, const int *parity_valid,
+	const int nbaddata)
+{
+	if (nbaddata == 1 && parity_valid[CODE_P]) {
+		return (rm->rm_ops->rec[RAIDZ_REC_P]);
+	}
+	return ((raidz_rec_f) NULL);
+}
+
+static raidz_rec_f
+_reconstruct_fun_raidz2(raidz_map_t *rm, const int *parity_valid,
+	const int nbaddata)
+{
+	if (nbaddata == 1) {
+		if (parity_valid[CODE_P]) {
+			return (rm->rm_ops->rec[RAIDZ_REC_P]);
+		} else if (parity_valid[CODE_Q]) {
+			return (rm->rm_ops->rec[RAIDZ_REC_Q]);
+		}
+	} else if (nbaddata == 2 &&
+		parity_valid[CODE_P] && parity_valid[CODE_Q]) {
+		return (rm->rm_ops->rec[RAIDZ_REC_PQ]);
+	}
+	return ((raidz_rec_f) NULL);
+}
+
+static raidz_rec_f
+_reconstruct_fun_raidz3(raidz_map_t *rm, const int *parity_valid,
+	const int nbaddata)
+{
+	if (nbaddata == 1) {
+		if (parity_valid[CODE_P]) {
+			return (rm->rm_ops->rec[RAIDZ_REC_P]);
+		} else if (parity_valid[CODE_Q]) {
+			return (rm->rm_ops->rec[RAIDZ_REC_Q]);
+		} else if (parity_valid[CODE_R]) {
+			return (rm->rm_ops->rec[RAIDZ_REC_R]);
+		}
+	} else if (nbaddata == 2) {
+		if (parity_valid[CODE_P] && parity_valid[CODE_Q]) {
+			return (rm->rm_ops->rec[RAIDZ_REC_PQ]);
+		} else if (parity_valid[CODE_P] && parity_valid[CODE_R]) {
+			return (rm->rm_ops->rec[RAIDZ_REC_PR]);
+		} else if (parity_valid[CODE_Q] && parity_valid[CODE_R]) {
+			return (rm->rm_ops->rec[RAIDZ_REC_QR]);
+		}
+	} else if (nbaddata == 3 &&
+		parity_valid[CODE_P] && parity_valid[CODE_Q] &&
+		parity_valid[CODE_R]) {
+		return (rm->rm_ops->rec[RAIDZ_REC_PQR]);
+	}
+	return ((raidz_rec_f) NULL);
+}
+
+int raidz_math_reconstruct(raidz_map_t *rm, const int *parity_valid,
+	const int *dt, const int nbaddata)
+{
+	raidz_rec_f rec_data = NULL;
+
+	switch (raidz_parity(rm)) {
+		case 1:
+			rec_data = _reconstruct_fun_raidz1(rm, parity_valid,
+				nbaddata);
+			break;
+		case 2:
+			rec_data = _reconstruct_fun_raidz2(rm, parity_valid,
+				nbaddata);
+			break;
+		case 3:
+			rec_data = _reconstruct_fun_raidz3(rm, parity_valid,
+				nbaddata);
+			break;
+		default:
+			cmn_err(CE_PANIC, "invalid RAID-Z configuration %d",
+				raidz_parity(rm));
+			break;
+	}
+
+	ASSERT(rec_data != NULL);
+
+	return (rec_data(rm, dt));
+}
+
+
+/* Number of pages for benchmark: 2^BENCH_SIZE_ORD */
+#define	BENCH_D_COLS	(8)
+#define	BENCH_COLS		(3 + BENCH_D_COLS)
+#define	BENCH_COL_SIZE	(4096)
+#define	BENCH_ZIO_SIZE	(BENCH_COL_SIZE * BENCH_D_COLS)
+#define	BENCH_SD_SIZE	(BENCH_COL_SIZE*3/4)
+#define	BENCH_NS		(50ULL*1000ULL*1000ULL) /* 50ms */
+
+#define	BENCH_RES_FMT	"RAIDZ_math: [%-7s] %-8s %5ld.%.3ld MB/s\n"
+#define	BENCH_SKIP_FMT	"RAIDZ_math: [%-7s] is not supported.\n"
+
+#if defined(_KERNEL)
+#define	bench_print(x...)	cmn_err(CE_CONT, x)
+#else
+#define	bench_print(x...)	do { } while (0)
+#endif
+
+static void
+init_raidz_kstat(raidz_math_ops_kstat_t *rs, const char *name)
+{
+	int i;
+	const size_t impl_name_len = strnlen(name, KSTAT_STRLEN);
+	const size_t op_name_max = (KSTAT_STRLEN-2) > impl_name_len ?
+		KSTAT_STRLEN - impl_name_len - 2 : 0;
+
+	for (i = 0; i < RAIDZ_GEN_NUM; i++) {
+		strncpy(rs->gen_kstat[i].name, name, impl_name_len);
+		strncpy(rs->gen_kstat[i].name + impl_name_len, "_", 1);
+		strncpy(rs->gen_kstat[i].name + impl_name_len + 1,
+			raidz_gen_name[i], op_name_max);
+
+		rs->gen_kstat[i].data_type = KSTAT_DATA_UINT64;
+		rs->gen_kstat[i].value.ui64  = 0;
+	}
+
+	for (i = 0; i < RAIDZ_REC_NUM; i++) {
+		strncpy(rs->rec_kstat[i].name, name, impl_name_len);
+		strncpy(rs->rec_kstat[i].name + impl_name_len, "_", 1);
+		strncpy(rs->rec_kstat[i].name + impl_name_len + 1,
+			raidz_rec_name[i], op_name_max);
+
+		rs->rec_kstat[i].data_type = KSTAT_DATA_UINT64;
+		rs->rec_kstat[i].value.ui64  = 0;
+	}
+}
+
+void
+vdev_raidz_math_init(void)
+{
+	const int impl_num = ARR_LEN(raidz_all_maths);
+	const int tgtidx[3] = {3, 4, 5};
+	raidz_math_ops_t const *curr_impl;
+	unsigned long long run_count, best_run_count, speed;
+	hrtime_t t_start;
+	zio_t *bench_zio = NULL;
+	raidz_map_t *bench_rm = NULL;
+	uint64_t bench_parity;
+	int i, c, fn, impl;
+	int bench_rec_orig[7][3] = {
+		{1, 2, 3}, {0, 2, 3},
+		{0, 1, 3}, {2, 3, 4},
+		{1, 3, 4}, {0, 3, 4},
+		{3, 4, 5}
+	};
+
+	/* init & vdev_raidz_used_impl_lock */
+	rw_init(&vdev_raidz_used_impl_lock, NULL, RW_DEFAULT, NULL);
+
+	/* move supported maths into raidz_supp_maths */
+	for (i = 0, c = 0; i < impl_num; i++) {
+		curr_impl = raidz_all_maths[i];
+
+		/* init kstat */
+		init_raidz_kstat(raidz_math_kstats + i, curr_impl->name);
+
+		if (curr_impl->is_supported()) {
+			raidz_supp_maths[c++] = (raidz_math_ops_t *) curr_impl;
+		} else {
+			bench_print(BENCH_SKIP_FMT, curr_impl->name);
+			continue;
+		}
+	}
+	raidz_supp_maths_cnt = c;	/* number of supported algos */
+
+	/* init  kstat for original algo  routines */
+	init_raidz_kstat(&(raidz_math_kstats[impl_num]), "original");
+
+	/* Fake an zio and run the benchmark on it */
+	bench_zio = kmem_alloc(sizeof (zio_t), KM_SLEEP);
+	bzero(bench_zio, sizeof (zio_t));
+
+	bench_zio->io_offset = 0;
+	bench_zio->io_size = BENCH_ZIO_SIZE; /* only data columns */
+	bench_zio->io_data = zio_data_buf_alloc(BENCH_ZIO_SIZE);
+	if (!bench_zio->io_data) {
+		cmn_err(CE_WARN, "RAIDZ: Can not allocate benchmark memory!");
+		/* use last supported math as the fastest */
+		cmn_err(CE_WARN, "RAIDZ: Using [%s] implementation",
+			raidz_supp_maths[raidz_supp_maths_cnt-1]->name);
+		memcpy(&vdev_raidz_fastest_impl,
+			raidz_supp_maths[raidz_supp_maths_cnt-1],
+			sizeof (raidz_math_ops_t));
+
+		kmem_free(bench_zio, sizeof (zio_t));
+		return;
+	}
+
+	/*
+	 * Benchmark new RAIDZ implementations
+	 */
+	/* Find the fastest gen functions */
+	for (fn = 0; fn < RAIDZ_GEN_NUM; fn++) {
+		bench_parity = fn+1;
+		best_run_count = 0;
+		/* New raidz_map is needed for rach generate_p/q/r */
+		bench_rm = vdev_raidz_map_alloc(bench_zio, 9,
+			BENCH_D_COLS+bench_parity, bench_parity);
+
+		for (impl = 0; impl < impl_num; impl++) {
+			curr_impl = raidz_all_maths[impl];
+
+			if (!curr_impl->is_supported()) {
+				continue;
+			}
+
+			kpreempt_disable();
+
+			run_count = 0;
+			t_start = gethrtime();
+
+			do {
+				for (i = 0; i < 10; i++, run_count++) {
+					curr_impl->gen[fn](bench_rm);
+				}
+			} while (gethrtime() < (t_start + BENCH_NS));
+
+			speed = run_count * (bench_zio->io_size >> 10);
+			speed /= (BENCH_D_COLS+bench_parity);
+			speed *= 1000000000ULL;
+			speed /= (gethrtime() - t_start);
+
+			kpreempt_enable();
+
+			raidz_math_kstats[impl].gen_kstat[fn].value.ui64 =
+				speed;
+			bench_print(BENCH_RES_FMT, raidz_gen_name[fn],
+				curr_impl->name, speed/1000, speed%1000);
+
+			if (run_count > best_run_count) {
+				best_run_count = run_count;
+				vdev_raidz_fastest_impl.gen[fn] =
+					curr_impl->gen[fn];
+			}
+		}
+		vdev_raidz_map_free(bench_rm);
+	}
+
+	/* Find the fastest rec functions */
+	bench_rm = vdev_raidz_map_alloc(bench_zio, 9, BENCH_COLS, CODE_PQR);
+
+	for (fn = 0; fn < RAIDZ_REC_NUM; fn++) {
+		best_run_count = 0;
+
+		for (impl = 0; impl < impl_num; impl++) {
+			curr_impl = raidz_all_maths[impl];
+
+			if (!curr_impl->is_supported()) {
+				continue;
+			}
+
+			run_count = 0;
+
+			kpreempt_disable();
+			t_start = gethrtime();
+
+			do {
+				for (i = 0; i < 10; i++, run_count++) {
+					curr_impl->rec[fn](bench_rm, tgtidx);
+				}
+			} while (gethrtime() < (t_start + BENCH_NS));
+
+			speed = run_count * (bench_zio->io_size >> 10);
+			speed /= (BENCH_COLS);
+			speed *= 1000000000ULL;
+			speed /= (gethrtime() - t_start);
+
+			kpreempt_enable();
+
+			raidz_math_kstats[impl].rec_kstat[fn].value.ui64 =
+				speed;
+			bench_print(BENCH_RES_FMT, raidz_rec_name[fn],
+				curr_impl->name, speed/1000, speed%1000);
+
+			if (run_count > best_run_count) {
+				best_run_count = run_count;
+				vdev_raidz_fastest_impl.rec[fn] =
+					curr_impl->rec[fn];
+			}
+		}
+	}
+	vdev_raidz_map_free(bench_rm);
+
+	/*
+	 * Benchmark original RAIDZ implementations
+	 */
+
+	/* Benchmark generate functions */
+	for (fn = 0; fn < RAIDZ_GEN_NUM; fn++) {
+		bench_parity = fn+1;
+		bench_rm = vdev_raidz_map_alloc(bench_zio, 9,
+			BENCH_D_COLS+bench_parity, bench_parity);
+		bench_rm->rm_ops = NULL; /* force original math */
+
+		kpreempt_disable();
+
+		run_count = 0;
+		t_start = gethrtime();
+
+		do {
+			for (i = 0; i < 10; i++, run_count++) {
+				vdev_raidz_generate_parity(bench_rm);
+			}
+		} while (gethrtime() < (t_start + BENCH_NS));
+
+		speed = run_count * (bench_zio->io_size >> 10);
+		speed /= (BENCH_D_COLS+bench_parity);
+		speed *= 1000000000ULL;
+		speed /= (gethrtime() - t_start);
+
+		kpreempt_enable();
+
+		raidz_math_kstats[impl_num].gen_kstat[fn].value.ui64 = speed;
+		bench_print(BENCH_RES_FMT, raidz_gen_name[fn], "original",
+			speed/1000, speed%1000);
+		vdev_raidz_map_free(bench_rm);
+	}
+
+	/* Benchmark reconstruction functions */
+	bench_rm = vdev_raidz_map_alloc(bench_zio, 9, BENCH_COLS, CODE_PQR);
+	bench_rm->rm_ops = NULL; /* force original math */
+
+	for (fn = 0; fn < RAIDZ_REC_NUM; fn++) {
+
+		kpreempt_disable();
+
+		run_count = 0;
+		t_start = gethrtime();
+
+		do {
+			for (i = 0; i < 10; i++, run_count++) {
+				vdev_raidz_reconstruct(bench_rm,
+					bench_rec_orig[fn], CODE_PQR);
+			}
+		} while (gethrtime() < (t_start + BENCH_NS));
+
+		speed = run_count * (bench_zio->io_size >> 10);
+		speed /= (BENCH_COLS);
+		speed *= 1000000000ULL;
+		speed /= (gethrtime() - t_start);
+
+		kpreempt_enable();
+
+		raidz_math_kstats[impl_num].rec_kstat[fn].value.ui64 = speed;
+		bench_print(BENCH_RES_FMT, raidz_rec_name[fn], "original",
+			speed/1000, speed%1000);
+	}
+	vdev_raidz_map_free(bench_rm);
+
+	/* cleanup the bench zio */
+	zio_data_buf_free(bench_zio->io_data, BENCH_ZIO_SIZE);
+	kmem_free(bench_zio, sizeof (zio_t));
+
+	/* install kstats for all algos */
+	raidz_math_kstat = kstat_create("zfs", 0, "vdev_raidz_bench",
+		"misc", KSTAT_TYPE_NAMED,
+		sizeof (raidz_math_ops_kstat_t) / sizeof (kstat_named_t) *
+		(impl_num+1), KSTAT_FLAG_VIRTUAL);
+	if (raidz_math_kstat != NULL) {
+		raidz_math_kstat->ks_data = raidz_math_kstats;
+		kstat_install(raidz_math_kstat);
+	}
+
+	/*
+	 * For testing only!!!
+	 * Use 'cycle' math selection method from userspace.
+	 */
+#if !defined(_KERNEL)
+	VERIFY0(zfs_raidz_math_impl_set("cycle", NULL));
+#endif
+}
+
+void
+vdev_raidz_math_fini(void)
+{
+	if (raidz_math_kstat != NULL) {
+		kstat_delete(raidz_math_kstat);
+		raidz_math_kstat = NULL;
+	}
+
+	rw_destroy(&vdev_raidz_used_impl_lock);
+}
+
+
+static const char * zfs_raidz_math_impl_names[] = {
+	"fastest",
+	"original",
+	"cycle",
+	"scalar",
+	"sse",
+	"avx2",
+};
+
+int
+zfs_raidz_math_impl_set(const char *val, struct kernel_param *kp)
+{
+	int idx, i, err = 0;
+	raidz_math_ops_t *impl;
+
+	for (idx = 0; idx < ARR_LEN(zfs_raidz_math_impl_names); idx++) {
+		if (0 == strncmp(val, zfs_raidz_math_impl_names[idx],
+			strlen(zfs_raidz_math_impl_names[idx]))) {
+			i = idx;
+			break;
+		}
+	}
+	if (idx >= ARR_LEN(zfs_raidz_math_impl_names))
+		return (-EINVAL);
+
+	rw_enter(&vdev_raidz_used_impl_lock, RW_WRITER);
+	impl = vdev_raidz_used_impl;
+
+	if (idx == 0) {
+		impl = &vdev_raidz_fastest_impl;
+		zfs_raidz_math_impl = MATH_IMPL_FASTEST;
+	} else if (idx == 1) {
+		impl = NULL;
+		zfs_raidz_math_impl = MATH_IMPL_ORIGINAL;
+	} else if (idx == 2) {
+		impl = raidz_supp_maths[0];
+		zfs_raidz_math_impl = MATH_IMPL_CYCLE;
+	} else {
+		for (idx = 0; idx < raidz_supp_maths_cnt; idx++) {
+			if (0 == strncmp(val, raidz_supp_maths[idx]->name,
+					strlen(raidz_supp_maths[idx]->name))) {
+				impl = raidz_supp_maths[idx];
+				zfs_raidz_math_impl = idx;
+				break;
+			}
+		}
+		if (idx >= raidz_supp_maths_cnt) {
+			err = -EINVAL;
+		}
+	}
+
+	vdev_raidz_used_impl = impl;
+	rw_exit(&vdev_raidz_used_impl_lock);
+
+	return (err);
+}
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+static int
+zfs_raidz_math_impl_get(char *buffer, struct kernel_param *kp)
+{
+	int i, cnt = 0;
+
+	cnt += sprintf(buffer + cnt,
+		(zfs_raidz_math_impl == -1) ? "[%s] " : "%s ", "fastest");
+	cnt += sprintf(buffer + cnt,
+		(zfs_raidz_math_impl == -2) ? "[%s] " : "%s ", "original");
+	cnt += sprintf(buffer + cnt,
+		(zfs_raidz_math_impl == -3) ? "[%s] " : "%s ", "cycle");
+
+	for (i = 0; i < raidz_supp_maths_cnt; i++) {
+		cnt += sprintf(buffer + cnt,
+			(zfs_raidz_math_impl == i) ? "[%s] " : "%s ",
+			raidz_supp_maths[i]->name);
+	}
+
+	return (cnt);
+}
+
+module_param_call(zfs_raidz_math_impl, zfs_raidz_math_impl_set,
+	zfs_raidz_math_impl_get, NULL, 0644);
+MODULE_PARM_DESC(zfs_raidz_math_impl, "Select raidz math to use");
+#endif
diff --git a/module/zfs/vdev_raidz_math_avx2.c b/module/zfs/vdev_raidz_math_avx2.c
new file mode 100644
index 000000000000..9959bb6bb595
--- /dev/null
+++ b/module/zfs/vdev_raidz_math_avx2.c
@@ -0,0 +1,313 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#include <sys/types.h>
+#include <sys/vdev_raidz.h>
+#include <linux/simd_x86.h>
+
+/*
+ * Only in 64bit for now
+ */
+#if defined(RAIDZ_AVX2_x86_64)
+
+#include <sys/vdev_raidz_impl.h>
+
+#define	__asm __asm__ __volatile__
+
+#define	_REG_CNT(_0, _1, _2, _3, _4, _5, _6, _7, N, ...) N
+#define	REG_CNT(r...) _REG_CNT(r, 8, 7, 6, 5, 4, 3, 2, 1)
+
+#define	VR0_(REG, ...) "ymm"#REG
+#define	VR1_(_1, REG, ...) "ymm"#REG
+#define	VR2_(_1, _2, REG, ...) "ymm"#REG
+#define	VR3_(_1, _2, _3, REG, ...) "ymm"#REG
+#define	VR4_(_1, _2, _3, _4, REG, ...) "ymm"#REG
+#define	VR5_(_1, _2, _3, _4, _5, REG, ...) "ymm"#REG
+#define	VR6_(_1, _2, _3, _4, _5, _6, REG, ...) "ymm"#REG
+#define	VR7_(_1, _2, _3, _4, _5, _6, _7, REG, ...) "ymm"#REG
+
+#define	VR0(r...) VR0_(r)
+#define	VR1(r...) VR1_(r)
+#define	VR2(r...) VR2_(r, 1)
+#define	VR3(r...) VR3_(r, 1, 2)
+#define	VR4(r...) VR4_(r, 1)
+#define	VR5(r...) VR5_(r, 1, 2)
+#define	VR6(r...) VR6_(r, 1, 2, 3)
+#define	VR7(r...) VR7_(r, 1, 2, 3, 4)
+
+#define	R_01(REG1, REG2, ...) REG1, REG2
+#define	R_23_(_0, _1, REG2, REG3, ...) REG2, REG3
+#define	R_23(REG...) R_23_(REG, 1, 2, 3)
+
+#define	ELEM_SIZE 32
+
+extern const uint8_t sse_gf_mod_lt[2*256][16] __attribute__((aligned(256)));
+extern const uint8_t sse_clmul_mod_lt[2*256][16] __attribute__((aligned(256)));
+
+typedef struct elem {
+	unsigned char b[ELEM_SIZE];
+} elem_t __attribute__((aligned(ELEM_SIZE)));
+
+/* Convert from GF log to perform multiplications using SIMD */
+inline static int
+fix_mul_exponent(int e) {
+	return ((int)vdev_raidz_pow2[e]);
+}
+
+#define	PREFETCHNTA(ptr, offset, stride) \
+{	\
+	switch (stride) {	\
+	case 4:	\
+	__asm("prefetchnta %0" :: "m" (((elem_t *)ptr)[offset+3])); \
+	__asm("prefetchnta %0" :: "m" (((elem_t *)ptr)[offset+2])); \
+	case 2:	\
+	__asm("prefetchnta %0" :: "m" (((elem_t *)ptr)[offset+1])); \
+	__asm("prefetchnta %0" :: "m" (((elem_t *)ptr)[offset+0])); \
+	}\
+}
+
+#define	XOR_ACC(src, r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 4:	\
+	__asm("vpxor %0, %%" VR3(r)", %%" VR3(r) : : "m" (((elem_t *)src)[3]));\
+	__asm("vpxor %0, %%" VR2(r)", %%" VR2(r) : : "m" (((elem_t *)src)[2]));\
+	case 2:	\
+	__asm("vpxor %0, %%" VR1(r)", %%" VR1(r) : : "m" (((elem_t *)src)[1]));\
+	case 1:	\
+	__asm("vpxor %0, %%" VR0(r)", %%" VR0(r) : : "m" (((elem_t *)src)[0]));\
+	}\
+}
+
+#define	XOR(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 8:\
+	__asm("vpxor %" VR3(r) ", %" VR7(r)", %" VR7(r));\
+	__asm("vpxor %" VR2(r) ", %" VR6(r)", %" VR6(r));\
+	__asm("vpxor %" VR1(r) ", %" VR5(r)", %" VR5(r));\
+	__asm("vpxor %" VR0(r) ", %" VR4(r)", %" VR4(r));\
+	break;\
+	case 4:\
+	__asm("vpxor %" VR1(r) ", %" VR3(r)", %" VR3(r));\
+	__asm("vpxor %" VR0(r) ", %" VR2(r)", %" VR2(r));\
+	break;\
+	case 2:\
+	__asm("vpxor %" VR0(r) ", %" VR1(r)", %" VR1(r));\
+	break;\
+	}\
+}
+
+#define	COPY(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 8:	\
+		__asm("vmovdqa %" VR0(r) ", %" VR4(r));	\
+		__asm("vmovdqa %" VR1(r) ", %" VR5(r));	\
+		__asm("vmovdqa %" VR2(r) ", %" VR6(r));	\
+		__asm("vmovdqa %" VR3(r) ", %" VR7(r));	\
+	break;	\
+	case 4:	\
+		__asm("vmovdqa %" VR0(r) ", %" VR2(r));	\
+		__asm("vmovdqa %" VR1(r) ", %" VR3(r));	\
+	break;	\
+	case 2:	\
+		__asm("vmovdqa %" VR0(r) ", %" VR1(r));	\
+	break;	\
+	}	\
+}
+
+#define	LOAD(src, r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 4:	\
+	__asm("vmovdqa %0, %%" VR3(r) : : "m" (((elem_t *)src)[3]));\
+	__asm("vmovdqa %0, %%" VR2(r) : : "m" (((elem_t *)src)[2]));\
+	case 2:	\
+	__asm("vmovdqa %0, %%" VR1(r) : : "m" (((elem_t *)src)[1]));\
+	case 1:	\
+	__asm("vmovdqa %0, %%" VR0(r) : : "m" (((elem_t *)src)[0]));\
+	}\
+}
+
+#define	ZERO(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+		case 4:	\
+			__asm("vpxor %" VR3(r)", %" VR3(r)", %" VR3(r));\
+			__asm("vpxor %" VR2(r)", %" VR2(r)", %" VR2(r));\
+		case 2:	\
+			__asm("vpxor %" VR1(r)", %" VR1(r)", %" VR1(r));\
+		case 1:	\
+			__asm("vpxor %" VR0(r)", %" VR0(r)", %" VR0(r));\
+	}\
+}
+
+#define	STREAM_STORE(dst, r...)   \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 4:	\
+		__asm("vmovntdq %%" VR3(r)", %0" : "=m" (((elem_t *)dst)[3]));\
+		__asm("vmovntdq %%" VR2(r)", %0" : "=m" (((elem_t *)dst)[2]));\
+	case 2:	\
+		__asm("vmovntdq %%" VR1(r)", %0" : "=m" (((elem_t *)dst)[1]));\
+	case 1:	\
+		__asm("vmovntdq %%" VR0(r)", %0" : "=m" (((elem_t *)dst)[0]));\
+	}\
+}
+
+#define	FLUSH() \
+{   \
+	__asm("vzeroupper");	\
+	__asm("sfence" : : : "memory");	\
+}
+
+#define	MUL2_SETUP() \
+{   \
+	__asm("vmovd %0, %%xmm14" :: "r"(0x1d1d1d1d1d1d1d1d));	\
+	__asm("vpbroadcastq %xmm14, %ymm14");	\
+	__asm("vpxor          %ymm15, %ymm15 ,%ymm15");	\
+}
+
+#define	MUL2_(r...) \
+{	\
+	switch	(REG_CNT(r)) {	\
+	case 2:\
+	__asm("vpcmpgtb %" VR0(r)", %ymm15,     %ymm12");\
+	__asm("vpcmpgtb %" VR1(r)", %ymm15,     %ymm13");\
+	__asm("vpaddb   %" VR0(r)", %" VR0(r)", %" VR0(r));\
+	__asm("vpaddb   %" VR1(r)", %" VR1(r)", %" VR1(r));\
+	__asm("vpand    %ymm14,     %ymm12,     %ymm12");\
+	__asm("vpand    %ymm14,     %ymm13,     %ymm13");\
+	__asm("vpxor    %ymm12,     %" VR0(r)", %" VR0(r));\
+	__asm("vpxor    %ymm13,     %" VR1(r)", %" VR1(r));\
+	break;\
+	}\
+}
+
+#define	MUL2(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 2:	\
+		MUL2_(r);\
+		break;\
+	case 4:	\
+		MUL2_(R_01(r));\
+		MUL2_(R_23(r));\
+		break;\
+	}\
+}
+
+#define	MUL4(r...) \
+{	\
+	MUL2(r); \
+	MUL2(r); \
+}
+
+#define	_0f_x		"xmm15"
+#define	_0f			"ymm15"
+#define	_a_save		"ymm14"
+#define	_b_save		"ymm13"
+#define	_lt_mod		"ymm12"
+#define	_lt_clmul	"ymm11"
+#define	_ta			"ymm10"
+#define	_tb			"ymm15"
+
+#define	MULx2(c, r...)\
+{\
+	__asm("vmovd %0, %%" _0f_x :: "r"(0x0f0f0f0f0f0f0f0f));\
+	__asm("vpbroadcastq %" _0f_x ", %" _0f);\
+	\
+	/* upper bits */\
+	__asm("vbroadcasti128 %0, %%" _lt_mod	\
+		: : "m" (sse_gf_mod_lt[2*(c)][0]));	\
+	__asm("vbroadcasti128 %0, %%" _lt_clmul		\
+		: : "m" (sse_clmul_mod_lt[2*(c)][0]));	\
+	\
+	__asm("vpsraw $0x4, %" VR0(r) ", %"_a_save);\
+	__asm("vpsraw $0x4, %" VR1(r) ", %"_b_save);\
+	__asm("vpand %" _0f ", %" VR0(r) ", %" VR0(r));\
+	__asm("vpand %" _0f ", %" VR1(r) ", %" VR1(r));\
+	__asm("vpand %" _0f ", %" _a_save ", %" _a_save);\
+	__asm("vpand %" _0f ", %" _b_save ", %" _b_save);\
+	\
+	__asm("vpshufb %" _a_save ",%" _lt_mod ",%" _ta);\
+	__asm("vpshufb %" _b_save ",%" _lt_mod ",%" _tb);\
+	__asm("vpshufb %" _a_save ",%" _lt_clmul ",%" _a_save);\
+	__asm("vpshufb %" _b_save ",%" _lt_clmul ",%" _b_save);\
+	\
+	/* low bits */\
+	__asm("vbroadcasti128 %0, %%" _lt_mod		\
+		: : "m" (sse_gf_mod_lt[2*(c)+1][0]));	\
+	__asm("vbroadcasti128 %0, %%" _lt_clmul		\
+		: : "m" (sse_clmul_mod_lt[2*(c)+1][0]));\
+	\
+	__asm("vpxor %" _ta ",%" _a_save ",%" _a_save);\
+	__asm("vpxor %" _tb ",%" _b_save ",%" _b_save);\
+	\
+	__asm("vpshufb %" VR0(r) ",%" _lt_mod ",%" _ta);\
+	__asm("vpshufb %" VR1(r) ",%" _lt_mod ",%" _tb);\
+	__asm("vpshufb %" VR0(r) ",%" _lt_clmul ",%" VR0(r));\
+	__asm("vpshufb %" VR1(r) ",%" _lt_clmul ",%" VR1(r));\
+	\
+	__asm("vpxor %" _ta ",%" VR0(r) ",%" VR0(r));\
+	__asm("vpxor %" _a_save ",%" VR0(r) ",%" VR0(r));\
+	__asm("vpxor %" _tb ",%" VR1(r) ",%" VR1(r));\
+	__asm("vpxor %" _b_save ",%" VR1(r) ",%" VR1(r));\
+}
+
+#include "vdev_raidz_math_x86simd.h"
+#include "vdev_raidz_math_impl.h"
+
+RAIDZ_x86SIMD_GEN_WRAP(p, avx2);
+RAIDZ_x86SIMD_GEN_WRAP(pq, avx2);
+RAIDZ_x86SIMD_GEN_WRAP(pqr, avx2);
+
+RAIDZ_x86SIMD_REC_WRAP(p, avx2);
+RAIDZ_x86SIMD_REC_WRAP(q, avx2);
+RAIDZ_x86SIMD_REC_WRAP(r, avx2);
+RAIDZ_x86SIMD_REC_WRAP(pq, avx2);
+RAIDZ_x86SIMD_REC_WRAP(pr, avx2);
+RAIDZ_x86SIMD_REC_WRAP(qr, avx2);
+RAIDZ_x86SIMD_REC_WRAP(pqr, avx2);
+
+static boolean_t
+raidz_math_will_avx2_work(void)
+{
+	return (zfs_avx_available() && zfs_avx2_available());
+}
+
+const raidz_math_ops_t vdev_raidz_avx2_impl = {
+	.gen = { &avx2_gen_p, &avx2_gen_pq, &avx2_gen_pqr },
+	.rec = {
+		&avx2_rec_p, &avx2_rec_q, &avx2_rec_r,
+		&avx2_rec_pq, &avx2_rec_pr, &avx2_rec_qr,
+		&avx2_rec_pqr
+	},
+	.is_supported = &raidz_math_will_avx2_work,
+	.name = "avx2"
+};
+
+#endif /* defined(RAIDZ_AVX2_x86_64) */
diff --git a/module/zfs/vdev_raidz_math_impl.h b/module/zfs/vdev_raidz_math_impl.h
new file mode 100644
index 000000000000..07779069e1a2
--- /dev/null
+++ b/module/zfs/vdev_raidz_math_impl.h
@@ -0,0 +1,410 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#ifndef _VDEV_RAIDZ_MATH_IMPL_H
+#define	_VDEV_RAIDZ_MATH_IMPL_H
+
+#include <sys/types.h>
+
+
+struct elem_t;
+struct elem_mul_pad_t;
+
+static raidz_inline void raidz_flush_data(void);
+
+static raidz_inline size_t
+gen_p_block(raidz_col_t *cols, const size_t nd, const size_t off);
+static raidz_inline size_t
+gen_pq_block(raidz_col_t *cols, const size_t nd, const size_t nld,
+	const size_t off);
+static raidz_inline size_t
+gen_pqr_block(raidz_col_t *cols, const size_t nd, const size_t nld,
+	const size_t off);
+
+static raidz_inline size_t
+rec_p_block(raidz_col_t *cols, const size_t parity, const size_t xidx,
+	const size_t nd, const size_t off);
+static raidz_inline size_t
+rec_q_block(raidz_col_t *cols, const size_t parity,
+	const size_t xidx, const int x_mul,
+	const size_t nd, const size_t nld, const size_t off);
+static raidz_inline size_t
+rec_r_block(raidz_col_t *cols, const size_t parity,
+	const size_t xidx, const int x_mul,
+	const size_t nd, const size_t nld, const size_t off);
+
+static raidz_inline size_t
+rec_pq_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y,
+	const size_t xsize, const size_t ysize,
+	const int a_mul, const int b_mul,
+	const size_t nd, const size_t nld, const size_t off);
+static raidz_inline size_t
+rec_pr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y,
+	const size_t xsize, const size_t ysize,
+	const int a_mul, const int b_mul,
+	const size_t nd, const size_t nld, const size_t off);
+static raidz_inline size_t
+rec_qr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y,
+	const size_t xsize, const size_t ysize,
+	const int xq_mul, const int x_mul, const int yq_mul, const int y_mul,
+	const size_t nd, const size_t nld, const size_t off);
+
+static raidz_inline size_t
+rec_pqr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y, const size_t z,
+	const size_t xsize, const size_t ysize, const size_t zsize,
+	const int xp_mul, const int xq_mul, const int xr_mul,
+	const int yp_mul, const int yq_mul, const int upd_q_mul,
+	const size_t nd, const size_t nld, const size_t off);
+
+static raidz_inline void
+raidz_flush_data(void);
+
+static raidz_inline size_t
+raidz_col_size(const raidz_map_t *rm, const size_t cidx)
+{
+	return (rm->rm_col[cidx].rc_size);
+}
+
+static raidz_inline void
+raidz_generate_p_impl(raidz_map_t *rm)
+{
+	size_t off;
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+	const size_t csize = raidz_csize(rm);
+
+	for (off = 0; off < ldsize; ) {
+		off += gen_p_block(rm->rm_col, ncols, off);
+	}
+	for (; off < csize; ) {
+		off += gen_p_block(rm->rm_col, nbigcols, off);
+	}
+
+	raidz_flush_data();
+}
+
+static raidz_inline void
+raidz_generate_pq_impl(raidz_map_t *rm)
+{
+	size_t off;
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+	const size_t csize = raidz_csize(rm);
+
+	for (off = 0; off < ldsize; ) {
+		off += gen_pq_block(rm->rm_col, ncols, ncols, off);
+	}
+	for (; off < csize; ) {
+		off += gen_pq_block(rm->rm_col, ncols, nbigcols, off);
+	}
+
+	raidz_flush_data();
+}
+
+static raidz_inline void
+raidz_generate_pqr_impl(raidz_map_t *rm)
+{
+	size_t off;
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+	const size_t csize = raidz_csize(rm);
+
+	for (off = 0; off < ldsize; ) {
+		off += gen_pqr_block(rm->rm_col, ncols, ncols, off);
+	}
+	for (; off < csize; ) {
+		off += gen_pqr_block(rm->rm_col, ncols, nbigcols, off);
+	}
+
+	raidz_flush_data();
+}
+
+static raidz_inline int
+raidz_reconstruct_p_impl(raidz_map_t *rm, const int *tgtidx)
+{
+	size_t off;
+	const size_t parity = raidz_parity(rm);
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+	const size_t xidx = tgtidx[0];
+	const size_t xsize = raidz_col_size(rm, xidx);
+
+	for (off = 0; off < ldsize; ) {
+		off += rec_p_block(rm->rm_col, parity, xidx, ncols, off);
+	}
+	for (; off < xsize; ) {
+		off += rec_p_block(rm->rm_col, parity, xidx, nbigcols, off);
+	}
+
+	raidz_flush_data();
+
+	return (1 << 0);
+}
+
+static raidz_inline int
+raidz_reconstruct_q_impl(raidz_map_t *rm, const int *tgtidx)
+{
+	size_t off;
+	const size_t parity = raidz_parity(rm);
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+	const size_t xidx = tgtidx[0];
+	const size_t xsize = raidz_col_size(rm, xidx);
+
+	const int tgtmul = fix_mul_exponent(255 - (ncols - xidx - 1));
+
+	for (off = 0; off < ldsize; ) {
+		off += rec_q_block(rm->rm_col, parity, xidx, tgtmul,
+			ncols, ncols, off);
+	}
+	for (; off < xsize; ) {
+		off += rec_q_block(rm->rm_col, parity, xidx, tgtmul,
+			ncols, nbigcols, off);
+	}
+
+	raidz_flush_data();
+
+	return (1 << 1);
+}
+
+static raidz_inline int
+raidz_reconstruct_r_impl(raidz_map_t *rm, const int *tgtidx)
+{
+	size_t off;
+	const size_t parity = raidz_parity(rm);
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+	const size_t xidx = tgtidx[0];
+	const size_t xsize = raidz_col_size(rm, xidx);
+
+	const int tgtmul = fix_mul_exponent(255 - 2 * (ncols - xidx - 1));
+
+	for (off = 0; off < ldsize; ) {
+		off += rec_r_block(rm->rm_col, parity, xidx,
+			tgtmul, ncols, ncols, off);
+	}
+	for (; off < xsize; ) {
+		off += rec_r_block(rm->rm_col, parity, xidx,
+			tgtmul, ncols, nbigcols, off);
+	}
+
+	raidz_flush_data();
+
+	return (1 << 2);
+}
+
+static raidz_inline int
+raidz_reconstruct_pq_impl(raidz_map_t *rm, const int *tgtidx)
+{
+	size_t off;
+	int tmp, aexp, bexp, a, b;
+
+	const size_t parity = raidz_parity(rm);
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+
+	const size_t xidx = tgtidx[0];
+	const size_t yidx = tgtidx[1];
+	const size_t xsize = raidz_col_size(rm, xidx);
+	const size_t ysize = raidz_col_size(rm, yidx);
+
+	a = vdev_raidz_pow2[255 + xidx - yidx];
+	b = vdev_raidz_pow2[255 - (ncols - 1 - xidx)];
+	tmp = 255 - vdev_raidz_log2[a ^ 0x01];
+
+	aexp = fix_mul_exponent(vdev_raidz_log2[vdev_raidz_exp2(a, tmp)]);
+	bexp = fix_mul_exponent(vdev_raidz_log2[vdev_raidz_exp2(b, tmp)]);
+
+	for (off = 0; off < ldsize; ) {
+		off += rec_pq_block(rm->rm_col, parity, xidx, yidx,
+			xsize, xsize, aexp, bexp, ncols, ncols, off);
+	}
+	for (; off < xsize; ) {
+		off += rec_pq_block(rm->rm_col, parity, xidx, yidx,
+			xsize, ysize, aexp, bexp, ncols, nbigcols, off);
+	}
+
+	raidz_flush_data();
+
+	return ((1 << 0) | (1 << 1));
+}
+
+static raidz_inline int
+raidz_reconstruct_pr_impl(raidz_map_t *rm, const int *tgtidx)
+{
+	size_t off;
+	int tmp, aexp, bexp, a, b;
+
+	const size_t parity = raidz_parity(rm);
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+
+	const size_t xidx = tgtidx[0];
+	const size_t yidx = tgtidx[1];
+	const size_t xsize = raidz_col_size(rm, xidx);
+	const size_t ysize = raidz_col_size(rm, yidx);
+
+	a = vdev_raidz_pow2[255 + 2 * xidx - 2 * yidx];
+	b = vdev_raidz_pow2[255 - 2 * (ncols - 1 - xidx)];
+	tmp = 255 - vdev_raidz_log2[a ^ 0x01];
+
+	aexp = fix_mul_exponent(vdev_raidz_log2[vdev_raidz_exp2(a, tmp)]);
+	bexp = fix_mul_exponent(vdev_raidz_log2[vdev_raidz_exp2(b, tmp)]);
+
+	for (off = 0; off < ldsize; ) {
+		off += rec_pr_block(rm->rm_col, parity, xidx, yidx,
+			xsize, xsize, aexp, bexp, ncols, ncols, off);
+	}
+	for (; off < xsize; ) {
+		off += rec_pr_block(rm->rm_col, parity, xidx, yidx,
+			xsize, ysize, aexp, bexp, ncols, nbigcols, off);
+	}
+
+	raidz_flush_data();
+
+	return ((1 << 0) | (1 << 2));
+}
+
+static raidz_inline int
+raidz_reconstruct_qr_impl(raidz_map_t *rm, const int *tgtidx)
+{
+	size_t off;
+	int xqmul_exp, xmul_exp, yqmul_exp, ymul_exp, denom;
+
+	const size_t parity = raidz_parity(rm);
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+
+	const size_t xidx = tgtidx[0];
+	const size_t yidx = tgtidx[1];
+	const size_t xsize = raidz_col_size(rm, xidx);
+	const size_t ysize = raidz_col_size(rm, yidx);
+
+	denom = 255 - vdev_raidz_log2[
+			vdev_raidz_pow2[3 * ncols - 3 - xidx - 2 * yidx] ^
+			vdev_raidz_pow2[3 * ncols - 3 - 2 * xidx - yidx]
+		];
+
+	xqmul_exp = fix_mul_exponent(ncols - 1 - yidx);
+	xmul_exp = fix_mul_exponent(ncols - 1 - yidx + denom);
+
+	yqmul_exp = fix_mul_exponent(ncols - 1 - xidx);
+	ymul_exp = fix_mul_exponent(ncols - 1 - xidx + denom);
+
+	for (off = 0; off < ldsize; ) {
+		off += rec_qr_block(rm->rm_col, parity, xidx, yidx,
+			xsize, xsize, xqmul_exp, xmul_exp, yqmul_exp, ymul_exp,
+			ncols, ncols, off);
+	}
+	for (; off < xsize; ) {
+		off += rec_qr_block(rm->rm_col, parity, xidx, yidx,
+			xsize, ysize, xqmul_exp, xmul_exp, yqmul_exp, ymul_exp,
+			ncols, nbigcols, off);
+	}
+
+	raidz_flush_data();
+
+	return ((1 << 1) | (1 << 2));
+}
+
+static raidz_inline int
+raidz_reconstruct_pqr_impl(raidz_map_t *rm, const int *tgtidx)
+{
+	size_t off;
+	int xp_exp, xq_exp, xr_exp, yp_exp, yq_exp, yu_exp, xdenom, ydenom;
+
+	const size_t parity = raidz_parity(rm);
+	const size_t ncols = raidz_ncols(rm);
+	const size_t nbigcols = raidz_nbigcols(rm);
+	const size_t ldsize = raidz_ldsize(rm);
+
+	const size_t xidx = tgtidx[0];
+	const size_t yidx = tgtidx[1];
+	const size_t zidx = tgtidx[2];
+	const size_t xsize = raidz_col_size(rm, xidx);
+	const size_t ysize = raidz_col_size(rm, yidx);
+	const size_t zsize = raidz_col_size(rm, zidx);
+
+	xdenom = 255 - vdev_raidz_log2[
+			vdev_raidz_pow2[3 * ncols - 3 - 2 * xidx - yidx] ^
+			vdev_raidz_pow2[3 * ncols - 3 - xidx - 2 * yidx] ^
+			vdev_raidz_pow2[3 * ncols - 3 - 2 * xidx - zidx] ^
+			vdev_raidz_pow2[3 * ncols - 3 - xidx - 2 * zidx] ^
+			vdev_raidz_pow2[3 * ncols - 3 - 2 * yidx - zidx] ^
+			vdev_raidz_pow2[3 * ncols - 3 - yidx - 2 * zidx]
+		];
+
+	xp_exp = fix_mul_exponent(vdev_raidz_log2[
+			vdev_raidz_pow2[3 * ncols - 3 - 2 * yidx - zidx] ^
+			vdev_raidz_pow2[3 * ncols - 3 - yidx - 2 * zidx]
+		] + xdenom);
+	xq_exp = fix_mul_exponent(vdev_raidz_log2[
+			vdev_raidz_pow2[2 * ncols - 2 - 2 * yidx] ^
+			vdev_raidz_pow2[2 * ncols - 2 - 2 * zidx]
+		] + xdenom);
+	xr_exp = fix_mul_exponent(vdev_raidz_log2[
+			vdev_raidz_pow2[ncols - 1 - yidx] ^
+			vdev_raidz_pow2[ncols - 1 - zidx]
+		] + xdenom);
+
+	ydenom = 255 - vdev_raidz_log2[
+					vdev_raidz_pow2[ncols - 1 - yidx] ^
+					vdev_raidz_pow2[ncols - 1 - zidx]
+				];
+
+	yp_exp = fix_mul_exponent(ncols - 1 - zidx + ydenom);
+	yq_exp = fix_mul_exponent(ydenom);
+	yu_exp = fix_mul_exponent(ncols - 1 - xidx);
+
+	for (off = 0; off < ldsize; ) {
+		off += rec_pqr_block(rm->rm_col, parity, xidx, yidx, zidx,
+			xsize, xsize, xsize, xp_exp, xq_exp, xr_exp,
+			yp_exp, yq_exp, yu_exp, ncols, ncols, off);
+	}
+	for (; off < xsize; ) {
+		off += rec_pqr_block(rm->rm_col, parity, xidx, yidx, zidx,
+			xsize, ysize, zsize, xp_exp, xq_exp, xr_exp,
+			yp_exp, yq_exp, yu_exp, ncols, nbigcols, off);
+	}
+
+	raidz_flush_data();
+
+	return ((1 << 0) | (1 << 1) | (1 << 2));
+}
+
+#endif /* _VDEV_RAIDZ_MATH_IMPL_H */
diff --git a/module/zfs/vdev_raidz_math_scalar.c b/module/zfs/vdev_raidz_math_scalar.c
new file mode 100644
index 000000000000..f44b3052b1f6
--- /dev/null
+++ b/module/zfs/vdev_raidz_math_scalar.c
@@ -0,0 +1,659 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#include <sys/vdev_raidz_impl.h>
+
+/*
+ * Provide native cpu scalar routines.
+ * Support 32bit and 64bit CPUs. Check the size of unsigned long long
+ * to determine native register size .
+ */
+
+#if (((~(0ULL)) >> 24) == 0xFF)
+#define	RAIDZ_ELEM_SIZE (4)
+#elif (((~(0ULL)) >> 56) == 0xFF)
+#define	RAIDZ_ELEM_SIZE (8)
+#else
+#error "VDEV_RAIDZ: Native CPU register size not supported."
+#endif
+
+typedef union elem {
+	unsigned long long e;
+	unsigned char b[RAIDZ_ELEM_SIZE];
+} elem_t __attribute__((aligned(RAIDZ_ELEM_SIZE)));
+
+static const struct raidz_scalar_constants {
+	elem_t mod;
+	elem_t mask;
+	elem_t check;
+} raidz_scalar_constants = {
+#if RAIDZ_ELEM_SIZE == 8
+	.mod.e   = 0x1d1d1d1d1d1d1d1dULL,
+	.mask.e  = 0xfefefefefefefefeULL,
+	.check.e = 0x8080808080808080ULL,
+#else
+	.mod.e   = 0x1d1d1d1dULL,
+	.mask.e  = 0xfefefefeULL,
+	.check.e = 0x80808080ULL,
+#endif
+};
+
+/* Keep multiplication in log form for scalar */
+raidz_inline static int
+fix_mul_exponent(int e) {
+	while (e > 255)
+		e -= 255;
+	return (e);
+}
+
+static raidz_inline void
+xor_acc_x2(const elem_t *data, elem_t *a0, elem_t *a1)
+{
+	a0->e ^= data[0].e;
+	a1->e ^= data[1].e;
+}
+
+static raidz_inline void
+load_x2(const elem_t *src, elem_t *a0, elem_t *a1)
+{
+	a0->e = src[0].e;
+	a1->e = src[1].e;
+}
+
+static raidz_inline void
+store_x2(elem_t *dst, elem_t a0, elem_t a1)
+{
+	dst[0].e = a0.e;
+	dst[1].e = a1.e;
+}
+
+static raidz_inline void
+zero_store_x2(elem_t *dst)
+{
+	dst[0].e = dst[1].e = 0;
+}
+
+static raidz_inline void
+xor_x2(const elem_t a0, const elem_t a1, elem_t *r0, elem_t *r1)
+{
+	r0->e ^= a0.e;
+	r1->e ^= a1.e;
+}
+
+static raidz_inline void
+copy_x2(const elem_t a0, const elem_t a1, elem_t *c0, elem_t *c1)
+{
+	c0->e = a0.e;
+	c1->e = a1.e;
+}
+
+static raidz_inline void
+zero_x2(elem_t *r0, elem_t *r1)
+{
+	r0->e = r1->e = 0ULL;
+}
+
+static raidz_inline void
+mul2_x2(elem_t *a0, elem_t *a1)
+{
+	elem_t cmp, dbl, mask;
+
+	cmp.e = (*a0).e & raidz_scalar_constants.check.e;
+	mask.e = (cmp.e << 1) - (cmp.e >> 7);
+	dbl.e = ((*a0).e << 1) & raidz_scalar_constants.mask.e;
+	(*a0).e = dbl.e ^ (mask.e & raidz_scalar_constants.mod.e);
+
+	cmp.e = (*a1).e & raidz_scalar_constants.check.e;
+	mask.e = (cmp.e << 1) - (cmp.e >> 7);
+	dbl.e = ((*a1).e << 1) & raidz_scalar_constants.mask.e;
+	(*a1).e = dbl.e ^ (mask.e & raidz_scalar_constants.mod.e);
+}
+
+static raidz_inline void
+mul4_x2(elem_t *a0, elem_t *a1)
+{
+	mul2_x2(a0, a1);
+	mul2_x2(a0, a1);
+}
+
+static raidz_inline elem_t
+exp2_x1(const elem_t a, const int mul)
+{
+	elem_t r;
+	switch (RAIDZ_ELEM_SIZE) {
+		case 8:
+			r.b[7] = vdev_raidz_exp2(a.b[7], mul);
+			r.b[6] = vdev_raidz_exp2(a.b[6], mul);
+			r.b[5] = vdev_raidz_exp2(a.b[5], mul);
+			r.b[4] = vdev_raidz_exp2(a.b[4], mul);
+		case 4:
+			r.b[3] = vdev_raidz_exp2(a.b[3], mul);
+			r.b[2] = vdev_raidz_exp2(a.b[2], mul);
+			r.b[1] = vdev_raidz_exp2(a.b[1], mul);
+			r.b[0] = vdev_raidz_exp2(a.b[0], mul);
+	}
+	return (r);
+}
+
+static raidz_inline void
+exp2_x2(elem_t *a0, elem_t *a1, const int mul)
+{
+	*a0 = exp2_x1(*a0, mul);
+	*a1 = exp2_x1(*a1, mul);
+}
+
+static raidz_inline void
+raidz_flush_data(void)
+{
+}
+
+#define	D(idx) ((elem_t *)(((uint8_t *)cols[idx].rc_data) + off))
+
+static raidz_inline size_t
+gen_p_block(raidz_col_t *cols, const size_t nd, const size_t off)
+{
+	size_t c;
+	elem_t p0, p1;
+
+	load_x2(D(CODE_P+1), &p0, &p1);
+	for (c = 2; c < nd; c++) {
+		xor_acc_x2(D(c), &p0, &p1);
+	}
+	store_x2(D(CODE_P), p0, p1);
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+gen_pq_block(raidz_col_t *cols, const size_t nd, const size_t nld,
+	const size_t off)
+{
+	size_t c;
+	elem_t p0, p1;
+	elem_t q0, q1;
+
+	load_x2(D(CODE_Q+1), &p0, &p1);
+	copy_x2(p0, p1, &q0, &q1);
+	for (c = 3; c < nld; c++) {
+		mul2_x2(&q0, &q1);
+		xor_acc_x2(D(c), &p0, &p1);
+		xor_acc_x2(D(c), &q0, &q1);
+	}
+	store_x2(D(CODE_P), p0, p1);
+
+	for (; c < nd; c++) {
+		mul2_x2(&q0, &q1);
+	}
+	store_x2(D(CODE_Q), q0, q1);
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+gen_pqr_block(raidz_col_t *cols, const size_t nd, const size_t nld,
+	const size_t off)
+{
+	size_t c;
+	elem_t p0, p1;
+	elem_t q0, q1;
+	elem_t r0, r1;
+
+	load_x2(D(CODE_R+1), &p0, &p1);
+	copy_x2(p0, p1, &q0, &q1);
+	copy_x2(p0, p1, &r0, &r1);
+
+	for (c = 4; c < nld; c++) {
+		mul2_x2(&q0, &q1);
+		mul4_x2(&r0, &r1);
+		xor_acc_x2(D(c), &p0, &p1);
+		xor_acc_x2(D(c), &q0, &q1);
+		xor_acc_x2(D(c), &r0, &r1);
+	}
+	store_x2(D(CODE_P), p0, p1);
+
+	for (; c < nd; c++) {
+		mul2_x2(&q0, &q1);
+		mul4_x2(&r0, &r1);
+	}
+	store_x2(D(CODE_Q), q0, q1);
+	store_x2(D(CODE_R), r0, r1);
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_p_block(raidz_col_t *cols, const size_t parity,
+	const size_t xidx, const size_t nd, const size_t off)
+{
+	size_t c;
+	elem_t p0, p1;
+
+	zero_store_x2(D(xidx));
+	load_x2(D(parity), &p0, &p1);
+
+	for (c = parity+1; c < nd; c++) {
+		xor_acc_x2(D(c), &p0, &p1);
+	}
+	xor_acc_x2(D(CODE_P), &p0, &p1);
+	store_x2(D(xidx), p0, p1);
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_q_block(raidz_col_t *cols, const size_t parity,
+	const size_t xidx, const int x_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+	elem_t q0, q1;
+
+	zero_store_x2(D(xidx));
+	load_x2(D(parity), &q0, &q1);
+
+	for (c = parity+1; c < nld; c++) {
+		mul2_x2(&q0, &q1);
+		xor_acc_x2(D(c), &q0, &q1);
+	}
+	for (; c < nd; c++) {
+		mul2_x2(&q0, &q1);
+	}
+
+	xor_acc_x2(D(CODE_Q), &q0, &q1);
+	exp2_x2(&q0, &q1, x_mul);
+	store_x2(D(xidx), q0, q1);
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_r_block(raidz_col_t *cols, const size_t parity,
+	const size_t xidx, const int x_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+	elem_t r0, r1;
+
+	zero_store_x2(D(xidx));
+	load_x2(D(parity), &r0, &r1);
+
+	for (c = parity+1; c < nld; c++) {
+		mul4_x2(&r0, &r1);
+		xor_acc_x2(D(c), &r0, &r1);
+	}
+	for (; c < nd; c++) {
+		mul4_x2(&r0, &r1);
+	}
+	xor_acc_x2(D(CODE_R), &r0, &r1);
+	exp2_x2(&r0, &r1, x_mul);
+
+	store_x2(D(xidx), r0, r1);
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_pq_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y, const size_t xsize, const size_t ysize,
+	const int a_mul, const int b_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+	elem_t p0, p1;
+	elem_t q0, q1;
+	elem_t t0, t1;
+
+	zero_x2(&p0, &p1);
+	zero_x2(&q0, &q1);
+
+	for (c = parity; c < nld; c++) {
+		mul2_x2(&q0, &q1);
+		if (c != x && c != y) {
+			xor_acc_x2(D(c), &p0, &p1);
+			xor_acc_x2(D(c), &q0, &q1);
+		}
+	}
+	for (; c < nd; c++) {
+		mul2_x2(&q0, &q1);
+	}
+
+	xor_acc_x2(D(CODE_P), &p0, &p1);
+	xor_acc_x2(D(CODE_Q), &q0, &q1);
+
+	/* Save Pxy */
+	copy_x2(p0, p1, &t0, &t1);
+
+	/* Calc X */
+	exp2_x2(&p0, &p1, a_mul);
+	exp2_x2(&q0, &q1, b_mul);
+	xor_x2(q0, q1, &p0, &p1);
+	store_x2(D(x), p0, p1);
+
+	if (xsize == ysize) {
+		/* Calc Y */
+		xor_x2(t0, t1, &p0, &p1);
+		store_x2(D(y), p0, p1);
+	}
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_pr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y, const size_t xsize,
+	const size_t ysize, const int a_mul, const int b_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+	elem_t p0, p1;
+	elem_t r0, r1;
+	elem_t t0, t1;
+
+	zero_x2(&p0, &p1);
+	zero_x2(&r0, &r1);
+
+	for (c = parity; c < nld; c++) {
+		mul4_x2(&r0, &r1);
+		if (c != x && c != y) {
+			xor_acc_x2(D(c), &p0, &p1);
+			xor_acc_x2(D(c), &r0, &r1);
+		}
+	}
+	for (; c < nd; c++) {
+		mul4_x2(&r0, &r1);
+	}
+
+	xor_acc_x2(D(CODE_P), &p0, &p1);
+	xor_acc_x2(D(CODE_R), &r0, &r1);
+
+	/* Save Pxy */
+	copy_x2(p0, p1, &t0, &t1);
+
+	/* Calc X */
+	exp2_x2(&p0, &p1, a_mul);
+	exp2_x2(&r0, &r1, b_mul);
+	xor_x2(r0, r1, &p0, &p1);
+	store_x2(D(x), p0, p1);
+
+	if (xsize == ysize) {
+		/* Calc Y */
+		xor_x2(t0, t1, &p0, &p1);
+		store_x2(D(y), p0, p1);
+	}
+
+	return (2 * sizeof (elem_t));
+}
+
+
+static raidz_inline size_t
+rec_qr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y, const size_t xsize,
+	const size_t ysize, const int xq_mul, const int x_mul,
+	const int yq_mul, const int y_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+	elem_t q0, q1;
+	elem_t r0, r1;
+	elem_t t0, t1;
+
+	zero_x2(&q0, &q1);
+	zero_x2(&r0, &r1);
+
+	for (c = parity; c < nld; c++) {
+		mul2_x2(&q0, &q1);
+		mul4_x2(&r0, &r1);
+		if (c != x && c != y) {
+			xor_acc_x2(D(c), &q0, &q1);
+			xor_acc_x2(D(c), &r0, &r1);
+		}
+	}
+	for (; c < nd; c++) {
+		mul2_x2(&q0, &q1);
+		mul4_x2(&r0, &r1);
+	}
+
+	xor_acc_x2(D(CODE_Q), &q0, &q1);
+	xor_acc_x2(D(CODE_R), &r0, &r1);
+
+	/* Calc X */
+	copy_x2(q0, q1, &t0, &t1);
+	exp2_x2(&t0, &t1, xq_mul); /* X = Q * xqm */
+	xor_x2(r0, r1, &t0, &t1); /* X = R ^ X   */
+	exp2_x2(&t0, &t1, x_mul);  /* X = X * xm  */
+	store_x2(D(x), t0, t1);
+
+	if (xsize == ysize) {
+		/* Calc Y */
+		exp2_x2(&q0, &q1, yq_mul);
+		xor_x2(r0, r1, &q0, &q1);
+		exp2_x2(&q0, &q1, y_mul);
+		store_x2(D(y), q0, q1);
+	}
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_pqr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y, const size_t z,
+	const size_t xsize, const size_t ysize, const size_t zsize,
+	const int xp_mul, const int xq_mul, const int xr_mul,
+	const int yp_mul, const int yq_mul, const int upd_q_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+	elem_t p0, p1, q0, q1, r0, r1;
+	elem_t t0, t1, t2, t3;
+
+	zero_x2(&p0, &p1);
+	zero_x2(&q0, &q1);
+	zero_x2(&r0, &r1);
+
+	for (c = parity; c < nld; c++) {
+		mul2_x2(&q0, &q1);
+		mul4_x2(&r0, &r1);
+		if (c != x && c != y && c != z) {
+			xor_acc_x2(D(c), &p0, &p1);
+			xor_acc_x2(D(c), &q0, &q1);
+			xor_acc_x2(D(c), &r0, &r1);
+		}
+	}
+	for (; c < nd; c++) {
+		mul2_x2(&q0, &q1);
+		mul4_x2(&r0, &r1);
+	}
+
+	xor_acc_x2(D(CODE_P), &p0, &p1);
+	xor_acc_x2(D(CODE_Q), &q0, &q1);
+	xor_acc_x2(D(CODE_R), &r0, &r1);
+
+	/* Calc X */
+	copy_x2(p0, p1, &t0, &t1);
+	exp2_x2(&t0, &t1, xp_mul);
+	copy_x2(q0, q1, &t2, &t3);
+	exp2_x2(&t2, &t3, xq_mul);
+	xor_x2(t2, t3, &t0, &t1);
+	exp2_x2(&r0, &r1, xr_mul);
+	xor_x2(r0, r1, &t0, &t1);
+	store_x2(D(x), t0, t1);
+
+
+	if (ysize == xsize) {
+		/* Calc Y */
+		xor_x2(t0, t1, &p0, &p1);
+		exp2_x2(&t0, &t1, upd_q_mul);
+		xor_x2(t0, t1, &q0, &q1);
+
+		copy_x2(p0, p1, &t0, &t1);
+		exp2_x2(&t0, &t1, yp_mul);
+		exp2_x2(&q0, &q1, yq_mul);
+		xor_x2(q0, q1, &t0, &t1);
+		store_x2(D(y), t0, t1);
+
+		if (zsize == xsize) {
+			/* Calc Z */
+			xor_x2(p0, p1, &t0, &t1);
+			store_x2(D(z), t0, t1);
+		}
+	}
+
+	return (2 * sizeof (elem_t));
+}
+
+
+#include "vdev_raidz_math_impl.h"
+
+static boolean_t
+raidz_math_will_scalar_work(void)
+{
+	return (B_TRUE); /* will always work */
+}
+
+RAIDZ_SCALAR_GEN_WRAP(p, scalar);
+RAIDZ_SCALAR_GEN_WRAP(pq, scalar);
+RAIDZ_SCALAR_GEN_WRAP(pqr, scalar);
+
+RAIDZ_SCALAR_REC_WRAP(p, scalar);
+RAIDZ_SCALAR_REC_WRAP(q, scalar);
+RAIDZ_SCALAR_REC_WRAP(r, scalar);
+RAIDZ_SCALAR_REC_WRAP(pq, scalar);
+RAIDZ_SCALAR_REC_WRAP(pr, scalar);
+RAIDZ_SCALAR_REC_WRAP(qr, scalar);
+RAIDZ_SCALAR_REC_WRAP(pqr, scalar);
+
+const raidz_math_ops_t vdev_raidz_scalar_impl = {
+	.gen = { &scalar_gen_p, &scalar_gen_pq, &scalar_gen_pqr },
+	.rec = {
+		&scalar_rec_p, &scalar_rec_q, &scalar_rec_r,
+		&scalar_rec_pq, &scalar_rec_pr, &scalar_rec_qr,
+		&scalar_rec_pqr
+	},
+	.is_supported = &raidz_math_will_scalar_work,
+	.name = "scalar"
+};
+
+/* Powers of 2 in the Galois field defined above. */
+const unsigned char vdev_raidz_pow2[511] __attribute__((aligned(256))) = {
+	0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+	0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
+	0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9,
+	0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
+	0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35,
+	0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
+	0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0,
+	0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
+	0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc,
+	0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
+	0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f,
+	0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
+	0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88,
+	0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
+	0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93,
+	0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
+	0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9,
+	0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
+	0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa,
+	0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
+	0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e,
+	0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
+	0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4,
+	0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
+	0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e,
+	0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
+	0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef,
+	0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
+	0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5,
+	0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
+	0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83,
+	0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01,
+	0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+	0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
+	0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9,
+	0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
+	0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35,
+	0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
+	0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0,
+	0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
+	0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc,
+	0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
+	0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f,
+	0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
+	0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88,
+	0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
+	0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93,
+	0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
+	0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9,
+	0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
+	0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa,
+	0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
+	0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e,
+	0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
+	0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4,
+	0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
+	0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e,
+	0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
+	0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef,
+	0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
+	0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5,
+	0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
+	0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83,
+	0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01
+};
+
+/* Logs of 2 in the Galois field defined above. */
+const unsigned char vdev_raidz_log2[256] __attribute__((aligned(256))) = {
+	0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6,
+	0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
+	0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81,
+	0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
+	0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21,
+	0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
+	0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9,
+	0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
+	0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd,
+	0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
+	0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd,
+	0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
+	0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e,
+	0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
+	0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b,
+	0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
+	0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d,
+	0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
+	0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c,
+	0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
+	0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd,
+	0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
+	0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e,
+	0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
+	0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76,
+	0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
+	0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa,
+	0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
+	0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51,
+	0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
+	0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8,
+	0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf,
+};
diff --git a/module/zfs/vdev_raidz_math_sse.c b/module/zfs/vdev_raidz_math_sse.c
new file mode 100644
index 000000000000..a14183918821
--- /dev/null
+++ b/module/zfs/vdev_raidz_math_sse.c
@@ -0,0 +1,2385 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#if defined(_KERNEL)
+#include <linux/version.h>
+#include <sys/disp.h>
+
+#endif /* defined(_KERNEL) */
+
+#include <linux/simd_x86.h>
+#include <sys/types.h>
+#include <sys/vdev_raidz.h>
+
+/*
+ * Only in 64bit for now
+ */
+#if defined(RAIDZ_SSE_x86_64)
+
+#include <sys/vdev_raidz_impl.h>
+
+#define	__asm __asm__ __volatile__
+
+#define	_REG_CNT(_0, _1, _2, _3, _4, _5, _6, _7, N, ...) N
+#define	REG_CNT(r...) _REG_CNT(r, 8, 7, 6, 5, 4, 3, 2, 1)
+
+#define	VR0_(REG, ...) "xmm"#REG
+#define	VR1_(_1, REG, ...) "xmm"#REG
+#define	VR2_(_1, _2, REG, ...) "xmm"#REG
+#define	VR3_(_1, _2, _3, REG, ...) "xmm"#REG
+#define	VR4_(_1, _2, _3, _4, REG, ...) "xmm"#REG
+#define	VR5_(_1, _2, _3, _4, _5, REG, ...) "xmm"#REG
+#define	VR6_(_1, _2, _3, _4, _5, _6, REG, ...) "xmm"#REG
+#define	VR7_(_1, _2, _3, _4, _5, _6, _7, REG, ...) "xmm"#REG
+
+#define	VR0(r...) VR0_(r)
+#define	VR1(r...) VR1_(r)
+#define	VR2(r...) VR2_(r, 1)
+#define	VR3(r...) VR3_(r, 1, 2)
+#define	VR4(r...) VR4_(r, 1)
+#define	VR5(r...) VR5_(r, 1, 2)
+#define	VR6(r...) VR6_(r, 1, 2, 3)
+#define	VR7(r...) VR7_(r, 1, 2, 3, 4)
+
+#define	R_01(REG1, REG2, ...) REG1, REG2
+#define	R_23_(_0, _1, REG2, REG3, ...) REG2, REG3
+#define	R_23(REG...) R_23_(REG, 1, 2, 3)
+
+#define	ELEM_SIZE 16
+
+const uint8_t sse_gf_mod_lt[2*256][16] __attribute__((aligned(256)));
+const uint8_t sse_clmul_mod_lt[2*256][16] __attribute__((aligned(256)));
+
+typedef struct elem {
+	unsigned char b[ELEM_SIZE];
+} elem_t __attribute__((aligned(ELEM_SIZE)));
+
+/* Convert from GF log to perform multiplications using SIMD */
+static raidz_inline int
+fix_mul_exponent(int e) {
+	return ((int)vdev_raidz_pow2[e]);
+}
+
+#define	PREFETCHNTA(ptr, offset, stride) \
+{	\
+	switch (stride) {	\
+	case 4:	\
+		__asm("prefetchnta %0" :: "m" (((elem_t *)ptr)[offset+2])); \
+	case 2:	\
+	__asm("prefetchnta %0" :: "m" (((elem_t *)ptr)[offset+0])); \
+	}\
+}
+
+#define	XOR_ACC(src, r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 4:	\
+		__asm("pxor %0, %%" VR3(r) : : "m" (((elem_t *)src)[3]));\
+		__asm("pxor %0, %%" VR2(r) : : "m" (((elem_t *)src)[2]));\
+	case 2:	\
+		__asm("pxor %0, %%" VR1(r) : : "m" (((elem_t *)src)[1]));\
+	case 1:	\
+		__asm("pxor %0, %%" VR0(r) : : "m" (((elem_t *)src)[0]));\
+	}\
+}
+
+#define	XOR(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 8:\
+		__asm("pxor %" VR0(r) ", %" VR4(r));\
+		__asm("pxor %" VR1(r) ", %" VR5(r));\
+		__asm("pxor %" VR2(r) ", %" VR6(r));\
+		__asm("pxor %" VR3(r) ", %" VR7(r));\
+		break;\
+	case 4:\
+		__asm("pxor %" VR0(r) ", %" VR2(r));\
+		__asm("pxor %" VR1(r) ", %" VR3(r));\
+		break;\
+	case 2:\
+		__asm("pxor %" VR0(r) ", %" VR1(r));\
+		break;\
+	}\
+}
+
+#define	COPY(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 8:\
+		__asm("movdqa %" VR0(r) ", %" VR4(r));\
+		__asm("movdqa %" VR1(r) ", %" VR5(r));\
+		__asm("movdqa %" VR2(r) ", %" VR6(r));\
+		__asm("movdqa %" VR3(r) ", %" VR7(r));\
+		break;\
+	case 4:\
+		__asm("movdqa %" VR0(r) ", %" VR2(r));\
+		__asm("movdqa %" VR1(r) ", %" VR3(r));\
+		break;\
+	case 2:\
+		__asm("movdqa %" VR0(r) ", %" VR1(r));\
+		break;\
+	}\
+}
+
+#define	LOAD(src, r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 4:	\
+		__asm("movdqa %0, %%" VR3(r) : : "m" (((elem_t *)src)[3]));\
+		__asm("movdqa %0, %%" VR2(r) : : "m" (((elem_t *)src)[2]));\
+	case 2:	\
+		__asm("movdqa %0, %%" VR1(r) : : "m" (((elem_t *)src)[1]));\
+	case 1:	\
+		__asm("movdqa %0, %%" VR0(r) : : "m" (((elem_t *)src)[0]));\
+	}\
+}
+
+#define	ZERO(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 4:	\
+		__asm("pxor %" VR3(r)", %" VR3(r));\
+		__asm("pxor %" VR2(r)", %" VR2(r));\
+	case 2:	\
+		__asm("pxor %" VR1(r)", %" VR1(r));\
+	case 1:	\
+		__asm("pxor %" VR0(r)", %" VR0(r));\
+	}\
+}
+
+#define	STREAM_STORE(dst, r...)   \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 4:	\
+		__asm("movntdq %%" VR3(r)", %0" : "=m" (((elem_t *)dst)[3]));\
+		__asm("movntdq %%" VR2(r)", %0" : "=m" (((elem_t *)dst)[2]));\
+	case 2:	\
+		__asm("movntdq %%" VR1(r)", %0" : "=m" (((elem_t *)dst)[1]));\
+	case 1:	\
+		__asm("movntdq %%" VR0(r)", %0" : "=m" (((elem_t *)dst)[0]));\
+	}\
+}
+
+#define	FLUSH() \
+{	\
+	__asm("sfence" : : : "memory");  \
+}
+
+#define	MUL2_SETUP() \
+{   \
+	__asm("movd %0, %%xmm15" :: "r"(0x1d1d1d1d));	\
+	__asm("pshufd $0x0, %xmm15, %xmm15");			\
+}
+
+#define	MUL2_(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 2:	\
+	__asm("pxor    %xmm14,      %xmm14");   \
+	__asm("pxor    %xmm13,      %xmm13");   \
+	__asm("pcmpgtb %" VR0(r)",  %xmm14");   \
+	__asm("pcmpgtb %" VR1(r)",  %xmm13");   \
+	__asm("pand    %xmm15,      %xmm14");   \
+	__asm("pand    %xmm15,      %xmm13");	\
+	__asm("paddb   %" VR0(r)", %" VR0(r));	\
+	__asm("paddb   %" VR1(r)", %" VR1(r));	\
+	__asm("pxor    %xmm14,      %" VR0(r));	\
+	__asm("pxor    %xmm13,      %" VR1(r));	\
+	break;\
+	}\
+}
+
+#define	MUL2(r...) \
+{	\
+	switch (REG_CNT(r)) {	\
+	case 2:	\
+		MUL2_(r);\
+		break;\
+	case 4:	\
+		MUL2_(R_01(r));\
+		MUL2_(R_23(r));\
+		break;\
+	}\
+}
+
+#define	MUL4(r...) \
+{	\
+	MUL2(r);\
+	MUL2(r);\
+}
+
+#define	_0f			"xmm15"
+#define	_a_save		"xmm14"
+#define	_b_save		"xmm13"
+#define	_lt_mod_a	"xmm12"
+#define	_lt_clmul_a	"xmm11"
+#define	_lt_mod_b	"xmm10"
+#define	_lt_clmul_b	"xmm15"
+
+#define	MULx2(c, r...)	\
+{	\
+	__asm("movd %0, %%" _0f :: "r"(0x0f0f0f0f));\
+	__asm("pshufd $0x0, %" _0f ", %" _0f);\
+	/* upper bits */\
+	__asm("movdqa %0, %%" _lt_mod_a			\
+		: : "m" (sse_gf_mod_lt[2*(c)][0]));	\
+	__asm("movdqa %0, %%" _lt_clmul_a			\
+		: : "m" (sse_clmul_mod_lt[2*(c)][0]));	\
+	\
+	__asm("movdqa %" VR0(r) ", %" _a_save);\
+	__asm("movdqa %" VR1(r) ", %" _b_save);\
+	__asm("psraw $0x4, %" VR0(r));\
+	__asm("psraw $0x4, %" VR1(r));\
+	__asm("pand %" _0f ", %" _a_save);\
+	__asm("pand %" _0f ", %" _b_save);\
+	__asm("pand %" _0f ", %" VR0(r));\
+	__asm("pand %" _0f ", %" VR1(r));\
+	\
+	__asm("movdqa %" _lt_mod_a ", %" _lt_mod_b);\
+	__asm("movdqa %" _lt_clmul_a ", %" _lt_clmul_b);\
+	\
+	__asm("pshufb %" VR0(r) ",%" _lt_mod_a);\
+	__asm("pshufb %" VR1(r) ",%" _lt_mod_b);\
+	__asm("pshufb %" VR0(r) ",%" _lt_clmul_a);\
+	__asm("pshufb %" VR1(r) ",%" _lt_clmul_b);\
+	\
+	__asm("pxor %" _lt_mod_a ",%" _lt_clmul_a);\
+	__asm("pxor %" _lt_mod_b ",%" _lt_clmul_b);\
+	__asm("movdqa %" _lt_clmul_a ",%" VR0(r));\
+	__asm("movdqa %" _lt_clmul_b ",%" VR1(r));\
+	\
+	/* low bits */\
+	__asm("movdqa %0, %%" _lt_mod_a				\
+		: :	"m" (sse_gf_mod_lt[2*(c)+1][0]));	\
+	__asm("movdqa %0, %%" _lt_clmul_a				\
+		: : "m" (sse_clmul_mod_lt[2*(c)+1][0]));	\
+	__asm("movdqa %" _lt_mod_a ", %" _lt_mod_b);\
+	__asm("movdqa %" _lt_clmul_a ", %" _lt_clmul_b);\
+	\
+	__asm("pshufb %" _a_save ",%" _lt_mod_a);\
+	__asm("pshufb %" _b_save ",%" _lt_mod_b);\
+	__asm("pshufb %" _a_save ",%" _lt_clmul_a);\
+	__asm("pshufb %" _b_save ",%" _lt_clmul_b);\
+	\
+	__asm("pxor %" _lt_mod_a ",%" VR0(r));\
+	__asm("pxor %" _lt_mod_b ",%" VR1(r));\
+	__asm("pxor %" _lt_clmul_a ",%" VR0(r));\
+	__asm("pxor %" _lt_clmul_b ",%" VR1(r));\
+}
+
+#include "vdev_raidz_math_x86simd.h"
+#include "vdev_raidz_math_impl.h"
+
+RAIDZ_x86SIMD_GEN_WRAP(p, sse);
+RAIDZ_x86SIMD_GEN_WRAP(pq, sse);
+RAIDZ_x86SIMD_GEN_WRAP(pqr, sse);
+
+RAIDZ_x86SIMD_REC_WRAP(p, sse);
+RAIDZ_x86SIMD_REC_WRAP(q, sse);
+RAIDZ_x86SIMD_REC_WRAP(r, sse);
+RAIDZ_x86SIMD_REC_WRAP(pq, sse);
+RAIDZ_x86SIMD_REC_WRAP(pr, sse);
+RAIDZ_x86SIMD_REC_WRAP(qr, sse);
+RAIDZ_x86SIMD_REC_WRAP(pqr, sse);
+
+static boolean_t
+raidz_math_will_sse_work(void)
+{
+	return (zfs_sse_available() &&
+		zfs_sse2_available() &&
+		zfs_ssse3_available());
+}
+
+const raidz_math_ops_t vdev_raidz_sse_impl = {
+	.gen = { &sse_gen_p, &sse_gen_pq, &sse_gen_pqr },
+	.rec = {
+		&sse_rec_p, &sse_rec_q, &sse_rec_r,
+		&sse_rec_pq, &sse_rec_pr, &sse_rec_qr,
+		&sse_rec_pqr
+	},
+	.is_supported = &raidz_math_will_sse_work,
+	.name = "sse"
+};
+
+#endif /* defined(RAIDZ_SSE_x86_64) */
+
+#if defined(RAIDZ_SSE_x86_64) || defined(RAIDZ_AVX2_x86_64)
+
+const uint8_t
+__attribute__((aligned(256))) sse_gf_mod_lt[2*256][16] = {
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x74, 0x69, 0x4e, 0x53,
+		0xe8, 0xf5, 0xd2, 0xcf, 0x9c, 0x81, 0xa6, 0xbb },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x74, 0x69, 0x4e, 0x53,
+		0xe8, 0xf5, 0xd2, 0xcf, 0x9c, 0x81, 0xa6, 0xbb },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x74, 0x69, 0x4e, 0x53,
+		0xf5, 0xe8, 0xcf, 0xd2, 0x81, 0x9c, 0xbb, 0xa6 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x74, 0x69, 0x4e, 0x53,
+		0xf5, 0xe8, 0xcf, 0xd2, 0x81, 0x9c, 0xbb, 0xa6 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x69, 0x74, 0x53, 0x4e,
+		0xd2, 0xcf, 0xe8, 0xf5, 0xbb, 0xa6, 0x81, 0x9c },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x69, 0x74, 0x53, 0x4e,
+		0xd2, 0xcf, 0xe8, 0xf5, 0xbb, 0xa6, 0x81, 0x9c },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x69, 0x74, 0x53, 0x4e,
+		0xcf, 0xd2, 0xf5, 0xe8, 0xa6, 0xbb, 0x9c, 0x81 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x69, 0x74, 0x53, 0x4e,
+		0xcf, 0xd2, 0xf5, 0xe8, 0xa6, 0xbb, 0x9c, 0x81 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x27, 0x3a, 0x4e, 0x53, 0x69, 0x74,
+		0x9c, 0x81, 0xbb, 0xa6, 0xd2, 0xcf, 0xf5, 0xe8 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x27, 0x3a, 0x4e, 0x53, 0x69, 0x74,
+		0x9c, 0x81, 0xbb, 0xa6, 0xd2, 0xcf, 0xf5, 0xe8 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x27, 0x3a, 0x4e, 0x53, 0x69, 0x74,
+		0x81, 0x9c, 0xa6, 0xbb, 0xcf, 0xd2, 0xe8, 0xf5 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x27, 0x3a, 0x4e, 0x53, 0x69, 0x74,
+		0x81, 0x9c, 0xa6, 0xbb, 0xcf, 0xd2, 0xe8, 0xf5 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x27, 0x3a, 0x53, 0x4e, 0x74, 0x69,
+		0xa6, 0xbb, 0x81, 0x9c, 0xf5, 0xe8, 0xd2, 0xcf },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x27, 0x3a, 0x53, 0x4e, 0x74, 0x69,
+		0xa6, 0xbb, 0x81, 0x9c, 0xf5, 0xe8, 0xd2, 0xcf },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x27, 0x3a, 0x53, 0x4e, 0x74, 0x69,
+		0xbb, 0xa6, 0x9c, 0x81, 0xe8, 0xf5, 0xcf, 0xd2 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x1d, 0x27, 0x3a, 0x53, 0x4e, 0x74, 0x69,
+		0xbb, 0xa6, 0x9c, 0x81, 0xe8, 0xf5, 0xcf, 0xd2 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xe8, 0xd2, 0x9c, 0xa6,
+		0xcd, 0xf7, 0xb9, 0x83, 0x25, 0x1f, 0x51, 0x6b },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xe8, 0xd2, 0x9c, 0xa6,
+		0xcd, 0xf7, 0xb9, 0x83, 0x25, 0x1f, 0x51, 0x6b },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xe8, 0xd2, 0x9c, 0xa6,
+		0xd0, 0xea, 0xa4, 0x9e, 0x38, 0x02, 0x4c, 0x76 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xe8, 0xd2, 0x9c, 0xa6,
+		0xd0, 0xea, 0xa4, 0x9e, 0x38, 0x02, 0x4c, 0x76 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xf5, 0xcf, 0x81, 0xbb,
+		0xf7, 0xcd, 0x83, 0xb9, 0x02, 0x38, 0x76, 0x4c },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xf5, 0xcf, 0x81, 0xbb,
+		0xf7, 0xcd, 0x83, 0xb9, 0x02, 0x38, 0x76, 0x4c },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xf5, 0xcf, 0x81, 0xbb,
+		0xea, 0xd0, 0x9e, 0xa4, 0x1f, 0x25, 0x6b, 0x51 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xf5, 0xcf, 0x81, 0xbb,
+		0xea, 0xd0, 0x9e, 0xa4, 0x1f, 0x25, 0x6b, 0x51 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x69, 0x53, 0xd2, 0xe8, 0xbb, 0x81,
+		0xb9, 0x83, 0xd0, 0xea, 0x6b, 0x51, 0x02, 0x38 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x69, 0x53, 0xd2, 0xe8, 0xbb, 0x81,
+		0xb9, 0x83, 0xd0, 0xea, 0x6b, 0x51, 0x02, 0x38 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x69, 0x53, 0xd2, 0xe8, 0xbb, 0x81,
+		0xa4, 0x9e, 0xcd, 0xf7, 0x76, 0x4c, 0x1f, 0x25 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x69, 0x53, 0xd2, 0xe8, 0xbb, 0x81,
+		0xa4, 0x9e, 0xcd, 0xf7, 0x76, 0x4c, 0x1f, 0x25 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x69, 0x53, 0xcf, 0xf5, 0xa6, 0x9c,
+		0x83, 0xb9, 0xea, 0xd0, 0x4c, 0x76, 0x25, 0x1f },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x69, 0x53, 0xcf, 0xf5, 0xa6, 0x9c,
+		0x83, 0xb9, 0xea, 0xd0, 0x4c, 0x76, 0x25, 0x1f },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x69, 0x53, 0xcf, 0xf5, 0xa6, 0x9c,
+		0x9e, 0xa4, 0xf7, 0xcd, 0x51, 0x6b, 0x38, 0x02 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x3a, 0x69, 0x53, 0xcf, 0xf5, 0xa6, 0x9c,
+		0x9e, 0xa4, 0xf7, 0xcd, 0x51, 0x6b, 0x38, 0x02 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x9c, 0xbb, 0xd2, 0xf5,
+		0x25, 0x02, 0x6b, 0x4c, 0xb9, 0x9e, 0xf7, 0xd0 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x9c, 0xbb, 0xd2, 0xf5,
+		0x25, 0x02, 0x6b, 0x4c, 0xb9, 0x9e, 0xf7, 0xd0 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x9c, 0xbb, 0xd2, 0xf5,
+		0x38, 0x1f, 0x76, 0x51, 0xa4, 0x83, 0xea, 0xcd },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x9c, 0xbb, 0xd2, 0xf5,
+		0x38, 0x1f, 0x76, 0x51, 0xa4, 0x83, 0xea, 0xcd },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x81, 0xa6, 0xcf, 0xe8,
+		0x1f, 0x38, 0x51, 0x76, 0x9e, 0xb9, 0xd0, 0xf7 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x81, 0xa6, 0xcf, 0xe8,
+		0x1f, 0x38, 0x51, 0x76, 0x9e, 0xb9, 0xd0, 0xf7 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x81, 0xa6, 0xcf, 0xe8,
+		0x02, 0x25, 0x4c, 0x6b, 0x83, 0xa4, 0xcd, 0xea },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x81, 0xa6, 0xcf, 0xe8,
+		0x02, 0x25, 0x4c, 0x6b, 0x83, 0xa4, 0xcd, 0xea },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x53, 0x74, 0xa6, 0x81, 0xf5, 0xd2,
+		0x51, 0x76, 0x02, 0x25, 0xf7, 0xd0, 0xa4, 0x83 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x53, 0x74, 0xa6, 0x81, 0xf5, 0xd2,
+		0x51, 0x76, 0x02, 0x25, 0xf7, 0xd0, 0xa4, 0x83 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x53, 0x74, 0xa6, 0x81, 0xf5, 0xd2,
+		0x4c, 0x6b, 0x1f, 0x38, 0xea, 0xcd, 0xb9, 0x9e },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x53, 0x74, 0xa6, 0x81, 0xf5, 0xd2,
+		0x4c, 0x6b, 0x1f, 0x38, 0xea, 0xcd, 0xb9, 0x9e },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x53, 0x74, 0xbb, 0x9c, 0xe8, 0xcf,
+		0x6b, 0x4c, 0x38, 0x1f, 0xd0, 0xf7, 0x83, 0xa4 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x53, 0x74, 0xbb, 0x9c, 0xe8, 0xcf,
+		0x6b, 0x4c, 0x38, 0x1f, 0xd0, 0xf7, 0x83, 0xa4 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x53, 0x74, 0xbb, 0x9c, 0xe8, 0xcf,
+		0x76, 0x51, 0x25, 0x02, 0xcd, 0xea, 0x9e, 0xb9 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x27, 0x53, 0x74, 0xbb, 0x9c, 0xe8, 0xcf,
+		0x76, 0x51, 0x25, 0x02, 0xcd, 0xea, 0x9e, 0xb9 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xcd, 0xb9, 0x25, 0x51,
+		0x87, 0xf3, 0x6f, 0x1b, 0x4a, 0x3e, 0xa2, 0xd6 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xcd, 0xb9, 0x25, 0x51,
+		0x87, 0xf3, 0x6f, 0x1b, 0x4a, 0x3e, 0xa2, 0xd6 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xcd, 0xb9, 0x25, 0x51,
+		0x9a, 0xee, 0x72, 0x06, 0x57, 0x23, 0xbf, 0xcb },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xcd, 0xb9, 0x25, 0x51,
+		0x9a, 0xee, 0x72, 0x06, 0x57, 0x23, 0xbf, 0xcb },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xd0, 0xa4, 0x38, 0x4c,
+		0xbd, 0xc9, 0x55, 0x21, 0x6d, 0x19, 0x85, 0xf1 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xd0, 0xa4, 0x38, 0x4c,
+		0xbd, 0xc9, 0x55, 0x21, 0x6d, 0x19, 0x85, 0xf1 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xd0, 0xa4, 0x38, 0x4c,
+		0xa0, 0xd4, 0x48, 0x3c, 0x70, 0x04, 0x98, 0xec },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xd0, 0xa4, 0x38, 0x4c,
+		0xa0, 0xd4, 0x48, 0x3c, 0x70, 0x04, 0x98, 0xec },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xf5, 0x81, 0xf7, 0x83, 0x02, 0x76,
+		0xf3, 0x87, 0x06, 0x72, 0x04, 0x70, 0xf1, 0x85 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xf5, 0x81, 0xf7, 0x83, 0x02, 0x76,
+		0xf3, 0x87, 0x06, 0x72, 0x04, 0x70, 0xf1, 0x85 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xf5, 0x81, 0xf7, 0x83, 0x02, 0x76,
+		0xee, 0x9a, 0x1b, 0x6f, 0x19, 0x6d, 0xec, 0x98 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xf5, 0x81, 0xf7, 0x83, 0x02, 0x76,
+		0xee, 0x9a, 0x1b, 0x6f, 0x19, 0x6d, 0xec, 0x98 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xf5, 0x81, 0xea, 0x9e, 0x1f, 0x6b,
+		0xc9, 0xbd, 0x3c, 0x48, 0x23, 0x57, 0xd6, 0xa2 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xf5, 0x81, 0xea, 0x9e, 0x1f, 0x6b,
+		0xc9, 0xbd, 0x3c, 0x48, 0x23, 0x57, 0xd6, 0xa2 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xf5, 0x81, 0xea, 0x9e, 0x1f, 0x6b,
+		0xd4, 0xa0, 0x21, 0x55, 0x3e, 0x4a, 0xcb, 0xbf },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x74, 0xf5, 0x81, 0xea, 0x9e, 0x1f, 0x6b,
+		0xd4, 0xa0, 0x21, 0x55, 0x3e, 0x4a, 0xcb, 0xbf },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xb9, 0xd0, 0x6b, 0x02,
+		0x6f, 0x06, 0xbd, 0xd4, 0xd6, 0xbf, 0x04, 0x6d },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xb9, 0xd0, 0x6b, 0x02,
+		0x6f, 0x06, 0xbd, 0xd4, 0xd6, 0xbf, 0x04, 0x6d },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xb9, 0xd0, 0x6b, 0x02,
+		0x72, 0x1b, 0xa0, 0xc9, 0xcb, 0xa2, 0x19, 0x70 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xb9, 0xd0, 0x6b, 0x02,
+		0x72, 0x1b, 0xa0, 0xc9, 0xcb, 0xa2, 0x19, 0x70 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xa4, 0xcd, 0x76, 0x1f,
+		0x55, 0x3c, 0x87, 0xee, 0xf1, 0x98, 0x23, 0x4a },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xa4, 0xcd, 0x76, 0x1f,
+		0x55, 0x3c, 0x87, 0xee, 0xf1, 0x98, 0x23, 0x4a },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xa4, 0xcd, 0x76, 0x1f,
+		0x48, 0x21, 0x9a, 0xf3, 0xec, 0x85, 0x3e, 0x57 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xa4, 0xcd, 0x76, 0x1f,
+		0x48, 0x21, 0x9a, 0xf3, 0xec, 0x85, 0x3e, 0x57 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xcf, 0xa6, 0x83, 0xea, 0x4c, 0x25,
+		0x1b, 0x72, 0xd4, 0xbd, 0x98, 0xf1, 0x57, 0x3e },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xcf, 0xa6, 0x83, 0xea, 0x4c, 0x25,
+		0x1b, 0x72, 0xd4, 0xbd, 0x98, 0xf1, 0x57, 0x3e },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xcf, 0xa6, 0x83, 0xea, 0x4c, 0x25,
+		0x06, 0x6f, 0xc9, 0xa0, 0x85, 0xec, 0x4a, 0x23 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xcf, 0xa6, 0x83, 0xea, 0x4c, 0x25,
+		0x06, 0x6f, 0xc9, 0xa0, 0x85, 0xec, 0x4a, 0x23 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xcf, 0xa6, 0x9e, 0xf7, 0x51, 0x38,
+		0x21, 0x48, 0xee, 0x87, 0xbf, 0xd6, 0x70, 0x19 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xcf, 0xa6, 0x9e, 0xf7, 0x51, 0x38,
+		0x21, 0x48, 0xee, 0x87, 0xbf, 0xd6, 0x70, 0x19 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xcf, 0xa6, 0x9e, 0xf7, 0x51, 0x38,
+		0x3c, 0x55, 0xf3, 0x9a, 0xa2, 0xcb, 0x6d, 0x04 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x69, 0xcf, 0xa6, 0x9e, 0xf7, 0x51, 0x38,
+		0x3c, 0x55, 0xf3, 0x9a, 0xa2, 0xcb, 0x6d, 0x04 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x3a, 0x3a, 0x3a, 0x3a, 0x27, 0x27, 0x27, 0x27 },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x25, 0x6b, 0xb9, 0xf7,
+		0x4a, 0x04, 0xd6, 0x98, 0x6f, 0x21, 0xf3, 0xbd },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x25, 0x6b, 0xb9, 0xf7,
+		0x4a, 0x04, 0xd6, 0x98, 0x6f, 0x21, 0xf3, 0xbd },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x25, 0x6b, 0xb9, 0xf7,
+		0x57, 0x19, 0xcb, 0x85, 0x72, 0x3c, 0xee, 0xa0 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x25, 0x6b, 0xb9, 0xf7,
+		0x57, 0x19, 0xcb, 0x85, 0x72, 0x3c, 0xee, 0xa0 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x38, 0x76, 0xa4, 0xea,
+		0x70, 0x3e, 0xec, 0xa2, 0x48, 0x06, 0xd4, 0x9a },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x38, 0x76, 0xa4, 0xea,
+		0x70, 0x3e, 0xec, 0xa2, 0x48, 0x06, 0xd4, 0x9a },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x38, 0x76, 0xa4, 0xea,
+		0x6d, 0x23, 0xf1, 0xbf, 0x55, 0x1b, 0xc9, 0x87 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x38, 0x76, 0xa4, 0xea,
+		0x6d, 0x23, 0xf1, 0xbf, 0x55, 0x1b, 0xc9, 0x87 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x81, 0xcf, 0x1f, 0x51, 0x9e, 0xd0,
+		0x3e, 0x70, 0xbf, 0xf1, 0x21, 0x6f, 0xa0, 0xee },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x81, 0xcf, 0x1f, 0x51, 0x9e, 0xd0,
+		0x3e, 0x70, 0xbf, 0xf1, 0x21, 0x6f, 0xa0, 0xee },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x81, 0xcf, 0x1f, 0x51, 0x9e, 0xd0,
+		0x23, 0x6d, 0xa2, 0xec, 0x3c, 0x72, 0xbd, 0xf3 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x81, 0xcf, 0x1f, 0x51, 0x9e, 0xd0,
+		0x23, 0x6d, 0xa2, 0xec, 0x3c, 0x72, 0xbd, 0xf3 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x81, 0xcf, 0x02, 0x4c, 0x83, 0xcd,
+		0x04, 0x4a, 0x85, 0xcb, 0x06, 0x48, 0x87, 0xc9 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x81, 0xcf, 0x02, 0x4c, 0x83, 0xcd,
+		0x04, 0x4a, 0x85, 0xcb, 0x06, 0x48, 0x87, 0xc9 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x81, 0xcf, 0x02, 0x4c, 0x83, 0xcd,
+		0x19, 0x57, 0x98, 0xd6, 0x1b, 0x55, 0x9a, 0xd4 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x4e, 0x81, 0xcf, 0x02, 0x4c, 0x83, 0xcd,
+		0x19, 0x57, 0x98, 0xd6, 0x1b, 0x55, 0x9a, 0xd4 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x51, 0x02, 0xf7, 0xa4,
+		0xa2, 0xf1, 0x04, 0x57, 0xf3, 0xa0, 0x55, 0x06 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x51, 0x02, 0xf7, 0xa4,
+		0xa2, 0xf1, 0x04, 0x57, 0xf3, 0xa0, 0x55, 0x06 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x51, 0x02, 0xf7, 0xa4,
+		0xbf, 0xec, 0x19, 0x4a, 0xee, 0xbd, 0x48, 0x1b },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x51, 0x02, 0xf7, 0xa4,
+		0xbf, 0xec, 0x19, 0x4a, 0xee, 0xbd, 0x48, 0x1b },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x4c, 0x1f, 0xea, 0xb9,
+		0x98, 0xcb, 0x3e, 0x6d, 0xd4, 0x87, 0x72, 0x21 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x4c, 0x1f, 0xea, 0xb9,
+		0x98, 0xcb, 0x3e, 0x6d, 0xd4, 0x87, 0x72, 0x21 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x4c, 0x1f, 0xea, 0xb9,
+		0x85, 0xd6, 0x23, 0x70, 0xc9, 0x9a, 0x6f, 0x3c },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x4c, 0x1f, 0xea, 0xb9,
+		0x85, 0xd6, 0x23, 0x70, 0xc9, 0x9a, 0x6f, 0x3c },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xbb, 0xe8, 0x6b, 0x38, 0xd0, 0x83,
+		0xd6, 0x85, 0x6d, 0x3e, 0xbd, 0xee, 0x06, 0x55 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xbb, 0xe8, 0x6b, 0x38, 0xd0, 0x83,
+		0xd6, 0x85, 0x6d, 0x3e, 0xbd, 0xee, 0x06, 0x55 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xbb, 0xe8, 0x6b, 0x38, 0xd0, 0x83,
+		0xcb, 0x98, 0x70, 0x23, 0xa0, 0xf3, 0x1b, 0x48 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xbb, 0xe8, 0x6b, 0x38, 0xd0, 0x83,
+		0xcb, 0x98, 0x70, 0x23, 0xa0, 0xf3, 0x1b, 0x48 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xbb, 0xe8, 0x76, 0x25, 0xcd, 0x9e,
+		0xec, 0xbf, 0x57, 0x04, 0x9a, 0xc9, 0x21, 0x72 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xbb, 0xe8, 0x76, 0x25, 0xcd, 0x9e,
+		0xec, 0xbf, 0x57, 0x04, 0x9a, 0xc9, 0x21, 0x72 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xbb, 0xe8, 0x76, 0x25, 0xcd, 0x9e,
+		0xf1, 0xa2, 0x4a, 0x19, 0x87, 0xd4, 0x3c, 0x6f },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0x53, 0xbb, 0xe8, 0x76, 0x25, 0xcd, 0x9e,
+		0xf1, 0xa2, 0x4a, 0x19, 0x87, 0xd4, 0x3c, 0x6f },
+	{ 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x1d, 0x1d,
+		0x27, 0x27, 0x27, 0x27, 0x3a, 0x3a, 0x3a, 0x3a },
+	{ 0x00, 0xe8, 0xcd, 0x25, 0x87, 0x6f, 0x4a, 0xa2,
+		0x13, 0xfb, 0xde, 0x36, 0x94, 0x7c, 0x59, 0xb1 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xcd, 0x25, 0x87, 0x6f, 0x4a, 0xa2,
+		0x13, 0xfb, 0xde, 0x36, 0x94, 0x7c, 0x59, 0xb1 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xcd, 0x25, 0x87, 0x6f, 0x4a, 0xa2,
+		0x0e, 0xe6, 0xc3, 0x2b, 0x89, 0x61, 0x44, 0xac },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xcd, 0x25, 0x87, 0x6f, 0x4a, 0xa2,
+		0x0e, 0xe6, 0xc3, 0x2b, 0x89, 0x61, 0x44, 0xac },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xcd, 0x25, 0x9a, 0x72, 0x57, 0xbf,
+		0x29, 0xc1, 0xe4, 0x0c, 0xb3, 0x5b, 0x7e, 0x96 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xcd, 0x25, 0x9a, 0x72, 0x57, 0xbf,
+		0x29, 0xc1, 0xe4, 0x0c, 0xb3, 0x5b, 0x7e, 0x96 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xcd, 0x25, 0x9a, 0x72, 0x57, 0xbf,
+		0x34, 0xdc, 0xf9, 0x11, 0xae, 0x46, 0x63, 0x8b },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xcd, 0x25, 0x9a, 0x72, 0x57, 0xbf,
+		0x34, 0xdc, 0xf9, 0x11, 0xae, 0x46, 0x63, 0x8b },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xbd, 0x55, 0x6d, 0x85,
+		0x67, 0x8f, 0xb7, 0x5f, 0xda, 0x32, 0x0a, 0xe2 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xbd, 0x55, 0x6d, 0x85,
+		0x67, 0x8f, 0xb7, 0x5f, 0xda, 0x32, 0x0a, 0xe2 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xbd, 0x55, 0x6d, 0x85,
+		0x7a, 0x92, 0xaa, 0x42, 0xc7, 0x2f, 0x17, 0xff },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xbd, 0x55, 0x6d, 0x85,
+		0x7a, 0x92, 0xaa, 0x42, 0xc7, 0x2f, 0x17, 0xff },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xa0, 0x48, 0x70, 0x98,
+		0x5d, 0xb5, 0x8d, 0x65, 0xfd, 0x15, 0x2d, 0xc5 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xa0, 0x48, 0x70, 0x98,
+		0x5d, 0xb5, 0x8d, 0x65, 0xfd, 0x15, 0x2d, 0xc5 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xa0, 0x48, 0x70, 0x98,
+		0x40, 0xa8, 0x90, 0x78, 0xe0, 0x08, 0x30, 0xd8 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xa0, 0x48, 0x70, 0x98,
+		0x40, 0xa8, 0x90, 0x78, 0xe0, 0x08, 0x30, 0xd8 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xf7, 0x02, 0xf3, 0x06, 0x04, 0xf1,
+		0xfb, 0x0e, 0x0c, 0xf9, 0x08, 0xfd, 0xff, 0x0a },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xf7, 0x02, 0xf3, 0x06, 0x04, 0xf1,
+		0xfb, 0x0e, 0x0c, 0xf9, 0x08, 0xfd, 0xff, 0x0a },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xf7, 0x02, 0xf3, 0x06, 0x04, 0xf1,
+		0xe6, 0x13, 0x11, 0xe4, 0x15, 0xe0, 0xe2, 0x17 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xf7, 0x02, 0xf3, 0x06, 0x04, 0xf1,
+		0xe6, 0x13, 0x11, 0xe4, 0x15, 0xe0, 0xe2, 0x17 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xf7, 0x02, 0xee, 0x1b, 0x19, 0xec,
+		0xc1, 0x34, 0x36, 0xc3, 0x2f, 0xda, 0xd8, 0x2d },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xf7, 0x02, 0xee, 0x1b, 0x19, 0xec,
+		0xc1, 0x34, 0x36, 0xc3, 0x2f, 0xda, 0xd8, 0x2d },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xf7, 0x02, 0xee, 0x1b, 0x19, 0xec,
+		0xdc, 0x29, 0x2b, 0xde, 0x32, 0xc7, 0xc5, 0x30 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xf7, 0x02, 0xee, 0x1b, 0x19, 0xec,
+		0xdc, 0x29, 0x2b, 0xde, 0x32, 0xc7, 0xc5, 0x30 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xc9, 0x3c, 0x23, 0xd6,
+		0x8f, 0x7a, 0x65, 0x90, 0x46, 0xb3, 0xac, 0x59 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xc9, 0x3c, 0x23, 0xd6,
+		0x8f, 0x7a, 0x65, 0x90, 0x46, 0xb3, 0xac, 0x59 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xc9, 0x3c, 0x23, 0xd6,
+		0x92, 0x67, 0x78, 0x8d, 0x5b, 0xae, 0xb1, 0x44 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xc9, 0x3c, 0x23, 0xd6,
+		0x92, 0x67, 0x78, 0x8d, 0x5b, 0xae, 0xb1, 0x44 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xd4, 0x21, 0x3e, 0xcb,
+		0xb5, 0x40, 0x5f, 0xaa, 0x61, 0x94, 0x8b, 0x7e },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xd4, 0x21, 0x3e, 0xcb,
+		0xb5, 0x40, 0x5f, 0xaa, 0x61, 0x94, 0x8b, 0x7e },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xd4, 0x21, 0x3e, 0xcb,
+		0xa8, 0x5d, 0x42, 0xb7, 0x7c, 0x89, 0x96, 0x63 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xd4, 0x21, 0x3e, 0xcb,
+		0xa8, 0x5d, 0x42, 0xb7, 0x7c, 0x89, 0x96, 0x63 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x74, 0x74, 0x69, 0x69, 0x4e, 0x4e, 0x53, 0x53 },
+	{ 0x00, 0xd2, 0xb9, 0x6b, 0x6f, 0xbd, 0xd6, 0x04,
+		0xde, 0x0c, 0x67, 0xb5, 0xb1, 0x63, 0x08, 0xda },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xb9, 0x6b, 0x6f, 0xbd, 0xd6, 0x04,
+		0xde, 0x0c, 0x67, 0xb5, 0xb1, 0x63, 0x08, 0xda },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xb9, 0x6b, 0x6f, 0xbd, 0xd6, 0x04,
+		0xc3, 0x11, 0x7a, 0xa8, 0xac, 0x7e, 0x15, 0xc7 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xb9, 0x6b, 0x6f, 0xbd, 0xd6, 0x04,
+		0xc3, 0x11, 0x7a, 0xa8, 0xac, 0x7e, 0x15, 0xc7 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xb9, 0x6b, 0x72, 0xa0, 0xcb, 0x19,
+		0xe4, 0x36, 0x5d, 0x8f, 0x96, 0x44, 0x2f, 0xfd },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xb9, 0x6b, 0x72, 0xa0, 0xcb, 0x19,
+		0xe4, 0x36, 0x5d, 0x8f, 0x96, 0x44, 0x2f, 0xfd },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xb9, 0x6b, 0x72, 0xa0, 0xcb, 0x19,
+		0xf9, 0x2b, 0x40, 0x92, 0x8b, 0x59, 0x32, 0xe0 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xb9, 0x6b, 0x72, 0xa0, 0xcb, 0x19,
+		0xf9, 0x2b, 0x40, 0x92, 0x8b, 0x59, 0x32, 0xe0 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x55, 0x87, 0xf1, 0x23,
+		0xaa, 0x78, 0x0e, 0xdc, 0xff, 0x2d, 0x5b, 0x89 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x55, 0x87, 0xf1, 0x23,
+		0xaa, 0x78, 0x0e, 0xdc, 0xff, 0x2d, 0x5b, 0x89 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x55, 0x87, 0xf1, 0x23,
+		0xb7, 0x65, 0x13, 0xc1, 0xe2, 0x30, 0x46, 0x94 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x55, 0x87, 0xf1, 0x23,
+		0xb7, 0x65, 0x13, 0xc1, 0xe2, 0x30, 0x46, 0x94 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x48, 0x9a, 0xec, 0x3e,
+		0x90, 0x42, 0x34, 0xe6, 0xd8, 0x0a, 0x7c, 0xae },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x48, 0x9a, 0xec, 0x3e,
+		0x90, 0x42, 0x34, 0xe6, 0xd8, 0x0a, 0x7c, 0xae },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x48, 0x9a, 0xec, 0x3e,
+		0x8d, 0x5f, 0x29, 0xfb, 0xc5, 0x17, 0x61, 0xb3 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x48, 0x9a, 0xec, 0x3e,
+		0x8d, 0x5f, 0x29, 0xfb, 0xc5, 0x17, 0x61, 0xb3 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x83, 0x4c, 0x1b, 0xd4, 0x98, 0x57,
+		0x36, 0xf9, 0xb5, 0x7a, 0x2d, 0xe2, 0xae, 0x61 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x83, 0x4c, 0x1b, 0xd4, 0x98, 0x57,
+		0x36, 0xf9, 0xb5, 0x7a, 0x2d, 0xe2, 0xae, 0x61 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x83, 0x4c, 0x1b, 0xd4, 0x98, 0x57,
+		0x2b, 0xe4, 0xa8, 0x67, 0x30, 0xff, 0xb3, 0x7c },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x83, 0x4c, 0x1b, 0xd4, 0x98, 0x57,
+		0x2b, 0xe4, 0xa8, 0x67, 0x30, 0xff, 0xb3, 0x7c },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x83, 0x4c, 0x06, 0xc9, 0x85, 0x4a,
+		0x0c, 0xc3, 0x8f, 0x40, 0x0a, 0xc5, 0x89, 0x46 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x83, 0x4c, 0x06, 0xc9, 0x85, 0x4a,
+		0x0c, 0xc3, 0x8f, 0x40, 0x0a, 0xc5, 0x89, 0x46 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x83, 0x4c, 0x06, 0xc9, 0x85, 0x4a,
+		0x11, 0xde, 0x92, 0x5d, 0x17, 0xd8, 0x94, 0x5b },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x83, 0x4c, 0x06, 0xc9, 0x85, 0x4a,
+		0x11, 0xde, 0x92, 0x5d, 0x17, 0xd8, 0x94, 0x5b },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x21, 0xee, 0xbf, 0x70,
+		0x42, 0x8d, 0xdc, 0x13, 0x63, 0xac, 0xfd, 0x32 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x21, 0xee, 0xbf, 0x70,
+		0x42, 0x8d, 0xdc, 0x13, 0x63, 0xac, 0xfd, 0x32 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x21, 0xee, 0xbf, 0x70,
+		0x5f, 0x90, 0xc1, 0x0e, 0x7e, 0xb1, 0xe0, 0x2f },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x21, 0xee, 0xbf, 0x70,
+		0x5f, 0x90, 0xc1, 0x0e, 0x7e, 0xb1, 0xe0, 0x2f },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x3c, 0xf3, 0xa2, 0x6d,
+		0x78, 0xb7, 0xe6, 0x29, 0x44, 0x8b, 0xda, 0x15 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x3c, 0xf3, 0xa2, 0x6d,
+		0x78, 0xb7, 0xe6, 0x29, 0x44, 0x8b, 0xda, 0x15 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x3c, 0xf3, 0xa2, 0x6d,
+		0x65, 0xaa, 0xfb, 0x34, 0x59, 0x96, 0xc7, 0x08 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x3c, 0xf3, 0xa2, 0x6d,
+		0x65, 0xaa, 0xfb, 0x34, 0x59, 0x96, 0xc7, 0x08 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x3a, 0x3a, 0x27, 0x27,
+		0x69, 0x69, 0x74, 0x74, 0x53, 0x53, 0x4e, 0x4e },
+	{ 0x00, 0x9c, 0x25, 0xb9, 0x4a, 0xd6, 0x6f, 0xf3,
+		0x94, 0x08, 0xb1, 0x2d, 0xde, 0x42, 0xfb, 0x67 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x25, 0xb9, 0x4a, 0xd6, 0x6f, 0xf3,
+		0x94, 0x08, 0xb1, 0x2d, 0xde, 0x42, 0xfb, 0x67 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x25, 0xb9, 0x4a, 0xd6, 0x6f, 0xf3,
+		0x89, 0x15, 0xac, 0x30, 0xc3, 0x5f, 0xe6, 0x7a },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x25, 0xb9, 0x4a, 0xd6, 0x6f, 0xf3,
+		0x89, 0x15, 0xac, 0x30, 0xc3, 0x5f, 0xe6, 0x7a },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x25, 0xb9, 0x57, 0xcb, 0x72, 0xee,
+		0xae, 0x32, 0x8b, 0x17, 0xf9, 0x65, 0xdc, 0x40 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x25, 0xb9, 0x57, 0xcb, 0x72, 0xee,
+		0xae, 0x32, 0x8b, 0x17, 0xf9, 0x65, 0xdc, 0x40 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x25, 0xb9, 0x57, 0xcb, 0x72, 0xee,
+		0xb3, 0x2f, 0x96, 0x0a, 0xe4, 0x78, 0xc1, 0x5d },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x25, 0xb9, 0x57, 0xcb, 0x72, 0xee,
+		0xb3, 0x2f, 0x96, 0x0a, 0xe4, 0x78, 0xc1, 0x5d },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x70, 0xec, 0x48, 0xd4,
+		0xe0, 0x7c, 0xd8, 0x44, 0x90, 0x0c, 0xa8, 0x34 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x70, 0xec, 0x48, 0xd4,
+		0xe0, 0x7c, 0xd8, 0x44, 0x90, 0x0c, 0xa8, 0x34 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x70, 0xec, 0x48, 0xd4,
+		0xfd, 0x61, 0xc5, 0x59, 0x8d, 0x11, 0xb5, 0x29 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x70, 0xec, 0x48, 0xd4,
+		0xfd, 0x61, 0xc5, 0x59, 0x8d, 0x11, 0xb5, 0x29 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x6d, 0xf1, 0x55, 0xc9,
+		0xda, 0x46, 0xe2, 0x7e, 0xb7, 0x2b, 0x8f, 0x13 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x6d, 0xf1, 0x55, 0xc9,
+		0xda, 0x46, 0xe2, 0x7e, 0xb7, 0x2b, 0x8f, 0x13 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x6d, 0xf1, 0x55, 0xc9,
+		0xc7, 0x5b, 0xff, 0x63, 0xaa, 0x36, 0x92, 0x0e },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x6d, 0xf1, 0x55, 0xc9,
+		0xc7, 0x5b, 0xff, 0x63, 0xaa, 0x36, 0x92, 0x0e },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x1f, 0x9e, 0x3e, 0xbf, 0x21, 0xa0,
+		0x7c, 0xfd, 0x63, 0xe2, 0x42, 0xc3, 0x5d, 0xdc },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x1f, 0x9e, 0x3e, 0xbf, 0x21, 0xa0,
+		0x7c, 0xfd, 0x63, 0xe2, 0x42, 0xc3, 0x5d, 0xdc },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x1f, 0x9e, 0x3e, 0xbf, 0x21, 0xa0,
+		0x61, 0xe0, 0x7e, 0xff, 0x5f, 0xde, 0x40, 0xc1 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x1f, 0x9e, 0x3e, 0xbf, 0x21, 0xa0,
+		0x61, 0xe0, 0x7e, 0xff, 0x5f, 0xde, 0x40, 0xc1 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x1f, 0x9e, 0x23, 0xa2, 0x3c, 0xbd,
+		0x46, 0xc7, 0x59, 0xd8, 0x65, 0xe4, 0x7a, 0xfb },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x1f, 0x9e, 0x23, 0xa2, 0x3c, 0xbd,
+		0x46, 0xc7, 0x59, 0xd8, 0x65, 0xe4, 0x7a, 0xfb },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x1f, 0x9e, 0x23, 0xa2, 0x3c, 0xbd,
+		0x5b, 0xda, 0x44, 0xc5, 0x78, 0xf9, 0x67, 0xe6 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x1f, 0x9e, 0x23, 0xa2, 0x3c, 0xbd,
+		0x5b, 0xda, 0x44, 0xc5, 0x78, 0xf9, 0x67, 0xe6 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x04, 0x85, 0x06, 0x87,
+		0x08, 0x89, 0x0a, 0x8b, 0x0c, 0x8d, 0x0e, 0x8f },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x04, 0x85, 0x06, 0x87,
+		0x08, 0x89, 0x0a, 0x8b, 0x0c, 0x8d, 0x0e, 0x8f },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x04, 0x85, 0x06, 0x87,
+		0x15, 0x94, 0x17, 0x96, 0x11, 0x90, 0x13, 0x92 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x04, 0x85, 0x06, 0x87,
+		0x15, 0x94, 0x17, 0x96, 0x11, 0x90, 0x13, 0x92 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x19, 0x98, 0x1b, 0x9a,
+		0x32, 0xb3, 0x30, 0xb1, 0x2b, 0xaa, 0x29, 0xa8 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x19, 0x98, 0x1b, 0x9a,
+		0x32, 0xb3, 0x30, 0xb1, 0x2b, 0xaa, 0x29, 0xa8 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x19, 0x98, 0x1b, 0x9a,
+		0x2f, 0xae, 0x2d, 0xac, 0x36, 0xb7, 0x34, 0xb5 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x19, 0x98, 0x1b, 0x9a,
+		0x2f, 0xae, 0x2d, 0xac, 0x36, 0xb7, 0x34, 0xb5 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x4e, 0x4e, 0x53, 0x53, 0x69, 0x69, 0x74, 0x74 },
+	{ 0x00, 0xa6, 0x51, 0xf7, 0xa2, 0x04, 0xf3, 0x55,
+		0x59, 0xff, 0x08, 0xae, 0xfb, 0x5d, 0xaa, 0x0c },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x51, 0xf7, 0xa2, 0x04, 0xf3, 0x55,
+		0x59, 0xff, 0x08, 0xae, 0xfb, 0x5d, 0xaa, 0x0c },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x51, 0xf7, 0xa2, 0x04, 0xf3, 0x55,
+		0x44, 0xe2, 0x15, 0xb3, 0xe6, 0x40, 0xb7, 0x11 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x51, 0xf7, 0xa2, 0x04, 0xf3, 0x55,
+		0x44, 0xe2, 0x15, 0xb3, 0xe6, 0x40, 0xb7, 0x11 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x51, 0xf7, 0xbf, 0x19, 0xee, 0x48,
+		0x63, 0xc5, 0x32, 0x94, 0xdc, 0x7a, 0x8d, 0x2b },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x51, 0xf7, 0xbf, 0x19, 0xee, 0x48,
+		0x63, 0xc5, 0x32, 0x94, 0xdc, 0x7a, 0x8d, 0x2b },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x51, 0xf7, 0xbf, 0x19, 0xee, 0x48,
+		0x7e, 0xd8, 0x2f, 0x89, 0xc1, 0x67, 0x90, 0x36 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x51, 0xf7, 0xbf, 0x19, 0xee, 0x48,
+		0x7e, 0xd8, 0x2f, 0x89, 0xc1, 0x67, 0x90, 0x36 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x98, 0x3e, 0xd4, 0x72,
+		0x2d, 0x8b, 0x61, 0xc7, 0xb5, 0x13, 0xf9, 0x5f },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x98, 0x3e, 0xd4, 0x72,
+		0x2d, 0x8b, 0x61, 0xc7, 0xb5, 0x13, 0xf9, 0x5f },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x98, 0x3e, 0xd4, 0x72,
+		0x30, 0x96, 0x7c, 0xda, 0xa8, 0x0e, 0xe4, 0x42 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x98, 0x3e, 0xd4, 0x72,
+		0x30, 0x96, 0x7c, 0xda, 0xa8, 0x0e, 0xe4, 0x42 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x85, 0x23, 0xc9, 0x6f,
+		0x17, 0xb1, 0x5b, 0xfd, 0x92, 0x34, 0xde, 0x78 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x85, 0x23, 0xc9, 0x6f,
+		0x17, 0xb1, 0x5b, 0xfd, 0x92, 0x34, 0xde, 0x78 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x85, 0x23, 0xc9, 0x6f,
+		0x0a, 0xac, 0x46, 0xe0, 0x8f, 0x29, 0xc3, 0x65 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x85, 0x23, 0xc9, 0x6f,
+		0x0a, 0xac, 0x46, 0xe0, 0x8f, 0x29, 0xc3, 0x65 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x6b, 0xd0, 0xd6, 0x6d, 0xbd, 0x06,
+		0xb1, 0x0a, 0xda, 0x61, 0x67, 0xdc, 0x0c, 0xb7 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x6b, 0xd0, 0xd6, 0x6d, 0xbd, 0x06,
+		0xb1, 0x0a, 0xda, 0x61, 0x67, 0xdc, 0x0c, 0xb7 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x6b, 0xd0, 0xd6, 0x6d, 0xbd, 0x06,
+		0xac, 0x17, 0xc7, 0x7c, 0x7a, 0xc1, 0x11, 0xaa },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x6b, 0xd0, 0xd6, 0x6d, 0xbd, 0x06,
+		0xac, 0x17, 0xc7, 0x7c, 0x7a, 0xc1, 0x11, 0xaa },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x6b, 0xd0, 0xcb, 0x70, 0xa0, 0x1b,
+		0x8b, 0x30, 0xe0, 0x5b, 0x40, 0xfb, 0x2b, 0x90 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x6b, 0xd0, 0xcb, 0x70, 0xa0, 0x1b,
+		0x8b, 0x30, 0xe0, 0x5b, 0x40, 0xfb, 0x2b, 0x90 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x6b, 0xd0, 0xcb, 0x70, 0xa0, 0x1b,
+		0x96, 0x2d, 0xfd, 0x46, 0x5d, 0xe6, 0x36, 0x8d },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x6b, 0xd0, 0xcb, 0x70, 0xa0, 0x1b,
+		0x96, 0x2d, 0xfd, 0x46, 0x5d, 0xe6, 0x36, 0x8d },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xec, 0x57, 0x9a, 0x21,
+		0xc5, 0x7e, 0xb3, 0x08, 0x29, 0x92, 0x5f, 0xe4 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xec, 0x57, 0x9a, 0x21,
+		0xc5, 0x7e, 0xb3, 0x08, 0x29, 0x92, 0x5f, 0xe4 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xec, 0x57, 0x9a, 0x21,
+		0xd8, 0x63, 0xae, 0x15, 0x34, 0x8f, 0x42, 0xf9 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xec, 0x57, 0x9a, 0x21,
+		0xd8, 0x63, 0xae, 0x15, 0x34, 0x8f, 0x42, 0xf9 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xf1, 0x4a, 0x87, 0x3c,
+		0xff, 0x44, 0x89, 0x32, 0x0e, 0xb5, 0x78, 0xc3 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xf1, 0x4a, 0x87, 0x3c,
+		0xff, 0x44, 0x89, 0x32, 0x0e, 0xb5, 0x78, 0xc3 },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xf1, 0x4a, 0x87, 0x3c,
+		0xe2, 0x59, 0x94, 0x2f, 0x13, 0xa8, 0x65, 0xde },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xf1, 0x4a, 0x87, 0x3c,
+		0xe2, 0x59, 0x94, 0x2f, 0x13, 0xa8, 0x65, 0xde },
+	{ 0x00, 0x00, 0x1d, 0x1d, 0x27, 0x27, 0x3a, 0x3a,
+		0x53, 0x53, 0x4e, 0x4e, 0x74, 0x74, 0x69, 0x69 },
+};
+
+const uint8_t
+__attribute__((aligned(256))) sse_clmul_mod_lt[2*256][16] = {
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+		0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e,
+		0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09,
+		0x18, 0x1b, 0x1e, 0x1d, 0x14, 0x17, 0x12, 0x11 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x04, 0x08, 0x0c, 0x10, 0x14, 0x18, 0x1c,
+		0x20, 0x24, 0x28, 0x2c, 0x30, 0x34, 0x38, 0x3c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x05, 0x0a, 0x0f, 0x14, 0x11, 0x1e, 0x1b,
+		0x28, 0x2d, 0x22, 0x27, 0x3c, 0x39, 0x36, 0x33 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x06, 0x0c, 0x0a, 0x18, 0x1e, 0x14, 0x12,
+		0x30, 0x36, 0x3c, 0x3a, 0x28, 0x2e, 0x24, 0x22 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
+		0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38,
+		0x40, 0x48, 0x50, 0x58, 0x60, 0x68, 0x70, 0x78 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f,
+		0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x0a, 0x14, 0x1e, 0x28, 0x22, 0x3c, 0x36,
+		0x50, 0x5a, 0x44, 0x4e, 0x78, 0x72, 0x6c, 0x66 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31,
+		0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x0c, 0x18, 0x14, 0x30, 0x3c, 0x28, 0x24,
+		0x60, 0x6c, 0x78, 0x74, 0x50, 0x5c, 0x48, 0x44 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23,
+		0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a,
+		0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x0f, 0x1e, 0x11, 0x3c, 0x33, 0x22, 0x2d,
+		0x78, 0x77, 0x66, 0x69, 0x44, 0x4b, 0x5a, 0x55 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+		0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x12, 0x24, 0x36, 0x48, 0x5a, 0x6c, 0x7e,
+		0x90, 0x82, 0xb4, 0xa6, 0xd8, 0xca, 0xfc, 0xee },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x13, 0x26, 0x35, 0x4c, 0x5f, 0x6a, 0x79,
+		0x98, 0x8b, 0xbe, 0xad, 0xd4, 0xc7, 0xf2, 0xe1 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x14, 0x28, 0x3c, 0x50, 0x44, 0x78, 0x6c,
+		0xa0, 0xb4, 0x88, 0x9c, 0xf0, 0xe4, 0xd8, 0xcc },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x15, 0x2a, 0x3f, 0x54, 0x41, 0x7e, 0x6b,
+		0xa8, 0xbd, 0x82, 0x97, 0xfc, 0xe9, 0xd6, 0xc3 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x16, 0x2c, 0x3a, 0x58, 0x4e, 0x74, 0x62,
+		0xb0, 0xa6, 0x9c, 0x8a, 0xe8, 0xfe, 0xc4, 0xd2 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x17, 0x2e, 0x39, 0x5c, 0x4b, 0x72, 0x65,
+		0xb8, 0xaf, 0x96, 0x81, 0xe4, 0xf3, 0xca, 0xdd },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x18, 0x30, 0x28, 0x60, 0x78, 0x50, 0x48,
+		0xc0, 0xd8, 0xf0, 0xe8, 0xa0, 0xb8, 0x90, 0x88 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x19, 0x32, 0x2b, 0x64, 0x7d, 0x56, 0x4f,
+		0xc8, 0xd1, 0xfa, 0xe3, 0xac, 0xb5, 0x9e, 0x87 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x1a, 0x34, 0x2e, 0x68, 0x72, 0x5c, 0x46,
+		0xd0, 0xca, 0xe4, 0xfe, 0xb8, 0xa2, 0x8c, 0x96 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x1b, 0x36, 0x2d, 0x6c, 0x77, 0x5a, 0x41,
+		0xd8, 0xc3, 0xee, 0xf5, 0xb4, 0xaf, 0x82, 0x99 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x1c, 0x38, 0x24, 0x70, 0x6c, 0x48, 0x54,
+		0xe0, 0xfc, 0xd8, 0xc4, 0x90, 0x8c, 0xa8, 0xb4 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x1d, 0x3a, 0x27, 0x74, 0x69, 0x4e, 0x53,
+		0xe8, 0xf5, 0xd2, 0xcf, 0x9c, 0x81, 0xa6, 0xbb },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x1e, 0x3c, 0x22, 0x78, 0x66, 0x44, 0x5a,
+		0xf0, 0xee, 0xcc, 0xd2, 0x88, 0x96, 0xb4, 0xaa },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x1f, 0x3e, 0x21, 0x7c, 0x63, 0x42, 0x5d,
+		0xf8, 0xe7, 0xc6, 0xd9, 0x84, 0x9b, 0xba, 0xa5 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x21, 0x42, 0x63, 0x84, 0xa5, 0xc6, 0xe7,
+		0x08, 0x29, 0x4a, 0x6b, 0x8c, 0xad, 0xce, 0xef },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x22, 0x44, 0x66, 0x88, 0xaa, 0xcc, 0xee,
+		0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x23, 0x46, 0x65, 0x8c, 0xaf, 0xca, 0xe9,
+		0x18, 0x3b, 0x5e, 0x7d, 0x94, 0xb7, 0xd2, 0xf1 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x24, 0x48, 0x6c, 0x90, 0xb4, 0xd8, 0xfc,
+		0x20, 0x04, 0x68, 0x4c, 0xb0, 0x94, 0xf8, 0xdc },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x25, 0x4a, 0x6f, 0x94, 0xb1, 0xde, 0xfb,
+		0x28, 0x0d, 0x62, 0x47, 0xbc, 0x99, 0xf6, 0xd3 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x26, 0x4c, 0x6a, 0x98, 0xbe, 0xd4, 0xf2,
+		0x30, 0x16, 0x7c, 0x5a, 0xa8, 0x8e, 0xe4, 0xc2 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x27, 0x4e, 0x69, 0x9c, 0xbb, 0xd2, 0xf5,
+		0x38, 0x1f, 0x76, 0x51, 0xa4, 0x83, 0xea, 0xcd },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x28, 0x50, 0x78, 0xa0, 0x88, 0xf0, 0xd8,
+		0x40, 0x68, 0x10, 0x38, 0xe0, 0xc8, 0xb0, 0x98 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x29, 0x52, 0x7b, 0xa4, 0x8d, 0xf6, 0xdf,
+		0x48, 0x61, 0x1a, 0x33, 0xec, 0xc5, 0xbe, 0x97 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x2a, 0x54, 0x7e, 0xa8, 0x82, 0xfc, 0xd6,
+		0x50, 0x7a, 0x04, 0x2e, 0xf8, 0xd2, 0xac, 0x86 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x2b, 0x56, 0x7d, 0xac, 0x87, 0xfa, 0xd1,
+		0x58, 0x73, 0x0e, 0x25, 0xf4, 0xdf, 0xa2, 0x89 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x2c, 0x58, 0x74, 0xb0, 0x9c, 0xe8, 0xc4,
+		0x60, 0x4c, 0x38, 0x14, 0xd0, 0xfc, 0x88, 0xa4 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x2d, 0x5a, 0x77, 0xb4, 0x99, 0xee, 0xc3,
+		0x68, 0x45, 0x32, 0x1f, 0xdc, 0xf1, 0x86, 0xab },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x2e, 0x5c, 0x72, 0xb8, 0x96, 0xe4, 0xca,
+		0x70, 0x5e, 0x2c, 0x02, 0xc8, 0xe6, 0x94, 0xba },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x2f, 0x5e, 0x71, 0xbc, 0x93, 0xe2, 0xcd,
+		0x78, 0x57, 0x26, 0x09, 0xc4, 0xeb, 0x9a, 0xb5 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x31, 0x62, 0x53, 0xc4, 0xf5, 0xa6, 0x97,
+		0x88, 0xb9, 0xea, 0xdb, 0x4c, 0x7d, 0x2e, 0x1f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x32, 0x64, 0x56, 0xc8, 0xfa, 0xac, 0x9e,
+		0x90, 0xa2, 0xf4, 0xc6, 0x58, 0x6a, 0x3c, 0x0e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x33, 0x66, 0x55, 0xcc, 0xff, 0xaa, 0x99,
+		0x98, 0xab, 0xfe, 0xcd, 0x54, 0x67, 0x32, 0x01 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x34, 0x68, 0x5c, 0xd0, 0xe4, 0xb8, 0x8c,
+		0xa0, 0x94, 0xc8, 0xfc, 0x70, 0x44, 0x18, 0x2c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x35, 0x6a, 0x5f, 0xd4, 0xe1, 0xbe, 0x8b,
+		0xa8, 0x9d, 0xc2, 0xf7, 0x7c, 0x49, 0x16, 0x23 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x36, 0x6c, 0x5a, 0xd8, 0xee, 0xb4, 0x82,
+		0xb0, 0x86, 0xdc, 0xea, 0x68, 0x5e, 0x04, 0x32 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x37, 0x6e, 0x59, 0xdc, 0xeb, 0xb2, 0x85,
+		0xb8, 0x8f, 0xd6, 0xe1, 0x64, 0x53, 0x0a, 0x3d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x38, 0x70, 0x48, 0xe0, 0xd8, 0x90, 0xa8,
+		0xc0, 0xf8, 0xb0, 0x88, 0x20, 0x18, 0x50, 0x68 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x39, 0x72, 0x4b, 0xe4, 0xdd, 0x96, 0xaf,
+		0xc8, 0xf1, 0xba, 0x83, 0x2c, 0x15, 0x5e, 0x67 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x3a, 0x74, 0x4e, 0xe8, 0xd2, 0x9c, 0xa6,
+		0xd0, 0xea, 0xa4, 0x9e, 0x38, 0x02, 0x4c, 0x76 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x3b, 0x76, 0x4d, 0xec, 0xd7, 0x9a, 0xa1,
+		0xd8, 0xe3, 0xae, 0x95, 0x34, 0x0f, 0x42, 0x79 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x3c, 0x78, 0x44, 0xf0, 0xcc, 0x88, 0xb4,
+		0xe0, 0xdc, 0x98, 0xa4, 0x10, 0x2c, 0x68, 0x54 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x3d, 0x7a, 0x47, 0xf4, 0xc9, 0x8e, 0xb3,
+		0xe8, 0xd5, 0x92, 0xaf, 0x1c, 0x21, 0x66, 0x5b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x3e, 0x7c, 0x42, 0xf8, 0xc6, 0x84, 0xba,
+		0xf0, 0xce, 0x8c, 0xb2, 0x08, 0x36, 0x74, 0x4a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x3f, 0x7e, 0x41, 0xfc, 0xc3, 0x82, 0xbd,
+		0xf8, 0xc7, 0x86, 0xb9, 0x04, 0x3b, 0x7a, 0x45 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x41, 0x82, 0xc3, 0x04, 0x45, 0x86, 0xc7,
+		0x08, 0x49, 0x8a, 0xcb, 0x0c, 0x4d, 0x8e, 0xcf },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x42, 0x84, 0xc6, 0x08, 0x4a, 0x8c, 0xce,
+		0x10, 0x52, 0x94, 0xd6, 0x18, 0x5a, 0x9c, 0xde },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x43, 0x86, 0xc5, 0x0c, 0x4f, 0x8a, 0xc9,
+		0x18, 0x5b, 0x9e, 0xdd, 0x14, 0x57, 0x92, 0xd1 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x44, 0x88, 0xcc, 0x10, 0x54, 0x98, 0xdc,
+		0x20, 0x64, 0xa8, 0xec, 0x30, 0x74, 0xb8, 0xfc },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x45, 0x8a, 0xcf, 0x14, 0x51, 0x9e, 0xdb,
+		0x28, 0x6d, 0xa2, 0xe7, 0x3c, 0x79, 0xb6, 0xf3 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x46, 0x8c, 0xca, 0x18, 0x5e, 0x94, 0xd2,
+		0x30, 0x76, 0xbc, 0xfa, 0x28, 0x6e, 0xa4, 0xe2 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x47, 0x8e, 0xc9, 0x1c, 0x5b, 0x92, 0xd5,
+		0x38, 0x7f, 0xb6, 0xf1, 0x24, 0x63, 0xaa, 0xed },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x48, 0x90, 0xd8, 0x20, 0x68, 0xb0, 0xf8,
+		0x40, 0x08, 0xd0, 0x98, 0x60, 0x28, 0xf0, 0xb8 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x49, 0x92, 0xdb, 0x24, 0x6d, 0xb6, 0xff,
+		0x48, 0x01, 0xda, 0x93, 0x6c, 0x25, 0xfe, 0xb7 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x4a, 0x94, 0xde, 0x28, 0x62, 0xbc, 0xf6,
+		0x50, 0x1a, 0xc4, 0x8e, 0x78, 0x32, 0xec, 0xa6 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x4b, 0x96, 0xdd, 0x2c, 0x67, 0xba, 0xf1,
+		0x58, 0x13, 0xce, 0x85, 0x74, 0x3f, 0xe2, 0xa9 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x4c, 0x98, 0xd4, 0x30, 0x7c, 0xa8, 0xe4,
+		0x60, 0x2c, 0xf8, 0xb4, 0x50, 0x1c, 0xc8, 0x84 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x4d, 0x9a, 0xd7, 0x34, 0x79, 0xae, 0xe3,
+		0x68, 0x25, 0xf2, 0xbf, 0x5c, 0x11, 0xc6, 0x8b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x4e, 0x9c, 0xd2, 0x38, 0x76, 0xa4, 0xea,
+		0x70, 0x3e, 0xec, 0xa2, 0x48, 0x06, 0xd4, 0x9a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x4f, 0x9e, 0xd1, 0x3c, 0x73, 0xa2, 0xed,
+		0x78, 0x37, 0xe6, 0xa9, 0x44, 0x0b, 0xda, 0x95 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x51, 0xa2, 0xf3, 0x44, 0x15, 0xe6, 0xb7,
+		0x88, 0xd9, 0x2a, 0x7b, 0xcc, 0x9d, 0x6e, 0x3f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x52, 0xa4, 0xf6, 0x48, 0x1a, 0xec, 0xbe,
+		0x90, 0xc2, 0x34, 0x66, 0xd8, 0x8a, 0x7c, 0x2e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x53, 0xa6, 0xf5, 0x4c, 0x1f, 0xea, 0xb9,
+		0x98, 0xcb, 0x3e, 0x6d, 0xd4, 0x87, 0x72, 0x21 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x54, 0xa8, 0xfc, 0x50, 0x04, 0xf8, 0xac,
+		0xa0, 0xf4, 0x08, 0x5c, 0xf0, 0xa4, 0x58, 0x0c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x55, 0xaa, 0xff, 0x54, 0x01, 0xfe, 0xab,
+		0xa8, 0xfd, 0x02, 0x57, 0xfc, 0xa9, 0x56, 0x03 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x56, 0xac, 0xfa, 0x58, 0x0e, 0xf4, 0xa2,
+		0xb0, 0xe6, 0x1c, 0x4a, 0xe8, 0xbe, 0x44, 0x12 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x57, 0xae, 0xf9, 0x5c, 0x0b, 0xf2, 0xa5,
+		0xb8, 0xef, 0x16, 0x41, 0xe4, 0xb3, 0x4a, 0x1d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x58, 0xb0, 0xe8, 0x60, 0x38, 0xd0, 0x88,
+		0xc0, 0x98, 0x70, 0x28, 0xa0, 0xf8, 0x10, 0x48 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x59, 0xb2, 0xeb, 0x64, 0x3d, 0xd6, 0x8f,
+		0xc8, 0x91, 0x7a, 0x23, 0xac, 0xf5, 0x1e, 0x47 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x5a, 0xb4, 0xee, 0x68, 0x32, 0xdc, 0x86,
+		0xd0, 0x8a, 0x64, 0x3e, 0xb8, 0xe2, 0x0c, 0x56 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x5b, 0xb6, 0xed, 0x6c, 0x37, 0xda, 0x81,
+		0xd8, 0x83, 0x6e, 0x35, 0xb4, 0xef, 0x02, 0x59 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x5c, 0xb8, 0xe4, 0x70, 0x2c, 0xc8, 0x94,
+		0xe0, 0xbc, 0x58, 0x04, 0x90, 0xcc, 0x28, 0x74 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x5d, 0xba, 0xe7, 0x74, 0x29, 0xce, 0x93,
+		0xe8, 0xb5, 0x52, 0x0f, 0x9c, 0xc1, 0x26, 0x7b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x5e, 0xbc, 0xe2, 0x78, 0x26, 0xc4, 0x9a,
+		0xf0, 0xae, 0x4c, 0x12, 0x88, 0xd6, 0x34, 0x6a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x5f, 0xbe, 0xe1, 0x7c, 0x23, 0xc2, 0x9d,
+		0xf8, 0xa7, 0x46, 0x19, 0x84, 0xdb, 0x3a, 0x65 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x61, 0xc2, 0xa3, 0x84, 0xe5, 0x46, 0x27,
+		0x08, 0x69, 0xca, 0xab, 0x8c, 0xed, 0x4e, 0x2f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x62, 0xc4, 0xa6, 0x88, 0xea, 0x4c, 0x2e,
+		0x10, 0x72, 0xd4, 0xb6, 0x98, 0xfa, 0x5c, 0x3e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x63, 0xc6, 0xa5, 0x8c, 0xef, 0x4a, 0x29,
+		0x18, 0x7b, 0xde, 0xbd, 0x94, 0xf7, 0x52, 0x31 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x64, 0xc8, 0xac, 0x90, 0xf4, 0x58, 0x3c,
+		0x20, 0x44, 0xe8, 0x8c, 0xb0, 0xd4, 0x78, 0x1c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x65, 0xca, 0xaf, 0x94, 0xf1, 0x5e, 0x3b,
+		0x28, 0x4d, 0xe2, 0x87, 0xbc, 0xd9, 0x76, 0x13 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x66, 0xcc, 0xaa, 0x98, 0xfe, 0x54, 0x32,
+		0x30, 0x56, 0xfc, 0x9a, 0xa8, 0xce, 0x64, 0x02 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x67, 0xce, 0xa9, 0x9c, 0xfb, 0x52, 0x35,
+		0x38, 0x5f, 0xf6, 0x91, 0xa4, 0xc3, 0x6a, 0x0d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x68, 0xd0, 0xb8, 0xa0, 0xc8, 0x70, 0x18,
+		0x40, 0x28, 0x90, 0xf8, 0xe0, 0x88, 0x30, 0x58 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x69, 0xd2, 0xbb, 0xa4, 0xcd, 0x76, 0x1f,
+		0x48, 0x21, 0x9a, 0xf3, 0xec, 0x85, 0x3e, 0x57 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x6a, 0xd4, 0xbe, 0xa8, 0xc2, 0x7c, 0x16,
+		0x50, 0x3a, 0x84, 0xee, 0xf8, 0x92, 0x2c, 0x46 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x6b, 0xd6, 0xbd, 0xac, 0xc7, 0x7a, 0x11,
+		0x58, 0x33, 0x8e, 0xe5, 0xf4, 0x9f, 0x22, 0x49 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x6c, 0xd8, 0xb4, 0xb0, 0xdc, 0x68, 0x04,
+		0x60, 0x0c, 0xb8, 0xd4, 0xd0, 0xbc, 0x08, 0x64 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x6d, 0xda, 0xb7, 0xb4, 0xd9, 0x6e, 0x03,
+		0x68, 0x05, 0xb2, 0xdf, 0xdc, 0xb1, 0x06, 0x6b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x6e, 0xdc, 0xb2, 0xb8, 0xd6, 0x64, 0x0a,
+		0x70, 0x1e, 0xac, 0xc2, 0xc8, 0xa6, 0x14, 0x7a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x6f, 0xde, 0xb1, 0xbc, 0xd3, 0x62, 0x0d,
+		0x78, 0x17, 0xa6, 0xc9, 0xc4, 0xab, 0x1a, 0x75 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x71, 0xe2, 0x93, 0xc4, 0xb5, 0x26, 0x57,
+		0x88, 0xf9, 0x6a, 0x1b, 0x4c, 0x3d, 0xae, 0xdf },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x72, 0xe4, 0x96, 0xc8, 0xba, 0x2c, 0x5e,
+		0x90, 0xe2, 0x74, 0x06, 0x58, 0x2a, 0xbc, 0xce },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x73, 0xe6, 0x95, 0xcc, 0xbf, 0x2a, 0x59,
+		0x98, 0xeb, 0x7e, 0x0d, 0x54, 0x27, 0xb2, 0xc1 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x74, 0xe8, 0x9c, 0xd0, 0xa4, 0x38, 0x4c,
+		0xa0, 0xd4, 0x48, 0x3c, 0x70, 0x04, 0x98, 0xec },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x75, 0xea, 0x9f, 0xd4, 0xa1, 0x3e, 0x4b,
+		0xa8, 0xdd, 0x42, 0x37, 0x7c, 0x09, 0x96, 0xe3 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x76, 0xec, 0x9a, 0xd8, 0xae, 0x34, 0x42,
+		0xb0, 0xc6, 0x5c, 0x2a, 0x68, 0x1e, 0x84, 0xf2 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x77, 0xee, 0x99, 0xdc, 0xab, 0x32, 0x45,
+		0xb8, 0xcf, 0x56, 0x21, 0x64, 0x13, 0x8a, 0xfd },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x78, 0xf0, 0x88, 0xe0, 0x98, 0x10, 0x68,
+		0xc0, 0xb8, 0x30, 0x48, 0x20, 0x58, 0xd0, 0xa8 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x79, 0xf2, 0x8b, 0xe4, 0x9d, 0x16, 0x6f,
+		0xc8, 0xb1, 0x3a, 0x43, 0x2c, 0x55, 0xde, 0xa7 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x7a, 0xf4, 0x8e, 0xe8, 0x92, 0x1c, 0x66,
+		0xd0, 0xaa, 0x24, 0x5e, 0x38, 0x42, 0xcc, 0xb6 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x7b, 0xf6, 0x8d, 0xec, 0x97, 0x1a, 0x61,
+		0xd8, 0xa3, 0x2e, 0x55, 0x34, 0x4f, 0xc2, 0xb9 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x7c, 0xf8, 0x84, 0xf0, 0x8c, 0x08, 0x74,
+		0xe0, 0x9c, 0x18, 0x64, 0x10, 0x6c, 0xe8, 0x94 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x7d, 0xfa, 0x87, 0xf4, 0x89, 0x0e, 0x73,
+		0xe8, 0x95, 0x12, 0x6f, 0x1c, 0x61, 0xe6, 0x9b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x7e, 0xfc, 0x82, 0xf8, 0x86, 0x04, 0x7a,
+		0xf0, 0x8e, 0x0c, 0x72, 0x08, 0x76, 0xf4, 0x8a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x7f, 0xfe, 0x81, 0xfc, 0x83, 0x02, 0x7d,
+		0xf8, 0x87, 0x06, 0x79, 0x04, 0x7b, 0xfa, 0x85 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x81, 0x02, 0x83, 0x04, 0x85, 0x06, 0x87,
+		0x08, 0x89, 0x0a, 0x8b, 0x0c, 0x8d, 0x0e, 0x8f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x82, 0x04, 0x86, 0x08, 0x8a, 0x0c, 0x8e,
+		0x10, 0x92, 0x14, 0x96, 0x18, 0x9a, 0x1c, 0x9e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x83, 0x06, 0x85, 0x0c, 0x8f, 0x0a, 0x89,
+		0x18, 0x9b, 0x1e, 0x9d, 0x14, 0x97, 0x12, 0x91 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x84, 0x08, 0x8c, 0x10, 0x94, 0x18, 0x9c,
+		0x20, 0xa4, 0x28, 0xac, 0x30, 0xb4, 0x38, 0xbc },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x85, 0x0a, 0x8f, 0x14, 0x91, 0x1e, 0x9b,
+		0x28, 0xad, 0x22, 0xa7, 0x3c, 0xb9, 0x36, 0xb3 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x86, 0x0c, 0x8a, 0x18, 0x9e, 0x14, 0x92,
+		0x30, 0xb6, 0x3c, 0xba, 0x28, 0xae, 0x24, 0xa2 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x87, 0x0e, 0x89, 0x1c, 0x9b, 0x12, 0x95,
+		0x38, 0xbf, 0x36, 0xb1, 0x24, 0xa3, 0x2a, 0xad },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x88, 0x10, 0x98, 0x20, 0xa8, 0x30, 0xb8,
+		0x40, 0xc8, 0x50, 0xd8, 0x60, 0xe8, 0x70, 0xf8 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x89, 0x12, 0x9b, 0x24, 0xad, 0x36, 0xbf,
+		0x48, 0xc1, 0x5a, 0xd3, 0x6c, 0xe5, 0x7e, 0xf7 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x8a, 0x14, 0x9e, 0x28, 0xa2, 0x3c, 0xb6,
+		0x50, 0xda, 0x44, 0xce, 0x78, 0xf2, 0x6c, 0xe6 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x8b, 0x16, 0x9d, 0x2c, 0xa7, 0x3a, 0xb1,
+		0x58, 0xd3, 0x4e, 0xc5, 0x74, 0xff, 0x62, 0xe9 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x8c, 0x18, 0x94, 0x30, 0xbc, 0x28, 0xa4,
+		0x60, 0xec, 0x78, 0xf4, 0x50, 0xdc, 0x48, 0xc4 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x8d, 0x1a, 0x97, 0x34, 0xb9, 0x2e, 0xa3,
+		0x68, 0xe5, 0x72, 0xff, 0x5c, 0xd1, 0x46, 0xcb },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x8e, 0x1c, 0x92, 0x38, 0xb6, 0x24, 0xaa,
+		0x70, 0xfe, 0x6c, 0xe2, 0x48, 0xc6, 0x54, 0xda },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x8f, 0x1e, 0x91, 0x3c, 0xb3, 0x22, 0xad,
+		0x78, 0xf7, 0x66, 0xe9, 0x44, 0xcb, 0x5a, 0xd5 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0x91, 0x22, 0xb3, 0x44, 0xd5, 0x66, 0xf7,
+		0x88, 0x19, 0xaa, 0x3b, 0xcc, 0x5d, 0xee, 0x7f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0x92, 0x24, 0xb6, 0x48, 0xda, 0x6c, 0xfe,
+		0x90, 0x02, 0xb4, 0x26, 0xd8, 0x4a, 0xfc, 0x6e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0x93, 0x26, 0xb5, 0x4c, 0xdf, 0x6a, 0xf9,
+		0x98, 0x0b, 0xbe, 0x2d, 0xd4, 0x47, 0xf2, 0x61 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0x94, 0x28, 0xbc, 0x50, 0xc4, 0x78, 0xec,
+		0xa0, 0x34, 0x88, 0x1c, 0xf0, 0x64, 0xd8, 0x4c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0x95, 0x2a, 0xbf, 0x54, 0xc1, 0x7e, 0xeb,
+		0xa8, 0x3d, 0x82, 0x17, 0xfc, 0x69, 0xd6, 0x43 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0x96, 0x2c, 0xba, 0x58, 0xce, 0x74, 0xe2,
+		0xb0, 0x26, 0x9c, 0x0a, 0xe8, 0x7e, 0xc4, 0x52 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0x97, 0x2e, 0xb9, 0x5c, 0xcb, 0x72, 0xe5,
+		0xb8, 0x2f, 0x96, 0x01, 0xe4, 0x73, 0xca, 0x5d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0x98, 0x30, 0xa8, 0x60, 0xf8, 0x50, 0xc8,
+		0xc0, 0x58, 0xf0, 0x68, 0xa0, 0x38, 0x90, 0x08 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0x99, 0x32, 0xab, 0x64, 0xfd, 0x56, 0xcf,
+		0xc8, 0x51, 0xfa, 0x63, 0xac, 0x35, 0x9e, 0x07 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x9a, 0x34, 0xae, 0x68, 0xf2, 0x5c, 0xc6,
+		0xd0, 0x4a, 0xe4, 0x7e, 0xb8, 0x22, 0x8c, 0x16 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x9b, 0x36, 0xad, 0x6c, 0xf7, 0x5a, 0xc1,
+		0xd8, 0x43, 0xee, 0x75, 0xb4, 0x2f, 0x82, 0x19 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x9c, 0x38, 0xa4, 0x70, 0xec, 0x48, 0xd4,
+		0xe0, 0x7c, 0xd8, 0x44, 0x90, 0x0c, 0xa8, 0x34 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x9d, 0x3a, 0xa7, 0x74, 0xe9, 0x4e, 0xd3,
+		0xe8, 0x75, 0xd2, 0x4f, 0x9c, 0x01, 0xa6, 0x3b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x9e, 0x3c, 0xa2, 0x78, 0xe6, 0x44, 0xda,
+		0xf0, 0x6e, 0xcc, 0x52, 0x88, 0x16, 0xb4, 0x2a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x9f, 0x3e, 0xa1, 0x7c, 0xe3, 0x42, 0xdd,
+		0xf8, 0x67, 0xc6, 0x59, 0x84, 0x1b, 0xba, 0x25 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0xa1, 0x42, 0xe3, 0x84, 0x25, 0xc6, 0x67,
+		0x08, 0xa9, 0x4a, 0xeb, 0x8c, 0x2d, 0xce, 0x6f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0xa2, 0x44, 0xe6, 0x88, 0x2a, 0xcc, 0x6e,
+		0x10, 0xb2, 0x54, 0xf6, 0x98, 0x3a, 0xdc, 0x7e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0xa3, 0x46, 0xe5, 0x8c, 0x2f, 0xca, 0x69,
+		0x18, 0xbb, 0x5e, 0xfd, 0x94, 0x37, 0xd2, 0x71 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0xa4, 0x48, 0xec, 0x90, 0x34, 0xd8, 0x7c,
+		0x20, 0x84, 0x68, 0xcc, 0xb0, 0x14, 0xf8, 0x5c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0xa5, 0x4a, 0xef, 0x94, 0x31, 0xde, 0x7b,
+		0x28, 0x8d, 0x62, 0xc7, 0xbc, 0x19, 0xf6, 0x53 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0xa6, 0x4c, 0xea, 0x98, 0x3e, 0xd4, 0x72,
+		0x30, 0x96, 0x7c, 0xda, 0xa8, 0x0e, 0xe4, 0x42 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0xa7, 0x4e, 0xe9, 0x9c, 0x3b, 0xd2, 0x75,
+		0x38, 0x9f, 0x76, 0xd1, 0xa4, 0x03, 0xea, 0x4d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0xa8, 0x50, 0xf8, 0xa0, 0x08, 0xf0, 0x58,
+		0x40, 0xe8, 0x10, 0xb8, 0xe0, 0x48, 0xb0, 0x18 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0xa9, 0x52, 0xfb, 0xa4, 0x0d, 0xf6, 0x5f,
+		0x48, 0xe1, 0x1a, 0xb3, 0xec, 0x45, 0xbe, 0x17 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0xaa, 0x54, 0xfe, 0xa8, 0x02, 0xfc, 0x56,
+		0x50, 0xfa, 0x04, 0xae, 0xf8, 0x52, 0xac, 0x06 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0xab, 0x56, 0xfd, 0xac, 0x07, 0xfa, 0x51,
+		0x58, 0xf3, 0x0e, 0xa5, 0xf4, 0x5f, 0xa2, 0x09 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0xac, 0x58, 0xf4, 0xb0, 0x1c, 0xe8, 0x44,
+		0x60, 0xcc, 0x38, 0x94, 0xd0, 0x7c, 0x88, 0x24 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0xad, 0x5a, 0xf7, 0xb4, 0x19, 0xee, 0x43,
+		0x68, 0xc5, 0x32, 0x9f, 0xdc, 0x71, 0x86, 0x2b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0xae, 0x5c, 0xf2, 0xb8, 0x16, 0xe4, 0x4a,
+		0x70, 0xde, 0x2c, 0x82, 0xc8, 0x66, 0x94, 0x3a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0xaf, 0x5e, 0xf1, 0xbc, 0x13, 0xe2, 0x4d,
+		0x78, 0xd7, 0x26, 0x89, 0xc4, 0x6b, 0x9a, 0x35 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0xb1, 0x62, 0xd3, 0xc4, 0x75, 0xa6, 0x17,
+		0x88, 0x39, 0xea, 0x5b, 0x4c, 0xfd, 0x2e, 0x9f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0xb2, 0x64, 0xd6, 0xc8, 0x7a, 0xac, 0x1e,
+		0x90, 0x22, 0xf4, 0x46, 0x58, 0xea, 0x3c, 0x8e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0xb3, 0x66, 0xd5, 0xcc, 0x7f, 0xaa, 0x19,
+		0x98, 0x2b, 0xfe, 0x4d, 0x54, 0xe7, 0x32, 0x81 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0xb4, 0x68, 0xdc, 0xd0, 0x64, 0xb8, 0x0c,
+		0xa0, 0x14, 0xc8, 0x7c, 0x70, 0xc4, 0x18, 0xac },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0xb5, 0x6a, 0xdf, 0xd4, 0x61, 0xbe, 0x0b,
+		0xa8, 0x1d, 0xc2, 0x77, 0x7c, 0xc9, 0x16, 0xa3 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0xb6, 0x6c, 0xda, 0xd8, 0x6e, 0xb4, 0x02,
+		0xb0, 0x06, 0xdc, 0x6a, 0x68, 0xde, 0x04, 0xb2 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0xb7, 0x6e, 0xd9, 0xdc, 0x6b, 0xb2, 0x05,
+		0xb8, 0x0f, 0xd6, 0x61, 0x64, 0xd3, 0x0a, 0xbd },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0xb8, 0x70, 0xc8, 0xe0, 0x58, 0x90, 0x28,
+		0xc0, 0x78, 0xb0, 0x08, 0x20, 0x98, 0x50, 0xe8 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0xb9, 0x72, 0xcb, 0xe4, 0x5d, 0x96, 0x2f,
+		0xc8, 0x71, 0xba, 0x03, 0x2c, 0x95, 0x5e, 0xe7 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0xba, 0x74, 0xce, 0xe8, 0x52, 0x9c, 0x26,
+		0xd0, 0x6a, 0xa4, 0x1e, 0x38, 0x82, 0x4c, 0xf6 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0xbb, 0x76, 0xcd, 0xec, 0x57, 0x9a, 0x21,
+		0xd8, 0x63, 0xae, 0x15, 0x34, 0x8f, 0x42, 0xf9 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0xbc, 0x78, 0xc4, 0xf0, 0x4c, 0x88, 0x34,
+		0xe0, 0x5c, 0x98, 0x24, 0x10, 0xac, 0x68, 0xd4 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0xbd, 0x7a, 0xc7, 0xf4, 0x49, 0x8e, 0x33,
+		0xe8, 0x55, 0x92, 0x2f, 0x1c, 0xa1, 0x66, 0xdb },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0xbe, 0x7c, 0xc2, 0xf8, 0x46, 0x84, 0x3a,
+		0xf0, 0x4e, 0x8c, 0x32, 0x08, 0xb6, 0x74, 0xca },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0xbf, 0x7e, 0xc1, 0xfc, 0x43, 0x82, 0x3d,
+		0xf8, 0x47, 0x86, 0x39, 0x04, 0xbb, 0x7a, 0xc5 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0xc1, 0x82, 0x43, 0x04, 0xc5, 0x86, 0x47,
+		0x08, 0xc9, 0x8a, 0x4b, 0x0c, 0xcd, 0x8e, 0x4f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0xc2, 0x84, 0x46, 0x08, 0xca, 0x8c, 0x4e,
+		0x10, 0xd2, 0x94, 0x56, 0x18, 0xda, 0x9c, 0x5e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0xc3, 0x86, 0x45, 0x0c, 0xcf, 0x8a, 0x49,
+		0x18, 0xdb, 0x9e, 0x5d, 0x14, 0xd7, 0x92, 0x51 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0xc4, 0x88, 0x4c, 0x10, 0xd4, 0x98, 0x5c,
+		0x20, 0xe4, 0xa8, 0x6c, 0x30, 0xf4, 0xb8, 0x7c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0xc5, 0x8a, 0x4f, 0x14, 0xd1, 0x9e, 0x5b,
+		0x28, 0xed, 0xa2, 0x67, 0x3c, 0xf9, 0xb6, 0x73 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0xc6, 0x8c, 0x4a, 0x18, 0xde, 0x94, 0x52,
+		0x30, 0xf6, 0xbc, 0x7a, 0x28, 0xee, 0xa4, 0x62 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0xc7, 0x8e, 0x49, 0x1c, 0xdb, 0x92, 0x55,
+		0x38, 0xff, 0xb6, 0x71, 0x24, 0xe3, 0xaa, 0x6d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0xc8, 0x90, 0x58, 0x20, 0xe8, 0xb0, 0x78,
+		0x40, 0x88, 0xd0, 0x18, 0x60, 0xa8, 0xf0, 0x38 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0xc9, 0x92, 0x5b, 0x24, 0xed, 0xb6, 0x7f,
+		0x48, 0x81, 0xda, 0x13, 0x6c, 0xa5, 0xfe, 0x37 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0xca, 0x94, 0x5e, 0x28, 0xe2, 0xbc, 0x76,
+		0x50, 0x9a, 0xc4, 0x0e, 0x78, 0xb2, 0xec, 0x26 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0xcb, 0x96, 0x5d, 0x2c, 0xe7, 0xba, 0x71,
+		0x58, 0x93, 0xce, 0x05, 0x74, 0xbf, 0xe2, 0x29 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0xcc, 0x98, 0x54, 0x30, 0xfc, 0xa8, 0x64,
+		0x60, 0xac, 0xf8, 0x34, 0x50, 0x9c, 0xc8, 0x04 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0xcd, 0x9a, 0x57, 0x34, 0xf9, 0xae, 0x63,
+		0x68, 0xa5, 0xf2, 0x3f, 0x5c, 0x91, 0xc6, 0x0b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0xce, 0x9c, 0x52, 0x38, 0xf6, 0xa4, 0x6a,
+		0x70, 0xbe, 0xec, 0x22, 0x48, 0x86, 0xd4, 0x1a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0xcf, 0x9e, 0x51, 0x3c, 0xf3, 0xa2, 0x6d,
+		0x78, 0xb7, 0xe6, 0x29, 0x44, 0x8b, 0xda, 0x15 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0xd1, 0xa2, 0x73, 0x44, 0x95, 0xe6, 0x37,
+		0x88, 0x59, 0x2a, 0xfb, 0xcc, 0x1d, 0x6e, 0xbf },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0xd2, 0xa4, 0x76, 0x48, 0x9a, 0xec, 0x3e,
+		0x90, 0x42, 0x34, 0xe6, 0xd8, 0x0a, 0x7c, 0xae },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0xd3, 0xa6, 0x75, 0x4c, 0x9f, 0xea, 0x39,
+		0x98, 0x4b, 0x3e, 0xed, 0xd4, 0x07, 0x72, 0xa1 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0xd4, 0xa8, 0x7c, 0x50, 0x84, 0xf8, 0x2c,
+		0xa0, 0x74, 0x08, 0xdc, 0xf0, 0x24, 0x58, 0x8c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0xd5, 0xaa, 0x7f, 0x54, 0x81, 0xfe, 0x2b,
+		0xa8, 0x7d, 0x02, 0xd7, 0xfc, 0x29, 0x56, 0x83 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0xd6, 0xac, 0x7a, 0x58, 0x8e, 0xf4, 0x22,
+		0xb0, 0x66, 0x1c, 0xca, 0xe8, 0x3e, 0x44, 0x92 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0xd7, 0xae, 0x79, 0x5c, 0x8b, 0xf2, 0x25,
+		0xb8, 0x6f, 0x16, 0xc1, 0xe4, 0x33, 0x4a, 0x9d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0xd8, 0xb0, 0x68, 0x60, 0xb8, 0xd0, 0x08,
+		0xc0, 0x18, 0x70, 0xa8, 0xa0, 0x78, 0x10, 0xc8 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0xd9, 0xb2, 0x6b, 0x64, 0xbd, 0xd6, 0x0f,
+		0xc8, 0x11, 0x7a, 0xa3, 0xac, 0x75, 0x1e, 0xc7 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0xda, 0xb4, 0x6e, 0x68, 0xb2, 0xdc, 0x06,
+		0xd0, 0x0a, 0x64, 0xbe, 0xb8, 0x62, 0x0c, 0xd6 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0xdb, 0xb6, 0x6d, 0x6c, 0xb7, 0xda, 0x01,
+		0xd8, 0x03, 0x6e, 0xb5, 0xb4, 0x6f, 0x02, 0xd9 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0xdc, 0xb8, 0x64, 0x70, 0xac, 0xc8, 0x14,
+		0xe0, 0x3c, 0x58, 0x84, 0x90, 0x4c, 0x28, 0xf4 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0xdd, 0xba, 0x67, 0x74, 0xa9, 0xce, 0x13,
+		0xe8, 0x35, 0x52, 0x8f, 0x9c, 0x41, 0x26, 0xfb },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0xde, 0xbc, 0x62, 0x78, 0xa6, 0xc4, 0x1a,
+		0xf0, 0x2e, 0x4c, 0x92, 0x88, 0x56, 0x34, 0xea },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0xdf, 0xbe, 0x61, 0x7c, 0xa3, 0xc2, 0x1d,
+		0xf8, 0x27, 0x46, 0x99, 0x84, 0x5b, 0x3a, 0xe5 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0xe1, 0xc2, 0x23, 0x84, 0x65, 0x46, 0xa7,
+		0x08, 0xe9, 0xca, 0x2b, 0x8c, 0x6d, 0x4e, 0xaf },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0xe2, 0xc4, 0x26, 0x88, 0x6a, 0x4c, 0xae,
+		0x10, 0xf2, 0xd4, 0x36, 0x98, 0x7a, 0x5c, 0xbe },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0xe3, 0xc6, 0x25, 0x8c, 0x6f, 0x4a, 0xa9,
+		0x18, 0xfb, 0xde, 0x3d, 0x94, 0x77, 0x52, 0xb1 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0xe4, 0xc8, 0x2c, 0x90, 0x74, 0x58, 0xbc,
+		0x20, 0xc4, 0xe8, 0x0c, 0xb0, 0x54, 0x78, 0x9c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0xe5, 0xca, 0x2f, 0x94, 0x71, 0x5e, 0xbb,
+		0x28, 0xcd, 0xe2, 0x07, 0xbc, 0x59, 0x76, 0x93 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0xe6, 0xcc, 0x2a, 0x98, 0x7e, 0x54, 0xb2,
+		0x30, 0xd6, 0xfc, 0x1a, 0xa8, 0x4e, 0x64, 0x82 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0xe7, 0xce, 0x29, 0x9c, 0x7b, 0x52, 0xb5,
+		0x38, 0xdf, 0xf6, 0x11, 0xa4, 0x43, 0x6a, 0x8d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0xe8, 0xd0, 0x38, 0xa0, 0x48, 0x70, 0x98,
+		0x40, 0xa8, 0x90, 0x78, 0xe0, 0x08, 0x30, 0xd8 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0xe9, 0xd2, 0x3b, 0xa4, 0x4d, 0x76, 0x9f,
+		0x48, 0xa1, 0x9a, 0x73, 0xec, 0x05, 0x3e, 0xd7 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0xea, 0xd4, 0x3e, 0xa8, 0x42, 0x7c, 0x96,
+		0x50, 0xba, 0x84, 0x6e, 0xf8, 0x12, 0x2c, 0xc6 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0xeb, 0xd6, 0x3d, 0xac, 0x47, 0x7a, 0x91,
+		0x58, 0xb3, 0x8e, 0x65, 0xf4, 0x1f, 0x22, 0xc9 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0xec, 0xd8, 0x34, 0xb0, 0x5c, 0x68, 0x84,
+		0x60, 0x8c, 0xb8, 0x54, 0xd0, 0x3c, 0x08, 0xe4 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0xed, 0xda, 0x37, 0xb4, 0x59, 0x6e, 0x83,
+		0x68, 0x85, 0xb2, 0x5f, 0xdc, 0x31, 0x06, 0xeb },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0xee, 0xdc, 0x32, 0xb8, 0x56, 0x64, 0x8a,
+		0x70, 0x9e, 0xac, 0x42, 0xc8, 0x26, 0x14, 0xfa },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0xef, 0xde, 0x31, 0xbc, 0x53, 0x62, 0x8d,
+		0x78, 0x97, 0xa6, 0x49, 0xc4, 0x2b, 0x1a, 0xf5 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+		0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0 },
+	{ 0x00, 0xf1, 0xe2, 0x13, 0xc4, 0x35, 0x26, 0xd7,
+		0x88, 0x79, 0x6a, 0x9b, 0x4c, 0xbd, 0xae, 0x5f },
+	{ 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0,
+		0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 },
+	{ 0x00, 0xf2, 0xe4, 0x16, 0xc8, 0x3a, 0x2c, 0xde,
+		0x90, 0x62, 0x74, 0x86, 0x58, 0xaa, 0xbc, 0x4e },
+	{ 0x00, 0x30, 0x60, 0x50, 0xc0, 0xf0, 0xa0, 0x90,
+		0x80, 0xb0, 0xe0, 0xd0, 0x40, 0x70, 0x20, 0x10 },
+	{ 0x00, 0xf3, 0xe6, 0x15, 0xcc, 0x3f, 0x2a, 0xd9,
+		0x98, 0x6b, 0x7e, 0x8d, 0x54, 0xa7, 0xb2, 0x41 },
+	{ 0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0,
+		0x00, 0x40, 0x80, 0xc0, 0x00, 0x40, 0x80, 0xc0 },
+	{ 0x00, 0xf4, 0xe8, 0x1c, 0xd0, 0x24, 0x38, 0xcc,
+		0xa0, 0x54, 0x48, 0xbc, 0x70, 0x84, 0x98, 0x6c },
+	{ 0x00, 0x50, 0xa0, 0xf0, 0x40, 0x10, 0xe0, 0xb0,
+		0x80, 0xd0, 0x20, 0x70, 0xc0, 0x90, 0x60, 0x30 },
+	{ 0x00, 0xf5, 0xea, 0x1f, 0xd4, 0x21, 0x3e, 0xcb,
+		0xa8, 0x5d, 0x42, 0xb7, 0x7c, 0x89, 0x96, 0x63 },
+	{ 0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20,
+		0x00, 0x60, 0xc0, 0xa0, 0x80, 0xe0, 0x40, 0x20 },
+	{ 0x00, 0xf6, 0xec, 0x1a, 0xd8, 0x2e, 0x34, 0xc2,
+		0xb0, 0x46, 0x5c, 0xaa, 0x68, 0x9e, 0x84, 0x72 },
+	{ 0x00, 0x70, 0xe0, 0x90, 0xc0, 0xb0, 0x20, 0x50,
+		0x80, 0xf0, 0x60, 0x10, 0x40, 0x30, 0xa0, 0xd0 },
+	{ 0x00, 0xf7, 0xee, 0x19, 0xdc, 0x2b, 0x32, 0xc5,
+		0xb8, 0x4f, 0x56, 0xa1, 0x64, 0x93, 0x8a, 0x7d },
+	{ 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
+		0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80 },
+	{ 0x00, 0xf8, 0xf0, 0x08, 0xe0, 0x18, 0x10, 0xe8,
+		0xc0, 0x38, 0x30, 0xc8, 0x20, 0xd8, 0xd0, 0x28 },
+	{ 0x00, 0x90, 0x20, 0xb0, 0x40, 0xd0, 0x60, 0xf0,
+		0x80, 0x10, 0xa0, 0x30, 0xc0, 0x50, 0xe0, 0x70 },
+	{ 0x00, 0xf9, 0xf2, 0x0b, 0xe4, 0x1d, 0x16, 0xef,
+		0xc8, 0x31, 0x3a, 0xc3, 0x2c, 0xd5, 0xde, 0x27 },
+	{ 0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60,
+		0x00, 0xa0, 0x40, 0xe0, 0x80, 0x20, 0xc0, 0x60 },
+	{ 0x00, 0xfa, 0xf4, 0x0e, 0xe8, 0x12, 0x1c, 0xe6,
+		0xd0, 0x2a, 0x24, 0xde, 0x38, 0xc2, 0xcc, 0x36 },
+	{ 0x00, 0xb0, 0x60, 0xd0, 0xc0, 0x70, 0xa0, 0x10,
+		0x80, 0x30, 0xe0, 0x50, 0x40, 0xf0, 0x20, 0x90 },
+	{ 0x00, 0xfb, 0xf6, 0x0d, 0xec, 0x17, 0x1a, 0xe1,
+		0xd8, 0x23, 0x2e, 0xd5, 0x34, 0xcf, 0xc2, 0x39 },
+	{ 0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40,
+		0x00, 0xc0, 0x80, 0x40, 0x00, 0xc0, 0x80, 0x40 },
+	{ 0x00, 0xfc, 0xf8, 0x04, 0xf0, 0x0c, 0x08, 0xf4,
+		0xe0, 0x1c, 0x18, 0xe4, 0x10, 0xec, 0xe8, 0x14 },
+	{ 0x00, 0xd0, 0xa0, 0x70, 0x40, 0x90, 0xe0, 0x30,
+		0x80, 0x50, 0x20, 0xf0, 0xc0, 0x10, 0x60, 0xb0 },
+	{ 0x00, 0xfd, 0xfa, 0x07, 0xf4, 0x09, 0x0e, 0xf3,
+		0xe8, 0x15, 0x12, 0xef, 0x1c, 0xe1, 0xe6, 0x1b },
+	{ 0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0,
+		0x00, 0xe0, 0xc0, 0x20, 0x80, 0x60, 0x40, 0xa0 },
+	{ 0x00, 0xfe, 0xfc, 0x02, 0xf8, 0x06, 0x04, 0xfa,
+		0xf0, 0x0e, 0x0c, 0xf2, 0x08, 0xf6, 0xf4, 0x0a },
+	{ 0x00, 0xf0, 0xe0, 0x10, 0xc0, 0x30, 0x20, 0xd0,
+		0x80, 0x70, 0x60, 0x90, 0x40, 0xb0, 0xa0, 0x50 },
+	{ 0x00, 0xff, 0xfe, 0x01, 0xfc, 0x03, 0x02, 0xfd,
+		0xf8, 0x07, 0x06, 0xf9, 0x04, 0xfb, 0xfa, 0x05 },
+};
+
+#endif /* defined(RAIDZ_SSE) || defined(RAIDZ_AVX2) */
diff --git a/module/zfs/vdev_raidz_math_x86simd.h b/module/zfs/vdev_raidz_math_x86simd.h
new file mode 100644
index 000000000000..3a35b62ee42f
--- /dev/null
+++ b/module/zfs/vdev_raidz_math_x86simd.h
@@ -0,0 +1,512 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#ifndef	_VDEV_RAIDZ_MATH_X86SIMD_H
+#define	_VDEV_RAIDZ_MATH_X86SIMD_H
+
+#include <sys/types.h>
+
+#define	D(idx) ((elem_t *)(((uint8_t *)(cols[idx].rc_data)) + off))
+
+static raidz_inline void
+raidz_flush_data(void)
+{
+	FLUSH();
+}
+
+static raidz_inline size_t
+gen_p_block(raidz_col_t *cols, const size_t nd, const size_t off)
+{
+	size_t c;
+
+#define	G_P_P 0, 1, 2, 3
+
+	PREFETCHNTA(D(1), 4, 4);
+
+	LOAD(D(CODE_P+1), G_P_P);
+	for (c = CODE_P+2; c < nd; c++) {
+		PREFETCHNTA(D(c), 4, 4);
+
+		XOR_ACC(D(c), G_P_P);
+	}
+
+	STREAM_STORE(D(CODE_P), G_P_P);
+	return (4 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+gen_pq_block(raidz_col_t *cols, const size_t nd, const size_t nld,
+	const size_t off)
+{
+	size_t c;
+
+#define	G_PQ_P 0, 1, 2, 3
+#define	G_PQ_Q 4, 5, 6, 7
+#define	G_PQ_LOAD 8, 9, 10, 11
+
+	PREFETCHNTA(D(2), 4, 4);
+
+	MUL2_SETUP();
+
+	LOAD(D(CODE_Q+1), G_PQ_P);
+	COPY(G_PQ_P, G_PQ_Q);
+
+	for (c = CODE_Q+2; c < nld; c++) {
+		PREFETCHNTA(D(c), 4, 4);
+		MUL2(G_PQ_Q);
+
+		LOAD(D(c), G_PQ_LOAD);
+		XOR(G_PQ_LOAD, G_PQ_P);
+		XOR(G_PQ_LOAD, G_PQ_Q);
+	}
+	STREAM_STORE(D(CODE_P), G_PQ_P);
+
+	for (; c < nd; c++) {
+		MUL2(G_PQ_Q);
+	}
+	STREAM_STORE(D(CODE_Q), G_PQ_Q);
+
+	return (4 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+gen_pqr_block(raidz_col_t *cols, const size_t nd, const size_t nld,
+	const size_t off)
+{
+	size_t c;
+
+#define	G_PQR_P 0, 1, 2, 3
+#define	G_PQR_Q 4, 5, 6, 7
+#define	G_PQR_R 8, 9, 10, 11
+#define	G_PQR_LOAD 12, 13
+
+#define	G_PQR_P_1 0, 1
+#define	G_PQR_P_2 2, 3
+#define	G_PQR_Q_1 4, 5
+#define	G_PQR_Q_2 6, 7
+#define	G_PQR_R_1 8, 9
+#define	G_PQR_R_2 10, 11
+
+	PREFETCHNTA(D(3), 4, 4);
+
+	MUL2_SETUP();
+
+	LOAD(D(CODE_R+1), G_PQR_P);
+	COPY(G_PQR_P,  G_PQR_Q);
+	COPY(G_PQR_P,  G_PQR_R);
+
+	for (c = CODE_R+2; c < nld; c++) {
+		PREFETCHNTA(D(c), 4, 4);
+
+		MUL2(G_PQR_Q);
+		MUL4(G_PQR_R);
+
+		LOAD(D(c), G_PQR_LOAD);
+		XOR(G_PQR_LOAD,  G_PQR_P_1);
+		XOR(G_PQR_LOAD,  G_PQR_Q_1);
+		XOR(G_PQR_LOAD,  G_PQR_R_1);
+
+		LOAD(D(c) + 2, G_PQR_LOAD);
+		XOR(G_PQR_LOAD,  G_PQR_P_2);
+		XOR(G_PQR_LOAD,  G_PQR_Q_2);
+		XOR(G_PQR_LOAD,  G_PQR_R_2);
+	}
+	STREAM_STORE(D(CODE_P), G_PQR_P);
+
+	for (; c < nd; c++) {
+		MUL2(G_PQR_Q);
+		MUL4(G_PQR_R);
+	}
+	STREAM_STORE(D(CODE_Q), G_PQR_Q);
+	STREAM_STORE(D(CODE_R), G_PQR_R);
+
+	return (4 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_p_block(raidz_col_t *cols, const size_t parity,
+	const size_t xidx, const size_t nd, const size_t off)
+{
+	size_t c;
+
+#define	R_P_P 0, 1, 2, 3
+
+	PREFETCHNTA(D(CODE_P), 0, 4);
+
+	ZERO(R_P_P);
+
+	for (c = parity; c < nd; c++) {
+		PREFETCHNTA(D(c), 4, 4);
+
+		if (c != xidx) {
+			XOR_ACC(D(c), R_P_P);
+		}
+	}
+	XOR_ACC(D(CODE_P), R_P_P);
+	/* Calc X (X==P) */
+	STREAM_STORE(D(xidx), R_P_P);
+
+	return (4 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_q_block(raidz_col_t *cols, const size_t parity,
+	const size_t xidx, const int x_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+
+#define	R_Q_Q 0, 1
+
+	PREFETCHNTA(D(CODE_Q), 0, 2);
+
+	MUL2_SETUP();
+	ZERO(R_Q_Q);
+
+	for (c = parity; c < nld; c++) {
+		PREFETCHNTA(D(c), 2, 2);
+
+		MUL2(R_Q_Q);
+
+		if (c != xidx) {
+			XOR_ACC(D(c), R_Q_Q);
+		}
+	}
+
+	for (; c < nd; c++) {
+		MUL2(R_Q_Q);
+	}
+	XOR_ACC(D(CODE_Q), R_Q_Q);
+
+	/* Calc X */
+	MULx2(x_mul, R_Q_Q);
+	STREAM_STORE(D(xidx), R_Q_Q);
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_r_block(raidz_col_t *cols, const size_t parity,
+	const size_t xidx, const int x_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+
+#define	R_R_R 0, 1
+
+	PREFETCHNTA(D(CODE_R), 0, 2);
+
+	MUL2_SETUP();
+	ZERO(R_R_R);
+
+	for (c = parity; c < nld; c++) {
+		PREFETCHNTA(D(c), 2, 2);
+
+		MUL4(R_R_R);
+
+		if (c != xidx) {
+			XOR_ACC(D(c), R_R_R);
+		}
+	}
+
+	for (; c < nd; c++) {
+		MUL4(R_R_R);
+	}
+	XOR_ACC(D(CODE_R), R_R_R);
+
+	/* Calc X */
+	MULx2(x_mul, R_R_R);
+	STREAM_STORE(D(xidx), R_R_R);
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_pq_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y,
+	const size_t xsize, const size_t ysize,
+	const int a_mul, const int b_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+
+	PREFETCHNTA(D(CODE_P), 0, 2);
+	PREFETCHNTA(D(CODE_Q), 0, 2);
+
+#define	R_PQ_P 0, 1
+#define	R_PQ_Q 2, 3
+#define	R_PQ_LOAD 	4, 5
+#define	R_PQ_P_SAVE 4, 5
+
+	MUL2_SETUP();
+	ZERO(R_PQ_P);
+	ZERO(R_PQ_Q);
+
+	for (c = parity; c < nld; c++) {
+		PREFETCHNTA(D(c), 2, 2);
+
+		MUL2(R_PQ_Q);
+
+		if (c != x && c != y) {
+			LOAD(D(c), R_PQ_LOAD);
+			XOR(R_PQ_LOAD, R_PQ_P);
+			XOR(R_PQ_LOAD, R_PQ_Q);
+		}
+	}
+
+	for (; c < nd; c++) {
+		MUL2(R_PQ_Q);
+	}
+	XOR_ACC(D(CODE_P), R_PQ_P);
+	XOR_ACC(D(CODE_Q), R_PQ_Q);
+
+	/* Save Pxy */
+	COPY(R_PQ_P,  R_PQ_P_SAVE);
+
+	/* Calc X */
+	MULx2(a_mul, R_PQ_P);
+	MULx2(b_mul, R_PQ_Q);
+
+	XOR(R_PQ_Q,  R_PQ_P);
+	STREAM_STORE(D(x), R_PQ_P);
+
+	if (xsize == ysize) {
+		/* Calc Y */
+		XOR(R_PQ_P_SAVE,  R_PQ_P);
+		STREAM_STORE(D(y), R_PQ_P);
+	}
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_pr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y,
+	const size_t xsize, const size_t ysize,
+	const int a_mul, const int b_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+
+#define	R_PR_P 0, 1
+#define	R_PR_R 2, 3
+#define	R_PR_LOAD	4, 5
+#define	R_PR_P_SAVE 4, 5
+
+	PREFETCHNTA(D(CODE_P), 0, 2);
+	PREFETCHNTA(D(CODE_R), 0, 2);
+
+	MUL2_SETUP();
+	ZERO(R_PR_P);
+	ZERO(R_PR_R);
+
+	for (c = parity; c < nld; c++) {
+		PREFETCHNTA(D(c), 2, 2);
+		MUL4(R_PR_R);
+		if (c != x && c != y) {
+			LOAD(D(c), R_PR_LOAD);
+			XOR(R_PR_LOAD, R_PR_P);
+			XOR(R_PR_LOAD, R_PR_R);
+		}
+	}
+
+	for (; c < nd; c++) {
+		MUL4(R_PR_R);
+	}
+	XOR_ACC(D(CODE_P), R_PR_P);
+	XOR_ACC(D(CODE_R), R_PR_R);
+
+	/* Save Pxy */
+	COPY(R_PR_P, R_PR_P_SAVE);
+
+	/* Calc X */
+	MULx2(a_mul, R_PR_P);
+	MULx2(b_mul, R_PR_R);
+
+	XOR(R_PR_R,  R_PR_P);
+	STREAM_STORE(D(x), R_PR_P);
+
+	if (xsize == ysize) {
+		/* Calc Y */
+		XOR(R_PR_P_SAVE, R_PR_P);
+		STREAM_STORE(D(y), R_PR_P);
+	}
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_qr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y,
+	const size_t xsize, const size_t ysize,
+	const int xq_mul, const int x_mul,
+	const int yq_mul, const int y_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+
+#define	R_QR_P		0, 1
+#define	R_QR_R		2, 3
+#define	R_QR_LOAD	4, 5
+#define	R_QR_P_SAVE 4, 5
+
+	PREFETCHNTA(D(CODE_Q), 0, 2);
+	PREFETCHNTA(D(CODE_R), 0, 2);
+
+	MUL2_SETUP();
+	ZERO(R_QR_P);
+	ZERO(R_QR_R);
+
+	for (c = parity; c < nld; c++) {
+		PREFETCHNTA(D(c), 2, 2);
+
+		MUL2(R_QR_P);
+		MUL4(R_QR_R);
+
+		if (c != x && c != y) {
+			LOAD(D(c), R_QR_LOAD);
+			XOR(R_QR_LOAD, R_QR_P);
+			XOR(R_QR_LOAD, R_QR_R);
+		}
+	}
+
+	for (; c < nd; c++) {
+		MUL2(R_QR_P);
+		MUL4(R_QR_R);
+	}
+	XOR_ACC(D(CODE_Q), R_QR_P);
+	XOR_ACC(D(CODE_R), R_QR_R);
+
+	/* Save Pxy */
+	COPY(R_QR_P, R_QR_P_SAVE);
+
+	/* Calc X */
+	MULx2(xq_mul, R_QR_P); /* X = Q * xqm */
+	XOR(R_QR_R, R_QR_P);   /* X = R ^ X   */
+	MULx2(x_mul, R_QR_P);  /* X = X * xm */
+	STREAM_STORE(D(x), R_QR_P);
+
+	if (xsize == ysize) {
+		/* Calc Y */
+		MULx2(yq_mul, R_QR_P_SAVE);  /* X = Q * xqm */
+
+		XOR(R_QR_R, R_QR_P_SAVE); /* X = R ^ X   */
+
+		MULx2(y_mul, R_QR_P_SAVE);  /* X = X * xm */
+		STREAM_STORE(D(y), R_QR_P_SAVE);
+	}
+
+	return (2 * sizeof (elem_t));
+}
+
+static raidz_inline size_t
+rec_pqr_block(raidz_col_t *cols, const size_t parity,
+	const size_t x, const size_t y, const size_t z,
+	const size_t xsize, const size_t ysize, const size_t zsize,
+	const int xp_mul, const int xq_mul, const int xr_mul,
+	const int yp_mul, const int yq_mul, const int upd_q_mul,
+	const size_t nd, const size_t nld, const size_t off)
+{
+	size_t c;
+
+#define	R_PQR_P 0, 1
+#define	R_PQR_Q 2, 3
+#define	R_PQR_R 4, 5
+#define	R_PQR_LOAD 6, 7
+#define	R_PQR_P_SAVE 6, 7
+#define	R_PQR_Q_SAVE 8, 9
+
+	PREFETCHNTA(D(CODE_P), 0, 2);
+	PREFETCHNTA(D(CODE_Q), 0, 2);
+	PREFETCHNTA(D(CODE_R), 0, 2);
+
+	MUL2_SETUP();
+	ZERO(R_PQR_P);
+	ZERO(R_PQR_Q);
+	ZERO(R_PQR_R);
+
+	for (c = parity; c < nld; c++) {
+		PREFETCHNTA(D(c), 2, 2);
+
+		MUL2(R_PQR_Q);
+		MUL4(R_PQR_R);
+
+		if (c != x && c != y && c != z) {
+			LOAD(D(c), R_PQR_LOAD);
+			XOR(R_PQR_LOAD, R_PQR_P);
+			XOR(R_PQR_LOAD, R_PQR_Q);
+			XOR(R_PQR_LOAD, R_PQR_R);
+		}
+	}
+
+	for (; c < nd; c++) {
+		MUL2(R_PQR_Q);
+		MUL4(R_PQR_R);
+	}
+
+	XOR_ACC(D(CODE_P), R_PQR_P);
+	XOR_ACC(D(CODE_Q), R_PQR_Q);
+	XOR_ACC(D(CODE_R), R_PQR_R);
+
+	/* Save Pxyz and Qxyz */
+	COPY(R_PQR_P, R_PQR_P_SAVE);
+	COPY(R_PQR_Q, R_PQR_Q_SAVE);
+
+	/* Calc X */
+	MULx2(xp_mul, R_PQR_P); /* Xp = Pxyz * xp */
+	MULx2(xq_mul, R_PQR_Q); /* Xq = Qxyz * xq */
+	XOR(R_PQR_Q, R_PQR_P);
+	MULx2(xr_mul, R_PQR_R); /* Xr = Rxyz * xr */
+	XOR(R_PQR_R, R_PQR_P);  /* X = Xp + Xq + Xr */
+
+	STREAM_STORE(D(x), R_PQR_P);
+
+	if (ysize == xsize) {
+
+		/* Calc Y */
+		XOR(R_PQR_P, R_PQR_P_SAVE); /* Pyz = Pxyz + X */
+
+		MULx2(upd_q_mul, R_PQR_P);  /* Xq = X * upd_q */
+		XOR(R_PQR_P, R_PQR_Q_SAVE); /* Qyz = Qxyz + Xq */
+
+		COPY(R_PQR_P_SAVE, R_PQR_P);	/* restore Pyz */
+		MULx2(yp_mul, R_PQR_P);			/* Yp = Pyz * yp */
+
+		MULx2(yq_mul, R_PQR_Q_SAVE);	/* Yq = Qyz * yq */
+		XOR(R_PQR_P, R_PQR_Q_SAVE); 	/* Y = Yp + Yq */
+
+		STREAM_STORE(D(y), R_PQR_Q_SAVE);
+
+		if (zsize == xsize) {
+			/* Calc Z */
+			XOR(R_PQR_P_SAVE, R_PQR_Q_SAVE); /* Z = Pz = Pyz + Y */
+			STREAM_STORE(D(z), R_PQR_Q_SAVE);
+		}
+	}
+
+	return (2 * sizeof (elem_t));
+}
+
+#endif  /* _VDEV_RAIDZ_MATH_X86SIMD_H */