vendor/openzfs/2.0-rc0-g184df27

152 files changed, 64911 insertions, 0 deletions

diff --git a/include/sys/Makefile.am b/include/sys/Makefile.am
new file mode 100644
index 0000000000000..c2bc3be03c9f0
--- /dev/null
+++ b/include/sys/Makefile.am
@@ -0,0 +1,147 @@
+SUBDIRS = fm fs crypto lua sysevent zstd
+
+COMMON_H = \
+	abd.h \
+	abd_impl.h \
+	aggsum.h \
+	arc.h \
+	arc_impl.h \
+	avl.h \
+	avl_impl.h \
+	bitops.h \
+	blkptr.h \
+	bplist.h \
+	bpobj.h \
+	bptree.h \
+	btree.h \
+	bqueue.h \
+	dataset_kstats.h \
+	dbuf.h \
+	ddt.h \
+	dmu.h \
+	dmu_impl.h \
+	dmu_objset.h \
+	dmu_recv.h \
+	dmu_redact.h \
+	dmu_send.h \
+	dmu_traverse.h \
+	dmu_tx.h \
+	dmu_zfetch.h \
+	dnode.h \
+	dsl_bookmark.h \
+	dsl_dataset.h \
+	dsl_deadlist.h \
+	dsl_deleg.h \
+	dsl_destroy.h \
+	dsl_dir.h \
+	dsl_crypt.h \
+	dsl_pool.h \
+	dsl_prop.h \
+	dsl_scan.h \
+	dsl_synctask.h \
+	dsl_userhold.h \
+	edonr.h \
+	efi_partition.h \
+	frame.h \
+	hkdf.h \
+	metaslab.h \
+	metaslab_impl.h \
+	mmp.h \
+	mntent.h \
+	mod.h \
+	multilist.h \
+	note.h \
+	nvpair.h \
+	nvpair_impl.h \
+	objlist.h \
+	pathname.h \
+	qat.h \
+	range_tree.h \
+	rrwlock.h \
+	sa.h \
+	sa_impl.h \
+	skein.h \
+	spa_boot.h \
+	spa_checkpoint.h \
+	spa_log_spacemap.h \
+	space_map.h \
+	space_reftree.h \
+	spa.h \
+	spa_impl.h \
+	spa_checksum.h \
+	sysevent.h \
+	txg.h \
+	txg_impl.h \
+	u8_textprep_data.h \
+	u8_textprep.h \
+	uberblock.h \
+	uberblock_impl.h \
+	uio_impl.h \
+	unique.h \
+	uuid.h \
+	vdev_disk.h \
+	vdev_file.h \
+	vdev.h \
+	vdev_impl.h \
+	vdev_indirect_births.h \
+	vdev_indirect_mapping.h \
+	vdev_initialize.h \
+	vdev_raidz.h \
+	vdev_raidz_impl.h \
+	vdev_rebuild.h \
+	vdev_removal.h \
+	vdev_trim.h \
+	xvattr.h \
+	zap.h \
+	zap_impl.h \
+	zap_leaf.h \
+	zcp.h \
+	zcp_global.h \
+	zcp_iter.h \
+	zcp_prop.h \
+	zcp_set.h \
+	zfeature.h \
+	zfs_acl.h \
+	zfs_context.h \
+	zfs_debug.h \
+	zfs_delay.h \
+	zfs_file.h \
+	zfs_fuid.h \
+	zfs_project.h \
+	zfs_quota.h \
+	zfs_ratelimit.h \
+	zfs_refcount.h \
+	zfs_rlock.h \
+	zfs_sa.h \
+	zfs_stat.h \
+	zfs_sysfs.h \
+	zfs_znode.h \
+	zil.h \
+	zil_impl.h \
+	zio_checksum.h \
+	zio_compress.h \
+	zio_crypt.h \
+	zio.h \
+	zio_impl.h \
+	zio_priority.h \
+	zrlock.h \
+	zthr.h
+
+KERNEL_H = \
+	zfs_ioctl.h \
+	zfs_ioctl_impl.h \
+	zfs_onexit.h \
+	zvol.h \
+	zvol_impl.h
+
+if CONFIG_USER
+libzfsdir = $(includedir)/libzfs/sys
+libzfs_HEADERS = $(COMMON_H)
+endif
+
+if CONFIG_KERNEL
+if BUILD_LINUX
+kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys
+kernel_HEADERS = $(COMMON_H) $(KERNEL_H)
+endif
+endif
diff --git a/include/sys/abd.h b/include/sys/abd.h
new file mode 100644
index 0000000000000..735a13147598c
--- /dev/null
+++ b/include/sys/abd.h
@@ -0,0 +1,162 @@
+/*
+ * 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) 2014 by Chunwei Chen. All rights reserved.
+ * Copyright (c) 2016, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef _ABD_H
+#define	_ABD_H
+
+#include <sys/isa_defs.h>
+#include <sys/debug.h>
+#include <sys/zfs_refcount.h>
+#include <sys/uio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct abd; /* forward declaration */
+typedef struct abd abd_t;
+
+typedef int abd_iter_func_t(void *buf, size_t len, void *priv);
+typedef int abd_iter_func2_t(void *bufa, void *bufb, size_t len, void *priv);
+
+extern int zfs_abd_scatter_enabled;
+
+/*
+ * Allocations and deallocations
+ */
+
+abd_t *abd_alloc(size_t, boolean_t);
+abd_t *abd_alloc_linear(size_t, boolean_t);
+abd_t *abd_alloc_gang_abd(void);
+abd_t *abd_alloc_for_io(size_t, boolean_t);
+abd_t *abd_alloc_sametype(abd_t *, size_t);
+void abd_gang_add(abd_t *, abd_t *, boolean_t);
+void abd_free(abd_t *);
+void abd_put(abd_t *);
+abd_t *abd_get_offset(abd_t *, size_t);
+abd_t *abd_get_offset_size(abd_t *, size_t, size_t);
+abd_t *abd_get_zeros(size_t);
+abd_t *abd_get_from_buf(void *, size_t);
+void abd_cache_reap_now(void);
+
+/*
+ * Conversion to and from a normal buffer
+ */
+
+void *abd_to_buf(abd_t *);
+void *abd_borrow_buf(abd_t *, size_t);
+void *abd_borrow_buf_copy(abd_t *, size_t);
+void abd_return_buf(abd_t *, void *, size_t);
+void abd_return_buf_copy(abd_t *, void *, size_t);
+void abd_take_ownership_of_buf(abd_t *, boolean_t);
+void abd_release_ownership_of_buf(abd_t *);
+
+/*
+ * ABD operations
+ */
+
+int abd_iterate_func(abd_t *, size_t, size_t, abd_iter_func_t *, void *);
+int abd_iterate_func2(abd_t *, abd_t *, size_t, size_t, size_t,
+    abd_iter_func2_t *, void *);
+void abd_copy_off(abd_t *, abd_t *, size_t, size_t, size_t);
+void abd_copy_from_buf_off(abd_t *, const void *, size_t, size_t);
+void abd_copy_to_buf_off(void *, abd_t *, size_t, size_t);
+int abd_cmp(abd_t *, abd_t *);
+int abd_cmp_buf_off(abd_t *, const void *, size_t, size_t);
+void abd_zero_off(abd_t *, size_t, size_t);
+void abd_verify(abd_t *);
+uint_t abd_get_size(abd_t *);
+
+void abd_raidz_gen_iterate(abd_t **cabds, abd_t *dabd,
+	ssize_t csize, ssize_t dsize, const unsigned parity,
+	void (*func_raidz_gen)(void **, const void *, size_t, size_t));
+void abd_raidz_rec_iterate(abd_t **cabds, abd_t **tabds,
+	ssize_t tsize, const unsigned parity,
+	void (*func_raidz_rec)(void **t, const size_t tsize, void **c,
+	const unsigned *mul),
+	const unsigned *mul);
+
+/*
+ * Wrappers for calls with offsets of 0
+ */
+
+static inline void
+abd_copy(abd_t *dabd, abd_t *sabd, size_t size)
+{
+	abd_copy_off(dabd, sabd, 0, 0, size);
+}
+
+static inline void
+abd_copy_from_buf(abd_t *abd, const void *buf, size_t size)
+{
+	abd_copy_from_buf_off(abd, buf, 0, size);
+}
+
+static inline void
+abd_copy_to_buf(void* buf, abd_t *abd, size_t size)
+{
+	abd_copy_to_buf_off(buf, abd, 0, size);
+}
+
+static inline int
+abd_cmp_buf(abd_t *abd, const void *buf, size_t size)
+{
+	return (abd_cmp_buf_off(abd, buf, 0, size));
+}
+
+static inline void
+abd_zero(abd_t *abd, size_t size)
+{
+	abd_zero_off(abd, 0, size);
+}
+
+/*
+ * ABD type check functions
+ */
+boolean_t abd_is_linear(abd_t *);
+boolean_t abd_is_gang(abd_t *);
+boolean_t abd_is_linear_page(abd_t *);
+
+/*
+ * Module lifecycle
+ * Defined in each specific OS's abd_os.c
+ */
+
+void abd_init(void);
+void abd_fini(void);
+
+/*
+ * Linux ABD bio functions
+ */
+#if defined(__linux__) && defined(_KERNEL)
+unsigned int abd_bio_map_off(struct bio *, abd_t *, unsigned int, size_t);
+unsigned long abd_nr_pages_off(abd_t *, unsigned int, size_t);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ABD_H */
diff --git a/include/sys/abd_impl.h b/include/sys/abd_impl.h
new file mode 100644
index 0000000000000..b1fa87b42a48b
--- /dev/null
+++ b/include/sys/abd_impl.h
@@ -0,0 +1,150 @@
+/*
+ * 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) 2014 by Chunwei Chen. All rights reserved.
+ * Copyright (c) 2016, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef _ABD_IMPL_H
+#define	_ABD_IMPL_H
+
+#include <sys/abd.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum abd_flags {
+	ABD_FLAG_LINEAR		= 1 << 0, /* is buffer linear (or scattered)? */
+	ABD_FLAG_OWNER		= 1 << 1, /* does it own its data buffers? */
+	ABD_FLAG_META		= 1 << 2, /* does this represent FS metadata? */
+	ABD_FLAG_MULTI_ZONE  	= 1 << 3, /* pages split over memory zones */
+	ABD_FLAG_MULTI_CHUNK 	= 1 << 4, /* pages split over multiple chunks */
+	ABD_FLAG_LINEAR_PAGE 	= 1 << 5, /* linear but allocd from page */
+	ABD_FLAG_GANG		= 1 << 6, /* mult ABDs chained together */
+	ABD_FLAG_GANG_FREE	= 1 << 7, /* gang ABD is responsible for mem */
+	ABD_FLAG_ZEROS		= 1 << 8, /* ABD for zero-filled buffer */
+} abd_flags_t;
+
+typedef enum abd_stats_op {
+	ABDSTAT_INCR, /* Increase abdstat values */
+	ABDSTAT_DECR  /* Decrease abdstat values */
+} abd_stats_op_t;
+
+struct abd {
+	abd_flags_t	abd_flags;
+	uint_t		abd_size;	/* excludes scattered abd_offset */
+	list_node_t	abd_gang_link;
+	struct abd	*abd_parent;
+	zfs_refcount_t	abd_children;
+	kmutex_t	abd_mtx;
+	union {
+		struct abd_scatter {
+			uint_t		abd_offset;
+#if defined(__FreeBSD__) && defined(_KERNEL)
+			uint_t  abd_chunk_size;
+			void    *abd_chunks[];
+#else
+			uint_t		abd_nents;
+			struct scatterlist *abd_sgl;
+#endif
+		} abd_scatter;
+		struct abd_linear {
+			void		*abd_buf;
+			struct scatterlist *abd_sgl; /* for LINEAR_PAGE */
+		} abd_linear;
+		struct abd_gang {
+			list_t abd_gang_chain;
+		} abd_gang;
+	} abd_u;
+};
+
+struct scatterlist; /* forward declaration */
+
+struct abd_iter {
+	/* public interface */
+	void		*iter_mapaddr;	/* addr corresponding to iter_pos */
+	size_t		iter_mapsize;	/* length of data valid at mapaddr */
+
+	/* private */
+	abd_t		*iter_abd;	/* ABD being iterated through */
+	size_t		iter_pos;
+	size_t		iter_offset;	/* offset in current sg/abd_buf, */
+					/* abd_offset included */
+	struct scatterlist *iter_sg;	/* current sg */
+};
+
+extern abd_t *abd_zero_scatter;
+
+abd_t *abd_gang_get_offset(abd_t *, size_t *);
+
+/*
+ * OS specific functions
+ */
+
+abd_t *abd_alloc_struct(size_t);
+abd_t *abd_get_offset_scatter(abd_t *, size_t);
+void abd_free_struct(abd_t *);
+void abd_alloc_chunks(abd_t *, size_t);
+void abd_free_chunks(abd_t *);
+boolean_t abd_size_alloc_linear(size_t);
+void abd_update_scatter_stats(abd_t *, abd_stats_op_t);
+void abd_update_linear_stats(abd_t *, abd_stats_op_t);
+void abd_verify_scatter(abd_t *);
+void abd_free_linear_page(abd_t *);
+/* OS specific abd_iter functions */
+void abd_iter_init(struct abd_iter  *, abd_t *);
+boolean_t abd_iter_at_end(struct abd_iter *);
+void abd_iter_advance(struct abd_iter *, size_t);
+void abd_iter_map(struct abd_iter *);
+void abd_iter_unmap(struct abd_iter *);
+
+/*
+ * Helper macros
+ */
+#define	ABDSTAT(stat)		(abd_stats.stat.value.ui64)
+#define	ABDSTAT_INCR(stat, val) \
+	atomic_add_64(&abd_stats.stat.value.ui64, (val))
+#define	ABDSTAT_BUMP(stat)	ABDSTAT_INCR(stat, 1)
+#define	ABDSTAT_BUMPDOWN(stat)	ABDSTAT_INCR(stat, -1)
+
+#define	ABD_SCATTER(abd)	(abd->abd_u.abd_scatter)
+#define	ABD_LINEAR_BUF(abd)	(abd->abd_u.abd_linear.abd_buf)
+#define	ABD_GANG(abd)		(abd->abd_u.abd_gang)
+
+#if defined(_KERNEL)
+#if defined(__FreeBSD__)
+#define	abd_enter_critical(flags)	critical_enter()
+#define	abd_exit_critical(flags)	critical_exit()
+#else
+#define	abd_enter_critical(flags)	local_irq_save(flags)
+#define	abd_exit_critical(flags)	local_irq_restore(flags)
+#endif
+#else /* !_KERNEL */
+#define	abd_enter_critical(flags)	((void)0)
+#define	abd_exit_critical(flags)	((void)0)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ABD_IMPL_H */
diff --git a/include/sys/aggsum.h b/include/sys/aggsum.h
new file mode 100644
index 0000000000000..cb43727f1df42
--- /dev/null
+++ b/include/sys/aggsum.h
@@ -0,0 +1,59 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (c) 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_AGGSUM_H
+#define	_SYS_AGGSUM_H
+
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct aggsum_bucket aggsum_bucket_t;
+
+struct aggsum_bucket {
+	kmutex_t asc_lock;
+	int64_t asc_delta;
+	uint64_t asc_borrowed;
+} ____cacheline_aligned;
+
+/*
+ * Fan out over FANOUT cpus.
+ */
+typedef struct aggsum {
+	kmutex_t as_lock;
+	int64_t as_lower_bound;
+	int64_t as_upper_bound;
+	uint_t as_numbuckets;
+	aggsum_bucket_t *as_buckets;
+} aggsum_t;
+
+void aggsum_init(aggsum_t *, uint64_t);
+void aggsum_fini(aggsum_t *);
+int64_t aggsum_lower_bound(aggsum_t *);
+int64_t aggsum_upper_bound(aggsum_t *);
+int aggsum_compare(aggsum_t *, uint64_t);
+uint64_t aggsum_value(aggsum_t *);
+void aggsum_add(aggsum_t *, int64_t);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_AGGSUM_H */
diff --git a/include/sys/arc.h b/include/sys/arc.h
new file mode 100644
index 0000000000000..a0852b4d5a70a
--- /dev/null
+++ b/include/sys/arc.h
@@ -0,0 +1,335 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2016 by Delphix. All rights reserved.
+ * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2019, Allan Jude
+ * Copyright (c) 2019, Klara Inc.
+ */
+
+#ifndef	_SYS_ARC_H
+#define	_SYS_ARC_H
+
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <sys/zio.h>
+#include <sys/dmu.h>
+#include <sys/spa.h>
+#include <sys/zfs_refcount.h>
+
+/*
+ * Used by arc_flush() to inform arc_evict_state() that it should evict
+ * all available buffers from the arc state being passed in.
+ */
+#define	ARC_EVICT_ALL	-1ULL
+
+#define	HDR_SET_LSIZE(hdr, x) do { \
+	ASSERT(IS_P2ALIGNED(x, 1U << SPA_MINBLOCKSHIFT)); \
+	(hdr)->b_lsize = ((x) >> SPA_MINBLOCKSHIFT); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	HDR_SET_PSIZE(hdr, x) do { \
+	ASSERT(IS_P2ALIGNED((x), 1U << SPA_MINBLOCKSHIFT)); \
+	(hdr)->b_psize = ((x) >> SPA_MINBLOCKSHIFT); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	HDR_GET_LSIZE(hdr)	((hdr)->b_lsize << SPA_MINBLOCKSHIFT)
+#define	HDR_GET_PSIZE(hdr)	((hdr)->b_psize << SPA_MINBLOCKSHIFT)
+
+typedef struct arc_buf_hdr arc_buf_hdr_t;
+typedef struct arc_buf arc_buf_t;
+typedef struct arc_prune arc_prune_t;
+
+/*
+ * Because the ARC can store encrypted data, errors (not due to bugs) may arise
+ * while transforming data into its desired format - specifically, when
+ * decrypting, the key may not be present, or the HMAC may not be correct
+ * which signifies deliberate tampering with the on-disk state
+ * (assuming that the checksum was correct). If any error occurs, the "buf"
+ * parameter will be NULL.
+ */
+typedef void arc_read_done_func_t(zio_t *zio, const zbookmark_phys_t *zb,
+    const blkptr_t *bp, arc_buf_t *buf, void *priv);
+typedef void arc_write_done_func_t(zio_t *zio, arc_buf_t *buf, void *priv);
+typedef void arc_prune_func_t(int64_t bytes, void *priv);
+
+/* Shared module parameters */
+extern int zfs_arc_average_blocksize;
+
+/* generic arc_done_func_t's which you can use */
+arc_read_done_func_t arc_bcopy_func;
+arc_read_done_func_t arc_getbuf_func;
+
+/* generic arc_prune_func_t wrapper for callbacks */
+struct arc_prune {
+	arc_prune_func_t	*p_pfunc;
+	void			*p_private;
+	uint64_t		p_adjust;
+	list_node_t		p_node;
+	zfs_refcount_t		p_refcnt;
+};
+
+typedef enum arc_strategy {
+	ARC_STRATEGY_META_ONLY		= 0, /* Evict only meta data buffers */
+	ARC_STRATEGY_META_BALANCED	= 1, /* Evict data buffers if needed */
+} arc_strategy_t;
+
+typedef enum arc_flags
+{
+	/*
+	 * Public flags that can be passed into the ARC by external consumers.
+	 */
+	ARC_FLAG_WAIT			= 1 << 0,	/* perform sync I/O */
+	ARC_FLAG_NOWAIT			= 1 << 1,	/* perform async I/O */
+	ARC_FLAG_PREFETCH		= 1 << 2,	/* I/O is a prefetch */
+	ARC_FLAG_CACHED			= 1 << 3,	/* I/O was in cache */
+	ARC_FLAG_L2CACHE		= 1 << 4,	/* cache in L2ARC */
+	ARC_FLAG_PREDICTIVE_PREFETCH	= 1 << 5,	/* I/O from zfetch */
+	ARC_FLAG_PRESCIENT_PREFETCH	= 1 << 6,	/* long min lifespan */
+
+	/*
+	 * Private ARC flags.  These flags are private ARC only flags that
+	 * will show up in b_flags in the arc_hdr_buf_t. These flags should
+	 * only be set by ARC code.
+	 */
+	ARC_FLAG_IN_HASH_TABLE		= 1 << 7,	/* buffer is hashed */
+	ARC_FLAG_IO_IN_PROGRESS		= 1 << 8,	/* I/O in progress */
+	ARC_FLAG_IO_ERROR		= 1 << 9,	/* I/O failed for buf */
+	ARC_FLAG_INDIRECT		= 1 << 10,	/* indirect block */
+	/* Indicates that block was read with ASYNC priority. */
+	ARC_FLAG_PRIO_ASYNC_READ	= 1 << 11,
+	ARC_FLAG_L2_WRITING		= 1 << 12,	/* write in progress */
+	ARC_FLAG_L2_EVICTED		= 1 << 13,	/* evicted during I/O */
+	ARC_FLAG_L2_WRITE_HEAD		= 1 << 14,	/* head of write list */
+	/*
+	 * Encrypted or authenticated on disk (may be plaintext in memory).
+	 * This header has b_crypt_hdr allocated. Does not include indirect
+	 * blocks with checksums of MACs which will also have their X
+	 * (encrypted) bit set in the bp.
+	 */
+	ARC_FLAG_PROTECTED		= 1 << 15,
+	/* data has not been authenticated yet */
+	ARC_FLAG_NOAUTH			= 1 << 16,
+	/* indicates that the buffer contains metadata (otherwise, data) */
+	ARC_FLAG_BUFC_METADATA		= 1 << 17,
+
+	/* Flags specifying whether optional hdr struct fields are defined */
+	ARC_FLAG_HAS_L1HDR		= 1 << 18,
+	ARC_FLAG_HAS_L2HDR		= 1 << 19,
+
+	/*
+	 * Indicates the arc_buf_hdr_t's b_pdata matches the on-disk data.
+	 * This allows the l2arc to use the blkptr's checksum to verify
+	 * the data without having to store the checksum in the hdr.
+	 */
+	ARC_FLAG_COMPRESSED_ARC		= 1 << 20,
+	ARC_FLAG_SHARED_DATA		= 1 << 21,
+
+	/*
+	 * Fail this arc_read() (with ENOENT) if the data is not already present
+	 * in cache.
+	 */
+	ARC_FLAG_CACHED_ONLY		= 1 << 22,
+
+	/*
+	 * The arc buffer's compression mode is stored in the top 7 bits of the
+	 * flags field, so these dummy flags are included so that MDB can
+	 * interpret the enum properly.
+	 */
+	ARC_FLAG_COMPRESS_0		= 1 << 24,
+	ARC_FLAG_COMPRESS_1		= 1 << 25,
+	ARC_FLAG_COMPRESS_2		= 1 << 26,
+	ARC_FLAG_COMPRESS_3		= 1 << 27,
+	ARC_FLAG_COMPRESS_4		= 1 << 28,
+	ARC_FLAG_COMPRESS_5		= 1 << 29,
+	ARC_FLAG_COMPRESS_6		= 1 << 30
+
+} arc_flags_t;
+
+typedef enum arc_buf_flags {
+	ARC_BUF_FLAG_SHARED		= 1 << 0,
+	ARC_BUF_FLAG_COMPRESSED		= 1 << 1,
+	/*
+	 * indicates whether this arc_buf_t is encrypted, regardless of
+	 * state on-disk
+	 */
+	ARC_BUF_FLAG_ENCRYPTED		= 1 << 2
+} arc_buf_flags_t;
+
+struct arc_buf {
+	arc_buf_hdr_t		*b_hdr;
+	arc_buf_t		*b_next;
+	kmutex_t		b_evict_lock;
+	void			*b_data;
+	arc_buf_flags_t		b_flags;
+};
+
+typedef enum arc_buf_contents {
+	ARC_BUFC_INVALID,			/* invalid type */
+	ARC_BUFC_DATA,				/* buffer contains data */
+	ARC_BUFC_METADATA,			/* buffer contains metadata */
+	ARC_BUFC_NUMTYPES
+} arc_buf_contents_t;
+
+/*
+ * The following breakdowns of arc_size exist for kstat only.
+ */
+typedef enum arc_space_type {
+	ARC_SPACE_DATA,
+	ARC_SPACE_META,
+	ARC_SPACE_HDRS,
+	ARC_SPACE_L2HDRS,
+	ARC_SPACE_DBUF,
+	ARC_SPACE_DNODE,
+	ARC_SPACE_BONUS,
+	ARC_SPACE_ABD_CHUNK_WASTE,
+	ARC_SPACE_NUMTYPES
+} arc_space_type_t;
+
+typedef enum arc_state_type {
+	ARC_STATE_ANON,
+	ARC_STATE_MRU,
+	ARC_STATE_MRU_GHOST,
+	ARC_STATE_MFU,
+	ARC_STATE_MFU_GHOST,
+	ARC_STATE_L2C_ONLY,
+	ARC_STATE_NUMTYPES
+} arc_state_type_t;
+
+typedef struct arc_buf_info {
+	arc_state_type_t	abi_state_type;
+	arc_buf_contents_t	abi_state_contents;
+	uint32_t		abi_flags;
+	uint32_t		abi_bufcnt;
+	uint64_t		abi_size;
+	uint64_t		abi_spa;
+	uint64_t		abi_access;
+	uint32_t		abi_mru_hits;
+	uint32_t		abi_mru_ghost_hits;
+	uint32_t		abi_mfu_hits;
+	uint32_t		abi_mfu_ghost_hits;
+	uint32_t		abi_l2arc_hits;
+	uint32_t		abi_holds;
+	uint64_t		abi_l2arc_dattr;
+	uint64_t		abi_l2arc_asize;
+	enum zio_compress	abi_l2arc_compress;
+} arc_buf_info_t;
+
+void arc_space_consume(uint64_t space, arc_space_type_t type);
+void arc_space_return(uint64_t space, arc_space_type_t type);
+boolean_t arc_is_metadata(arc_buf_t *buf);
+boolean_t arc_is_encrypted(arc_buf_t *buf);
+boolean_t arc_is_unauthenticated(arc_buf_t *buf);
+enum zio_compress arc_get_compression(arc_buf_t *buf);
+void arc_get_raw_params(arc_buf_t *buf, boolean_t *byteorder, uint8_t *salt,
+    uint8_t *iv, uint8_t *mac);
+int arc_untransform(arc_buf_t *buf, spa_t *spa, const zbookmark_phys_t *zb,
+    boolean_t in_place);
+void arc_convert_to_raw(arc_buf_t *buf, uint64_t dsobj, boolean_t byteorder,
+    dmu_object_type_t ot, const uint8_t *salt, const uint8_t *iv,
+    const uint8_t *mac);
+arc_buf_t *arc_alloc_buf(spa_t *spa, void *tag, arc_buf_contents_t type,
+    int32_t size);
+arc_buf_t *arc_alloc_compressed_buf(spa_t *spa, void *tag,
+    uint64_t psize, uint64_t lsize, enum zio_compress compression_type,
+    uint8_t complevel);
+arc_buf_t *arc_alloc_raw_buf(spa_t *spa, void *tag, uint64_t dsobj,
+    boolean_t byteorder, const uint8_t *salt, const uint8_t *iv,
+    const uint8_t *mac, dmu_object_type_t ot, uint64_t psize, uint64_t lsize,
+    enum zio_compress compression_type, uint8_t complevel);
+uint8_t arc_get_complevel(arc_buf_t *buf);
+arc_buf_t *arc_loan_buf(spa_t *spa, boolean_t is_metadata, int size);
+arc_buf_t *arc_loan_compressed_buf(spa_t *spa, uint64_t psize, uint64_t lsize,
+    enum zio_compress compression_type, uint8_t complevel);
+arc_buf_t *arc_loan_raw_buf(spa_t *spa, uint64_t dsobj, boolean_t byteorder,
+    const uint8_t *salt, const uint8_t *iv, const uint8_t *mac,
+    dmu_object_type_t ot, uint64_t psize, uint64_t lsize,
+    enum zio_compress compression_type, uint8_t complevel);
+void arc_return_buf(arc_buf_t *buf, void *tag);
+void arc_loan_inuse_buf(arc_buf_t *buf, void *tag);
+void arc_buf_destroy(arc_buf_t *buf, void *tag);
+void arc_buf_info(arc_buf_t *buf, arc_buf_info_t *abi, int state_index);
+uint64_t arc_buf_size(arc_buf_t *buf);
+uint64_t arc_buf_lsize(arc_buf_t *buf);
+void arc_buf_access(arc_buf_t *buf);
+void arc_release(arc_buf_t *buf, void *tag);
+int arc_released(arc_buf_t *buf);
+void arc_buf_sigsegv(int sig, siginfo_t *si, void *unused);
+void arc_buf_freeze(arc_buf_t *buf);
+void arc_buf_thaw(arc_buf_t *buf);
+#ifdef ZFS_DEBUG
+int arc_referenced(arc_buf_t *buf);
+#endif
+
+int arc_read(zio_t *pio, spa_t *spa, const blkptr_t *bp,
+    arc_read_done_func_t *done, void *priv, zio_priority_t priority,
+    int flags, arc_flags_t *arc_flags, const zbookmark_phys_t *zb);
+zio_t *arc_write(zio_t *pio, spa_t *spa, uint64_t txg,
+    blkptr_t *bp, arc_buf_t *buf, boolean_t l2arc, const zio_prop_t *zp,
+    arc_write_done_func_t *ready, arc_write_done_func_t *child_ready,
+    arc_write_done_func_t *physdone, arc_write_done_func_t *done,
+    void *priv, zio_priority_t priority, int zio_flags,
+    const zbookmark_phys_t *zb);
+
+arc_prune_t *arc_add_prune_callback(arc_prune_func_t *func, void *priv);
+void arc_remove_prune_callback(arc_prune_t *p);
+void arc_freed(spa_t *spa, const blkptr_t *bp);
+
+void arc_flush(spa_t *spa, boolean_t retry);
+void arc_tempreserve_clear(uint64_t reserve);
+int arc_tempreserve_space(spa_t *spa, uint64_t reserve, uint64_t txg);
+
+uint64_t arc_all_memory(void);
+uint64_t arc_default_max(uint64_t min, uint64_t allmem);
+uint64_t arc_target_bytes(void);
+void arc_init(void);
+void arc_fini(void);
+
+/*
+ * Level 2 ARC
+ */
+
+void l2arc_add_vdev(spa_t *spa, vdev_t *vd);
+void l2arc_remove_vdev(vdev_t *vd);
+boolean_t l2arc_vdev_present(vdev_t *vd);
+void l2arc_rebuild_vdev(vdev_t *vd, boolean_t reopen);
+boolean_t l2arc_range_check_overlap(uint64_t bottom, uint64_t top,
+    uint64_t check);
+void l2arc_init(void);
+void l2arc_fini(void);
+void l2arc_start(void);
+void l2arc_stop(void);
+void l2arc_spa_rebuild_start(spa_t *spa);
+
+#ifndef _KERNEL
+extern boolean_t arc_watch;
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_ARC_H */
diff --git a/include/sys/arc_impl.h b/include/sys/arc_impl.h
new file mode 100644
index 0000000000000..c5061695d9442
--- /dev/null
+++ b/include/sys/arc_impl.h
@@ -0,0 +1,928 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, Delphix. All rights reserved.
+ * Copyright (c) 2013, Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2013, Nexenta Systems, Inc.  All rights reserved.
+ * Copyright (c) 2020, George Amanakis. All rights reserved.
+ */
+
+#ifndef _SYS_ARC_IMPL_H
+#define	_SYS_ARC_IMPL_H
+
+#include <sys/arc.h>
+#include <sys/zio_crypt.h>
+#include <sys/zthr.h>
+#include <sys/aggsum.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Note that buffers can be in one of 6 states:
+ *	ARC_anon	- anonymous (discussed below)
+ *	ARC_mru		- recently used, currently cached
+ *	ARC_mru_ghost	- recently used, no longer in cache
+ *	ARC_mfu		- frequently used, currently cached
+ *	ARC_mfu_ghost	- frequently used, no longer in cache
+ *	ARC_l2c_only	- exists in L2ARC but not other states
+ * When there are no active references to the buffer, they are
+ * are linked onto a list in one of these arc states.  These are
+ * the only buffers that can be evicted or deleted.  Within each
+ * state there are multiple lists, one for meta-data and one for
+ * non-meta-data.  Meta-data (indirect blocks, blocks of dnodes,
+ * etc.) is tracked separately so that it can be managed more
+ * explicitly: favored over data, limited explicitly.
+ *
+ * Anonymous buffers are buffers that are not associated with
+ * a DVA.  These are buffers that hold dirty block copies
+ * before they are written to stable storage.  By definition,
+ * they are "ref'd" and are considered part of arc_mru
+ * that cannot be freed.  Generally, they will acquire a DVA
+ * as they are written and migrate onto the arc_mru list.
+ *
+ * The ARC_l2c_only state is for buffers that are in the second
+ * level ARC but no longer in any of the ARC_m* lists.  The second
+ * level ARC itself may also contain buffers that are in any of
+ * the ARC_m* states - meaning that a buffer can exist in two
+ * places.  The reason for the ARC_l2c_only state is to keep the
+ * buffer header in the hash table, so that reads that hit the
+ * second level ARC benefit from these fast lookups.
+ */
+
+typedef struct arc_state {
+	/*
+	 * list of evictable buffers
+	 */
+	multilist_t *arcs_list[ARC_BUFC_NUMTYPES];
+	/*
+	 * total amount of evictable data in this state
+	 */
+	zfs_refcount_t arcs_esize[ARC_BUFC_NUMTYPES];
+	/*
+	 * total amount of data in this state; this includes: evictable,
+	 * non-evictable, ARC_BUFC_DATA, and ARC_BUFC_METADATA.
+	 */
+	zfs_refcount_t arcs_size;
+	/*
+	 * supports the "dbufs" kstat
+	 */
+	arc_state_type_t arcs_state;
+} arc_state_t;
+
+typedef struct arc_callback arc_callback_t;
+
+struct arc_callback {
+	void			*acb_private;
+	arc_read_done_func_t	*acb_done;
+	arc_buf_t		*acb_buf;
+	boolean_t		acb_encrypted;
+	boolean_t		acb_compressed;
+	boolean_t		acb_noauth;
+	zbookmark_phys_t	acb_zb;
+	zio_t			*acb_zio_dummy;
+	zio_t			*acb_zio_head;
+	arc_callback_t		*acb_next;
+};
+
+typedef struct arc_write_callback arc_write_callback_t;
+
+struct arc_write_callback {
+	void			*awcb_private;
+	arc_write_done_func_t	*awcb_ready;
+	arc_write_done_func_t	*awcb_children_ready;
+	arc_write_done_func_t	*awcb_physdone;
+	arc_write_done_func_t	*awcb_done;
+	arc_buf_t		*awcb_buf;
+};
+
+/*
+ * ARC buffers are separated into multiple structs as a memory saving measure:
+ *   - Common fields struct, always defined, and embedded within it:
+ *       - L2-only fields, always allocated but undefined when not in L2ARC
+ *       - L1-only fields, only allocated when in L1ARC
+ *
+ *           Buffer in L1                     Buffer only in L2
+ *    +------------------------+          +------------------------+
+ *    | arc_buf_hdr_t          |          | arc_buf_hdr_t          |
+ *    |                        |          |                        |
+ *    |                        |          |                        |
+ *    |                        |          |                        |
+ *    +------------------------+          +------------------------+
+ *    | l2arc_buf_hdr_t        |          | l2arc_buf_hdr_t        |
+ *    | (undefined if L1-only) |          |                        |
+ *    +------------------------+          +------------------------+
+ *    | l1arc_buf_hdr_t        |
+ *    |                        |
+ *    |                        |
+ *    |                        |
+ *    |                        |
+ *    +------------------------+
+ *
+ * Because it's possible for the L2ARC to become extremely large, we can wind
+ * up eating a lot of memory in L2ARC buffer headers, so the size of a header
+ * is minimized by only allocating the fields necessary for an L1-cached buffer
+ * when a header is actually in the L1 cache. The sub-headers (l1arc_buf_hdr and
+ * l2arc_buf_hdr) are embedded rather than allocated separately to save a couple
+ * words in pointers. arc_hdr_realloc() is used to switch a header between
+ * these two allocation states.
+ */
+typedef struct l1arc_buf_hdr {
+	kmutex_t		b_freeze_lock;
+	zio_cksum_t		*b_freeze_cksum;
+
+	arc_buf_t		*b_buf;
+	uint32_t		b_bufcnt;
+	/* for waiting on writes to complete */
+	kcondvar_t		b_cv;
+	uint8_t			b_byteswap;
+
+
+	/* protected by arc state mutex */
+	arc_state_t		*b_state;
+	multilist_node_t	b_arc_node;
+
+	/* updated atomically */
+	clock_t			b_arc_access;
+	uint32_t		b_mru_hits;
+	uint32_t		b_mru_ghost_hits;
+	uint32_t		b_mfu_hits;
+	uint32_t		b_mfu_ghost_hits;
+	uint32_t		b_l2_hits;
+
+	/* self protecting */
+	zfs_refcount_t		b_refcnt;
+
+	arc_callback_t		*b_acb;
+	abd_t			*b_pabd;
+} l1arc_buf_hdr_t;
+
+typedef enum l2arc_dev_hdr_flags_t {
+	L2ARC_DEV_HDR_EVICT_FIRST = (1 << 0)	/* mirror of l2ad_first */
+} l2arc_dev_hdr_flags_t;
+
+/*
+ * Pointer used in persistent L2ARC (for pointing to log blocks).
+ */
+typedef struct l2arc_log_blkptr {
+	/*
+	 * Offset of log block within the device, in bytes
+	 */
+	uint64_t	lbp_daddr;
+	/*
+	 * Aligned payload size (in bytes) of the log block
+	 */
+	uint64_t	lbp_payload_asize;
+	/*
+	 * Offset in bytes of the first buffer in the payload
+	 */
+	uint64_t	lbp_payload_start;
+	/*
+	 * lbp_prop has the following format:
+	 *	* logical size (in bytes)
+	 *	* aligned (after compression) size (in bytes)
+	 *	* compression algorithm (we always LZ4-compress l2arc logs)
+	 *	* checksum algorithm (used for lbp_cksum)
+	 */
+	uint64_t	lbp_prop;
+	zio_cksum_t	lbp_cksum;	/* checksum of log */
+} l2arc_log_blkptr_t;
+
+/*
+ * The persistent L2ARC device header.
+ * Byte order of magic determines whether 64-bit bswap of fields is necessary.
+ */
+typedef struct l2arc_dev_hdr_phys {
+	uint64_t	dh_magic;	/* L2ARC_DEV_HDR_MAGIC */
+	uint64_t	dh_version;	/* Persistent L2ARC version */
+
+	/*
+	 * Global L2ARC device state and metadata.
+	 */
+	uint64_t	dh_spa_guid;
+	uint64_t	dh_vdev_guid;
+	uint64_t	dh_log_entries;		/* mirror of l2ad_log_entries */
+	uint64_t	dh_evict;		/* evicted offset in bytes */
+	uint64_t	dh_flags;		/* l2arc_dev_hdr_flags_t */
+	/*
+	 * Used in zdb.c for determining if a log block is valid, in the same
+	 * way that l2arc_rebuild() does.
+	 */
+	uint64_t	dh_start;		/* mirror of l2ad_start */
+	uint64_t	dh_end;			/* mirror of l2ad_end */
+	/*
+	 * Start of log block chain. [0] -> newest log, [1] -> one older (used
+	 * for initiating prefetch).
+	 */
+	l2arc_log_blkptr_t	dh_start_lbps[2];
+	/*
+	 * Aligned size of all log blocks as accounted by vdev_space_update().
+	 */
+	uint64_t	dh_lb_asize;		/* mirror of l2ad_lb_asize */
+	uint64_t	dh_lb_count;		/* mirror of l2ad_lb_count */
+	/*
+	 * Mirrors of vdev_trim_action_time and vdev_trim_state, used to
+	 * display when the cache device was fully trimmed for the last
+	 * time.
+	 */
+	uint64_t		dh_trim_action_time;
+	uint64_t		dh_trim_state;
+	const uint64_t		dh_pad[30];	/* pad to 512 bytes */
+	zio_eck_t		dh_tail;
+} l2arc_dev_hdr_phys_t;
+CTASSERT_GLOBAL(sizeof (l2arc_dev_hdr_phys_t) == SPA_MINBLOCKSIZE);
+
+/*
+ * A single ARC buffer header entry in a l2arc_log_blk_phys_t.
+ */
+typedef struct l2arc_log_ent_phys {
+	dva_t			le_dva;		/* dva of buffer */
+	uint64_t		le_birth;	/* birth txg of buffer */
+	/*
+	 * le_prop has the following format:
+	 *	* logical size (in bytes)
+	 *	* physical (compressed) size (in bytes)
+	 *	* compression algorithm
+	 *	* object type (used to restore arc_buf_contents_t)
+	 *	* protected status (used for encryption)
+	 *	* prefetch status (used in l2arc_read_done())
+	 */
+	uint64_t		le_prop;
+	uint64_t		le_daddr;	/* buf location on l2dev */
+	uint64_t		le_complevel;
+	/*
+	 * We pad the size of each entry to a power of 2 so that the size of
+	 * l2arc_log_blk_phys_t is power-of-2 aligned with SPA_MINBLOCKSHIFT,
+	 * because of the L2ARC_SET_*SIZE macros.
+	 */
+	const uint64_t		le_pad[2];	/* pad to 64 bytes	 */
+} l2arc_log_ent_phys_t;
+
+#define	L2ARC_LOG_BLK_MAX_ENTRIES	(1022)
+
+/*
+ * A log block of up to 1022 ARC buffer log entries, chained into the
+ * persistent L2ARC metadata linked list. Byte order of magic determines
+ * whether 64-bit bswap of fields is necessary.
+ */
+typedef struct l2arc_log_blk_phys {
+	uint64_t		lb_magic;	/* L2ARC_LOG_BLK_MAGIC */
+	/*
+	 * There are 2 chains (headed by dh_start_lbps[2]), and this field
+	 * points back to the previous block in this chain. We alternate
+	 * which chain we append to, so they are time-wise and offset-wise
+	 * interleaved, but that is an optimization rather than for
+	 * correctness.
+	 */
+	l2arc_log_blkptr_t	lb_prev_lbp;	/* pointer to prev log block */
+	/*
+	 * Pad header section to 128 bytes
+	 */
+	uint64_t		lb_pad[7];
+	/* Payload */
+	l2arc_log_ent_phys_t	lb_entries[L2ARC_LOG_BLK_MAX_ENTRIES];
+} l2arc_log_blk_phys_t;				/* 64K total */
+
+/*
+ * The size of l2arc_log_blk_phys_t has to be power-of-2 aligned with
+ * SPA_MINBLOCKSHIFT because of L2BLK_SET_*SIZE macros.
+ */
+CTASSERT_GLOBAL(IS_P2ALIGNED(sizeof (l2arc_log_blk_phys_t),
+    1ULL << SPA_MINBLOCKSHIFT));
+CTASSERT_GLOBAL(sizeof (l2arc_log_blk_phys_t) >= SPA_MINBLOCKSIZE);
+CTASSERT_GLOBAL(sizeof (l2arc_log_blk_phys_t) <= SPA_MAXBLOCKSIZE);
+
+/*
+ * These structures hold in-flight abd buffers for log blocks as they're being
+ * written to the L2ARC device.
+ */
+typedef struct l2arc_lb_abd_buf {
+	abd_t		*abd;
+	list_node_t	node;
+} l2arc_lb_abd_buf_t;
+
+/*
+ * These structures hold pointers to log blocks present on the L2ARC device.
+ */
+typedef struct l2arc_lb_ptr_buf {
+	l2arc_log_blkptr_t	*lb_ptr;
+	list_node_t		node;
+} l2arc_lb_ptr_buf_t;
+
+/* Macros for setting fields in le_prop and lbp_prop */
+#define	L2BLK_GET_LSIZE(field)	\
+	BF64_GET_SB((field), 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1)
+#define	L2BLK_SET_LSIZE(field, x)	\
+	BF64_SET_SB((field), 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1, x)
+#define	L2BLK_GET_PSIZE(field)	\
+	BF64_GET_SB((field), 16, SPA_PSIZEBITS, SPA_MINBLOCKSHIFT, 1)
+#define	L2BLK_SET_PSIZE(field, x)	\
+	BF64_SET_SB((field), 16, SPA_PSIZEBITS, SPA_MINBLOCKSHIFT, 1, x)
+#define	L2BLK_GET_COMPRESS(field)	\
+	BF64_GET((field), 32, SPA_COMPRESSBITS)
+#define	L2BLK_SET_COMPRESS(field, x)	\
+	BF64_SET((field), 32, SPA_COMPRESSBITS, x)
+#define	L2BLK_GET_PREFETCH(field)	BF64_GET((field), 39, 1)
+#define	L2BLK_SET_PREFETCH(field, x)	BF64_SET((field), 39, 1, x)
+#define	L2BLK_GET_CHECKSUM(field)	BF64_GET((field), 40, 8)
+#define	L2BLK_SET_CHECKSUM(field, x)	BF64_SET((field), 40, 8, x)
+#define	L2BLK_GET_TYPE(field)		BF64_GET((field), 48, 8)
+#define	L2BLK_SET_TYPE(field, x)	BF64_SET((field), 48, 8, x)
+#define	L2BLK_GET_PROTECTED(field)	BF64_GET((field), 56, 1)
+#define	L2BLK_SET_PROTECTED(field, x)	BF64_SET((field), 56, 1, x)
+
+#define	PTR_SWAP(x, y)		\
+	do {			\
+		void *tmp = (x);\
+		x = y;		\
+		y = tmp;	\
+		_NOTE(CONSTCOND)\
+	} while (0)
+
+#define	L2ARC_DEV_HDR_MAGIC	0x5a46534341434845LLU	/* ASCII: "ZFSCACHE" */
+#define	L2ARC_LOG_BLK_MAGIC	0x4c4f47424c4b4844LLU	/* ASCII: "LOGBLKHD" */
+
+/*
+ * L2ARC Internals
+ */
+typedef struct l2arc_dev {
+	vdev_t			*l2ad_vdev;	/* vdev */
+	spa_t			*l2ad_spa;	/* spa */
+	uint64_t		l2ad_hand;	/* next write location */
+	uint64_t		l2ad_start;	/* first addr on device */
+	uint64_t		l2ad_end;	/* last addr on device */
+	boolean_t		l2ad_first;	/* first sweep through */
+	boolean_t		l2ad_writing;	/* currently writing */
+	kmutex_t		l2ad_mtx;	/* lock for buffer list */
+	list_t			l2ad_buflist;	/* buffer list */
+	list_node_t		l2ad_node;	/* device list node */
+	zfs_refcount_t		l2ad_alloc;	/* allocated bytes */
+	/*
+	 * Persistence-related stuff
+	 */
+	l2arc_dev_hdr_phys_t	*l2ad_dev_hdr;	/* persistent device header */
+	uint64_t		l2ad_dev_hdr_asize; /* aligned hdr size */
+	l2arc_log_blk_phys_t	l2ad_log_blk;	/* currently open log block */
+	int			l2ad_log_ent_idx; /* index into cur log blk */
+	/* Number of bytes in current log block's payload */
+	uint64_t		l2ad_log_blk_payload_asize;
+	/*
+	 * Offset (in bytes) of the first buffer in current log block's
+	 * payload.
+	 */
+	uint64_t		l2ad_log_blk_payload_start;
+	/* Flag indicating whether a rebuild is scheduled or is going on */
+	boolean_t		l2ad_rebuild;
+	boolean_t		l2ad_rebuild_cancel;
+	boolean_t		l2ad_rebuild_began;
+	uint64_t		l2ad_log_entries;   /* entries per log blk  */
+	uint64_t		l2ad_evict;	 /* evicted offset in bytes */
+	/* List of pointers to log blocks present in the L2ARC device */
+	list_t			l2ad_lbptr_list;
+	/*
+	 * Aligned size of all log blocks as accounted by vdev_space_update().
+	 */
+	zfs_refcount_t		l2ad_lb_asize;
+	/*
+	 * Number of log blocks present on the device.
+	 */
+	zfs_refcount_t		l2ad_lb_count;
+	boolean_t		l2ad_trim_all; /* TRIM whole device */
+} l2arc_dev_t;
+
+/*
+ * Encrypted blocks will need to be stored encrypted on the L2ARC
+ * disk as they appear in the main pool. In order for this to work we
+ * need to pass around the encryption parameters so they can be used
+ * to write data to the L2ARC. This struct is only defined in the
+ * arc_buf_hdr_t if the L1 header is defined and has the ARC_FLAG_ENCRYPTED
+ * flag set.
+ */
+typedef struct arc_buf_hdr_crypt {
+	abd_t			*b_rabd;	/* raw encrypted data */
+	dmu_object_type_t	b_ot;		/* object type */
+	uint32_t		b_ebufcnt;	/* count of encrypted buffers */
+
+	/* dsobj for looking up encryption key for l2arc encryption */
+	uint64_t		b_dsobj;
+
+	/* encryption parameters */
+	uint8_t			b_salt[ZIO_DATA_SALT_LEN];
+	uint8_t			b_iv[ZIO_DATA_IV_LEN];
+
+	/*
+	 * Technically this could be removed since we will always be able to
+	 * get the mac from the bp when we need it. However, it is inconvenient
+	 * for callers of arc code to have to pass a bp in all the time. This
+	 * also allows us to assert that L2ARC data is properly encrypted to
+	 * match the data in the main storage pool.
+	 */
+	uint8_t			b_mac[ZIO_DATA_MAC_LEN];
+} arc_buf_hdr_crypt_t;
+
+typedef struct l2arc_buf_hdr {
+	/* protected by arc_buf_hdr mutex */
+	l2arc_dev_t		*b_dev;		/* L2ARC device */
+	uint64_t		b_daddr;	/* disk address, offset byte */
+	uint32_t		b_hits;
+	list_node_t		b_l2node;
+} l2arc_buf_hdr_t;
+
+typedef struct l2arc_write_callback {
+	l2arc_dev_t	*l2wcb_dev;		/* device info */
+	arc_buf_hdr_t	*l2wcb_head;		/* head of write buflist */
+	/* in-flight list of log blocks */
+	list_t		l2wcb_abd_list;
+} l2arc_write_callback_t;
+
+struct arc_buf_hdr {
+	/* protected by hash lock */
+	dva_t			b_dva;
+	uint64_t		b_birth;
+
+	arc_buf_contents_t	b_type;
+	uint8_t			b_complevel;
+	uint8_t			b_reserved1; /* used for 4 byte alignment */
+	uint16_t		b_reserved2; /* used for 4 byte alignment */
+	arc_buf_hdr_t		*b_hash_next;
+	arc_flags_t		b_flags;
+
+	/*
+	 * This field stores the size of the data buffer after
+	 * compression, and is set in the arc's zio completion handlers.
+	 * It is in units of SPA_MINBLOCKSIZE (e.g. 1 == 512 bytes).
+	 *
+	 * While the block pointers can store up to 32MB in their psize
+	 * field, we can only store up to 32MB minus 512B. This is due
+	 * to the bp using a bias of 1, whereas we use a bias of 0 (i.e.
+	 * a field of zeros represents 512B in the bp). We can't use a
+	 * bias of 1 since we need to reserve a psize of zero, here, to
+	 * represent holes and embedded blocks.
+	 *
+	 * This isn't a problem in practice, since the maximum size of a
+	 * buffer is limited to 16MB, so we never need to store 32MB in
+	 * this field. Even in the upstream illumos code base, the
+	 * maximum size of a buffer is limited to 16MB.
+	 */
+	uint16_t		b_psize;
+
+	/*
+	 * This field stores the size of the data buffer before
+	 * compression, and cannot change once set. It is in units
+	 * of SPA_MINBLOCKSIZE (e.g. 2 == 1024 bytes)
+	 */
+	uint16_t		b_lsize;	/* immutable */
+	uint64_t		b_spa;		/* immutable */
+
+	/* L2ARC fields. Undefined when not in L2ARC. */
+	l2arc_buf_hdr_t		b_l2hdr;
+	/* L1ARC fields. Undefined when in l2arc_only state */
+	l1arc_buf_hdr_t		b_l1hdr;
+	/*
+	 * Encryption parameters. Defined only when ARC_FLAG_ENCRYPTED
+	 * is set and the L1 header exists.
+	 */
+	arc_buf_hdr_crypt_t b_crypt_hdr;
+};
+
+typedef struct arc_stats {
+	kstat_named_t arcstat_hits;
+	kstat_named_t arcstat_misses;
+	kstat_named_t arcstat_demand_data_hits;
+	kstat_named_t arcstat_demand_data_misses;
+	kstat_named_t arcstat_demand_metadata_hits;
+	kstat_named_t arcstat_demand_metadata_misses;
+	kstat_named_t arcstat_prefetch_data_hits;
+	kstat_named_t arcstat_prefetch_data_misses;
+	kstat_named_t arcstat_prefetch_metadata_hits;
+	kstat_named_t arcstat_prefetch_metadata_misses;
+	kstat_named_t arcstat_mru_hits;
+	kstat_named_t arcstat_mru_ghost_hits;
+	kstat_named_t arcstat_mfu_hits;
+	kstat_named_t arcstat_mfu_ghost_hits;
+	kstat_named_t arcstat_deleted;
+	/*
+	 * Number of buffers that could not be evicted because the hash lock
+	 * was held by another thread.  The lock may not necessarily be held
+	 * by something using the same buffer, since hash locks are shared
+	 * by multiple buffers.
+	 */
+	kstat_named_t arcstat_mutex_miss;
+	/*
+	 * Number of buffers skipped when updating the access state due to the
+	 * header having already been released after acquiring the hash lock.
+	 */
+	kstat_named_t arcstat_access_skip;
+	/*
+	 * Number of buffers skipped because they have I/O in progress, are
+	 * indirect prefetch buffers that have not lived long enough, or are
+	 * not from the spa we're trying to evict from.
+	 */
+	kstat_named_t arcstat_evict_skip;
+	/*
+	 * Number of times arc_evict_state() was unable to evict enough
+	 * buffers to reach its target amount.
+	 */
+	kstat_named_t arcstat_evict_not_enough;
+	kstat_named_t arcstat_evict_l2_cached;
+	kstat_named_t arcstat_evict_l2_eligible;
+	kstat_named_t arcstat_evict_l2_ineligible;
+	kstat_named_t arcstat_evict_l2_skip;
+	kstat_named_t arcstat_hash_elements;
+	kstat_named_t arcstat_hash_elements_max;
+	kstat_named_t arcstat_hash_collisions;
+	kstat_named_t arcstat_hash_chains;
+	kstat_named_t arcstat_hash_chain_max;
+	kstat_named_t arcstat_p;
+	kstat_named_t arcstat_c;
+	kstat_named_t arcstat_c_min;
+	kstat_named_t arcstat_c_max;
+	/* Not updated directly; only synced in arc_kstat_update. */
+	kstat_named_t arcstat_size;
+	/*
+	 * Number of compressed bytes stored in the arc_buf_hdr_t's b_pabd.
+	 * Note that the compressed bytes may match the uncompressed bytes
+	 * if the block is either not compressed or compressed arc is disabled.
+	 */
+	kstat_named_t arcstat_compressed_size;
+	/*
+	 * Uncompressed size of the data stored in b_pabd. If compressed
+	 * arc is disabled then this value will be identical to the stat
+	 * above.
+	 */
+	kstat_named_t arcstat_uncompressed_size;
+	/*
+	 * Number of bytes stored in all the arc_buf_t's. This is classified
+	 * as "overhead" since this data is typically short-lived and will
+	 * be evicted from the arc when it becomes unreferenced unless the
+	 * zfs_keep_uncompressed_metadata or zfs_keep_uncompressed_level
+	 * values have been set (see comment in dbuf.c for more information).
+	 */
+	kstat_named_t arcstat_overhead_size;
+	/*
+	 * Number of bytes consumed by internal ARC structures necessary
+	 * for tracking purposes; these structures are not actually
+	 * backed by ARC buffers. This includes arc_buf_hdr_t structures
+	 * (allocated via arc_buf_hdr_t_full and arc_buf_hdr_t_l2only
+	 * caches), and arc_buf_t structures (allocated via arc_buf_t
+	 * cache).
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_hdr_size;
+	/*
+	 * Number of bytes consumed by ARC buffers of type equal to
+	 * ARC_BUFC_DATA. This is generally consumed by buffers backing
+	 * on disk user data (e.g. plain file contents).
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_data_size;
+	/*
+	 * Number of bytes consumed by ARC buffers of type equal to
+	 * ARC_BUFC_METADATA. This is generally consumed by buffers
+	 * backing on disk data that is used for internal ZFS
+	 * structures (e.g. ZAP, dnode, indirect blocks, etc).
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_metadata_size;
+	/*
+	 * Number of bytes consumed by dmu_buf_impl_t objects.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_dbuf_size;
+	/*
+	 * Number of bytes consumed by dnode_t objects.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_dnode_size;
+	/*
+	 * Number of bytes consumed by bonus buffers.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_bonus_size;
+#if defined(COMPAT_FREEBSD11)
+	/*
+	 * Sum of the previous three counters, provided for compatibility.
+	 */
+	kstat_named_t arcstat_other_size;
+#endif
+
+	/*
+	 * Total number of bytes consumed by ARC buffers residing in the
+	 * arc_anon state. This includes *all* buffers in the arc_anon
+	 * state; e.g. data, metadata, evictable, and unevictable buffers
+	 * are all included in this value.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_anon_size;
+	/*
+	 * Number of bytes consumed by ARC buffers that meet the
+	 * following criteria: backing buffers of type ARC_BUFC_DATA,
+	 * residing in the arc_anon state, and are eligible for eviction
+	 * (e.g. have no outstanding holds on the buffer).
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_anon_evictable_data;
+	/*
+	 * Number of bytes consumed by ARC buffers that meet the
+	 * following criteria: backing buffers of type ARC_BUFC_METADATA,
+	 * residing in the arc_anon state, and are eligible for eviction
+	 * (e.g. have no outstanding holds on the buffer).
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_anon_evictable_metadata;
+	/*
+	 * Total number of bytes consumed by ARC buffers residing in the
+	 * arc_mru state. This includes *all* buffers in the arc_mru
+	 * state; e.g. data, metadata, evictable, and unevictable buffers
+	 * are all included in this value.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mru_size;
+	/*
+	 * Number of bytes consumed by ARC buffers that meet the
+	 * following criteria: backing buffers of type ARC_BUFC_DATA,
+	 * residing in the arc_mru state, and are eligible for eviction
+	 * (e.g. have no outstanding holds on the buffer).
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mru_evictable_data;
+	/*
+	 * Number of bytes consumed by ARC buffers that meet the
+	 * following criteria: backing buffers of type ARC_BUFC_METADATA,
+	 * residing in the arc_mru state, and are eligible for eviction
+	 * (e.g. have no outstanding holds on the buffer).
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mru_evictable_metadata;
+	/*
+	 * Total number of bytes that *would have been* consumed by ARC
+	 * buffers in the arc_mru_ghost state. The key thing to note
+	 * here, is the fact that this size doesn't actually indicate
+	 * RAM consumption. The ghost lists only consist of headers and
+	 * don't actually have ARC buffers linked off of these headers.
+	 * Thus, *if* the headers had associated ARC buffers, these
+	 * buffers *would have* consumed this number of bytes.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mru_ghost_size;
+	/*
+	 * Number of bytes that *would have been* consumed by ARC
+	 * buffers that are eligible for eviction, of type
+	 * ARC_BUFC_DATA, and linked off the arc_mru_ghost state.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mru_ghost_evictable_data;
+	/*
+	 * Number of bytes that *would have been* consumed by ARC
+	 * buffers that are eligible for eviction, of type
+	 * ARC_BUFC_METADATA, and linked off the arc_mru_ghost state.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mru_ghost_evictable_metadata;
+	/*
+	 * Total number of bytes consumed by ARC buffers residing in the
+	 * arc_mfu state. This includes *all* buffers in the arc_mfu
+	 * state; e.g. data, metadata, evictable, and unevictable buffers
+	 * are all included in this value.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mfu_size;
+	/*
+	 * Number of bytes consumed by ARC buffers that are eligible for
+	 * eviction, of type ARC_BUFC_DATA, and reside in the arc_mfu
+	 * state.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mfu_evictable_data;
+	/*
+	 * Number of bytes consumed by ARC buffers that are eligible for
+	 * eviction, of type ARC_BUFC_METADATA, and reside in the
+	 * arc_mfu state.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mfu_evictable_metadata;
+	/*
+	 * Total number of bytes that *would have been* consumed by ARC
+	 * buffers in the arc_mfu_ghost state. See the comment above
+	 * arcstat_mru_ghost_size for more details.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mfu_ghost_size;
+	/*
+	 * Number of bytes that *would have been* consumed by ARC
+	 * buffers that are eligible for eviction, of type
+	 * ARC_BUFC_DATA, and linked off the arc_mfu_ghost state.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mfu_ghost_evictable_data;
+	/*
+	 * Number of bytes that *would have been* consumed by ARC
+	 * buffers that are eligible for eviction, of type
+	 * ARC_BUFC_METADATA, and linked off the arc_mru_ghost state.
+	 * Not updated directly; only synced in arc_kstat_update.
+	 */
+	kstat_named_t arcstat_mfu_ghost_evictable_metadata;
+	kstat_named_t arcstat_l2_hits;
+	kstat_named_t arcstat_l2_misses;
+	kstat_named_t arcstat_l2_feeds;
+	kstat_named_t arcstat_l2_rw_clash;
+	kstat_named_t arcstat_l2_read_bytes;
+	kstat_named_t arcstat_l2_write_bytes;
+	kstat_named_t arcstat_l2_writes_sent;
+	kstat_named_t arcstat_l2_writes_done;
+	kstat_named_t arcstat_l2_writes_error;
+	kstat_named_t arcstat_l2_writes_lock_retry;
+	kstat_named_t arcstat_l2_evict_lock_retry;
+	kstat_named_t arcstat_l2_evict_reading;
+	kstat_named_t arcstat_l2_evict_l1cached;
+	kstat_named_t arcstat_l2_free_on_write;
+	kstat_named_t arcstat_l2_abort_lowmem;
+	kstat_named_t arcstat_l2_cksum_bad;
+	kstat_named_t arcstat_l2_io_error;
+	kstat_named_t arcstat_l2_lsize;
+	kstat_named_t arcstat_l2_psize;
+	/* Not updated directly; only synced in arc_kstat_update. */
+	kstat_named_t arcstat_l2_hdr_size;
+	/*
+	 * Number of L2ARC log blocks written. These are used for restoring the
+	 * L2ARC. Updated during writing of L2ARC log blocks.
+	 */
+	kstat_named_t arcstat_l2_log_blk_writes;
+	/*
+	 * Moving average of the aligned size of the L2ARC log blocks, in
+	 * bytes. Updated during L2ARC rebuild and during writing of L2ARC
+	 * log blocks.
+	 */
+	kstat_named_t arcstat_l2_log_blk_avg_asize;
+	/* Aligned size of L2ARC log blocks on L2ARC devices. */
+	kstat_named_t arcstat_l2_log_blk_asize;
+	/* Number of L2ARC log blocks present on L2ARC devices. */
+	kstat_named_t arcstat_l2_log_blk_count;
+	/*
+	 * Moving average of the aligned size of L2ARC restored data, in bytes,
+	 * to the aligned size of their metadata in L2ARC, in bytes.
+	 * Updated during L2ARC rebuild and during writing of L2ARC log blocks.
+	 */
+	kstat_named_t arcstat_l2_data_to_meta_ratio;
+	/*
+	 * Number of times the L2ARC rebuild was successful for an L2ARC device.
+	 */
+	kstat_named_t arcstat_l2_rebuild_success;
+	/*
+	 * Number of times the L2ARC rebuild failed because the device header
+	 * was in an unsupported format or corrupted.
+	 */
+	kstat_named_t arcstat_l2_rebuild_abort_unsupported;
+	/*
+	 * Number of times the L2ARC rebuild failed because of IO errors
+	 * while reading a log block.
+	 */
+	kstat_named_t arcstat_l2_rebuild_abort_io_errors;
+	/*
+	 * Number of times the L2ARC rebuild failed because of IO errors when
+	 * reading the device header.
+	 */
+	kstat_named_t arcstat_l2_rebuild_abort_dh_errors;
+	/*
+	 * Number of L2ARC log blocks which failed to be restored due to
+	 * checksum errors.
+	 */
+	kstat_named_t arcstat_l2_rebuild_abort_cksum_lb_errors;
+	/*
+	 * Number of times the L2ARC rebuild was aborted due to low system
+	 * memory.
+	 */
+	kstat_named_t arcstat_l2_rebuild_abort_lowmem;
+	/* Logical size of L2ARC restored data, in bytes. */
+	kstat_named_t arcstat_l2_rebuild_size;
+	/* Aligned size of L2ARC restored data, in bytes. */
+	kstat_named_t arcstat_l2_rebuild_asize;
+	/*
+	 * Number of L2ARC log entries (buffers) that were successfully
+	 * restored in ARC.
+	 */
+	kstat_named_t arcstat_l2_rebuild_bufs;
+	/*
+	 * Number of L2ARC log entries (buffers) already cached in ARC. These
+	 * were not restored again.
+	 */
+	kstat_named_t arcstat_l2_rebuild_bufs_precached;
+	/*
+	 * Number of L2ARC log blocks that were restored successfully. Each
+	 * log block may hold up to L2ARC_LOG_BLK_MAX_ENTRIES buffers.
+	 */
+	kstat_named_t arcstat_l2_rebuild_log_blks;
+	kstat_named_t arcstat_memory_throttle_count;
+	kstat_named_t arcstat_memory_direct_count;
+	kstat_named_t arcstat_memory_indirect_count;
+	kstat_named_t arcstat_memory_all_bytes;
+	kstat_named_t arcstat_memory_free_bytes;
+	kstat_named_t arcstat_memory_available_bytes;
+	kstat_named_t arcstat_no_grow;
+	kstat_named_t arcstat_tempreserve;
+	kstat_named_t arcstat_loaned_bytes;
+	kstat_named_t arcstat_prune;
+	/* Not updated directly; only synced in arc_kstat_update. */
+	kstat_named_t arcstat_meta_used;
+	kstat_named_t arcstat_meta_limit;
+	kstat_named_t arcstat_dnode_limit;
+	kstat_named_t arcstat_meta_max;
+	kstat_named_t arcstat_meta_min;
+	kstat_named_t arcstat_async_upgrade_sync;
+	kstat_named_t arcstat_demand_hit_predictive_prefetch;
+	kstat_named_t arcstat_demand_hit_prescient_prefetch;
+	kstat_named_t arcstat_need_free;
+	kstat_named_t arcstat_sys_free;
+	kstat_named_t arcstat_raw_size;
+	kstat_named_t arcstat_cached_only_in_progress;
+	kstat_named_t arcstat_abd_chunk_waste_size;
+} arc_stats_t;
+
+typedef struct arc_evict_waiter {
+	list_node_t aew_node;
+	kcondvar_t aew_cv;
+	uint64_t aew_count;
+} arc_evict_waiter_t;
+
+#define	ARCSTAT(stat)	(arc_stats.stat.value.ui64)
+
+#define	ARCSTAT_INCR(stat, val) \
+	atomic_add_64(&arc_stats.stat.value.ui64, (val))
+
+#define	ARCSTAT_BUMP(stat)	ARCSTAT_INCR(stat, 1)
+#define	ARCSTAT_BUMPDOWN(stat)	ARCSTAT_INCR(stat, -1)
+
+#define	arc_no_grow	ARCSTAT(arcstat_no_grow) /* do not grow cache size */
+#define	arc_p		ARCSTAT(arcstat_p)	/* target size of MRU */
+#define	arc_c		ARCSTAT(arcstat_c)	/* target size of cache */
+#define	arc_c_min	ARCSTAT(arcstat_c_min)	/* min target cache size */
+#define	arc_c_max	ARCSTAT(arcstat_c_max)	/* max target cache size */
+#define	arc_sys_free	ARCSTAT(arcstat_sys_free) /* target system free bytes */
+
+extern taskq_t *arc_prune_taskq;
+extern arc_stats_t arc_stats;
+extern hrtime_t arc_growtime;
+extern boolean_t arc_warm;
+extern int arc_grow_retry;
+extern int arc_no_grow_shift;
+extern int arc_shrink_shift;
+extern kmutex_t arc_prune_mtx;
+extern list_t arc_prune_list;
+extern aggsum_t arc_size;
+extern arc_state_t	*arc_mfu;
+extern arc_state_t	*arc_mru;
+extern uint_t zfs_arc_pc_percent;
+extern int arc_lotsfree_percent;
+extern unsigned long zfs_arc_min;
+extern unsigned long zfs_arc_max;
+
+extern void arc_reduce_target_size(int64_t to_free);
+extern boolean_t arc_reclaim_needed(void);
+extern void arc_kmem_reap_soon(void);
+extern boolean_t arc_is_overflowing(void);
+extern void arc_wait_for_eviction(uint64_t);
+
+extern void arc_lowmem_init(void);
+extern void arc_lowmem_fini(void);
+extern void arc_prune_async(int64_t);
+extern int arc_memory_throttle(spa_t *spa, uint64_t reserve, uint64_t txg);
+extern uint64_t arc_free_memory(void);
+extern int64_t arc_available_memory(void);
+extern void arc_tuning_update(boolean_t);
+
+extern int param_set_arc_long(ZFS_MODULE_PARAM_ARGS);
+extern int param_set_arc_int(ZFS_MODULE_PARAM_ARGS);
+
+/* used in zdb.c */
+boolean_t l2arc_log_blkptr_valid(l2arc_dev_t *dev,
+    const l2arc_log_blkptr_t *lbp);
+
+/* used in vdev_trim.c */
+void l2arc_dev_hdr_update(l2arc_dev_t *dev);
+l2arc_dev_t *l2arc_vdev_get(vdev_t *vd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_ARC_IMPL_H */
diff --git a/include/sys/avl.h b/include/sys/avl.h
new file mode 100644
index 0000000000000..ed3c6f86a5683
--- /dev/null
+++ b/include/sys/avl.h
@@ -0,0 +1,325 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2014 by Delphix. All rights reserved.
+ */
+
+#ifndef	_AVL_H
+#define	_AVL_H
+
+/*
+ * This is a private header file.  Applications should not directly include
+ * this file.
+ */
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+#include <sys/avl_impl.h>
+
+/*
+ * This is a generic implementation of AVL trees for use in the Solaris kernel.
+ * The interfaces provide an efficient way of implementing an ordered set of
+ * data structures.
+ *
+ * AVL trees provide an alternative to using an ordered linked list. Using AVL
+ * trees will usually be faster, however they requires more storage. An ordered
+ * linked list in general requires 2 pointers in each data structure. The
+ * AVL tree implementation uses 3 pointers. The following chart gives the
+ * approximate performance of operations with the different approaches:
+ *
+ *	Operation	 Link List	AVL tree
+ *	---------	 --------	--------
+ *	lookup		   O(n)		O(log(n))
+ *
+ *	insert 1 node	 constant	constant
+ *
+ *	delete 1 node	 constant	between constant and O(log(n))
+ *
+ *	delete all nodes   O(n)		O(n)
+ *
+ *	visit the next
+ *	or prev node	 constant	between constant and O(log(n))
+ *
+ *
+ * The data structure nodes are anchored at an "avl_tree_t" (the equivalent
+ * of a list header) and the individual nodes will have a field of
+ * type "avl_node_t" (corresponding to list pointers).
+ *
+ * The type "avl_index_t" is used to indicate a position in the list for
+ * certain calls.
+ *
+ * The usage scenario is generally:
+ *
+ * 1. Create the list/tree with: avl_create()
+ *
+ * followed by any mixture of:
+ *
+ * 2a. Insert nodes with: avl_add(), or avl_find() and avl_insert()
+ *
+ * 2b. Visited elements with:
+ *	 avl_first() - returns the lowest valued node
+ *	 avl_last() - returns the highest valued node
+ *	 AVL_NEXT() - given a node go to next higher one
+ *	 AVL_PREV() - given a node go to previous lower one
+ *
+ * 2c.  Find the node with the closest value either less than or greater
+ *	than a given value with avl_nearest().
+ *
+ * 2d. Remove individual nodes from the list/tree with avl_remove().
+ *
+ * and finally when the list is being destroyed
+ *
+ * 3. Use avl_destroy_nodes() to quickly process/free up any remaining nodes.
+ *    Note that once you use avl_destroy_nodes(), you can no longer
+ *    use any routine except avl_destroy_nodes() and avl_destroy().
+ *
+ * 4. Use avl_destroy() to destroy the AVL tree itself.
+ *
+ * Any locking for multiple thread access is up to the user to provide, just
+ * as is needed for any linked list implementation.
+ */
+
+/*
+ * AVL comparator helpers
+ */
+#define	TREE_ISIGN(a)	(((a) > 0) - ((a) < 0))
+#define	TREE_CMP(a, b)	(((a) > (b)) - ((a) < (b)))
+#define	TREE_PCMP(a, b)	\
+	(((uintptr_t)(a) > (uintptr_t)(b)) - ((uintptr_t)(a) < (uintptr_t)(b)))
+
+/*
+ * Type used for the root of the AVL tree.
+ */
+typedef struct avl_tree avl_tree_t;
+
+/*
+ * The data nodes in the AVL tree must have a field of this type.
+ */
+typedef struct avl_node avl_node_t;
+
+/*
+ * An opaque type used to locate a position in the tree where a node
+ * would be inserted.
+ */
+typedef uintptr_t avl_index_t;
+
+
+/*
+ * Direction constants used for avl_nearest().
+ */
+#define	AVL_BEFORE	(0)
+#define	AVL_AFTER	(1)
+
+
+/*
+ * Prototypes
+ *
+ * Where not otherwise mentioned, "void *" arguments are a pointer to the
+ * user data structure which must contain a field of type avl_node_t.
+ *
+ * Also assume the user data structures looks like:
+ *	struct my_type {
+ *		...
+ *		avl_node_t	my_link;
+ *		...
+ *	};
+ */
+
+/*
+ * Initialize an AVL tree. Arguments are:
+ *
+ * tree   - the tree to be initialized
+ * compar - function to compare two nodes, it must return exactly: -1, 0, or +1
+ *          -1 for <, 0 for ==, and +1 for >
+ * size   - the value of sizeof(struct my_type)
+ * offset - the value of OFFSETOF(struct my_type, my_link)
+ */
+extern void avl_create(avl_tree_t *tree,
+	int (*compar) (const void *, const void *), size_t size, size_t offset);
+
+
+/*
+ * Find a node with a matching value in the tree. Returns the matching node
+ * found. If not found, it returns NULL and then if "where" is not NULL it sets
+ * "where" for use with avl_insert() or avl_nearest().
+ *
+ * node   - node that has the value being looked for
+ * where  - position for use with avl_nearest() or avl_insert(), may be NULL
+ */
+extern void *avl_find(avl_tree_t *tree, const void *node, avl_index_t *where);
+
+/*
+ * Insert a node into the tree.
+ *
+ * node   - the node to insert
+ * where  - position as returned from avl_find()
+ */
+extern void avl_insert(avl_tree_t *tree, void *node, avl_index_t where);
+
+/*
+ * Insert "new_data" in "tree" in the given "direction" either after
+ * or before the data "here".
+ *
+ * This might be useful for avl clients caching recently accessed
+ * data to avoid doing avl_find() again for insertion.
+ *
+ * new_data	- new data to insert
+ * here		- existing node in "tree"
+ * direction	- either AVL_AFTER or AVL_BEFORE the data "here".
+ */
+extern void avl_insert_here(avl_tree_t *tree, void *new_data, void *here,
+    int direction);
+
+
+/*
+ * Return the first or last valued node in the tree. Will return NULL
+ * if the tree is empty.
+ *
+ */
+extern void *avl_first(avl_tree_t *tree);
+extern void *avl_last(avl_tree_t *tree);
+
+
+/*
+ * Return the next or previous valued node in the tree.
+ * AVL_NEXT() will return NULL if at the last node.
+ * AVL_PREV() will return NULL if at the first node.
+ *
+ * node   - the node from which the next or previous node is found
+ */
+#define	AVL_NEXT(tree, node)	avl_walk(tree, node, AVL_AFTER)
+#define	AVL_PREV(tree, node)	avl_walk(tree, node, AVL_BEFORE)
+
+
+/*
+ * Find the node with the nearest value either greater or less than
+ * the value from a previous avl_find(). Returns the node or NULL if
+ * there isn't a matching one.
+ *
+ * where     - position as returned from avl_find()
+ * direction - either AVL_BEFORE or AVL_AFTER
+ *
+ * EXAMPLE get the greatest node that is less than a given value:
+ *
+ *	avl_tree_t *tree;
+ *	struct my_data look_for_value = {....};
+ *	struct my_data *node;
+ *	struct my_data *less;
+ *	avl_index_t where;
+ *
+ *	node = avl_find(tree, &look_for_value, &where);
+ *	if (node != NULL)
+ *		less = AVL_PREV(tree, node);
+ *	else
+ *		less = avl_nearest(tree, where, AVL_BEFORE);
+ */
+extern void *avl_nearest(avl_tree_t *tree, avl_index_t where, int direction);
+
+
+/*
+ * Add a single node to the tree.
+ * The node must not be in the tree, and it must not
+ * compare equal to any other node already in the tree.
+ *
+ * node   - the node to add
+ */
+extern void avl_add(avl_tree_t *tree, void *node);
+
+
+/*
+ * Remove a single node from the tree.  The node must be in the tree.
+ *
+ * node   - the node to remove
+ */
+extern void avl_remove(avl_tree_t *tree, void *node);
+
+/*
+ * Reinsert a node only if its order has changed relative to its nearest
+ * neighbors. To optimize performance avl_update_lt() checks only the previous
+ * node and avl_update_gt() checks only the next node. Use avl_update_lt() and
+ * avl_update_gt() only if you know the direction in which the order of the
+ * node may change.
+ */
+extern boolean_t avl_update(avl_tree_t *, void *);
+extern boolean_t avl_update_lt(avl_tree_t *, void *);
+extern boolean_t avl_update_gt(avl_tree_t *, void *);
+
+/*
+ * Swaps the contents of the two trees.
+ */
+extern void avl_swap(avl_tree_t *tree1, avl_tree_t *tree2);
+
+/*
+ * Return the number of nodes in the tree
+ */
+extern ulong_t avl_numnodes(avl_tree_t *tree);
+
+/*
+ * Return B_TRUE if there are zero nodes in the tree, B_FALSE otherwise.
+ */
+extern boolean_t avl_is_empty(avl_tree_t *tree);
+
+/*
+ * Used to destroy any remaining nodes in a tree. The cookie argument should
+ * be initialized to NULL before the first call. Returns a node that has been
+ * removed from the tree and may be free()'d. Returns NULL when the tree is
+ * empty.
+ *
+ * Once you call avl_destroy_nodes(), you can only continuing calling it and
+ * finally avl_destroy(). No other AVL routines will be valid.
+ *
+ * cookie - a "void *" used to save state between calls to avl_destroy_nodes()
+ *
+ * EXAMPLE:
+ *	avl_tree_t *tree;
+ *	struct my_data *node;
+ *	void *cookie;
+ *
+ *	cookie = NULL;
+ *	while ((node = avl_destroy_nodes(tree, &cookie)) != NULL)
+ *		free(node);
+ *	avl_destroy(tree);
+ */
+extern void *avl_destroy_nodes(avl_tree_t *tree, void **cookie);
+
+
+/*
+ * Final destroy of an AVL tree. Arguments are:
+ *
+ * tree   - the empty tree to destroy
+ */
+extern void avl_destroy(avl_tree_t *tree);
+
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _AVL_H */
diff --git a/include/sys/avl_impl.h b/include/sys/avl_impl.h
new file mode 100644
index 0000000000000..fddf76906deeb
--- /dev/null
+++ b/include/sys/avl_impl.h
@@ -0,0 +1,164 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2004 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_AVL_IMPL_H
+#define	_AVL_IMPL_H
+
+
+
+/*
+ * This is a private header file.  Applications should not directly include
+ * this file.
+ */
+
+#include <sys/types.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * generic AVL tree implementation for kernel use
+ *
+ * There are 5 pieces of information stored for each node in an AVL tree
+ *
+ * 	pointer to less than child
+ * 	pointer to greater than child
+ * 	a pointer to the parent of this node
+ *	an indication  [0/1]  of which child I am of my parent
+ * 	a "balance" (-1, 0, +1)  indicating which child tree is taller
+ *
+ * Since they only need 3 bits, the last two fields are packed into the
+ * bottom bits of the parent pointer on 64 bit machines to save on space.
+ */
+
+#ifndef _LP64
+
+struct avl_node {
+	struct avl_node *avl_child[2];	/* left/right children */
+	struct avl_node *avl_parent;	/* this node's parent */
+	unsigned short avl_child_index;	/* my index in parent's avl_child[] */
+	short avl_balance;		/* balance value: -1, 0, +1 */
+};
+
+#define	AVL_XPARENT(n)		((n)->avl_parent)
+#define	AVL_SETPARENT(n, p)	((n)->avl_parent = (p))
+
+#define	AVL_XCHILD(n)		((n)->avl_child_index)
+#define	AVL_SETCHILD(n, c)	((n)->avl_child_index = (unsigned short)(c))
+
+#define	AVL_XBALANCE(n)		((n)->avl_balance)
+#define	AVL_SETBALANCE(n, b)	((n)->avl_balance = (short)(b))
+
+#else /* _LP64 */
+
+/*
+ * for 64 bit machines, avl_pcb contains parent pointer, balance and child_index
+ * values packed in the following manner:
+ *
+ * |63                                  3|        2        |1          0 |
+ * |-------------------------------------|-----------------|-------------|
+ * |      avl_parent hi order bits       | avl_child_index | avl_balance |
+ * |                                     |                 |     + 1     |
+ * |-------------------------------------|-----------------|-------------|
+ *
+ */
+struct avl_node {
+	struct avl_node *avl_child[2];	/* left/right children nodes */
+	uintptr_t avl_pcb;		/* parent, child_index, balance */
+};
+
+/*
+ * macros to extract/set fields in avl_pcb
+ *
+ * pointer to the parent of the current node is the high order bits
+ */
+#define	AVL_XPARENT(n)		((struct avl_node *)((n)->avl_pcb & ~7))
+#define	AVL_SETPARENT(n, p)						\
+	((n)->avl_pcb = (((n)->avl_pcb & 7) | (uintptr_t)(p)))
+
+/*
+ * index of this node in its parent's avl_child[]: bit #2
+ */
+#define	AVL_XCHILD(n)		(((n)->avl_pcb >> 2) & 1)
+#define	AVL_SETCHILD(n, c)						\
+	((n)->avl_pcb = (uintptr_t)(((n)->avl_pcb & ~4) | ((c) << 2)))
+
+/*
+ * balance indication for a node, lowest 2 bits. A valid balance is
+ * -1, 0, or +1, and is encoded by adding 1 to the value to get the
+ * unsigned values of 0, 1, 2.
+ */
+#define	AVL_XBALANCE(n)		((int)(((n)->avl_pcb & 3) - 1))
+#define	AVL_SETBALANCE(n, b)						\
+	((n)->avl_pcb = (uintptr_t)((((n)->avl_pcb & ~3) | ((b) + 1))))
+
+#endif /* _LP64 */
+
+
+
+/*
+ * switch between a node and data pointer for a given tree
+ * the value of "o" is tree->avl_offset
+ */
+#define	AVL_NODE2DATA(n, o)	((void *)((uintptr_t)(n) - (o)))
+#define	AVL_DATA2NODE(d, o)	((struct avl_node *)((uintptr_t)(d) + (o)))
+
+
+
+/*
+ * macros used to create/access an avl_index_t
+ */
+#define	AVL_INDEX2NODE(x)	((avl_node_t *)((x) & ~1))
+#define	AVL_INDEX2CHILD(x)	((x) & 1)
+#define	AVL_MKINDEX(n, c)	((avl_index_t)(n) | (c))
+
+
+/*
+ * The tree structure. The fields avl_root, avl_compar, and avl_offset come
+ * first since they are needed for avl_find().  We want them to fit into
+ * a single 64 byte cache line to make avl_find() as fast as possible.
+ */
+struct avl_tree {
+	struct avl_node *avl_root;	/* root node in tree */
+	int (*avl_compar)(const void *, const void *);
+	size_t avl_offset;		/* offsetof(type, avl_link_t field) */
+	ulong_t avl_numnodes;		/* number of nodes in the tree */
+	size_t avl_size;		/* sizeof user type struct */
+};
+
+
+/*
+ * This will only by used via AVL_NEXT() or AVL_PREV()
+ */
+extern void *avl_walk(struct avl_tree *, void *, int);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _AVL_IMPL_H */
diff --git a/include/sys/bitops.h b/include/sys/bitops.h
new file mode 100644
index 0000000000000..56d52073bcc81
--- /dev/null
+++ b/include/sys/bitops.h
@@ -0,0 +1,90 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2019 by Delphix. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ * Copyright 2013 Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2014 Integros [integros.com]
+ * Copyright 2017 Joyent, Inc.
+ * Copyright (c) 2017 Datto Inc.
+ */
+
+#ifndef _SYS_BITOPS_H
+#define	_SYS_BITOPS_H
+
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * General-purpose 32-bit and 64-bit bitfield encodings.
+ */
+#define	BF32_DECODE(x, low, len)	P2PHASE((x) >> (low), 1U << (len))
+#define	BF64_DECODE(x, low, len)	P2PHASE((x) >> (low), 1ULL << (len))
+#define	BF32_ENCODE(x, low, len)	(P2PHASE((x), 1U << (len)) << (low))
+#define	BF64_ENCODE(x, low, len)	(P2PHASE((x), 1ULL << (len)) << (low))
+
+#define	BF32_GET(x, low, len)		BF32_DECODE(x, low, len)
+#define	BF64_GET(x, low, len)		BF64_DECODE(x, low, len)
+
+#define	BF32_SET(x, low, len, val) do { \
+	ASSERT3U(val, <, 1U << (len)); \
+	ASSERT3U(low + len, <=, 32); \
+	(x) ^= BF32_ENCODE((x >> low) ^ (val), low, len); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	BF64_SET(x, low, len, val) do { \
+	ASSERT3U(val, <, 1ULL << (len)); \
+	ASSERT3U(low + len, <=, 64); \
+	((x) ^= BF64_ENCODE((x >> low) ^ (val), low, len)); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	BF32_GET_SB(x, low, len, shift, bias)	\
+	((BF32_GET(x, low, len) + (bias)) << (shift))
+#define	BF64_GET_SB(x, low, len, shift, bias)	\
+	((BF64_GET(x, low, len) + (bias)) << (shift))
+
+/*
+ * We use ASSERT3U instead of ASSERT in these macros to prevent a lint error in
+ * the case where val is a constant.  We can't fix ASSERT because it's used as
+ * an expression in several places in the kernel; as a result, changing it to
+ * the do{} while() syntax to allow us to _NOTE the CONSTCOND is not an option.
+ */
+#define	BF32_SET_SB(x, low, len, shift, bias, val) do { \
+	ASSERT3U(IS_P2ALIGNED(val, 1U << shift), !=, B_FALSE); \
+	ASSERT3S((val) >> (shift), >=, bias); \
+	BF32_SET(x, low, len, ((val) >> (shift)) - (bias)); \
+_NOTE(CONSTCOND) } while (0)
+#define	BF64_SET_SB(x, low, len, shift, bias, val) do { \
+	ASSERT3U(IS_P2ALIGNED(val, 1ULL << shift), !=, B_FALSE); \
+	ASSERT3S((val) >> (shift), >=, bias); \
+	BF64_SET(x, low, len, ((val) >> (shift)) - (bias)); \
+_NOTE(CONSTCOND) } while (0)
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_BITOPS_H */
diff --git a/include/sys/blkptr.h b/include/sys/blkptr.h
new file mode 100644
index 0000000000000..77b1b827ac375
--- /dev/null
+++ b/include/sys/blkptr.h
@@ -0,0 +1,39 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2013 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_BLKPTR_H
+#define	_SYS_BLKPTR_H
+
+#include <sys/spa.h>
+#include <sys/zio.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+void encode_embedded_bp_compressed(blkptr_t *, void *,
+    enum zio_compress, int, int);
+void decode_embedded_bp_compressed(const blkptr_t *, void *);
+int decode_embedded_bp(const blkptr_t *, void *, int);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_BLKPTR_H */
diff --git a/include/sys/bplist.h b/include/sys/bplist.h
new file mode 100644
index 0000000000000..f8deaf8437e64
--- /dev/null
+++ b/include/sys/bplist.h
@@ -0,0 +1,59 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_BPLIST_H
+#define	_SYS_BPLIST_H
+
+#include <sys/zfs_context.h>
+#include <sys/spa.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct bplist_entry {
+	blkptr_t	bpe_blk;
+	list_node_t	bpe_node;
+} bplist_entry_t;
+
+typedef struct bplist {
+	kmutex_t	bpl_lock;
+	list_t		bpl_list;
+} bplist_t;
+
+typedef int bplist_itor_t(void *arg, const blkptr_t *bp, dmu_tx_t *tx);
+
+void bplist_create(bplist_t *bpl);
+void bplist_destroy(bplist_t *bpl);
+void bplist_append(bplist_t *bpl, const blkptr_t *bp);
+void bplist_iterate(bplist_t *bpl, bplist_itor_t *func,
+    void *arg, dmu_tx_t *tx);
+void bplist_clear(bplist_t *bpl);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_BPLIST_H */
diff --git a/include/sys/bpobj.h b/include/sys/bpobj.h
new file mode 100644
index 0000000000000..16e403526cff1
--- /dev/null
+++ b/include/sys/bpobj.h
@@ -0,0 +1,106 @@
+/*
+ * 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) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_BPOBJ_H
+#define	_SYS_BPOBJ_H
+
+#include <sys/dmu.h>
+#include <sys/spa.h>
+#include <sys/txg.h>
+#include <sys/zio.h>
+#include <sys/zfs_context.h>
+#include <sys/bplist.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct bpobj_phys {
+	/*
+	 * This is the bonus buffer for the dead lists.  The object's
+	 * contents is an array of bpo_entries blkptr_t's, representing
+	 * a total of bpo_bytes physical space.
+	 */
+	uint64_t	bpo_num_blkptrs;
+	uint64_t	bpo_bytes;
+	uint64_t	bpo_comp;
+	uint64_t	bpo_uncomp;
+	uint64_t	bpo_subobjs;
+	uint64_t	bpo_num_subobjs;
+	uint64_t	bpo_num_freed;
+} bpobj_phys_t;
+
+#define	BPOBJ_SIZE_V0	(2 * sizeof (uint64_t))
+#define	BPOBJ_SIZE_V1	(4 * sizeof (uint64_t))
+#define	BPOBJ_SIZE_V2	(6 * sizeof (uint64_t))
+
+typedef struct bpobj {
+	kmutex_t	bpo_lock;
+	objset_t	*bpo_os;
+	uint64_t	bpo_object;
+	int		bpo_epb;
+	uint8_t		bpo_havecomp;
+	uint8_t		bpo_havesubobj;
+	uint8_t		bpo_havefreed;
+	bpobj_phys_t	*bpo_phys;
+	dmu_buf_t	*bpo_dbuf;
+	dmu_buf_t	*bpo_cached_dbuf;
+} bpobj_t;
+
+typedef int bpobj_itor_t(void *arg, const blkptr_t *bp, boolean_t bp_freed,
+    dmu_tx_t *tx);
+
+uint64_t bpobj_alloc(objset_t *mos, int blocksize, dmu_tx_t *tx);
+uint64_t bpobj_alloc_empty(objset_t *os, int blocksize, dmu_tx_t *tx);
+void bpobj_free(objset_t *os, uint64_t obj, dmu_tx_t *tx);
+void bpobj_decr_empty(objset_t *os, dmu_tx_t *tx);
+
+int bpobj_open(bpobj_t *bpo, objset_t *mos, uint64_t object);
+void bpobj_close(bpobj_t *bpo);
+boolean_t bpobj_is_open(const bpobj_t *bpo);
+
+int bpobj_iterate(bpobj_t *bpo, bpobj_itor_t func, void *arg, dmu_tx_t *tx);
+int bpobj_iterate_nofree(bpobj_t *bpo, bpobj_itor_t func, void *, uint64_t *);
+int livelist_bpobj_iterate_from_nofree(bpobj_t *bpo, bpobj_itor_t func,
+    void *arg, int64_t start);
+
+void bpobj_enqueue_subobj(bpobj_t *bpo, uint64_t subobj, dmu_tx_t *tx);
+void bpobj_enqueue(bpobj_t *bpo, const blkptr_t *bp, boolean_t bp_freed,
+    dmu_tx_t *tx);
+
+int bpobj_space(bpobj_t *bpo,
+    uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
+int bpobj_space_range(bpobj_t *bpo, uint64_t mintxg, uint64_t maxtxg,
+    uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
+boolean_t bpobj_is_empty(bpobj_t *bpo);
+
+int bplist_append_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed,
+    dmu_tx_t *tx);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_BPOBJ_H */
diff --git a/include/sys/bptree.h b/include/sys/bptree.h
new file mode 100644
index 0000000000000..327c128bf493c
--- /dev/null
+++ b/include/sys/bptree.h
@@ -0,0 +1,65 @@
+/*
+ * 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) 2012, 2014 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_BPTREE_H
+#define	_SYS_BPTREE_H
+
+#include <sys/spa.h>
+#include <sys/zio.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct bptree_phys {
+	uint64_t bt_begin;
+	uint64_t bt_end;
+	uint64_t bt_bytes;
+	uint64_t bt_comp;
+	uint64_t bt_uncomp;
+} bptree_phys_t;
+
+typedef struct bptree_entry_phys {
+	blkptr_t be_bp;
+	uint64_t be_birth_txg; /* only delete blocks born after this txg */
+	zbookmark_phys_t be_zb; /* holds traversal resume point if needed */
+} bptree_entry_phys_t;
+
+typedef int bptree_itor_t(void *arg, const blkptr_t *bp, dmu_tx_t *tx);
+
+uint64_t bptree_alloc(objset_t *os, dmu_tx_t *tx);
+int bptree_free(objset_t *os, uint64_t obj, dmu_tx_t *tx);
+boolean_t bptree_is_empty(objset_t *os, uint64_t obj);
+
+void bptree_add(objset_t *os, uint64_t obj, blkptr_t *bp, uint64_t birth_txg,
+    uint64_t bytes, uint64_t comp, uint64_t uncomp, dmu_tx_t *tx);
+
+int bptree_iterate(objset_t *os, uint64_t obj, boolean_t free,
+    bptree_itor_t func, void *arg, dmu_tx_t *tx);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_BPTREE_H */
diff --git a/include/sys/bqueue.h b/include/sys/bqueue.h
new file mode 100644
index 0000000000000..797aecd791a3d
--- /dev/null
+++ b/include/sys/bqueue.h
@@ -0,0 +1,56 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (c) 2014, 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef	_BQUEUE_H
+#define	_BQUEUE_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include	<sys/zfs_context.h>
+
+typedef struct bqueue {
+	list_t bq_list;
+	kmutex_t bq_lock;
+	kcondvar_t bq_add_cv;
+	kcondvar_t bq_pop_cv;
+	uint64_t bq_size;
+	uint64_t bq_maxsize;
+	uint64_t bq_fill_fraction;
+	size_t bq_node_offset;
+} bqueue_t;
+
+typedef struct bqueue_node {
+	list_node_t bqn_node;
+	uint64_t bqn_size;
+} bqueue_node_t;
+
+
+int bqueue_init(bqueue_t *, uint64_t, uint64_t, size_t);
+void bqueue_destroy(bqueue_t *);
+void bqueue_enqueue(bqueue_t *, void *, uint64_t);
+void bqueue_enqueue_flush(bqueue_t *, void *, uint64_t);
+void *bqueue_dequeue(bqueue_t *);
+boolean_t bqueue_empty(bqueue_t *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _BQUEUE_H */
diff --git a/include/sys/btree.h b/include/sys/btree.h
new file mode 100644
index 0000000000000..3b53476c7c68a
--- /dev/null
+++ b/include/sys/btree.h
@@ -0,0 +1,243 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (c) 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef	_BTREE_H
+#define	_BTREE_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include	<sys/zfs_context.h>
+
+/*
+ * This file defines the interface for a B-Tree implementation for ZFS. The
+ * tree can be used to store arbitrary sortable data types with low overhead
+ * and good operation performance. In addition the tree intelligently
+ * optimizes bulk in-order insertions to improve memory use and performance.
+ *
+ * Note that for all B-Tree functions, the values returned are pointers to the
+ * internal copies of the data in the tree. The internal data can only be
+ * safely mutated if the changes cannot change the ordering of the element
+ * with respect to any other elements in the tree.
+ *
+ * The major drawback of the B-Tree is that any returned elements or indexes
+ * are only valid until a side-effectful operation occurs, since these can
+ * result in reallocation or relocation of data. Side effectful operations are
+ * defined as insertion, removal, and zfs_btree_destroy_nodes.
+ *
+ * The B-Tree has two types of nodes: core nodes, and leaf nodes. Core
+ * nodes have an array of children pointing to other nodes, and an array of
+ * elements that act as separators between the elements of the subtrees rooted
+ * at its children. Leaf nodes only contain data elements, and form the bottom
+ * layer of the tree. Unlike B+ Trees, in this B-Tree implementation the
+ * elements in the core nodes are not copies of or references to leaf node
+ * elements.  Each element occurs only once in the tree, no matter what kind
+ * of node it is in.
+ *
+ * The tree's height is the same throughout, unlike many other forms of search
+ * tree. Each node (except for the root) must be between half minus one and
+ * completely full of elements (and children) at all times. Any operation that
+ * would put the node outside of that range results in a rebalancing operation
+ * (taking, merging, or splitting).
+ *
+ * This tree was implemented using descriptions from Wikipedia's articles on
+ * B-Trees and B+ Trees.
+ */
+
+/*
+ * Decreasing these values results in smaller memmove operations, but more of
+ * them, and increased memory overhead. Increasing these values results in
+ * higher variance in operation time, and reduces memory overhead.
+ */
+#define	BTREE_CORE_ELEMS	128
+#define	BTREE_LEAF_SIZE		4096
+
+extern kmem_cache_t *zfs_btree_leaf_cache;
+
+typedef struct zfs_btree_hdr {
+	struct zfs_btree_core	*bth_parent;
+	boolean_t		bth_core;
+	/*
+	 * For both leaf and core nodes, represents the number of elements in
+	 * the node. For core nodes, they will have bth_count + 1 children.
+	 */
+	uint32_t		bth_count;
+} zfs_btree_hdr_t;
+
+typedef struct zfs_btree_core {
+	zfs_btree_hdr_t	btc_hdr;
+	zfs_btree_hdr_t	*btc_children[BTREE_CORE_ELEMS + 1];
+	uint8_t		btc_elems[];
+} zfs_btree_core_t;
+
+typedef struct zfs_btree_leaf {
+	zfs_btree_hdr_t	btl_hdr;
+	uint8_t		btl_elems[];
+} zfs_btree_leaf_t;
+
+typedef struct zfs_btree_index {
+	zfs_btree_hdr_t	*bti_node;
+	uint64_t	bti_offset;
+	/*
+	 * True if the location is before the list offset, false if it's at
+	 * the listed offset.
+	 */
+	boolean_t	bti_before;
+} zfs_btree_index_t;
+
+typedef struct btree {
+	zfs_btree_hdr_t		*bt_root;
+	int64_t			bt_height;
+	size_t			bt_elem_size;
+	uint64_t		bt_num_elems;
+	uint64_t		bt_num_nodes;
+	zfs_btree_leaf_t	*bt_bulk; // non-null if bulk loading
+	int (*bt_compar) (const void *, const void *);
+} zfs_btree_t;
+
+/*
+ * Allocate and deallocate caches for btree nodes.
+ */
+void zfs_btree_init(void);
+void zfs_btree_fini(void);
+
+/*
+ * Initialize an B-Tree. Arguments are:
+ *
+ * tree   - the tree to be initialized
+ * compar - function to compare two nodes, it must return exactly: -1, 0, or +1
+ *          -1 for <, 0 for ==, and +1 for >
+ * size   - the value of sizeof(struct my_type)
+ */
+void zfs_btree_create(zfs_btree_t *, int (*) (const void *, const void *),
+    size_t);
+
+/*
+ * Find a node with a matching value in the tree. Returns the matching node
+ * found. If not found, it returns NULL and then if "where" is not NULL it sets
+ * "where" for use with zfs_btree_add_idx() or zfs_btree_nearest().
+ *
+ * node   - node that has the value being looked for
+ * where  - position for use with zfs_btree_nearest() or zfs_btree_add_idx(),
+ *          may be NULL
+ */
+void *zfs_btree_find(zfs_btree_t *, const void *, zfs_btree_index_t *);
+
+/*
+ * Insert a node into the tree.
+ *
+ * node   - the node to insert
+ * where  - position as returned from zfs_btree_find()
+ */
+void zfs_btree_add_idx(zfs_btree_t *, const void *, const zfs_btree_index_t *);
+
+/*
+ * Return the first or last valued node in the tree. Will return NULL if the
+ * tree is empty. The index can be NULL if the location of the first or last
+ * element isn't required.
+ */
+void *zfs_btree_first(zfs_btree_t *, zfs_btree_index_t *);
+void *zfs_btree_last(zfs_btree_t *, zfs_btree_index_t *);
+
+/*
+ * Return the next or previous valued node in the tree. The second index can
+ * safely be NULL, if the location of the next or previous value isn't
+ * required.
+ */
+void *zfs_btree_next(zfs_btree_t *, const zfs_btree_index_t *,
+    zfs_btree_index_t *);
+void *zfs_btree_prev(zfs_btree_t *, const zfs_btree_index_t *,
+    zfs_btree_index_t *);
+
+/*
+ * Get a value from a tree and an index.
+ */
+void *zfs_btree_get(zfs_btree_t *, zfs_btree_index_t *);
+
+/*
+ * Add a single value to the tree. The value must not compare equal to any
+ * other node already in the tree. Note that the value will be copied out, not
+ * inserted directly. It is safe to free or destroy the value once this
+ * function returns.
+ */
+void zfs_btree_add(zfs_btree_t *, const void *);
+
+/*
+ * Remove a single value from the tree.  The value must be in the tree. The
+ * pointer passed in may be a pointer into a tree-controlled buffer, but it
+ * need not be.
+ */
+void zfs_btree_remove(zfs_btree_t *, const void *);
+
+/*
+ * Remove the value at the given location from the tree.
+ */
+void zfs_btree_remove_idx(zfs_btree_t *, zfs_btree_index_t *);
+
+/*
+ * Return the number of nodes in the tree
+ */
+ulong_t zfs_btree_numnodes(zfs_btree_t *);
+
+/*
+ * Used to destroy any remaining nodes in a tree. The cookie argument should
+ * be initialized to NULL before the first call. Returns a node that has been
+ * removed from the tree and may be free()'d. Returns NULL when the tree is
+ * empty.
+ *
+ * Once you call zfs_btree_destroy_nodes(), you can only continuing calling it
+ * and finally zfs_btree_destroy(). No other B-Tree routines will be valid.
+ *
+ * cookie - an index used to save state between calls to
+ * zfs_btree_destroy_nodes()
+ *
+ * EXAMPLE:
+ *	zfs_btree_t *tree;
+ *	struct my_data *node;
+ *	zfs_btree_index_t *cookie;
+ *
+ *	cookie = NULL;
+ *	while ((node = zfs_btree_destroy_nodes(tree, &cookie)) != NULL)
+ *		data_destroy(node);
+ *	zfs_btree_destroy(tree);
+ */
+void *zfs_btree_destroy_nodes(zfs_btree_t *, zfs_btree_index_t **);
+
+/*
+ * Destroys all nodes in the tree quickly. This doesn't give the caller an
+ * opportunity to iterate over each node and do its own cleanup; for that, use
+ * zfs_btree_destroy_nodes().
+ */
+void zfs_btree_clear(zfs_btree_t *);
+
+/*
+ * Final destroy of an B-Tree. Arguments are:
+ *
+ * tree   - the empty tree to destroy
+ */
+void zfs_btree_destroy(zfs_btree_t *tree);
+
+/* Runs a variety of self-checks on the btree to verify integrity. */
+void zfs_btree_verify(zfs_btree_t *tree);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _BTREE_H */
diff --git a/include/sys/crypto/Makefile.am b/include/sys/crypto/Makefile.am
new file mode 100644
index 0000000000000..eb31f6a457435
--- /dev/null
+++ b/include/sys/crypto/Makefile.am
@@ -0,0 +1,16 @@
+COMMON_H = \
+	api.h \
+	common.h \
+	icp.h
+
+if CONFIG_USER
+libzfsdir = $(includedir)/libzfs/sys/crypto
+libzfs_HEADERS = $(COMMON_H)
+endif
+
+if CONFIG_KERNEL
+if BUILD_LINUX
+kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys/crypto
+kernel_HEADERS = $(COMMON_H)
+endif
+endif
diff --git a/include/sys/crypto/api.h b/include/sys/crypto/api.h
new file mode 100644
index 0000000000000..7c3c465513def
--- /dev/null
+++ b/include/sys/crypto/api.h
@@ -0,0 +1,425 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_CRYPTO_API_H
+#define	_SYS_CRYPTO_API_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <sys/zfs_context.h>
+#include <sys/crypto/common.h>
+
+typedef long crypto_req_id_t;
+typedef void *crypto_bc_t;
+typedef void *crypto_context_t;
+typedef void *crypto_ctx_template_t;
+
+typedef uint32_t crypto_call_flag_t;
+
+/* crypto_call_flag's values */
+#define	CRYPTO_ALWAYS_QUEUE	0x00000001	/* ALWAYS queue the req. */
+#define	CRYPTO_NOTIFY_OPDONE	0x00000002	/* Notify intermediate steps */
+#define	CRYPTO_SKIP_REQID	0x00000004	/* Skip request ID generation */
+#define	CRYPTO_RESTRICTED	0x00000008	/* cannot use restricted prov */
+
+typedef struct {
+	crypto_call_flag_t	cr_flag;
+	void			(*cr_callback_func)(void *, int);
+	void			*cr_callback_arg;
+	crypto_req_id_t		cr_reqid;
+} crypto_call_req_t;
+
+/*
+ * Returns the mechanism type corresponding to a mechanism name.
+ */
+
+#define	CRYPTO_MECH_INVALID	((uint64_t)-1)
+extern crypto_mech_type_t crypto_mech2id(crypto_mech_name_t name);
+
+/*
+ * Create and destroy context templates.
+ */
+extern int crypto_create_ctx_template(crypto_mechanism_t *mech,
+    crypto_key_t *key, crypto_ctx_template_t *tmpl, int kmflag);
+extern void crypto_destroy_ctx_template(crypto_ctx_template_t tmpl);
+
+/*
+ * Single and multi-part digest operations.
+ */
+extern int crypto_digest(crypto_mechanism_t *mech, crypto_data_t *data,
+    crypto_data_t *digest, crypto_call_req_t *cr);
+extern int crypto_digest_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_data_t *, crypto_data_t *,
+    crypto_call_req_t *);
+extern int crypto_digest_init(crypto_mechanism_t *mech, crypto_context_t *ctxp,
+    crypto_call_req_t *cr);
+extern int crypto_digest_init_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_context_t *, crypto_call_req_t *);
+extern int crypto_digest_update(crypto_context_t ctx, crypto_data_t *data,
+    crypto_call_req_t *cr);
+extern int crypto_digest_final(crypto_context_t ctx, crypto_data_t *digest,
+    crypto_call_req_t *cr);
+
+/*
+ * Single and multi-part MAC operations.
+ */
+extern int crypto_mac(crypto_mechanism_t *mech, crypto_data_t *data,
+    crypto_key_t *key, crypto_ctx_template_t tmpl, crypto_data_t *mac,
+    crypto_call_req_t *cr);
+extern int crypto_mac_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_data_t *, crypto_key_t *,
+    crypto_ctx_template_t, crypto_data_t *, crypto_call_req_t *);
+extern int crypto_mac_verify(crypto_mechanism_t *mech, crypto_data_t *data,
+    crypto_key_t *key, crypto_ctx_template_t tmpl, crypto_data_t *mac,
+    crypto_call_req_t *cr);
+extern int crypto_mac_verify_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_data_t *, crypto_key_t *,
+    crypto_ctx_template_t, crypto_data_t *, crypto_call_req_t *);
+extern int crypto_mac_init(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_ctx_template_t tmpl, crypto_context_t *ctxp, crypto_call_req_t *cr);
+extern int crypto_mac_init_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_ctx_template_t,
+    crypto_context_t *, crypto_call_req_t *);
+extern int crypto_mac_update(crypto_context_t ctx, crypto_data_t *data,
+    crypto_call_req_t *cr);
+extern int crypto_mac_final(crypto_context_t ctx, crypto_data_t *data,
+    crypto_call_req_t *cr);
+
+/*
+ * Single and multi-part sign with private key operations.
+ */
+extern int crypto_sign(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_data_t *data, crypto_ctx_template_t tmpl,
+    crypto_data_t *signature, crypto_call_req_t *cr);
+extern int crypto_sign_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
+    crypto_ctx_template_t, crypto_data_t *, crypto_call_req_t *);
+extern int crypto_sign_init(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_ctx_template_t tmpl, crypto_context_t *ctxp, crypto_call_req_t *cr);
+extern int crypto_sign_init_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_ctx_template_t,
+    crypto_context_t *, crypto_call_req_t *);
+extern int crypto_sign_update(crypto_context_t ctx, crypto_data_t *data,
+    crypto_call_req_t *cr);
+extern int crypto_sign_final(crypto_context_t ctx, crypto_data_t *signature,
+    crypto_call_req_t *cr);
+extern int crypto_sign_recover_init_prov(crypto_provider_t,
+    crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *,
+    crypto_ctx_template_t tmpl, crypto_context_t *, crypto_call_req_t *);
+extern int crypto_sign_recover(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_data_t *data, crypto_ctx_template_t tmpl, crypto_data_t *signature,
+    crypto_call_req_t *cr);
+extern int crypto_sign_recover_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
+    crypto_ctx_template_t, crypto_data_t *, crypto_call_req_t *);
+
+/*
+ * Single and multi-part verify with public key operations.
+ */
+extern int crypto_verify(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_data_t *data, crypto_ctx_template_t tmpl, crypto_data_t *signature,
+    crypto_call_req_t *cr);
+extern int crypto_verify_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
+    crypto_ctx_template_t, crypto_data_t *, crypto_call_req_t *);
+extern int crypto_verify_init(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_ctx_template_t tmpl, crypto_context_t *ctxp, crypto_call_req_t *cr);
+extern int crypto_verify_init_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_ctx_template_t,
+    crypto_context_t *, crypto_call_req_t *);
+extern int crypto_verify_update(crypto_context_t ctx, crypto_data_t *data,
+    crypto_call_req_t *cr);
+extern int crypto_verify_final(crypto_context_t ctx, crypto_data_t *signature,
+    crypto_call_req_t *cr);
+extern int crypto_verify_recover_init_prov(crypto_provider_t,
+    crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *,
+    crypto_ctx_template_t tmpl, crypto_context_t *, crypto_call_req_t *);
+extern int crypto_verify_recover(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_data_t *signature, crypto_ctx_template_t tmpl, crypto_data_t *data,
+    crypto_call_req_t *cr);
+extern int crypto_verify_recover_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
+    crypto_ctx_template_t, crypto_data_t *, crypto_call_req_t *);
+
+/*
+ * Single and multi-part encryption operations.
+ */
+extern int crypto_encrypt(crypto_mechanism_t *mech, crypto_data_t *plaintext,
+    crypto_key_t *key, crypto_ctx_template_t tmpl, crypto_data_t *ciphertext,
+    crypto_call_req_t *cr);
+extern int crypto_encrypt_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_data_t *, crypto_key_t *,
+    crypto_ctx_template_t, crypto_data_t *, crypto_call_req_t *);
+extern int crypto_encrypt_init(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_ctx_template_t tmpl, crypto_context_t *ctxp, crypto_call_req_t *cr);
+extern int crypto_encrypt_init_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_ctx_template_t,
+    crypto_context_t *, crypto_call_req_t *);
+extern int crypto_encrypt_update(crypto_context_t ctx,
+    crypto_data_t *plaintext, crypto_data_t *ciphertext,
+    crypto_call_req_t *cr);
+extern int crypto_encrypt_final(crypto_context_t ctx,
+    crypto_data_t *ciphertext, crypto_call_req_t *cr);
+
+/*
+ * Single and multi-part decryption operations.
+ */
+extern int crypto_decrypt(crypto_mechanism_t *mech, crypto_data_t *ciphertext,
+    crypto_key_t *key, crypto_ctx_template_t tmpl, crypto_data_t *plaintext,
+    crypto_call_req_t *cr);
+extern int crypto_decrypt_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_data_t *, crypto_key_t *,
+    crypto_ctx_template_t, crypto_data_t *, crypto_call_req_t *);
+extern int crypto_decrypt_init(crypto_mechanism_t *mech, crypto_key_t *key,
+    crypto_ctx_template_t tmpl, crypto_context_t *ctxp,
+    crypto_call_req_t *cr);
+extern int crypto_decrypt_init_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_ctx_template_t,
+    crypto_context_t *, crypto_call_req_t *);
+extern int crypto_decrypt_update(crypto_context_t ctx,
+    crypto_data_t *ciphertext, crypto_data_t *plaintext,
+    crypto_call_req_t *cr);
+extern int crypto_decrypt_final(crypto_context_t ctx, crypto_data_t *plaintext,
+    crypto_call_req_t *cr);
+
+/*
+ * Single and multi-part encrypt/MAC dual operations.
+ */
+extern int crypto_encrypt_mac(crypto_mechanism_t *encr_mech,
+    crypto_mechanism_t *mac_mech, crypto_data_t *pt,
+    crypto_key_t *encr_key, crypto_key_t *mac_key,
+    crypto_ctx_template_t encr_tmpl, crypto_ctx_template_t mac_tmpl,
+    crypto_dual_data_t *ct, crypto_data_t *mac, crypto_call_req_t *cr);
+extern int crypto_encrypt_mac_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_mechanism_t *, crypto_data_t *,
+    crypto_key_t *, crypto_key_t *, crypto_ctx_template_t,
+    crypto_ctx_template_t, crypto_dual_data_t *, crypto_data_t *,
+    crypto_call_req_t *);
+extern int crypto_encrypt_mac_init(crypto_mechanism_t *encr_mech,
+    crypto_mechanism_t *mac_mech, crypto_key_t *encr_key,
+    crypto_key_t *mac_key, crypto_ctx_template_t encr_tmpl,
+    crypto_ctx_template_t mac_tmpl, crypto_context_t *ctxp,
+    crypto_call_req_t *cr);
+extern int crypto_encrypt_mac_init_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_mechanism_t *, crypto_key_t *, crypto_key_t *,
+    crypto_ctx_template_t, crypto_ctx_template_t, crypto_context_t *,
+    crypto_call_req_t *);
+extern int crypto_encrypt_mac_update(crypto_context_t ctx,
+    crypto_data_t *pt, crypto_dual_data_t *ct, crypto_call_req_t *cr);
+extern int crypto_encrypt_mac_final(crypto_context_t ctx,
+    crypto_dual_data_t *ct, crypto_data_t *mac, crypto_call_req_t *cr);
+
+/*
+ * Single and multi-part MAC/decrypt dual operations.
+ */
+extern int crypto_mac_decrypt(crypto_mechanism_t *mac_mech,
+    crypto_mechanism_t *decr_mech, crypto_dual_data_t *ct,
+    crypto_key_t *mac_key, crypto_key_t *decr_key,
+    crypto_ctx_template_t mac_tmpl, crypto_ctx_template_t decr_tmpl,
+    crypto_data_t *mac, crypto_data_t *pt, crypto_call_req_t *cr);
+extern int crypto_mac_decrypt_prov(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *mac_mech, crypto_mechanism_t *decr_mech,
+    crypto_dual_data_t *ct, crypto_key_t *mac_key, crypto_key_t *decr_key,
+    crypto_ctx_template_t mac_tmpl, crypto_ctx_template_t decr_tmpl,
+    crypto_data_t *mac, crypto_data_t *pt, crypto_call_req_t *cr);
+extern int crypto_mac_verify_decrypt(crypto_mechanism_t *mac_mech,
+    crypto_mechanism_t *decr_mech, crypto_dual_data_t *ct,
+    crypto_key_t *mac_key, crypto_key_t *decr_key,
+    crypto_ctx_template_t mac_tmpl, crypto_ctx_template_t decr_tmpl,
+    crypto_data_t *mac, crypto_data_t *pt, crypto_call_req_t *cr);
+extern int crypto_mac_verify_decrypt_prov(crypto_provider_t,
+    crypto_session_id_t, crypto_mechanism_t *mac_mech,
+    crypto_mechanism_t *decr_mech, crypto_dual_data_t *ct,
+    crypto_key_t *mac_key, crypto_key_t *decr_key,
+    crypto_ctx_template_t mac_tmpl, crypto_ctx_template_t decr_tmpl,
+    crypto_data_t *mac, crypto_data_t *pt, crypto_call_req_t *cr);
+extern int crypto_mac_decrypt_init(crypto_mechanism_t *mac_mech,
+    crypto_mechanism_t *decr_mech, crypto_key_t *mac_key,
+    crypto_key_t *decr_key, crypto_ctx_template_t mac_tmpl,
+    crypto_ctx_template_t decr_tmpl, crypto_context_t *ctxp,
+    crypto_call_req_t *cr);
+extern int crypto_mac_decrypt_init_prov(crypto_provider_t,
+    crypto_session_id_t, crypto_mechanism_t *mac_mech,
+    crypto_mechanism_t *decr_mech, crypto_key_t *mac_key,
+    crypto_key_t *decr_key, crypto_ctx_template_t mac_tmpl,
+    crypto_ctx_template_t decr_tmpl, crypto_context_t *ctxp,
+    crypto_call_req_t *cr);
+extern int crypto_mac_decrypt_update(crypto_context_t ctx,
+    crypto_dual_data_t *ct, crypto_data_t *pt, crypto_call_req_t *cr);
+extern int crypto_mac_decrypt_final(crypto_context_t ctx, crypto_data_t *mac,
+    crypto_data_t *pt, crypto_call_req_t *cr);
+
+/* Session Management */
+extern int crypto_session_open(crypto_provider_t, crypto_session_id_t *,
+    crypto_call_req_t *);
+extern int crypto_session_close(crypto_provider_t, crypto_session_id_t,
+    crypto_call_req_t *);
+extern int crypto_session_login(crypto_provider_t, crypto_session_id_t,
+    crypto_user_type_t, char *, size_t, crypto_call_req_t *);
+extern int crypto_session_logout(crypto_provider_t, crypto_session_id_t,
+    crypto_call_req_t *);
+
+/* Object Management */
+extern int crypto_object_copy(crypto_provider_t, crypto_session_id_t,
+    crypto_object_id_t, crypto_object_attribute_t *, uint_t,
+    crypto_object_id_t *, crypto_call_req_t *);
+extern int crypto_object_create(crypto_provider_t, crypto_session_id_t,
+    crypto_object_attribute_t *, uint_t, crypto_object_id_t *,
+    crypto_call_req_t *);
+extern int crypto_object_destroy(crypto_provider_t, crypto_session_id_t,
+    crypto_object_id_t, crypto_call_req_t *);
+extern int crypto_object_get_attribute_value(crypto_provider_t,
+    crypto_session_id_t, crypto_object_id_t, crypto_object_attribute_t *,
+    uint_t, crypto_call_req_t *);
+extern int crypto_object_get_size(crypto_provider_t, crypto_session_id_t,
+    crypto_object_id_t, size_t *, crypto_call_req_t *);
+extern int crypto_object_find_final(crypto_provider_t, void *,
+    crypto_call_req_t *);
+extern int crypto_object_find_init(crypto_provider_t, crypto_session_id_t,
+    crypto_object_attribute_t *, uint_t, void **, crypto_call_req_t *);
+extern int crypto_object_find(crypto_provider_t, void *, crypto_object_id_t *,
+    uint_t *, uint_t, crypto_call_req_t *);
+extern int crypto_object_set_attribute_value(crypto_provider_t,
+    crypto_session_id_t, crypto_object_id_t, crypto_object_attribute_t *,
+    uint_t, crypto_call_req_t *);
+
+/* Key Management */
+extern int crypto_key_derive(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_object_attribute_t *,
+    uint_t, crypto_object_id_t *, crypto_call_req_t *);
+extern int crypto_key_generate(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_object_attribute_t *, uint_t,
+    crypto_object_id_t *, crypto_call_req_t *);
+extern int crypto_key_generate_pair(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_object_attribute_t *, uint_t,
+    crypto_object_attribute_t *, uint_t, crypto_object_id_t *,
+    crypto_object_id_t *, crypto_call_req_t *);
+extern int crypto_key_unwrap(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, uchar_t *, size_t *,
+    crypto_object_attribute_t *, uint_t, crypto_object_id_t *,
+    crypto_call_req_t *);
+extern int crypto_key_wrap(crypto_provider_t, crypto_session_id_t,
+    crypto_mechanism_t *, crypto_key_t *, crypto_object_id_t *, uchar_t *,
+    size_t *, crypto_call_req_t *);
+extern int crypto_key_check_prov(crypto_provider_t, crypto_mechanism_t *mech,
+    crypto_key_t *key);
+extern int crypto_key_check(crypto_mechanism_t *mech, crypto_key_t *key);
+
+
+/*
+ * Routines to cancel a single asynchronous request or all asynchronous
+ * requests associated with a particular context.
+ */
+extern void crypto_cancel_req(crypto_req_id_t req);
+extern void crypto_cancel_ctx(crypto_context_t ctx);
+
+/*
+ * crypto_get_mech_list(9F) allocates and returns the list of currently
+ * supported cryptographic mechanisms.
+ */
+extern crypto_mech_name_t *crypto_get_mech_list(uint_t *count, int kmflag);
+extern void crypto_free_mech_list(crypto_mech_name_t *mech_names,
+    uint_t count);
+
+extern crypto_provider_t crypto_get_provider(char *, char *, char *);
+extern int crypto_get_provinfo(crypto_provider_t, crypto_provider_ext_info_t *);
+extern void crypto_release_provider(crypto_provider_t);
+
+/*
+ * A kernel consumer can request to be notified when some particular event
+ * occurs. The valid events, callback function type, and functions to
+ * be called to register or unregister for notification are defined below.
+ */
+
+#define	CRYPTO_EVENT_MECHS_CHANGED		0x00000001
+#define	CRYPTO_EVENT_PROVIDER_REGISTERED	0x00000002
+#define	CRYPTO_EVENT_PROVIDER_UNREGISTERED	0x00000004
+
+typedef enum {
+	CRYPTO_MECH_ADDED = 1,
+	CRYPTO_MECH_REMOVED
+} crypto_event_change_t;
+
+/* The event_arg argument structure for CRYPTO_EVENT_PROVIDERS_CHANGE event */
+typedef struct crypto_notify_event_change {
+	crypto_mech_name_t ec_mech_name;
+	crypto_provider_type_t ec_provider_type;
+	crypto_event_change_t ec_change;
+} crypto_notify_event_change_t;
+
+typedef void *crypto_notify_handle_t;
+typedef void (*crypto_notify_callback_t)(uint32_t event_mask, void *event_arg);
+
+extern crypto_notify_handle_t crypto_notify_events(
+    crypto_notify_callback_t nf, uint32_t event_mask);
+extern void crypto_unnotify_events(crypto_notify_handle_t);
+
+/*
+ * crypto_bufcall(9F) group of routines.
+ */
+extern crypto_bc_t crypto_bufcall_alloc(void);
+extern int crypto_bufcall_free(crypto_bc_t bc);
+extern int crypto_bufcall(crypto_bc_t bc, void (*func)(void *arg), void *arg);
+extern int crypto_unbufcall(crypto_bc_t bc);
+
+/*
+ * To obtain the list of key size ranges supported by a mechanism.
+ */
+
+#define	CRYPTO_MECH_USAGE_ENCRYPT	0x00000001
+#define	CRYPTO_MECH_USAGE_DECRYPT	0x00000002
+#define	CRYPTO_MECH_USAGE_MAC		0x00000004
+
+typedef	uint32_t crypto_mech_usage_t;
+
+typedef struct crypto_mechanism_info {
+	size_t mi_min_key_size;
+	size_t mi_max_key_size;
+	crypto_keysize_unit_t mi_keysize_unit; /* for mi_xxx_key_size */
+	crypto_mech_usage_t mi_usage;
+} crypto_mechanism_info_t;
+
+#ifdef	_SYSCALL32
+
+typedef struct crypto_mechanism_info32 {
+	size32_t mi_min_key_size;
+	size32_t mi_max_key_size;
+	crypto_keysize_unit_t mi_keysize_unit; /* for mi_xxx_key_size */
+	crypto_mech_usage_t mi_usage;
+} crypto_mechanism_info32_t;
+
+#endif	/* _SYSCALL32 */
+
+extern int crypto_get_all_mech_info(crypto_mech_type_t,
+    crypto_mechanism_info_t **, uint_t *, int);
+extern void crypto_free_all_mech_info(crypto_mechanism_info_t *, uint_t);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_CRYPTO_API_H */
diff --git a/include/sys/crypto/common.h b/include/sys/crypto/common.h
new file mode 100644
index 0000000000000..a4f9d9848c237
--- /dev/null
+++ b/include/sys/crypto/common.h
@@ -0,0 +1,583 @@
+/*
+ * 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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+ */
+/*
+ * Copyright 2013 Saso Kiselkov.  All rights reserved.
+ */
+
+#ifndef _SYS_CRYPTO_COMMON_H
+#define	_SYS_CRYPTO_COMMON_H
+
+/*
+ * Header file for the common data structures of the cryptographic framework
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/zfs_context.h>
+
+/* Cryptographic Mechanisms */
+
+#define	CRYPTO_MAX_MECH_NAME 32
+typedef char crypto_mech_name_t[CRYPTO_MAX_MECH_NAME];
+
+typedef uint64_t crypto_mech_type_t;
+
+typedef struct crypto_mechanism {
+	crypto_mech_type_t	cm_type;	/* mechanism type */
+	caddr_t			cm_param;	/* mech. parameter */
+	size_t			cm_param_len;	/* mech. parameter len */
+} crypto_mechanism_t;
+
+#ifdef  _SYSCALL32
+
+typedef struct crypto_mechanism32 {
+	crypto_mech_type_t	cm_type;	/* mechanism type */
+	caddr32_t		cm_param;	/* mech. parameter */
+	size32_t		cm_param_len;   /* mech. parameter len */
+} crypto_mechanism32_t;
+
+#endif  /* _SYSCALL32 */
+
+/* CK_AES_CTR_PARAMS provides parameters to the CKM_AES_CTR mechanism */
+typedef struct CK_AES_CTR_PARAMS {
+	ulong_t	ulCounterBits;
+	uint8_t cb[16];
+} CK_AES_CTR_PARAMS;
+
+/* CK_AES_CCM_PARAMS provides parameters to the CKM_AES_CCM mechanism */
+typedef struct CK_AES_CCM_PARAMS {
+	ulong_t ulMACSize;
+	ulong_t ulNonceSize;
+	ulong_t ulAuthDataSize;
+	ulong_t ulDataSize; /* used for plaintext or ciphertext */
+	uchar_t *nonce;
+	uchar_t *authData;
+} CK_AES_CCM_PARAMS;
+
+/* CK_AES_GCM_PARAMS provides parameters to the CKM_AES_GCM mechanism */
+typedef struct CK_AES_GCM_PARAMS {
+	uchar_t *pIv;
+	ulong_t ulIvLen;
+	ulong_t ulIvBits;
+	uchar_t *pAAD;
+	ulong_t ulAADLen;
+	ulong_t ulTagBits;
+} CK_AES_GCM_PARAMS;
+
+/* CK_AES_GMAC_PARAMS provides parameters to the CKM_AES_GMAC mechanism */
+typedef struct CK_AES_GMAC_PARAMS {
+	uchar_t *pIv;
+	uchar_t *pAAD;
+	ulong_t ulAADLen;
+} CK_AES_GMAC_PARAMS;
+
+/*
+ * CK_ECDH1_DERIVE_PARAMS provides the parameters to the
+ * CKM_ECDH1_KEY_DERIVE mechanism
+ */
+typedef struct CK_ECDH1_DERIVE_PARAMS {
+	ulong_t		kdf;
+	ulong_t		ulSharedDataLen;
+	uchar_t		*pSharedData;
+	ulong_t		ulPublicDataLen;
+	uchar_t		*pPublicData;
+} CK_ECDH1_DERIVE_PARAMS;
+
+#ifdef  _SYSCALL32
+
+/* needed for 32-bit applications running on 64-bit kernels */
+typedef struct CK_AES_CTR_PARAMS32 {
+	uint32_t ulCounterBits;
+	uint8_t cb[16];
+} CK_AES_CTR_PARAMS32;
+
+/* needed for 32-bit applications running on 64-bit kernels */
+typedef struct CK_AES_CCM_PARAMS32 {
+	uint32_t ulMACSize;
+	uint32_t ulNonceSize;
+	uint32_t ulAuthDataSize;
+	uint32_t ulDataSize;
+	caddr32_t nonce;
+	caddr32_t authData;
+} CK_AES_CCM_PARAMS32;
+
+/* needed for 32-bit applications running on 64-bit kernels */
+typedef struct CK_AES_GCM_PARAMS32 {
+	caddr32_t pIv;
+	uint32_t ulIvLen;
+	uint32_t ulIvBits;
+	caddr32_t pAAD;
+	uint32_t ulAADLen;
+	uint32_t ulTagBits;
+} CK_AES_GCM_PARAMS32;
+
+/* needed for 32-bit applications running on 64-bit kernels */
+typedef struct CK_AES_GMAC_PARAMS32 {
+	caddr32_t pIv;
+	caddr32_t pAAD;
+	uint32_t ulAADLen;
+} CK_AES_GMAC_PARAMS32;
+
+typedef struct CK_ECDH1_DERIVE_PARAMS32 {
+	uint32_t	kdf;
+	uint32_t	ulSharedDataLen;
+	caddr32_t	pSharedData;
+	uint32_t	ulPublicDataLen;
+	caddr32_t	pPublicData;
+} CK_ECDH1_DERIVE_PARAMS32;
+
+#endif  /* _SYSCALL32 */
+
+/*
+ * The measurement unit bit flag for a mechanism's minimum or maximum key size.
+ * The unit are mechanism dependent.  It can be in bits or in bytes.
+ */
+typedef uint32_t crypto_keysize_unit_t;
+
+/*
+ * The following bit flags are valid in cm_mech_flags field in
+ * the crypto_mech_info_t structure of the SPI.
+ *
+ * Only the first two bit flags are valid in mi_keysize_unit
+ * field in the crypto_mechanism_info_t structure of the API.
+ */
+#define	CRYPTO_KEYSIZE_UNIT_IN_BITS	0x00000001
+#define	CRYPTO_KEYSIZE_UNIT_IN_BYTES	0x00000002
+#define	CRYPTO_CAN_SHARE_OPSTATE	0x00000004 /* supports sharing */
+
+
+/* Mechanisms supported out-of-the-box */
+#define	SUN_CKM_MD4			"CKM_MD4"
+#define	SUN_CKM_MD5			"CKM_MD5"
+#define	SUN_CKM_MD5_HMAC		"CKM_MD5_HMAC"
+#define	SUN_CKM_MD5_HMAC_GENERAL	"CKM_MD5_HMAC_GENERAL"
+#define	SUN_CKM_SHA1			"CKM_SHA_1"
+#define	SUN_CKM_SHA1_HMAC		"CKM_SHA_1_HMAC"
+#define	SUN_CKM_SHA1_HMAC_GENERAL	"CKM_SHA_1_HMAC_GENERAL"
+#define	SUN_CKM_SHA256			"CKM_SHA256"
+#define	SUN_CKM_SHA256_HMAC		"CKM_SHA256_HMAC"
+#define	SUN_CKM_SHA256_HMAC_GENERAL	"CKM_SHA256_HMAC_GENERAL"
+#define	SUN_CKM_SHA384			"CKM_SHA384"
+#define	SUN_CKM_SHA384_HMAC		"CKM_SHA384_HMAC"
+#define	SUN_CKM_SHA384_HMAC_GENERAL	"CKM_SHA384_HMAC_GENERAL"
+#define	SUN_CKM_SHA512			"CKM_SHA512"
+#define	SUN_CKM_SHA512_HMAC		"CKM_SHA512_HMAC"
+#define	SUN_CKM_SHA512_HMAC_GENERAL	"CKM_SHA512_HMAC_GENERAL"
+#define	SUN_CKM_SHA512_224		"CKM_SHA512_224"
+#define	SUN_CKM_SHA512_256		"CKM_SHA512_256"
+#define	SUN_CKM_DES_CBC			"CKM_DES_CBC"
+#define	SUN_CKM_DES3_CBC		"CKM_DES3_CBC"
+#define	SUN_CKM_DES_ECB			"CKM_DES_ECB"
+#define	SUN_CKM_DES3_ECB		"CKM_DES3_ECB"
+#define	SUN_CKM_BLOWFISH_CBC		"CKM_BLOWFISH_CBC"
+#define	SUN_CKM_BLOWFISH_ECB		"CKM_BLOWFISH_ECB"
+#define	SUN_CKM_AES_CBC			"CKM_AES_CBC"
+#define	SUN_CKM_AES_ECB			"CKM_AES_ECB"
+#define	SUN_CKM_AES_CTR			"CKM_AES_CTR"
+#define	SUN_CKM_AES_CCM			"CKM_AES_CCM"
+#define	SUN_CKM_AES_GCM			"CKM_AES_GCM"
+#define	SUN_CKM_AES_GMAC		"CKM_AES_GMAC"
+#define	SUN_CKM_AES_CFB128		"CKM_AES_CFB128"
+#define	SUN_CKM_RC4			"CKM_RC4"
+#define	SUN_CKM_RSA_PKCS		"CKM_RSA_PKCS"
+#define	SUN_CKM_RSA_X_509		"CKM_RSA_X_509"
+#define	SUN_CKM_MD5_RSA_PKCS		"CKM_MD5_RSA_PKCS"
+#define	SUN_CKM_SHA1_RSA_PKCS		"CKM_SHA1_RSA_PKCS"
+#define	SUN_CKM_SHA256_RSA_PKCS		"CKM_SHA256_RSA_PKCS"
+#define	SUN_CKM_SHA384_RSA_PKCS		"CKM_SHA384_RSA_PKCS"
+#define	SUN_CKM_SHA512_RSA_PKCS		"CKM_SHA512_RSA_PKCS"
+#define	SUN_CKM_EC_KEY_PAIR_GEN		"CKM_EC_KEY_PAIR_GEN"
+#define	SUN_CKM_ECDH1_DERIVE		"CKM_ECDH1_DERIVE"
+#define	SUN_CKM_ECDSA_SHA1		"CKM_ECDSA_SHA1"
+#define	SUN_CKM_ECDSA			"CKM_ECDSA"
+
+/* Shared operation context format for CKM_RC4 */
+typedef struct {
+#if defined(__amd64)
+	uint32_t	i, j;
+	uint32_t	arr[256];
+	uint32_t	flag;
+#else
+	uchar_t		arr[256];
+	uchar_t		i, j;
+#endif /* __amd64 */
+	uint64_t	pad;		/* For 64-bit alignment */
+} arcfour_state_t;
+
+/* Data arguments of cryptographic operations */
+
+typedef enum crypto_data_format {
+	CRYPTO_DATA_RAW = 1,
+	CRYPTO_DATA_UIO,
+} crypto_data_format_t;
+
+typedef struct crypto_data {
+	crypto_data_format_t	cd_format;	/* Format identifier	*/
+	off_t			cd_offset;	/* Offset from the beginning */
+	size_t			cd_length;	/* # of bytes in use */
+	caddr_t			cd_miscdata;	/* ancillary data */
+	union {
+		/* Raw format */
+		iovec_t cdu_raw;		/* Pointer and length	    */
+
+		/* uio scatter-gather format */
+		uio_t	*cdu_uio;
+
+	} cdu;	/* Crypto Data Union */
+} crypto_data_t;
+
+#define	cd_raw		cdu.cdu_raw
+#define	cd_uio		cdu.cdu_uio
+#define	cd_mp		cdu.cdu_mp
+
+typedef struct crypto_dual_data {
+	crypto_data_t		dd_data;	/* The data */
+	off_t			dd_offset2;	/* Used by dual operation */
+	size_t			dd_len2;	/* # of bytes to take	*/
+} crypto_dual_data_t;
+
+#define	dd_format	dd_data.cd_format
+#define	dd_offset1	dd_data.cd_offset
+#define	dd_len1		dd_data.cd_length
+#define	dd_miscdata	dd_data.cd_miscdata
+#define	dd_raw		dd_data.cd_raw
+#define	dd_uio		dd_data.cd_uio
+#define	dd_mp		dd_data.cd_mp
+
+/* The keys, and their contents */
+
+typedef enum {
+	CRYPTO_KEY_RAW = 1,	/* ck_data is a cleartext key */
+	CRYPTO_KEY_REFERENCE,	/* ck_obj_id is an opaque reference */
+	CRYPTO_KEY_ATTR_LIST	/* ck_attrs is a list of object attributes */
+} crypto_key_format_t;
+
+typedef uint64_t crypto_attr_type_t;
+
+/* Attribute types to use for passing a RSA public key or a private key. */
+#define	SUN_CKA_MODULUS			0x00000120
+#define	SUN_CKA_MODULUS_BITS		0x00000121
+#define	SUN_CKA_PUBLIC_EXPONENT		0x00000122
+#define	SUN_CKA_PRIVATE_EXPONENT	0x00000123
+#define	SUN_CKA_PRIME_1			0x00000124
+#define	SUN_CKA_PRIME_2			0x00000125
+#define	SUN_CKA_EXPONENT_1		0x00000126
+#define	SUN_CKA_EXPONENT_2		0x00000127
+#define	SUN_CKA_COEFFICIENT		0x00000128
+#define	SUN_CKA_PRIME			0x00000130
+#define	SUN_CKA_SUBPRIME		0x00000131
+#define	SUN_CKA_BASE			0x00000132
+
+#define	CKK_EC			0x00000003
+#define	CKK_GENERIC_SECRET	0x00000010
+#define	CKK_RC4			0x00000012
+#define	CKK_AES			0x0000001F
+#define	CKK_DES			0x00000013
+#define	CKK_DES2		0x00000014
+#define	CKK_DES3		0x00000015
+
+#define	CKO_PUBLIC_KEY		0x00000002
+#define	CKO_PRIVATE_KEY		0x00000003
+#define	CKA_CLASS		0x00000000
+#define	CKA_VALUE		0x00000011
+#define	CKA_KEY_TYPE		0x00000100
+#define	CKA_VALUE_LEN		0x00000161
+#define	CKA_EC_PARAMS		0x00000180
+#define	CKA_EC_POINT		0x00000181
+
+typedef uint32_t	crypto_object_id_t;
+
+typedef struct crypto_object_attribute {
+	crypto_attr_type_t	oa_type;	/* attribute type */
+	caddr_t			oa_value;	/* attribute value */
+	ssize_t			oa_value_len;	/* length of attribute value */
+} crypto_object_attribute_t;
+
+typedef struct crypto_key {
+	crypto_key_format_t	ck_format;	/* format identifier */
+	union {
+		/* for CRYPTO_KEY_RAW ck_format */
+		struct {
+			uint_t	cku_v_length;	/* # of bits in ck_data   */
+			void	*cku_v_data;	/* ptr to key value */
+		} cku_key_value;
+
+		/* for CRYPTO_KEY_REFERENCE ck_format */
+		crypto_object_id_t cku_key_id;	/* reference to object key */
+
+		/* for CRYPTO_KEY_ATTR_LIST ck_format */
+		struct {
+			uint_t cku_a_count;	/* number of attributes */
+			crypto_object_attribute_t *cku_a_oattr;
+		} cku_key_attrs;
+	} cku_data;				/* Crypto Key union */
+} crypto_key_t;
+
+#ifdef  _SYSCALL32
+
+typedef struct crypto_object_attribute32 {
+	uint64_t	oa_type;	/* attribute type */
+	caddr32_t	oa_value;	/* attribute value */
+	ssize32_t	oa_value_len;	/* length of attribute value */
+} crypto_object_attribute32_t;
+
+typedef struct crypto_key32 {
+	crypto_key_format_t	ck_format;	/* format identifier */
+	union {
+		/* for CRYPTO_KEY_RAW ck_format */
+		struct {
+			uint32_t cku_v_length;	/* # of bytes in ck_data */
+			caddr32_t cku_v_data;	/* ptr to key value */
+		} cku_key_value;
+
+		/* for CRYPTO_KEY_REFERENCE ck_format */
+		crypto_object_id_t cku_key_id; /* reference to object key */
+
+		/* for CRYPTO_KEY_ATTR_LIST ck_format */
+		struct {
+			uint32_t cku_a_count;	/* number of attributes */
+			caddr32_t cku_a_oattr;
+		} cku_key_attrs;
+	} cku_data;				/* Crypto Key union */
+} crypto_key32_t;
+
+#endif  /* _SYSCALL32 */
+
+#define	ck_data		cku_data.cku_key_value.cku_v_data
+#define	ck_length	cku_data.cku_key_value.cku_v_length
+#define	ck_obj_id	cku_data.cku_key_id
+#define	ck_count	cku_data.cku_key_attrs.cku_a_count
+#define	ck_attrs	cku_data.cku_key_attrs.cku_a_oattr
+
+/*
+ * Raw key lengths are expressed in number of bits.
+ * The following macro returns the minimum number of
+ * bytes that can contain the specified number of bits.
+ * Round up without overflowing the integer type.
+ */
+#define	CRYPTO_BITS2BYTES(n) ((n) == 0 ? 0 : (((n) - 1) >> 3) + 1)
+#define	CRYPTO_BYTES2BITS(n) ((n) << 3)
+
+/* Providers */
+
+typedef enum {
+	CRYPTO_HW_PROVIDER = 0,
+	CRYPTO_SW_PROVIDER,
+	CRYPTO_LOGICAL_PROVIDER
+} crypto_provider_type_t;
+
+typedef uint32_t 	crypto_provider_id_t;
+#define	KCF_PROVID_INVALID	((uint32_t)-1)
+
+typedef struct crypto_provider_entry {
+	crypto_provider_id_t	pe_provider_id;
+	uint_t			pe_mechanism_count;
+} crypto_provider_entry_t;
+
+typedef struct crypto_dev_list_entry {
+	char			le_dev_name[MAXNAMELEN];
+	uint_t			le_dev_instance;
+	uint_t			le_mechanism_count;
+} crypto_dev_list_entry_t;
+
+/* User type for authentication ioctls and SPI entry points */
+
+typedef enum crypto_user_type {
+	CRYPTO_SO = 0,
+	CRYPTO_USER
+} crypto_user_type_t;
+
+/* Version for provider management ioctls and SPI entry points */
+
+typedef struct crypto_version {
+	uchar_t	cv_major;
+	uchar_t	cv_minor;
+} crypto_version_t;
+
+/* session data structure opaque to the consumer */
+typedef void *crypto_session_t;
+
+/* provider data structure opaque to the consumer */
+typedef void *crypto_provider_t;
+
+/* Limits used by both consumers and providers */
+#define	CRYPTO_EXT_SIZE_LABEL		32
+#define	CRYPTO_EXT_SIZE_MANUF		32
+#define	CRYPTO_EXT_SIZE_MODEL		16
+#define	CRYPTO_EXT_SIZE_SERIAL		16
+#define	CRYPTO_EXT_SIZE_TIME		16
+
+typedef struct crypto_provider_ext_info {
+	uchar_t			ei_label[CRYPTO_EXT_SIZE_LABEL];
+	uchar_t			ei_manufacturerID[CRYPTO_EXT_SIZE_MANUF];
+	uchar_t			ei_model[CRYPTO_EXT_SIZE_MODEL];
+	uchar_t			ei_serial_number[CRYPTO_EXT_SIZE_SERIAL];
+	ulong_t			ei_flags;
+	ulong_t			ei_max_session_count;
+	ulong_t			ei_max_pin_len;
+	ulong_t			ei_min_pin_len;
+	ulong_t			ei_total_public_memory;
+	ulong_t			ei_free_public_memory;
+	ulong_t			ei_total_private_memory;
+	ulong_t			ei_free_private_memory;
+	crypto_version_t	ei_hardware_version;
+	crypto_version_t	ei_firmware_version;
+	uchar_t			ei_time[CRYPTO_EXT_SIZE_TIME];
+	int			ei_hash_max_input_len;
+	int			ei_hmac_max_input_len;
+} crypto_provider_ext_info_t;
+
+typedef uint_t		crypto_session_id_t;
+
+typedef enum cmd_type {
+	COPY_FROM_DATA,
+	COPY_TO_DATA,
+	COMPARE_TO_DATA,
+	MD5_DIGEST_DATA,
+	SHA1_DIGEST_DATA,
+	SHA2_DIGEST_DATA,
+	GHASH_DATA
+} cmd_type_t;
+
+#define	CRYPTO_DO_UPDATE	0x01
+#define	CRYPTO_DO_FINAL		0x02
+#define	CRYPTO_DO_MD5		0x04
+#define	CRYPTO_DO_SHA1		0x08
+#define	CRYPTO_DO_SIGN		0x10
+#define	CRYPTO_DO_VERIFY	0x20
+#define	CRYPTO_DO_SHA2		0x40
+
+#define	PROVIDER_OWNS_KEY_SCHEDULE	0x00000001
+
+/*
+ * Common cryptographic status and error codes.
+ */
+#define	CRYPTO_SUCCESS				0x00000000
+#define	CRYPTO_CANCEL				0x00000001
+#define	CRYPTO_HOST_MEMORY			0x00000002
+#define	CRYPTO_GENERAL_ERROR			0x00000003
+#define	CRYPTO_FAILED				0x00000004
+#define	CRYPTO_ARGUMENTS_BAD			0x00000005
+#define	CRYPTO_ATTRIBUTE_READ_ONLY		0x00000006
+#define	CRYPTO_ATTRIBUTE_SENSITIVE		0x00000007
+#define	CRYPTO_ATTRIBUTE_TYPE_INVALID		0x00000008
+#define	CRYPTO_ATTRIBUTE_VALUE_INVALID		0x00000009
+#define	CRYPTO_CANCELED				0x0000000A
+#define	CRYPTO_DATA_INVALID			0x0000000B
+#define	CRYPTO_DATA_LEN_RANGE			0x0000000C
+#define	CRYPTO_DEVICE_ERROR			0x0000000D
+#define	CRYPTO_DEVICE_MEMORY			0x0000000E
+#define	CRYPTO_DEVICE_REMOVED			0x0000000F
+#define	CRYPTO_ENCRYPTED_DATA_INVALID		0x00000010
+#define	CRYPTO_ENCRYPTED_DATA_LEN_RANGE		0x00000011
+#define	CRYPTO_KEY_HANDLE_INVALID		0x00000012
+#define	CRYPTO_KEY_SIZE_RANGE			0x00000013
+#define	CRYPTO_KEY_TYPE_INCONSISTENT		0x00000014
+#define	CRYPTO_KEY_NOT_NEEDED			0x00000015
+#define	CRYPTO_KEY_CHANGED			0x00000016
+#define	CRYPTO_KEY_NEEDED			0x00000017
+#define	CRYPTO_KEY_INDIGESTIBLE			0x00000018
+#define	CRYPTO_KEY_FUNCTION_NOT_PERMITTED	0x00000019
+#define	CRYPTO_KEY_NOT_WRAPPABLE		0x0000001A
+#define	CRYPTO_KEY_UNEXTRACTABLE		0x0000001B
+#define	CRYPTO_MECHANISM_INVALID		0x0000001C
+#define	CRYPTO_MECHANISM_PARAM_INVALID		0x0000001D
+#define	CRYPTO_OBJECT_HANDLE_INVALID		0x0000001E
+#define	CRYPTO_OPERATION_IS_ACTIVE		0x0000001F
+#define	CRYPTO_OPERATION_NOT_INITIALIZED	0x00000020
+#define	CRYPTO_PIN_INCORRECT			0x00000021
+#define	CRYPTO_PIN_INVALID			0x00000022
+#define	CRYPTO_PIN_LEN_RANGE			0x00000023
+#define	CRYPTO_PIN_EXPIRED			0x00000024
+#define	CRYPTO_PIN_LOCKED			0x00000025
+#define	CRYPTO_SESSION_CLOSED			0x00000026
+#define	CRYPTO_SESSION_COUNT			0x00000027
+#define	CRYPTO_SESSION_HANDLE_INVALID		0x00000028
+#define	CRYPTO_SESSION_READ_ONLY		0x00000029
+#define	CRYPTO_SESSION_EXISTS			0x0000002A
+#define	CRYPTO_SESSION_READ_ONLY_EXISTS		0x0000002B
+#define	CRYPTO_SESSION_READ_WRITE_SO_EXISTS	0x0000002C
+#define	CRYPTO_SIGNATURE_INVALID		0x0000002D
+#define	CRYPTO_SIGNATURE_LEN_RANGE		0x0000002E
+#define	CRYPTO_TEMPLATE_INCOMPLETE		0x0000002F
+#define	CRYPTO_TEMPLATE_INCONSISTENT		0x00000030
+#define	CRYPTO_UNWRAPPING_KEY_HANDLE_INVALID	0x00000031
+#define	CRYPTO_UNWRAPPING_KEY_SIZE_RANGE	0x00000032
+#define	CRYPTO_UNWRAPPING_KEY_TYPE_INCONSISTENT	0x00000033
+#define	CRYPTO_USER_ALREADY_LOGGED_IN		0x00000034
+#define	CRYPTO_USER_NOT_LOGGED_IN		0x00000035
+#define	CRYPTO_USER_PIN_NOT_INITIALIZED		0x00000036
+#define	CRYPTO_USER_TYPE_INVALID		0x00000037
+#define	CRYPTO_USER_ANOTHER_ALREADY_LOGGED_IN	0x00000038
+#define	CRYPTO_USER_TOO_MANY_TYPES		0x00000039
+#define	CRYPTO_WRAPPED_KEY_INVALID		0x0000003A
+#define	CRYPTO_WRAPPED_KEY_LEN_RANGE		0x0000003B
+#define	CRYPTO_WRAPPING_KEY_HANDLE_INVALID	0x0000003C
+#define	CRYPTO_WRAPPING_KEY_SIZE_RANGE		0x0000003D
+#define	CRYPTO_WRAPPING_KEY_TYPE_INCONSISTENT	0x0000003E
+#define	CRYPTO_RANDOM_SEED_NOT_SUPPORTED	0x0000003F
+#define	CRYPTO_RANDOM_NO_RNG			0x00000040
+#define	CRYPTO_DOMAIN_PARAMS_INVALID		0x00000041
+#define	CRYPTO_BUFFER_TOO_SMALL			0x00000042
+#define	CRYPTO_INFORMATION_SENSITIVE		0x00000043
+#define	CRYPTO_NOT_SUPPORTED			0x00000044
+
+#define	CRYPTO_QUEUED				0x00000045
+#define	CRYPTO_BUFFER_TOO_BIG			0x00000046
+#define	CRYPTO_INVALID_CONTEXT			0x00000047
+#define	CRYPTO_INVALID_MAC			0x00000048
+#define	CRYPTO_MECH_NOT_SUPPORTED		0x00000049
+#define	CRYPTO_INCONSISTENT_ATTRIBUTE		0x0000004A
+#define	CRYPTO_NO_PERMISSION			0x0000004B
+#define	CRYPTO_INVALID_PROVIDER_ID		0x0000004C
+#define	CRYPTO_VERSION_MISMATCH			0x0000004D
+#define	CRYPTO_BUSY				0x0000004E
+#define	CRYPTO_UNKNOWN_PROVIDER			0x0000004F
+#define	CRYPTO_MODVERIFICATION_FAILED		0x00000050
+#define	CRYPTO_OLD_CTX_TEMPLATE			0x00000051
+#define	CRYPTO_WEAK_KEY				0x00000052
+#define	CRYPTO_FIPS140_ERROR			0x00000053
+/*
+ * Don't forget to update CRYPTO_LAST_ERROR and the error_number_table[]
+ * in kernelUtil.c when new error code is added.
+ */
+#define	CRYPTO_LAST_ERROR			0x00000053
+
+/*
+ * Special values that can be used to indicate that information is unavailable
+ * or that there is not practical limit. These values can be used
+ * by fields of the SPI crypto_provider_ext_info(9S) structure.
+ * The value of CRYPTO_UNAVAILABLE_INFO should be the same as
+ * CK_UNAVAILABLE_INFO in the PKCS#11 spec.
+ */
+#define	CRYPTO_UNAVAILABLE_INFO		((ulong_t)(-1))
+#define	CRYPTO_EFFECTIVELY_INFINITE	0x0
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_CRYPTO_COMMON_H */
diff --git a/include/sys/crypto/icp.h b/include/sys/crypto/icp.h
new file mode 100644
index 0000000000000..4609e3a1dae7d
--- /dev/null
+++ b/include/sys/crypto/icp.h
@@ -0,0 +1,50 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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, Datto, Inc. All rights reserved.
+ */
+
+#ifndef	_SYS_CRYPTO_ALGS_H
+#define	_SYS_CRYPTO_ALGS_H
+
+int aes_mod_init(void);
+int aes_mod_fini(void);
+
+int edonr_mod_init(void);
+int edonr_mod_fini(void);
+
+int sha1_mod_init(void);
+int sha1_mod_fini(void);
+
+int sha2_mod_init(void);
+int sha2_mod_fini(void);
+
+int skein_mod_init(void);
+int skein_mod_fini(void);
+
+int icp_init(void);
+void icp_fini(void);
+
+int aes_impl_set(const char *);
+int gcm_impl_set(const char *);
+
+#endif /* _SYS_CRYPTO_ALGS_H */
diff --git a/include/sys/dataset_kstats.h b/include/sys/dataset_kstats.h
new file mode 100644
index 0000000000000..667d1b85fa2c1
--- /dev/null
+++ b/include/sys/dataset_kstats.h
@@ -0,0 +1,75 @@
+/*
+ * 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) 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2018 Datto Inc.
+ */
+
+#ifndef _SYS_DATASET_KSTATS_H
+#define	_SYS_DATASET_KSTATS_H
+
+#include <sys/aggsum.h>
+#include <sys/dmu.h>
+#include <sys/kstat.h>
+
+typedef struct dataset_aggsum_stats_t {
+	aggsum_t das_writes;
+	aggsum_t das_nwritten;
+	aggsum_t das_reads;
+	aggsum_t das_nread;
+	aggsum_t das_nunlinks;
+	aggsum_t das_nunlinked;
+} dataset_aggsum_stats_t;
+
+typedef struct dataset_kstat_values {
+	kstat_named_t dkv_ds_name;
+	kstat_named_t dkv_writes;
+	kstat_named_t dkv_nwritten;
+	kstat_named_t dkv_reads;
+	kstat_named_t dkv_nread;
+	/*
+	 * nunlinks is initialized to the unlinked set size on mount and
+	 * is incremented whenever a new entry is added to the unlinked set
+	 */
+	kstat_named_t dkv_nunlinks;
+	/*
+	 * nunlinked is initialized to zero on mount and is incremented when an
+	 * entry is removed from the unlinked set
+	 */
+	kstat_named_t dkv_nunlinked;
+} dataset_kstat_values_t;
+
+typedef struct dataset_kstats {
+	dataset_aggsum_stats_t dk_aggsums;
+	kstat_t *dk_kstats;
+} dataset_kstats_t;
+
+void dataset_kstats_create(dataset_kstats_t *, objset_t *);
+void dataset_kstats_destroy(dataset_kstats_t *);
+
+void dataset_kstats_update_write_kstats(dataset_kstats_t *, int64_t);
+void dataset_kstats_update_read_kstats(dataset_kstats_t *, int64_t);
+
+void dataset_kstats_update_nunlinks_kstat(dataset_kstats_t *, int64_t);
+void dataset_kstats_update_nunlinked_kstat(dataset_kstats_t *, int64_t);
+
+#endif /* _SYS_DATASET_KSTATS_H */
diff --git a/include/sys/dbuf.h b/include/sys/dbuf.h
new file mode 100644
index 0000000000000..04338b2c491b0
--- /dev/null
+++ b/include/sys/dbuf.h
@@ -0,0 +1,472 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ */
+
+#ifndef	_SYS_DBUF_H
+#define	_SYS_DBUF_H
+
+#include <sys/dmu.h>
+#include <sys/spa.h>
+#include <sys/txg.h>
+#include <sys/zio.h>
+#include <sys/arc.h>
+#include <sys/zfs_context.h>
+#include <sys/zfs_refcount.h>
+#include <sys/zrlock.h>
+#include <sys/multilist.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	IN_DMU_SYNC 2
+
+/*
+ * define flags for dbuf_read
+ */
+
+#define	DB_RF_MUST_SUCCEED	(1 << 0)
+#define	DB_RF_CANFAIL		(1 << 1)
+#define	DB_RF_HAVESTRUCT	(1 << 2)
+#define	DB_RF_NOPREFETCH	(1 << 3)
+#define	DB_RF_NEVERWAIT		(1 << 4)
+#define	DB_RF_CACHED		(1 << 5)
+#define	DB_RF_NO_DECRYPT	(1 << 6)
+
+/*
+ * The simplified state transition diagram for dbufs looks like:
+ *
+ *		+----> READ ----+
+ *		|		|
+ *		|		V
+ *  (alloc)-->UNCACHED	     CACHED-->EVICTING-->(free)
+ *		|		^	 ^
+ *		|		|	 |
+ *		+----> FILL ----+	 |
+ *		|			 |
+ *		|			 |
+ *		+--------> NOFILL -------+
+ *
+ * DB_SEARCH is an invalid state for a dbuf. It is used by dbuf_free_range
+ * to find all dbufs in a range of a dnode and must be less than any other
+ * dbuf_states_t (see comment on dn_dbufs in dnode.h).
+ */
+typedef enum dbuf_states {
+	DB_SEARCH = -1,
+	DB_UNCACHED,
+	DB_FILL,
+	DB_NOFILL,
+	DB_READ,
+	DB_CACHED,
+	DB_EVICTING
+} dbuf_states_t;
+
+typedef enum dbuf_cached_state {
+	DB_NO_CACHE = -1,
+	DB_DBUF_CACHE,
+	DB_DBUF_METADATA_CACHE,
+	DB_CACHE_MAX
+} dbuf_cached_state_t;
+
+struct dnode;
+struct dmu_tx;
+
+/*
+ * level = 0 means the user data
+ * level = 1 means the single indirect block
+ * etc.
+ */
+
+struct dmu_buf_impl;
+
+typedef enum override_states {
+	DR_NOT_OVERRIDDEN,
+	DR_IN_DMU_SYNC,
+	DR_OVERRIDDEN
+} override_states_t;
+
+typedef enum db_lock_type {
+	DLT_NONE,
+	DLT_PARENT,
+	DLT_OBJSET
+} db_lock_type_t;
+
+typedef struct dbuf_dirty_record {
+	/* link on our parents dirty list */
+	list_node_t dr_dirty_node;
+
+	/* transaction group this data will sync in */
+	uint64_t dr_txg;
+
+	/* zio of outstanding write IO */
+	zio_t *dr_zio;
+
+	/* pointer back to our dbuf */
+	struct dmu_buf_impl *dr_dbuf;
+
+	/* list link for dbuf dirty records */
+	list_node_t dr_dbuf_node;
+
+	/* pointer to parent dirty record */
+	struct dbuf_dirty_record *dr_parent;
+
+	/* How much space was changed to dsl_pool_dirty_space() for this? */
+	unsigned int dr_accounted;
+
+	/* A copy of the bp that points to us */
+	blkptr_t dr_bp_copy;
+
+	union dirty_types {
+		struct dirty_indirect {
+
+			/* protect access to list */
+			kmutex_t dr_mtx;
+
+			/* Our list of dirty children */
+			list_t dr_children;
+		} di;
+		struct dirty_leaf {
+
+			/*
+			 * dr_data is set when we dirty the buffer
+			 * so that we can retain the pointer even if it
+			 * gets COW'd in a subsequent transaction group.
+			 */
+			arc_buf_t *dr_data;
+			blkptr_t dr_overridden_by;
+			override_states_t dr_override_state;
+			uint8_t dr_copies;
+			boolean_t dr_nopwrite;
+			boolean_t dr_has_raw_params;
+
+			/*
+			 * If dr_has_raw_params is set, the following crypt
+			 * params will be set on the BP that's written.
+			 */
+			boolean_t dr_byteorder;
+			uint8_t	dr_salt[ZIO_DATA_SALT_LEN];
+			uint8_t	dr_iv[ZIO_DATA_IV_LEN];
+			uint8_t	dr_mac[ZIO_DATA_MAC_LEN];
+		} dl;
+	} dt;
+} dbuf_dirty_record_t;
+
+typedef struct dmu_buf_impl {
+	/*
+	 * The following members are immutable, with the exception of
+	 * db.db_data, which is protected by db_mtx.
+	 */
+
+	/* the publicly visible structure */
+	dmu_buf_t db;
+
+	/* the objset we belong to */
+	struct objset *db_objset;
+
+	/*
+	 * handle to safely access the dnode we belong to (NULL when evicted)
+	 */
+	struct dnode_handle *db_dnode_handle;
+
+	/*
+	 * our parent buffer; if the dnode points to us directly,
+	 * db_parent == db_dnode_handle->dnh_dnode->dn_dbuf
+	 * only accessed by sync thread ???
+	 * (NULL when evicted)
+	 * May change from NULL to non-NULL under the protection of db_mtx
+	 * (see dbuf_check_blkptr())
+	 */
+	struct dmu_buf_impl *db_parent;
+
+	/*
+	 * link for hash table of all dmu_buf_impl_t's
+	 */
+	struct dmu_buf_impl *db_hash_next;
+
+	/*
+	 * Our link on the owner dnodes's dn_dbufs list.
+	 * Protected by its dn_dbufs_mtx.  Should be on the same cache line
+	 * as db_level and db_blkid for the best avl_add() performance.
+	 */
+	avl_node_t db_link;
+
+	/* our block number */
+	uint64_t db_blkid;
+
+	/*
+	 * Pointer to the blkptr_t which points to us. May be NULL if we
+	 * don't have one yet. (NULL when evicted)
+	 */
+	blkptr_t *db_blkptr;
+
+	/*
+	 * Our indirection level.  Data buffers have db_level==0.
+	 * Indirect buffers which point to data buffers have
+	 * db_level==1. etc.  Buffers which contain dnodes have
+	 * db_level==0, since the dnodes are stored in a file.
+	 */
+	uint8_t db_level;
+
+	/*
+	 * Protects db_buf's contents if they contain an indirect block or data
+	 * block of the meta-dnode. We use this lock to protect the structure of
+	 * the block tree. This means that when modifying this dbuf's data, we
+	 * grab its rwlock. When modifying its parent's data (including the
+	 * blkptr to this dbuf), we grab the parent's rwlock. The lock ordering
+	 * for this lock is:
+	 * 1) dn_struct_rwlock
+	 * 2) db_rwlock
+	 * We don't currently grab multiple dbufs' db_rwlocks at once.
+	 */
+	krwlock_t db_rwlock;
+
+	/* buffer holding our data */
+	arc_buf_t *db_buf;
+
+	/* db_mtx protects the members below */
+	kmutex_t db_mtx;
+
+	/*
+	 * Current state of the buffer
+	 */
+	dbuf_states_t db_state;
+
+	/*
+	 * Refcount accessed by dmu_buf_{hold,rele}.
+	 * If nonzero, the buffer can't be destroyed.
+	 * Protected by db_mtx.
+	 */
+	zfs_refcount_t db_holds;
+
+	kcondvar_t db_changed;
+	dbuf_dirty_record_t *db_data_pending;
+
+	/* List of dirty records for the buffer sorted newest to oldest. */
+	list_t db_dirty_records;
+
+	/* Link in dbuf_cache or dbuf_metadata_cache */
+	multilist_node_t db_cache_link;
+
+	/* Tells us which dbuf cache this dbuf is in, if any */
+	dbuf_cached_state_t db_caching_status;
+
+	/* Data which is unique to data (leaf) blocks: */
+
+	/* User callback information. */
+	dmu_buf_user_t *db_user;
+
+	/*
+	 * Evict user data as soon as the dirty and reference
+	 * counts are equal.
+	 */
+	uint8_t db_user_immediate_evict;
+
+	/*
+	 * This block was freed while a read or write was
+	 * active.
+	 */
+	uint8_t db_freed_in_flight;
+
+	/*
+	 * dnode_evict_dbufs() or dnode_evict_bonus() tried to
+	 * evict this dbuf, but couldn't due to outstanding
+	 * references.  Evict once the refcount drops to 0.
+	 */
+	uint8_t db_pending_evict;
+
+	uint8_t db_dirtycnt;
+} dmu_buf_impl_t;
+
+/* Note: the dbuf hash table is exposed only for the mdb module */
+#define	DBUF_MUTEXES 8192
+#define	DBUF_HASH_MUTEX(h, idx) (&(h)->hash_mutexes[(idx) & (DBUF_MUTEXES-1)])
+typedef struct dbuf_hash_table {
+	uint64_t hash_table_mask;
+	dmu_buf_impl_t **hash_table;
+	kmutex_t hash_mutexes[DBUF_MUTEXES];
+} dbuf_hash_table_t;
+
+uint64_t dbuf_whichblock(const struct dnode *di, const int64_t level,
+    const uint64_t offset);
+
+void dbuf_create_bonus(struct dnode *dn);
+int dbuf_spill_set_blksz(dmu_buf_t *db, uint64_t blksz, dmu_tx_t *tx);
+
+void dbuf_rm_spill(struct dnode *dn, dmu_tx_t *tx);
+
+dmu_buf_impl_t *dbuf_hold(struct dnode *dn, uint64_t blkid, void *tag);
+dmu_buf_impl_t *dbuf_hold_level(struct dnode *dn, int level, uint64_t blkid,
+    void *tag);
+int dbuf_hold_impl(struct dnode *dn, uint8_t level, uint64_t blkid,
+    boolean_t fail_sparse, boolean_t fail_uncached,
+    void *tag, dmu_buf_impl_t **dbp);
+
+void dbuf_prefetch(struct dnode *dn, int64_t level, uint64_t blkid,
+    zio_priority_t prio, arc_flags_t aflags);
+
+void dbuf_add_ref(dmu_buf_impl_t *db, void *tag);
+boolean_t dbuf_try_add_ref(dmu_buf_t *db, objset_t *os, uint64_t obj,
+    uint64_t blkid, void *tag);
+uint64_t dbuf_refcount(dmu_buf_impl_t *db);
+
+void dbuf_rele(dmu_buf_impl_t *db, void *tag);
+void dbuf_rele_and_unlock(dmu_buf_impl_t *db, void *tag, boolean_t evicting);
+
+dmu_buf_impl_t *dbuf_find(struct objset *os, uint64_t object, uint8_t level,
+    uint64_t blkid);
+
+int dbuf_read(dmu_buf_impl_t *db, zio_t *zio, uint32_t flags);
+void dmu_buf_will_not_fill(dmu_buf_t *db, dmu_tx_t *tx);
+void dmu_buf_will_fill(dmu_buf_t *db, dmu_tx_t *tx);
+void dmu_buf_fill_done(dmu_buf_t *db, dmu_tx_t *tx);
+void dbuf_assign_arcbuf(dmu_buf_impl_t *db, arc_buf_t *buf, dmu_tx_t *tx);
+dbuf_dirty_record_t *dbuf_dirty(dmu_buf_impl_t *db, dmu_tx_t *tx);
+arc_buf_t *dbuf_loan_arcbuf(dmu_buf_impl_t *db);
+void dmu_buf_write_embedded(dmu_buf_t *dbuf, void *data,
+    bp_embedded_type_t etype, enum zio_compress comp,
+    int uncompressed_size, int compressed_size, int byteorder, dmu_tx_t *tx);
+
+void dmu_buf_redact(dmu_buf_t *dbuf, dmu_tx_t *tx);
+void dbuf_destroy(dmu_buf_impl_t *db);
+
+void dbuf_unoverride(dbuf_dirty_record_t *dr);
+void dbuf_sync_list(list_t *list, int level, dmu_tx_t *tx);
+void dbuf_release_bp(dmu_buf_impl_t *db);
+db_lock_type_t dmu_buf_lock_parent(dmu_buf_impl_t *db, krw_t rw, void *tag);
+void dmu_buf_unlock_parent(dmu_buf_impl_t *db, db_lock_type_t type, void *tag);
+
+void dbuf_free_range(struct dnode *dn, uint64_t start, uint64_t end,
+    struct dmu_tx *);
+
+void dbuf_new_size(dmu_buf_impl_t *db, int size, dmu_tx_t *tx);
+
+void dbuf_stats_init(dbuf_hash_table_t *hash);
+void dbuf_stats_destroy(void);
+
+int dbuf_dnode_findbp(dnode_t *dn, uint64_t level, uint64_t blkid,
+    blkptr_t *bp, uint16_t *datablkszsec, uint8_t *indblkshift);
+
+#define	DB_DNODE(_db)		((_db)->db_dnode_handle->dnh_dnode)
+#define	DB_DNODE_LOCK(_db)	((_db)->db_dnode_handle->dnh_zrlock)
+#define	DB_DNODE_ENTER(_db)	(zrl_add(&DB_DNODE_LOCK(_db)))
+#define	DB_DNODE_EXIT(_db)	(zrl_remove(&DB_DNODE_LOCK(_db)))
+#define	DB_DNODE_HELD(_db)	(!zrl_is_zero(&DB_DNODE_LOCK(_db)))
+
+void dbuf_init(void);
+void dbuf_fini(void);
+
+boolean_t dbuf_is_metadata(dmu_buf_impl_t *db);
+
+static inline dbuf_dirty_record_t *
+dbuf_find_dirty_lte(dmu_buf_impl_t *db, uint64_t txg)
+{
+	dbuf_dirty_record_t *dr;
+
+	for (dr = list_head(&db->db_dirty_records);
+	    dr != NULL && dr->dr_txg > txg;
+	    dr = list_next(&db->db_dirty_records, dr))
+		continue;
+	return (dr);
+}
+
+static inline dbuf_dirty_record_t *
+dbuf_find_dirty_eq(dmu_buf_impl_t *db, uint64_t txg)
+{
+	dbuf_dirty_record_t *dr;
+
+	dr = dbuf_find_dirty_lte(db, txg);
+	if (dr && dr->dr_txg == txg)
+		return (dr);
+	return (NULL);
+}
+
+#define	DBUF_GET_BUFC_TYPE(_db)	\
+	(dbuf_is_metadata(_db) ? ARC_BUFC_METADATA : ARC_BUFC_DATA)
+
+#define	DBUF_IS_CACHEABLE(_db)						\
+	((_db)->db_objset->os_primary_cache == ZFS_CACHE_ALL ||		\
+	(dbuf_is_metadata(_db) &&					\
+	((_db)->db_objset->os_primary_cache == ZFS_CACHE_METADATA)))
+
+#define	DBUF_IS_L2CACHEABLE(_db)					\
+	((_db)->db_objset->os_secondary_cache == ZFS_CACHE_ALL ||	\
+	(dbuf_is_metadata(_db) &&					\
+	((_db)->db_objset->os_secondary_cache == ZFS_CACHE_METADATA)))
+
+#define	DNODE_LEVEL_IS_L2CACHEABLE(_dn, _level)				\
+	((_dn)->dn_objset->os_secondary_cache == ZFS_CACHE_ALL ||	\
+	(((_level) > 0 ||						\
+	DMU_OT_IS_METADATA((_dn)->dn_handle->dnh_dnode->dn_type)) &&	\
+	((_dn)->dn_objset->os_secondary_cache == ZFS_CACHE_METADATA)))
+
+#ifdef ZFS_DEBUG
+
+/*
+ * There should be a ## between the string literal and fmt, to make it
+ * clear that we're joining two strings together, but gcc does not
+ * support that preprocessor token.
+ */
+#define	dprintf_dbuf(dbuf, fmt, ...) do { \
+	if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
+	char __db_buf[32]; \
+	uint64_t __db_obj = (dbuf)->db.db_object; \
+	if (__db_obj == DMU_META_DNODE_OBJECT) \
+		(void) strcpy(__db_buf, "mdn"); \
+	else \
+		(void) snprintf(__db_buf, sizeof (__db_buf), "%lld", \
+		    (u_longlong_t)__db_obj); \
+	dprintf_ds((dbuf)->db_objset->os_dsl_dataset, \
+	    "obj=%s lvl=%u blkid=%lld " fmt, \
+	    __db_buf, (dbuf)->db_level, \
+	    (u_longlong_t)(dbuf)->db_blkid, __VA_ARGS__); \
+	} \
+_NOTE(CONSTCOND) } while (0)
+
+#define	dprintf_dbuf_bp(db, bp, fmt, ...) do {			\
+	if (zfs_flags & ZFS_DEBUG_DPRINTF) {			\
+	char *__blkbuf = kmem_alloc(BP_SPRINTF_LEN, KM_SLEEP);	\
+	snprintf_blkptr(__blkbuf, BP_SPRINTF_LEN, bp);		\
+	dprintf_dbuf(db, fmt " %s\n", __VA_ARGS__, __blkbuf);	\
+	kmem_free(__blkbuf, BP_SPRINTF_LEN);			\
+	}							\
+_NOTE(CONSTCOND) } while (0)
+
+#define	DBUF_VERIFY(db)	dbuf_verify(db)
+
+#else
+
+#define	dprintf_dbuf(db, fmt, ...)
+#define	dprintf_dbuf_bp(db, bp, fmt, ...)
+#define	DBUF_VERIFY(db)
+
+#endif
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DBUF_H */
diff --git a/include/sys/ddt.h b/include/sys/ddt.h
new file mode 100644
index 0000000000000..25be6f56dddca
--- /dev/null
+++ b/include/sys/ddt.h
@@ -0,0 +1,257 @@
+/*
+ * 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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_DDT_H
+#define	_SYS_DDT_H
+
+#include <sys/sysmacros.h>
+#include <sys/types.h>
+#include <sys/fs/zfs.h>
+#include <sys/zio.h>
+#include <sys/dmu.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct abd;
+
+/*
+ * On-disk DDT formats, in the desired search order (newest version first).
+ */
+enum ddt_type {
+	DDT_TYPE_ZAP = 0,
+	DDT_TYPES
+};
+
+/*
+ * DDT classes, in the desired search order (highest replication level first).
+ */
+enum ddt_class {
+	DDT_CLASS_DITTO = 0,
+	DDT_CLASS_DUPLICATE,
+	DDT_CLASS_UNIQUE,
+	DDT_CLASSES
+};
+
+#define	DDT_TYPE_CURRENT		0
+
+#define	DDT_COMPRESS_BYTEORDER_MASK	0x80
+#define	DDT_COMPRESS_FUNCTION_MASK	0x7f
+
+/*
+ * On-disk ddt entry:  key (name) and physical storage (value).
+ */
+typedef struct ddt_key {
+	zio_cksum_t	ddk_cksum;	/* 256-bit block checksum */
+	/*
+	 * Encoded with logical & physical size, encryption, and compression,
+	 * as follows:
+	 *   +-------+-------+-------+-------+-------+-------+-------+-------+
+	 *   |   0   |   0   |   0   |X| comp|     PSIZE     |     LSIZE     |
+	 *   +-------+-------+-------+-------+-------+-------+-------+-------+
+	 */
+	uint64_t	ddk_prop;
+} ddt_key_t;
+
+#define	DDK_GET_LSIZE(ddk)	\
+	BF64_GET_SB((ddk)->ddk_prop, 0, 16, SPA_MINBLOCKSHIFT, 1)
+#define	DDK_SET_LSIZE(ddk, x)	\
+	BF64_SET_SB((ddk)->ddk_prop, 0, 16, SPA_MINBLOCKSHIFT, 1, x)
+
+#define	DDK_GET_PSIZE(ddk)	\
+	BF64_GET_SB((ddk)->ddk_prop, 16, 16, SPA_MINBLOCKSHIFT, 1)
+#define	DDK_SET_PSIZE(ddk, x)	\
+	BF64_SET_SB((ddk)->ddk_prop, 16, 16, SPA_MINBLOCKSHIFT, 1, x)
+
+#define	DDK_GET_COMPRESS(ddk)		BF64_GET((ddk)->ddk_prop, 32, 7)
+#define	DDK_SET_COMPRESS(ddk, x)	BF64_SET((ddk)->ddk_prop, 32, 7, x)
+
+#define	DDK_GET_CRYPT(ddk)		BF64_GET((ddk)->ddk_prop, 39, 1)
+#define	DDK_SET_CRYPT(ddk, x)	BF64_SET((ddk)->ddk_prop, 39, 1, x)
+
+#define	DDT_KEY_WORDS	(sizeof (ddt_key_t) / sizeof (uint64_t))
+
+#define	DDE_GET_NDVAS(dde) (DDK_GET_CRYPT(&dde->dde_key) \
+	? SPA_DVAS_PER_BP - 1 : SPA_DVAS_PER_BP)
+
+typedef struct ddt_phys {
+	dva_t		ddp_dva[SPA_DVAS_PER_BP];
+	uint64_t	ddp_refcnt;
+	uint64_t	ddp_phys_birth;
+} ddt_phys_t;
+
+/*
+ * Note, we no longer generate new DDT_PHYS_DITTO-type blocks.  However,
+ * we maintain the ability to free existing dedup-ditto blocks.
+ */
+enum ddt_phys_type {
+	DDT_PHYS_DITTO = 0,
+	DDT_PHYS_SINGLE = 1,
+	DDT_PHYS_DOUBLE = 2,
+	DDT_PHYS_TRIPLE = 3,
+	DDT_PHYS_TYPES
+};
+
+/*
+ * In-core ddt entry
+ */
+struct ddt_entry {
+	ddt_key_t	dde_key;
+	ddt_phys_t	dde_phys[DDT_PHYS_TYPES];
+	zio_t		*dde_lead_zio[DDT_PHYS_TYPES];
+	struct abd	*dde_repair_abd;
+	enum ddt_type	dde_type;
+	enum ddt_class	dde_class;
+	uint8_t		dde_loading;
+	uint8_t		dde_loaded;
+	kcondvar_t	dde_cv;
+	avl_node_t	dde_node;
+};
+
+/*
+ * In-core ddt
+ */
+struct ddt {
+	kmutex_t	ddt_lock;
+	avl_tree_t	ddt_tree;
+	avl_tree_t	ddt_repair_tree;
+	enum zio_checksum ddt_checksum;
+	spa_t		*ddt_spa;
+	objset_t	*ddt_os;
+	uint64_t	ddt_stat_object;
+	uint64_t	ddt_object[DDT_TYPES][DDT_CLASSES];
+	ddt_histogram_t	ddt_histogram[DDT_TYPES][DDT_CLASSES];
+	ddt_histogram_t	ddt_histogram_cache[DDT_TYPES][DDT_CLASSES];
+	ddt_object_t	ddt_object_stats[DDT_TYPES][DDT_CLASSES];
+	avl_node_t	ddt_node;
+};
+
+/*
+ * In-core and on-disk bookmark for DDT walks
+ */
+typedef struct ddt_bookmark {
+	uint64_t	ddb_class;
+	uint64_t	ddb_type;
+	uint64_t	ddb_checksum;
+	uint64_t	ddb_cursor;
+} ddt_bookmark_t;
+
+/*
+ * Ops vector to access a specific DDT object type.
+ */
+typedef struct ddt_ops {
+	char ddt_op_name[32];
+	int (*ddt_op_create)(objset_t *os, uint64_t *object, dmu_tx_t *tx,
+	    boolean_t prehash);
+	int (*ddt_op_destroy)(objset_t *os, uint64_t object, dmu_tx_t *tx);
+	int (*ddt_op_lookup)(objset_t *os, uint64_t object, ddt_entry_t *dde);
+	void (*ddt_op_prefetch)(objset_t *os, uint64_t object,
+	    ddt_entry_t *dde);
+	int (*ddt_op_update)(objset_t *os, uint64_t object, ddt_entry_t *dde,
+	    dmu_tx_t *tx);
+	int (*ddt_op_remove)(objset_t *os, uint64_t object, ddt_entry_t *dde,
+	    dmu_tx_t *tx);
+	int (*ddt_op_walk)(objset_t *os, uint64_t object, ddt_entry_t *dde,
+	    uint64_t *walk);
+	int (*ddt_op_count)(objset_t *os, uint64_t object, uint64_t *count);
+} ddt_ops_t;
+
+#define	DDT_NAMELEN	107
+
+extern void ddt_object_name(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, char *name);
+extern int ddt_object_walk(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, uint64_t *walk, ddt_entry_t *dde);
+extern int ddt_object_count(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, uint64_t *count);
+extern int ddt_object_info(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, dmu_object_info_t *);
+extern boolean_t ddt_object_exists(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz);
+
+extern void ddt_bp_fill(const ddt_phys_t *ddp, blkptr_t *bp,
+    uint64_t txg);
+extern void ddt_bp_create(enum zio_checksum checksum, const ddt_key_t *ddk,
+    const ddt_phys_t *ddp, blkptr_t *bp);
+
+extern void ddt_key_fill(ddt_key_t *ddk, const blkptr_t *bp);
+
+extern void ddt_phys_fill(ddt_phys_t *ddp, const blkptr_t *bp);
+extern void ddt_phys_clear(ddt_phys_t *ddp);
+extern void ddt_phys_addref(ddt_phys_t *ddp);
+extern void ddt_phys_decref(ddt_phys_t *ddp);
+extern void ddt_phys_free(ddt_t *ddt, ddt_key_t *ddk, ddt_phys_t *ddp,
+    uint64_t txg);
+extern ddt_phys_t *ddt_phys_select(const ddt_entry_t *dde, const blkptr_t *bp);
+extern uint64_t ddt_phys_total_refcnt(const ddt_entry_t *dde);
+
+extern void ddt_stat_add(ddt_stat_t *dst, const ddt_stat_t *src, uint64_t neg);
+
+extern void ddt_histogram_add(ddt_histogram_t *dst, const ddt_histogram_t *src);
+extern void ddt_histogram_stat(ddt_stat_t *dds, const ddt_histogram_t *ddh);
+extern boolean_t ddt_histogram_empty(const ddt_histogram_t *ddh);
+extern void ddt_get_dedup_object_stats(spa_t *spa, ddt_object_t *ddo);
+extern void ddt_get_dedup_histogram(spa_t *spa, ddt_histogram_t *ddh);
+extern void ddt_get_dedup_stats(spa_t *spa, ddt_stat_t *dds_total);
+
+extern uint64_t ddt_get_dedup_dspace(spa_t *spa);
+extern uint64_t ddt_get_pool_dedup_ratio(spa_t *spa);
+
+extern size_t ddt_compress(void *src, uchar_t *dst, size_t s_len, size_t d_len);
+extern void ddt_decompress(uchar_t *src, void *dst, size_t s_len, size_t d_len);
+
+extern ddt_t *ddt_select(spa_t *spa, const blkptr_t *bp);
+extern void ddt_enter(ddt_t *ddt);
+extern void ddt_exit(ddt_t *ddt);
+extern void ddt_init(void);
+extern void ddt_fini(void);
+extern ddt_entry_t *ddt_lookup(ddt_t *ddt, const blkptr_t *bp, boolean_t add);
+extern void ddt_prefetch(spa_t *spa, const blkptr_t *bp);
+extern void ddt_remove(ddt_t *ddt, ddt_entry_t *dde);
+
+extern boolean_t ddt_class_contains(spa_t *spa, enum ddt_class max_class,
+    const blkptr_t *bp);
+
+extern ddt_entry_t *ddt_repair_start(ddt_t *ddt, const blkptr_t *bp);
+extern void ddt_repair_done(ddt_t *ddt, ddt_entry_t *dde);
+
+extern int ddt_entry_compare(const void *x1, const void *x2);
+
+extern void ddt_create(spa_t *spa);
+extern int ddt_load(spa_t *spa);
+extern void ddt_unload(spa_t *spa);
+extern void ddt_sync(spa_t *spa, uint64_t txg);
+extern int ddt_walk(spa_t *spa, ddt_bookmark_t *ddb, ddt_entry_t *dde);
+extern int ddt_object_update(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, ddt_entry_t *dde, dmu_tx_t *tx);
+
+extern const ddt_ops_t ddt_zap_ops;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DDT_H */
diff --git a/include/sys/dmu.h b/include/sys/dmu.h
new file mode 100644
index 0000000000000..d6efe2595be00
--- /dev/null
+++ b/include/sys/dmu.h
@@ -0,0 +1,1090 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
+ * Copyright (c) 2012, Joyent, Inc. All rights reserved.
+ * Copyright 2014 HybridCluster. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ * Copyright 2013 Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2017, Intel Corporation.
+ */
+
+/* Portions Copyright 2010 Robert Milkowski */
+
+#ifndef	_SYS_DMU_H
+#define	_SYS_DMU_H
+
+/*
+ * This file describes the interface that the DMU provides for its
+ * consumers.
+ *
+ * The DMU also interacts with the SPA.  That interface is described in
+ * dmu_spa.h.
+ */
+
+#include <sys/zfs_context.h>
+#include <sys/inttypes.h>
+#include <sys/cred.h>
+#include <sys/fs/zfs.h>
+#include <sys/zio_compress.h>
+#include <sys/zio_priority.h>
+#include <sys/uio.h>
+#include <sys/zfs_file.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct page;
+struct vnode;
+struct spa;
+struct zilog;
+struct zio;
+struct blkptr;
+struct zap_cursor;
+struct dsl_dataset;
+struct dsl_pool;
+struct dnode;
+struct drr_begin;
+struct drr_end;
+struct zbookmark_phys;
+struct spa;
+struct nvlist;
+struct arc_buf;
+struct zio_prop;
+struct sa_handle;
+struct dsl_crypto_params;
+struct locked_range;
+
+typedef struct objset objset_t;
+typedef struct dmu_tx dmu_tx_t;
+typedef struct dsl_dir dsl_dir_t;
+typedef struct dnode dnode_t;
+
+typedef enum dmu_object_byteswap {
+	DMU_BSWAP_UINT8,
+	DMU_BSWAP_UINT16,
+	DMU_BSWAP_UINT32,
+	DMU_BSWAP_UINT64,
+	DMU_BSWAP_ZAP,
+	DMU_BSWAP_DNODE,
+	DMU_BSWAP_OBJSET,
+	DMU_BSWAP_ZNODE,
+	DMU_BSWAP_OLDACL,
+	DMU_BSWAP_ACL,
+	/*
+	 * Allocating a new byteswap type number makes the on-disk format
+	 * incompatible with any other format that uses the same number.
+	 *
+	 * Data can usually be structured to work with one of the
+	 * DMU_BSWAP_UINT* or DMU_BSWAP_ZAP types.
+	 */
+	DMU_BSWAP_NUMFUNCS
+} dmu_object_byteswap_t;
+
+#define	DMU_OT_NEWTYPE 0x80
+#define	DMU_OT_METADATA 0x40
+#define	DMU_OT_ENCRYPTED 0x20
+#define	DMU_OT_BYTESWAP_MASK 0x1f
+
+/*
+ * Defines a uint8_t object type. Object types specify if the data
+ * in the object is metadata (boolean) and how to byteswap the data
+ * (dmu_object_byteswap_t). All of the types created by this method
+ * are cached in the dbuf metadata cache.
+ */
+#define	DMU_OT(byteswap, metadata, encrypted) \
+	(DMU_OT_NEWTYPE | \
+	((metadata) ? DMU_OT_METADATA : 0) | \
+	((encrypted) ? DMU_OT_ENCRYPTED : 0) | \
+	((byteswap) & DMU_OT_BYTESWAP_MASK))
+
+#define	DMU_OT_IS_VALID(ot) (((ot) & DMU_OT_NEWTYPE) ? \
+	((ot) & DMU_OT_BYTESWAP_MASK) < DMU_BSWAP_NUMFUNCS : \
+	(ot) < DMU_OT_NUMTYPES)
+
+#define	DMU_OT_IS_METADATA_CACHED(ot) (((ot) & DMU_OT_NEWTYPE) ? \
+	B_TRUE : dmu_ot[(ot)].ot_dbuf_metadata_cache)
+
+/*
+ * MDB doesn't have dmu_ot; it defines these macros itself.
+ */
+#ifndef ZFS_MDB
+#define	DMU_OT_IS_METADATA_IMPL(ot) (dmu_ot[ot].ot_metadata)
+#define	DMU_OT_IS_ENCRYPTED_IMPL(ot) (dmu_ot[ot].ot_encrypt)
+#define	DMU_OT_BYTESWAP_IMPL(ot) (dmu_ot[ot].ot_byteswap)
+#endif
+
+#define	DMU_OT_IS_METADATA(ot) (((ot) & DMU_OT_NEWTYPE) ? \
+	((ot) & DMU_OT_METADATA) : \
+	DMU_OT_IS_METADATA_IMPL(ot))
+
+#define	DMU_OT_IS_DDT(ot) \
+	((ot) == DMU_OT_DDT_ZAP)
+
+#define	DMU_OT_IS_ZIL(ot) \
+	((ot) == DMU_OT_INTENT_LOG)
+
+/* Note: ztest uses DMU_OT_UINT64_OTHER as a proxy for file blocks */
+#define	DMU_OT_IS_FILE(ot) \
+	((ot) == DMU_OT_PLAIN_FILE_CONTENTS || (ot) == DMU_OT_UINT64_OTHER)
+
+#define	DMU_OT_IS_ENCRYPTED(ot) (((ot) & DMU_OT_NEWTYPE) ? \
+	((ot) & DMU_OT_ENCRYPTED) : \
+	DMU_OT_IS_ENCRYPTED_IMPL(ot))
+
+/*
+ * These object types use bp_fill != 1 for their L0 bp's. Therefore they can't
+ * have their data embedded (i.e. use a BP_IS_EMBEDDED() bp), because bp_fill
+ * is repurposed for embedded BPs.
+ */
+#define	DMU_OT_HAS_FILL(ot) \
+	((ot) == DMU_OT_DNODE || (ot) == DMU_OT_OBJSET)
+
+#define	DMU_OT_BYTESWAP(ot) (((ot) & DMU_OT_NEWTYPE) ? \
+	((ot) & DMU_OT_BYTESWAP_MASK) : \
+	DMU_OT_BYTESWAP_IMPL(ot))
+
+typedef enum dmu_object_type {
+	DMU_OT_NONE,
+	/* general: */
+	DMU_OT_OBJECT_DIRECTORY,	/* ZAP */
+	DMU_OT_OBJECT_ARRAY,		/* UINT64 */
+	DMU_OT_PACKED_NVLIST,		/* UINT8 (XDR by nvlist_pack/unpack) */
+	DMU_OT_PACKED_NVLIST_SIZE,	/* UINT64 */
+	DMU_OT_BPOBJ,			/* UINT64 */
+	DMU_OT_BPOBJ_HDR,		/* UINT64 */
+	/* spa: */
+	DMU_OT_SPACE_MAP_HEADER,	/* UINT64 */
+	DMU_OT_SPACE_MAP,		/* UINT64 */
+	/* zil: */
+	DMU_OT_INTENT_LOG,		/* UINT64 */
+	/* dmu: */
+	DMU_OT_DNODE,			/* DNODE */
+	DMU_OT_OBJSET,			/* OBJSET */
+	/* dsl: */
+	DMU_OT_DSL_DIR,			/* UINT64 */
+	DMU_OT_DSL_DIR_CHILD_MAP,	/* ZAP */
+	DMU_OT_DSL_DS_SNAP_MAP,		/* ZAP */
+	DMU_OT_DSL_PROPS,		/* ZAP */
+	DMU_OT_DSL_DATASET,		/* UINT64 */
+	/* zpl: */
+	DMU_OT_ZNODE,			/* ZNODE */
+	DMU_OT_OLDACL,			/* Old ACL */
+	DMU_OT_PLAIN_FILE_CONTENTS,	/* UINT8 */
+	DMU_OT_DIRECTORY_CONTENTS,	/* ZAP */
+	DMU_OT_MASTER_NODE,		/* ZAP */
+	DMU_OT_UNLINKED_SET,		/* ZAP */
+	/* zvol: */
+	DMU_OT_ZVOL,			/* UINT8 */
+	DMU_OT_ZVOL_PROP,		/* ZAP */
+	/* other; for testing only! */
+	DMU_OT_PLAIN_OTHER,		/* UINT8 */
+	DMU_OT_UINT64_OTHER,		/* UINT64 */
+	DMU_OT_ZAP_OTHER,		/* ZAP */
+	/* new object types: */
+	DMU_OT_ERROR_LOG,		/* ZAP */
+	DMU_OT_SPA_HISTORY,		/* UINT8 */
+	DMU_OT_SPA_HISTORY_OFFSETS,	/* spa_his_phys_t */
+	DMU_OT_POOL_PROPS,		/* ZAP */
+	DMU_OT_DSL_PERMS,		/* ZAP */
+	DMU_OT_ACL,			/* ACL */
+	DMU_OT_SYSACL,			/* SYSACL */
+	DMU_OT_FUID,			/* FUID table (Packed NVLIST UINT8) */
+	DMU_OT_FUID_SIZE,		/* FUID table size UINT64 */
+	DMU_OT_NEXT_CLONES,		/* ZAP */
+	DMU_OT_SCAN_QUEUE,		/* ZAP */
+	DMU_OT_USERGROUP_USED,		/* ZAP */
+	DMU_OT_USERGROUP_QUOTA,		/* ZAP */
+	DMU_OT_USERREFS,		/* ZAP */
+	DMU_OT_DDT_ZAP,			/* ZAP */
+	DMU_OT_DDT_STATS,		/* ZAP */
+	DMU_OT_SA,			/* System attr */
+	DMU_OT_SA_MASTER_NODE,		/* ZAP */
+	DMU_OT_SA_ATTR_REGISTRATION,	/* ZAP */
+	DMU_OT_SA_ATTR_LAYOUTS,		/* ZAP */
+	DMU_OT_SCAN_XLATE,		/* ZAP */
+	DMU_OT_DEDUP,			/* fake dedup BP from ddt_bp_create() */
+	DMU_OT_DEADLIST,		/* ZAP */
+	DMU_OT_DEADLIST_HDR,		/* UINT64 */
+	DMU_OT_DSL_CLONES,		/* ZAP */
+	DMU_OT_BPOBJ_SUBOBJ,		/* UINT64 */
+	/*
+	 * Do not allocate new object types here. Doing so makes the on-disk
+	 * format incompatible with any other format that uses the same object
+	 * type number.
+	 *
+	 * When creating an object which does not have one of the above types
+	 * use the DMU_OTN_* type with the correct byteswap and metadata
+	 * values.
+	 *
+	 * The DMU_OTN_* types do not have entries in the dmu_ot table,
+	 * use the DMU_OT_IS_METADATA() and DMU_OT_BYTESWAP() macros instead
+	 * of indexing into dmu_ot directly (this works for both DMU_OT_* types
+	 * and DMU_OTN_* types).
+	 */
+	DMU_OT_NUMTYPES,
+
+	/*
+	 * Names for valid types declared with DMU_OT().
+	 */
+	DMU_OTN_UINT8_DATA = DMU_OT(DMU_BSWAP_UINT8, B_FALSE, B_FALSE),
+	DMU_OTN_UINT8_METADATA = DMU_OT(DMU_BSWAP_UINT8, B_TRUE, B_FALSE),
+	DMU_OTN_UINT16_DATA = DMU_OT(DMU_BSWAP_UINT16, B_FALSE, B_FALSE),
+	DMU_OTN_UINT16_METADATA = DMU_OT(DMU_BSWAP_UINT16, B_TRUE, B_FALSE),
+	DMU_OTN_UINT32_DATA = DMU_OT(DMU_BSWAP_UINT32, B_FALSE, B_FALSE),
+	DMU_OTN_UINT32_METADATA = DMU_OT(DMU_BSWAP_UINT32, B_TRUE, B_FALSE),
+	DMU_OTN_UINT64_DATA = DMU_OT(DMU_BSWAP_UINT64, B_FALSE, B_FALSE),
+	DMU_OTN_UINT64_METADATA = DMU_OT(DMU_BSWAP_UINT64, B_TRUE, B_FALSE),
+	DMU_OTN_ZAP_DATA = DMU_OT(DMU_BSWAP_ZAP, B_FALSE, B_FALSE),
+	DMU_OTN_ZAP_METADATA = DMU_OT(DMU_BSWAP_ZAP, B_TRUE, B_FALSE),
+
+	DMU_OTN_UINT8_ENC_DATA = DMU_OT(DMU_BSWAP_UINT8, B_FALSE, B_TRUE),
+	DMU_OTN_UINT8_ENC_METADATA = DMU_OT(DMU_BSWAP_UINT8, B_TRUE, B_TRUE),
+	DMU_OTN_UINT16_ENC_DATA = DMU_OT(DMU_BSWAP_UINT16, B_FALSE, B_TRUE),
+	DMU_OTN_UINT16_ENC_METADATA = DMU_OT(DMU_BSWAP_UINT16, B_TRUE, B_TRUE),
+	DMU_OTN_UINT32_ENC_DATA = DMU_OT(DMU_BSWAP_UINT32, B_FALSE, B_TRUE),
+	DMU_OTN_UINT32_ENC_METADATA = DMU_OT(DMU_BSWAP_UINT32, B_TRUE, B_TRUE),
+	DMU_OTN_UINT64_ENC_DATA = DMU_OT(DMU_BSWAP_UINT64, B_FALSE, B_TRUE),
+	DMU_OTN_UINT64_ENC_METADATA = DMU_OT(DMU_BSWAP_UINT64, B_TRUE, B_TRUE),
+	DMU_OTN_ZAP_ENC_DATA = DMU_OT(DMU_BSWAP_ZAP, B_FALSE, B_TRUE),
+	DMU_OTN_ZAP_ENC_METADATA = DMU_OT(DMU_BSWAP_ZAP, B_TRUE, B_TRUE),
+} dmu_object_type_t;
+
+/*
+ * These flags are intended to be used to specify the "txg_how"
+ * parameter when calling the dmu_tx_assign() function. See the comment
+ * above dmu_tx_assign() for more details on the meaning of these flags.
+ */
+#define	TXG_NOWAIT	(0ULL)
+#define	TXG_WAIT	(1ULL<<0)
+#define	TXG_NOTHROTTLE	(1ULL<<1)
+
+void byteswap_uint64_array(void *buf, size_t size);
+void byteswap_uint32_array(void *buf, size_t size);
+void byteswap_uint16_array(void *buf, size_t size);
+void byteswap_uint8_array(void *buf, size_t size);
+void zap_byteswap(void *buf, size_t size);
+void zfs_oldacl_byteswap(void *buf, size_t size);
+void zfs_acl_byteswap(void *buf, size_t size);
+void zfs_znode_byteswap(void *buf, size_t size);
+
+#define	DS_FIND_SNAPSHOTS	(1<<0)
+#define	DS_FIND_CHILDREN	(1<<1)
+#define	DS_FIND_SERIALIZE	(1<<2)
+
+/*
+ * The maximum number of bytes that can be accessed as part of one
+ * operation, including metadata.
+ */
+#define	DMU_MAX_ACCESS (64 * 1024 * 1024) /* 64MB */
+#define	DMU_MAX_DELETEBLKCNT (20480) /* ~5MB of indirect blocks */
+
+#define	DMU_USERUSED_OBJECT	(-1ULL)
+#define	DMU_GROUPUSED_OBJECT	(-2ULL)
+#define	DMU_PROJECTUSED_OBJECT	(-3ULL)
+
+/*
+ * Zap prefix for object accounting in DMU_{USER,GROUP,PROJECT}USED_OBJECT.
+ */
+#define	DMU_OBJACCT_PREFIX	"obj-"
+#define	DMU_OBJACCT_PREFIX_LEN	4
+
+/*
+ * artificial blkids for bonus buffer and spill blocks
+ */
+#define	DMU_BONUS_BLKID		(-1ULL)
+#define	DMU_SPILL_BLKID		(-2ULL)
+
+/*
+ * Public routines to create, destroy, open, and close objsets.
+ */
+typedef void dmu_objset_create_sync_func_t(objset_t *os, void *arg,
+    cred_t *cr, dmu_tx_t *tx);
+
+int dmu_objset_hold(const char *name, void *tag, objset_t **osp);
+int dmu_objset_own(const char *name, dmu_objset_type_t type,
+    boolean_t readonly, boolean_t key_required, void *tag, objset_t **osp);
+void dmu_objset_rele(objset_t *os, void *tag);
+void dmu_objset_disown(objset_t *os, boolean_t key_required, void *tag);
+int dmu_objset_open_ds(struct dsl_dataset *ds, objset_t **osp);
+
+void dmu_objset_evict_dbufs(objset_t *os);
+int dmu_objset_create(const char *name, dmu_objset_type_t type, uint64_t flags,
+    struct dsl_crypto_params *dcp, dmu_objset_create_sync_func_t func,
+    void *arg);
+int dmu_objset_clone(const char *name, const char *origin);
+int dsl_destroy_snapshots_nvl(struct nvlist *snaps, boolean_t defer,
+    struct nvlist *errlist);
+int dmu_objset_snapshot_one(const char *fsname, const char *snapname);
+int dmu_objset_snapshot_tmp(const char *, const char *, int);
+int dmu_objset_find(const char *name, int func(const char *, void *), void *arg,
+    int flags);
+void dmu_objset_byteswap(void *buf, size_t size);
+int dsl_dataset_rename_snapshot(const char *fsname,
+    const char *oldsnapname, const char *newsnapname, boolean_t recursive);
+
+typedef struct dmu_buf {
+	uint64_t db_object;		/* object that this buffer is part of */
+	uint64_t db_offset;		/* byte offset in this object */
+	uint64_t db_size;		/* size of buffer in bytes */
+	void *db_data;			/* data in buffer */
+} dmu_buf_t;
+
+/*
+ * The names of zap entries in the DIRECTORY_OBJECT of the MOS.
+ */
+#define	DMU_POOL_DIRECTORY_OBJECT	1
+#define	DMU_POOL_CONFIG			"config"
+#define	DMU_POOL_FEATURES_FOR_WRITE	"features_for_write"
+#define	DMU_POOL_FEATURES_FOR_READ	"features_for_read"
+#define	DMU_POOL_FEATURE_DESCRIPTIONS	"feature_descriptions"
+#define	DMU_POOL_FEATURE_ENABLED_TXG	"feature_enabled_txg"
+#define	DMU_POOL_ROOT_DATASET		"root_dataset"
+#define	DMU_POOL_SYNC_BPOBJ		"sync_bplist"
+#define	DMU_POOL_ERRLOG_SCRUB		"errlog_scrub"
+#define	DMU_POOL_ERRLOG_LAST		"errlog_last"
+#define	DMU_POOL_SPARES			"spares"
+#define	DMU_POOL_DEFLATE		"deflate"
+#define	DMU_POOL_HISTORY		"history"
+#define	DMU_POOL_PROPS			"pool_props"
+#define	DMU_POOL_L2CACHE		"l2cache"
+#define	DMU_POOL_TMP_USERREFS		"tmp_userrefs"
+#define	DMU_POOL_DDT			"DDT-%s-%s-%s"
+#define	DMU_POOL_DDT_STATS		"DDT-statistics"
+#define	DMU_POOL_CREATION_VERSION	"creation_version"
+#define	DMU_POOL_SCAN			"scan"
+#define	DMU_POOL_FREE_BPOBJ		"free_bpobj"
+#define	DMU_POOL_BPTREE_OBJ		"bptree_obj"
+#define	DMU_POOL_EMPTY_BPOBJ		"empty_bpobj"
+#define	DMU_POOL_CHECKSUM_SALT		"org.illumos:checksum_salt"
+#define	DMU_POOL_VDEV_ZAP_MAP		"com.delphix:vdev_zap_map"
+#define	DMU_POOL_REMOVING		"com.delphix:removing"
+#define	DMU_POOL_OBSOLETE_BPOBJ		"com.delphix:obsolete_bpobj"
+#define	DMU_POOL_CONDENSING_INDIRECT	"com.delphix:condensing_indirect"
+#define	DMU_POOL_ZPOOL_CHECKPOINT	"com.delphix:zpool_checkpoint"
+#define	DMU_POOL_LOG_SPACEMAP_ZAP	"com.delphix:log_spacemap_zap"
+#define	DMU_POOL_DELETED_CLONES		"com.delphix:deleted_clones"
+
+/*
+ * Allocate an object from this objset.  The range of object numbers
+ * available is (0, DN_MAX_OBJECT).  Object 0 is the meta-dnode.
+ *
+ * The transaction must be assigned to a txg.  The newly allocated
+ * object will be "held" in the transaction (ie. you can modify the
+ * newly allocated object in this transaction).
+ *
+ * dmu_object_alloc() chooses an object and returns it in *objectp.
+ *
+ * dmu_object_claim() allocates a specific object number.  If that
+ * number is already allocated, it fails and returns EEXIST.
+ *
+ * Return 0 on success, or ENOSPC or EEXIST as specified above.
+ */
+uint64_t dmu_object_alloc(objset_t *os, dmu_object_type_t ot,
+    int blocksize, dmu_object_type_t bonus_type, int bonus_len, dmu_tx_t *tx);
+uint64_t dmu_object_alloc_ibs(objset_t *os, dmu_object_type_t ot, int blocksize,
+    int indirect_blockshift,
+    dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx);
+uint64_t dmu_object_alloc_dnsize(objset_t *os, dmu_object_type_t ot,
+    int blocksize, dmu_object_type_t bonus_type, int bonus_len,
+    int dnodesize, dmu_tx_t *tx);
+uint64_t dmu_object_alloc_hold(objset_t *os, dmu_object_type_t ot,
+    int blocksize, int indirect_blockshift, dmu_object_type_t bonustype,
+    int bonuslen, int dnodesize, dnode_t **allocated_dnode, void *tag,
+    dmu_tx_t *tx);
+int dmu_object_claim(objset_t *os, uint64_t object, dmu_object_type_t ot,
+    int blocksize, dmu_object_type_t bonus_type, int bonus_len, dmu_tx_t *tx);
+int dmu_object_claim_dnsize(objset_t *os, uint64_t object, dmu_object_type_t ot,
+    int blocksize, dmu_object_type_t bonus_type, int bonus_len,
+    int dnodesize, dmu_tx_t *tx);
+int dmu_object_reclaim(objset_t *os, uint64_t object, dmu_object_type_t ot,
+    int blocksize, dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *txp);
+int dmu_object_reclaim_dnsize(objset_t *os, uint64_t object,
+    dmu_object_type_t ot, int blocksize, dmu_object_type_t bonustype,
+    int bonuslen, int dnodesize, boolean_t keep_spill, dmu_tx_t *tx);
+int dmu_object_rm_spill(objset_t *os, uint64_t object, dmu_tx_t *tx);
+
+/*
+ * Free an object from this objset.
+ *
+ * The object's data will be freed as well (ie. you don't need to call
+ * dmu_free(object, 0, -1, tx)).
+ *
+ * The object need not be held in the transaction.
+ *
+ * If there are any holds on this object's buffers (via dmu_buf_hold()),
+ * or tx holds on the object (via dmu_tx_hold_object()), you can not
+ * free it; it fails and returns EBUSY.
+ *
+ * If the object is not allocated, it fails and returns ENOENT.
+ *
+ * Return 0 on success, or EBUSY or ENOENT as specified above.
+ */
+int dmu_object_free(objset_t *os, uint64_t object, dmu_tx_t *tx);
+
+/*
+ * Find the next allocated or free object.
+ *
+ * The objectp parameter is in-out.  It will be updated to be the next
+ * object which is allocated.  Ignore objects which have not been
+ * modified since txg.
+ *
+ * XXX Can only be called on a objset with no dirty data.
+ *
+ * Returns 0 on success, or ENOENT if there are no more objects.
+ */
+int dmu_object_next(objset_t *os, uint64_t *objectp,
+    boolean_t hole, uint64_t txg);
+
+/*
+ * Set the number of levels on a dnode. nlevels must be greater than the
+ * current number of levels or an EINVAL will be returned.
+ */
+int dmu_object_set_nlevels(objset_t *os, uint64_t object, int nlevels,
+    dmu_tx_t *tx);
+
+/*
+ * Set the data blocksize for an object.
+ *
+ * The object cannot have any blocks allocated beyond the first.  If
+ * the first block is allocated already, the new size must be greater
+ * than the current block size.  If these conditions are not met,
+ * ENOTSUP will be returned.
+ *
+ * Returns 0 on success, or EBUSY if there are any holds on the object
+ * contents, or ENOTSUP as described above.
+ */
+int dmu_object_set_blocksize(objset_t *os, uint64_t object, uint64_t size,
+    int ibs, dmu_tx_t *tx);
+
+/*
+ * Manually set the maxblkid on a dnode. This will adjust nlevels accordingly
+ * to accommodate the change. When calling this function, the caller must
+ * ensure that the object's nlevels can sufficiently support the new maxblkid.
+ */
+int dmu_object_set_maxblkid(objset_t *os, uint64_t object, uint64_t maxblkid,
+    dmu_tx_t *tx);
+
+/*
+ * Set the checksum property on a dnode.  The new checksum algorithm will
+ * apply to all newly written blocks; existing blocks will not be affected.
+ */
+void dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum,
+    dmu_tx_t *tx);
+
+/*
+ * Set the compress property on a dnode.  The new compression algorithm will
+ * apply to all newly written blocks; existing blocks will not be affected.
+ */
+void dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress,
+    dmu_tx_t *tx);
+
+void dmu_write_embedded(objset_t *os, uint64_t object, uint64_t offset,
+    void *data, uint8_t etype, uint8_t comp, int uncompressed_size,
+    int compressed_size, int byteorder, dmu_tx_t *tx);
+void dmu_redact(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
+    dmu_tx_t *tx);
+
+/*
+ * Decide how to write a block: checksum, compression, number of copies, etc.
+ */
+#define	WP_NOFILL	0x1
+#define	WP_DMU_SYNC	0x2
+#define	WP_SPILL	0x4
+
+void dmu_write_policy(objset_t *os, dnode_t *dn, int level, int wp,
+    struct zio_prop *zp);
+
+/*
+ * The bonus data is accessed more or less like a regular buffer.
+ * You must dmu_bonus_hold() to get the buffer, which will give you a
+ * dmu_buf_t with db_offset==-1ULL, and db_size = the size of the bonus
+ * data.  As with any normal buffer, you must call dmu_buf_will_dirty()
+ * before modifying it, and the
+ * object must be held in an assigned transaction before calling
+ * dmu_buf_will_dirty.  You may use dmu_buf_set_user() on the bonus
+ * buffer as well.  You must release what you hold with dmu_buf_rele().
+ *
+ * Returns ENOENT, EIO, or 0.
+ */
+int dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **dbp);
+int dmu_bonus_hold_by_dnode(dnode_t *dn, void *tag, dmu_buf_t **dbp,
+    uint32_t flags);
+int dmu_bonus_max(void);
+int dmu_set_bonus(dmu_buf_t *, int, dmu_tx_t *);
+int dmu_set_bonustype(dmu_buf_t *, dmu_object_type_t, dmu_tx_t *);
+dmu_object_type_t dmu_get_bonustype(dmu_buf_t *);
+int dmu_rm_spill(objset_t *, uint64_t, dmu_tx_t *);
+
+/*
+ * Special spill buffer support used by "SA" framework
+ */
+
+int dmu_spill_hold_by_bonus(dmu_buf_t *bonus, uint32_t flags, void *tag,
+    dmu_buf_t **dbp);
+int dmu_spill_hold_by_dnode(dnode_t *dn, uint32_t flags,
+    void *tag, dmu_buf_t **dbp);
+int dmu_spill_hold_existing(dmu_buf_t *bonus, void *tag, dmu_buf_t **dbp);
+
+/*
+ * Obtain the DMU buffer from the specified object which contains the
+ * specified offset.  dmu_buf_hold() puts a "hold" on the buffer, so
+ * that it will remain in memory.  You must release the hold with
+ * dmu_buf_rele().  You must not access the dmu_buf_t after releasing
+ * what you hold.  You must have a hold on any dmu_buf_t* you pass to the DMU.
+ *
+ * You must call dmu_buf_read, dmu_buf_will_dirty, or dmu_buf_will_fill
+ * on the returned buffer before reading or writing the buffer's
+ * db_data.  The comments for those routines describe what particular
+ * operations are valid after calling them.
+ *
+ * The object number must be a valid, allocated object number.
+ */
+int dmu_buf_hold(objset_t *os, uint64_t object, uint64_t offset,
+    void *tag, dmu_buf_t **, int flags);
+int dmu_buf_hold_by_dnode(dnode_t *dn, uint64_t offset,
+    void *tag, dmu_buf_t **dbp, int flags);
+int dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset,
+    uint64_t length, boolean_t read, void *tag, int *numbufsp,
+    dmu_buf_t ***dbpp, uint32_t flags);
+/*
+ * Add a reference to a dmu buffer that has already been held via
+ * dmu_buf_hold() in the current context.
+ */
+void dmu_buf_add_ref(dmu_buf_t *db, void* tag);
+
+/*
+ * Attempt to add a reference to a dmu buffer that is in an unknown state,
+ * using a pointer that may have been invalidated by eviction processing.
+ * The request will succeed if the passed in dbuf still represents the
+ * same os/object/blkid, is ineligible for eviction, and has at least
+ * one hold by a user other than the syncer.
+ */
+boolean_t dmu_buf_try_add_ref(dmu_buf_t *, objset_t *os, uint64_t object,
+    uint64_t blkid, void *tag);
+
+void dmu_buf_rele(dmu_buf_t *db, void *tag);
+uint64_t dmu_buf_refcount(dmu_buf_t *db);
+uint64_t dmu_buf_user_refcount(dmu_buf_t *db);
+
+/*
+ * dmu_buf_hold_array holds the DMU buffers which contain all bytes in a
+ * range of an object.  A pointer to an array of dmu_buf_t*'s is
+ * returned (in *dbpp).
+ *
+ * dmu_buf_rele_array releases the hold on an array of dmu_buf_t*'s, and
+ * frees the array.  The hold on the array of buffers MUST be released
+ * with dmu_buf_rele_array.  You can NOT release the hold on each buffer
+ * individually with dmu_buf_rele.
+ */
+int dmu_buf_hold_array_by_bonus(dmu_buf_t *db, uint64_t offset,
+    uint64_t length, boolean_t read, void *tag,
+    int *numbufsp, dmu_buf_t ***dbpp);
+void dmu_buf_rele_array(dmu_buf_t **, int numbufs, void *tag);
+
+typedef void dmu_buf_evict_func_t(void *user_ptr);
+
+/*
+ * A DMU buffer user object may be associated with a dbuf for the
+ * duration of its lifetime.  This allows the user of a dbuf (client)
+ * to attach private data to a dbuf (e.g. in-core only data such as a
+ * dnode_children_t, zap_t, or zap_leaf_t) and be optionally notified
+ * when that dbuf has been evicted.  Clients typically respond to the
+ * eviction notification by freeing their private data, thus ensuring
+ * the same lifetime for both dbuf and private data.
+ *
+ * The mapping from a dmu_buf_user_t to any client private data is the
+ * client's responsibility.  All current consumers of the API with private
+ * data embed a dmu_buf_user_t as the first member of the structure for
+ * their private data.  This allows conversions between the two types
+ * with a simple cast.  Since the DMU buf user API never needs access
+ * to the private data, other strategies can be employed if necessary
+ * or convenient for the client (e.g. using container_of() to do the
+ * conversion for private data that cannot have the dmu_buf_user_t as
+ * its first member).
+ *
+ * Eviction callbacks are executed without the dbuf mutex held or any
+ * other type of mechanism to guarantee that the dbuf is still available.
+ * For this reason, users must assume the dbuf has already been freed
+ * and not reference the dbuf from the callback context.
+ *
+ * Users requesting "immediate eviction" are notified as soon as the dbuf
+ * is only referenced by dirty records (dirties == holds).  Otherwise the
+ * notification occurs after eviction processing for the dbuf begins.
+ */
+typedef struct dmu_buf_user {
+	/*
+	 * Asynchronous user eviction callback state.
+	 */
+	taskq_ent_t	dbu_tqent;
+
+	/*
+	 * This instance's eviction function pointers.
+	 *
+	 * dbu_evict_func_sync is called synchronously and then
+	 * dbu_evict_func_async is executed asynchronously on a taskq.
+	 */
+	dmu_buf_evict_func_t *dbu_evict_func_sync;
+	dmu_buf_evict_func_t *dbu_evict_func_async;
+#ifdef ZFS_DEBUG
+	/*
+	 * Pointer to user's dbuf pointer.  NULL for clients that do
+	 * not associate a dbuf with their user data.
+	 *
+	 * The dbuf pointer is cleared upon eviction so as to catch
+	 * use-after-evict bugs in clients.
+	 */
+	dmu_buf_t **dbu_clear_on_evict_dbufp;
+#endif
+} dmu_buf_user_t;
+
+/*
+ * Initialize the given dmu_buf_user_t instance with the eviction function
+ * evict_func, to be called when the user is evicted.
+ *
+ * NOTE: This function should only be called once on a given dmu_buf_user_t.
+ *       To allow enforcement of this, dbu must already be zeroed on entry.
+ */
+/*ARGSUSED*/
+static inline void
+dmu_buf_init_user(dmu_buf_user_t *dbu, dmu_buf_evict_func_t *evict_func_sync,
+    dmu_buf_evict_func_t *evict_func_async,
+    dmu_buf_t **clear_on_evict_dbufp __maybe_unused)
+{
+	ASSERT(dbu->dbu_evict_func_sync == NULL);
+	ASSERT(dbu->dbu_evict_func_async == NULL);
+
+	/* must have at least one evict func */
+	IMPLY(evict_func_sync == NULL, evict_func_async != NULL);
+	dbu->dbu_evict_func_sync = evict_func_sync;
+	dbu->dbu_evict_func_async = evict_func_async;
+	taskq_init_ent(&dbu->dbu_tqent);
+#ifdef ZFS_DEBUG
+	dbu->dbu_clear_on_evict_dbufp = clear_on_evict_dbufp;
+#endif
+}
+
+/*
+ * Attach user data to a dbuf and mark it for normal (when the dbuf's
+ * data is cleared or its reference count goes to zero) eviction processing.
+ *
+ * Returns NULL on success, or the existing user if another user currently
+ * owns the buffer.
+ */
+void *dmu_buf_set_user(dmu_buf_t *db, dmu_buf_user_t *user);
+
+/*
+ * Attach user data to a dbuf and mark it for immediate (its dirty and
+ * reference counts are equal) eviction processing.
+ *
+ * Returns NULL on success, or the existing user if another user currently
+ * owns the buffer.
+ */
+void *dmu_buf_set_user_ie(dmu_buf_t *db, dmu_buf_user_t *user);
+
+/*
+ * Replace the current user of a dbuf.
+ *
+ * If given the current user of a dbuf, replaces the dbuf's user with
+ * "new_user" and returns the user data pointer that was replaced.
+ * Otherwise returns the current, and unmodified, dbuf user pointer.
+ */
+void *dmu_buf_replace_user(dmu_buf_t *db,
+    dmu_buf_user_t *old_user, dmu_buf_user_t *new_user);
+
+/*
+ * Remove the specified user data for a DMU buffer.
+ *
+ * Returns the user that was removed on success, or the current user if
+ * another user currently owns the buffer.
+ */
+void *dmu_buf_remove_user(dmu_buf_t *db, dmu_buf_user_t *user);
+
+/*
+ * Returns the user data (dmu_buf_user_t *) associated with this dbuf.
+ */
+void *dmu_buf_get_user(dmu_buf_t *db);
+
+objset_t *dmu_buf_get_objset(dmu_buf_t *db);
+dnode_t *dmu_buf_dnode_enter(dmu_buf_t *db);
+void dmu_buf_dnode_exit(dmu_buf_t *db);
+
+/* Block until any in-progress dmu buf user evictions complete. */
+void dmu_buf_user_evict_wait(void);
+
+/*
+ * Returns the blkptr associated with this dbuf, or NULL if not set.
+ */
+struct blkptr *dmu_buf_get_blkptr(dmu_buf_t *db);
+
+/*
+ * Indicate that you are going to modify the buffer's data (db_data).
+ *
+ * The transaction (tx) must be assigned to a txg (ie. you've called
+ * dmu_tx_assign()).  The buffer's object must be held in the tx
+ * (ie. you've called dmu_tx_hold_object(tx, db->db_object)).
+ */
+void dmu_buf_will_dirty(dmu_buf_t *db, dmu_tx_t *tx);
+boolean_t dmu_buf_is_dirty(dmu_buf_t *db, dmu_tx_t *tx);
+void dmu_buf_set_crypt_params(dmu_buf_t *db_fake, boolean_t byteorder,
+    const uint8_t *salt, const uint8_t *iv, const uint8_t *mac, dmu_tx_t *tx);
+
+/*
+ * You must create a transaction, then hold the objects which you will
+ * (or might) modify as part of this transaction.  Then you must assign
+ * the transaction to a transaction group.  Once the transaction has
+ * been assigned, you can modify buffers which belong to held objects as
+ * part of this transaction.  You can't modify buffers before the
+ * transaction has been assigned; you can't modify buffers which don't
+ * belong to objects which this transaction holds; you can't hold
+ * objects once the transaction has been assigned.  You may hold an
+ * object which you are going to free (with dmu_object_free()), but you
+ * don't have to.
+ *
+ * You can abort the transaction before it has been assigned.
+ *
+ * Note that you may hold buffers (with dmu_buf_hold) at any time,
+ * regardless of transaction state.
+ */
+
+#define	DMU_NEW_OBJECT	(-1ULL)
+#define	DMU_OBJECT_END	(-1ULL)
+
+dmu_tx_t *dmu_tx_create(objset_t *os);
+void dmu_tx_hold_write(dmu_tx_t *tx, uint64_t object, uint64_t off, int len);
+void dmu_tx_hold_write_by_dnode(dmu_tx_t *tx, dnode_t *dn, uint64_t off,
+    int len);
+void dmu_tx_hold_free(dmu_tx_t *tx, uint64_t object, uint64_t off,
+    uint64_t len);
+void dmu_tx_hold_free_by_dnode(dmu_tx_t *tx, dnode_t *dn, uint64_t off,
+    uint64_t len);
+void dmu_tx_hold_zap(dmu_tx_t *tx, uint64_t object, int add, const char *name);
+void dmu_tx_hold_zap_by_dnode(dmu_tx_t *tx, dnode_t *dn, int add,
+    const char *name);
+void dmu_tx_hold_bonus(dmu_tx_t *tx, uint64_t object);
+void dmu_tx_hold_bonus_by_dnode(dmu_tx_t *tx, dnode_t *dn);
+void dmu_tx_hold_spill(dmu_tx_t *tx, uint64_t object);
+void dmu_tx_hold_sa(dmu_tx_t *tx, struct sa_handle *hdl, boolean_t may_grow);
+void dmu_tx_hold_sa_create(dmu_tx_t *tx, int total_size);
+void dmu_tx_abort(dmu_tx_t *tx);
+int dmu_tx_assign(dmu_tx_t *tx, uint64_t txg_how);
+void dmu_tx_wait(dmu_tx_t *tx);
+void dmu_tx_commit(dmu_tx_t *tx);
+void dmu_tx_mark_netfree(dmu_tx_t *tx);
+
+/*
+ * To register a commit callback, dmu_tx_callback_register() must be called.
+ *
+ * dcb_data is a pointer to caller private data that is passed on as a
+ * callback parameter. The caller is responsible for properly allocating and
+ * freeing it.
+ *
+ * When registering a callback, the transaction must be already created, but
+ * it cannot be committed or aborted. It can be assigned to a txg or not.
+ *
+ * The callback will be called after the transaction has been safely written
+ * to stable storage and will also be called if the dmu_tx is aborted.
+ * If there is any error which prevents the transaction from being committed to
+ * disk, the callback will be called with a value of error != 0.
+ *
+ * When multiple callbacks are registered to the transaction, the callbacks
+ * will be called in reverse order to let Lustre, the only user of commit
+ * callback currently, take the fast path of its commit callback handling.
+ */
+typedef void dmu_tx_callback_func_t(void *dcb_data, int error);
+
+void dmu_tx_callback_register(dmu_tx_t *tx, dmu_tx_callback_func_t *dcb_func,
+    void *dcb_data);
+void dmu_tx_do_callbacks(list_t *cb_list, int error);
+
+/*
+ * Free up the data blocks for a defined range of a file.  If size is
+ * -1, the range from offset to end-of-file is freed.
+ */
+int dmu_free_range(objset_t *os, uint64_t object, uint64_t offset,
+    uint64_t size, dmu_tx_t *tx);
+int dmu_free_long_range(objset_t *os, uint64_t object, uint64_t offset,
+    uint64_t size);
+int dmu_free_long_object(objset_t *os, uint64_t object);
+
+/*
+ * Convenience functions.
+ *
+ * Canfail routines will return 0 on success, or an errno if there is a
+ * nonrecoverable I/O error.
+ */
+#define	DMU_READ_PREFETCH	0 /* prefetch */
+#define	DMU_READ_NO_PREFETCH	1 /* don't prefetch */
+#define	DMU_READ_NO_DECRYPT	2 /* don't decrypt */
+int dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
+	void *buf, uint32_t flags);
+int dmu_read_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size, void *buf,
+    uint32_t flags);
+void dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
+	const void *buf, dmu_tx_t *tx);
+void dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
+    const void *buf, dmu_tx_t *tx);
+void dmu_prealloc(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
+	dmu_tx_t *tx);
+#ifdef _KERNEL
+int dmu_read_uio(objset_t *os, uint64_t object, struct uio *uio, uint64_t size);
+int dmu_read_uio_dbuf(dmu_buf_t *zdb, struct uio *uio, uint64_t size);
+int dmu_read_uio_dnode(dnode_t *dn, struct uio *uio, uint64_t size);
+int dmu_write_uio(objset_t *os, uint64_t object, struct uio *uio, uint64_t size,
+	dmu_tx_t *tx);
+int dmu_write_uio_dbuf(dmu_buf_t *zdb, struct uio *uio, uint64_t size,
+	dmu_tx_t *tx);
+int dmu_write_uio_dnode(dnode_t *dn, struct uio *uio, uint64_t size,
+	dmu_tx_t *tx);
+#endif
+struct arc_buf *dmu_request_arcbuf(dmu_buf_t *handle, int size);
+void dmu_return_arcbuf(struct arc_buf *buf);
+int dmu_assign_arcbuf_by_dnode(dnode_t *dn, uint64_t offset,
+    struct arc_buf *buf, dmu_tx_t *tx);
+int dmu_assign_arcbuf_by_dbuf(dmu_buf_t *handle, uint64_t offset,
+    struct arc_buf *buf, dmu_tx_t *tx);
+#define	dmu_assign_arcbuf	dmu_assign_arcbuf_by_dbuf
+#ifdef HAVE_UIO_ZEROCOPY
+int dmu_xuio_init(struct xuio *uio, int niov);
+void dmu_xuio_fini(struct xuio *uio);
+int dmu_xuio_add(struct xuio *uio, struct arc_buf *abuf, offset_t off,
+    size_t n);
+int dmu_xuio_cnt(struct xuio *uio);
+struct arc_buf *dmu_xuio_arcbuf(struct xuio *uio, int i);
+void dmu_xuio_clear(struct xuio *uio, int i);
+#endif /* HAVE_UIO_ZEROCOPY */
+void xuio_stat_wbuf_copied(void);
+void xuio_stat_wbuf_nocopy(void);
+
+extern int zfs_prefetch_disable;
+extern int zfs_max_recordsize;
+
+/*
+ * Asynchronously try to read in the data.
+ */
+void dmu_prefetch(objset_t *os, uint64_t object, int64_t level, uint64_t offset,
+	uint64_t len, enum zio_priority pri);
+
+typedef struct dmu_object_info {
+	/* All sizes are in bytes unless otherwise indicated. */
+	uint32_t doi_data_block_size;
+	uint32_t doi_metadata_block_size;
+	dmu_object_type_t doi_type;
+	dmu_object_type_t doi_bonus_type;
+	uint64_t doi_bonus_size;
+	uint8_t doi_indirection;		/* 2 = dnode->indirect->data */
+	uint8_t doi_checksum;
+	uint8_t doi_compress;
+	uint8_t doi_nblkptr;
+	uint8_t doi_pad[4];
+	uint64_t doi_dnodesize;
+	uint64_t doi_physical_blocks_512;	/* data + metadata, 512b blks */
+	uint64_t doi_max_offset;
+	uint64_t doi_fill_count;		/* number of non-empty blocks */
+} dmu_object_info_t;
+
+typedef void (*const arc_byteswap_func_t)(void *buf, size_t size);
+
+typedef struct dmu_object_type_info {
+	dmu_object_byteswap_t	ot_byteswap;
+	boolean_t		ot_metadata;
+	boolean_t		ot_dbuf_metadata_cache;
+	boolean_t		ot_encrypt;
+	char			*ot_name;
+} dmu_object_type_info_t;
+
+typedef const struct dmu_object_byteswap_info {
+	arc_byteswap_func_t	 ob_func;
+	char			*ob_name;
+} dmu_object_byteswap_info_t;
+
+extern const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES];
+extern const dmu_object_byteswap_info_t dmu_ot_byteswap[DMU_BSWAP_NUMFUNCS];
+
+/*
+ * Get information on a DMU object.
+ *
+ * Return 0 on success or ENOENT if object is not allocated.
+ *
+ * If doi is NULL, just indicates whether the object exists.
+ */
+int dmu_object_info(objset_t *os, uint64_t object, dmu_object_info_t *doi);
+void __dmu_object_info_from_dnode(struct dnode *dn, dmu_object_info_t *doi);
+/* Like dmu_object_info, but faster if you have a held dnode in hand. */
+void dmu_object_info_from_dnode(dnode_t *dn, dmu_object_info_t *doi);
+/* Like dmu_object_info, but faster if you have a held dbuf in hand. */
+void dmu_object_info_from_db(dmu_buf_t *db, dmu_object_info_t *doi);
+/*
+ * Like dmu_object_info_from_db, but faster still when you only care about
+ * the size.
+ */
+void dmu_object_size_from_db(dmu_buf_t *db, uint32_t *blksize,
+    u_longlong_t *nblk512);
+
+void dmu_object_dnsize_from_db(dmu_buf_t *db, int *dnsize);
+
+typedef struct dmu_objset_stats {
+	uint64_t dds_num_clones; /* number of clones of this */
+	uint64_t dds_creation_txg;
+	uint64_t dds_guid;
+	dmu_objset_type_t dds_type;
+	uint8_t dds_is_snapshot;
+	uint8_t dds_inconsistent;
+	uint8_t dds_redacted;
+	char dds_origin[ZFS_MAX_DATASET_NAME_LEN];
+} dmu_objset_stats_t;
+
+/*
+ * Get stats on a dataset.
+ */
+void dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat);
+
+/*
+ * Add entries to the nvlist for all the objset's properties.  See
+ * zfs_prop_table[] and zfs(1m) for details on the properties.
+ */
+void dmu_objset_stats(objset_t *os, struct nvlist *nv);
+
+/*
+ * Get the space usage statistics for statvfs().
+ *
+ * refdbytes is the amount of space "referenced" by this objset.
+ * availbytes is the amount of space available to this objset, taking
+ * into account quotas & reservations, assuming that no other objsets
+ * use the space first.  These values correspond to the 'referenced' and
+ * 'available' properties, described in the zfs(1m) manpage.
+ *
+ * usedobjs and availobjs are the number of objects currently allocated,
+ * and available.
+ */
+void dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp,
+    uint64_t *usedobjsp, uint64_t *availobjsp);
+
+/*
+ * The fsid_guid is a 56-bit ID that can change to avoid collisions.
+ * (Contrast with the ds_guid which is a 64-bit ID that will never
+ * change, so there is a small probability that it will collide.)
+ */
+uint64_t dmu_objset_fsid_guid(objset_t *os);
+
+/*
+ * Get the [cm]time for an objset's snapshot dir
+ */
+inode_timespec_t dmu_objset_snap_cmtime(objset_t *os);
+
+int dmu_objset_is_snapshot(objset_t *os);
+
+extern struct spa *dmu_objset_spa(objset_t *os);
+extern struct zilog *dmu_objset_zil(objset_t *os);
+extern struct dsl_pool *dmu_objset_pool(objset_t *os);
+extern struct dsl_dataset *dmu_objset_ds(objset_t *os);
+extern void dmu_objset_name(objset_t *os, char *buf);
+extern dmu_objset_type_t dmu_objset_type(objset_t *os);
+extern uint64_t dmu_objset_id(objset_t *os);
+extern uint64_t dmu_objset_dnodesize(objset_t *os);
+extern zfs_sync_type_t dmu_objset_syncprop(objset_t *os);
+extern zfs_logbias_op_t dmu_objset_logbias(objset_t *os);
+extern int dmu_objset_blksize(objset_t *os);
+extern int dmu_snapshot_list_next(objset_t *os, int namelen, char *name,
+    uint64_t *id, uint64_t *offp, boolean_t *case_conflict);
+extern int dmu_snapshot_lookup(objset_t *os, const char *name, uint64_t *val);
+extern int dmu_snapshot_realname(objset_t *os, char *name, char *real,
+    int maxlen, boolean_t *conflict);
+extern int dmu_dir_list_next(objset_t *os, int namelen, char *name,
+    uint64_t *idp, uint64_t *offp);
+
+typedef struct zfs_file_info {
+	uint64_t zfi_user;
+	uint64_t zfi_group;
+	uint64_t zfi_project;
+	uint64_t zfi_generation;
+} zfs_file_info_t;
+
+typedef int file_info_cb_t(dmu_object_type_t bonustype, const void *data,
+    struct zfs_file_info *zoi);
+extern void dmu_objset_register_type(dmu_objset_type_t ost,
+    file_info_cb_t *cb);
+extern void dmu_objset_set_user(objset_t *os, void *user_ptr);
+extern void *dmu_objset_get_user(objset_t *os);
+
+/*
+ * Return the txg number for the given assigned transaction.
+ */
+uint64_t dmu_tx_get_txg(dmu_tx_t *tx);
+
+/*
+ * Synchronous write.
+ * If a parent zio is provided this function initiates a write on the
+ * provided buffer as a child of the parent zio.
+ * In the absence of a parent zio, the write is completed synchronously.
+ * At write completion, blk is filled with the bp of the written block.
+ * Note that while the data covered by this function will be on stable
+ * storage when the write completes this new data does not become a
+ * permanent part of the file until the associated transaction commits.
+ */
+
+/*
+ * {zfs,zvol,ztest}_get_done() args
+ */
+typedef struct zgd {
+	struct lwb	*zgd_lwb;
+	struct blkptr	*zgd_bp;
+	dmu_buf_t	*zgd_db;
+	struct zfs_locked_range *zgd_lr;
+	void		*zgd_private;
+} zgd_t;
+
+typedef void dmu_sync_cb_t(zgd_t *arg, int error);
+int dmu_sync(struct zio *zio, uint64_t txg, dmu_sync_cb_t *done, zgd_t *zgd);
+
+/*
+ * Find the next hole or data block in file starting at *off
+ * Return found offset in *off. Return ESRCH for end of file.
+ */
+int dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole,
+    uint64_t *off);
+
+/*
+ * Initial setup and final teardown.
+ */
+extern void dmu_init(void);
+extern void dmu_fini(void);
+
+typedef void (*dmu_traverse_cb_t)(objset_t *os, void *arg, struct blkptr *bp,
+    uint64_t object, uint64_t offset, int len);
+void dmu_traverse_objset(objset_t *os, uint64_t txg_start,
+    dmu_traverse_cb_t cb, void *arg);
+
+int dmu_diff(const char *tosnap_name, const char *fromsnap_name,
+    zfs_file_t *fp, offset_t *offp);
+
+/* CRC64 table */
+#define	ZFS_CRC64_POLY	0xC96C5795D7870F42ULL	/* ECMA-182, reflected form */
+extern uint64_t zfs_crc64_table[256];
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DMU_H */
diff --git a/include/sys/dmu_impl.h b/include/sys/dmu_impl.h
new file mode 100644
index 0000000000000..0c6273a3a7271
--- /dev/null
+++ b/include/sys/dmu_impl.h
@@ -0,0 +1,264 @@
+/*
+ * 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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*
+ * Copyright (c) 2012, Joyent, Inc. All rights reserved.
+ * Copyright (c) 2013, 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_DMU_IMPL_H
+#define	_SYS_DMU_IMPL_H
+
+#include <sys/txg_impl.h>
+#include <sys/zio.h>
+#include <sys/dnode.h>
+#include <sys/zfs_context.h>
+#include <sys/zfs_ioctl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * This is the locking strategy for the DMU.  Numbers in parenthesis are
+ * cases that use that lock order, referenced below:
+ *
+ * ARC is self-contained
+ * bplist is self-contained
+ * refcount is self-contained
+ * txg is self-contained (hopefully!)
+ * zst_lock
+ * zf_rwlock
+ *
+ * XXX try to improve evicting path?
+ *
+ * dp_config_rwlock > os_obj_lock > dn_struct_rwlock >
+ * 	dn_dbufs_mtx > hash_mutexes > db_mtx > dd_lock > leafs
+ *
+ * dp_config_rwlock
+ *    must be held before: everything
+ *    protects dd namespace changes
+ *    protects property changes globally
+ *    held from:
+ *    	dsl_dir_open/r:
+ *    	dsl_dir_create_sync/w:
+ *    	dsl_dir_sync_destroy/w:
+ *    	dsl_dir_rename_sync/w:
+ *    	dsl_prop_changed_notify/r:
+ *
+ * os_obj_lock
+ *   must be held before:
+ *   	everything except dp_config_rwlock
+ *   protects os_obj_next
+ *   held from:
+ *   	dmu_object_alloc: dn_dbufs_mtx, db_mtx, hash_mutexes, dn_struct_rwlock
+ *
+ * dn_struct_rwlock
+ *   must be held before:
+ *   	everything except dp_config_rwlock and os_obj_lock
+ *   protects structure of dnode (eg. nlevels)
+ *   	db_blkptr can change when syncing out change to nlevels
+ *   	dn_maxblkid
+ *   	dn_nlevels
+ *   	dn_*blksz*
+ *   	phys nlevels, maxblkid, physical blkptr_t's (?)
+ *   held from:
+ *   	callers of dbuf_read_impl, dbuf_hold[_impl], dbuf_prefetch
+ *   	dmu_object_info_from_dnode: dn_dirty_mtx (dn_datablksz)
+ *   	dbuf_read_impl: db_mtx, dmu_zfetch()
+ *   	dmu_zfetch: zf_rwlock/r, zst_lock, dbuf_prefetch()
+ *   	dbuf_new_size: db_mtx
+ *   	dbuf_dirty: db_mtx
+ *	dbuf_findbp: (callers, phys? - the real need)
+ *	dbuf_create: dn_dbufs_mtx, hash_mutexes, db_mtx (phys?)
+ *	dbuf_prefetch: dn_dirty_mtx, hash_mutexes, db_mtx, dn_dbufs_mtx
+ *	dbuf_hold_impl: hash_mutexes, db_mtx, dn_dbufs_mtx, dbuf_findbp()
+ *	dnode_sync/w (increase_indirection): db_mtx (phys)
+ *	dnode_set_blksz/w: dn_dbufs_mtx (dn_*blksz*)
+ *	dnode_new_blkid/w: (dn_maxblkid)
+ *	dnode_free_range/w: dn_dirty_mtx (dn_maxblkid)
+ *	dnode_next_offset: (phys)
+ *
+ * dn_dbufs_mtx
+ *    must be held before:
+ *    	db_mtx, hash_mutexes
+ *    protects:
+ *    	dn_dbufs
+ *    	dn_evicted
+ *    held from:
+ *    	dmu_evict_user: db_mtx (dn_dbufs)
+ *    	dbuf_free_range: db_mtx (dn_dbufs)
+ *    	dbuf_remove_ref: db_mtx, callees:
+ *    		dbuf_hash_remove: hash_mutexes, db_mtx
+ *    	dbuf_create: hash_mutexes, db_mtx (dn_dbufs)
+ *    	dnode_set_blksz: (dn_dbufs)
+ *
+ * hash_mutexes (global)
+ *   must be held before:
+ *   	db_mtx
+ *   protects dbuf_hash_table (global) and db_hash_next
+ *   held from:
+ *   	dbuf_find: db_mtx
+ *   	dbuf_hash_insert: db_mtx
+ *   	dbuf_hash_remove: db_mtx
+ *
+ * db_mtx (meta-leaf)
+ *   must be held before:
+ *   	dn_mtx, dn_dirty_mtx, dd_lock (leaf mutexes)
+ *   protects:
+ *   	db_state
+ * 	db_holds
+ * 	db_buf
+ * 	db_changed
+ * 	db_data_pending
+ * 	db_dirtied
+ * 	db_link
+ * 	db_dirty_node (??)
+ * 	db_dirtycnt
+ * 	db_d.*
+ * 	db.*
+ *   held from:
+ * 	dbuf_dirty: dn_mtx, dn_dirty_mtx
+ * 	dbuf_dirty->dsl_dir_willuse_space: dd_lock
+ * 	dbuf_dirty->dbuf_new_block->dsl_dataset_block_freeable: dd_lock
+ * 	dbuf_undirty: dn_dirty_mtx (db_d)
+ * 	dbuf_write_done: dn_dirty_mtx (db_state)
+ * 	dbuf_*
+ * 	dmu_buf_update_user: none (db_d)
+ * 	dmu_evict_user: none (db_d) (maybe can eliminate)
+ *   	dbuf_find: none (db_holds)
+ *   	dbuf_hash_insert: none (db_holds)
+ *   	dmu_buf_read_array_impl: none (db_state, db_changed)
+ *   	dmu_sync: none (db_dirty_node, db_d)
+ *   	dnode_reallocate: none (db)
+ *
+ * dn_mtx (leaf)
+ *   protects:
+ *   	dn_dirty_dbufs
+ *   	dn_ranges
+ *   	phys accounting
+ * 	dn_allocated_txg
+ * 	dn_free_txg
+ * 	dn_assigned_txg
+ * 	dn_dirty_txg
+ * 	dd_assigned_tx
+ * 	dn_notxholds
+ *	dn_nodnholds
+ * 	dn_dirtyctx
+ * 	dn_dirtyctx_firstset
+ * 	(dn_phys copy fields?)
+ * 	(dn_phys contents?)
+ *   held from:
+ *   	dnode_*
+ *   	dbuf_dirty: none
+ *   	dbuf_sync: none (phys accounting)
+ *   	dbuf_undirty: none (dn_ranges, dn_dirty_dbufs)
+ *   	dbuf_write_done: none (phys accounting)
+ *   	dmu_object_info_from_dnode: none (accounting)
+ *   	dmu_tx_commit: none
+ *   	dmu_tx_hold_object_impl: none
+ *   	dmu_tx_try_assign: dn_notxholds(cv)
+ *   	dmu_tx_unassign: none
+ *
+ * dd_lock
+ *    must be held before:
+ *      ds_lock
+ *      ancestors' dd_lock
+ *    protects:
+ *    	dd_prop_cbs
+ *    	dd_sync_*
+ *    	dd_used_bytes
+ *    	dd_tempreserved
+ *    	dd_space_towrite
+ *    	dd_myname
+ *    	dd_phys accounting?
+ *    held from:
+ *    	dsl_dir_*
+ *    	dsl_prop_changed_notify: none (dd_prop_cbs)
+ *    	dsl_prop_register: none (dd_prop_cbs)
+ *    	dsl_prop_unregister: none (dd_prop_cbs)
+ *
+ * os_lock (leaf)
+ *   protects:
+ *   	os_dirty_dnodes
+ *   	os_free_dnodes
+ *   	os_dnodes
+ *   	os_downgraded_dbufs
+ *   	dn_dirtyblksz
+ *   	dn_dirty_link
+ *   held from:
+ *   	dnode_create: none (os_dnodes)
+ *   	dnode_destroy: none (os_dnodes)
+ *   	dnode_setdirty: none (dn_dirtyblksz, os_*_dnodes)
+ *   	dnode_free: none (dn_dirtyblksz, os_*_dnodes)
+ *
+ * ds_lock
+ *    protects:
+ *    	ds_objset
+ *    	ds_open_refcount
+ *    	ds_snapname
+ *    	ds_phys accounting
+ *	ds_phys userrefs zapobj
+ *	ds_reserved
+ *    held from:
+ *    	dsl_dataset_*
+ *
+ * dr_mtx (leaf)
+ *    protects:
+ *	dr_children
+ *    held from:
+ *	dbuf_dirty
+ *	dbuf_undirty
+ *	dbuf_sync_indirect
+ *	dnode_new_blkid
+ */
+
+struct objset;
+struct dmu_pool;
+
+typedef struct dmu_xuio {
+	int next;
+	int cnt;
+	struct arc_buf **bufs;
+	iovec_t *iovp;
+} dmu_xuio_t;
+
+typedef struct dmu_sendstatus {
+	list_node_t dss_link;
+	int dss_outfd;
+	proc_t *dss_proc;
+	offset_t *dss_off;
+	uint64_t dss_blocks; /* blocks visited during the sending process */
+} dmu_sendstatus_t;
+
+void dmu_object_zapify(objset_t *, uint64_t, dmu_object_type_t, dmu_tx_t *);
+void dmu_object_free_zapified(objset_t *, uint64_t, dmu_tx_t *);
+int dmu_buf_hold_noread(objset_t *, uint64_t, uint64_t,
+    void *, dmu_buf_t **);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DMU_IMPL_H */
diff --git a/include/sys/dmu_objset.h b/include/sys/dmu_objset.h
new file mode 100644
index 0000000000000..1af69832c5d38
--- /dev/null
+++ b/include/sys/dmu_objset.h
@@ -0,0 +1,273 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ */
+
+/* Portions Copyright 2010 Robert Milkowski */
+
+#ifndef	_SYS_DMU_OBJSET_H
+#define	_SYS_DMU_OBJSET_H
+
+#include <sys/spa.h>
+#include <sys/arc.h>
+#include <sys/txg.h>
+#include <sys/zfs_context.h>
+#include <sys/dnode.h>
+#include <sys/zio.h>
+#include <sys/zil.h>
+#include <sys/sa.h>
+#include <sys/zfs_ioctl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern krwlock_t os_lock;
+
+struct dsl_pool;
+struct dsl_dataset;
+struct dmu_tx;
+
+#define	OBJSET_PHYS_SIZE_V1	1024
+#define	OBJSET_PHYS_SIZE_V2	2048
+#define	OBJSET_PHYS_SIZE_V3	4096
+
+#define	OBJSET_BUF_HAS_USERUSED(buf) \
+	(arc_buf_size(buf) >= OBJSET_PHYS_SIZE_V2)
+#define	OBJSET_BUF_HAS_PROJECTUSED(buf) \
+	(arc_buf_size(buf) >= OBJSET_PHYS_SIZE_V3)
+
+#define	OBJSET_FLAG_USERACCOUNTING_COMPLETE	(1ULL << 0)
+#define	OBJSET_FLAG_USEROBJACCOUNTING_COMPLETE	(1ULL << 1)
+#define	OBJSET_FLAG_PROJECTQUOTA_COMPLETE	(1ULL << 2)
+
+/*
+ * This mask defines the set of flags which are "portable", meaning
+ * that they can be preserved when doing a raw encrypted zfs send.
+ * Flags included in this mask will be protected by os_portable_mac
+ * when the block of dnodes is encrypted. No portable flags currently
+ * exist.
+ */
+#define	OBJSET_CRYPT_PORTABLE_FLAGS_MASK	(0)
+
+typedef struct objset_phys {
+	dnode_phys_t os_meta_dnode;
+	zil_header_t os_zil_header;
+	uint64_t os_type;
+	uint64_t os_flags;
+	uint8_t os_portable_mac[ZIO_OBJSET_MAC_LEN];
+	uint8_t os_local_mac[ZIO_OBJSET_MAC_LEN];
+	char os_pad0[OBJSET_PHYS_SIZE_V2 - sizeof (dnode_phys_t)*3 -
+	    sizeof (zil_header_t) - sizeof (uint64_t)*2 -
+	    2*ZIO_OBJSET_MAC_LEN];
+	dnode_phys_t os_userused_dnode;
+	dnode_phys_t os_groupused_dnode;
+	dnode_phys_t os_projectused_dnode;
+	char os_pad1[OBJSET_PHYS_SIZE_V3 - OBJSET_PHYS_SIZE_V2 -
+	    sizeof (dnode_phys_t)];
+} objset_phys_t;
+
+typedef int (*dmu_objset_upgrade_cb_t)(objset_t *);
+
+#define	OBJSET_PROP_UNINITIALIZED	((uint64_t)-1)
+struct objset {
+	/* Immutable: */
+	struct dsl_dataset *os_dsl_dataset;
+	spa_t *os_spa;
+	arc_buf_t *os_phys_buf;
+	objset_phys_t *os_phys;
+	boolean_t os_encrypted;
+
+	/*
+	 * The following "special" dnodes have no parent, are exempt
+	 * from dnode_move(), and are not recorded in os_dnodes, but they
+	 * root their descendents in this objset using handles anyway, so
+	 * that all access to dnodes from dbufs consistently uses handles.
+	 */
+	dnode_handle_t os_meta_dnode;
+	dnode_handle_t os_userused_dnode;
+	dnode_handle_t os_groupused_dnode;
+	dnode_handle_t os_projectused_dnode;
+	zilog_t *os_zil;
+
+	list_node_t os_evicting_node;
+
+	/* can change, under dsl_dir's locks: */
+	uint64_t os_dnodesize; /* default dnode size for new objects */
+	enum zio_checksum os_checksum;
+	enum zio_compress os_compress;
+	uint8_t os_complevel;
+	uint8_t os_copies;
+	enum zio_checksum os_dedup_checksum;
+	boolean_t os_dedup_verify;
+	zfs_logbias_op_t os_logbias;
+	zfs_cache_type_t os_primary_cache;
+	zfs_cache_type_t os_secondary_cache;
+	zfs_sync_type_t os_sync;
+	zfs_redundant_metadata_type_t os_redundant_metadata;
+	uint64_t os_recordsize;
+	/*
+	 * The next four values are used as a cache of whatever's on disk, and
+	 * are initialized the first time these properties are queried. Before
+	 * being initialized with their real values, their values are
+	 * OBJSET_PROP_UNINITIALIZED.
+	 */
+	uint64_t os_version;
+	uint64_t os_normalization;
+	uint64_t os_utf8only;
+	uint64_t os_casesensitivity;
+	/*
+	 * The largest zpl file block allowed in special class.
+	 * cached here instead of zfsvfs for easier access.
+	 */
+	int os_zpl_special_smallblock;
+
+	/*
+	 * Pointer is constant; the blkptr it points to is protected by
+	 * os_dsl_dataset->ds_bp_rwlock
+	 */
+	blkptr_t *os_rootbp;
+
+	/* no lock needed: */
+	struct dmu_tx *os_synctx; /* XXX sketchy */
+	zil_header_t os_zil_header;
+	multilist_t *os_synced_dnodes;
+	uint64_t os_flags;
+	uint64_t os_freed_dnodes;
+	boolean_t os_rescan_dnodes;
+	boolean_t os_raw_receive;
+
+	/* os_phys_buf should be written raw next txg */
+	boolean_t os_next_write_raw[TXG_SIZE];
+
+	/* Protected by os_obj_lock */
+	kmutex_t os_obj_lock;
+	uint64_t os_obj_next_chunk;
+
+	/* Per-CPU next object to allocate, protected by atomic ops. */
+	uint64_t *os_obj_next_percpu;
+	int os_obj_next_percpu_len;
+
+	/* Protected by os_lock */
+	kmutex_t os_lock;
+	multilist_t *os_dirty_dnodes[TXG_SIZE];
+	list_t os_dnodes;
+	list_t os_downgraded_dbufs;
+
+	/* Protects changes to DMU_{USER,GROUP,PROJECT}USED_OBJECT */
+	kmutex_t os_userused_lock;
+
+	/* stuff we store for the user */
+	kmutex_t os_user_ptr_lock;
+	void *os_user_ptr;
+	sa_os_t *os_sa;
+
+	/* kernel thread to upgrade this dataset */
+	kmutex_t os_upgrade_lock;
+	taskqid_t os_upgrade_id;
+	dmu_objset_upgrade_cb_t os_upgrade_cb;
+	boolean_t os_upgrade_exit;
+	int os_upgrade_status;
+};
+
+#define	DMU_META_OBJSET		0
+#define	DMU_META_DNODE_OBJECT	0
+#define	DMU_OBJECT_IS_SPECIAL(obj) ((int64_t)(obj) <= 0)
+#define	DMU_META_DNODE(os)	((os)->os_meta_dnode.dnh_dnode)
+#define	DMU_USERUSED_DNODE(os)	((os)->os_userused_dnode.dnh_dnode)
+#define	DMU_GROUPUSED_DNODE(os)	((os)->os_groupused_dnode.dnh_dnode)
+#define	DMU_PROJECTUSED_DNODE(os) ((os)->os_projectused_dnode.dnh_dnode)
+
+#define	DMU_OS_IS_L2CACHEABLE(os)				\
+	((os)->os_secondary_cache == ZFS_CACHE_ALL ||		\
+	(os)->os_secondary_cache == ZFS_CACHE_METADATA)
+
+/* called from zpl */
+int dmu_objset_hold(const char *name, void *tag, objset_t **osp);
+int dmu_objset_hold_flags(const char *name, boolean_t decrypt, void *tag,
+    objset_t **osp);
+int dmu_objset_own(const char *name, dmu_objset_type_t type,
+    boolean_t readonly, boolean_t decrypt, void *tag, objset_t **osp);
+int dmu_objset_own_obj(struct dsl_pool *dp, uint64_t obj,
+    dmu_objset_type_t type, boolean_t readonly, boolean_t decrypt,
+    void *tag, objset_t **osp);
+void dmu_objset_refresh_ownership(struct dsl_dataset *ds,
+    struct dsl_dataset **newds, boolean_t decrypt, void *tag);
+void dmu_objset_rele(objset_t *os, void *tag);
+void dmu_objset_rele_flags(objset_t *os, boolean_t decrypt, void *tag);
+void dmu_objset_disown(objset_t *os, boolean_t decrypt, void *tag);
+int dmu_objset_from_ds(struct dsl_dataset *ds, objset_t **osp);
+
+void dmu_objset_stats(objset_t *os, nvlist_t *nv);
+void dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat);
+void dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp,
+    uint64_t *usedobjsp, uint64_t *availobjsp);
+uint64_t dmu_objset_fsid_guid(objset_t *os);
+int dmu_objset_find_dp(struct dsl_pool *dp, uint64_t ddobj,
+    int func(struct dsl_pool *, struct dsl_dataset *, void *),
+    void *arg, int flags);
+void dmu_objset_evict_dbufs(objset_t *os);
+inode_timespec_t dmu_objset_snap_cmtime(objset_t *os);
+
+/* called from dsl */
+void dmu_objset_sync(objset_t *os, zio_t *zio, dmu_tx_t *tx);
+boolean_t dmu_objset_is_dirty(objset_t *os, uint64_t txg);
+objset_t *dmu_objset_create_impl_dnstats(spa_t *spa, struct dsl_dataset *ds,
+    blkptr_t *bp, dmu_objset_type_t type, int levels, int blksz, int ibs,
+    dmu_tx_t *tx);
+objset_t *dmu_objset_create_impl(spa_t *spa, struct dsl_dataset *ds,
+    blkptr_t *bp, dmu_objset_type_t type, dmu_tx_t *tx);
+int dmu_objset_open_impl(spa_t *spa, struct dsl_dataset *ds, blkptr_t *bp,
+    objset_t **osp);
+void dmu_objset_evict(objset_t *os);
+void dmu_objset_do_userquota_updates(objset_t *os, dmu_tx_t *tx);
+void dmu_objset_userquota_get_ids(dnode_t *dn, boolean_t before, dmu_tx_t *tx);
+boolean_t dmu_objset_userused_enabled(objset_t *os);
+int dmu_objset_userspace_upgrade(objset_t *os);
+boolean_t dmu_objset_userspace_present(objset_t *os);
+boolean_t dmu_objset_userobjused_enabled(objset_t *os);
+boolean_t dmu_objset_userobjspace_upgradable(objset_t *os);
+boolean_t dmu_objset_userobjspace_present(objset_t *os);
+boolean_t dmu_objset_incompatible_encryption_version(objset_t *os);
+boolean_t dmu_objset_projectquota_enabled(objset_t *os);
+boolean_t dmu_objset_projectquota_present(objset_t *os);
+boolean_t dmu_objset_projectquota_upgradable(objset_t *os);
+void dmu_objset_id_quota_upgrade(objset_t *os);
+int dmu_get_file_info(objset_t *os, dmu_object_type_t bonustype,
+    const void *data, zfs_file_info_t *zfi);
+
+int dmu_fsname(const char *snapname, char *buf);
+
+void dmu_objset_evict_done(objset_t *os);
+void dmu_objset_willuse_space(objset_t *os, int64_t space, dmu_tx_t *tx);
+
+void dmu_objset_init(void);
+void dmu_objset_fini(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DMU_OBJSET_H */
diff --git a/include/sys/dmu_recv.h b/include/sys/dmu_recv.h
new file mode 100644
index 0000000000000..dacc6b7829da6
--- /dev/null
+++ b/include/sys/dmu_recv.h
@@ -0,0 +1,88 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 by Delphix. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
+ * Copyright (c) 2013, Joyent, Inc. All rights reserved.
+ */
+
+#ifndef _DMU_RECV_H
+#define	_DMU_RECV_H
+
+#include <sys/inttypes.h>
+#include <sys/dsl_bookmark.h>
+#include <sys/dsl_dataset.h>
+#include <sys/spa.h>
+#include <sys/objlist.h>
+#include <sys/dsl_bookmark.h>
+
+extern const char *recv_clone_name;
+
+typedef struct dmu_recv_cookie {
+	struct dsl_dataset *drc_ds;
+	struct dmu_replay_record *drc_drr_begin;
+	struct drr_begin *drc_drrb;
+	const char *drc_tofs;
+	const char *drc_tosnap;
+	boolean_t drc_newfs;
+	boolean_t drc_byteswap;
+	uint64_t drc_featureflags;
+	boolean_t drc_force;
+	boolean_t drc_resumable;
+	boolean_t drc_should_save;
+	boolean_t drc_raw;
+	boolean_t drc_clone;
+	boolean_t drc_spill;
+	nvlist_t *drc_keynvl;
+	uint64_t drc_fromsnapobj;
+	uint64_t drc_ivset_guid;
+	void *drc_owner;
+	cred_t *drc_cred;
+	proc_t *drc_proc;
+	nvlist_t *drc_begin_nvl;
+
+	objset_t *drc_os;
+	zfs_file_t *drc_fp; /* The file to read the stream from */
+	uint64_t drc_voff; /* The current offset in the stream */
+	uint64_t drc_bytes_read;
+	/*
+	 * A record that has had its payload read in, but hasn't yet been handed
+	 * off to the worker thread.
+	 */
+	struct receive_record_arg *drc_rrd;
+	/* A record that has had its header read in, but not its payload. */
+	struct receive_record_arg *drc_next_rrd;
+	zio_cksum_t drc_cksum;
+	zio_cksum_t drc_prev_cksum;
+	/* Sorted list of objects not to issue prefetches for. */
+	objlist_t *drc_ignore_objlist;
+} dmu_recv_cookie_t;
+
+int dmu_recv_begin(char *, char *, dmu_replay_record_t *,
+    boolean_t, boolean_t, nvlist_t *, nvlist_t *, char *,
+    dmu_recv_cookie_t *, zfs_file_t *, offset_t *);
+int dmu_recv_stream(dmu_recv_cookie_t *, offset_t *);
+int dmu_recv_end(dmu_recv_cookie_t *, void *);
+boolean_t dmu_objset_is_receiving(objset_t *);
+
+#endif /* _DMU_RECV_H */
diff --git a/include/sys/dmu_redact.h b/include/sys/dmu_redact.h
new file mode 100644
index 0000000000000..207fdbb5cfda0
--- /dev/null
+++ b/include/sys/dmu_redact.h
@@ -0,0 +1,58 @@
+/*
+ * 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) 2018 by Delphix. All rights reserved.
+ */
+#ifndef _DMU_REDACT_H_
+#define	_DMU_REDACT_H_
+
+#include <sys/spa.h>
+#include <sys/dsl_bookmark.h>
+
+#define	REDACT_BLOCK_MAX_COUNT (1ULL << 48)
+
+static inline uint64_t
+redact_block_get_size(redact_block_phys_t *rbp)
+{
+	return (BF64_GET_SB((rbp)->rbp_size_count, 48, 16, SPA_MINBLOCKSHIFT,
+	    0));
+}
+
+static inline void
+redact_block_set_size(redact_block_phys_t *rbp, uint64_t size)
+{
+	BF64_SET_SB((rbp)->rbp_size_count, 48, 16, SPA_MINBLOCKSHIFT, 0, size);
+}
+
+static inline uint64_t
+redact_block_get_count(redact_block_phys_t *rbp)
+{
+	return (BF64_GET_SB((rbp)->rbp_size_count, 0, 48, 0, 1));
+}
+
+static inline void
+redact_block_set_count(redact_block_phys_t *rbp, uint64_t count)
+{
+	BF64_SET_SB((rbp)->rbp_size_count, 0, 48, 0, 1, count);
+}
+
+int dmu_redact_snap(const char *, nvlist_t *, const char *);
+#endif /* _DMU_REDACT_H_ */
diff --git a/include/sys/dmu_send.h b/include/sys/dmu_send.h
new file mode 100644
index 0000000000000..d6d050e01f976
--- /dev/null
+++ b/include/sys/dmu_send.h
@@ -0,0 +1,72 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
+ * Copyright (c) 2013, Joyent, Inc. All rights reserved.
+ */
+
+#ifndef _DMU_SEND_H
+#define	_DMU_SEND_H
+
+#include <sys/inttypes.h>
+#include <sys/dsl_crypt.h>
+#include <sys/dsl_bookmark.h>
+#include <sys/spa.h>
+#include <sys/objlist.h>
+#include <sys/dsl_bookmark.h>
+#include <sys/dmu_redact.h>
+
+#define	BEGINNV_REDACT_SNAPS		"redact_snaps"
+#define	BEGINNV_REDACT_FROM_SNAPS	"redact_from_snaps"
+#define	BEGINNV_RESUME_OBJECT		"resume_object"
+#define	BEGINNV_RESUME_OFFSET		"resume_offset"
+
+struct vnode;
+struct dsl_dataset;
+struct drr_begin;
+struct avl_tree;
+struct dmu_replay_record;
+struct dmu_send_outparams;
+int
+dmu_send(const char *tosnap, const char *fromsnap, boolean_t embedok,
+    boolean_t large_block_ok, boolean_t compressok, boolean_t rawok,
+    boolean_t savedok, uint64_t resumeobj, uint64_t resumeoff,
+    const char *redactbook, int outfd, offset_t *off,
+    struct dmu_send_outparams *dsop);
+int dmu_send_estimate_fast(struct dsl_dataset *ds, struct dsl_dataset *fromds,
+    zfs_bookmark_phys_t *frombook, boolean_t stream_compressed,
+    boolean_t saved, uint64_t *sizep);
+int dmu_send_obj(const char *pool, uint64_t tosnap, uint64_t fromsnap,
+    boolean_t embedok, boolean_t large_block_ok, boolean_t compressok,
+    boolean_t rawok, boolean_t savedok, int outfd, offset_t *off,
+    struct dmu_send_outparams *dso);
+
+typedef int (*dmu_send_outfunc_t)(objset_t *os, void *buf, int len, void *arg);
+typedef struct dmu_send_outparams {
+	dmu_send_outfunc_t	dso_outfunc;
+	void			*dso_arg;
+	boolean_t		dso_dryrun;
+} dmu_send_outparams_t;
+
+#endif /* _DMU_SEND_H */
diff --git a/include/sys/dmu_traverse.h b/include/sys/dmu_traverse.h
new file mode 100644
index 0000000000000..d76bfe3c9af3d
--- /dev/null
+++ b/include/sys/dmu_traverse.h
@@ -0,0 +1,92 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_DMU_TRAVERSE_H
+#define	_SYS_DMU_TRAVERSE_H
+
+#include <sys/zfs_context.h>
+#include <sys/spa.h>
+#include <sys/zio.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct dnode_phys;
+struct dsl_dataset;
+struct zilog;
+struct arc_buf;
+
+typedef int (blkptr_cb_t)(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
+    const zbookmark_phys_t *zb, const struct dnode_phys *dnp, void *arg);
+
+#define	TRAVERSE_PRE			(1<<0)
+#define	TRAVERSE_POST			(1<<1)
+#define	TRAVERSE_PREFETCH_METADATA	(1<<2)
+#define	TRAVERSE_PREFETCH_DATA		(1<<3)
+#define	TRAVERSE_PREFETCH (TRAVERSE_PREFETCH_METADATA | TRAVERSE_PREFETCH_DATA)
+#define	TRAVERSE_HARD			(1<<4)
+
+/*
+ * Encrypted dnode blocks have encrypted bonus buffers while the rest
+ * of the dnode is left unencrypted. Callers can specify the
+ * TRAVERSE_NO_DECRYPT flag to indicate to the traversal code that
+ * they wish to receive the raw encrypted dnodes instead of attempting
+ * to read the logical data.
+ */
+#define	TRAVERSE_NO_DECRYPT		(1<<5)
+
+/* Special traverse error return value to indicate skipping of children */
+#define	TRAVERSE_VISIT_NO_CHILDREN	-1
+
+int traverse_dataset(struct dsl_dataset *ds,
+    uint64_t txg_start, int flags, blkptr_cb_t func, void *arg);
+int traverse_dataset_resume(struct dsl_dataset *ds, uint64_t txg_start,
+    zbookmark_phys_t *resume, int flags, blkptr_cb_t func, void *arg);
+int traverse_dataset_destroyed(spa_t *spa, blkptr_t *blkptr,
+    uint64_t txg_start, zbookmark_phys_t *resume, int flags,
+    blkptr_cb_t func, void *arg);
+int traverse_pool(spa_t *spa,
+    uint64_t txg_start, int flags, blkptr_cb_t func, void *arg);
+
+/*
+ * Note that this calculation cannot overflow with the current maximum indirect
+ * block size (128k).  If that maximum is increased to 1M, however, this
+ * calculation can overflow, and handling would need to be added to ensure
+ * continued correctness.
+ */
+static inline uint64_t
+bp_span_in_blocks(uint8_t indblkshift, uint64_t level)
+{
+	unsigned int shift = level * (indblkshift - SPA_BLKPTRSHIFT);
+	ASSERT3U(shift, <, 64);
+	return (1ULL << shift);
+}
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DMU_TRAVERSE_H */
diff --git a/include/sys/dmu_tx.h b/include/sys/dmu_tx.h
new file mode 100644
index 0000000000000..60e9ed6e26f57
--- /dev/null
+++ b/include/sys/dmu_tx.h
@@ -0,0 +1,177 @@
+/*
+ * 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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*
+ * Copyright (c) 2012, 2016 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_DMU_TX_H
+#define	_SYS_DMU_TX_H
+
+#include <sys/inttypes.h>
+#include <sys/dmu.h>
+#include <sys/txg.h>
+#include <sys/zfs_refcount.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct dmu_buf_impl;
+struct dmu_tx_hold;
+struct dnode_link;
+struct dsl_pool;
+struct dnode;
+struct dsl_dir;
+
+struct dmu_tx {
+	/*
+	 * No synchronization is needed because a tx can only be handled
+	 * by one thread.
+	 */
+	list_t tx_holds; /* list of dmu_tx_hold_t */
+	objset_t *tx_objset;
+	struct dsl_dir *tx_dir;
+	struct dsl_pool *tx_pool;
+	uint64_t tx_txg;
+	uint64_t tx_lastsnap_txg;
+	uint64_t tx_lasttried_txg;
+	txg_handle_t tx_txgh;
+	void *tx_tempreserve_cookie;
+	struct dmu_tx_hold *tx_needassign_txh;
+
+	/* list of dmu_tx_callback_t on this dmu_tx */
+	list_t tx_callbacks;
+
+	/* placeholder for syncing context, doesn't need specific holds */
+	boolean_t tx_anyobj;
+
+	/* transaction is marked as being a "net free" of space */
+	boolean_t tx_netfree;
+
+	/* time this transaction was created */
+	hrtime_t tx_start;
+
+	/* need to wait for sufficient dirty space */
+	boolean_t tx_wait_dirty;
+
+	/* has this transaction already been delayed? */
+	boolean_t tx_dirty_delayed;
+
+	int tx_err;
+};
+
+enum dmu_tx_hold_type {
+	THT_NEWOBJECT,
+	THT_WRITE,
+	THT_BONUS,
+	THT_FREE,
+	THT_ZAP,
+	THT_SPACE,
+	THT_SPILL,
+	THT_NUMTYPES
+};
+
+typedef struct dmu_tx_hold {
+	dmu_tx_t *txh_tx;
+	list_node_t txh_node;
+	struct dnode *txh_dnode;
+	zfs_refcount_t txh_space_towrite;
+	zfs_refcount_t txh_memory_tohold;
+	enum dmu_tx_hold_type txh_type;
+	uint64_t txh_arg1;
+	uint64_t txh_arg2;
+} dmu_tx_hold_t;
+
+typedef struct dmu_tx_callback {
+	list_node_t		dcb_node;    /* linked to tx_callbacks list */
+	dmu_tx_callback_func_t	*dcb_func;   /* caller function pointer */
+	void			*dcb_data;   /* caller private data */
+} dmu_tx_callback_t;
+
+/*
+ * Used for dmu tx kstat.
+ */
+typedef struct dmu_tx_stats {
+	kstat_named_t dmu_tx_assigned;
+	kstat_named_t dmu_tx_delay;
+	kstat_named_t dmu_tx_error;
+	kstat_named_t dmu_tx_suspended;
+	kstat_named_t dmu_tx_group;
+	kstat_named_t dmu_tx_memory_reserve;
+	kstat_named_t dmu_tx_memory_reclaim;
+	kstat_named_t dmu_tx_dirty_throttle;
+	kstat_named_t dmu_tx_dirty_delay;
+	kstat_named_t dmu_tx_dirty_over_max;
+	kstat_named_t dmu_tx_dirty_frees_delay;
+	kstat_named_t dmu_tx_quota;
+} dmu_tx_stats_t;
+
+extern dmu_tx_stats_t dmu_tx_stats;
+
+#define	DMU_TX_STAT_INCR(stat, val) \
+    atomic_add_64(&dmu_tx_stats.stat.value.ui64, (val));
+#define	DMU_TX_STAT_BUMP(stat) \
+    DMU_TX_STAT_INCR(stat, 1);
+
+/*
+ * These routines are defined in dmu.h, and are called by the user.
+ */
+dmu_tx_t *dmu_tx_create(objset_t *dd);
+int dmu_tx_assign(dmu_tx_t *tx, uint64_t txg_how);
+void dmu_tx_commit(dmu_tx_t *tx);
+void dmu_tx_abort(dmu_tx_t *tx);
+uint64_t dmu_tx_get_txg(dmu_tx_t *tx);
+struct dsl_pool *dmu_tx_pool(dmu_tx_t *tx);
+void dmu_tx_wait(dmu_tx_t *tx);
+
+/*
+ * These routines are defined in dmu_spa.h, and are called by the SPA.
+ */
+extern dmu_tx_t *dmu_tx_create_assigned(struct dsl_pool *dp, uint64_t txg);
+
+/*
+ * These routines are only called by the DMU.
+ */
+dmu_tx_t *dmu_tx_create_dd(dsl_dir_t *dd);
+int dmu_tx_is_syncing(dmu_tx_t *tx);
+int dmu_tx_private_ok(dmu_tx_t *tx);
+void dmu_tx_add_new_object(dmu_tx_t *tx, dnode_t *dn);
+void dmu_tx_dirty_buf(dmu_tx_t *tx, struct dmu_buf_impl *db);
+void dmu_tx_hold_space(dmu_tx_t *tx, uint64_t space);
+
+#ifdef ZFS_DEBUG
+#define	DMU_TX_DIRTY_BUF(tx, db)	dmu_tx_dirty_buf(tx, db)
+#else
+#define	DMU_TX_DIRTY_BUF(tx, db)
+#endif
+
+void dmu_tx_init(void);
+void dmu_tx_fini(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DMU_TX_H */
diff --git a/include/sys/dmu_zfetch.h b/include/sys/dmu_zfetch.h
new file mode 100644
index 0000000000000..4303ab314ced7
--- /dev/null
+++ b/include/sys/dmu_zfetch.h
@@ -0,0 +1,77 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2014, 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef	_DMU_ZFETCH_H
+#define	_DMU_ZFETCH_H
+
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern unsigned long	zfetch_array_rd_sz;
+
+struct dnode;				/* so we can reference dnode */
+
+typedef struct zstream {
+	uint64_t	zs_blkid;	/* expect next access at this blkid */
+	uint64_t	zs_pf_blkid;	/* next block to prefetch */
+
+	/*
+	 * We will next prefetch the L1 indirect block of this level-0
+	 * block id.
+	 */
+	uint64_t	zs_ipf_blkid;
+
+	kmutex_t	zs_lock;	/* protects stream */
+	hrtime_t	zs_atime;	/* time last prefetch issued */
+	list_node_t	zs_node;	/* link for zf_stream */
+} zstream_t;
+
+typedef struct zfetch {
+	kmutex_t	zf_lock;	/* protects zfetch structure */
+	list_t		zf_stream;	/* list of zstream_t's */
+	struct dnode	*zf_dnode;	/* dnode that owns this zfetch */
+} zfetch_t;
+
+void		zfetch_init(void);
+void		zfetch_fini(void);
+
+void		dmu_zfetch_init(zfetch_t *, struct dnode *);
+void		dmu_zfetch_fini(zfetch_t *);
+void		dmu_zfetch(zfetch_t *, uint64_t, uint64_t, boolean_t,
+    boolean_t);
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _DMU_ZFETCH_H */
diff --git a/include/sys/dnode.h b/include/sys/dnode.h
new file mode 100644
index 0000000000000..3208b60f0e7bf
--- /dev/null
+++ b/include/sys/dnode.h
@@ -0,0 +1,627 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ */
+
+#ifndef	_SYS_DNODE_H
+#define	_SYS_DNODE_H
+
+#include <sys/zfs_context.h>
+#include <sys/avl.h>
+#include <sys/spa.h>
+#include <sys/txg.h>
+#include <sys/zio.h>
+#include <sys/zfs_refcount.h>
+#include <sys/dmu_zfetch.h>
+#include <sys/zrlock.h>
+#include <sys/multilist.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * dnode_hold() flags.
+ */
+#define	DNODE_MUST_BE_ALLOCATED	1
+#define	DNODE_MUST_BE_FREE	2
+#define	DNODE_DRY_RUN		4
+
+/*
+ * dnode_next_offset() flags.
+ */
+#define	DNODE_FIND_HOLE		1
+#define	DNODE_FIND_BACKWARDS	2
+#define	DNODE_FIND_HAVELOCK	4
+
+/*
+ * Fixed constants.
+ */
+#define	DNODE_SHIFT		9	/* 512 bytes */
+#define	DN_MIN_INDBLKSHIFT	12	/* 4k */
+/*
+ * If we ever increase this value beyond 20, we need to revisit all logic that
+ * does x << level * ebps to handle overflow.  With a 1M indirect block size,
+ * 4 levels of indirect blocks would not be able to guarantee addressing an
+ * entire object, so 5 levels will be used, but 5 * (20 - 7) = 65.
+ */
+#define	DN_MAX_INDBLKSHIFT	17	/* 128k */
+#define	DNODE_BLOCK_SHIFT	14	/* 16k */
+#define	DNODE_CORE_SIZE		64	/* 64 bytes for dnode sans blkptrs */
+#define	DN_MAX_OBJECT_SHIFT	48	/* 256 trillion (zfs_fid_t limit) */
+#define	DN_MAX_OFFSET_SHIFT	64	/* 2^64 bytes in a dnode */
+
+/*
+ * dnode id flags
+ *
+ * Note: a file will never ever have its ids moved from bonus->spill
+ */
+#define	DN_ID_CHKED_BONUS	0x1
+#define	DN_ID_CHKED_SPILL	0x2
+#define	DN_ID_OLD_EXIST		0x4
+#define	DN_ID_NEW_EXIST		0x8
+
+/*
+ * Derived constants.
+ */
+#define	DNODE_MIN_SIZE		(1 << DNODE_SHIFT)
+#define	DNODE_MAX_SIZE		(1 << DNODE_BLOCK_SHIFT)
+#define	DNODE_BLOCK_SIZE	(1 << DNODE_BLOCK_SHIFT)
+#define	DNODE_MIN_SLOTS		(DNODE_MIN_SIZE >> DNODE_SHIFT)
+#define	DNODE_MAX_SLOTS		(DNODE_MAX_SIZE >> DNODE_SHIFT)
+#define	DN_BONUS_SIZE(dnsize)	((dnsize) - DNODE_CORE_SIZE - \
+	(1 << SPA_BLKPTRSHIFT))
+#define	DN_SLOTS_TO_BONUSLEN(slots)	DN_BONUS_SIZE((slots) << DNODE_SHIFT)
+#define	DN_OLD_MAX_BONUSLEN	(DN_BONUS_SIZE(DNODE_MIN_SIZE))
+#define	DN_MAX_NBLKPTR	((DNODE_MIN_SIZE - DNODE_CORE_SIZE) >> SPA_BLKPTRSHIFT)
+#define	DN_MAX_OBJECT	(1ULL << DN_MAX_OBJECT_SHIFT)
+#define	DN_ZERO_BONUSLEN	(DN_BONUS_SIZE(DNODE_MAX_SIZE) + 1)
+#define	DN_KILL_SPILLBLK (1)
+
+#define	DN_SLOT_UNINIT		((void *)NULL)	/* Uninitialized */
+#define	DN_SLOT_FREE		((void *)1UL)	/* Free slot */
+#define	DN_SLOT_ALLOCATED	((void *)2UL)	/* Allocated slot */
+#define	DN_SLOT_INTERIOR	((void *)3UL)	/* Interior allocated slot */
+#define	DN_SLOT_IS_PTR(dn)	((void *)dn > DN_SLOT_INTERIOR)
+#define	DN_SLOT_IS_VALID(dn)	((void *)dn != NULL)
+
+#define	DNODES_PER_BLOCK_SHIFT	(DNODE_BLOCK_SHIFT - DNODE_SHIFT)
+#define	DNODES_PER_BLOCK	(1ULL << DNODES_PER_BLOCK_SHIFT)
+
+/*
+ * This is inaccurate if the indblkshift of the particular object is not the
+ * max.  But it's only used by userland to calculate the zvol reservation.
+ */
+#define	DNODES_PER_LEVEL_SHIFT	(DN_MAX_INDBLKSHIFT - SPA_BLKPTRSHIFT)
+#define	DNODES_PER_LEVEL	(1ULL << DNODES_PER_LEVEL_SHIFT)
+
+#define	DN_MAX_LEVELS	(DIV_ROUND_UP(DN_MAX_OFFSET_SHIFT - SPA_MINBLOCKSHIFT, \
+	DN_MIN_INDBLKSHIFT - SPA_BLKPTRSHIFT) + 1)
+
+#define	DN_BONUS(dnp)	((void*)((dnp)->dn_bonus + \
+	(((dnp)->dn_nblkptr - 1) * sizeof (blkptr_t))))
+#define	DN_MAX_BONUS_LEN(dnp) \
+	((dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ? \
+	(uint8_t *)DN_SPILL_BLKPTR(dnp) - (uint8_t *)DN_BONUS(dnp) : \
+	(uint8_t *)(dnp + (dnp->dn_extra_slots + 1)) - (uint8_t *)DN_BONUS(dnp))
+
+#define	DN_USED_BYTES(dnp) (((dnp)->dn_flags & DNODE_FLAG_USED_BYTES) ? \
+	(dnp)->dn_used : (dnp)->dn_used << SPA_MINBLOCKSHIFT)
+
+#define	EPB(blkshift, typeshift)	(1 << (blkshift - typeshift))
+
+struct dmu_buf_impl;
+struct objset;
+struct zio;
+
+enum dnode_dirtycontext {
+	DN_UNDIRTIED,
+	DN_DIRTY_OPEN,
+	DN_DIRTY_SYNC
+};
+
+/* Is dn_used in bytes?  if not, it's in multiples of SPA_MINBLOCKSIZE */
+#define	DNODE_FLAG_USED_BYTES			(1 << 0)
+#define	DNODE_FLAG_USERUSED_ACCOUNTED		(1 << 1)
+
+/* Does dnode have a SA spill blkptr in bonus? */
+#define	DNODE_FLAG_SPILL_BLKPTR			(1 << 2)
+
+/* User/Group/Project dnode accounting */
+#define	DNODE_FLAG_USEROBJUSED_ACCOUNTED	(1 << 3)
+
+/*
+ * This mask defines the set of flags which are "portable", meaning
+ * that they can be preserved when doing a raw encrypted zfs send.
+ * Flags included in this mask will be protected by AAD when the block
+ * of dnodes is encrypted.
+ */
+#define	DNODE_CRYPT_PORTABLE_FLAGS_MASK		(DNODE_FLAG_SPILL_BLKPTR)
+
+/*
+ * VARIABLE-LENGTH (LARGE) DNODES
+ *
+ * The motivation for variable-length dnodes is to eliminate the overhead
+ * associated with using spill blocks.  Spill blocks are used to store
+ * system attribute data (i.e. file metadata) that does not fit in the
+ * dnode's bonus buffer. By allowing a larger bonus buffer area the use of
+ * a spill block can be avoided.  Spill blocks potentially incur an
+ * additional read I/O for every dnode in a dnode block. As a worst case
+ * example, reading 32 dnodes from a 16k dnode block and all of the spill
+ * blocks could issue 33 separate reads. Now suppose those dnodes have size
+ * 1024 and therefore don't need spill blocks. Then the worst case number
+ * of blocks read is reduced to from 33 to two--one per dnode block.
+ *
+ * ZFS-on-Linux systems that make heavy use of extended attributes benefit
+ * from this feature. In particular, ZFS-on-Linux supports the xattr=sa
+ * dataset property which allows file extended attribute data to be stored
+ * in the dnode bonus buffer as an alternative to the traditional
+ * directory-based format. Workloads such as SELinux and the Lustre
+ * distributed filesystem often store enough xattr data to force spill
+ * blocks when xattr=sa is in effect. Large dnodes may therefore provide a
+ * performance benefit to such systems. Other use cases that benefit from
+ * this feature include files with large ACLs and symbolic links with long
+ * target names.
+ *
+ * The size of a dnode may be a multiple of 512 bytes up to the size of a
+ * dnode block (currently 16384 bytes). The dn_extra_slots field of the
+ * on-disk dnode_phys_t structure describes the size of the physical dnode
+ * on disk. The field represents how many "extra" dnode_phys_t slots a
+ * dnode consumes in its dnode block. This convention results in a value of
+ * 0 for 512 byte dnodes which preserves on-disk format compatibility with
+ * older software which doesn't support large dnodes.
+ *
+ * Similarly, the in-memory dnode_t structure has a dn_num_slots field
+ * to represent the total number of dnode_phys_t slots consumed on disk.
+ * Thus dn->dn_num_slots is 1 greater than the corresponding
+ * dnp->dn_extra_slots. This difference in convention was adopted
+ * because, unlike on-disk structures, backward compatibility is not a
+ * concern for in-memory objects, so we used a more natural way to
+ * represent size for a dnode_t.
+ *
+ * The default size for newly created dnodes is determined by the value of
+ * the "dnodesize" dataset property. By default the property is set to
+ * "legacy" which is compatible with older software. Setting the property
+ * to "auto" will allow the filesystem to choose the most suitable dnode
+ * size. Currently this just sets the default dnode size to 1k, but future
+ * code improvements could dynamically choose a size based on observed
+ * workload patterns. Dnodes of varying sizes can coexist within the same
+ * dataset and even within the same dnode block.
+ */
+
+typedef struct dnode_phys {
+	uint8_t dn_type;		/* dmu_object_type_t */
+	uint8_t dn_indblkshift;		/* ln2(indirect block size) */
+	uint8_t dn_nlevels;		/* 1=dn_blkptr->data blocks */
+	uint8_t dn_nblkptr;		/* length of dn_blkptr */
+	uint8_t dn_bonustype;		/* type of data in bonus buffer */
+	uint8_t	dn_checksum;		/* ZIO_CHECKSUM type */
+	uint8_t	dn_compress;		/* ZIO_COMPRESS type */
+	uint8_t dn_flags;		/* DNODE_FLAG_* */
+	uint16_t dn_datablkszsec;	/* data block size in 512b sectors */
+	uint16_t dn_bonuslen;		/* length of dn_bonus */
+	uint8_t dn_extra_slots;		/* # of subsequent slots consumed */
+	uint8_t dn_pad2[3];
+
+	/* accounting is protected by dn_dirty_mtx */
+	uint64_t dn_maxblkid;		/* largest allocated block ID */
+	uint64_t dn_used;		/* bytes (or sectors) of disk space */
+
+	/*
+	 * Both dn_pad2 and dn_pad3 are protected by the block's MAC. This
+	 * allows us to protect any fields that might be added here in the
+	 * future. In either case, developers will want to check
+	 * zio_crypt_init_uios_dnode() to ensure the new field is being
+	 * protected properly.
+	 */
+	uint64_t dn_pad3[4];
+
+	/*
+	 * The tail region is 448 bytes for a 512 byte dnode, and
+	 * correspondingly larger for larger dnode sizes. The spill
+	 * block pointer, when present, is always at the end of the tail
+	 * region. There are three ways this space may be used, using
+	 * a 512 byte dnode for this diagram:
+	 *
+	 * 0       64      128     192     256     320     384     448 (offset)
+	 * +---------------+---------------+---------------+-------+
+	 * | dn_blkptr[0]  | dn_blkptr[1]  | dn_blkptr[2]  | /     |
+	 * +---------------+---------------+---------------+-------+
+	 * | dn_blkptr[0]  | dn_bonus[0..319]                      |
+	 * +---------------+-----------------------+---------------+
+	 * | dn_blkptr[0]  | dn_bonus[0..191]      | dn_spill      |
+	 * +---------------+-----------------------+---------------+
+	 */
+	union {
+		blkptr_t dn_blkptr[1+DN_OLD_MAX_BONUSLEN/sizeof (blkptr_t)];
+		struct {
+			blkptr_t __dn_ignore1;
+			uint8_t dn_bonus[DN_OLD_MAX_BONUSLEN];
+		};
+		struct {
+			blkptr_t __dn_ignore2;
+			uint8_t __dn_ignore3[DN_OLD_MAX_BONUSLEN -
+			    sizeof (blkptr_t)];
+			blkptr_t dn_spill;
+		};
+	};
+} dnode_phys_t;
+
+#define	DN_SPILL_BLKPTR(dnp)	((blkptr_t *)((char *)(dnp) + \
+	(((dnp)->dn_extra_slots + 1) << DNODE_SHIFT) - (1 << SPA_BLKPTRSHIFT)))
+
+struct dnode {
+	/*
+	 * Protects the structure of the dnode, including the number of levels
+	 * of indirection (dn_nlevels), dn_maxblkid, and dn_next_*
+	 */
+	krwlock_t dn_struct_rwlock;
+
+	/* Our link on dn_objset->os_dnodes list; protected by os_lock.  */
+	list_node_t dn_link;
+
+	/* immutable: */
+	struct objset *dn_objset;
+	uint64_t dn_object;
+	struct dmu_buf_impl *dn_dbuf;
+	struct dnode_handle *dn_handle;
+	dnode_phys_t *dn_phys; /* pointer into dn->dn_dbuf->db.db_data */
+
+	/*
+	 * Copies of stuff in dn_phys.  They're valid in the open
+	 * context (eg. even before the dnode is first synced).
+	 * Where necessary, these are protected by dn_struct_rwlock.
+	 */
+	dmu_object_type_t dn_type;	/* object type */
+	uint16_t dn_bonuslen;		/* bonus length */
+	uint8_t dn_bonustype;		/* bonus type */
+	uint8_t dn_nblkptr;		/* number of blkptrs (immutable) */
+	uint8_t dn_checksum;		/* ZIO_CHECKSUM type */
+	uint8_t dn_compress;		/* ZIO_COMPRESS type */
+	uint8_t dn_nlevels;
+	uint8_t dn_indblkshift;
+	uint8_t dn_datablkshift;	/* zero if blksz not power of 2! */
+	uint8_t dn_moved;		/* Has this dnode been moved? */
+	uint16_t dn_datablkszsec;	/* in 512b sectors */
+	uint32_t dn_datablksz;		/* in bytes */
+	uint64_t dn_maxblkid;
+	uint8_t dn_next_type[TXG_SIZE];
+	uint8_t dn_num_slots;		/* metadnode slots consumed on disk */
+	uint8_t dn_next_nblkptr[TXG_SIZE];
+	uint8_t dn_next_nlevels[TXG_SIZE];
+	uint8_t dn_next_indblkshift[TXG_SIZE];
+	uint8_t dn_next_bonustype[TXG_SIZE];
+	uint8_t dn_rm_spillblk[TXG_SIZE];	/* for removing spill blk */
+	uint16_t dn_next_bonuslen[TXG_SIZE];
+	uint32_t dn_next_blksz[TXG_SIZE];	/* next block size in bytes */
+	uint64_t dn_next_maxblkid[TXG_SIZE];	/* next maxblkid in bytes */
+
+	/* protected by dn_dbufs_mtx; declared here to fill 32-bit hole */
+	uint32_t dn_dbufs_count;	/* count of dn_dbufs */
+
+	/* protected by os_lock: */
+	multilist_node_t dn_dirty_link[TXG_SIZE]; /* next on dataset's dirty */
+
+	/* protected by dn_mtx: */
+	kmutex_t dn_mtx;
+	list_t dn_dirty_records[TXG_SIZE];
+	struct range_tree *dn_free_ranges[TXG_SIZE];
+	uint64_t dn_allocated_txg;
+	uint64_t dn_free_txg;
+	uint64_t dn_assigned_txg;
+	uint64_t dn_dirty_txg;			/* txg dnode was last dirtied */
+	kcondvar_t dn_notxholds;
+	kcondvar_t dn_nodnholds;
+	enum dnode_dirtycontext dn_dirtyctx;
+	void *dn_dirtyctx_firstset;		/* dbg: contents meaningless */
+
+	/* protected by own devices */
+	zfs_refcount_t dn_tx_holds;
+	zfs_refcount_t dn_holds;
+
+	kmutex_t dn_dbufs_mtx;
+	/*
+	 * Descendent dbufs, ordered by dbuf_compare. Note that dn_dbufs
+	 * can contain multiple dbufs of the same (level, blkid) when a
+	 * dbuf is marked DB_EVICTING without being removed from
+	 * dn_dbufs. To maintain the avl invariant that there cannot be
+	 * duplicate entries, we order the dbufs by an arbitrary value -
+	 * their address in memory. This means that dn_dbufs cannot be used to
+	 * directly look up a dbuf. Instead, callers must use avl_walk, have
+	 * a reference to the dbuf, or look up a non-existent node with
+	 * db_state = DB_SEARCH (see dbuf_free_range for an example).
+	 */
+	avl_tree_t dn_dbufs;
+
+	/* protected by dn_struct_rwlock */
+	struct dmu_buf_impl *dn_bonus;	/* bonus buffer dbuf */
+
+	boolean_t dn_have_spill;	/* have spill or are spilling */
+
+	/* parent IO for current sync write */
+	zio_t *dn_zio;
+
+	/* used in syncing context */
+	uint64_t dn_oldused;	/* old phys used bytes */
+	uint64_t dn_oldflags;	/* old phys dn_flags */
+	uint64_t dn_olduid, dn_oldgid, dn_oldprojid;
+	uint64_t dn_newuid, dn_newgid, dn_newprojid;
+	int dn_id_flags;
+
+	/* holds prefetch structure */
+	struct zfetch	dn_zfetch;
+};
+
+/*
+ * Since AVL already has embedded element counter, use dn_dbufs_count
+ * only for dbufs not counted there (bonus buffers) and just add them.
+ */
+#define	DN_DBUFS_COUNT(dn)	((dn)->dn_dbufs_count + \
+    avl_numnodes(&(dn)->dn_dbufs))
+
+/*
+ * We use this (otherwise unused) bit to indicate if the value of
+ * dn_next_maxblkid[txgoff] is valid to use in dnode_sync().
+ */
+#define	DMU_NEXT_MAXBLKID_SET		(1ULL << 63)
+
+/*
+ * Adds a level of indirection between the dbuf and the dnode to avoid
+ * iterating descendent dbufs in dnode_move(). Handles are not allocated
+ * individually, but as an array of child dnodes in dnode_hold_impl().
+ */
+typedef struct dnode_handle {
+	/* Protects dnh_dnode from modification by dnode_move(). */
+	zrlock_t dnh_zrlock;
+	dnode_t *dnh_dnode;
+} dnode_handle_t;
+
+typedef struct dnode_children {
+	dmu_buf_user_t dnc_dbu;		/* User evict data */
+	size_t dnc_count;		/* number of children */
+	dnode_handle_t dnc_children[];	/* sized dynamically */
+} dnode_children_t;
+
+typedef struct free_range {
+	avl_node_t fr_node;
+	uint64_t fr_blkid;
+	uint64_t fr_nblks;
+} free_range_t;
+
+void dnode_special_open(struct objset *dd, dnode_phys_t *dnp,
+    uint64_t object, dnode_handle_t *dnh);
+void dnode_special_close(dnode_handle_t *dnh);
+
+void dnode_setbonuslen(dnode_t *dn, int newsize, dmu_tx_t *tx);
+void dnode_setbonus_type(dnode_t *dn, dmu_object_type_t, dmu_tx_t *tx);
+void dnode_rm_spill(dnode_t *dn, dmu_tx_t *tx);
+
+int dnode_hold(struct objset *dd, uint64_t object,
+    void *ref, dnode_t **dnp);
+int dnode_hold_impl(struct objset *dd, uint64_t object, int flag, int dn_slots,
+    void *ref, dnode_t **dnp);
+boolean_t dnode_add_ref(dnode_t *dn, void *ref);
+void dnode_rele(dnode_t *dn, void *ref);
+void dnode_rele_and_unlock(dnode_t *dn, void *tag, boolean_t evicting);
+int dnode_try_claim(objset_t *os, uint64_t object, int slots);
+void dnode_setdirty(dnode_t *dn, dmu_tx_t *tx);
+void dnode_set_dirtyctx(dnode_t *dn, dmu_tx_t *tx, void *tag);
+void dnode_sync(dnode_t *dn, dmu_tx_t *tx);
+void dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,
+    dmu_object_type_t bonustype, int bonuslen, int dn_slots, dmu_tx_t *tx);
+void dnode_reallocate(dnode_t *dn, dmu_object_type_t ot, int blocksize,
+    dmu_object_type_t bonustype, int bonuslen, int dn_slots,
+    boolean_t keep_spill, dmu_tx_t *tx);
+void dnode_free(dnode_t *dn, dmu_tx_t *tx);
+void dnode_byteswap(dnode_phys_t *dnp);
+void dnode_buf_byteswap(void *buf, size_t size);
+void dnode_verify(dnode_t *dn);
+int dnode_set_nlevels(dnode_t *dn, int nlevels, dmu_tx_t *tx);
+int dnode_set_blksz(dnode_t *dn, uint64_t size, int ibs, dmu_tx_t *tx);
+void dnode_free_range(dnode_t *dn, uint64_t off, uint64_t len, dmu_tx_t *tx);
+void dnode_diduse_space(dnode_t *dn, int64_t space);
+void dnode_new_blkid(dnode_t *dn, uint64_t blkid, dmu_tx_t *tx,
+    boolean_t have_read, boolean_t force);
+uint64_t dnode_block_freed(dnode_t *dn, uint64_t blkid);
+void dnode_init(void);
+void dnode_fini(void);
+int dnode_next_offset(dnode_t *dn, int flags, uint64_t *off,
+    int minlvl, uint64_t blkfill, uint64_t txg);
+void dnode_evict_dbufs(dnode_t *dn);
+void dnode_evict_bonus(dnode_t *dn);
+void dnode_free_interior_slots(dnode_t *dn);
+
+#define	DNODE_IS_DIRTY(_dn)						\
+	((_dn)->dn_dirty_txg >= spa_syncing_txg((_dn)->dn_objset->os_spa))
+
+#define	DNODE_IS_CACHEABLE(_dn)						\
+	((_dn)->dn_objset->os_primary_cache == ZFS_CACHE_ALL ||		\
+	(DMU_OT_IS_METADATA((_dn)->dn_type) &&				\
+	(_dn)->dn_objset->os_primary_cache == ZFS_CACHE_METADATA))
+
+#define	DNODE_META_IS_CACHEABLE(_dn)					\
+	((_dn)->dn_objset->os_primary_cache == ZFS_CACHE_ALL ||		\
+	(_dn)->dn_objset->os_primary_cache == ZFS_CACHE_METADATA)
+
+/*
+ * Used for dnodestats kstat.
+ */
+typedef struct dnode_stats {
+	/*
+	 * Number of failed attempts to hold a meta dnode dbuf.
+	 */
+	kstat_named_t dnode_hold_dbuf_hold;
+	/*
+	 * Number of failed attempts to read a meta dnode dbuf.
+	 */
+	kstat_named_t dnode_hold_dbuf_read;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) was able
+	 * to hold the requested object number which was allocated.  This is
+	 * the common case when looking up any allocated object number.
+	 */
+	kstat_named_t dnode_hold_alloc_hits;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) was not
+	 * able to hold the request object number because it was not allocated.
+	 */
+	kstat_named_t dnode_hold_alloc_misses;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) was not
+	 * able to hold the request object number because the object number
+	 * refers to an interior large dnode slot.
+	 */
+	kstat_named_t dnode_hold_alloc_interior;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) needed
+	 * to retry acquiring slot zrl locks due to contention.
+	 */
+	kstat_named_t dnode_hold_alloc_lock_retry;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) did not
+	 * need to create the dnode because another thread did so after
+	 * dropping the read lock but before acquiring the write lock.
+	 */
+	kstat_named_t dnode_hold_alloc_lock_misses;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) found
+	 * a free dnode instantiated by dnode_create() but not yet allocated
+	 * by dnode_allocate().
+	 */
+	kstat_named_t dnode_hold_alloc_type_none;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_FREE) was able
+	 * to hold the requested range of free dnode slots.
+	 */
+	kstat_named_t dnode_hold_free_hits;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_FREE) was not
+	 * able to hold the requested range of free dnode slots because
+	 * at least one slot was allocated.
+	 */
+	kstat_named_t dnode_hold_free_misses;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_FREE) was not
+	 * able to hold the requested range of free dnode slots because
+	 * after acquiring the zrl lock at least one slot was allocated.
+	 */
+	kstat_named_t dnode_hold_free_lock_misses;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_FREE) needed
+	 * to retry acquiring slot zrl locks due to contention.
+	 */
+	kstat_named_t dnode_hold_free_lock_retry;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_FREE) requested
+	 * a range of dnode slots which were held by another thread.
+	 */
+	kstat_named_t dnode_hold_free_refcount;
+	/*
+	 * Number of times dnode_hold(..., DNODE_MUST_BE_FREE) requested
+	 * a range of dnode slots which would overflow the dnode_phys_t.
+	 */
+	kstat_named_t dnode_hold_free_overflow;
+	/*
+	 * Number of times dnode_free_interior_slots() needed to retry
+	 * acquiring a slot zrl lock due to contention.
+	 */
+	kstat_named_t dnode_free_interior_lock_retry;
+	/*
+	 * Number of new dnodes allocated by dnode_allocate().
+	 */
+	kstat_named_t dnode_allocate;
+	/*
+	 * Number of dnodes re-allocated by dnode_reallocate().
+	 */
+	kstat_named_t dnode_reallocate;
+	/*
+	 * Number of meta dnode dbufs evicted.
+	 */
+	kstat_named_t dnode_buf_evict;
+	/*
+	 * Number of times dmu_object_alloc*() reached the end of the existing
+	 * object ID chunk and advanced to a new one.
+	 */
+	kstat_named_t dnode_alloc_next_chunk;
+	/*
+	 * Number of times multiple threads attempted to allocate a dnode
+	 * from the same block of free dnodes.
+	 */
+	kstat_named_t dnode_alloc_race;
+	/*
+	 * Number of times dmu_object_alloc*() was forced to advance to the
+	 * next meta dnode dbuf due to an error from  dmu_object_next().
+	 */
+	kstat_named_t dnode_alloc_next_block;
+	/*
+	 * Statistics for tracking dnodes which have been moved.
+	 */
+	kstat_named_t dnode_move_invalid;
+	kstat_named_t dnode_move_recheck1;
+	kstat_named_t dnode_move_recheck2;
+	kstat_named_t dnode_move_special;
+	kstat_named_t dnode_move_handle;
+	kstat_named_t dnode_move_rwlock;
+	kstat_named_t dnode_move_active;
+} dnode_stats_t;
+
+extern dnode_stats_t dnode_stats;
+
+#define	DNODE_STAT_INCR(stat, val) \
+    atomic_add_64(&dnode_stats.stat.value.ui64, (val));
+#define	DNODE_STAT_BUMP(stat) \
+    DNODE_STAT_INCR(stat, 1);
+
+#ifdef ZFS_DEBUG
+
+#define	dprintf_dnode(dn, fmt, ...) do { \
+	if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
+	char __db_buf[32]; \
+	uint64_t __db_obj = (dn)->dn_object; \
+	if (__db_obj == DMU_META_DNODE_OBJECT) \
+		(void) strcpy(__db_buf, "mdn"); \
+	else \
+		(void) snprintf(__db_buf, sizeof (__db_buf), "%lld", \
+		    (u_longlong_t)__db_obj);\
+	dprintf_ds((dn)->dn_objset->os_dsl_dataset, "obj=%s " fmt, \
+	    __db_buf, __VA_ARGS__); \
+	} \
+_NOTE(CONSTCOND) } while (0)
+
+#define	DNODE_VERIFY(dn)		dnode_verify(dn)
+#define	FREE_VERIFY(db, start, end, tx)	free_verify(db, start, end, tx)
+
+#else
+
+#define	dprintf_dnode(db, fmt, ...)
+#define	DNODE_VERIFY(dn)
+#define	FREE_VERIFY(db, start, end, tx)
+
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DNODE_H */
diff --git a/include/sys/dsl_bookmark.h b/include/sys/dsl_bookmark.h
new file mode 100644
index 0000000000000..70f4813449aa0
--- /dev/null
+++ b/include/sys/dsl_bookmark.h
@@ -0,0 +1,157 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (c) 2013, 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_BOOKMARK_H
+#define	_SYS_DSL_BOOKMARK_H
+
+#include <sys/zfs_context.h>
+#include <sys/zfs_refcount.h>
+#include <sys/dsl_dataset.h>
+#include <sys/dsl_pool.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * On disk zap object.
+ */
+typedef struct zfs_bookmark_phys {
+	uint64_t zbm_guid;		/* guid of bookmarked dataset */
+	uint64_t zbm_creation_txg;	/* birth transaction group */
+	uint64_t zbm_creation_time;	/* bookmark creation time */
+
+	/* fields used for redacted send / recv */
+	uint64_t zbm_redaction_obj;	/* redaction list object */
+	uint64_t zbm_flags;		/* ZBM_FLAG_* */
+
+	/* fields used for bookmark written size */
+	uint64_t zbm_referenced_bytes_refd;
+	uint64_t zbm_compressed_bytes_refd;
+	uint64_t zbm_uncompressed_bytes_refd;
+	uint64_t zbm_referenced_freed_before_next_snap;
+	uint64_t zbm_compressed_freed_before_next_snap;
+	uint64_t zbm_uncompressed_freed_before_next_snap;
+
+	/* fields used for raw sends */
+	uint64_t zbm_ivset_guid;
+} zfs_bookmark_phys_t;
+
+
+#define	BOOKMARK_PHYS_SIZE_V1	(3 * sizeof (uint64_t))
+#define	BOOKMARK_PHYS_SIZE_V2	(12 * sizeof (uint64_t))
+
+typedef enum zbm_flags {
+	ZBM_FLAG_HAS_FBN = (1 << 0),
+	ZBM_FLAG_SNAPSHOT_EXISTS = (1 << 1),
+} zbm_flags_t;
+
+typedef struct redaction_list_phys {
+	uint64_t rlp_last_object;
+	uint64_t rlp_last_blkid;
+	uint64_t rlp_num_entries;
+	uint64_t rlp_num_snaps;
+	uint64_t rlp_snaps[]; /* variable length */
+} redaction_list_phys_t;
+
+typedef struct redaction_list {
+	dmu_buf_user_t		rl_dbu;
+	redaction_list_phys_t	*rl_phys;
+	dmu_buf_t		*rl_dbuf;
+	uint64_t		rl_object;
+	zfs_refcount_t		rl_longholds;
+	objset_t		*rl_mos;
+} redaction_list_t;
+
+/* node in ds_bookmarks */
+typedef struct dsl_bookmark_node {
+	char *dbn_name; /* free with strfree() */
+	kmutex_t dbn_lock; /* protects dirty/phys in block_killed */
+	boolean_t dbn_dirty; /* in currently syncing txg */
+	zfs_bookmark_phys_t dbn_phys;
+	avl_node_t dbn_node;
+} dsl_bookmark_node_t;
+
+typedef struct redact_block_phys {
+	uint64_t	rbp_object;
+	uint64_t	rbp_blkid;
+	/*
+	 * The top 16 bits of this field represent the block size in sectors of
+	 * the blocks in question; the bottom 48 bits are used to store the
+	 * number of consecutive blocks that are in the redaction list.  They
+	 * should be accessed using the inline functions below.
+	 */
+	uint64_t	rbp_size_count;
+	uint64_t	rbp_padding;
+} redact_block_phys_t;
+
+typedef int (*rl_traverse_callback_t)(redact_block_phys_t *, void *);
+
+
+typedef struct dsl_bookmark_create_arg {
+	nvlist_t *dbca_bmarks;
+	nvlist_t *dbca_errors;
+} dsl_bookmark_create_arg_t;
+
+typedef struct dsl_bookmark_create_redacted_arg {
+	const char	*dbcra_bmark;
+	const char	*dbcra_snap;
+	redaction_list_t **dbcra_rl;
+	uint64_t	dbcra_numsnaps;
+	uint64_t	*dbcra_snaps;
+	void		*dbcra_tag;
+} dsl_bookmark_create_redacted_arg_t;
+
+int dsl_bookmark_create(nvlist_t *, nvlist_t *);
+int dsl_bookmark_create_nvl_validate(nvlist_t *);
+int dsl_bookmark_create_check(void *arg, dmu_tx_t *tx);
+void dsl_bookmark_create_sync(void *arg, dmu_tx_t *tx);
+int dsl_bookmark_create_redacted(const char *, const char *, uint64_t,
+    uint64_t *, void *, redaction_list_t **);
+int dsl_get_bookmarks(const char *, nvlist_t *, nvlist_t *);
+int dsl_get_bookmarks_impl(dsl_dataset_t *, nvlist_t *, nvlist_t *);
+int dsl_get_bookmark_props(const char *, const char *, nvlist_t *);
+int dsl_bookmark_destroy(nvlist_t *, nvlist_t *);
+int dsl_bookmark_lookup(struct dsl_pool *, const char *,
+    struct dsl_dataset *, zfs_bookmark_phys_t *);
+int dsl_bookmark_lookup_impl(dsl_dataset_t *, const char *,
+    zfs_bookmark_phys_t *);
+int dsl_redaction_list_hold_obj(struct dsl_pool *, uint64_t, void *,
+    redaction_list_t **);
+void dsl_redaction_list_rele(redaction_list_t *, void *);
+void dsl_redaction_list_long_hold(struct dsl_pool *, redaction_list_t *,
+    void *);
+void dsl_redaction_list_long_rele(redaction_list_t *, void *);
+boolean_t dsl_redaction_list_long_held(redaction_list_t *);
+int dsl_bookmark_init_ds(dsl_dataset_t *);
+void dsl_bookmark_fini_ds(dsl_dataset_t *);
+boolean_t dsl_bookmark_ds_destroyed(dsl_dataset_t *, dmu_tx_t *);
+void dsl_bookmark_snapshotted(dsl_dataset_t *, dmu_tx_t *);
+void dsl_bookmark_block_killed(dsl_dataset_t *, const blkptr_t *, dmu_tx_t *);
+void dsl_bookmark_sync_done(dsl_dataset_t *, dmu_tx_t *);
+void dsl_bookmark_node_add(dsl_dataset_t *, dsl_bookmark_node_t *, dmu_tx_t *);
+uint64_t dsl_bookmark_latest_txg(dsl_dataset_t *);
+int dsl_redaction_list_traverse(redaction_list_t *, zbookmark_phys_t *,
+    rl_traverse_callback_t, void *);
+void dsl_bookmark_next_changed(dsl_dataset_t *, dsl_dataset_t *, dmu_tx_t *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_BOOKMARK_H */
diff --git a/include/sys/dsl_crypt.h b/include/sys/dsl_crypt.h
new file mode 100644
index 0000000000000..835720c878726
--- /dev/null
+++ b/include/sys/dsl_crypt.h
@@ -0,0 +1,225 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2017, Datto, Inc. All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_CRYPT_H
+#define	_SYS_DSL_CRYPT_H
+
+#include <sys/dmu_tx.h>
+#include <sys/dmu.h>
+#include <sys/zio_crypt.h>
+#include <sys/spa.h>
+#include <sys/dsl_dataset.h>
+
+/*
+ * ZAP entry keys for DSL Crypto Keys stored on disk. In addition,
+ * ZFS_PROP_KEYFORMAT, ZFS_PROP_PBKDF2_SALT, and ZFS_PROP_PBKDF2_ITERS are
+ * also maintained here using their respective property names.
+ */
+#define	DSL_CRYPTO_KEY_CRYPTO_SUITE	"DSL_CRYPTO_SUITE"
+#define	DSL_CRYPTO_KEY_GUID		"DSL_CRYPTO_GUID"
+#define	DSL_CRYPTO_KEY_IV		"DSL_CRYPTO_IV"
+#define	DSL_CRYPTO_KEY_MAC		"DSL_CRYPTO_MAC"
+#define	DSL_CRYPTO_KEY_MASTER_KEY	"DSL_CRYPTO_MASTER_KEY_1"
+#define	DSL_CRYPTO_KEY_HMAC_KEY		"DSL_CRYPTO_HMAC_KEY_1"
+#define	DSL_CRYPTO_KEY_ROOT_DDOBJ	"DSL_CRYPTO_ROOT_DDOBJ"
+#define	DSL_CRYPTO_KEY_REFCOUNT		"DSL_CRYPTO_REFCOUNT"
+#define	DSL_CRYPTO_KEY_VERSION		"DSL_CRYPTO_VERSION"
+
+/*
+ * In-memory representation of a wrapping key. One of these structs will exist
+ * for each encryption root with its key loaded.
+ */
+typedef struct dsl_wrapping_key {
+	/* link on spa_keystore_t:sk_wkeys */
+	avl_node_t wk_avl_link;
+
+	/* keyformat property enum */
+	zfs_keyformat_t wk_keyformat;
+
+	/* the pbkdf2 salt, if the keyformat is of type passphrase */
+	uint64_t wk_salt;
+
+	/* the pbkdf2 iterations, if the keyformat is of type passphrase */
+	uint64_t wk_iters;
+
+	/* actual wrapping key */
+	crypto_key_t wk_key;
+
+	/* refcount of number of dsl_crypto_key_t's holding this struct */
+	zfs_refcount_t wk_refcnt;
+
+	/* dsl directory object that owns this wrapping key */
+	uint64_t wk_ddobj;
+} dsl_wrapping_key_t;
+
+/* enum of commands indicating special actions that should be run */
+typedef enum dcp_cmd {
+	/* key creation commands */
+	DCP_CMD_NONE = 0,	/* no specific command */
+	DCP_CMD_RAW_RECV,	/* raw receive */
+
+	/* key changing commands */
+	DCP_CMD_NEW_KEY,	/* rewrap key as an encryption root */
+	DCP_CMD_INHERIT,	/* rewrap key with parent's wrapping key */
+	DCP_CMD_FORCE_NEW_KEY,	/* change to encryption root without rewrap */
+	DCP_CMD_FORCE_INHERIT,	/* inherit parent's key without rewrap */
+
+	DCP_CMD_MAX
+} dcp_cmd_t;
+
+/*
+ * This struct is a simple wrapper around all the parameters that are usually
+ * required to setup encryption. It exists so that all of the params can be
+ * passed around the kernel together for convenience.
+ */
+typedef struct dsl_crypto_params {
+	/* command indicating intended action */
+	dcp_cmd_t cp_cmd;
+
+	/* the encryption algorithm */
+	enum zio_encrypt cp_crypt;
+
+	/* keylocation property string */
+	char *cp_keylocation;
+
+	/* the wrapping key */
+	dsl_wrapping_key_t *cp_wkey;
+} dsl_crypto_params_t;
+
+/*
+ * In-memory representation of a DSL Crypto Key object. One of these structs
+ * (and corresponding on-disk ZAP object) will exist for each encrypted
+ * clone family that is mounted or otherwise reading protected data.
+ */
+typedef struct dsl_crypto_key {
+	/* link on spa_keystore_t:sk_dsl_keys */
+	avl_node_t dck_avl_link;
+
+	/* refcount of holders of this key */
+	zfs_refcount_t dck_holds;
+
+	/* master key used to derive encryption keys */
+	zio_crypt_key_t dck_key;
+
+	/* wrapping key for syncing this structure to disk */
+	dsl_wrapping_key_t *dck_wkey;
+
+	/* on-disk object id */
+	uint64_t dck_obj;
+} dsl_crypto_key_t;
+
+/*
+ * In-memory mapping of a dataset object id to a DSL Crypto Key. This is used
+ * to look up the corresponding dsl_crypto_key_t from the zio layer for
+ * performing data encryption and decryption.
+ */
+typedef struct dsl_key_mapping {
+	/* link on spa_keystore_t:sk_key_mappings */
+	avl_node_t km_avl_link;
+
+	/* refcount of how many users are depending on this mapping */
+	zfs_refcount_t km_refcnt;
+
+	/* dataset this crypto key belongs to (index) */
+	uint64_t km_dsobj;
+
+	/* crypto key (value) of this record */
+	dsl_crypto_key_t *km_key;
+} dsl_key_mapping_t;
+
+/* in memory structure for holding all wrapping and dsl keys */
+typedef struct spa_keystore {
+	/* lock for protecting sk_dsl_keys */
+	krwlock_t sk_dk_lock;
+
+	/* tree of all dsl_crypto_key_t's */
+	avl_tree_t sk_dsl_keys;
+
+	/* lock for protecting sk_key_mappings */
+	krwlock_t sk_km_lock;
+
+	/* tree of all dsl_key_mapping_t's, indexed by dsobj */
+	avl_tree_t sk_key_mappings;
+
+	/* lock for protecting the wrapping keys tree */
+	krwlock_t sk_wkeys_lock;
+
+	/* tree of all dsl_wrapping_key_t's, indexed by ddobj */
+	avl_tree_t sk_wkeys;
+} spa_keystore_t;
+
+int dsl_crypto_params_create_nvlist(dcp_cmd_t cmd, nvlist_t *props,
+    nvlist_t *crypto_args, dsl_crypto_params_t **dcp_out);
+void dsl_crypto_params_free(dsl_crypto_params_t *dcp, boolean_t unload);
+void dsl_dataset_crypt_stats(struct dsl_dataset *ds, nvlist_t *nv);
+int dsl_crypto_can_set_keylocation(const char *dsname, const char *keylocation);
+boolean_t dsl_dir_incompatible_encryption_version(dsl_dir_t *dd);
+
+void spa_keystore_init(spa_keystore_t *sk);
+void spa_keystore_fini(spa_keystore_t *sk);
+
+void spa_keystore_dsl_key_rele(spa_t *spa, dsl_crypto_key_t *dck, void *tag);
+int spa_keystore_load_wkey_impl(spa_t *spa, dsl_wrapping_key_t *wkey);
+int spa_keystore_load_wkey(const char *dsname, dsl_crypto_params_t *dcp,
+    boolean_t noop);
+int spa_keystore_unload_wkey_impl(spa_t *spa, uint64_t ddobj);
+int spa_keystore_unload_wkey(const char *dsname);
+
+int spa_keystore_create_mapping(spa_t *spa, struct dsl_dataset *ds, void *tag,
+    dsl_key_mapping_t **km_out);
+int spa_keystore_remove_mapping(spa_t *spa, uint64_t dsobj, void *tag);
+void key_mapping_add_ref(dsl_key_mapping_t *km, void *tag);
+void key_mapping_rele(spa_t *spa, dsl_key_mapping_t *km, void *tag);
+int spa_keystore_lookup_key(spa_t *spa, uint64_t dsobj, void *tag,
+    dsl_crypto_key_t **dck_out);
+
+int dsl_crypto_populate_key_nvlist(struct objset *os,
+    uint64_t from_ivset_guid, nvlist_t **nvl_out);
+int dsl_crypto_recv_raw_key_check(struct dsl_dataset *ds,
+    nvlist_t *nvl, dmu_tx_t *tx);
+void dsl_crypto_recv_raw_key_sync(struct dsl_dataset *ds,
+    nvlist_t *nvl, dmu_tx_t *tx);
+int dsl_crypto_recv_raw(const char *poolname, uint64_t dsobj, uint64_t fromobj,
+    dmu_objset_type_t ostype, nvlist_t *nvl, boolean_t do_key);
+
+int spa_keystore_change_key(const char *dsname, dsl_crypto_params_t *dcp);
+int dsl_dir_rename_crypt_check(dsl_dir_t *dd, dsl_dir_t *newparent);
+int dsl_dataset_promote_crypt_check(dsl_dir_t *target, dsl_dir_t *origin);
+void dsl_dataset_promote_crypt_sync(dsl_dir_t *target, dsl_dir_t *origin,
+    dmu_tx_t *tx);
+int dmu_objset_create_crypt_check(dsl_dir_t *parentdd,
+    dsl_crypto_params_t *dcp, boolean_t *will_encrypt);
+void dsl_dataset_create_crypt_sync(uint64_t dsobj, dsl_dir_t *dd,
+    struct dsl_dataset *origin, dsl_crypto_params_t *dcp, dmu_tx_t *tx);
+uint64_t dsl_crypto_key_create_sync(uint64_t crypt, dsl_wrapping_key_t *wkey,
+    dmu_tx_t *tx);
+uint64_t dsl_crypto_key_clone_sync(dsl_dir_t *origindd, dmu_tx_t *tx);
+void dsl_crypto_key_destroy_sync(uint64_t dckobj, dmu_tx_t *tx);
+
+int spa_crypt_get_salt(spa_t *spa, uint64_t dsobj, uint8_t *salt);
+int spa_do_crypt_mac_abd(boolean_t generate, spa_t *spa, uint64_t dsobj,
+    abd_t *abd, uint_t datalen, uint8_t *mac);
+int spa_do_crypt_objset_mac_abd(boolean_t generate, spa_t *spa, uint64_t dsobj,
+    abd_t *abd, uint_t datalen, boolean_t byteswap);
+int spa_do_crypt_abd(boolean_t encrypt, spa_t *spa, const zbookmark_phys_t *zb,
+    dmu_object_type_t ot, boolean_t dedup, boolean_t bswap, uint8_t *salt,
+    uint8_t *iv, uint8_t *mac, uint_t datalen, abd_t *pabd, abd_t *cabd,
+    boolean_t *no_crypt);
+
+#endif
diff --git a/include/sys/dsl_dataset.h b/include/sys/dsl_dataset.h
new file mode 100644
index 0000000000000..f5816a934c5f8
--- /dev/null
+++ b/include/sys/dsl_dataset.h
@@ -0,0 +1,508 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2013 Steven Hartland. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_DATASET_H
+#define	_SYS_DSL_DATASET_H
+
+#include <sys/dmu.h>
+#include <sys/spa.h>
+#include <sys/txg.h>
+#include <sys/zio.h>
+#include <sys/bplist.h>
+#include <sys/dsl_synctask.h>
+#include <sys/zfs_context.h>
+#include <sys/dsl_deadlist.h>
+#include <sys/zfs_refcount.h>
+#include <sys/rrwlock.h>
+#include <sys/dsl_crypt.h>
+#include <zfeature_common.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern int zfs_allow_redacted_dataset_mount;
+struct dsl_dataset;
+struct dsl_dir;
+struct dsl_pool;
+struct dsl_crypto_params;
+struct dsl_key_mapping;
+struct zfs_bookmark_phys;
+
+#define	DS_FLAG_INCONSISTENT	(1ULL<<0)
+#define	DS_IS_INCONSISTENT(ds)	\
+	(dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT)
+
+/*
+ * Do not allow this dataset to be promoted.
+ */
+#define	DS_FLAG_NOPROMOTE	(1ULL<<1)
+
+/*
+ * DS_FLAG_UNIQUE_ACCURATE is set if ds_unique_bytes has been correctly
+ * calculated for head datasets (starting with SPA_VERSION_UNIQUE_ACCURATE,
+ * refquota/refreservations).
+ */
+#define	DS_FLAG_UNIQUE_ACCURATE	(1ULL<<2)
+
+/*
+ * DS_FLAG_DEFER_DESTROY is set after 'zfs destroy -d' has been called
+ * on a dataset. This allows the dataset to be destroyed using 'zfs release'.
+ */
+#define	DS_FLAG_DEFER_DESTROY	(1ULL<<3)
+#define	DS_IS_DEFER_DESTROY(ds)	\
+	(dsl_dataset_phys(ds)->ds_flags & DS_FLAG_DEFER_DESTROY)
+
+/*
+ * DS_FIELD_* are strings that are used in the "extensified" dataset zap object.
+ * They should be of the format <reverse-dns>:<field>.
+ */
+
+/*
+ * This field's value is the object ID of a zap object which contains the
+ * bookmarks of this dataset.  If it is present, then this dataset is counted
+ * in the refcount of the SPA_FEATURES_BOOKMARKS feature.
+ */
+#define	DS_FIELD_BOOKMARK_NAMES "com.delphix:bookmarks"
+
+/*
+ * This field is present (with value=0) if this dataset may contain large
+ * dnodes (>512B).  If it is present, then this dataset is counted in the
+ * refcount of the SPA_FEATURE_LARGE_DNODE feature.
+ */
+#define	DS_FIELD_LARGE_DNODE "org.zfsonlinux:large_dnode"
+
+/*
+ * These fields are set on datasets that are in the middle of a resumable
+ * receive, and allow the sender to resume the send if it is interrupted.
+ */
+#define	DS_FIELD_RESUME_FROMGUID "com.delphix:resume_fromguid"
+#define	DS_FIELD_RESUME_TONAME "com.delphix:resume_toname"
+#define	DS_FIELD_RESUME_TOGUID "com.delphix:resume_toguid"
+#define	DS_FIELD_RESUME_OBJECT "com.delphix:resume_object"
+#define	DS_FIELD_RESUME_OFFSET "com.delphix:resume_offset"
+#define	DS_FIELD_RESUME_BYTES "com.delphix:resume_bytes"
+#define	DS_FIELD_RESUME_LARGEBLOCK "com.delphix:resume_largeblockok"
+#define	DS_FIELD_RESUME_EMBEDOK "com.delphix:resume_embedok"
+#define	DS_FIELD_RESUME_COMPRESSOK "com.delphix:resume_compressok"
+#define	DS_FIELD_RESUME_RAWOK "com.datto:resume_rawok"
+
+/*
+ * This field is set to the object number of the remap deadlist if one exists.
+ */
+#define	DS_FIELD_REMAP_DEADLIST	"com.delphix:remap_deadlist"
+
+/*
+ * We were receiving an incremental from a redaction bookmark, and these are the
+ * guids of its snapshots.
+ */
+#define	DS_FIELD_RESUME_REDACT_BOOKMARK_SNAPS \
+	"com.delphix:resume_redact_book_snaps"
+
+/*
+ * This field is set to the ivset guid for encrypted snapshots. This is used
+ * for validating raw receives.
+ */
+#define	DS_FIELD_IVSET_GUID	"com.datto:ivset_guid"
+
+/*
+ * DS_FLAG_CI_DATASET is set if the dataset contains a file system whose
+ * name lookups should be performed case-insensitively.
+ */
+#define	DS_FLAG_CI_DATASET	(1ULL<<16)
+
+#define	DS_CREATE_FLAG_NODIRTY	(1ULL<<24)
+
+typedef struct dsl_dataset_phys {
+	uint64_t ds_dir_obj;		/* DMU_OT_DSL_DIR */
+	uint64_t ds_prev_snap_obj;	/* DMU_OT_DSL_DATASET */
+	uint64_t ds_prev_snap_txg;
+	uint64_t ds_next_snap_obj;	/* DMU_OT_DSL_DATASET */
+	uint64_t ds_snapnames_zapobj;	/* DMU_OT_DSL_DS_SNAP_MAP 0 for snaps */
+	uint64_t ds_num_children;	/* clone/snap children; ==0 for head */
+	uint64_t ds_creation_time;	/* seconds since 1970 */
+	uint64_t ds_creation_txg;
+	uint64_t ds_deadlist_obj;	/* DMU_OT_DEADLIST */
+	/*
+	 * ds_referenced_bytes, ds_compressed_bytes, and ds_uncompressed_bytes
+	 * include all blocks referenced by this dataset, including those
+	 * shared with any other datasets.
+	 */
+	uint64_t ds_referenced_bytes;
+	uint64_t ds_compressed_bytes;
+	uint64_t ds_uncompressed_bytes;
+	uint64_t ds_unique_bytes;	/* only relevant to snapshots */
+	/*
+	 * The ds_fsid_guid is a 56-bit ID that can change to avoid
+	 * collisions.  The ds_guid is a 64-bit ID that will never
+	 * change, so there is a small probability that it will collide.
+	 */
+	uint64_t ds_fsid_guid;
+	uint64_t ds_guid;
+	uint64_t ds_flags;		/* DS_FLAG_* */
+	blkptr_t ds_bp;
+	uint64_t ds_next_clones_obj;	/* DMU_OT_DSL_CLONES */
+	uint64_t ds_props_obj;		/* DMU_OT_DSL_PROPS for snaps */
+	uint64_t ds_userrefs_obj;	/* DMU_OT_USERREFS */
+	uint64_t ds_pad[5]; /* pad out to 320 bytes for good measure */
+} dsl_dataset_phys_t;
+
+typedef struct dsl_dataset {
+	dmu_buf_user_t ds_dbu;
+	rrwlock_t ds_bp_rwlock; /* Protects ds_phys->ds_bp */
+
+	/* Immutable: */
+	struct dsl_dir *ds_dir;
+	dmu_buf_t *ds_dbuf;
+	uint64_t ds_object;
+	uint64_t ds_fsid_guid;
+	boolean_t ds_is_snapshot;
+	struct dsl_key_mapping *ds_key_mapping;
+
+	/* only used in syncing context, only valid for non-snapshots: */
+	struct dsl_dataset *ds_prev;
+	uint64_t ds_bookmarks_obj;  /* DMU_OTN_ZAP_METADATA */
+	avl_tree_t ds_bookmarks; /* dsl_bookmark_node_t */
+
+	/* has internal locking: */
+	dsl_deadlist_t ds_deadlist;
+	bplist_t ds_pending_deadlist;
+
+	/*
+	 * The remap deadlist contains blocks (DVA's, really) that are
+	 * referenced by the previous snapshot and point to indirect vdevs,
+	 * but in this dataset they have been remapped to point to concrete
+	 * (or at least, less-indirect) vdevs.  In other words, the
+	 * physical DVA is referenced by the previous snapshot but not by
+	 * this dataset.  Logically, the DVA continues to be referenced,
+	 * but we are using a different (less indirect) physical DVA.
+	 * This deadlist is used to determine when physical DVAs that
+	 * point to indirect vdevs are no longer referenced anywhere,
+	 * and thus should be marked obsolete.
+	 *
+	 * This is only used if SPA_FEATURE_OBSOLETE_COUNTS is enabled.
+	 */
+	dsl_deadlist_t ds_remap_deadlist;
+	/* protects creation of the ds_remap_deadlist */
+	kmutex_t ds_remap_deadlist_lock;
+
+	/* protected by lock on pool's dp_dirty_datasets list */
+	txg_node_t ds_dirty_link;
+	list_node_t ds_synced_link;
+
+	/*
+	 * ds_phys->ds_<accounting> is also protected by ds_lock.
+	 * Protected by ds_lock:
+	 */
+	kmutex_t ds_lock;
+	objset_t *ds_objset;
+	uint64_t ds_userrefs;
+	void *ds_owner;
+
+	/*
+	 * Long holds prevent the ds from being destroyed; they allow the
+	 * ds to remain held even after dropping the dp_config_rwlock.
+	 * Owning counts as a long hold.  See the comments above
+	 * dsl_pool_hold() for details.
+	 */
+	zfs_refcount_t ds_longholds;
+
+	/* no locking; only for making guesses */
+	uint64_t ds_trysnap_txg;
+
+	/* for objset_open() */
+	kmutex_t ds_opening_lock;
+
+	uint64_t ds_reserved;	/* cached refreservation */
+	uint64_t ds_quota;	/* cached refquota */
+
+	kmutex_t ds_sendstream_lock;
+	list_t ds_sendstreams;
+
+	/*
+	 * When in the middle of a resumable receive, tracks how much
+	 * progress we have made.
+	 */
+	uint64_t ds_resume_object[TXG_SIZE];
+	uint64_t ds_resume_offset[TXG_SIZE];
+	uint64_t ds_resume_bytes[TXG_SIZE];
+
+	/* Protected by our dsl_dir's dd_lock */
+	list_t ds_prop_cbs;
+
+	/*
+	 * For ZFEATURE_FLAG_PER_DATASET features, set if this dataset
+	 * uses this feature.
+	 */
+	void *ds_feature[SPA_FEATURES];
+
+	/*
+	 * Set if we need to activate the feature on this dataset this txg
+	 * (used only in syncing context).
+	 */
+	void *ds_feature_activation[SPA_FEATURES];
+
+	/* Protected by ds_lock; keep at end of struct for better locality */
+	char ds_snapname[ZFS_MAX_DATASET_NAME_LEN];
+} dsl_dataset_t;
+
+static inline dsl_dataset_phys_t *
+dsl_dataset_phys(dsl_dataset_t *ds)
+{
+	return ((dsl_dataset_phys_t *)ds->ds_dbuf->db_data);
+}
+
+typedef struct dsl_dataset_promote_arg {
+	const char *ddpa_clonename;
+	dsl_dataset_t *ddpa_clone;
+	list_t shared_snaps, origin_snaps, clone_snaps;
+	dsl_dataset_t *origin_origin; /* origin of the origin */
+	uint64_t used, comp, uncomp, unique, cloneusedsnap, originusedsnap;
+	nvlist_t *err_ds;
+	cred_t *cr;
+	proc_t *proc;
+} dsl_dataset_promote_arg_t;
+
+typedef struct dsl_dataset_rollback_arg {
+	const char *ddra_fsname;
+	const char *ddra_tosnap;
+	void *ddra_owner;
+	nvlist_t *ddra_result;
+} dsl_dataset_rollback_arg_t;
+
+typedef struct dsl_dataset_snapshot_arg {
+	nvlist_t *ddsa_snaps;
+	nvlist_t *ddsa_props;
+	nvlist_t *ddsa_errors;
+	cred_t *ddsa_cr;
+	proc_t *ddsa_proc;
+} dsl_dataset_snapshot_arg_t;
+
+/*
+ * The max length of a temporary tag prefix is the number of hex digits
+ * required to express UINT64_MAX plus one for the hyphen.
+ */
+#define	MAX_TAG_PREFIX_LEN	17
+
+#define	dsl_dataset_is_snapshot(ds) \
+	(dsl_dataset_phys(ds)->ds_num_children != 0)
+
+#define	DS_UNIQUE_IS_ACCURATE(ds)	\
+	((dsl_dataset_phys(ds)->ds_flags & DS_FLAG_UNIQUE_ACCURATE) != 0)
+
+/* flags for holding the dataset */
+typedef enum ds_hold_flags {
+	DS_HOLD_FLAG_DECRYPT	= 1 << 0 /* needs access to encrypted data */
+} ds_hold_flags_t;
+
+int dsl_dataset_hold(struct dsl_pool *dp, const char *name, void *tag,
+    dsl_dataset_t **dsp);
+int dsl_dataset_hold_flags(struct dsl_pool *dp, const char *name,
+    ds_hold_flags_t flags, void *tag, dsl_dataset_t **dsp);
+boolean_t dsl_dataset_try_add_ref(struct dsl_pool *dp, dsl_dataset_t *ds,
+    void *tag);
+int dsl_dataset_create_key_mapping(dsl_dataset_t *ds);
+int dsl_dataset_hold_obj_flags(struct dsl_pool *dp, uint64_t dsobj,
+    ds_hold_flags_t flags, void *tag, dsl_dataset_t **);
+void dsl_dataset_remove_key_mapping(dsl_dataset_t *ds);
+int dsl_dataset_hold_obj(struct dsl_pool *dp, uint64_t dsobj,
+    void *tag, dsl_dataset_t **);
+void dsl_dataset_rele_flags(dsl_dataset_t *ds, ds_hold_flags_t flags,
+    void *tag);
+void dsl_dataset_rele(dsl_dataset_t *ds, void *tag);
+int dsl_dataset_own(struct dsl_pool *dp, const char *name,
+    ds_hold_flags_t flags, void *tag, dsl_dataset_t **dsp);
+int dsl_dataset_own_force(struct dsl_pool *dp, const char *name,
+    ds_hold_flags_t flags, void *tag, dsl_dataset_t **dsp);
+int dsl_dataset_own_obj(struct dsl_pool *dp, uint64_t dsobj,
+    ds_hold_flags_t flags, void *tag, dsl_dataset_t **dsp);
+int dsl_dataset_own_obj_force(struct dsl_pool *dp, uint64_t dsobj,
+    ds_hold_flags_t flags, void *tag, dsl_dataset_t **dsp);
+void dsl_dataset_disown(dsl_dataset_t *ds, ds_hold_flags_t flags, void *tag);
+void dsl_dataset_name(dsl_dataset_t *ds, char *name);
+boolean_t dsl_dataset_tryown(dsl_dataset_t *ds, void *tag, boolean_t override);
+int dsl_dataset_namelen(dsl_dataset_t *ds);
+boolean_t dsl_dataset_has_owner(dsl_dataset_t *ds);
+uint64_t dsl_dataset_create_sync(dsl_dir_t *pds, const char *lastname,
+    dsl_dataset_t *origin, uint64_t flags, cred_t *,
+    struct dsl_crypto_params *, dmu_tx_t *);
+uint64_t dsl_dataset_create_sync_dd(dsl_dir_t *dd, dsl_dataset_t *origin,
+    struct dsl_crypto_params *dcp, uint64_t flags, dmu_tx_t *tx);
+void dsl_dataset_snapshot_sync(void *arg, dmu_tx_t *tx);
+int dsl_dataset_snapshot_check(void *arg, dmu_tx_t *tx);
+int dsl_dataset_snapshot(nvlist_t *snaps, nvlist_t *props, nvlist_t *errors);
+void dsl_dataset_promote_sync(void *arg, dmu_tx_t *tx);
+int dsl_dataset_promote_check(void *arg, dmu_tx_t *tx);
+int dsl_dataset_promote(const char *name, char *conflsnap);
+int dsl_dataset_rename_snapshot(const char *fsname,
+    const char *oldsnapname, const char *newsnapname, boolean_t recursive);
+int dsl_dataset_snapshot_tmp(const char *fsname, const char *snapname,
+    minor_t cleanup_minor, const char *htag);
+
+blkptr_t *dsl_dataset_get_blkptr(dsl_dataset_t *ds);
+
+spa_t *dsl_dataset_get_spa(dsl_dataset_t *ds);
+
+boolean_t dsl_dataset_modified_since_snap(dsl_dataset_t *ds,
+    dsl_dataset_t *snap);
+
+void dsl_dataset_sync(dsl_dataset_t *ds, zio_t *zio, dmu_tx_t *tx);
+void dsl_dataset_sync_done(dsl_dataset_t *ds, dmu_tx_t *tx);
+
+void dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp,
+    dmu_tx_t *tx);
+int dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp,
+    dmu_tx_t *tx, boolean_t async);
+void dsl_dataset_block_remapped(dsl_dataset_t *ds, uint64_t vdev,
+    uint64_t offset, uint64_t size, uint64_t birth, dmu_tx_t *tx);
+int dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name,
+    uint64_t *value);
+
+void dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx);
+
+int get_clones_stat_impl(dsl_dataset_t *ds, nvlist_t *val);
+char *get_receive_resume_stats_impl(dsl_dataset_t *ds);
+char *get_child_receive_stats(dsl_dataset_t *ds);
+uint64_t dsl_get_refratio(dsl_dataset_t *ds);
+uint64_t dsl_get_logicalreferenced(dsl_dataset_t *ds);
+uint64_t dsl_get_compressratio(dsl_dataset_t *ds);
+uint64_t dsl_get_used(dsl_dataset_t *ds);
+uint64_t dsl_get_creation(dsl_dataset_t *ds);
+uint64_t dsl_get_creationtxg(dsl_dataset_t *ds);
+uint64_t dsl_get_refquota(dsl_dataset_t *ds);
+uint64_t dsl_get_refreservation(dsl_dataset_t *ds);
+uint64_t dsl_get_guid(dsl_dataset_t *ds);
+uint64_t dsl_get_unique(dsl_dataset_t *ds);
+uint64_t dsl_get_objsetid(dsl_dataset_t *ds);
+uint64_t dsl_get_userrefs(dsl_dataset_t *ds);
+uint64_t dsl_get_defer_destroy(dsl_dataset_t *ds);
+uint64_t dsl_get_referenced(dsl_dataset_t *ds);
+uint64_t dsl_get_numclones(dsl_dataset_t *ds);
+uint64_t dsl_get_inconsistent(dsl_dataset_t *ds);
+uint64_t dsl_get_redacted(dsl_dataset_t *ds);
+uint64_t dsl_get_available(dsl_dataset_t *ds);
+int dsl_get_written(dsl_dataset_t *ds, uint64_t *written);
+int dsl_get_prev_snap(dsl_dataset_t *ds, char *snap);
+void dsl_get_redact_snaps(dsl_dataset_t *ds, nvlist_t *propval);
+int dsl_get_mountpoint(dsl_dataset_t *ds, const char *dsname, char *value,
+    char *source);
+
+void get_clones_stat(dsl_dataset_t *ds, nvlist_t *nv);
+void dsl_dataset_stats(dsl_dataset_t *os, nvlist_t *nv);
+
+void dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat);
+void dsl_dataset_space(dsl_dataset_t *ds,
+    uint64_t *refdbytesp, uint64_t *availbytesp,
+    uint64_t *usedobjsp, uint64_t *availobjsp);
+uint64_t dsl_dataset_fsid_guid(dsl_dataset_t *ds);
+int dsl_dataset_space_written(dsl_dataset_t *oldsnap, dsl_dataset_t *newds,
+    uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
+int dsl_dataset_space_written_bookmark(struct zfs_bookmark_phys *bmp,
+    dsl_dataset_t *newds, uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
+int dsl_dataset_space_wouldfree(dsl_dataset_t *firstsnap, dsl_dataset_t *last,
+    uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
+
+int dsl_dsobj_to_dsname(char *pname, uint64_t obj, char *buf);
+
+int dsl_dataset_check_quota(dsl_dataset_t *ds, boolean_t check_quota,
+    uint64_t asize, uint64_t inflight, uint64_t *used,
+    uint64_t *ref_rsrv);
+int dsl_dataset_set_refquota(const char *dsname, zprop_source_t source,
+    uint64_t quota);
+int dsl_dataset_set_refreservation(const char *dsname, zprop_source_t source,
+    uint64_t reservation);
+int dsl_dataset_set_compression(const char *dsname, zprop_source_t source,
+    uint64_t compression);
+
+boolean_t dsl_dataset_is_before(dsl_dataset_t *later, dsl_dataset_t *earlier,
+    uint64_t earlier_txg);
+void dsl_dataset_long_hold(dsl_dataset_t *ds, void *tag);
+void dsl_dataset_long_rele(dsl_dataset_t *ds, void *tag);
+boolean_t dsl_dataset_long_held(dsl_dataset_t *ds);
+
+int dsl_dataset_clone_swap_check_impl(dsl_dataset_t *clone,
+    dsl_dataset_t *origin_head, boolean_t force, void *owner, dmu_tx_t *tx);
+void dsl_dataset_clone_swap_sync_impl(dsl_dataset_t *clone,
+    dsl_dataset_t *origin_head, dmu_tx_t *tx);
+int dsl_dataset_snapshot_check_impl(dsl_dataset_t *ds, const char *snapname,
+    dmu_tx_t *tx, boolean_t recv, uint64_t cnt, cred_t *cr, proc_t *proc);
+void dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname,
+    dmu_tx_t *tx);
+
+void dsl_dataset_remove_from_next_clones(dsl_dataset_t *ds, uint64_t obj,
+    dmu_tx_t *tx);
+void dsl_dataset_recalc_head_uniq(dsl_dataset_t *ds);
+int dsl_dataset_get_snapname(dsl_dataset_t *ds);
+int dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name,
+    uint64_t *value);
+int dsl_dataset_snap_remove(dsl_dataset_t *ds, const char *name, dmu_tx_t *tx,
+    boolean_t adj_cnt);
+void dsl_dataset_set_refreservation_sync_impl(dsl_dataset_t *ds,
+    zprop_source_t source, uint64_t value, dmu_tx_t *tx);
+void dsl_dataset_zapify(dsl_dataset_t *ds, dmu_tx_t *tx);
+boolean_t dsl_dataset_is_zapified(dsl_dataset_t *ds);
+boolean_t dsl_dataset_has_resume_receive_state(dsl_dataset_t *ds);
+
+int dsl_dataset_rollback_check(void *arg, dmu_tx_t *tx);
+void dsl_dataset_rollback_sync(void *arg, dmu_tx_t *tx);
+int dsl_dataset_rollback(const char *fsname, const char *tosnap, void *owner,
+    nvlist_t *result);
+
+uint64_t dsl_dataset_get_remap_deadlist_object(dsl_dataset_t *ds);
+void dsl_dataset_create_remap_deadlist(dsl_dataset_t *ds, dmu_tx_t *tx);
+boolean_t dsl_dataset_remap_deadlist_exists(dsl_dataset_t *ds);
+void dsl_dataset_destroy_remap_deadlist(dsl_dataset_t *ds, dmu_tx_t *tx);
+
+void dsl_dataset_activate_feature(uint64_t dsobj, spa_feature_t f, void *arg,
+    dmu_tx_t *tx);
+void dsl_dataset_deactivate_feature(dsl_dataset_t *ds, spa_feature_t f,
+    dmu_tx_t *tx);
+boolean_t dsl_dataset_feature_is_active(dsl_dataset_t *ds, spa_feature_t f);
+boolean_t dsl_dataset_get_uint64_array_feature(dsl_dataset_t *ds,
+    spa_feature_t f, uint64_t *outlength, uint64_t **outp);
+
+void dsl_dataset_activate_redaction(dsl_dataset_t *ds, uint64_t *redact_snaps,
+    uint64_t num_redact_snaps, dmu_tx_t *tx);
+
+#ifdef ZFS_DEBUG
+#define	dprintf_ds(ds, fmt, ...) do { \
+	if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
+	char *__ds_name = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); \
+	dsl_dataset_name(ds, __ds_name); \
+	dprintf("ds=%s " fmt, __ds_name, __VA_ARGS__); \
+	kmem_free(__ds_name, ZFS_MAX_DATASET_NAME_LEN); \
+	} \
+_NOTE(CONSTCOND) } while (0)
+#else
+#define	dprintf_ds(dd, fmt, ...)
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_DATASET_H */
diff --git a/include/sys/dsl_deadlist.h b/include/sys/dsl_deadlist.h
new file mode 100644
index 0000000000000..64358bb5fc0ba
--- /dev/null
+++ b/include/sys/dsl_deadlist.h
@@ -0,0 +1,128 @@
+/*
+ * 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) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_DEADLIST_H
+#define	_SYS_DSL_DEADLIST_H
+
+#include <sys/bpobj.h>
+#include <sys/zfs_context.h>
+#include <sys/zthr.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct dmu_buf;
+struct dsl_pool;
+struct dsl_dataset;
+
+typedef struct dsl_deadlist_phys {
+	uint64_t dl_used;
+	uint64_t dl_comp;
+	uint64_t dl_uncomp;
+	uint64_t dl_pad[37]; /* pad out to 320b for future expansion */
+} dsl_deadlist_phys_t;
+
+typedef struct dsl_deadlist {
+	objset_t *dl_os;
+	uint64_t dl_object;
+	avl_tree_t dl_tree; /* contains dsl_deadlist_entry_t */
+	avl_tree_t dl_cache; /* contains dsl_deadlist_cache_entry_t */
+	boolean_t dl_havetree;
+	boolean_t dl_havecache;
+	struct dmu_buf *dl_dbuf;
+	dsl_deadlist_phys_t *dl_phys;
+	kmutex_t dl_lock;
+
+	/* if it's the old on-disk format: */
+	bpobj_t dl_bpobj;
+	boolean_t dl_oldfmt;
+} dsl_deadlist_t;
+
+typedef struct dsl_deadlist_cache_entry {
+	avl_node_t dlce_node;
+	uint64_t dlce_mintxg;
+	uint64_t dlce_bpobj;
+	uint64_t dlce_bytes;
+	uint64_t dlce_comp;
+	uint64_t dlce_uncomp;
+} dsl_deadlist_cache_entry_t;
+
+typedef struct dsl_deadlist_entry {
+	avl_node_t dle_node;
+	uint64_t dle_mintxg;
+	bpobj_t dle_bpobj;
+} dsl_deadlist_entry_t;
+
+typedef struct livelist_condense_entry {
+	struct dsl_dataset *ds;
+	dsl_deadlist_entry_t *first;
+	dsl_deadlist_entry_t *next;
+	boolean_t syncing;
+	boolean_t cancelled;
+} livelist_condense_entry_t;
+
+extern unsigned long zfs_livelist_max_entries;
+extern int zfs_livelist_min_percent_shared;
+
+typedef int deadlist_iter_t(void *args, dsl_deadlist_entry_t *dle);
+
+void dsl_deadlist_open(dsl_deadlist_t *dl, objset_t *os, uint64_t object);
+void dsl_deadlist_close(dsl_deadlist_t *dl);
+void dsl_deadlist_iterate(dsl_deadlist_t *dl, deadlist_iter_t func, void *arg);
+uint64_t dsl_deadlist_alloc(objset_t *os, dmu_tx_t *tx);
+void dsl_deadlist_free(objset_t *os, uint64_t dlobj, dmu_tx_t *tx);
+void dsl_deadlist_insert(dsl_deadlist_t *dl, const blkptr_t *bp,
+    boolean_t free, dmu_tx_t *tx);
+int dsl_deadlist_insert_alloc_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx);
+int dsl_deadlist_insert_free_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx);
+void dsl_deadlist_add_key(dsl_deadlist_t *dl, uint64_t mintxg, dmu_tx_t *tx);
+void dsl_deadlist_remove_key(dsl_deadlist_t *dl, uint64_t mintxg, dmu_tx_t *tx);
+void dsl_deadlist_remove_entry(dsl_deadlist_t *dl, uint64_t mintxg,
+dmu_tx_t *tx);
+dsl_deadlist_entry_t *dsl_deadlist_first(dsl_deadlist_t *dl);
+dsl_deadlist_entry_t *dsl_deadlist_last(dsl_deadlist_t *dl);
+uint64_t dsl_deadlist_clone(dsl_deadlist_t *dl, uint64_t maxtxg,
+    uint64_t mrs_obj, dmu_tx_t *tx);
+void dsl_deadlist_space(dsl_deadlist_t *dl,
+    uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
+void dsl_deadlist_space_range(dsl_deadlist_t *dl,
+    uint64_t mintxg, uint64_t maxtxg,
+    uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
+void dsl_deadlist_merge(dsl_deadlist_t *dl, uint64_t obj, dmu_tx_t *tx);
+void dsl_deadlist_move_bpobj(dsl_deadlist_t *dl, bpobj_t *bpo, uint64_t mintxg,
+    dmu_tx_t *tx);
+boolean_t dsl_deadlist_is_open(dsl_deadlist_t *dl);
+int dsl_process_sub_livelist(bpobj_t *bpobj, struct bplist *to_free,
+    zthr_t *t, uint64_t *size);
+void dsl_deadlist_clear_entry(dsl_deadlist_entry_t *dle, dsl_deadlist_t *dl,
+    dmu_tx_t *tx);
+void dsl_deadlist_discard_tree(dsl_deadlist_t *dl);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_DEADLIST_H */
diff --git a/include/sys/dsl_deleg.h b/include/sys/dsl_deleg.h
new file mode 100644
index 0000000000000..7f46233a889b1
--- /dev/null
+++ b/include/sys/dsl_deleg.h
@@ -0,0 +1,90 @@
+/*
+ * 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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2015 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_DELEG_H
+#define	_SYS_DSL_DELEG_H
+
+#include <sys/dmu.h>
+#include <sys/dsl_pool.h>
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	ZFS_DELEG_PERM_NONE		""
+#define	ZFS_DELEG_PERM_CREATE		"create"
+#define	ZFS_DELEG_PERM_DESTROY		"destroy"
+#define	ZFS_DELEG_PERM_SNAPSHOT		"snapshot"
+#define	ZFS_DELEG_PERM_ROLLBACK		"rollback"
+#define	ZFS_DELEG_PERM_CLONE		"clone"
+#define	ZFS_DELEG_PERM_PROMOTE		"promote"
+#define	ZFS_DELEG_PERM_RENAME		"rename"
+#define	ZFS_DELEG_PERM_MOUNT		"mount"
+#define	ZFS_DELEG_PERM_SHARE		"share"
+#define	ZFS_DELEG_PERM_SEND		"send"
+#define	ZFS_DELEG_PERM_RECEIVE		"receive"
+#define	ZFS_DELEG_PERM_ALLOW		"allow"
+#define	ZFS_DELEG_PERM_USERPROP		"userprop"
+#define	ZFS_DELEG_PERM_VSCAN		"vscan"
+#define	ZFS_DELEG_PERM_USERQUOTA	"userquota"
+#define	ZFS_DELEG_PERM_GROUPQUOTA	"groupquota"
+#define	ZFS_DELEG_PERM_USEROBJQUOTA	"userobjquota"
+#define	ZFS_DELEG_PERM_GROUPOBJQUOTA	"groupobjquota"
+#define	ZFS_DELEG_PERM_USERUSED		"userused"
+#define	ZFS_DELEG_PERM_GROUPUSED	"groupused"
+#define	ZFS_DELEG_PERM_USEROBJUSED	"userobjused"
+#define	ZFS_DELEG_PERM_GROUPOBJUSED	"groupobjused"
+#define	ZFS_DELEG_PERM_HOLD		"hold"
+#define	ZFS_DELEG_PERM_RELEASE		"release"
+#define	ZFS_DELEG_PERM_DIFF		"diff"
+#define	ZFS_DELEG_PERM_BOOKMARK		"bookmark"
+#define	ZFS_DELEG_PERM_LOAD_KEY		"load-key"
+#define	ZFS_DELEG_PERM_CHANGE_KEY	"change-key"
+#define	ZFS_DELEG_PERM_PROJECTUSED	"projectused"
+#define	ZFS_DELEG_PERM_PROJECTQUOTA	"projectquota"
+#define	ZFS_DELEG_PERM_PROJECTOBJUSED	"projectobjused"
+#define	ZFS_DELEG_PERM_PROJECTOBJQUOTA	"projectobjquota"
+
+/*
+ * Note: the names of properties that are marked delegatable are also
+ * valid delegated permissions
+ */
+
+int dsl_deleg_get(const char *ddname, nvlist_t **nvp);
+int dsl_deleg_set(const char *ddname, nvlist_t *nvp, boolean_t unset);
+int dsl_deleg_access(const char *ddname, const char *perm, cred_t *cr);
+int dsl_deleg_access_impl(struct dsl_dataset *ds, const char *perm, cred_t *cr);
+void dsl_deleg_set_create_perms(dsl_dir_t *dd, dmu_tx_t *tx, cred_t *cr);
+int dsl_deleg_can_allow(char *ddname, nvlist_t *nvp, cred_t *cr);
+int dsl_deleg_can_unallow(char *ddname, nvlist_t *nvp, cred_t *cr);
+int dsl_deleg_destroy(objset_t *os, uint64_t zapobj, dmu_tx_t *tx);
+boolean_t dsl_delegation_on(objset_t *os);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DSL_DELEG_H */
diff --git a/include/sys/dsl_destroy.h b/include/sys/dsl_destroy.h
new file mode 100644
index 0000000000000..208d75bacffab
--- /dev/null
+++ b/include/sys/dsl_destroy.h
@@ -0,0 +1,70 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2012, Joyent, Inc. All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_DESTROY_H
+#define	_SYS_DSL_DESTROY_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct nvlist;
+struct dsl_dataset;
+struct dsl_pool;
+struct dmu_tx;
+
+int dsl_destroy_snapshots_nvl(struct nvlist *, boolean_t,
+    struct nvlist *);
+int dsl_destroy_snapshot(const char *, boolean_t);
+int dsl_destroy_head(const char *);
+int dsl_destroy_head_check_impl(struct dsl_dataset *, int);
+void dsl_destroy_head_sync_impl(struct dsl_dataset *, struct dmu_tx *);
+int dsl_destroy_inconsistent(const char *, void *);
+int dsl_destroy_snapshot_check_impl(struct dsl_dataset *, boolean_t);
+void dsl_destroy_snapshot_sync_impl(struct dsl_dataset *,
+    boolean_t, struct dmu_tx *);
+void dsl_dir_remove_clones_key(dsl_dir_t *, uint64_t, dmu_tx_t *);
+
+typedef struct dsl_destroy_snapshot_arg {
+	const char *ddsa_name;
+	boolean_t ddsa_defer;
+} dsl_destroy_snapshot_arg_t;
+
+int dsl_destroy_snapshot_check(void *, dmu_tx_t *);
+void dsl_destroy_snapshot_sync(void *, dmu_tx_t *);
+
+typedef struct dsl_destroy_head_arg {
+	const char *ddha_name;
+} dsl_destroy_head_arg_t;
+
+int dsl_destroy_head_check(void *, dmu_tx_t *);
+void dsl_destroy_head_sync(void *, dmu_tx_t *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_DESTROY_H */
diff --git a/include/sys/dsl_dir.h b/include/sys/dsl_dir.h
new file mode 100644
index 0000000000000..7cf5093c2c304
--- /dev/null
+++ b/include/sys/dsl_dir.h
@@ -0,0 +1,227 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2014, Joyent, Inc. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_DIR_H
+#define	_SYS_DSL_DIR_H
+
+#include <sys/dmu.h>
+#include <sys/dsl_deadlist.h>
+#include <sys/dsl_pool.h>
+#include <sys/dsl_synctask.h>
+#include <sys/zfs_refcount.h>
+#include <sys/zfs_context.h>
+#include <sys/dsl_crypt.h>
+#include <sys/bplist.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct dsl_dataset;
+struct zthr;
+/*
+ * DD_FIELD_* are strings that are used in the "extensified" dsl_dir zap object.
+ * They should be of the format <reverse-dns>:<field>.
+ */
+
+#define	DD_FIELD_FILESYSTEM_COUNT	"com.joyent:filesystem_count"
+#define	DD_FIELD_SNAPSHOT_COUNT		"com.joyent:snapshot_count"
+#define	DD_FIELD_CRYPTO_KEY_OBJ		"com.datto:crypto_key_obj"
+#define	DD_FIELD_LIVELIST		"com.delphix:livelist"
+
+typedef enum dd_used {
+	DD_USED_HEAD,
+	DD_USED_SNAP,
+	DD_USED_CHILD,
+	DD_USED_CHILD_RSRV,
+	DD_USED_REFRSRV,
+	DD_USED_NUM
+} dd_used_t;
+
+#define	DD_FLAG_USED_BREAKDOWN (1<<0)
+
+typedef struct dsl_dir_phys {
+	uint64_t dd_creation_time; /* not actually used */
+	uint64_t dd_head_dataset_obj;
+	uint64_t dd_parent_obj;
+	uint64_t dd_origin_obj;
+	uint64_t dd_child_dir_zapobj;
+	/*
+	 * how much space our children are accounting for; for leaf
+	 * datasets, == physical space used by fs + snaps
+	 */
+	uint64_t dd_used_bytes;
+	uint64_t dd_compressed_bytes;
+	uint64_t dd_uncompressed_bytes;
+	/* Administrative quota setting */
+	uint64_t dd_quota;
+	/* Administrative reservation setting */
+	uint64_t dd_reserved;
+	uint64_t dd_props_zapobj;
+	uint64_t dd_deleg_zapobj; /* dataset delegation permissions */
+	uint64_t dd_flags;
+	uint64_t dd_used_breakdown[DD_USED_NUM];
+	uint64_t dd_clones; /* dsl_dir objects */
+	uint64_t dd_pad[13]; /* pad out to 256 bytes for good measure */
+} dsl_dir_phys_t;
+
+struct dsl_dir {
+	dmu_buf_user_t dd_dbu;
+
+	/* These are immutable; no lock needed: */
+	uint64_t dd_object;
+	uint64_t dd_crypto_obj;
+	dsl_pool_t *dd_pool;
+
+	/* Stable until user eviction; no lock needed: */
+	dmu_buf_t *dd_dbuf;
+
+	/* protected by lock on pool's dp_dirty_dirs list */
+	txg_node_t dd_dirty_link;
+
+	/* protected by dp_config_rwlock */
+	dsl_dir_t *dd_parent;
+
+	/* Protected by dd_lock */
+	kmutex_t dd_lock;
+	list_t dd_props; /* list of dsl_prop_record_t's */
+	inode_timespec_t dd_snap_cmtime; /* last snapshot namespace change */
+	uint64_t dd_origin_txg;
+
+	/* gross estimate of space used by in-flight tx's */
+	uint64_t dd_tempreserved[TXG_SIZE];
+	/* amount of space we expect to write; == amount of dirty data */
+	int64_t dd_space_towrite[TXG_SIZE];
+
+	dsl_deadlist_t dd_livelist;
+	bplist_t dd_pending_frees;
+	bplist_t dd_pending_allocs;
+
+	kmutex_t dd_activity_lock;
+	kcondvar_t dd_activity_cv;
+	boolean_t dd_activity_cancelled;
+	uint64_t dd_activity_waiters;
+
+	/* protected by dd_lock; keep at end of struct for better locality */
+	char dd_myname[ZFS_MAX_DATASET_NAME_LEN];
+};
+
+static inline dsl_dir_phys_t *
+dsl_dir_phys(dsl_dir_t *dd)
+{
+	return (dd->dd_dbuf->db_data);
+}
+
+void dsl_dir_rele(dsl_dir_t *dd, void *tag);
+void dsl_dir_async_rele(dsl_dir_t *dd, void *tag);
+int dsl_dir_hold(dsl_pool_t *dp, const char *name, void *tag,
+    dsl_dir_t **, const char **tail);
+int dsl_dir_hold_obj(dsl_pool_t *dp, uint64_t ddobj,
+    const char *tail, void *tag, dsl_dir_t **);
+void dsl_dir_name(dsl_dir_t *dd, char *buf);
+int dsl_dir_namelen(dsl_dir_t *dd);
+uint64_t dsl_dir_create_sync(dsl_pool_t *dp, dsl_dir_t *pds,
+    const char *name, dmu_tx_t *tx);
+
+uint64_t dsl_dir_get_used(dsl_dir_t *dd);
+uint64_t dsl_dir_get_compressed(dsl_dir_t *dd);
+uint64_t dsl_dir_get_quota(dsl_dir_t *dd);
+uint64_t dsl_dir_get_reservation(dsl_dir_t *dd);
+uint64_t dsl_dir_get_compressratio(dsl_dir_t *dd);
+uint64_t dsl_dir_get_logicalused(dsl_dir_t *dd);
+uint64_t dsl_dir_get_usedsnap(dsl_dir_t *dd);
+uint64_t dsl_dir_get_usedds(dsl_dir_t *dd);
+uint64_t dsl_dir_get_usedrefreserv(dsl_dir_t *dd);
+uint64_t dsl_dir_get_usedchild(dsl_dir_t *dd);
+void dsl_dir_get_origin(dsl_dir_t *dd, char *buf);
+int dsl_dir_get_filesystem_count(dsl_dir_t *dd, uint64_t *count);
+int dsl_dir_get_snapshot_count(dsl_dir_t *dd, uint64_t *count);
+
+void dsl_dir_stats(dsl_dir_t *dd, nvlist_t *nv);
+uint64_t dsl_dir_space_available(dsl_dir_t *dd,
+    dsl_dir_t *ancestor, int64_t delta, int ondiskonly);
+void dsl_dir_dirty(dsl_dir_t *dd, dmu_tx_t *tx);
+void dsl_dir_sync(dsl_dir_t *dd, dmu_tx_t *tx);
+int dsl_dir_tempreserve_space(dsl_dir_t *dd, uint64_t mem,
+    uint64_t asize, boolean_t netfree, void **tr_cookiep, dmu_tx_t *tx);
+void dsl_dir_tempreserve_clear(void *tr_cookie, dmu_tx_t *tx);
+void dsl_dir_willuse_space(dsl_dir_t *dd, int64_t space, dmu_tx_t *tx);
+void dsl_dir_diduse_space(dsl_dir_t *dd, dd_used_t type,
+    int64_t used, int64_t compressed, int64_t uncompressed, dmu_tx_t *tx);
+void dsl_dir_transfer_space(dsl_dir_t *dd, int64_t delta,
+    dd_used_t oldtype, dd_used_t newtype, dmu_tx_t *tx);
+int dsl_dir_set_quota(const char *ddname, zprop_source_t source,
+    uint64_t quota);
+int dsl_dir_set_reservation(const char *ddname, zprop_source_t source,
+    uint64_t reservation);
+int dsl_dir_activate_fs_ss_limit(const char *);
+int dsl_fs_ss_limit_check(dsl_dir_t *, uint64_t, zfs_prop_t, dsl_dir_t *,
+    cred_t *, proc_t *);
+void dsl_fs_ss_count_adjust(dsl_dir_t *, int64_t, const char *, dmu_tx_t *);
+int dsl_dir_rename(const char *oldname, const char *newname);
+int dsl_dir_transfer_possible(dsl_dir_t *sdd, dsl_dir_t *tdd,
+    uint64_t fs_cnt, uint64_t ss_cnt, uint64_t space, cred_t *, proc_t *);
+boolean_t dsl_dir_is_clone(dsl_dir_t *dd);
+void dsl_dir_new_refreservation(dsl_dir_t *dd, struct dsl_dataset *ds,
+    uint64_t reservation, cred_t *cr, dmu_tx_t *tx);
+void dsl_dir_snap_cmtime_update(dsl_dir_t *dd);
+inode_timespec_t dsl_dir_snap_cmtime(dsl_dir_t *dd);
+void dsl_dir_set_reservation_sync_impl(dsl_dir_t *dd, uint64_t value,
+    dmu_tx_t *tx);
+void dsl_dir_zapify(dsl_dir_t *dd, dmu_tx_t *tx);
+boolean_t dsl_dir_is_zapified(dsl_dir_t *dd);
+void dsl_dir_livelist_open(dsl_dir_t *dd, uint64_t obj);
+void dsl_dir_livelist_close(dsl_dir_t *dd);
+void dsl_dir_remove_livelist(dsl_dir_t *dd, dmu_tx_t *tx, boolean_t total);
+int dsl_dir_wait(dsl_dir_t *dd, dsl_dataset_t *ds, zfs_wait_activity_t activity,
+    boolean_t *waited);
+void dsl_dir_cancel_waiters(dsl_dir_t *dd);
+
+/* internal reserved dir name */
+#define	MOS_DIR_NAME "$MOS"
+#define	ORIGIN_DIR_NAME "$ORIGIN"
+#define	FREE_DIR_NAME "$FREE"
+#define	LEAK_DIR_NAME "$LEAK"
+
+#ifdef ZFS_DEBUG
+#define	dprintf_dd(dd, fmt, ...) do { \
+	if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
+	char *__ds_name = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); \
+	dsl_dir_name(dd, __ds_name); \
+	dprintf("dd=%s " fmt, __ds_name, __VA_ARGS__); \
+	kmem_free(__ds_name, ZFS_MAX_DATASET_NAME_LEN); \
+	} \
+_NOTE(CONSTCOND) } while (0)
+#else
+#define	dprintf_dd(dd, fmt, ...)
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_DIR_H */
diff --git a/include/sys/dsl_pool.h b/include/sys/dsl_pool.h
new file mode 100644
index 0000000000000..8249bb8fc633f
--- /dev/null
+++ b/include/sys/dsl_pool.h
@@ -0,0 +1,199 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2018 by Delphix. All rights reserved.
+ * Copyright 2016 Nexenta Systems, Inc.  All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_POOL_H
+#define	_SYS_DSL_POOL_H
+
+#include <sys/spa.h>
+#include <sys/txg.h>
+#include <sys/txg_impl.h>
+#include <sys/zfs_context.h>
+#include <sys/zio.h>
+#include <sys/dnode.h>
+#include <sys/ddt.h>
+#include <sys/arc.h>
+#include <sys/bpobj.h>
+#include <sys/bptree.h>
+#include <sys/rrwlock.h>
+#include <sys/dsl_synctask.h>
+#include <sys/mmp.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern int zfs_txg_synctime_ms;
+
+struct objset;
+struct dsl_dir;
+struct dsl_dataset;
+struct dsl_pool;
+struct dmu_tx;
+struct dsl_scan;
+struct dsl_crypto_params;
+struct dsl_deadlist;
+
+extern unsigned long zfs_dirty_data_max;
+extern unsigned long zfs_dirty_data_max_max;
+extern int zfs_dirty_data_sync_percent;
+extern int zfs_dirty_data_max_percent;
+extern int zfs_dirty_data_max_max_percent;
+extern int zfs_delay_min_dirty_percent;
+extern unsigned long zfs_delay_scale;
+
+/* These macros are for indexing into the zfs_all_blkstats_t. */
+#define	DMU_OT_DEFERRED	DMU_OT_NONE
+#define	DMU_OT_OTHER	DMU_OT_NUMTYPES /* place holder for DMU_OT() types */
+#define	DMU_OT_TOTAL	(DMU_OT_NUMTYPES + 1)
+
+typedef struct zfs_blkstat {
+	uint64_t	zb_count;
+	uint64_t	zb_asize;
+	uint64_t	zb_lsize;
+	uint64_t	zb_psize;
+	uint64_t	zb_gangs;
+	uint64_t	zb_ditto_2_of_2_samevdev;
+	uint64_t	zb_ditto_2_of_3_samevdev;
+	uint64_t	zb_ditto_3_of_3_samevdev;
+} zfs_blkstat_t;
+
+typedef struct zfs_all_blkstats {
+	zfs_blkstat_t	zab_type[DN_MAX_LEVELS + 1][DMU_OT_TOTAL + 1];
+	kmutex_t	zab_lock;
+} zfs_all_blkstats_t;
+
+
+typedef struct dsl_pool {
+	/* Immutable */
+	spa_t *dp_spa;
+	struct objset *dp_meta_objset;
+	struct dsl_dir *dp_root_dir;
+	struct dsl_dir *dp_mos_dir;
+	struct dsl_dir *dp_free_dir;
+	struct dsl_dir *dp_leak_dir;
+	struct dsl_dataset *dp_origin_snap;
+	uint64_t dp_root_dir_obj;
+	struct taskq *dp_zrele_taskq;
+	struct taskq *dp_unlinked_drain_taskq;
+
+	/* No lock needed - sync context only */
+	blkptr_t dp_meta_rootbp;
+	uint64_t dp_tmp_userrefs_obj;
+	bpobj_t dp_free_bpobj;
+	uint64_t dp_bptree_obj;
+	uint64_t dp_empty_bpobj;
+	bpobj_t dp_obsolete_bpobj;
+
+	struct dsl_scan *dp_scan;
+
+	/* Uses dp_lock */
+	kmutex_t dp_lock;
+	kcondvar_t dp_spaceavail_cv;
+	uint64_t dp_dirty_pertxg[TXG_SIZE];
+	uint64_t dp_dirty_total;
+	uint64_t dp_long_free_dirty_pertxg[TXG_SIZE];
+	uint64_t dp_mos_used_delta;
+	uint64_t dp_mos_compressed_delta;
+	uint64_t dp_mos_uncompressed_delta;
+
+	/*
+	 * Time of most recently scheduled (furthest in the future)
+	 * wakeup for delayed transactions.
+	 */
+	hrtime_t dp_last_wakeup;
+
+	/* Has its own locking */
+	tx_state_t dp_tx;
+	txg_list_t dp_dirty_datasets;
+	txg_list_t dp_dirty_zilogs;
+	txg_list_t dp_dirty_dirs;
+	txg_list_t dp_sync_tasks;
+	txg_list_t dp_early_sync_tasks;
+	taskq_t *dp_sync_taskq;
+	taskq_t *dp_zil_clean_taskq;
+
+	/*
+	 * Protects administrative changes (properties, namespace)
+	 *
+	 * It is only held for write in syncing context.  Therefore
+	 * syncing context does not need to ever have it for read, since
+	 * nobody else could possibly have it for write.
+	 */
+	rrwlock_t dp_config_rwlock;
+
+	zfs_all_blkstats_t *dp_blkstats;
+} dsl_pool_t;
+
+int dsl_pool_init(spa_t *spa, uint64_t txg, dsl_pool_t **dpp);
+int dsl_pool_open(dsl_pool_t *dp);
+void dsl_pool_close(dsl_pool_t *dp);
+dsl_pool_t *dsl_pool_create(spa_t *spa, nvlist_t *zplprops,
+    struct dsl_crypto_params *dcp, uint64_t txg);
+void dsl_pool_sync(dsl_pool_t *dp, uint64_t txg);
+void dsl_pool_sync_done(dsl_pool_t *dp, uint64_t txg);
+int dsl_pool_sync_context(dsl_pool_t *dp);
+uint64_t dsl_pool_adjustedsize(dsl_pool_t *dp, zfs_space_check_t slop_policy);
+uint64_t dsl_pool_unreserved_space(dsl_pool_t *dp,
+    zfs_space_check_t slop_policy);
+void dsl_pool_dirty_space(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx);
+void dsl_pool_undirty_space(dsl_pool_t *dp, int64_t space, uint64_t txg);
+void dsl_free(dsl_pool_t *dp, uint64_t txg, const blkptr_t *bpp);
+void dsl_free_sync(zio_t *pio, dsl_pool_t *dp, uint64_t txg,
+    const blkptr_t *bpp);
+void dsl_pool_create_origin(dsl_pool_t *dp, dmu_tx_t *tx);
+void dsl_pool_upgrade_clones(dsl_pool_t *dp, dmu_tx_t *tx);
+void dsl_pool_upgrade_dir_clones(dsl_pool_t *dp, dmu_tx_t *tx);
+void dsl_pool_mos_diduse_space(dsl_pool_t *dp,
+    int64_t used, int64_t comp, int64_t uncomp);
+void dsl_pool_ckpoint_diduse_space(dsl_pool_t *dp,
+    int64_t used, int64_t comp, int64_t uncomp);
+boolean_t dsl_pool_need_dirty_delay(dsl_pool_t *dp);
+void dsl_pool_config_enter(dsl_pool_t *dp, void *tag);
+void dsl_pool_config_enter_prio(dsl_pool_t *dp, void *tag);
+void dsl_pool_config_exit(dsl_pool_t *dp, void *tag);
+boolean_t dsl_pool_config_held(dsl_pool_t *dp);
+boolean_t dsl_pool_config_held_writer(dsl_pool_t *dp);
+
+taskq_t *dsl_pool_zrele_taskq(dsl_pool_t *dp);
+taskq_t *dsl_pool_unlinked_drain_taskq(dsl_pool_t *dp);
+
+int dsl_pool_user_hold(dsl_pool_t *dp, uint64_t dsobj,
+    const char *tag, uint64_t now, dmu_tx_t *tx);
+int dsl_pool_user_release(dsl_pool_t *dp, uint64_t dsobj,
+    const char *tag, dmu_tx_t *tx);
+void dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp);
+int dsl_pool_open_special_dir(dsl_pool_t *dp, const char *name, dsl_dir_t **);
+int dsl_pool_hold(const char *name, void *tag, dsl_pool_t **dp);
+void dsl_pool_rele(dsl_pool_t *dp, void *tag);
+
+void dsl_pool_create_obsolete_bpobj(dsl_pool_t *dp, dmu_tx_t *tx);
+void dsl_pool_destroy_obsolete_bpobj(dsl_pool_t *dp, dmu_tx_t *tx);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_POOL_H */
diff --git a/include/sys/dsl_prop.h b/include/sys/dsl_prop.h
new file mode 100644
index 0000000000000..fba8f908dc9ef
--- /dev/null
+++ b/include/sys/dsl_prop.h
@@ -0,0 +1,126 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012 by Delphix. All rights reserved.
+ * Copyright 2019 Joyent, Inc.
+ */
+
+#ifndef	_SYS_DSL_PROP_H
+#define	_SYS_DSL_PROP_H
+
+#include <sys/dmu.h>
+#include <sys/dsl_pool.h>
+#include <sys/zfs_context.h>
+#include <sys/dsl_synctask.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct dsl_dataset;
+struct dsl_dir;
+
+/* The callback func may not call into the DMU or DSL! */
+typedef void (dsl_prop_changed_cb_t)(void *arg, uint64_t newval);
+
+typedef struct dsl_prop_record {
+	list_node_t pr_node; /* link on dd_props */
+	const char *pr_propname;
+	list_t pr_cbs;
+} dsl_prop_record_t;
+
+typedef struct dsl_prop_cb_record {
+	list_node_t cbr_pr_node; /* link on pr_cbs */
+	list_node_t cbr_ds_node; /* link on ds_prop_cbs */
+	dsl_prop_record_t *cbr_pr;
+	struct dsl_dataset *cbr_ds;
+	dsl_prop_changed_cb_t *cbr_func;
+	void *cbr_arg;
+} dsl_prop_cb_record_t;
+
+typedef struct dsl_props_arg {
+	nvlist_t *pa_props;
+	zprop_source_t pa_source;
+} dsl_props_arg_t;
+
+typedef struct dsl_props_set_arg {
+	const char *dpsa_dsname;
+	zprop_source_t dpsa_source;
+	nvlist_t *dpsa_props;
+} dsl_props_set_arg_t;
+
+void dsl_prop_init(dsl_dir_t *dd);
+void dsl_prop_fini(dsl_dir_t *dd);
+int dsl_prop_register(struct dsl_dataset *ds, const char *propname,
+    dsl_prop_changed_cb_t *callback, void *cbarg);
+int dsl_prop_unregister(struct dsl_dataset *ds, const char *propname,
+    dsl_prop_changed_cb_t *callback, void *cbarg);
+void dsl_prop_unregister_all(struct dsl_dataset *ds, void *cbarg);
+void dsl_prop_notify_all(struct dsl_dir *dd);
+boolean_t dsl_prop_hascb(struct dsl_dataset *ds);
+
+int dsl_prop_get(const char *ddname, const char *propname,
+    int intsz, int numints, void *buf, char *setpoint);
+int dsl_prop_get_integer(const char *ddname, const char *propname,
+    uint64_t *valuep, char *setpoint);
+int dsl_prop_get_all(objset_t *os, nvlist_t **nvp);
+int dsl_prop_get_received(const char *dsname, nvlist_t **nvp);
+int dsl_prop_get_ds(struct dsl_dataset *ds, const char *propname,
+    int intsz, int numints, void *buf, char *setpoint);
+int dsl_prop_get_int_ds(struct dsl_dataset *ds, const char *propname,
+    uint64_t *valuep);
+int dsl_prop_get_dd(struct dsl_dir *dd, const char *propname,
+    int intsz, int numints, void *buf, char *setpoint,
+    boolean_t snapshot);
+
+int dsl_props_set_check(void *arg, dmu_tx_t *tx);
+void dsl_props_set_sync(void *arg, dmu_tx_t *tx);
+void dsl_props_set_sync_impl(struct dsl_dataset *ds, zprop_source_t source,
+    nvlist_t *props, dmu_tx_t *tx);
+void dsl_prop_set_sync_impl(struct dsl_dataset *ds, const char *propname,
+    zprop_source_t source, int intsz, int numints, const void *value,
+    dmu_tx_t *tx);
+int dsl_props_set(const char *dsname, zprop_source_t source, nvlist_t *nvl);
+int dsl_prop_set_int(const char *dsname, const char *propname,
+    zprop_source_t source, uint64_t value);
+int dsl_prop_set_string(const char *dsname, const char *propname,
+    zprop_source_t source, const char *value);
+int dsl_prop_inherit(const char *dsname, const char *propname,
+    zprop_source_t source);
+
+int dsl_prop_predict(dsl_dir_t *dd, const char *propname,
+    zprop_source_t source, uint64_t value, uint64_t *newvalp);
+
+/* flag first receive on or after SPA_VERSION_RECVD_PROPS */
+boolean_t dsl_prop_get_hasrecvd(const char *dsname);
+int dsl_prop_set_hasrecvd(const char *dsname);
+void dsl_prop_unset_hasrecvd(const char *dsname);
+
+void dsl_prop_nvlist_add_uint64(nvlist_t *nv, zfs_prop_t prop, uint64_t value);
+void dsl_prop_nvlist_add_string(nvlist_t *nv,
+    zfs_prop_t prop, const char *value);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DSL_PROP_H */
diff --git a/include/sys/dsl_scan.h b/include/sys/dsl_scan.h
new file mode 100644
index 0000000000000..8f929207d2d7d
--- /dev/null
+++ b/include/sys/dsl_scan.h
@@ -0,0 +1,193 @@
+/*
+ * 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) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2017 by Delphix. All rights reserved.
+ * Copyright (c) 2017, 2019, Datto Inc. All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_SCAN_H
+#define	_SYS_DSL_SCAN_H
+
+#include <sys/zfs_context.h>
+#include <sys/zio.h>
+#include <sys/ddt.h>
+#include <sys/bplist.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct objset;
+struct dsl_dir;
+struct dsl_dataset;
+struct dsl_pool;
+struct dmu_tx;
+
+extern int zfs_scan_suspend_progress;
+
+/*
+ * All members of this structure must be uint64_t, for byteswap
+ * purposes.
+ */
+typedef struct dsl_scan_phys {
+	uint64_t scn_func; /* pool_scan_func_t */
+	uint64_t scn_state; /* dsl_scan_state_t */
+	uint64_t scn_queue_obj;
+	uint64_t scn_min_txg;
+	uint64_t scn_max_txg;
+	uint64_t scn_cur_min_txg;
+	uint64_t scn_cur_max_txg;
+	uint64_t scn_start_time;
+	uint64_t scn_end_time;
+	uint64_t scn_to_examine; /* total bytes to be scanned */
+	uint64_t scn_examined; /* bytes scanned so far */
+	uint64_t scn_to_process;
+	uint64_t scn_processed;
+	uint64_t scn_errors;	/* scan I/O error count */
+	uint64_t scn_ddt_class_max;
+	ddt_bookmark_t scn_ddt_bookmark;
+	zbookmark_phys_t scn_bookmark;
+	uint64_t scn_flags; /* dsl_scan_flags_t */
+} dsl_scan_phys_t;
+
+#define	SCAN_PHYS_NUMINTS (sizeof (dsl_scan_phys_t) / sizeof (uint64_t))
+
+typedef enum dsl_scan_flags {
+	DSF_VISIT_DS_AGAIN = 1<<0,
+	DSF_SCRUB_PAUSED = 1<<1,
+} dsl_scan_flags_t;
+
+#define	DSL_SCAN_FLAGS_MASK (DSF_VISIT_DS_AGAIN)
+
+/*
+ * Every pool will have one dsl_scan_t and this structure will contain
+ * in-memory information about the scan and a pointer to the on-disk
+ * representation (i.e. dsl_scan_phys_t). Most of the state of the scan
+ * is contained on-disk to allow the scan to resume in the event of a reboot
+ * or panic. This structure maintains information about the behavior of a
+ * running scan, some caching information, and how it should traverse the pool.
+ *
+ * The following members of this structure direct the behavior of the scan:
+ *
+ * scn_suspending -	a scan that cannot be completed in a single txg or
+ *			has exceeded its allotted time will need to suspend.
+ *			When this flag is set the scanner will stop traversing
+ *			the pool and write out the current state to disk.
+ *
+ * scn_restart_txg -	directs the scanner to either restart or start a
+ *			a scan at the specified txg value.
+ *
+ * scn_done_txg -	when a scan completes its traversal it will set
+ *			the completion txg to the next txg. This is necessary
+ *			to ensure that any blocks that were freed during
+ *			the scan but have not yet been processed (i.e deferred
+ *			frees) are accounted for.
+ *
+ * This structure also maintains information about deferred frees which are
+ * a special kind of traversal. Deferred free can exist in either a bptree or
+ * a bpobj structure. The scn_is_bptree flag will indicate the type of
+ * deferred free that is in progress. If the deferred free is part of an
+ * asynchronous destroy then the scn_async_destroying flag will be set.
+ */
+typedef struct dsl_scan {
+	struct dsl_pool *scn_dp;
+	uint64_t scn_restart_txg;
+	uint64_t scn_done_txg;
+	uint64_t scn_sync_start_time;
+	uint64_t scn_issued_before_pass;
+
+	/* for freeing blocks */
+	boolean_t scn_is_bptree;
+	boolean_t scn_async_destroying;
+	boolean_t scn_async_stalled;
+	uint64_t  scn_async_block_min_time_ms;
+
+	/* flags and stats for controlling scan state */
+	boolean_t scn_is_sorted;	/* doing sequential scan */
+	boolean_t scn_clearing;		/* scan is issuing sequential extents */
+	boolean_t scn_checkpointing;	/* scan is issuing all queued extents */
+	boolean_t scn_suspending;	/* scan is suspending until next txg */
+	uint64_t scn_last_checkpoint;	/* time of last checkpoint */
+
+	/* members for thread synchronization */
+	zio_t *scn_zio_root;		/* root zio for waiting on IO */
+	taskq_t *scn_taskq;		/* task queue for issuing extents */
+
+	/* for controlling scan prefetch, protected by spa_scrub_lock */
+	boolean_t scn_prefetch_stop;	/* prefetch should stop */
+	zbookmark_phys_t scn_prefetch_bookmark;	/* prefetch start bookmark */
+	avl_tree_t scn_prefetch_queue;	/* priority queue of prefetch IOs */
+	uint64_t scn_maxinflight_bytes; /* max bytes in flight for pool */
+
+	/* per txg statistics */
+	uint64_t scn_visited_this_txg;	/* total bps visited this txg */
+	uint64_t scn_dedup_frees_this_txg;	/* dedup bps freed this txg */
+	uint64_t scn_holes_this_txg;
+	uint64_t scn_lt_min_this_txg;
+	uint64_t scn_gt_max_this_txg;
+	uint64_t scn_ddt_contained_this_txg;
+	uint64_t scn_objsets_visited_this_txg;
+	uint64_t scn_avg_seg_size_this_txg;
+	uint64_t scn_segs_this_txg;
+	uint64_t scn_avg_zio_size_this_txg;
+	uint64_t scn_zios_this_txg;
+
+	/* members needed for syncing scan status to disk */
+	dsl_scan_phys_t scn_phys;	/* on disk representation of scan */
+	dsl_scan_phys_t scn_phys_cached;
+	avl_tree_t scn_queue;		/* queue of datasets to scan */
+	uint64_t scn_bytes_pending;	/* outstanding data to issue */
+} dsl_scan_t;
+
+typedef struct dsl_scan_io_queue dsl_scan_io_queue_t;
+
+void scan_init(void);
+void scan_fini(void);
+int dsl_scan_init(struct dsl_pool *dp, uint64_t txg);
+void dsl_scan_fini(struct dsl_pool *dp);
+void dsl_scan_sync(struct dsl_pool *, dmu_tx_t *);
+int dsl_scan_cancel(struct dsl_pool *);
+int dsl_scan(struct dsl_pool *, pool_scan_func_t);
+void dsl_scan_assess_vdev(struct dsl_pool *dp, vdev_t *vd);
+boolean_t dsl_scan_scrubbing(const struct dsl_pool *dp);
+int dsl_scrub_set_pause_resume(const struct dsl_pool *dp, pool_scrub_cmd_t cmd);
+void dsl_scan_restart_resilver(struct dsl_pool *, uint64_t txg);
+boolean_t dsl_scan_resilvering(struct dsl_pool *dp);
+boolean_t dsl_scan_resilver_scheduled(struct dsl_pool *dp);
+boolean_t dsl_dataset_unstable(struct dsl_dataset *ds);
+void dsl_scan_ddt_entry(dsl_scan_t *scn, enum zio_checksum checksum,
+    ddt_entry_t *dde, dmu_tx_t *tx);
+void dsl_scan_ds_destroyed(struct dsl_dataset *ds, struct dmu_tx *tx);
+void dsl_scan_ds_snapshotted(struct dsl_dataset *ds, struct dmu_tx *tx);
+void dsl_scan_ds_clone_swapped(struct dsl_dataset *ds1, struct dsl_dataset *ds2,
+    struct dmu_tx *tx);
+boolean_t dsl_scan_active(dsl_scan_t *scn);
+boolean_t dsl_scan_is_paused_scrub(const dsl_scan_t *scn);
+void dsl_scan_freed(spa_t *spa, const blkptr_t *bp);
+void dsl_scan_io_queue_destroy(dsl_scan_io_queue_t *queue);
+void dsl_scan_io_queue_vdev_xfer(vdev_t *svd, vdev_t *tvd);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_SCAN_H */
diff --git a/include/sys/dsl_synctask.h b/include/sys/dsl_synctask.h
new file mode 100644
index 0000000000000..957963ffe553c
--- /dev/null
+++ b/include/sys/dsl_synctask.h
@@ -0,0 +1,127 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_SYNCTASK_H
+#define	_SYS_DSL_SYNCTASK_H
+
+#include <sys/txg.h>
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct dsl_pool;
+
+typedef int (dsl_checkfunc_t)(void *, dmu_tx_t *);
+typedef void (dsl_syncfunc_t)(void *, dmu_tx_t *);
+typedef void (dsl_sigfunc_t)(void *, dmu_tx_t *);
+
+typedef enum zfs_space_check {
+	/*
+	 * Normal space check: if there is less than 3.2% free space,
+	 * the operation will fail.  Operations which are logically
+	 * creating things should use this (e.g. "zfs create", "zfs snapshot").
+	 * User writes (via the ZPL / ZVOL) also fail at this point.
+	 */
+	ZFS_SPACE_CHECK_NORMAL,
+
+	/*
+	 * Space check allows use of half the slop space.  If there
+	 * is less than 1.6% free space, the operation will fail.  Most
+	 * operations should use this (e.g. "zfs set", "zfs rename"),
+	 * because we want them to succeed even after user writes are failing,
+	 * so that they can be used as part of the space recovery process.
+	 */
+	ZFS_SPACE_CHECK_RESERVED,
+
+	/*
+	 * Space check allows use of three quarters of the slop space.
+	 * If there is less than 0.8% free space, the operation will
+	 * fail.
+	 */
+	ZFS_SPACE_CHECK_EXTRA_RESERVED,
+
+	/*
+	 * In all cases "zfs destroy" is expected to result in an net
+	 * reduction of space, except one. When the pool has a
+	 * checkpoint, space freed by "zfs destroy" will not actually
+	 * free anything internally. Thus, it starts failing after
+	 * three quarters of the slop space is exceeded.
+	 */
+	ZFS_SPACE_CHECK_DESTROY = ZFS_SPACE_CHECK_EXTRA_RESERVED,
+
+	/*
+	 * A channel program can run a "zfs destroy" as part of its
+	 * script and therefore has the same space_check policy when
+	 * being evaluated.
+	 */
+	ZFS_SPACE_CHECK_ZCP_EVAL = ZFS_SPACE_CHECK_DESTROY,
+
+	/*
+	 * No space check is performed. This level of space check should
+	 * be used cautiously as operations that use it can even run when
+	 * 0.8% capacity is left for use. In this scenario, if there is a
+	 * checkpoint, async destroys are suspended and any kind of freeing
+	 * can potentially add space instead of freeing it.
+	 *
+	 * See also the comments above spa_slop_shift.
+	 */
+	ZFS_SPACE_CHECK_NONE,
+
+	ZFS_SPACE_CHECK_DISCARD_CHECKPOINT = ZFS_SPACE_CHECK_NONE,
+
+} zfs_space_check_t;
+
+typedef struct dsl_sync_task {
+	txg_node_t dst_node;
+	struct dsl_pool *dst_pool;
+	uint64_t dst_txg;
+	int dst_space;
+	zfs_space_check_t dst_space_check;
+	dsl_checkfunc_t *dst_checkfunc;
+	dsl_syncfunc_t *dst_syncfunc;
+	void *dst_arg;
+	int dst_error;
+	boolean_t dst_nowaiter;
+} dsl_sync_task_t;
+
+void dsl_sync_task_sync(dsl_sync_task_t *, dmu_tx_t *);
+int dsl_sync_task(const char *, dsl_checkfunc_t *,
+    dsl_syncfunc_t *, void *, int, zfs_space_check_t);
+void dsl_sync_task_nowait(struct dsl_pool *, dsl_syncfunc_t *,
+    void *, int, zfs_space_check_t, dmu_tx_t *);
+int dsl_early_sync_task(const char *, dsl_checkfunc_t *,
+    dsl_syncfunc_t *, void *, int, zfs_space_check_t);
+void dsl_early_sync_task_nowait(struct dsl_pool *, dsl_syncfunc_t *,
+    void *, int, zfs_space_check_t, dmu_tx_t *);
+int dsl_sync_task_sig(const char *, dsl_checkfunc_t *, dsl_syncfunc_t *,
+    dsl_sigfunc_t *, void *, int, zfs_space_check_t);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_SYNCTASK_H */
diff --git a/include/sys/dsl_userhold.h b/include/sys/dsl_userhold.h
new file mode 100644
index 0000000000000..071aeb86d1f10
--- /dev/null
+++ b/include/sys/dsl_userhold.h
@@ -0,0 +1,57 @@
+
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012 by Delphix. All rights reserved.
+ * Copyright (c) 2012, Joyent, Inc. All rights reserved.
+ * Copyright (c) 2013 Steven Hartland. All rights reserved.
+ */
+
+#ifndef	_SYS_DSL_USERHOLD_H
+#define	_SYS_DSL_USERHOLD_H
+
+#include <sys/nvpair.h>
+#include <sys/types.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct dsl_pool;
+struct dsl_dataset;
+struct dmu_tx;
+
+int dsl_dataset_user_hold(nvlist_t *holds, minor_t cleanup_minor,
+    nvlist_t *errlist);
+int dsl_dataset_user_release(nvlist_t *holds, nvlist_t *errlist);
+int dsl_dataset_get_holds(const char *dsname, nvlist_t *nvl);
+void dsl_dataset_user_release_tmp(struct dsl_pool *dp, nvlist_t *holds);
+int dsl_dataset_user_hold_check_one(struct dsl_dataset *ds, const char *htag,
+    boolean_t temphold, struct dmu_tx *tx);
+void dsl_dataset_user_hold_sync_one(struct dsl_dataset *ds, const char *htag,
+    minor_t minor, uint64_t now, struct dmu_tx *tx);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DSL_USERHOLD_H */
diff --git a/include/sys/edonr.h b/include/sys/edonr.h
new file mode 100644
index 0000000000000..79b7cd8c75b87
--- /dev/null
+++ b/include/sys/edonr.h
@@ -0,0 +1,98 @@
+/*
+ * IDI,NTNU
+ *
+ * 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://opensource.org/licenses/CDDL-1.0.
+ * 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) 2009, 2010, Jorn Amundsen <jorn.amundsen@ntnu.no>
+ *
+ * Tweaked Edon-R implementation for SUPERCOP, based on NIST API.
+ *
+ * $Id: edonr.h 517 2013-02-17 20:34:39Z joern $
+ */
+/*
+ * Portions copyright (c) 2013, Saso Kiselkov, All rights reserved
+ */
+
+#ifndef	_SYS_EDONR_H_
+#define	_SYS_EDONR_H_
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifdef  _KERNEL
+#include <sys/types.h>
+#else
+#include <stdint.h> /* uint32_t... */
+#include <stdlib.h> /* size_t ... */
+#endif
+
+/*
+ * EdonR allows to call EdonRUpdate() consecutively only if the total length
+ * of stored unprocessed data and the new supplied data is less than or equal
+ * to the BLOCK_SIZE on which the compression functions operates.
+ * Otherwise an assertion failure is invoked.
+ */
+
+/* Specific algorithm definitions */
+#define	EdonR224_DIGEST_SIZE	28
+#define	EdonR224_BLOCK_SIZE	64
+#define	EdonR256_DIGEST_SIZE	32
+#define	EdonR256_BLOCK_SIZE	64
+#define	EdonR384_DIGEST_SIZE	48
+#define	EdonR384_BLOCK_SIZE	128
+#define	EdonR512_DIGEST_SIZE	64
+#define	EdonR512_BLOCK_SIZE	128
+
+#define	EdonR256_BLOCK_BITSIZE	512
+#define	EdonR512_BLOCK_BITSIZE	1024
+
+typedef struct {
+	uint32_t DoublePipe[16];
+	uint8_t LastPart[EdonR256_BLOCK_SIZE * 2];
+} EdonRData256;
+typedef struct {
+	uint64_t DoublePipe[16];
+	uint8_t LastPart[EdonR512_BLOCK_SIZE * 2];
+} EdonRData512;
+
+typedef struct {
+	size_t hashbitlen;
+
+	/* + algorithm specific parameters */
+	int unprocessed_bits;
+	uint64_t bits_processed;
+	union {
+		EdonRData256 p256[1];
+		EdonRData512 p512[1];
+	} pipe[1];
+} EdonRState;
+
+void EdonRInit(EdonRState *state, size_t hashbitlen);
+void EdonRUpdate(EdonRState *state, const uint8_t *data, size_t databitlen);
+void EdonRFinal(EdonRState *state, uint8_t *hashval);
+void EdonRHash(size_t hashbitlen, const uint8_t *data, size_t databitlen,
+    uint8_t *hashval);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_EDONR_H_ */
diff --git a/include/sys/efi_partition.h b/include/sys/efi_partition.h
new file mode 100644
index 0000000000000..88bdfd2b1ca37
--- /dev/null
+++ b/include/sys/efi_partition.h
@@ -0,0 +1,381 @@
+/*
+ * 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) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2012 Nexenta Systems, Inc.  All rights reserved.
+ */
+
+#ifndef	_SYS_EFI_PARTITION_H
+#define	_SYS_EFI_PARTITION_H
+
+#include <sys/uuid.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * GUID Partition Table Header
+ */
+
+#define	EFI_MIN_LABEL_SIZE 92
+#define	EFI_LABEL_SIZE	512
+#define	LEN_EFI_PAD	(EFI_LABEL_SIZE - \
+			    ((5 * sizeof (diskaddr_t)) + \
+			    (7 * sizeof (uint_t)) + \
+			    (8 * sizeof (char)) + \
+			    (1 * (sizeof (struct uuid)))))
+
+#define	EFI_SIGNATURE	0x5452415020494645ULL
+
+/* EFI Guid Partition Table Header -- little endian on-disk format */
+typedef struct efi_gpt {
+	uint64_t	efi_gpt_Signature;
+	uint_t		efi_gpt_Revision;
+	uint_t		efi_gpt_HeaderSize;
+	uint_t		efi_gpt_HeaderCRC32;
+	uint_t		efi_gpt_Reserved1;
+	diskaddr_t	efi_gpt_MyLBA;
+	diskaddr_t	efi_gpt_AlternateLBA;
+	diskaddr_t	efi_gpt_FirstUsableLBA;
+	diskaddr_t	efi_gpt_LastUsableLBA;
+	struct uuid	efi_gpt_DiskGUID;
+	diskaddr_t	efi_gpt_PartitionEntryLBA;
+	uint_t		efi_gpt_NumberOfPartitionEntries;
+	uint_t		efi_gpt_SizeOfPartitionEntry;
+	uint_t		efi_gpt_PartitionEntryArrayCRC32;
+	char		efi_gpt_Reserved2[LEN_EFI_PAD];
+} efi_gpt_t;
+
+/* EFI Guid Partition Entry Attributes -- little endian format */
+typedef struct efi_gpe_Attrs {
+	uint32_t	PartitionAttrs		:16,
+			Reserved2		:16;
+	uint32_t	Reserved1		:31,
+			RequiredPartition	:1;
+} efi_gpe_Attrs_t;
+
+/*
+ * 6a96237f-1dd2-11b2-99a6-080020736631	V_UNASSIGNED (not used as such)
+ * 6a82cb45-1dd2-11b2-99a6-080020736631	V_BOOT
+ * 6a85cf4d-1dd2-11b2-99a6-080020736631	V_ROOT
+ * 6a87c46f-1dd2-11b2-99a6-080020736631	V_SWAP
+ * 6a898cc3-1dd2-11b2-99a6-080020736631	V_USR
+ * 6a8b642b-1dd2-11b2-99a6-080020736631	V_BACKUP
+ * 6a8d2ac7-1dd2-11b2-99a6-080020736631	V_STAND (not used)
+ * 6a8ef2e9-1dd2-11b2-99a6-080020736631	V_VAR
+ * 6a90ba39-1dd2-11b2-99a6-080020736631	V_HOME
+ * 6a9283a5-1dd2-11b2-99a6-080020736631	V_ALTSCTR
+ * 6a945a3b-1dd2-11b2-99a6-080020736631	V_CACHE
+ */
+
+#define	EFI_UNUSED		{ 0x00000000, 0x0000, 0x0000, 0x00, 0x00, \
+				    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
+#define	EFI_RESV1		{ 0x6a96237f, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_BOOT		{ 0x6a82cb45, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_ROOT		{ 0x6a85cf4d, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_SWAP		{ 0x6a87c46f, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_USR			{ 0x6a898cc3, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_BACKUP		{ 0x6a8b642b, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_RESV2		{ 0x6a8d2ac7, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_VAR			{ 0x6a8ef2e9, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_HOME		{ 0x6a90ba39, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_ALTSCTR		{ 0x6a9283a5, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_RESERVED		{ 0x6a945a3b, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_SYSTEM		{ 0xC12A7328, 0xF81F, 0x11d2, 0xBA, 0x4B, \
+				    { 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B } }
+#define	EFI_LEGACY_MBR		{ 0x024DEE41, 0x33E7, 0x11d3, 0x9D, 0x69, \
+				    { 0x00, 0x08, 0xC7, 0x81, 0xF3, 0x9F } }
+#define	EFI_SYMC_PUB		{ 0x6a9630d1, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_SYMC_CDS		{ 0x6a980767, 0x1dd2, 0x11b2, 0x99, 0xa6, \
+				    { 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }
+#define	EFI_MSFT_RESV		{ 0xE3C9E316, 0x0B5C, 0x4DB8, 0x81, 0x7D, \
+				    { 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE } }
+#define	EFI_DELL_BASIC		{ 0xebd0a0a2, 0xb9e5, 0x4433, 0x87, 0xc0, \
+				    { 0x68, 0xb6, 0xb7, 0x26, 0x99, 0xc7 } }
+#define	EFI_DELL_RAID		{ 0xa19d880f, 0x05fc, 0x4d3b, 0xa0, 0x06, \
+				    { 0x74, 0x3f, 0x0f, 0x84, 0x91, 0x1e } }
+#define	EFI_DELL_SWAP		{ 0x0657fd6d, 0xa4ab, 0x43c4, 0x84, 0xe5, \
+				    { 0x09, 0x33, 0xc8, 0x4b, 0x4f, 0x4f } }
+#define	EFI_DELL_LVM		{ 0xe6d6d379, 0xf507, 0x44c2, 0xa2, 0x3c, \
+				    { 0x23, 0x8f, 0x2a, 0x3d, 0xf9, 0x28 } }
+#define	EFI_DELL_RESV		{ 0x8da63339, 0x0007, 0x60c0, 0xc4, 0x36, \
+				    { 0x08, 0x3a, 0xc8, 0x23, 0x09, 0x08 } }
+#define	EFI_AAPL_HFS		{ 0x48465300, 0x0000, 0x11aa, 0xaa, 0x11, \
+				    { 0x00, 0x30, 0x65, 0x43, 0xec, 0xac } }
+#define	EFI_AAPL_UFS		{ 0x55465300, 0x0000, 0x11aa, 0xaa, 0x11, \
+				    { 0x00, 0x30, 0x65, 0x43, 0xec, 0xac } }
+#define	EFI_FREEBSD_BOOT	{ 0x83bd6b9d, 0x7f41, 0x11dc, 0xbe, 0x0b, \
+				    { 0x00, 0x15, 0x60, 0xb8, 0x4f, 0x0f } }
+#define	EFI_FREEBSD_SWAP	{ 0x516e7cb5, 0x6ecf, 0x11d6, 0x8f, 0xf8, \
+				    { 0x00, 0x02, 0x2d, 0x09, 0x71, 0x2b } }
+#define	EFI_FREEBSD_UFS		{ 0x516e7cb6, 0x6ecf, 0x11d6, 0x8f, 0xf8, \
+				    { 0x00, 0x02, 0x2d, 0x09, 0x71, 0x2b } }
+#define	EFI_FREEBSD_VINUM	{ 0x516e7cb8, 0x6ecf, 0x11d6, 0x8f, 0xf8, \
+				    { 0x00, 0x02, 0x2d, 0x09, 0x71, 0x2b } }
+#define	EFI_FREEBSD_ZFS		{ 0x516e7cba, 0x6ecf, 0x11d6, 0x8f, 0xf8, \
+				    { 0x00, 0x02, 0x2d, 0x09, 0x71, 0x2b } }
+
+/* From Wikipedia */
+
+#define	EFI_BIOS_BOOT		{ 0x21686148, 0x6449, 0x6e6f, 0x74, 0x4e, \
+				    { 0x65, 0x65, 0x64, 0x45, 0x46, 0x49 } }
+#define	EFI_INTC_RS		{ 0xd3bfe2de, 0x3daf, 0x11df, 0xba, 0x40, \
+				    { 0xe3, 0xa5, 0x56, 0xd8, 0x95, 0x93 } }
+#define	EFI_SNE_BOOT		{ 0xf4019732, 0x066e, 0x4e12, 0x82, 0x73, \
+				    { 0x34, 0x6c, 0x56, 0x41, 0x49, 0x4f } }
+#define	EFI_LENOVO_BOOT		{ 0xbfbfafe7, 0xa34f, 0x448a, 0x9a, 0x5b, \
+				    { 0x62, 0x13, 0xeb, 0x73, 0x6c, 0x22 } }
+#define	EFI_MSFT_LDMM		{ 0x5808c8aa, 0x7e8f, 0x42e0, 0x85, 0xd2, \
+				    { 0xe1, 0xe9, 0x04, 0x34, 0xcf, 0xb3 } }
+#define	EFI_MSFT_LDMD		{ 0xaf9b60a0, 0x1431, 0x4f62, 0xbc, 0x68, \
+				    { 0x33, 0x11, 0x71, 0x4a, 0x69, 0xad } }
+#define	EFI_MSFT_RE		{ 0xde94bba4, 0x06d1, 0x4d40, 0xa1, 0x6a, \
+				    { 0xbf, 0xd5, 0x01, 0x79, 0xd6, 0xac } }
+#define	EFI_IBM_GPFS		{ 0x37affc90, 0xef7d, 0x4e96, 0x91, 0xc3, \
+				    { 0x2d, 0x7a, 0xe0, 0x55, 0xb1, 0x74 } }
+#define	EFI_MSFT_STORAGESPACES	{ 0xe75caf8f, 0xf680, 0x4cee, 0xaf, 0xa3, \
+				    { 0xb0, 0x01, 0xe5, 0x6e, 0xfc, 0x2d } }
+#define	EFI_HPQ_DATA		{ 0x75894c1e, 0x3aeb, 0x11d3, 0xb7, 0xc1, \
+				    { 0x7b, 0x03, 0xa0, 0x00, 0x00, 0x00 } }
+#define	EFI_HPQ_SVC		{ 0xe2a1e728, 0x32e3, 0x11d6, 0xa6, 0x82, \
+				    { 0x7b, 0x03, 0xa0, 0x00, 0x00, 0x00 } }
+#define	EFI_RHT_DATA		{ 0x0fc63daf, 0x8483, 0x4772, 0x8e, 0x79, \
+				    { 0x3d, 0x69, 0xd8, 0x47, 0x7d, 0xe4 } }
+#define	EFI_RHT_HOME		{ 0x933ac7e1, 0x2eb4, 0x4f13, 0xb8, 0x44, \
+				    { 0x0e, 0x14, 0xe2, 0xae, 0xf9, 0x15 } }
+#define	EFI_RHT_SRV		{ 0x3b8f8425, 0x20e0, 0x4f3b, 0x90, 0x7f, \
+				    { 0x1a, 0x25, 0xa7, 0x6f, 0x98, 0xe8 } }
+#define	EFI_RHT_DMCRYPT		{ 0x7ffec5c9, 0x2d00, 0x49b7, 0x89, 0x41, \
+				    { 0x3e, 0xa1, 0x0a, 0x55, 0x86, 0xb7 } }
+#define	EFI_RHT_LUKS		{ 0xca7d7ccb, 0x63ed, 0x4c53, 0x86, 0x1c, \
+				    { 0x17, 0x42, 0x53, 0x60, 0x59, 0xcc } }
+#define	EFI_FREEBSD_DISKLABEL	{ 0x516e7cb4, 0x6ecf, 0x11d6, 0x8f, 0xf8, \
+				    { 0x00, 0x02, 0x2d, 0x09, 0x71, 0x2b } }
+#define	EFI_AAPL_RAID		{ 0x52414944, 0x0000, 0x11aa, 0xaa, 0x11, \
+				    { 0x00, 0x30, 0x65, 0x43, 0xec, 0xac } }
+#define	EFI_AAPL_RAIDOFFLINE	{ 0x52414944, 0x5f4f, 0x11aa, 0xaa, 0x11, \
+				    { 0x00, 0x30, 0x65, 0x43, 0xec, 0xac } }
+#define	EFI_AAPL_BOOT		{ 0x426f6f74, 0x0000, 0x11aa, 0xaa, 0x11, \
+				    { 0x00, 0x30, 0x65, 0x43, 0xec, 0xac } }
+#define	EFI_AAPL_LABEL		{ 0x4c616265, 0x6c00, 0x11aa, 0xaa, 0x11, \
+				    { 0x00, 0x30, 0x65, 0x43, 0xec, 0xac } }
+#define	EFI_AAPL_TVRECOVERY	{ 0x5265636f, 0x7665, 0x11aa, 0xaa, 0x11, \
+				    { 0x00, 0x30, 0x65, 0x43, 0xec, 0xac } }
+#define	EFI_AAPL_CORESTORAGE	{ 0x53746f72, 0x6167, 0x11aa, 0xaa, 0x11, \
+				    { 0x00, 0x30, 0x65, 0x43, 0xec, 0xac } }
+#define	EFI_NETBSD_SWAP		{ 0x49f48d32, 0xb10e, 0x11dc, 0xb9, 0x9b, \
+				    { 0x00, 0x19, 0xd1, 0x87, 0x96, 0x48 } }
+#define	EFI_NETBSD_FFS		{ 0x49f48d5a, 0xb10e, 0x11dc, 0xb9, 0x9b, \
+				    { 0x00, 0x19, 0xd1, 0x87, 0x96, 0x48 } }
+#define	EFI_NETBSD_LFS		{ 0x49f48d82, 0xb10e, 0x11dc, 0xb9, 0x9b, \
+				    { 0x00, 0x19, 0xd1, 0x87, 0x96, 0x48 } }
+#define	EFI_NETBSD_RAID		{ 0x49f48daa, 0xb10e, 0x11dc, 0xb9, 0x9b, \
+				    { 0x00, 0x19, 0xd1, 0x87, 0x96, 0x48 } }
+#define	EFI_NETBSD_CAT		{ 0x2db519c4, 0xb10f, 0x11dc, 0xb9, 0x9b, \
+				    { 0x00, 0x19, 0xd1, 0x87, 0x96, 0x48 } }
+#define	EFI_NETBSD_CRYPT	{ 0x2db519ec, 0xb10f, 0x11dc, 0xb9, 0x9b, \
+				    { 0x00, 0x19, 0xd1, 0x87, 0x96, 0x48 } }
+#define	EFI_GOOG_KERN		{ 0xfe3a2a5d, 0x4f32, 0x41a7, 0xb7, 0x25, \
+				    { 0xac, 0xcc, 0x32, 0x85, 0xa3, 0x09 } }
+#define	EFI_GOOG_ROOT		{ 0x3cb8e202, 0x3b7e, 0x47dd, 0x8a, 0x3c, \
+				    { 0x7f, 0xf2, 0xa1, 0x3c, 0xfc, 0xec } }
+#define	EFI_GOOG_RESV		{ 0x2e0a753d, 0x9e48, 0x43b0, 0x83, 0x37, \
+				    { 0xb1, 0x51, 0x92, 0xcb, 0x1b, 0x5e } }
+#define	EFI_HAIKU_BFS		{ 0x42465331, 0x3ba3, 0x10f1, 0x80, 0x2a, \
+				    { 0x48, 0x61, 0x69, 0x6b, 0x75, 0x21 } }
+#define	EFI_MIDNIGHTBSD_BOOT	{ 0x85d5e45e, 0x237c, 0x11e1, 0xb4, 0xb3, \
+				    { 0xe8, 0x9a, 0x8f, 0x7f, 0xc3, 0xa7 } }
+#define	EFI_MIDNIGHTBSD_DATA	{ 0x85d5e45a, 0x237c, 0x11e1, 0xb4, 0xb3, \
+				    { 0xe8, 0x9a, 0x8f, 0x7f, 0xc3, 0xa7 } }
+#define	EFI_MIDNIGHTBSD_SWAP	{ 0x85d5e45b, 0x237c, 0x11e1, 0xb4, 0xb3, \
+				    { 0xe8, 0x9a, 0x8f, 0x7f, 0xc3, 0xa7 } }
+#define	EFI_MIDNIGHTBSD_UFS	{ 0x0394ef8b, 0x237e, 0x11e1, 0xb4, 0xb3, \
+				    { 0xe8, 0x9a, 0x8f, 0x7f, 0xc3, 0xa7 } }
+#define	EFI_MIDNIGHTBSD_VINUM	{ 0x85d5e45c, 0x237c, 0x11e1, 0xb4, 0xb3, \
+				    { 0xe8, 0x9a, 0x8f, 0x7f, 0xc3, 0xa7 } }
+#define	EFI_MIDNIGHTBSD_ZFS	{ 0x85d5e45d, 0x237c, 0x11e1, 0xb4, 0xb3, \
+				    { 0xe8, 0x9a, 0x8f, 0x7f, 0xc3, 0xa7 } }
+#define	EFI_CEPH_JOURNAL	{ 0x45b0969e, 0x9b03, 0x4f30, 0xb4, 0xc6, \
+				    { 0xb4, 0xb8, 0x0c, 0xef, 0xf1, 0x06 } }
+#define	EFI_CEPH_DMCRYPTJOURNAL	{ 0x45b0969e, 0x9b03, 0x4f30, 0xb4, 0xc6, \
+				    { 0x5e, 0xc0, 0x0c, 0xef, 0xf1, 0x06 } }
+#define	EFI_CEPH_OSD		{ 0x4fbd7e29, 0x9d25, 0x41b8, 0xaf, 0xd0, \
+				    { 0x06, 0x2c, 0x0c, 0xef, 0xf0, 0x5d } }
+#define	EFI_CEPH_DMCRYPTOSD	{ 0x4fbd7e29, 0x9d25, 0x41b8, 0xaf, 0xd0, \
+				    { 0x5e, 0xc0, 0x0c, 0xef, 0xf0, 0x5d } }
+#define	EFI_CEPH_CREATE		{ 0x89c57f98, 0x2fe5, 0x4dc0, 0x89, 0xc1, \
+				    { 0xf3, 0xad, 0x0c, 0xef, 0xf2, 0xbe } }
+#define	EFI_CEPH_DMCRYPTCREATE	{ 0x89c57f98, 0x2fe5, 0x4dc0, 0x89, 0xc1, \
+				    { 0x5e, 0xc0, 0x0c, 0xef, 0xf2, 0xbe } }
+#define	EFI_OPENBSD_DISKLABEL	{ 0x824cc7a0, 0x36a8, 0x11e3, 0x89, 0x0a, \
+				    { 0x95, 0x25, 0x19, 0xad, 0x3f, 0x61 } }
+#define	EFI_BBRY_QNX		{ 0xcef5a9ad, 0x73bc, 0x4601, 0x89, 0xf3, \
+				    { 0xcd, 0xee, 0xee, 0xe3, 0x21, 0xa1 } }
+#define	EFI_BELL_PLAN9		{ 0xc91818f9, 0x8025, 0x47af, 0x89, 0xd2, \
+				    { 0xf0, 0x30, 0xd7, 0x00, 0x0c, 0x2c } }
+#define	EFI_VMW_KCORE		{ 0x9d275380, 0x40ad, 0x11db, 0xbf, 0x97, \
+				    { 0x00, 0x0c, 0x29, 0x11, 0xd1, 0xb8 } }
+#define	EFI_VMW_VMFS		{ 0xaa31e02a, 0x400f, 0x11db, 0x95, 0x90, \
+				    { 0x00, 0x0c, 0x29, 0x11, 0xd1, 0xb8 } }
+#define	EFI_VMW_RESV		{ 0x9198effc, 0x31c0, 0x11db, 0x8f, 0x78, \
+				    { 0x00, 0x0c, 0x29, 0x11, 0xd1, 0xb8 } }
+
+/* From GPT fdisk */
+
+#define	EFI_RHT_ROOTX86		{ 0x44479540, 0xf297, 0x41b2, 0x9a, 0xf7, \
+				    { 0xd1, 0x31, 0xd5, 0xf0, 0x45, 0x8a } }
+#define	EFI_RHT_ROOTAMD64	{ 0x4f68bce3, 0xe8cd, 0x4db1, 0x96, 0xe7, \
+				    { 0xfb, 0xca, 0xf9, 0x84, 0xb7, 0x09 } }
+#define	EFI_RHT_ROOTARM		{ 0x69dad710, 0x2ce4, 0x4e3c, 0xb1, 0x6c, \
+				    { 0x21, 0xa1, 0xd4, 0x9a, 0xbe, 0xd3 } }
+#define	EFI_RHT_ROOTARM64	{ 0xb921b045, 0x1df0, 0x41c3, 0xaf, 0x44, \
+				    { 0x4c, 0x6f, 0x28, 0x0d, 0x3f, 0xae } }
+#define	EFI_ACRONIS_SECUREZONE	{ 0x0311fc50, 0x01ca, 0x4725, 0xad, 0x77, \
+				    { 0x9a, 0xdb, 0xb2, 0x0a, 0xce, 0x98 } }
+#define	EFI_ONIE_BOOT		{ 0x7412f7d5, 0xa156, 0x4b13, 0x81, 0xdc, \
+				    { 0x86, 0x71, 0x74, 0x92, 0x93, 0x25 } }
+#define	EFI_ONIE_CONFIG		{ 0xd4e6e2cd, 0x4469, 0x46f3, 0xb5, 0xcb, \
+				    { 0x1b, 0xff, 0x57, 0xaf, 0xc1, 0x49 } }
+#define	EFI_IBM_PPRPBOOT	{ 0x9e1a2d38, 0xc612, 0x4316, 0xaa, 0x26, \
+				    { 0x8b, 0x49, 0x52, 0x1e, 0x5a, 0x8b } }
+#define	EFI_FREEDESKTOP_BOOT	{ 0xbc13c2ff, 0x59e6, 0x4262, 0xa3, 0x52, \
+				    { 0xb2, 0x75, 0xfd, 0x6f, 0x71, 0x72 } }
+
+/* minimum # of bytes for partition table entries, per EFI spec */
+#define	EFI_MIN_ARRAY_SIZE	(16 * 1024)
+
+#define	EFI_PART_NAME_LEN	36
+
+/* size of the "reserved" partition, in blocks */
+#define	EFI_MIN_RESV_SIZE	(16 * 1024)
+
+/* EFI Guid Partition Entry */
+typedef struct efi_gpe {
+	struct uuid	efi_gpe_PartitionTypeGUID;
+	struct uuid	efi_gpe_UniquePartitionGUID;
+	diskaddr_t	efi_gpe_StartingLBA;
+	diskaddr_t	efi_gpe_EndingLBA;
+	efi_gpe_Attrs_t	efi_gpe_Attributes;
+	ushort_t	efi_gpe_PartitionName[EFI_PART_NAME_LEN];
+} efi_gpe_t;
+
+/*
+ * passed to the useful (we hope) routines (efi_alloc_and_read and
+ * efi_write) that take this VTOC-like struct.  These routines handle
+ * converting this struct into the EFI struct, generate UUIDs and
+ * checksums, and perform any necessary byte-swapping to the on-disk
+ * format.
+ */
+/* Solaris library abstraction for EFI partitions */
+typedef struct dk_part	{
+	diskaddr_t	p_start;	/* starting LBA */
+	diskaddr_t	p_size;		/* size in blocks */
+	struct uuid	p_guid;		/* partition type GUID */
+	ushort_t	p_tag;		/* converted to part'n type GUID */
+	ushort_t	p_flag;		/* attributes */
+	char		p_name[EFI_PART_NAME_LEN]; /* partition name */
+	struct uuid	p_uguid;	/* unique partition GUID */
+	uint_t		p_resv[8];	/* future use - set to zero */
+} dk_part_t;
+
+/* Solaris library abstraction for an EFI GPT */
+#define	EFI_VERSION102		0x00010002
+#define	EFI_VERSION100		0x00010000
+#define	EFI_VERSION_CURRENT	EFI_VERSION100
+typedef struct dk_gpt {
+	uint_t		efi_version;	/* set to EFI_VERSION_CURRENT */
+	uint_t		efi_nparts;	/* number of partitions below */
+	uint_t		efi_part_size;	/* size of each partition entry */
+					/* efi_part_size is unused */
+	uint_t		efi_lbasize;	/* size of block in bytes */
+	diskaddr_t	efi_last_lba;	/* last block on the disk */
+	diskaddr_t	efi_first_u_lba; /* first block after labels */
+	diskaddr_t	efi_last_u_lba;	/* last block before backup labels */
+	struct uuid	efi_disk_uguid;	/* unique disk GUID */
+	uint_t		efi_flags;
+	uint_t		efi_reserved1;	/* future use - set to zero */
+	diskaddr_t	efi_altern_lba;	/* lba of alternate GPT header */
+	uint_t		efi_reserved[12]; /* future use - set to zero */
+	struct dk_part	efi_parts[1];	/* array of partitions */
+} dk_gpt_t;
+
+/* possible values for "efi_flags" */
+#define	EFI_GPT_PRIMARY_CORRUPT	0x1	/* primary label corrupt */
+
+/* the private ioctl between libefi and the driver */
+typedef struct dk_efi {
+	diskaddr_t	 dki_lba;	/* starting block */
+	len_t		 dki_length;	/* length in bytes */
+	union {
+		efi_gpt_t 	*_dki_data;
+		uint64_t	_dki_data_64;
+	} dki_un;
+#define	dki_data	dki_un._dki_data
+#define	dki_data_64	dki_un._dki_data_64
+} dk_efi_t;
+
+struct partition64 {
+	struct uuid	p_type;
+	uint_t		p_partno;
+	uint_t		p_resv1;
+	diskaddr_t	p_start;
+	diskaddr_t	p_size;
+};
+
+/*
+ * Number of EFI partitions
+ */
+#if defined(__linux__)
+#define	EFI_NUMPAR	128 /* Expected by parted-1.8.1 */
+#else
+#define	EFI_NUMPAR	9
+#endif
+
+#ifndef _KERNEL
+extern	int	efi_alloc_and_init(int, uint32_t, struct dk_gpt **);
+extern	int	efi_alloc_and_read(int, struct dk_gpt **);
+extern	int	efi_write(int, struct dk_gpt *);
+extern	int	efi_rescan(int);
+extern	void	efi_free(struct dk_gpt *);
+extern	int	efi_type(int);
+extern	void	efi_err_check(struct dk_gpt *);
+extern	int	efi_auto_sense(int fd, struct dk_gpt **);
+extern	int	efi_use_whole_disk(int fd);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_EFI_PARTITION_H */
diff --git a/include/sys/fm/Makefile.am b/include/sys/fm/Makefile.am
new file mode 100644
index 0000000000000..7c6c3d49b6e9e
--- /dev/null
+++ b/include/sys/fm/Makefile.am
@@ -0,0 +1,17 @@
+SUBDIRS = fs
+
+COMMON_H = \
+	protocol.h \
+	util.h
+
+if CONFIG_USER
+libzfsdir = $(includedir)/libzfs/sys/fm
+libzfs_HEADERS = $(COMMON_H)
+endif
+
+if CONFIG_KERNEL
+if BUILD_LINUX
+kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys/fm
+kernel_HEADERS = $(COMMON_H)
+endif
+endif
diff --git a/include/sys/fm/fs/Makefile.am b/include/sys/fm/fs/Makefile.am
new file mode 100644
index 0000000000000..a662753a9e971
--- /dev/null
+++ b/include/sys/fm/fs/Makefile.am
@@ -0,0 +1,14 @@
+COMMON_H = \
+	zfs.h
+
+if CONFIG_USER
+libzfsdir = $(includedir)/libzfs/sys/fm/fs
+libzfs_HEADERS = $(COMMON_H)
+endif
+
+if CONFIG_KERNEL
+if BUILD_LINUX
+kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys/fm/fs
+kernel_HEADERS = $(COMMON_H)
+endif
+endif
diff --git a/include/sys/fm/fs/zfs.h b/include/sys/fm/fs/zfs.h
new file mode 100644
index 0000000000000..9bfb123c76fee
--- /dev/null
+++ b/include/sys/fm/fs/zfs.h
@@ -0,0 +1,121 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_FM_FS_ZFS_H
+#define	_SYS_FM_FS_ZFS_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	ZFS_ERROR_CLASS				"fs.zfs"
+
+#define	FM_EREPORT_ZFS_CHECKSUM			"checksum"
+#define	FM_EREPORT_ZFS_AUTHENTICATION		"authentication"
+#define	FM_EREPORT_ZFS_IO			"io"
+#define	FM_EREPORT_ZFS_DATA			"data"
+#define	FM_EREPORT_ZFS_DELAY			"delay"
+#define	FM_EREPORT_ZFS_DEADMAN			"deadman"
+#define	FM_EREPORT_ZFS_POOL			"zpool"
+#define	FM_EREPORT_ZFS_DEVICE_UNKNOWN		"vdev.unknown"
+#define	FM_EREPORT_ZFS_DEVICE_OPEN_FAILED	"vdev.open_failed"
+#define	FM_EREPORT_ZFS_DEVICE_CORRUPT_DATA	"vdev.corrupt_data"
+#define	FM_EREPORT_ZFS_DEVICE_NO_REPLICAS	"vdev.no_replicas"
+#define	FM_EREPORT_ZFS_DEVICE_BAD_GUID_SUM	"vdev.bad_guid_sum"
+#define	FM_EREPORT_ZFS_DEVICE_TOO_SMALL		"vdev.too_small"
+#define	FM_EREPORT_ZFS_DEVICE_BAD_LABEL		"vdev.bad_label"
+#define	FM_EREPORT_ZFS_DEVICE_BAD_ASHIFT	"vdev.bad_ashift"
+#define	FM_EREPORT_ZFS_IO_FAILURE		"io_failure"
+#define	FM_EREPORT_ZFS_PROBE_FAILURE		"probe_failure"
+#define	FM_EREPORT_ZFS_LOG_REPLAY		"log_replay"
+#define	FM_EREPORT_ZFS_CONFIG_CACHE_WRITE	"config_cache_write"
+
+#define	FM_EREPORT_PAYLOAD_ZFS_POOL		"pool"
+#define	FM_EREPORT_PAYLOAD_ZFS_POOL_FAILMODE	"pool_failmode"
+#define	FM_EREPORT_PAYLOAD_ZFS_POOL_GUID	"pool_guid"
+#define	FM_EREPORT_PAYLOAD_ZFS_POOL_CONTEXT	"pool_context"
+#define	FM_EREPORT_PAYLOAD_ZFS_POOL_STATE	"pool_state"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_GUID	"vdev_guid"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_TYPE	"vdev_type"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_PATH	"vdev_path"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_PHYSPATH	"vdev_physpath"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_ENC_SYSFS_PATH	"vdev_enc_sysfs_path"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_DEVID	"vdev_devid"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_FRU		"vdev_fru"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE	"vdev_state"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE	"vdev_laststate"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_ASHIFT	"vdev_ashift"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_COMP_TS	"vdev_complete_ts"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_DELTA_TS	"vdev_delta_ts"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_SPARE_PATHS	"vdev_spare_paths"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_SPARE_GUIDS	"vdev_spare_guids"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_READ_ERRORS	"vdev_read_errors"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_WRITE_ERRORS "vdev_write_errors"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_CKSUM_ERRORS "vdev_cksum_errors"
+#define	FM_EREPORT_PAYLOAD_ZFS_VDEV_DELAYS	"vdev_delays"
+#define	FM_EREPORT_PAYLOAD_ZFS_PARENT_GUID	"parent_guid"
+#define	FM_EREPORT_PAYLOAD_ZFS_PARENT_TYPE	"parent_type"
+#define	FM_EREPORT_PAYLOAD_ZFS_PARENT_PATH	"parent_path"
+#define	FM_EREPORT_PAYLOAD_ZFS_PARENT_DEVID	"parent_devid"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_OBJSET	"zio_objset"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_OBJECT	"zio_object"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_LEVEL	"zio_level"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_BLKID	"zio_blkid"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_ERR		"zio_err"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_OFFSET	"zio_offset"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_SIZE		"zio_size"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_FLAGS	"zio_flags"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_STAGE	"zio_stage"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_PIPELINE	"zio_pipeline"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_DELAY	"zio_delay"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_TIMESTAMP	"zio_timestamp"
+#define	FM_EREPORT_PAYLOAD_ZFS_ZIO_DELTA	"zio_delta"
+#define	FM_EREPORT_PAYLOAD_ZFS_PREV_STATE	"prev_state"
+#define	FM_EREPORT_PAYLOAD_ZFS_CKSUM_EXPECTED	"cksum_expected"
+#define	FM_EREPORT_PAYLOAD_ZFS_CKSUM_ACTUAL	"cksum_actual"
+#define	FM_EREPORT_PAYLOAD_ZFS_CKSUM_ALGO	"cksum_algorithm"
+#define	FM_EREPORT_PAYLOAD_ZFS_CKSUM_BYTESWAP	"cksum_byteswap"
+#define	FM_EREPORT_PAYLOAD_ZFS_BAD_OFFSET_RANGES "bad_ranges"
+#define	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_MIN_GAP "bad_ranges_min_gap"
+#define	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_SETS	"bad_range_sets"
+#define	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_CLEARS	"bad_range_clears"
+#define	FM_EREPORT_PAYLOAD_ZFS_BAD_SET_BITS	"bad_set_bits"
+#define	FM_EREPORT_PAYLOAD_ZFS_BAD_CLEARED_BITS	"bad_cleared_bits"
+#define	FM_EREPORT_PAYLOAD_ZFS_BAD_SET_HISTOGRAM "bad_set_histogram"
+#define	FM_EREPORT_PAYLOAD_ZFS_BAD_CLEARED_HISTOGRAM "bad_cleared_histogram"
+
+#define	FM_EREPORT_FAILMODE_WAIT		"wait"
+#define	FM_EREPORT_FAILMODE_CONTINUE		"continue"
+#define	FM_EREPORT_FAILMODE_PANIC		"panic"
+
+#define	FM_RESOURCE_REMOVED			"removed"
+#define	FM_RESOURCE_AUTOREPLACE			"autoreplace"
+#define	FM_RESOURCE_STATECHANGE			"statechange"
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_FM_FS_ZFS_H */
diff --git a/include/sys/fm/protocol.h b/include/sys/fm/protocol.h
new file mode 100644
index 0000000000000..78031f7c15ec3
--- /dev/null
+++ b/include/sys/fm/protocol.h
@@ -0,0 +1,369 @@
+/*
+ * 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) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
+ */
+
+#ifndef	_SYS_FM_PROTOCOL_H
+#define	_SYS_FM_PROTOCOL_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifdef _KERNEL
+#include <sys/nvpair.h>
+#else
+#include <libnvpair.h>
+#include <stdarg.h>
+#endif
+#include <sys/processor.h>
+
+/* FM common member names */
+#define	FM_CLASS			"class"
+#define	FM_VERSION			"version"
+
+/* FM protocol category 1 class names */
+#define	FM_EREPORT_CLASS		"ereport"
+#define	FM_FAULT_CLASS			"fault"
+#define	FM_DEFECT_CLASS			"defect"
+#define	FM_RSRC_CLASS			"resource"
+#define	FM_LIST_EVENT			"list"
+#define	FM_IREPORT_CLASS		"ireport"
+#define	FM_SYSEVENT_CLASS		"sysevent"
+
+/* FM list.* event class values */
+#define	FM_LIST_SUSPECT_CLASS		FM_LIST_EVENT ".suspect"
+#define	FM_LIST_ISOLATED_CLASS		FM_LIST_EVENT ".isolated"
+#define	FM_LIST_REPAIRED_CLASS		FM_LIST_EVENT ".repaired"
+#define	FM_LIST_UPDATED_CLASS		FM_LIST_EVENT ".updated"
+#define	FM_LIST_RESOLVED_CLASS		FM_LIST_EVENT ".resolved"
+
+/* ereport class subcategory values */
+#define	FM_ERROR_CPU			"cpu"
+#define	FM_ERROR_IO			"io"
+
+/* ereport version and payload member names */
+#define	FM_EREPORT_VERS0		0
+#define	FM_EREPORT_VERSION		FM_EREPORT_VERS0
+
+/* ereport payload member names */
+#define	FM_EREPORT_DETECTOR		"detector"
+#define	FM_EREPORT_ENA			"ena"
+#define	FM_EREPORT_TIME			"time"
+#define	FM_EREPORT_EID			"eid"
+
+/* list.* event payload member names */
+#define	FM_LIST_EVENT_SIZE		"list-sz"
+
+/* ireport.* event payload member names */
+#define	FM_IREPORT_DETECTOR		"detector"
+#define	FM_IREPORT_UUID			"uuid"
+#define	FM_IREPORT_PRIORITY		"pri"
+#define	FM_IREPORT_ATTRIBUTES		"attr"
+
+/*
+ * list.suspect, isolated, updated, repaired and resolved
+ * versions/payload member names.
+ */
+#define	FM_SUSPECT_UUID			"uuid"
+#define	FM_SUSPECT_DIAG_CODE		"code"
+#define	FM_SUSPECT_DIAG_TIME		"diag-time"
+#define	FM_SUSPECT_DE			"de"
+#define	FM_SUSPECT_FAULT_LIST		"fault-list"
+#define	FM_SUSPECT_FAULT_SZ		"fault-list-sz"
+#define	FM_SUSPECT_FAULT_STATUS		"fault-status"
+#define	FM_SUSPECT_INJECTED		"__injected"
+#define	FM_SUSPECT_MESSAGE		"message"
+#define	FM_SUSPECT_RETIRE		"retire"
+#define	FM_SUSPECT_RESPONSE		"response"
+#define	FM_SUSPECT_SEVERITY		"severity"
+
+#define	FM_SUSPECT_VERS0		0
+#define	FM_SUSPECT_VERSION		FM_SUSPECT_VERS0
+
+#define	FM_SUSPECT_FAULTY		0x1
+#define	FM_SUSPECT_UNUSABLE		0x2
+#define	FM_SUSPECT_NOT_PRESENT		0x4
+#define	FM_SUSPECT_DEGRADED		0x8
+#define	FM_SUSPECT_REPAIRED		0x10
+#define	FM_SUSPECT_REPLACED		0x20
+#define	FM_SUSPECT_ACQUITTED		0x40
+
+/* fault event versions and payload member names */
+#define	FM_FAULT_VERS0			0
+#define	FM_FAULT_VERSION		FM_FAULT_VERS0
+
+#define	FM_FAULT_ASRU			"asru"
+#define	FM_FAULT_FRU			"fru"
+#define	FM_FAULT_FRU_LABEL		"fru-label"
+#define	FM_FAULT_CERTAINTY		"certainty"
+#define	FM_FAULT_RESOURCE		"resource"
+#define	FM_FAULT_LOCATION		"location"
+
+/* resource event versions and payload member names */
+#define	FM_RSRC_VERS0			0
+#define	FM_RSRC_VERSION			FM_RSRC_VERS0
+#define	FM_RSRC_RESOURCE		"resource"
+
+/* resource.fm.asru.* payload member names */
+#define	FM_RSRC_ASRU_UUID		"uuid"
+#define	FM_RSRC_ASRU_CODE		"code"
+#define	FM_RSRC_ASRU_FAULTY		"faulty"
+#define	FM_RSRC_ASRU_REPAIRED		"repaired"
+#define	FM_RSRC_ASRU_REPLACED		"replaced"
+#define	FM_RSRC_ASRU_ACQUITTED		"acquitted"
+#define	FM_RSRC_ASRU_RESOLVED		"resolved"
+#define	FM_RSRC_ASRU_UNUSABLE		"unusable"
+#define	FM_RSRC_ASRU_EVENT		"event"
+
+/* resource.fm.xprt.* versions and payload member names */
+#define	FM_RSRC_XPRT_VERS0		0
+#define	FM_RSRC_XPRT_VERSION		FM_RSRC_XPRT_VERS0
+#define	FM_RSRC_XPRT_UUID		"uuid"
+#define	FM_RSRC_XPRT_SUBCLASS		"subclass"
+#define	FM_RSRC_XPRT_FAULT_STATUS	"fault-status"
+#define	FM_RSRC_XPRT_FAULT_HAS_ASRU	"fault-has-asru"
+
+/*
+ * FM ENA Format Macros
+ */
+#define	ENA_FORMAT_MASK			0x3
+#define	ENA_FORMAT(ena)			((ena) & ENA_FORMAT_MASK)
+
+/* ENA format types */
+#define	FM_ENA_FMT0			0
+#define	FM_ENA_FMT1			1
+#define	FM_ENA_FMT2			2
+
+/* Format 1 */
+#define	ENA_FMT1_GEN_MASK		0x00000000000003FCull
+#define	ENA_FMT1_ID_MASK		0xFFFFFFFFFFFFFC00ull
+#define	ENA_FMT1_CPUID_MASK		0x00000000000FFC00ull
+#define	ENA_FMT1_TIME_MASK		0xFFFFFFFFFFF00000ull
+#define	ENA_FMT1_GEN_SHFT		2
+#define	ENA_FMT1_ID_SHFT		10
+#define	ENA_FMT1_CPUID_SHFT		ENA_FMT1_ID_SHFT
+#define	ENA_FMT1_TIME_SHFT		20
+
+/* Format 2 */
+#define	ENA_FMT2_GEN_MASK		0x00000000000003FCull
+#define	ENA_FMT2_ID_MASK		0xFFFFFFFFFFFFFC00ull
+#define	ENA_FMT2_TIME_MASK		ENA_FMT2_ID_MASK
+#define	ENA_FMT2_GEN_SHFT		2
+#define	ENA_FMT2_ID_SHFT		10
+#define	ENA_FMT2_TIME_SHFT		ENA_FMT2_ID_SHFT
+
+/* Common FMRI type names */
+#define	FM_FMRI_AUTHORITY		"authority"
+#define	FM_FMRI_SCHEME			"scheme"
+#define	FM_FMRI_SVC_AUTHORITY		"svc-authority"
+#define	FM_FMRI_FACILITY		"facility"
+
+/* FMRI authority-type member names */
+#define	FM_FMRI_AUTH_CHASSIS		"chassis-id"
+#define	FM_FMRI_AUTH_PRODUCT_SN		"product-sn"
+#define	FM_FMRI_AUTH_PRODUCT		"product-id"
+#define	FM_FMRI_AUTH_DOMAIN		"domain-id"
+#define	FM_FMRI_AUTH_SERVER		"server-id"
+#define	FM_FMRI_AUTH_HOST		"host-id"
+
+#define	FM_AUTH_VERS0			0
+#define	FM_FMRI_AUTH_VERSION		FM_AUTH_VERS0
+
+/* scheme name values */
+#define	FM_FMRI_SCHEME_FMD		"fmd"
+#define	FM_FMRI_SCHEME_DEV		"dev"
+#define	FM_FMRI_SCHEME_HC		"hc"
+#define	FM_FMRI_SCHEME_SVC		"svc"
+#define	FM_FMRI_SCHEME_CPU		"cpu"
+#define	FM_FMRI_SCHEME_MEM		"mem"
+#define	FM_FMRI_SCHEME_MOD		"mod"
+#define	FM_FMRI_SCHEME_PKG		"pkg"
+#define	FM_FMRI_SCHEME_LEGACY		"legacy-hc"
+#define	FM_FMRI_SCHEME_ZFS		"zfs"
+#define	FM_FMRI_SCHEME_SW		"sw"
+
+/* Scheme versions */
+#define	FMD_SCHEME_VERSION0		0
+#define	FM_FMD_SCHEME_VERSION		FMD_SCHEME_VERSION0
+#define	DEV_SCHEME_VERSION0		0
+#define	FM_DEV_SCHEME_VERSION		DEV_SCHEME_VERSION0
+#define	FM_HC_VERS0			0
+#define	FM_HC_SCHEME_VERSION		FM_HC_VERS0
+#define	CPU_SCHEME_VERSION0		0
+#define	CPU_SCHEME_VERSION1		1
+#define	FM_CPU_SCHEME_VERSION		CPU_SCHEME_VERSION1
+#define	MEM_SCHEME_VERSION0		0
+#define	FM_MEM_SCHEME_VERSION		MEM_SCHEME_VERSION0
+#define	MOD_SCHEME_VERSION0		0
+#define	FM_MOD_SCHEME_VERSION		MOD_SCHEME_VERSION0
+#define	PKG_SCHEME_VERSION0		0
+#define	FM_PKG_SCHEME_VERSION		PKG_SCHEME_VERSION0
+#define	LEGACY_SCHEME_VERSION0		0
+#define	FM_LEGACY_SCHEME_VERSION	LEGACY_SCHEME_VERSION0
+#define	SVC_SCHEME_VERSION0		0
+#define	FM_SVC_SCHEME_VERSION		SVC_SCHEME_VERSION0
+#define	ZFS_SCHEME_VERSION0		0
+#define	FM_ZFS_SCHEME_VERSION		ZFS_SCHEME_VERSION0
+#define	SW_SCHEME_VERSION0		0
+#define	FM_SW_SCHEME_VERSION		SW_SCHEME_VERSION0
+
+/* hc scheme member names */
+#define	FM_FMRI_HC_SERIAL_ID		"serial"
+#define	FM_FMRI_HC_PART			"part"
+#define	FM_FMRI_HC_REVISION		"revision"
+#define	FM_FMRI_HC_ROOT			"hc-root"
+#define	FM_FMRI_HC_LIST_SZ		"hc-list-sz"
+#define	FM_FMRI_HC_LIST			"hc-list"
+#define	FM_FMRI_HC_SPECIFIC		"hc-specific"
+
+/* facility member names */
+#define	FM_FMRI_FACILITY_NAME		"facility-name"
+#define	FM_FMRI_FACILITY_TYPE		"facility-type"
+
+/* hc-list version and member names */
+#define	FM_FMRI_HC_NAME			"hc-name"
+#define	FM_FMRI_HC_ID			"hc-id"
+
+#define	HC_LIST_VERSION0		0
+#define	FM_HC_LIST_VERSION		HC_LIST_VERSION0
+
+/* hc-specific member names */
+#define	FM_FMRI_HC_SPECIFIC_OFFSET	"offset"
+#define	FM_FMRI_HC_SPECIFIC_PHYSADDR	"physaddr"
+
+/* fmd module scheme member names */
+#define	FM_FMRI_FMD_NAME		"mod-name"
+#define	FM_FMRI_FMD_VERSION		"mod-version"
+
+/* dev scheme member names */
+#define	FM_FMRI_DEV_ID			"devid"
+#define	FM_FMRI_DEV_TGTPTLUN0		"target-port-l0id"
+#define	FM_FMRI_DEV_PATH		"device-path"
+
+/* pkg scheme member names */
+#define	FM_FMRI_PKG_BASEDIR		"pkg-basedir"
+#define	FM_FMRI_PKG_INST		"pkg-inst"
+#define	FM_FMRI_PKG_VERSION		"pkg-version"
+
+/* svc scheme member names */
+#define	FM_FMRI_SVC_NAME		"svc-name"
+#define	FM_FMRI_SVC_INSTANCE		"svc-instance"
+#define	FM_FMRI_SVC_CONTRACT_ID		"svc-contract-id"
+
+/* svc-authority member names */
+#define	FM_FMRI_SVC_AUTH_SCOPE		"scope"
+#define	FM_FMRI_SVC_AUTH_SYSTEM_FQN	"system-fqn"
+
+/* cpu scheme member names */
+#define	FM_FMRI_CPU_ID			"cpuid"
+#define	FM_FMRI_CPU_SERIAL_ID		"serial"
+#define	FM_FMRI_CPU_MASK		"cpumask"
+#define	FM_FMRI_CPU_VID			"cpuvid"
+#define	FM_FMRI_CPU_CPUFRU		"cpufru"
+#define	FM_FMRI_CPU_CACHE_INDEX		"cacheindex"
+#define	FM_FMRI_CPU_CACHE_WAY		"cacheway"
+#define	FM_FMRI_CPU_CACHE_BIT		"cachebit"
+#define	FM_FMRI_CPU_CACHE_TYPE		"cachetype"
+
+#define	FM_FMRI_CPU_CACHE_TYPE_L2	0
+#define	FM_FMRI_CPU_CACHE_TYPE_L3	1
+
+/* legacy-hc scheme member names */
+#define	FM_FMRI_LEGACY_HC		"component"
+#define	FM_FMRI_LEGACY_HC_PREFIX	FM_FMRI_SCHEME_HC":///" \
+    FM_FMRI_LEGACY_HC"="
+
+/* mem scheme member names */
+#define	FM_FMRI_MEM_UNUM		"unum"
+#define	FM_FMRI_MEM_SERIAL_ID		"serial"
+#define	FM_FMRI_MEM_PHYSADDR		"physaddr"
+#define	FM_FMRI_MEM_MEMCONFIG		"memconfig"
+#define	FM_FMRI_MEM_OFFSET		"offset"
+
+/* mod scheme member names */
+#define	FM_FMRI_MOD_PKG			"mod-pkg"
+#define	FM_FMRI_MOD_NAME		"mod-name"
+#define	FM_FMRI_MOD_ID			"mod-id"
+#define	FM_FMRI_MOD_DESC		"mod-desc"
+
+/* zfs scheme member names */
+#define	FM_FMRI_ZFS_POOL		"pool"
+#define	FM_FMRI_ZFS_VDEV		"vdev"
+
+/* sw scheme member names - extra indentation for members of an nvlist */
+#define	FM_FMRI_SW_OBJ			"object"
+#define	FM_FMRI_SW_OBJ_PATH			"path"
+#define	FM_FMRI_SW_OBJ_ROOT			"root"
+#define	FM_FMRI_SW_OBJ_PKG			"pkg"
+#define	FM_FMRI_SW_SITE			"site"
+#define	FM_FMRI_SW_SITE_TOKEN			"token"
+#define	FM_FMRI_SW_SITE_MODULE			"module"
+#define	FM_FMRI_SW_SITE_FILE			"file"
+#define	FM_FMRI_SW_SITE_LINE			"line"
+#define	FM_FMRI_SW_SITE_FUNC			"func"
+#define	FM_FMRI_SW_CTXT			"context"
+#define	FM_FMRI_SW_CTXT_ORIGIN			"origin"
+#define	FM_FMRI_SW_CTXT_EXECNAME		"execname"
+#define	FM_FMRI_SW_CTXT_PID			"pid"
+#define	FM_FMRI_SW_CTXT_ZONE			"zone"
+#define	FM_FMRI_SW_CTXT_CTID			"ctid"
+#define	FM_FMRI_SW_CTXT_STACK			"stack"
+#define	FM_NVA_FREE		0	/* free allocator on nvlist_destroy */
+#define	FM_NVA_RETAIN		1	/* keep allocator on nvlist_destroy */
+
+extern nv_alloc_t *fm_nva_xcreate(char *, size_t);
+extern void fm_nva_xdestroy(nv_alloc_t *);
+extern nvlist_t *fm_nvlist_create(nv_alloc_t *);
+extern void fm_nvlist_destroy(nvlist_t *, int);
+extern void fm_ereport_set(nvlist_t *, int, const char *, uint64_t,
+    const nvlist_t *, ...);
+extern void fm_payload_set(nvlist_t *, ...);
+extern int i_fm_payload_set(nvlist_t *, const char *, va_list);
+extern void fm_fmri_hc_set(nvlist_t *, int, const nvlist_t *, nvlist_t *,
+    int, ...);
+extern void fm_fmri_dev_set(nvlist_t *, int, const nvlist_t *, const char *,
+    const char *, const char *);
+extern void fm_fmri_de_set(nvlist_t *, int, const nvlist_t *, const char *);
+extern void fm_fmri_cpu_set(nvlist_t *, int, const nvlist_t *, uint32_t,
+    uint8_t *, const char *);
+extern void fm_fmri_mem_set(nvlist_t *, int, const nvlist_t *, const char *,
+    const char *, uint64_t);
+extern void fm_fmri_zfs_set(nvlist_t *, int, uint64_t, uint64_t);
+extern void fm_fmri_hc_create(nvlist_t *, int, const nvlist_t *, nvlist_t *,
+    nvlist_t *, int, ...);
+
+extern uint64_t fm_ena_increment(uint64_t);
+extern uint64_t fm_ena_generate(uint64_t, uchar_t);
+extern uint64_t fm_ena_generate_cpu(uint64_t, processorid_t, uchar_t);
+extern uint64_t fm_ena_generation_get(uint64_t);
+extern uchar_t fm_ena_format_get(uint64_t);
+extern uint64_t fm_ena_id_get(uint64_t);
+extern uint64_t fm_ena_time_get(uint64_t);
+extern void fm_erpt_dropped_increment(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_FM_PROTOCOL_H */
diff --git a/include/sys/fm/util.h b/include/sys/fm/util.h
new file mode 100644
index 0000000000000..ff54b05bb6afd
--- /dev/null
+++ b/include/sys/fm/util.h
@@ -0,0 +1,118 @@
+/*
+ * 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) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
+ */
+
+#ifndef	_SYS_FM_UTIL_H
+#define	_SYS_FM_UTIL_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <sys/nvpair.h>
+
+/*
+ * Shared user/kernel definitions for class length, error channel name,
+ * and kernel event publisher string.
+ */
+#define	FM_MAX_CLASS 100
+#define	FM_ERROR_CHAN	"com.sun:fm:error"
+#define	FM_PUB		"fm"
+
+/*
+ * ereport dump device transport support
+ *
+ * Ereports are written out to the dump device at a proscribed offset from the
+ * end, similar to in-transit log messages.  The ereports are represented as a
+ * erpt_dump_t header followed by ed_size bytes of packed native nvlist data.
+ *
+ * NOTE: All of these constants and the header must be defined so they have the
+ * same representation for *both* 32-bit and 64-bit producers and consumers.
+ */
+#define	ERPT_MAGIC	0xf00d4eddU
+#define	ERPT_MAX_ERRS	16
+#define	ERPT_DATA_SZ	(6 * 1024)
+#define	ERPT_EVCH_MAX	256
+#define	ERPT_HIWAT	64
+
+typedef struct erpt_dump {
+	uint32_t ed_magic;	/* ERPT_MAGIC or zero to indicate end */
+	uint32_t ed_chksum;	/* checksum32() of packed nvlist data */
+	uint32_t ed_size;	/* ereport (nvl) fixed buf size */
+	uint32_t ed_pad;	/* reserved for future use */
+	hrtime_t ed_hrt_nsec;	/* hrtime of this ereport */
+	hrtime_t ed_hrt_base;	/* hrtime sample corresponding to ed_tod_base */
+	struct {
+		uint64_t sec;	/* seconds since gettimeofday() Epoch */
+		uint64_t nsec;	/* nanoseconds past ed_tod_base.sec */
+	} ed_tod_base;
+} erpt_dump_t;
+
+#ifdef _KERNEL
+
+#define	ZEVENT_SHUTDOWN		0x1
+
+typedef void zevent_cb_t(nvlist_t *, nvlist_t *);
+
+typedef struct zevent_s {
+	nvlist_t	*ev_nvl;	/* protected by the zevent_lock */
+	nvlist_t	*ev_detector;	/* " */
+	list_t		ev_ze_list;	/* " */
+	list_node_t	ev_node;	/* " */
+	zevent_cb_t	*ev_cb;		/* " */
+	uint64_t	ev_eid;
+} zevent_t;
+
+typedef struct zfs_zevent {
+	zevent_t	*ze_zevent;	/* protected by the zevent_lock */
+	list_node_t	ze_node;	/* " */
+	uint64_t	ze_dropped;	/* " */
+} zfs_zevent_t;
+
+extern void fm_init(void);
+extern void fm_fini(void);
+extern void fm_nvprint(nvlist_t *);
+extern void zfs_zevent_post_cb(nvlist_t *nvl, nvlist_t *detector);
+extern int zfs_zevent_post(nvlist_t *, nvlist_t *, zevent_cb_t *);
+extern void zfs_zevent_drain_all(int *);
+extern int zfs_zevent_fd_hold(int, minor_t *, zfs_zevent_t **);
+extern void zfs_zevent_fd_rele(int);
+extern int zfs_zevent_next(zfs_zevent_t *, nvlist_t **, uint64_t *, uint64_t *);
+extern int zfs_zevent_wait(zfs_zevent_t *);
+extern int zfs_zevent_seek(zfs_zevent_t *, uint64_t);
+extern void zfs_zevent_init(zfs_zevent_t **);
+extern void zfs_zevent_destroy(zfs_zevent_t *);
+
+#else
+
+static inline void fm_init(void) { }
+static inline void fm_fini(void) { }
+
+#endif  /* _KERNEL */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_FM_UTIL_H */
diff --git a/include/sys/frame.h b/include/sys/frame.h
new file mode 100644
index 0000000000000..2865dbb57dc3e
--- /dev/null
+++ b/include/sys/frame.h
@@ -0,0 +1,36 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (C) 2017 by Lawrence Livermore National Security, LLC.
+ */
+
+#ifndef _SYS_FRAME_H
+#define	_SYS_FRAME_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#if defined(__KERNEL__) && defined(HAVE_STACK_FRAME_NON_STANDARD)
+#include <linux/frame.h>
+#else
+#define	STACK_FRAME_NON_STANDARD(func)
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_FRAME_H */
diff --git a/include/sys/fs/Makefile.am b/include/sys/fs/Makefile.am
new file mode 100644
index 0000000000000..6a93053c8e2bb
--- /dev/null
+++ b/include/sys/fs/Makefile.am
@@ -0,0 +1,14 @@
+COMMON_H = \
+	zfs.h
+
+if CONFIG_USER
+libzfsdir = $(includedir)/libzfs/sys/fs
+libzfs_HEADERS = $(COMMON_H)
+endif
+
+if CONFIG_KERNEL
+if BUILD_LINUX
+kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys/fs
+kernel_HEADERS = $(COMMON_H)
+endif
+endif
diff --git a/include/sys/fs/zfs.h b/include/sys/fs/zfs.h
new file mode 100644
index 0000000000000..d3acd674a6c6a
--- /dev/null
+++ b/include/sys/fs/zfs.h
@@ -0,0 +1,1589 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
+ * Copyright (c) 2013, 2017 Joyent, Inc. All rights reserved.
+ * Copyright (c) 2014 Integros [integros.com]
+ * Copyright (c) 2017, Intel Corporation.
+ * Copyright (c) 2019 Datto Inc.
+ */
+
+/* Portions Copyright 2010 Robert Milkowski */
+
+#ifndef	_SYS_FS_ZFS_H
+#define	_SYS_FS_ZFS_H
+
+#include <sys/time.h>
+#include <sys/zio_priority.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Types and constants shared between userland and the kernel.
+ */
+
+/*
+ * Each dataset can be one of the following types.  These constants can be
+ * combined into masks that can be passed to various functions.
+ */
+typedef enum {
+	ZFS_TYPE_FILESYSTEM	= (1 << 0),
+	ZFS_TYPE_SNAPSHOT	= (1 << 1),
+	ZFS_TYPE_VOLUME		= (1 << 2),
+	ZFS_TYPE_POOL		= (1 << 3),
+	ZFS_TYPE_BOOKMARK	= (1 << 4)
+} zfs_type_t;
+
+/*
+ * NB: lzc_dataset_type should be updated whenever a new objset type is added,
+ * if it represents a real type of a dataset that can be created from userland.
+ */
+typedef enum dmu_objset_type {
+	DMU_OST_NONE,
+	DMU_OST_META,
+	DMU_OST_ZFS,
+	DMU_OST_ZVOL,
+	DMU_OST_OTHER,			/* For testing only! */
+	DMU_OST_ANY,			/* Be careful! */
+	DMU_OST_NUMTYPES
+} dmu_objset_type_t;
+
+#define	ZFS_TYPE_DATASET	\
+	(ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME | ZFS_TYPE_SNAPSHOT)
+
+/*
+ * All of these include the terminating NUL byte.
+ */
+#define	ZAP_MAXNAMELEN 256
+#define	ZAP_MAXVALUELEN (1024 * 8)
+#define	ZAP_OLDMAXVALUELEN 1024
+#define	ZFS_MAX_DATASET_NAME_LEN 256
+
+/*
+ * Dataset properties are identified by these constants and must be added to
+ * the end of this list to ensure that external consumers are not affected
+ * by the change. If you make any changes to this list, be sure to update
+ * the property table in module/zcommon/zfs_prop.c.
+ */
+typedef enum {
+	ZPROP_CONT = -2,
+	ZPROP_INVAL = -1,
+	ZFS_PROP_TYPE = 0,
+	ZFS_PROP_CREATION,
+	ZFS_PROP_USED,
+	ZFS_PROP_AVAILABLE,
+	ZFS_PROP_REFERENCED,
+	ZFS_PROP_COMPRESSRATIO,
+	ZFS_PROP_MOUNTED,
+	ZFS_PROP_ORIGIN,
+	ZFS_PROP_QUOTA,
+	ZFS_PROP_RESERVATION,
+	ZFS_PROP_VOLSIZE,
+	ZFS_PROP_VOLBLOCKSIZE,
+	ZFS_PROP_RECORDSIZE,
+	ZFS_PROP_MOUNTPOINT,
+	ZFS_PROP_SHARENFS,
+	ZFS_PROP_CHECKSUM,
+	ZFS_PROP_COMPRESSION,
+	ZFS_PROP_ATIME,
+	ZFS_PROP_DEVICES,
+	ZFS_PROP_EXEC,
+	ZFS_PROP_SETUID,
+	ZFS_PROP_READONLY,
+	ZFS_PROP_ZONED,
+	ZFS_PROP_SNAPDIR,
+	ZFS_PROP_ACLMODE,
+	ZFS_PROP_ACLINHERIT,
+	ZFS_PROP_CREATETXG,
+	ZFS_PROP_NAME,			/* not exposed to the user */
+	ZFS_PROP_CANMOUNT,
+	ZFS_PROP_ISCSIOPTIONS,		/* not exposed to the user */
+	ZFS_PROP_XATTR,
+	ZFS_PROP_NUMCLONES,		/* not exposed to the user */
+	ZFS_PROP_COPIES,
+	ZFS_PROP_VERSION,
+	ZFS_PROP_UTF8ONLY,
+	ZFS_PROP_NORMALIZE,
+	ZFS_PROP_CASE,
+	ZFS_PROP_VSCAN,
+	ZFS_PROP_NBMAND,
+	ZFS_PROP_SHARESMB,
+	ZFS_PROP_REFQUOTA,
+	ZFS_PROP_REFRESERVATION,
+	ZFS_PROP_GUID,
+	ZFS_PROP_PRIMARYCACHE,
+	ZFS_PROP_SECONDARYCACHE,
+	ZFS_PROP_USEDSNAP,
+	ZFS_PROP_USEDDS,
+	ZFS_PROP_USEDCHILD,
+	ZFS_PROP_USEDREFRESERV,
+	ZFS_PROP_USERACCOUNTING,	/* not exposed to the user */
+	ZFS_PROP_STMF_SHAREINFO,	/* not exposed to the user */
+	ZFS_PROP_DEFER_DESTROY,
+	ZFS_PROP_USERREFS,
+	ZFS_PROP_LOGBIAS,
+	ZFS_PROP_UNIQUE,		/* not exposed to the user */
+	ZFS_PROP_OBJSETID,
+	ZFS_PROP_DEDUP,
+	ZFS_PROP_MLSLABEL,
+	ZFS_PROP_SYNC,
+	ZFS_PROP_DNODESIZE,
+	ZFS_PROP_REFRATIO,
+	ZFS_PROP_WRITTEN,
+	ZFS_PROP_CLONES,
+	ZFS_PROP_LOGICALUSED,
+	ZFS_PROP_LOGICALREFERENCED,
+	ZFS_PROP_INCONSISTENT,		/* not exposed to the user */
+	ZFS_PROP_VOLMODE,
+	ZFS_PROP_FILESYSTEM_LIMIT,
+	ZFS_PROP_SNAPSHOT_LIMIT,
+	ZFS_PROP_FILESYSTEM_COUNT,
+	ZFS_PROP_SNAPSHOT_COUNT,
+	ZFS_PROP_SNAPDEV,
+	ZFS_PROP_ACLTYPE,
+	ZFS_PROP_SELINUX_CONTEXT,
+	ZFS_PROP_SELINUX_FSCONTEXT,
+	ZFS_PROP_SELINUX_DEFCONTEXT,
+	ZFS_PROP_SELINUX_ROOTCONTEXT,
+	ZFS_PROP_RELATIME,
+	ZFS_PROP_REDUNDANT_METADATA,
+	ZFS_PROP_OVERLAY,
+	ZFS_PROP_PREV_SNAP,
+	ZFS_PROP_RECEIVE_RESUME_TOKEN,
+	ZFS_PROP_ENCRYPTION,
+	ZFS_PROP_KEYLOCATION,
+	ZFS_PROP_KEYFORMAT,
+	ZFS_PROP_PBKDF2_SALT,
+	ZFS_PROP_PBKDF2_ITERS,
+	ZFS_PROP_ENCRYPTION_ROOT,
+	ZFS_PROP_KEY_GUID,
+	ZFS_PROP_KEYSTATUS,
+	ZFS_PROP_REMAPTXG,		/* obsolete - no longer used */
+	ZFS_PROP_SPECIAL_SMALL_BLOCKS,
+	ZFS_PROP_IVSET_GUID,		/* not exposed to the user */
+	ZFS_PROP_REDACTED,
+	ZFS_PROP_REDACT_SNAPS,
+	ZFS_NUM_PROPS
+} zfs_prop_t;
+
+typedef enum {
+	ZFS_PROP_USERUSED,
+	ZFS_PROP_USERQUOTA,
+	ZFS_PROP_GROUPUSED,
+	ZFS_PROP_GROUPQUOTA,
+	ZFS_PROP_USEROBJUSED,
+	ZFS_PROP_USEROBJQUOTA,
+	ZFS_PROP_GROUPOBJUSED,
+	ZFS_PROP_GROUPOBJQUOTA,
+	ZFS_PROP_PROJECTUSED,
+	ZFS_PROP_PROJECTQUOTA,
+	ZFS_PROP_PROJECTOBJUSED,
+	ZFS_PROP_PROJECTOBJQUOTA,
+	ZFS_NUM_USERQUOTA_PROPS
+} zfs_userquota_prop_t;
+
+extern const char *zfs_userquota_prop_prefixes[ZFS_NUM_USERQUOTA_PROPS];
+
+/*
+ * Pool properties are identified by these constants and must be added to the
+ * end of this list to ensure that external consumers are not affected
+ * by the change.  Properties must be registered in zfs_prop_init().
+ */
+typedef enum {
+	ZPOOL_PROP_INVAL = -1,
+	ZPOOL_PROP_NAME,
+	ZPOOL_PROP_SIZE,
+	ZPOOL_PROP_CAPACITY,
+	ZPOOL_PROP_ALTROOT,
+	ZPOOL_PROP_HEALTH,
+	ZPOOL_PROP_GUID,
+	ZPOOL_PROP_VERSION,
+	ZPOOL_PROP_BOOTFS,
+	ZPOOL_PROP_DELEGATION,
+	ZPOOL_PROP_AUTOREPLACE,
+	ZPOOL_PROP_CACHEFILE,
+	ZPOOL_PROP_FAILUREMODE,
+	ZPOOL_PROP_LISTSNAPS,
+	ZPOOL_PROP_AUTOEXPAND,
+	ZPOOL_PROP_DEDUPDITTO,
+	ZPOOL_PROP_DEDUPRATIO,
+	ZPOOL_PROP_FREE,
+	ZPOOL_PROP_ALLOCATED,
+	ZPOOL_PROP_READONLY,
+	ZPOOL_PROP_ASHIFT,
+	ZPOOL_PROP_COMMENT,
+	ZPOOL_PROP_EXPANDSZ,
+	ZPOOL_PROP_FREEING,
+	ZPOOL_PROP_FRAGMENTATION,
+	ZPOOL_PROP_LEAKED,
+	ZPOOL_PROP_MAXBLOCKSIZE,
+	ZPOOL_PROP_TNAME,
+	ZPOOL_PROP_MAXDNODESIZE,
+	ZPOOL_PROP_MULTIHOST,
+	ZPOOL_PROP_CHECKPOINT,
+	ZPOOL_PROP_LOAD_GUID,
+	ZPOOL_PROP_AUTOTRIM,
+	ZPOOL_NUM_PROPS
+} zpool_prop_t;
+
+/* Small enough to not hog a whole line of printout in zpool(1M). */
+#define	ZPROP_MAX_COMMENT	32
+
+#define	ZPROP_VALUE		"value"
+#define	ZPROP_SOURCE		"source"
+
+typedef enum {
+	ZPROP_SRC_NONE = 0x1,
+	ZPROP_SRC_DEFAULT = 0x2,
+	ZPROP_SRC_TEMPORARY = 0x4,
+	ZPROP_SRC_LOCAL = 0x8,
+	ZPROP_SRC_INHERITED = 0x10,
+	ZPROP_SRC_RECEIVED = 0x20
+} zprop_source_t;
+
+#define	ZPROP_SRC_ALL	0x3f
+
+#define	ZPROP_SOURCE_VAL_RECVD	"$recvd"
+#define	ZPROP_N_MORE_ERRORS	"N_MORE_ERRORS"
+
+/*
+ * Dataset flag implemented as a special entry in the props zap object
+ * indicating that the dataset has received properties on or after
+ * SPA_VERSION_RECVD_PROPS. The first such receive blows away local properties
+ * just as it did in earlier versions, and thereafter, local properties are
+ * preserved.
+ */
+#define	ZPROP_HAS_RECVD		"$hasrecvd"
+
+typedef enum {
+	ZPROP_ERR_NOCLEAR = 0x1, /* failure to clear existing props */
+	ZPROP_ERR_NORESTORE = 0x2 /* failure to restore props on error */
+} zprop_errflags_t;
+
+typedef int (*zprop_func)(int, void *);
+
+/*
+ * Properties to be set on the root file system of a new pool
+ * are stuffed into their own nvlist, which is then included in
+ * the properties nvlist with the pool properties.
+ */
+#define	ZPOOL_ROOTFS_PROPS	"root-props-nvl"
+
+/*
+ * Length of 'written@' and 'written#'
+ */
+#define	ZFS_WRITTEN_PROP_PREFIX_LEN	8
+
+/*
+ * Dataset property functions shared between libzfs and kernel.
+ */
+const char *zfs_prop_default_string(zfs_prop_t);
+uint64_t zfs_prop_default_numeric(zfs_prop_t);
+boolean_t zfs_prop_readonly(zfs_prop_t);
+boolean_t zfs_prop_visible(zfs_prop_t prop);
+boolean_t zfs_prop_inheritable(zfs_prop_t);
+boolean_t zfs_prop_setonce(zfs_prop_t);
+boolean_t zfs_prop_encryption_key_param(zfs_prop_t);
+boolean_t zfs_prop_valid_keylocation(const char *, boolean_t);
+const char *zfs_prop_to_name(zfs_prop_t);
+zfs_prop_t zfs_name_to_prop(const char *);
+boolean_t zfs_prop_user(const char *);
+boolean_t zfs_prop_userquota(const char *);
+boolean_t zfs_prop_written(const char *);
+int zfs_prop_index_to_string(zfs_prop_t, uint64_t, const char **);
+int zfs_prop_string_to_index(zfs_prop_t, const char *, uint64_t *);
+uint64_t zfs_prop_random_value(zfs_prop_t, uint64_t seed);
+boolean_t zfs_prop_valid_for_type(int, zfs_type_t, boolean_t);
+
+/*
+ * Pool property functions shared between libzfs and kernel.
+ */
+zpool_prop_t zpool_name_to_prop(const char *);
+const char *zpool_prop_to_name(zpool_prop_t);
+const char *zpool_prop_default_string(zpool_prop_t);
+uint64_t zpool_prop_default_numeric(zpool_prop_t);
+boolean_t zpool_prop_readonly(zpool_prop_t);
+boolean_t zpool_prop_setonce(zpool_prop_t);
+boolean_t zpool_prop_feature(const char *);
+boolean_t zpool_prop_unsupported(const char *);
+int zpool_prop_index_to_string(zpool_prop_t, uint64_t, const char **);
+int zpool_prop_string_to_index(zpool_prop_t, const char *, uint64_t *);
+uint64_t zpool_prop_random_value(zpool_prop_t, uint64_t seed);
+
+/*
+ * Definitions for the Delegation.
+ */
+typedef enum {
+	ZFS_DELEG_WHO_UNKNOWN = 0,
+	ZFS_DELEG_USER = 'u',
+	ZFS_DELEG_USER_SETS = 'U',
+	ZFS_DELEG_GROUP = 'g',
+	ZFS_DELEG_GROUP_SETS = 'G',
+	ZFS_DELEG_EVERYONE = 'e',
+	ZFS_DELEG_EVERYONE_SETS = 'E',
+	ZFS_DELEG_CREATE = 'c',
+	ZFS_DELEG_CREATE_SETS = 'C',
+	ZFS_DELEG_NAMED_SET = 's',
+	ZFS_DELEG_NAMED_SET_SETS = 'S'
+} zfs_deleg_who_type_t;
+
+typedef enum {
+	ZFS_DELEG_NONE = 0,
+	ZFS_DELEG_PERM_LOCAL = 1,
+	ZFS_DELEG_PERM_DESCENDENT = 2,
+	ZFS_DELEG_PERM_LOCALDESCENDENT = 3,
+	ZFS_DELEG_PERM_CREATE = 4
+} zfs_deleg_inherit_t;
+
+#define	ZFS_DELEG_PERM_UID	"uid"
+#define	ZFS_DELEG_PERM_GID	"gid"
+#define	ZFS_DELEG_PERM_GROUPS	"groups"
+
+#define	ZFS_MLSLABEL_DEFAULT	"none"
+
+#define	ZFS_SMB_ACL_SRC		"src"
+#define	ZFS_SMB_ACL_TARGET	"target"
+
+typedef enum {
+	ZFS_CANMOUNT_OFF = 0,
+	ZFS_CANMOUNT_ON = 1,
+	ZFS_CANMOUNT_NOAUTO = 2
+} zfs_canmount_type_t;
+
+typedef enum {
+	ZFS_LOGBIAS_LATENCY = 0,
+	ZFS_LOGBIAS_THROUGHPUT = 1
+} zfs_logbias_op_t;
+
+typedef enum zfs_share_op {
+	ZFS_SHARE_NFS = 0,
+	ZFS_UNSHARE_NFS = 1,
+	ZFS_SHARE_SMB = 2,
+	ZFS_UNSHARE_SMB = 3
+} zfs_share_op_t;
+
+typedef enum zfs_smb_acl_op {
+	ZFS_SMB_ACL_ADD,
+	ZFS_SMB_ACL_REMOVE,
+	ZFS_SMB_ACL_RENAME,
+	ZFS_SMB_ACL_PURGE
+} zfs_smb_acl_op_t;
+
+typedef enum zfs_cache_type {
+	ZFS_CACHE_NONE = 0,
+	ZFS_CACHE_METADATA = 1,
+	ZFS_CACHE_ALL = 2
+} zfs_cache_type_t;
+
+typedef enum {
+	ZFS_SYNC_STANDARD = 0,
+	ZFS_SYNC_ALWAYS = 1,
+	ZFS_SYNC_DISABLED = 2
+} zfs_sync_type_t;
+
+typedef enum {
+	ZFS_XATTR_OFF = 0,
+	ZFS_XATTR_DIR = 1,
+	ZFS_XATTR_SA = 2
+} zfs_xattr_type_t;
+
+typedef enum {
+	ZFS_DNSIZE_LEGACY = 0,
+	ZFS_DNSIZE_AUTO = 1,
+	ZFS_DNSIZE_1K = 1024,
+	ZFS_DNSIZE_2K = 2048,
+	ZFS_DNSIZE_4K = 4096,
+	ZFS_DNSIZE_8K = 8192,
+	ZFS_DNSIZE_16K = 16384
+} zfs_dnsize_type_t;
+
+typedef enum {
+	ZFS_REDUNDANT_METADATA_ALL,
+	ZFS_REDUNDANT_METADATA_MOST
+} zfs_redundant_metadata_type_t;
+
+typedef enum {
+	ZFS_VOLMODE_DEFAULT = 0,
+	ZFS_VOLMODE_GEOM = 1,
+	ZFS_VOLMODE_DEV = 2,
+	ZFS_VOLMODE_NONE = 3
+} zfs_volmode_t;
+
+typedef enum zfs_keystatus {
+	ZFS_KEYSTATUS_NONE = 0,
+	ZFS_KEYSTATUS_UNAVAILABLE,
+	ZFS_KEYSTATUS_AVAILABLE,
+} zfs_keystatus_t;
+
+typedef enum zfs_keyformat {
+	ZFS_KEYFORMAT_NONE = 0,
+	ZFS_KEYFORMAT_RAW,
+	ZFS_KEYFORMAT_HEX,
+	ZFS_KEYFORMAT_PASSPHRASE,
+	ZFS_KEYFORMAT_FORMATS
+} zfs_keyformat_t;
+
+typedef enum zfs_key_location {
+	ZFS_KEYLOCATION_NONE = 0,
+	ZFS_KEYLOCATION_PROMPT,
+	ZFS_KEYLOCATION_URI,
+	ZFS_KEYLOCATION_LOCATIONS
+} zfs_keylocation_t;
+
+#define	DEFAULT_PBKDF2_ITERATIONS 350000
+#define	MIN_PBKDF2_ITERATIONS 100000
+
+/*
+ * On-disk version number.
+ */
+#define	SPA_VERSION_1			1ULL
+#define	SPA_VERSION_2			2ULL
+#define	SPA_VERSION_3			3ULL
+#define	SPA_VERSION_4			4ULL
+#define	SPA_VERSION_5			5ULL
+#define	SPA_VERSION_6			6ULL
+#define	SPA_VERSION_7			7ULL
+#define	SPA_VERSION_8			8ULL
+#define	SPA_VERSION_9			9ULL
+#define	SPA_VERSION_10			10ULL
+#define	SPA_VERSION_11			11ULL
+#define	SPA_VERSION_12			12ULL
+#define	SPA_VERSION_13			13ULL
+#define	SPA_VERSION_14			14ULL
+#define	SPA_VERSION_15			15ULL
+#define	SPA_VERSION_16			16ULL
+#define	SPA_VERSION_17			17ULL
+#define	SPA_VERSION_18			18ULL
+#define	SPA_VERSION_19			19ULL
+#define	SPA_VERSION_20			20ULL
+#define	SPA_VERSION_21			21ULL
+#define	SPA_VERSION_22			22ULL
+#define	SPA_VERSION_23			23ULL
+#define	SPA_VERSION_24			24ULL
+#define	SPA_VERSION_25			25ULL
+#define	SPA_VERSION_26			26ULL
+#define	SPA_VERSION_27			27ULL
+#define	SPA_VERSION_28			28ULL
+#define	SPA_VERSION_5000		5000ULL
+
+/*
+ * The incrementing pool version number has been replaced by pool feature
+ * flags.  For more details, see zfeature.c.
+ */
+#define	SPA_VERSION			SPA_VERSION_5000
+#define	SPA_VERSION_STRING		"5000"
+
+/*
+ * Symbolic names for the changes that caused a SPA_VERSION switch.
+ * Used in the code when checking for presence or absence of a feature.
+ * Feel free to define multiple symbolic names for each version if there
+ * were multiple changes to on-disk structures during that version.
+ *
+ * NOTE: When checking the current SPA_VERSION in your code, be sure
+ *       to use spa_version() since it reports the version of the
+ *       last synced uberblock.  Checking the in-flight version can
+ *       be dangerous in some cases.
+ */
+#define	SPA_VERSION_INITIAL		SPA_VERSION_1
+#define	SPA_VERSION_DITTO_BLOCKS	SPA_VERSION_2
+#define	SPA_VERSION_SPARES		SPA_VERSION_3
+#define	SPA_VERSION_RAIDZ2		SPA_VERSION_3
+#define	SPA_VERSION_BPOBJ_ACCOUNT	SPA_VERSION_3
+#define	SPA_VERSION_RAIDZ_DEFLATE	SPA_VERSION_3
+#define	SPA_VERSION_DNODE_BYTES		SPA_VERSION_3
+#define	SPA_VERSION_ZPOOL_HISTORY	SPA_VERSION_4
+#define	SPA_VERSION_GZIP_COMPRESSION	SPA_VERSION_5
+#define	SPA_VERSION_BOOTFS		SPA_VERSION_6
+#define	SPA_VERSION_SLOGS		SPA_VERSION_7
+#define	SPA_VERSION_DELEGATED_PERMS	SPA_VERSION_8
+#define	SPA_VERSION_FUID		SPA_VERSION_9
+#define	SPA_VERSION_REFRESERVATION	SPA_VERSION_9
+#define	SPA_VERSION_REFQUOTA		SPA_VERSION_9
+#define	SPA_VERSION_UNIQUE_ACCURATE	SPA_VERSION_9
+#define	SPA_VERSION_L2CACHE		SPA_VERSION_10
+#define	SPA_VERSION_NEXT_CLONES		SPA_VERSION_11
+#define	SPA_VERSION_ORIGIN		SPA_VERSION_11
+#define	SPA_VERSION_DSL_SCRUB		SPA_VERSION_11
+#define	SPA_VERSION_SNAP_PROPS		SPA_VERSION_12
+#define	SPA_VERSION_USED_BREAKDOWN	SPA_VERSION_13
+#define	SPA_VERSION_PASSTHROUGH_X	SPA_VERSION_14
+#define	SPA_VERSION_USERSPACE		SPA_VERSION_15
+#define	SPA_VERSION_STMF_PROP		SPA_VERSION_16
+#define	SPA_VERSION_RAIDZ3		SPA_VERSION_17
+#define	SPA_VERSION_USERREFS		SPA_VERSION_18
+#define	SPA_VERSION_HOLES		SPA_VERSION_19
+#define	SPA_VERSION_ZLE_COMPRESSION	SPA_VERSION_20
+#define	SPA_VERSION_DEDUP		SPA_VERSION_21
+#define	SPA_VERSION_RECVD_PROPS		SPA_VERSION_22
+#define	SPA_VERSION_SLIM_ZIL		SPA_VERSION_23
+#define	SPA_VERSION_SA			SPA_VERSION_24
+#define	SPA_VERSION_SCAN		SPA_VERSION_25
+#define	SPA_VERSION_DIR_CLONES		SPA_VERSION_26
+#define	SPA_VERSION_DEADLISTS		SPA_VERSION_26
+#define	SPA_VERSION_FAST_SNAP		SPA_VERSION_27
+#define	SPA_VERSION_MULTI_REPLACE	SPA_VERSION_28
+#define	SPA_VERSION_BEFORE_FEATURES	SPA_VERSION_28
+#define	SPA_VERSION_FEATURES		SPA_VERSION_5000
+
+#define	SPA_VERSION_IS_SUPPORTED(v) \
+	(((v) >= SPA_VERSION_INITIAL && (v) <= SPA_VERSION_BEFORE_FEATURES) || \
+	((v) >= SPA_VERSION_FEATURES && (v) <= SPA_VERSION))
+
+/*
+ * ZPL version - rev'd whenever an incompatible on-disk format change
+ * occurs.  This is independent of SPA/DMU/ZAP versioning.  You must
+ * also update the version_table[] and help message in zfs_prop.c.
+ */
+#define	ZPL_VERSION_1			1ULL
+#define	ZPL_VERSION_2			2ULL
+#define	ZPL_VERSION_3			3ULL
+#define	ZPL_VERSION_4			4ULL
+#define	ZPL_VERSION_5			5ULL
+#define	ZPL_VERSION			ZPL_VERSION_5
+#define	ZPL_VERSION_STRING		"5"
+
+#define	ZPL_VERSION_INITIAL		ZPL_VERSION_1
+#define	ZPL_VERSION_DIRENT_TYPE		ZPL_VERSION_2
+#define	ZPL_VERSION_FUID		ZPL_VERSION_3
+#define	ZPL_VERSION_NORMALIZATION	ZPL_VERSION_3
+#define	ZPL_VERSION_SYSATTR		ZPL_VERSION_3
+#define	ZPL_VERSION_USERSPACE		ZPL_VERSION_4
+#define	ZPL_VERSION_SA			ZPL_VERSION_5
+
+/* Persistent L2ARC version */
+#define	L2ARC_PERSISTENT_VERSION_1	1ULL
+#define	L2ARC_PERSISTENT_VERSION	L2ARC_PERSISTENT_VERSION_1
+#define	L2ARC_PERSISTENT_VERSION_STRING	"1"
+
+/* Rewind policy information */
+#define	ZPOOL_NO_REWIND		1  /* No policy - default behavior */
+#define	ZPOOL_NEVER_REWIND	2  /* Do not search for best txg or rewind */
+#define	ZPOOL_TRY_REWIND	4  /* Search for best txg, but do not rewind */
+#define	ZPOOL_DO_REWIND		8  /* Rewind to best txg w/in deferred frees */
+#define	ZPOOL_EXTREME_REWIND	16 /* Allow extreme measures to find best txg */
+#define	ZPOOL_REWIND_MASK	28 /* All the possible rewind bits */
+#define	ZPOOL_REWIND_POLICIES	31 /* All the possible policy bits */
+
+typedef struct zpool_load_policy {
+	uint32_t	zlp_rewind;	/* rewind policy requested */
+	uint64_t	zlp_maxmeta;	/* max acceptable meta-data errors */
+	uint64_t	zlp_maxdata;	/* max acceptable data errors */
+	uint64_t	zlp_txg;	/* specific txg to load */
+} zpool_load_policy_t;
+
+/*
+ * The following are configuration names used in the nvlist describing a pool's
+ * configuration.  New on-disk names should be prefixed with "<reversed-DNS>:"
+ * (e.g. "org.openzfs:") to avoid conflicting names being developed
+ * independently.
+ */
+#define	ZPOOL_CONFIG_VERSION		"version"
+#define	ZPOOL_CONFIG_POOL_NAME		"name"
+#define	ZPOOL_CONFIG_POOL_STATE		"state"
+#define	ZPOOL_CONFIG_POOL_TXG		"txg"
+#define	ZPOOL_CONFIG_POOL_GUID		"pool_guid"
+#define	ZPOOL_CONFIG_CREATE_TXG		"create_txg"
+#define	ZPOOL_CONFIG_TOP_GUID		"top_guid"
+#define	ZPOOL_CONFIG_VDEV_TREE		"vdev_tree"
+#define	ZPOOL_CONFIG_TYPE		"type"
+#define	ZPOOL_CONFIG_CHILDREN		"children"
+#define	ZPOOL_CONFIG_ID			"id"
+#define	ZPOOL_CONFIG_GUID		"guid"
+#define	ZPOOL_CONFIG_INDIRECT_OBJECT	"com.delphix:indirect_object"
+#define	ZPOOL_CONFIG_INDIRECT_BIRTHS	"com.delphix:indirect_births"
+#define	ZPOOL_CONFIG_PREV_INDIRECT_VDEV	"com.delphix:prev_indirect_vdev"
+#define	ZPOOL_CONFIG_PATH		"path"
+#define	ZPOOL_CONFIG_DEVID		"devid"
+#define	ZPOOL_CONFIG_METASLAB_ARRAY	"metaslab_array"
+#define	ZPOOL_CONFIG_METASLAB_SHIFT	"metaslab_shift"
+#define	ZPOOL_CONFIG_ASHIFT		"ashift"
+#define	ZPOOL_CONFIG_ASIZE		"asize"
+#define	ZPOOL_CONFIG_DTL		"DTL"
+#define	ZPOOL_CONFIG_SCAN_STATS		"scan_stats"	/* not stored on disk */
+#define	ZPOOL_CONFIG_REMOVAL_STATS	"removal_stats"	/* not stored on disk */
+#define	ZPOOL_CONFIG_CHECKPOINT_STATS	"checkpoint_stats" /* not on disk */
+#define	ZPOOL_CONFIG_VDEV_STATS		"vdev_stats"	/* not stored on disk */
+#define	ZPOOL_CONFIG_INDIRECT_SIZE	"indirect_size"	/* not stored on disk */
+
+/* container nvlist of extended stats */
+#define	ZPOOL_CONFIG_VDEV_STATS_EX	"vdev_stats_ex"
+
+/* Active queue read/write stats */
+#define	ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE	"vdev_sync_r_active_queue"
+#define	ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE	"vdev_sync_w_active_queue"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE	"vdev_async_r_active_queue"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE	"vdev_async_w_active_queue"
+#define	ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE	"vdev_async_scrub_active_queue"
+#define	ZPOOL_CONFIG_VDEV_TRIM_ACTIVE_QUEUE	"vdev_async_trim_active_queue"
+
+/* Queue sizes */
+#define	ZPOOL_CONFIG_VDEV_SYNC_R_PEND_QUEUE	"vdev_sync_r_pend_queue"
+#define	ZPOOL_CONFIG_VDEV_SYNC_W_PEND_QUEUE	"vdev_sync_w_pend_queue"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_R_PEND_QUEUE	"vdev_async_r_pend_queue"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_W_PEND_QUEUE	"vdev_async_w_pend_queue"
+#define	ZPOOL_CONFIG_VDEV_SCRUB_PEND_QUEUE	"vdev_async_scrub_pend_queue"
+#define	ZPOOL_CONFIG_VDEV_TRIM_PEND_QUEUE	"vdev_async_trim_pend_queue"
+
+/* Latency read/write histogram stats */
+#define	ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO	"vdev_tot_r_lat_histo"
+#define	ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO	"vdev_tot_w_lat_histo"
+#define	ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO	"vdev_disk_r_lat_histo"
+#define	ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO	"vdev_disk_w_lat_histo"
+#define	ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO	"vdev_sync_r_lat_histo"
+#define	ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO	"vdev_sync_w_lat_histo"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO	"vdev_async_r_lat_histo"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO	"vdev_async_w_lat_histo"
+#define	ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO	"vdev_scrub_histo"
+#define	ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO	"vdev_trim_histo"
+
+/* Request size histograms */
+#define	ZPOOL_CONFIG_VDEV_SYNC_IND_R_HISTO	"vdev_sync_ind_r_histo"
+#define	ZPOOL_CONFIG_VDEV_SYNC_IND_W_HISTO	"vdev_sync_ind_w_histo"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_IND_R_HISTO	"vdev_async_ind_r_histo"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_IND_W_HISTO	"vdev_async_ind_w_histo"
+#define	ZPOOL_CONFIG_VDEV_IND_SCRUB_HISTO	"vdev_ind_scrub_histo"
+#define	ZPOOL_CONFIG_VDEV_IND_TRIM_HISTO	"vdev_ind_trim_histo"
+#define	ZPOOL_CONFIG_VDEV_SYNC_AGG_R_HISTO	"vdev_sync_agg_r_histo"
+#define	ZPOOL_CONFIG_VDEV_SYNC_AGG_W_HISTO	"vdev_sync_agg_w_histo"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_AGG_R_HISTO	"vdev_async_agg_r_histo"
+#define	ZPOOL_CONFIG_VDEV_ASYNC_AGG_W_HISTO	"vdev_async_agg_w_histo"
+#define	ZPOOL_CONFIG_VDEV_AGG_SCRUB_HISTO	"vdev_agg_scrub_histo"
+#define	ZPOOL_CONFIG_VDEV_AGG_TRIM_HISTO	"vdev_agg_trim_histo"
+
+/* Number of slow IOs */
+#define	ZPOOL_CONFIG_VDEV_SLOW_IOS		"vdev_slow_ios"
+
+/* vdev enclosure sysfs path */
+#define	ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH	"vdev_enc_sysfs_path"
+
+#define	ZPOOL_CONFIG_WHOLE_DISK		"whole_disk"
+#define	ZPOOL_CONFIG_ERRCOUNT		"error_count"
+#define	ZPOOL_CONFIG_NOT_PRESENT	"not_present"
+#define	ZPOOL_CONFIG_SPARES		"spares"
+#define	ZPOOL_CONFIG_IS_SPARE		"is_spare"
+#define	ZPOOL_CONFIG_NPARITY		"nparity"
+#define	ZPOOL_CONFIG_HOSTID		"hostid"
+#define	ZPOOL_CONFIG_HOSTNAME		"hostname"
+#define	ZPOOL_CONFIG_LOADED_TIME	"initial_load_time"
+#define	ZPOOL_CONFIG_UNSPARE		"unspare"
+#define	ZPOOL_CONFIG_PHYS_PATH		"phys_path"
+#define	ZPOOL_CONFIG_IS_LOG		"is_log"
+#define	ZPOOL_CONFIG_L2CACHE		"l2cache"
+#define	ZPOOL_CONFIG_HOLE_ARRAY		"hole_array"
+#define	ZPOOL_CONFIG_VDEV_CHILDREN	"vdev_children"
+#define	ZPOOL_CONFIG_IS_HOLE		"is_hole"
+#define	ZPOOL_CONFIG_DDT_HISTOGRAM	"ddt_histogram"
+#define	ZPOOL_CONFIG_DDT_OBJ_STATS	"ddt_object_stats"
+#define	ZPOOL_CONFIG_DDT_STATS		"ddt_stats"
+#define	ZPOOL_CONFIG_SPLIT		"splitcfg"
+#define	ZPOOL_CONFIG_ORIG_GUID		"orig_guid"
+#define	ZPOOL_CONFIG_SPLIT_GUID		"split_guid"
+#define	ZPOOL_CONFIG_SPLIT_LIST		"guid_list"
+#define	ZPOOL_CONFIG_REMOVING		"removing"
+#define	ZPOOL_CONFIG_RESILVER_TXG	"resilver_txg"
+#define	ZPOOL_CONFIG_REBUILD_TXG	"rebuild_txg"
+#define	ZPOOL_CONFIG_COMMENT		"comment"
+#define	ZPOOL_CONFIG_SUSPENDED		"suspended"	/* not stored on disk */
+#define	ZPOOL_CONFIG_SUSPENDED_REASON	"suspended_reason"	/* not stored */
+#define	ZPOOL_CONFIG_TIMESTAMP		"timestamp"	/* not stored on disk */
+#define	ZPOOL_CONFIG_BOOTFS		"bootfs"	/* not stored on disk */
+#define	ZPOOL_CONFIG_MISSING_DEVICES	"missing_vdevs"	/* not stored on disk */
+#define	ZPOOL_CONFIG_LOAD_INFO		"load_info"	/* not stored on disk */
+#define	ZPOOL_CONFIG_REWIND_INFO	"rewind_info"	/* not stored on disk */
+#define	ZPOOL_CONFIG_UNSUP_FEAT		"unsup_feat"	/* not stored on disk */
+#define	ZPOOL_CONFIG_ENABLED_FEAT	"enabled_feat"	/* not stored on disk */
+#define	ZPOOL_CONFIG_CAN_RDONLY		"can_rdonly"	/* not stored on disk */
+#define	ZPOOL_CONFIG_FEATURES_FOR_READ	"features_for_read"
+#define	ZPOOL_CONFIG_FEATURE_STATS	"feature_stats"	/* not stored on disk */
+#define	ZPOOL_CONFIG_ERRATA		"errata"	/* not stored on disk */
+#define	ZPOOL_CONFIG_VDEV_TOP_ZAP	"com.delphix:vdev_zap_top"
+#define	ZPOOL_CONFIG_VDEV_LEAF_ZAP	"com.delphix:vdev_zap_leaf"
+#define	ZPOOL_CONFIG_HAS_PER_VDEV_ZAPS	"com.delphix:has_per_vdev_zaps"
+#define	ZPOOL_CONFIG_RESILVER_DEFER	"com.datto:resilver_defer"
+#define	ZPOOL_CONFIG_CACHEFILE		"cachefile"	/* not stored on disk */
+#define	ZPOOL_CONFIG_MMP_STATE		"mmp_state"	/* not stored on disk */
+#define	ZPOOL_CONFIG_MMP_TXG		"mmp_txg"	/* not stored on disk */
+#define	ZPOOL_CONFIG_MMP_SEQ		"mmp_seq"	/* not stored on disk */
+#define	ZPOOL_CONFIG_MMP_HOSTNAME	"mmp_hostname"	/* not stored on disk */
+#define	ZPOOL_CONFIG_MMP_HOSTID		"mmp_hostid"	/* not stored on disk */
+#define	ZPOOL_CONFIG_ALLOCATION_BIAS	"alloc_bias"	/* not stored on disk */
+#define	ZPOOL_CONFIG_EXPANSION_TIME	"expansion_time"	/* not stored */
+#define	ZPOOL_CONFIG_REBUILD_STATS	"org.openzfs:rebuild_stats"
+
+/*
+ * The persistent vdev state is stored as separate values rather than a single
+ * 'vdev_state' entry.  This is because a device can be in multiple states, such
+ * as offline and degraded.
+ */
+#define	ZPOOL_CONFIG_OFFLINE		"offline"
+#define	ZPOOL_CONFIG_FAULTED		"faulted"
+#define	ZPOOL_CONFIG_DEGRADED		"degraded"
+#define	ZPOOL_CONFIG_REMOVED		"removed"
+#define	ZPOOL_CONFIG_FRU		"fru"
+#define	ZPOOL_CONFIG_AUX_STATE		"aux_state"
+
+/* Pool load policy parameters */
+#define	ZPOOL_LOAD_POLICY		"load-policy"
+#define	ZPOOL_LOAD_REWIND_POLICY	"load-rewind-policy"
+#define	ZPOOL_LOAD_REQUEST_TXG		"load-request-txg"
+#define	ZPOOL_LOAD_META_THRESH		"load-meta-thresh"
+#define	ZPOOL_LOAD_DATA_THRESH		"load-data-thresh"
+
+/* Rewind data discovered */
+#define	ZPOOL_CONFIG_LOAD_TIME		"rewind_txg_ts"
+#define	ZPOOL_CONFIG_LOAD_DATA_ERRORS	"verify_data_errors"
+#define	ZPOOL_CONFIG_REWIND_TIME	"seconds_of_rewind"
+
+#define	VDEV_TYPE_ROOT			"root"
+#define	VDEV_TYPE_MIRROR		"mirror"
+#define	VDEV_TYPE_REPLACING		"replacing"
+#define	VDEV_TYPE_RAIDZ			"raidz"
+#define	VDEV_TYPE_DISK			"disk"
+#define	VDEV_TYPE_FILE			"file"
+#define	VDEV_TYPE_MISSING		"missing"
+#define	VDEV_TYPE_HOLE			"hole"
+#define	VDEV_TYPE_SPARE			"spare"
+#define	VDEV_TYPE_LOG			"log"
+#define	VDEV_TYPE_L2CACHE		"l2cache"
+#define	VDEV_TYPE_INDIRECT		"indirect"
+
+/* VDEV_TOP_ZAP_* are used in top-level vdev ZAP objects. */
+#define	VDEV_TOP_ZAP_INDIRECT_OBSOLETE_SM \
+	"com.delphix:indirect_obsolete_sm"
+#define	VDEV_TOP_ZAP_OBSOLETE_COUNTS_ARE_PRECISE \
+	"com.delphix:obsolete_counts_are_precise"
+#define	VDEV_TOP_ZAP_POOL_CHECKPOINT_SM \
+	"com.delphix:pool_checkpoint_sm"
+#define	VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS \
+	"com.delphix:ms_unflushed_phys_txgs"
+
+#define	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS \
+	"org.openzfs:vdev_rebuild"
+
+#define	VDEV_TOP_ZAP_ALLOCATION_BIAS \
+	"org.zfsonlinux:allocation_bias"
+
+/* vdev metaslab allocation bias */
+#define	VDEV_ALLOC_BIAS_LOG		"log"
+#define	VDEV_ALLOC_BIAS_SPECIAL		"special"
+#define	VDEV_ALLOC_BIAS_DEDUP		"dedup"
+
+/* vdev initialize state */
+#define	VDEV_LEAF_ZAP_INITIALIZE_LAST_OFFSET	\
+	"com.delphix:next_offset_to_initialize"
+#define	VDEV_LEAF_ZAP_INITIALIZE_STATE	\
+	"com.delphix:vdev_initialize_state"
+#define	VDEV_LEAF_ZAP_INITIALIZE_ACTION_TIME	\
+	"com.delphix:vdev_initialize_action_time"
+
+/* vdev TRIM state */
+#define	VDEV_LEAF_ZAP_TRIM_LAST_OFFSET	\
+	"org.zfsonlinux:next_offset_to_trim"
+#define	VDEV_LEAF_ZAP_TRIM_STATE	\
+	"org.zfsonlinux:vdev_trim_state"
+#define	VDEV_LEAF_ZAP_TRIM_ACTION_TIME	\
+	"org.zfsonlinux:vdev_trim_action_time"
+#define	VDEV_LEAF_ZAP_TRIM_RATE		\
+	"org.zfsonlinux:vdev_trim_rate"
+#define	VDEV_LEAF_ZAP_TRIM_PARTIAL	\
+	"org.zfsonlinux:vdev_trim_partial"
+#define	VDEV_LEAF_ZAP_TRIM_SECURE	\
+	"org.zfsonlinux:vdev_trim_secure"
+
+/*
+ * This is needed in userland to report the minimum necessary device size.
+ */
+#define	SPA_MINDEVSIZE		(64ULL << 20)
+
+/*
+ * Set if the fragmentation has not yet been calculated. This can happen
+ * because the space maps have not been upgraded or the histogram feature
+ * is not enabled.
+ */
+#define	ZFS_FRAG_INVALID	UINT64_MAX
+
+/*
+ * The location of the pool configuration repository, shared between kernel and
+ * userland.
+ */
+#define	ZPOOL_CACHE_BOOT	"/boot/zfs/zpool.cache"
+#define	ZPOOL_CACHE		"/etc/zfs/zpool.cache"
+/*
+ * vdev states are ordered from least to most healthy.
+ * A vdev that's CANT_OPEN or below is considered unusable.
+ */
+typedef enum vdev_state {
+	VDEV_STATE_UNKNOWN = 0,	/* Uninitialized vdev			*/
+	VDEV_STATE_CLOSED,	/* Not currently open			*/
+	VDEV_STATE_OFFLINE,	/* Not allowed to open			*/
+	VDEV_STATE_REMOVED,	/* Explicitly removed from system	*/
+	VDEV_STATE_CANT_OPEN,	/* Tried to open, but failed		*/
+	VDEV_STATE_FAULTED,	/* External request to fault device	*/
+	VDEV_STATE_DEGRADED,	/* Replicated vdev with unhealthy kids	*/
+	VDEV_STATE_HEALTHY	/* Presumed good			*/
+} vdev_state_t;
+
+#define	VDEV_STATE_ONLINE	VDEV_STATE_HEALTHY
+
+/*
+ * vdev aux states.  When a vdev is in the CANT_OPEN state, the aux field
+ * of the vdev stats structure uses these constants to distinguish why.
+ */
+typedef enum vdev_aux {
+	VDEV_AUX_NONE,		/* no error				*/
+	VDEV_AUX_OPEN_FAILED,	/* ldi_open_*() or vn_open() failed	*/
+	VDEV_AUX_CORRUPT_DATA,	/* bad label or disk contents		*/
+	VDEV_AUX_NO_REPLICAS,	/* insufficient number of replicas	*/
+	VDEV_AUX_BAD_GUID_SUM,	/* vdev guid sum doesn't match		*/
+	VDEV_AUX_TOO_SMALL,	/* vdev size is too small		*/
+	VDEV_AUX_BAD_LABEL,	/* the label is OK but invalid		*/
+	VDEV_AUX_VERSION_NEWER,	/* on-disk version is too new		*/
+	VDEV_AUX_VERSION_OLDER,	/* on-disk version is too old		*/
+	VDEV_AUX_UNSUP_FEAT,	/* unsupported features			*/
+	VDEV_AUX_SPARED,	/* hot spare used in another pool	*/
+	VDEV_AUX_ERR_EXCEEDED,	/* too many errors			*/
+	VDEV_AUX_IO_FAILURE,	/* experienced I/O failure		*/
+	VDEV_AUX_BAD_LOG,	/* cannot read log chain(s)		*/
+	VDEV_AUX_EXTERNAL,	/* external diagnosis or forced fault	*/
+	VDEV_AUX_SPLIT_POOL,	/* vdev was split off into another pool	*/
+	VDEV_AUX_BAD_ASHIFT,	/* vdev ashift is invalid		*/
+	VDEV_AUX_EXTERNAL_PERSIST,	/* persistent forced fault	*/
+	VDEV_AUX_ACTIVE,	/* vdev active on a different host	*/
+	VDEV_AUX_CHILDREN_OFFLINE, /* all children are offline		*/
+	VDEV_AUX_ASHIFT_TOO_BIG, /* vdev's min block size is too large   */
+} vdev_aux_t;
+
+/*
+ * pool state.  The following states are written to disk as part of the normal
+ * SPA lifecycle: ACTIVE, EXPORTED, DESTROYED, SPARE, L2CACHE.  The remaining
+ * states are software abstractions used at various levels to communicate
+ * pool state.
+ */
+typedef enum pool_state {
+	POOL_STATE_ACTIVE = 0,		/* In active use		*/
+	POOL_STATE_EXPORTED,		/* Explicitly exported		*/
+	POOL_STATE_DESTROYED,		/* Explicitly destroyed		*/
+	POOL_STATE_SPARE,		/* Reserved for hot spare use	*/
+	POOL_STATE_L2CACHE,		/* Level 2 ARC device		*/
+	POOL_STATE_UNINITIALIZED,	/* Internal spa_t state		*/
+	POOL_STATE_UNAVAIL,		/* Internal libzfs state	*/
+	POOL_STATE_POTENTIALLY_ACTIVE	/* Internal libzfs state	*/
+} pool_state_t;
+
+/*
+ * mmp state. The following states provide additional detail describing
+ * why a pool couldn't be safely imported.
+ */
+typedef enum mmp_state {
+	MMP_STATE_ACTIVE = 0,		/* In active use		*/
+	MMP_STATE_INACTIVE,		/* Inactive and safe to import	*/
+	MMP_STATE_NO_HOSTID		/* System hostid is not set	*/
+} mmp_state_t;
+
+/*
+ * Scan Functions.
+ */
+typedef enum pool_scan_func {
+	POOL_SCAN_NONE,
+	POOL_SCAN_SCRUB,
+	POOL_SCAN_RESILVER,
+	POOL_SCAN_FUNCS
+} pool_scan_func_t;
+
+/*
+ * Used to control scrub pause and resume.
+ */
+typedef enum pool_scrub_cmd {
+	POOL_SCRUB_NORMAL = 0,
+	POOL_SCRUB_PAUSE,
+	POOL_SCRUB_FLAGS_END
+} pool_scrub_cmd_t;
+
+typedef enum {
+	CS_NONE,
+	CS_CHECKPOINT_EXISTS,
+	CS_CHECKPOINT_DISCARDING,
+	CS_NUM_STATES
+} checkpoint_state_t;
+
+typedef struct pool_checkpoint_stat {
+	uint64_t pcs_state;		/* checkpoint_state_t */
+	uint64_t pcs_start_time;	/* time checkpoint/discard started */
+	uint64_t pcs_space;		/* checkpointed space */
+} pool_checkpoint_stat_t;
+
+/*
+ * ZIO types.  Needed to interpret vdev statistics below.
+ */
+typedef enum zio_type {
+	ZIO_TYPE_NULL = 0,
+	ZIO_TYPE_READ,
+	ZIO_TYPE_WRITE,
+	ZIO_TYPE_FREE,
+	ZIO_TYPE_CLAIM,
+	ZIO_TYPE_IOCTL,
+	ZIO_TYPE_TRIM,
+	ZIO_TYPES
+} zio_type_t;
+
+/*
+ * Pool statistics.  Note: all fields should be 64-bit because this
+ * is passed between kernel and userland as an nvlist uint64 array.
+ */
+typedef struct pool_scan_stat {
+	/* values stored on disk */
+	uint64_t	pss_func;	/* pool_scan_func_t */
+	uint64_t	pss_state;	/* dsl_scan_state_t */
+	uint64_t	pss_start_time;	/* scan start time */
+	uint64_t	pss_end_time;	/* scan end time */
+	uint64_t	pss_to_examine;	/* total bytes to scan */
+	uint64_t	pss_examined;	/* total bytes located by scanner */
+	uint64_t	pss_to_process; /* total bytes to process */
+	uint64_t	pss_processed;	/* total processed bytes */
+	uint64_t	pss_errors;	/* scan errors	*/
+
+	/* values not stored on disk */
+	uint64_t	pss_pass_exam; /* examined bytes per scan pass */
+	uint64_t	pss_pass_start;	/* start time of a scan pass */
+	uint64_t	pss_pass_scrub_pause; /* pause time of a scrub pass */
+	/* cumulative time scrub spent paused, needed for rate calculation */
+	uint64_t	pss_pass_scrub_spent_paused;
+	uint64_t	pss_pass_issued; /* issued bytes per scan pass */
+	uint64_t	pss_issued;	/* total bytes checked by scanner */
+} pool_scan_stat_t;
+
+typedef struct pool_removal_stat {
+	uint64_t prs_state; /* dsl_scan_state_t */
+	uint64_t prs_removing_vdev;
+	uint64_t prs_start_time;
+	uint64_t prs_end_time;
+	uint64_t prs_to_copy; /* bytes that need to be copied */
+	uint64_t prs_copied; /* bytes copied so far */
+	/*
+	 * bytes of memory used for indirect mappings.
+	 * This includes all removed vdevs.
+	 */
+	uint64_t prs_mapping_memory;
+} pool_removal_stat_t;
+
+typedef enum dsl_scan_state {
+	DSS_NONE,
+	DSS_SCANNING,
+	DSS_FINISHED,
+	DSS_CANCELED,
+	DSS_NUM_STATES
+} dsl_scan_state_t;
+
+typedef struct vdev_rebuild_stat {
+	uint64_t vrs_state;		/* vdev_rebuild_state_t */
+	uint64_t vrs_start_time;	/* time_t */
+	uint64_t vrs_end_time;		/* time_t */
+	uint64_t vrs_scan_time_ms;	/* total run time (millisecs) */
+	uint64_t vrs_bytes_scanned;	/* allocated bytes scanned */
+	uint64_t vrs_bytes_issued;	/* read bytes issued */
+	uint64_t vrs_bytes_rebuilt;	/* rebuilt bytes */
+	uint64_t vrs_bytes_est;		/* total bytes to scan */
+	uint64_t vrs_errors;		/* scanning errors */
+	uint64_t vrs_pass_time_ms;	/* pass run time (millisecs) */
+	uint64_t vrs_pass_bytes_scanned; /* bytes scanned since start/resume */
+	uint64_t vrs_pass_bytes_issued;	/* bytes rebuilt since start/resume */
+} vdev_rebuild_stat_t;
+
+/*
+ * Errata described by https://zfsonlinux.org/msg/ZFS-8000-ER.  The ordering
+ * of this enum must be maintained to ensure the errata identifiers map to
+ * the correct documentation.  New errata may only be appended to the list
+ * and must contain corresponding documentation at the above link.
+ */
+typedef enum zpool_errata {
+	ZPOOL_ERRATA_NONE,
+	ZPOOL_ERRATA_ZOL_2094_SCRUB,
+	ZPOOL_ERRATA_ZOL_2094_ASYNC_DESTROY,
+	ZPOOL_ERRATA_ZOL_6845_ENCRYPTION,
+	ZPOOL_ERRATA_ZOL_8308_ENCRYPTION,
+} zpool_errata_t;
+
+/*
+ * Vdev statistics.  Note: all fields should be 64-bit because this
+ * is passed between kernel and user land as an nvlist uint64 array.
+ *
+ * The vs_ops[] and vs_bytes[] arrays must always be an array size of 6 in
+ * order to keep subsequent members at their known fixed offsets.  When
+ * adding a new field it must be added to the end the structure.
+ */
+#define	VS_ZIO_TYPES	6
+
+typedef struct vdev_stat {
+	hrtime_t	vs_timestamp;		/* time since vdev load	*/
+	uint64_t	vs_state;		/* vdev state		*/
+	uint64_t	vs_aux;			/* see vdev_aux_t	*/
+	uint64_t	vs_alloc;		/* space allocated	*/
+	uint64_t	vs_space;		/* total capacity	*/
+	uint64_t	vs_dspace;		/* deflated capacity	*/
+	uint64_t	vs_rsize;		/* replaceable dev size */
+	uint64_t	vs_esize;		/* expandable dev size */
+	uint64_t	vs_ops[VS_ZIO_TYPES];	/* operation count	*/
+	uint64_t	vs_bytes[VS_ZIO_TYPES];	/* bytes read/written	*/
+	uint64_t	vs_read_errors;		/* read errors		*/
+	uint64_t	vs_write_errors;	/* write errors		*/
+	uint64_t	vs_checksum_errors;	/* checksum errors	*/
+	uint64_t	vs_initialize_errors;	/* initializing errors	*/
+	uint64_t	vs_self_healed;		/* self-healed bytes	*/
+	uint64_t	vs_scan_removing;	/* removing?	*/
+	uint64_t	vs_scan_processed;	/* scan processed bytes	*/
+	uint64_t	vs_fragmentation;	/* device fragmentation */
+	uint64_t	vs_initialize_bytes_done; /* bytes initialized */
+	uint64_t	vs_initialize_bytes_est; /* total bytes to initialize */
+	uint64_t	vs_initialize_state;	/* vdev_initializing_state_t */
+	uint64_t	vs_initialize_action_time; /* time_t */
+	uint64_t	vs_checkpoint_space;    /* checkpoint-consumed space */
+	uint64_t	vs_resilver_deferred;	/* resilver deferred	*/
+	uint64_t	vs_slow_ios;		/* slow IOs */
+	uint64_t	vs_trim_errors;		/* trimming errors	*/
+	uint64_t	vs_trim_notsup;		/* supported by device */
+	uint64_t	vs_trim_bytes_done;	/* bytes trimmed */
+	uint64_t	vs_trim_bytes_est;	/* total bytes to trim */
+	uint64_t	vs_trim_state;		/* vdev_trim_state_t */
+	uint64_t	vs_trim_action_time;	/* time_t */
+	uint64_t	vs_rebuild_processed;	/* bytes rebuilt */
+	uint64_t	vs_configured_ashift;   /* TLV vdev_ashift */
+	uint64_t	vs_logical_ashift;	/* vdev_logical_ashift  */
+	uint64_t	vs_physical_ashift;	/* vdev_physical_ashift */
+} vdev_stat_t;
+
+/* BEGIN CSTYLED */
+#define	VDEV_STAT_VALID(field, uint64_t_field_count) \
+    ((uint64_t_field_count * sizeof (uint64_t)) >=	 \
+     (offsetof(vdev_stat_t, field) + sizeof (((vdev_stat_t *)NULL)->field)))
+/* END CSTYLED */
+
+/*
+ * Extended stats
+ *
+ * These are stats which aren't included in the original iostat output.  For
+ * convenience, they are grouped together in vdev_stat_ex, although each stat
+ * is individually exported as an nvlist.
+ */
+typedef struct vdev_stat_ex {
+	/* Number of ZIOs issued to disk and waiting to finish */
+	uint64_t vsx_active_queue[ZIO_PRIORITY_NUM_QUEUEABLE];
+
+	/* Number of ZIOs pending to be issued to disk */
+	uint64_t vsx_pend_queue[ZIO_PRIORITY_NUM_QUEUEABLE];
+
+	/*
+	 * Below are the histograms for various latencies. Buckets are in
+	 * units of nanoseconds.
+	 */
+
+	/*
+	 * 2^37 nanoseconds = 134s. Timeouts will probably start kicking in
+	 * before this.
+	 */
+#define	VDEV_L_HISTO_BUCKETS 37		/* Latency histo buckets */
+#define	VDEV_RQ_HISTO_BUCKETS 25	/* Request size histo buckets */
+
+	/* Amount of time in ZIO queue (ns) */
+	uint64_t vsx_queue_histo[ZIO_PRIORITY_NUM_QUEUEABLE]
+	    [VDEV_L_HISTO_BUCKETS];
+
+	/* Total ZIO latency (ns).  Includes queuing and disk access time */
+	uint64_t vsx_total_histo[ZIO_TYPES][VDEV_L_HISTO_BUCKETS];
+
+	/* Amount of time to read/write the disk (ns) */
+	uint64_t vsx_disk_histo[ZIO_TYPES][VDEV_L_HISTO_BUCKETS];
+
+	/* "lookup the bucket for a value" histogram macros */
+#define	HISTO(val, buckets) (val != 0 ? MIN(highbit64(val) - 1, \
+	    buckets - 1) : 0)
+#define	L_HISTO(a) HISTO(a, VDEV_L_HISTO_BUCKETS)
+#define	RQ_HISTO(a) HISTO(a, VDEV_RQ_HISTO_BUCKETS)
+
+	/* Physical IO histogram */
+	uint64_t vsx_ind_histo[ZIO_PRIORITY_NUM_QUEUEABLE]
+	    [VDEV_RQ_HISTO_BUCKETS];
+
+	/* Delegated (aggregated) physical IO histogram */
+	uint64_t vsx_agg_histo[ZIO_PRIORITY_NUM_QUEUEABLE]
+	    [VDEV_RQ_HISTO_BUCKETS];
+
+} vdev_stat_ex_t;
+
+/*
+ * Initialize functions.
+ */
+typedef enum pool_initialize_func {
+	POOL_INITIALIZE_START,
+	POOL_INITIALIZE_CANCEL,
+	POOL_INITIALIZE_SUSPEND,
+	POOL_INITIALIZE_FUNCS
+} pool_initialize_func_t;
+
+/*
+ * TRIM functions.
+ */
+typedef enum pool_trim_func {
+	POOL_TRIM_START,
+	POOL_TRIM_CANCEL,
+	POOL_TRIM_SUSPEND,
+	POOL_TRIM_FUNCS
+} pool_trim_func_t;
+
+/*
+ * DDT statistics.  Note: all fields should be 64-bit because this
+ * is passed between kernel and userland as an nvlist uint64 array.
+ */
+typedef struct ddt_object {
+	uint64_t	ddo_count;	/* number of elements in ddt	*/
+	uint64_t	ddo_dspace;	/* size of ddt on disk		*/
+	uint64_t	ddo_mspace;	/* size of ddt in-core		*/
+} ddt_object_t;
+
+typedef struct ddt_stat {
+	uint64_t	dds_blocks;	/* blocks			*/
+	uint64_t	dds_lsize;	/* logical size			*/
+	uint64_t	dds_psize;	/* physical size		*/
+	uint64_t	dds_dsize;	/* deflated allocated size	*/
+	uint64_t	dds_ref_blocks;	/* referenced blocks		*/
+	uint64_t	dds_ref_lsize;	/* referenced lsize * refcnt	*/
+	uint64_t	dds_ref_psize;	/* referenced psize * refcnt	*/
+	uint64_t	dds_ref_dsize;	/* referenced dsize * refcnt	*/
+} ddt_stat_t;
+
+typedef struct ddt_histogram {
+	ddt_stat_t	ddh_stat[64];	/* power-of-two histogram buckets */
+} ddt_histogram_t;
+
+#define	ZVOL_DRIVER	"zvol"
+#define	ZFS_DRIVER	"zfs"
+#define	ZFS_DEV		"/dev/zfs"
+
+#define	ZFS_SUPER_MAGIC	0x2fc12fc1
+
+/* general zvol path */
+#define	ZVOL_DIR		"/dev/zvol/"
+
+#define	ZVOL_MAJOR		230
+#define	ZVOL_MINOR_BITS		4
+#define	ZVOL_MINOR_MASK		((1U << ZVOL_MINOR_BITS) - 1)
+#define	ZVOL_MINORS		(1 << 4)
+#define	ZVOL_DEV_NAME		"zd"
+
+#define	ZVOL_PROP_NAME		"name"
+#define	ZVOL_DEFAULT_BLOCKSIZE	8192
+
+typedef enum {
+	VDEV_INITIALIZE_NONE,
+	VDEV_INITIALIZE_ACTIVE,
+	VDEV_INITIALIZE_CANCELED,
+	VDEV_INITIALIZE_SUSPENDED,
+	VDEV_INITIALIZE_COMPLETE
+} vdev_initializing_state_t;
+
+typedef enum {
+	VDEV_TRIM_NONE,
+	VDEV_TRIM_ACTIVE,
+	VDEV_TRIM_CANCELED,
+	VDEV_TRIM_SUSPENDED,
+	VDEV_TRIM_COMPLETE,
+} vdev_trim_state_t;
+
+typedef enum {
+	VDEV_REBUILD_NONE,
+	VDEV_REBUILD_ACTIVE,
+	VDEV_REBUILD_CANCELED,
+	VDEV_REBUILD_COMPLETE,
+} vdev_rebuild_state_t;
+
+/*
+ * nvlist name constants. Facilitate restricting snapshot iteration range for
+ * the "list next snapshot" ioctl
+ */
+#define	SNAP_ITER_MIN_TXG	"snap_iter_min_txg"
+#define	SNAP_ITER_MAX_TXG	"snap_iter_max_txg"
+
+/*
+ * /dev/zfs ioctl numbers.
+ *
+ * These numbers cannot change over time. New ioctl numbers must be appended.
+ */
+typedef enum zfs_ioc {
+	/*
+	 * Core features - 81/128 numbers reserved.
+	 */
+#ifdef __FreeBSD__
+	ZFS_IOC_FIRST =	0,
+#else
+	ZFS_IOC_FIRST =	('Z' << 8),
+#endif
+	ZFS_IOC = ZFS_IOC_FIRST,
+	ZFS_IOC_POOL_CREATE = ZFS_IOC_FIRST,	/* 0x5a00 */
+	ZFS_IOC_POOL_DESTROY,			/* 0x5a01 */
+	ZFS_IOC_POOL_IMPORT,			/* 0x5a02 */
+	ZFS_IOC_POOL_EXPORT,			/* 0x5a03 */
+	ZFS_IOC_POOL_CONFIGS,			/* 0x5a04 */
+	ZFS_IOC_POOL_STATS,			/* 0x5a05 */
+	ZFS_IOC_POOL_TRYIMPORT,			/* 0x5a06 */
+	ZFS_IOC_POOL_SCAN,			/* 0x5a07 */
+	ZFS_IOC_POOL_FREEZE,			/* 0x5a08 */
+	ZFS_IOC_POOL_UPGRADE,			/* 0x5a09 */
+	ZFS_IOC_POOL_GET_HISTORY,		/* 0x5a0a */
+	ZFS_IOC_VDEV_ADD,			/* 0x5a0b */
+	ZFS_IOC_VDEV_REMOVE,			/* 0x5a0c */
+	ZFS_IOC_VDEV_SET_STATE,			/* 0x5a0d */
+	ZFS_IOC_VDEV_ATTACH,			/* 0x5a0e */
+	ZFS_IOC_VDEV_DETACH,			/* 0x5a0f */
+	ZFS_IOC_VDEV_SETPATH,			/* 0x5a10 */
+	ZFS_IOC_VDEV_SETFRU,			/* 0x5a11 */
+	ZFS_IOC_OBJSET_STATS,			/* 0x5a12 */
+	ZFS_IOC_OBJSET_ZPLPROPS,		/* 0x5a13 */
+	ZFS_IOC_DATASET_LIST_NEXT,		/* 0x5a14 */
+	ZFS_IOC_SNAPSHOT_LIST_NEXT,		/* 0x5a15 */
+	ZFS_IOC_SET_PROP,			/* 0x5a16 */
+	ZFS_IOC_CREATE,				/* 0x5a17 */
+	ZFS_IOC_DESTROY,			/* 0x5a18 */
+	ZFS_IOC_ROLLBACK,			/* 0x5a19 */
+	ZFS_IOC_RENAME,				/* 0x5a1a */
+	ZFS_IOC_RECV,				/* 0x5a1b */
+	ZFS_IOC_SEND,				/* 0x5a1c */
+	ZFS_IOC_INJECT_FAULT,			/* 0x5a1d */
+	ZFS_IOC_CLEAR_FAULT,			/* 0x5a1e */
+	ZFS_IOC_INJECT_LIST_NEXT,		/* 0x5a1f */
+	ZFS_IOC_ERROR_LOG,			/* 0x5a20 */
+	ZFS_IOC_CLEAR,				/* 0x5a21 */
+	ZFS_IOC_PROMOTE,			/* 0x5a22 */
+	ZFS_IOC_SNAPSHOT,			/* 0x5a23 */
+	ZFS_IOC_DSOBJ_TO_DSNAME,		/* 0x5a24 */
+	ZFS_IOC_OBJ_TO_PATH,			/* 0x5a25 */
+	ZFS_IOC_POOL_SET_PROPS,			/* 0x5a26 */
+	ZFS_IOC_POOL_GET_PROPS,			/* 0x5a27 */
+	ZFS_IOC_SET_FSACL,			/* 0x5a28 */
+	ZFS_IOC_GET_FSACL,			/* 0x5a29 */
+	ZFS_IOC_SHARE,				/* 0x5a2a */
+	ZFS_IOC_INHERIT_PROP,			/* 0x5a2b */
+	ZFS_IOC_SMB_ACL,			/* 0x5a2c */
+	ZFS_IOC_USERSPACE_ONE,			/* 0x5a2d */
+	ZFS_IOC_USERSPACE_MANY,			/* 0x5a2e */
+	ZFS_IOC_USERSPACE_UPGRADE,		/* 0x5a2f */
+	ZFS_IOC_HOLD,				/* 0x5a30 */
+	ZFS_IOC_RELEASE,			/* 0x5a31 */
+	ZFS_IOC_GET_HOLDS,			/* 0x5a32 */
+	ZFS_IOC_OBJSET_RECVD_PROPS,		/* 0x5a33 */
+	ZFS_IOC_VDEV_SPLIT,			/* 0x5a34 */
+	ZFS_IOC_NEXT_OBJ,			/* 0x5a35 */
+	ZFS_IOC_DIFF,				/* 0x5a36 */
+	ZFS_IOC_TMP_SNAPSHOT,			/* 0x5a37 */
+	ZFS_IOC_OBJ_TO_STATS,			/* 0x5a38 */
+	ZFS_IOC_SPACE_WRITTEN,			/* 0x5a39 */
+	ZFS_IOC_SPACE_SNAPS,			/* 0x5a3a */
+	ZFS_IOC_DESTROY_SNAPS,			/* 0x5a3b */
+	ZFS_IOC_POOL_REGUID,			/* 0x5a3c */
+	ZFS_IOC_POOL_REOPEN,			/* 0x5a3d */
+	ZFS_IOC_SEND_PROGRESS,			/* 0x5a3e */
+	ZFS_IOC_LOG_HISTORY,			/* 0x5a3f */
+	ZFS_IOC_SEND_NEW,			/* 0x5a40 */
+	ZFS_IOC_SEND_SPACE,			/* 0x5a41 */
+	ZFS_IOC_CLONE,				/* 0x5a42 */
+	ZFS_IOC_BOOKMARK,			/* 0x5a43 */
+	ZFS_IOC_GET_BOOKMARKS,			/* 0x5a44 */
+	ZFS_IOC_DESTROY_BOOKMARKS,		/* 0x5a45 */
+	ZFS_IOC_RECV_NEW,			/* 0x5a46 */
+	ZFS_IOC_POOL_SYNC,			/* 0x5a47 */
+	ZFS_IOC_CHANNEL_PROGRAM,		/* 0x5a48 */
+	ZFS_IOC_LOAD_KEY,			/* 0x5a49 */
+	ZFS_IOC_UNLOAD_KEY,			/* 0x5a4a */
+	ZFS_IOC_CHANGE_KEY,			/* 0x5a4b */
+	ZFS_IOC_REMAP,				/* 0x5a4c */
+	ZFS_IOC_POOL_CHECKPOINT,		/* 0x5a4d */
+	ZFS_IOC_POOL_DISCARD_CHECKPOINT,	/* 0x5a4e */
+	ZFS_IOC_POOL_INITIALIZE,		/* 0x5a4f */
+	ZFS_IOC_POOL_TRIM,			/* 0x5a50 */
+	ZFS_IOC_REDACT,				/* 0x5a51 */
+	ZFS_IOC_GET_BOOKMARK_PROPS,		/* 0x5a52 */
+	ZFS_IOC_WAIT,				/* 0x5a53 */
+	ZFS_IOC_WAIT_FS,			/* 0x5a54 */
+
+	/*
+	 * Per-platform (Optional) - 8/128 numbers reserved.
+	 */
+	ZFS_IOC_PLATFORM = ZFS_IOC_FIRST + 0x80,
+	ZFS_IOC_EVENTS_NEXT,			/* 0x81 (Linux) */
+	ZFS_IOC_EVENTS_CLEAR,			/* 0x82 (Linux) */
+	ZFS_IOC_EVENTS_SEEK,			/* 0x83 (Linux) */
+	ZFS_IOC_NEXTBOOT,			/* 0x84 (FreeBSD) */
+	ZFS_IOC_JAIL,				/* 0x85 (FreeBSD) */
+	ZFS_IOC_UNJAIL,				/* 0x86 (FreeBSD) */
+	ZFS_IOC_SET_BOOTENV,			/* 0x87 (Linux) */
+	ZFS_IOC_GET_BOOTENV,			/* 0x88 (Linux) */
+	ZFS_IOC_LAST
+} zfs_ioc_t;
+
+/*
+ * zvol ioctl to get dataset name
+ */
+#define	BLKZNAME		_IOR(0x12, 125, char[ZFS_MAX_DATASET_NAME_LEN])
+
+/*
+ * ZFS-specific error codes used for returning descriptive errors
+ * to the userland through zfs ioctls.
+ *
+ * The enum implicitly includes all the error codes from errno.h.
+ * New code should use and extend this enum for errors that are
+ * not described precisely by generic errno codes.
+ *
+ * These numbers should not change over time. New entries should be appended.
+ *
+ * (Keep in sync with contrib/pyzfs/libzfs_core/_constants.py)
+ */
+typedef enum {
+	ZFS_ERR_CHECKPOINT_EXISTS = 1024,
+	ZFS_ERR_DISCARDING_CHECKPOINT,
+	ZFS_ERR_NO_CHECKPOINT,
+	ZFS_ERR_DEVRM_IN_PROGRESS,
+	ZFS_ERR_VDEV_TOO_BIG,
+	ZFS_ERR_IOC_CMD_UNAVAIL,
+	ZFS_ERR_IOC_ARG_UNAVAIL,
+	ZFS_ERR_IOC_ARG_REQUIRED,
+	ZFS_ERR_IOC_ARG_BADTYPE,
+	ZFS_ERR_WRONG_PARENT,
+	ZFS_ERR_FROM_IVSET_GUID_MISSING,
+	ZFS_ERR_FROM_IVSET_GUID_MISMATCH,
+	ZFS_ERR_SPILL_BLOCK_FLAG_MISSING,
+	ZFS_ERR_UNKNOWN_SEND_STREAM_FEATURE,
+	ZFS_ERR_EXPORT_IN_PROGRESS,
+	ZFS_ERR_BOOKMARK_SOURCE_NOT_ANCESTOR,
+	ZFS_ERR_STREAM_TRUNCATED,
+	ZFS_ERR_STREAM_LARGE_BLOCK_MISMATCH,
+	ZFS_ERR_RESILVER_IN_PROGRESS,
+	ZFS_ERR_REBUILD_IN_PROGRESS,
+	ZFS_ERR_BADPROP,
+} zfs_errno_t;
+
+/*
+ * Internal SPA load state.  Used by FMA diagnosis engine.
+ */
+typedef enum {
+	SPA_LOAD_NONE,		/* no load in progress	*/
+	SPA_LOAD_OPEN,		/* normal open		*/
+	SPA_LOAD_IMPORT,	/* import in progress	*/
+	SPA_LOAD_TRYIMPORT,	/* tryimport in progress */
+	SPA_LOAD_RECOVER,	/* recovery requested	*/
+	SPA_LOAD_ERROR,		/* load failed		*/
+	SPA_LOAD_CREATE		/* creation in progress */
+} spa_load_state_t;
+
+typedef enum {
+	ZPOOL_WAIT_CKPT_DISCARD,
+	ZPOOL_WAIT_FREE,
+	ZPOOL_WAIT_INITIALIZE,
+	ZPOOL_WAIT_REPLACE,
+	ZPOOL_WAIT_REMOVE,
+	ZPOOL_WAIT_RESILVER,
+	ZPOOL_WAIT_SCRUB,
+	ZPOOL_WAIT_TRIM,
+	ZPOOL_WAIT_NUM_ACTIVITIES
+} zpool_wait_activity_t;
+
+typedef enum {
+	ZFS_WAIT_DELETEQ,
+	ZFS_WAIT_NUM_ACTIVITIES
+} zfs_wait_activity_t;
+
+/*
+ * Bookmark name values.
+ */
+#define	ZPOOL_ERR_LIST		"error list"
+#define	ZPOOL_ERR_DATASET	"dataset"
+#define	ZPOOL_ERR_OBJECT	"object"
+
+#define	HIS_MAX_RECORD_LEN	(MAXPATHLEN + MAXPATHLEN + 1)
+
+/*
+ * The following are names used in the nvlist describing
+ * the pool's history log.
+ */
+#define	ZPOOL_HIST_RECORD	"history record"
+#define	ZPOOL_HIST_TIME		"history time"
+#define	ZPOOL_HIST_CMD		"history command"
+#define	ZPOOL_HIST_WHO		"history who"
+#define	ZPOOL_HIST_ZONE		"history zone"
+#define	ZPOOL_HIST_HOST		"history hostname"
+#define	ZPOOL_HIST_TXG		"history txg"
+#define	ZPOOL_HIST_INT_EVENT	"history internal event"
+#define	ZPOOL_HIST_INT_STR	"history internal str"
+#define	ZPOOL_HIST_INT_NAME	"internal_name"
+#define	ZPOOL_HIST_IOCTL	"ioctl"
+#define	ZPOOL_HIST_INPUT_NVL	"in_nvl"
+#define	ZPOOL_HIST_OUTPUT_NVL	"out_nvl"
+#define	ZPOOL_HIST_DSNAME	"dsname"
+#define	ZPOOL_HIST_DSID		"dsid"
+#define	ZPOOL_HIST_ERRNO	"errno"
+
+/*
+ * Special nvlist name that will not have its args recorded in the pool's
+ * history log.
+ */
+#define	ZPOOL_HIDDEN_ARGS	"hidden_args"
+
+/*
+ * The following are names used when invoking ZFS_IOC_POOL_INITIALIZE.
+ */
+#define	ZPOOL_INITIALIZE_COMMAND	"initialize_command"
+#define	ZPOOL_INITIALIZE_VDEVS		"initialize_vdevs"
+
+/*
+ * The following are names used when invoking ZFS_IOC_POOL_TRIM.
+ */
+#define	ZPOOL_TRIM_COMMAND		"trim_command"
+#define	ZPOOL_TRIM_VDEVS		"trim_vdevs"
+#define	ZPOOL_TRIM_RATE			"trim_rate"
+#define	ZPOOL_TRIM_SECURE		"trim_secure"
+
+/*
+ * The following are names used when invoking ZFS_IOC_POOL_WAIT.
+ */
+#define	ZPOOL_WAIT_ACTIVITY		"wait_activity"
+#define	ZPOOL_WAIT_TAG			"wait_tag"
+#define	ZPOOL_WAIT_WAITED		"wait_waited"
+
+/*
+ * The following are names used when invoking ZFS_IOC_WAIT_FS.
+ */
+#define	ZFS_WAIT_ACTIVITY		"wait_activity"
+#define	ZFS_WAIT_WAITED			"wait_waited"
+
+/*
+ * Flags for ZFS_IOC_VDEV_SET_STATE
+ */
+#define	ZFS_ONLINE_CHECKREMOVE	0x1
+#define	ZFS_ONLINE_UNSPARE	0x2
+#define	ZFS_ONLINE_FORCEFAULT	0x4
+#define	ZFS_ONLINE_EXPAND	0x8
+#define	ZFS_OFFLINE_TEMPORARY	0x1
+
+/*
+ * Flags for ZFS_IOC_POOL_IMPORT
+ */
+#define	ZFS_IMPORT_NORMAL	0x0
+#define	ZFS_IMPORT_VERBATIM	0x1
+#define	ZFS_IMPORT_ANY_HOST	0x2
+#define	ZFS_IMPORT_MISSING_LOG	0x4
+#define	ZFS_IMPORT_ONLY		0x8
+#define	ZFS_IMPORT_TEMP_NAME	0x10
+#define	ZFS_IMPORT_SKIP_MMP	0x20
+#define	ZFS_IMPORT_LOAD_KEYS	0x40
+#define	ZFS_IMPORT_CHECKPOINT	0x80
+
+/*
+ * Channel program argument/return nvlist keys and defaults.
+ */
+#define	ZCP_ARG_PROGRAM		"program"
+#define	ZCP_ARG_ARGLIST		"arg"
+#define	ZCP_ARG_SYNC		"sync"
+#define	ZCP_ARG_INSTRLIMIT	"instrlimit"
+#define	ZCP_ARG_MEMLIMIT	"memlimit"
+
+#define	ZCP_ARG_CLIARGV		"argv"
+
+#define	ZCP_RET_ERROR		"error"
+#define	ZCP_RET_RETURN		"return"
+
+#define	ZCP_DEFAULT_INSTRLIMIT	(10 * 1000 * 1000)
+#define	ZCP_MAX_INSTRLIMIT	(10 * ZCP_DEFAULT_INSTRLIMIT)
+#define	ZCP_DEFAULT_MEMLIMIT	(10 * 1024 * 1024)
+#define	ZCP_MAX_MEMLIMIT	(10 * ZCP_DEFAULT_MEMLIMIT)
+
+/*
+ * Sysevent payload members.  ZFS will generate the following sysevents with the
+ * given payloads:
+ *
+ *	ESC_ZFS_RESILVER_START
+ *	ESC_ZFS_RESILVER_FINISH
+ *
+ *		ZFS_EV_POOL_NAME	DATA_TYPE_STRING
+ *		ZFS_EV_POOL_GUID	DATA_TYPE_UINT64
+ *		ZFS_EV_RESILVER_TYPE	DATA_TYPE_STRING
+ *
+ *	ESC_ZFS_POOL_DESTROY
+ *	ESC_ZFS_POOL_REGUID
+ *
+ *		ZFS_EV_POOL_NAME	DATA_TYPE_STRING
+ *		ZFS_EV_POOL_GUID	DATA_TYPE_UINT64
+ *
+ *	ESC_ZFS_VDEV_REMOVE
+ *	ESC_ZFS_VDEV_CLEAR
+ *	ESC_ZFS_VDEV_CHECK
+ *
+ *		ZFS_EV_POOL_NAME	DATA_TYPE_STRING
+ *		ZFS_EV_POOL_GUID	DATA_TYPE_UINT64
+ *		ZFS_EV_VDEV_PATH	DATA_TYPE_STRING	(optional)
+ *		ZFS_EV_VDEV_GUID	DATA_TYPE_UINT64
+ *
+ *	ESC_ZFS_HISTORY_EVENT
+ *
+ *		ZFS_EV_POOL_NAME	DATA_TYPE_STRING
+ *		ZFS_EV_POOL_GUID	DATA_TYPE_UINT64
+ *		ZFS_EV_HIST_TIME	DATA_TYPE_UINT64	(optional)
+ *		ZFS_EV_HIST_CMD		DATA_TYPE_STRING	(optional)
+ *		ZFS_EV_HIST_WHO		DATA_TYPE_UINT64	(optional)
+ *		ZFS_EV_HIST_ZONE	DATA_TYPE_STRING	(optional)
+ *		ZFS_EV_HIST_HOST	DATA_TYPE_STRING	(optional)
+ *		ZFS_EV_HIST_TXG		DATA_TYPE_UINT64	(optional)
+ *		ZFS_EV_HIST_INT_EVENT	DATA_TYPE_UINT64	(optional)
+ *		ZFS_EV_HIST_INT_STR	DATA_TYPE_STRING	(optional)
+ *		ZFS_EV_HIST_INT_NAME	DATA_TYPE_STRING	(optional)
+ *		ZFS_EV_HIST_IOCTL	DATA_TYPE_STRING	(optional)
+ *		ZFS_EV_HIST_DSNAME	DATA_TYPE_STRING	(optional)
+ *		ZFS_EV_HIST_DSID	DATA_TYPE_UINT64	(optional)
+ *
+ * The ZFS_EV_HIST_* members will correspond to the ZPOOL_HIST_* members in the
+ * history log nvlist.  The keynames will be free of any spaces or other
+ * characters that could be potentially unexpected to consumers of the
+ * sysevents.
+ */
+#define	ZFS_EV_POOL_NAME	"pool_name"
+#define	ZFS_EV_POOL_GUID	"pool_guid"
+#define	ZFS_EV_VDEV_PATH	"vdev_path"
+#define	ZFS_EV_VDEV_GUID	"vdev_guid"
+#define	ZFS_EV_HIST_TIME	"history_time"
+#define	ZFS_EV_HIST_CMD		"history_command"
+#define	ZFS_EV_HIST_WHO		"history_who"
+#define	ZFS_EV_HIST_ZONE	"history_zone"
+#define	ZFS_EV_HIST_HOST	"history_hostname"
+#define	ZFS_EV_HIST_TXG		"history_txg"
+#define	ZFS_EV_HIST_INT_EVENT	"history_internal_event"
+#define	ZFS_EV_HIST_INT_STR	"history_internal_str"
+#define	ZFS_EV_HIST_INT_NAME	"history_internal_name"
+#define	ZFS_EV_HIST_IOCTL	"history_ioctl"
+#define	ZFS_EV_HIST_DSNAME	"history_dsname"
+#define	ZFS_EV_HIST_DSID	"history_dsid"
+#define	ZFS_EV_RESILVER_TYPE	"resilver_type"
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_FS_ZFS_H */
diff --git a/include/sys/hkdf.h b/include/sys/hkdf.h
new file mode 100644
index 0000000000000..e0f7678c03d57
--- /dev/null
+++ b/include/sys/hkdf.h
@@ -0,0 +1,29 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2017, Datto, Inc. All rights reserved.
+ */
+
+#ifndef	_SYS_HKDF_H_
+#define	_SYS_HKDF_H_
+
+#include <sys/types.h>
+
+int hkdf_sha512(uint8_t *key_material, uint_t km_len, uint8_t *salt,
+    uint_t salt_len, uint8_t *info, uint_t info_len, uint8_t *output_key,
+    uint_t out_len);
+
+#endif	/* _SYS_HKDF_H_ */
diff --git a/include/sys/lua/Makefile.am b/include/sys/lua/Makefile.am
new file mode 100644
index 0000000000000..8b4dafaa8cf7f
--- /dev/null
+++ b/include/sys/lua/Makefile.am
@@ -0,0 +1,17 @@
+COMMON_H = \
+	lua.h \
+	luaconf.h \
+	lualib.h \
+	lauxlib.h
+
+if CONFIG_USER
+libzfsdir = $(includedir)/libzfs/sys/lua
+libzfs_HEADERS = $(COMMON_H)
+endif
+
+if CONFIG_KERNEL
+if BUILD_LINUX
+kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys/lua
+kernel_HEADERS = $(COMMON_H)
+endif
+endif
diff --git a/include/sys/lua/lauxlib.h b/include/sys/lua/lauxlib.h
new file mode 100644
index 0000000000000..503a99e9426d1
--- /dev/null
+++ b/include/sys/lua/lauxlib.h
@@ -0,0 +1,175 @@
+/* BEGIN CSTYLED */
+/*
+** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <sys/lua/lua.h>
+
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);
+#define luaL_checkversion(L)	luaL_checkversion_(L, LUA_VERSION_NUM)
+
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+                                          lua_Integer def);
+LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);
+LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,
+                                            lua_Unsigned def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+                                   const char *const lst[]);
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+                                   const char *name, const char *mode);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API int (luaL_len) (lua_State *L, int idx);
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
+
+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
+                                  const char *msg, int level);
+
+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
+                                 lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+
+#define luaL_newlibtable(L,l)	\
+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L,l)	(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,numarg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+typedef struct luaL_Buffer {
+  char *b;  /* buffer address */
+  size_t size;  /* buffer size */
+  size_t n;  /* number of characters in buffer */
+  lua_State *L;
+  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
+} luaL_Buffer;
+
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+   ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B,s)	((B)->n += (s))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+
+/* compatibility with old module system */
+#if defined(LUA_COMPAT_MODULE)
+
+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
+                                   int sizehint);
+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+
+#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
+
+#endif
+
+
+#endif
+
+/* END CSTYLED */
diff --git a/include/sys/lua/lua.h b/include/sys/lua/lua.h
new file mode 100644
index 0000000000000..0b4eb045cf8f1
--- /dev/null
+++ b/include/sys/lua/lua.h
@@ -0,0 +1,445 @@
+/* BEGIN CSTYLED */
+/*
+** $Id: lua.h,v 1.285.1.4 2015/02/21 14:04:50 roberto Exp $
+** Lua - A Scripting Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <sys/zfs_context.h>
+
+#include <sys/lua/luaconf.h>
+
+
+#define LUA_VERSION_MAJOR	"5"
+#define LUA_VERSION_MINOR	"2"
+#define LUA_VERSION_NUM		502
+#define LUA_VERSION_RELEASE	"4"
+
+#define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2015 Lua.org, PUC-Rio"
+#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+#define LUA_SIGNATURE	"\033Lua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/*
+** pseudo-indices
+*/
+#define LUA_REGISTRYINDEX	LUAI_FIRSTPSEUDOIDX
+#define lua_upvalueindex(i)	(LUA_REGISTRYINDEX - (i))
+
+
+/* thread status */
+#define LUA_OK		0
+#define LUA_YIELD	1
+#define LUA_ERRRUN	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRGCMM	5
+#define LUA_ERRERR	6
+
+
+typedef struct lua_State lua_State;
+
+typedef int (*lua_CFunction) (lua_State *L);
+
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
+
+
+/*
+** prototype for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE		(-1)
+
+#define LUA_TNIL		0
+#define LUA_TBOOLEAN		1
+#define LUA_TLIGHTUSERDATA	2
+#define LUA_TNUMBER		3
+#define LUA_TSTRING		4
+#define LUA_TTABLE		5
+#define LUA_TFUNCTION		6
+#define LUA_TUSERDATA		7
+#define LUA_TTHREAD		8
+
+#define LUA_NUMTAGS		9
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
+
+
+/* predefined values in the registry */
+#define LUA_RIDX_MAINTHREAD	1
+#define LUA_RIDX_GLOBALS	2
+#define LUA_RIDX_LAST		LUA_RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+/* unsigned integer type */
+typedef LUA_UNSIGNED lua_Unsigned;
+
+
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+/*
+** RCS ident string
+*/
+extern const char lua_ident[];
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+LUA_API const lua_Number *(lua_version) (lua_State *L);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_absindex) (lua_State *L, int idx);
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_remove) (lua_State *L, int idx);
+LUA_API void  (lua_insert) (lua_State *L, int idx);
+LUA_API void  (lua_replace) (lua_State *L, int idx);
+LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
+LUA_API int   (lua_checkstack) (lua_State *L, int sz);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Unsigned    (lua_tounsignedx) (lua_State *L, int idx, int *isnum);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** Comparison and arithmetic functions
+*/
+
+#define LUA_OPADD	0	/* ORDER TM */
+#define LUA_OPSUB	1
+#define LUA_OPMUL	2
+#define LUA_OPDIV	3
+#define LUA_OPMOD	4
+#define LUA_OPPOW	5
+#define LUA_OPUNM	6
+
+LUA_API void  (lua_arith) (lua_State *L, int op);
+
+#define LUA_OPEQ	0
+#define LUA_OPLT	1
+#define LUA_OPLE	2
+
+LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void        (lua_pushnil) (lua_State *L);
+LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API void        (lua_pushunsigned) (lua_State *L, lua_Unsigned n);
+LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l);
+LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void  (lua_getglobal) (lua_State *L, const char *var);
+LUA_API void  (lua_gettable) (lua_State *L, int idx);
+LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawget) (lua_State *L, int idx);
+LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_rawgetp) (lua_State *L, int idx, const void *p);
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_getuservalue) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_setglobal) (lua_State *L, const char *var);
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
+
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults, int ctx,
+                           lua_CFunction k);
+#define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int   (lua_getctx) (lua_State *L, int *ctx);
+
+LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
+                            int ctx, lua_CFunction k);
+#define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                                        const char *chunkname,
+                                        const char *mode);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yieldk) (lua_State *L, int nresults, int ctx,
+                           lua_CFunction k);
+#define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
+LUA_API int  (lua_resume) (lua_State *L, lua_State *from, int narg);
+LUA_API int  (lua_status) (lua_State *L);
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP		0
+#define LUA_GCRESTART		1
+#define LUA_GCCOLLECT		2
+#define LUA_GCCOUNT		3
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7
+#define LUA_GCSETMAJORINC	8
+#define LUA_GCISRUNNING		9
+#define LUA_GCGEN		10
+#define LUA_GCINC		11
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+LUA_API void  (lua_len)    (lua_State *L, int idx);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_tonumber(L,i)	lua_tonumberx(L,i,NULL)
+#define lua_tointeger(L,i)	lua_tointegerx(L,i,NULL)
+#define lua_tounsigned(L,i)	lua_tounsignedx(L,i,NULL)
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)	\
+	lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
+
+#define lua_pushglobaltable(L)  \
+	lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
+
+#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+
+
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL	0
+#define LUA_HOOKRET	1
+#define LUA_HOOKLINE	2
+#define LUA_HOOKCOUNT	3
+#define LUA_HOOKTAILCALL 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+#define LUA_MASKRET	(1 << LUA_HOOKRET)
+#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debugger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
+LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
+LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
+
+LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
+LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
+                                               int fidx2, int n2);
+
+LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook (lua_gethook) (lua_State *L);
+LUA_API int (lua_gethookmask) (lua_State *L);
+LUA_API int (lua_gethookcount) (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;	/* (n) */
+  const char *namewhat;	/* (n) 'global', 'local', 'field', 'method' */
+  const char *what;	/* (S) 'Lua', 'C', 'main', 'tail' */
+  const char *source;	/* (S) */
+  int currentline;	/* (l) */
+  int linedefined;	/* (S) */
+  int lastlinedefined;	/* (S) */
+  unsigned char nups;	/* (u) number of upvalues */
+  unsigned char nparams;/* (u) number of parameters */
+  char isvararg;        /* (u) */
+  char istailcall;	/* (t) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  struct CallInfo *i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2015 Lua.org, PUC-Rio.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif
+/* END CSTYLED */
diff --git a/include/sys/lua/luaconf.h b/include/sys/lua/luaconf.h
new file mode 100644
index 0000000000000..ce99f339fe349
--- /dev/null
+++ b/include/sys/lua/luaconf.h
@@ -0,0 +1,562 @@
+/* BEGIN CSTYLED */
+/*
+** $Id: luaconf.h,v 1.176.1.2 2013/11/21 17:26:16 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lconfig_h
+#define lconfig_h
+
+#include <sys/zfs_context.h>
+
+
+extern ssize_t lcompat_sprintf(char *, size_t size, const char *, ...);
+extern int64_t lcompat_strtoll(const char *, char **);
+extern int64_t lcompat_pow(int64_t, int64_t);
+extern int lcompat_hashnum(int64_t);
+
+/*
+** ==================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+@@ LUA_ANSI controls the use of non-ansi features.
+** CHANGE it (define it) if you want Lua to avoid the use of any
+** non-ansi feature or library.
+*/
+#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__)
+#define LUA_ANSI
+#endif
+
+
+#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
+#define LUA_WIN		/* enable goodies for regular Windows platforms */
+#endif
+
+#if defined(LUA_WIN)
+#define LUA_DL_DLL
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#endif
+
+
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+#define LUA_USE_READLINE	/* needs some extra libraries */
+#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hex formats */
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG	/* assume support for long long */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* does not need -ldl */
+#define LUA_USE_READLINE	/* needs an extra library: -lreadline */
+#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hex formats */
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG	/* assume support for long long */
+#endif
+
+
+
+/*
+@@ LUA_USE_POSIX includes all functionality listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#define LUA_USE_GMTIME_R
+#endif
+
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+@* Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+@* C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#if defined(_WIN32)	/* { */
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR	"!\\lua\\"
+#define LUA_CDIR	"!\\"
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" ".\\?.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll"
+
+#else			/* }{ */
+
+#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/"
+#define LUA_ROOT	"/usr/local/"
+#define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR
+#define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" "./?.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
+#endif			/* } */
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP	"\\"
+#else
+#define LUA_DIRSEP	"/"
+#endif
+
+
+/*
+@@ LUA_ENV is the name of the variable that holds the current
+@@ environment, used to access global names.
+** CHANGE it if you do not like this name.
+*/
+#define LUA_ENV		"_ENV"
+
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all auxiliary library functions.
+@@ LUAMOD_API is a mark for all standard library opening functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL)	/* { */
+
+#if defined(LUA_CORE) || defined(LUA_LIB)	/* { */
+#define LUA_API __declspec(dllexport)
+#else						/* }{ */
+#define LUA_API __declspec(dllimport)
+#endif						/* } */
+
+#else				/* }{ */
+
+#define LUA_API		extern
+
+#endif				/* } */
+
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API	LUA_API
+#define LUAMOD_API	LUALIB_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+@* exported to outside modules.
+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
+@* that are not to be exported to outside modules (LUAI_DDEF for
+@* definitions and LUAI_DDEC for declarations).
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library. Not all elf targets support
+** this attribute. Unfortunately, gcc does not offer a way to check
+** whether the target offers that support, and those without support
+** give a warning about it. To avoid these warnings, change to the
+** default definition.
+*/
+#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+    defined(__ELF__)		/* { */
+#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
+#define LUAI_DDEC	LUAI_FUNC
+#define LUAI_DDEF	/* empty */
+
+#else				/* }{ */
+#define LUAI_FUNC	extern
+#define LUAI_DDEC	extern
+#define LUAI_DDEF	/* empty */
+#endif				/* } */
+
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** CHANGE it if you want a different appearance.
+*/
+#define LUA_QL(x)	"'" x "'"
+#define LUA_QS		LUA_QL("%s")
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@* of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE	60
+
+
+/*
+@@ luai_writestringerror defines how to print error messages.
+** (A format string with one argument is enough for Lua...)
+*/
+#ifdef _KERNEL
+#define luai_writestringerror(s,p) \
+	(zfs_dbgmsg((s), (p)))
+#else
+#define luai_writestringerror(s,p) \
+	(fprintf(stderr, (s), (p)), fflush(stderr))
+#endif
+
+
+/*
+@@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is,
+** strings that are internalized. (Cannot be smaller than reserved words
+** or tags for metamethods, as these strings must be internalized;
+** #("function") = 8, #("__newindex") = 10.)
+*/
+#define LUAI_MAXSHORTLEN        40
+
+
+
+/*
+** {==================================================================
+** Compatibility with previous versions
+** ===================================================================
+*/
+
+/*
+@@ LUA_COMPAT_ALL controls all compatibility options.
+** You can define it to get all options, or change specific options
+** to fit your specific needs.
+*/
+#if defined(LUA_COMPAT_ALL)	/* { */
+
+/*
+@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
+** You can replace it with 'table.unpack'.
+*/
+#define LUA_COMPAT_UNPACK
+
+/*
+@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
+** You can replace it with 'package.searchers'.
+*/
+#define LUA_COMPAT_LOADERS
+
+/*
+@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
+** You can call your C function directly (with light C functions).
+*/
+#define lua_cpcall(L,f,u)  \
+	(lua_pushcfunction(L, (f)), \
+	 lua_pushlightuserdata(L,(u)), \
+	 lua_pcall(L,1,0,0))
+
+
+/*
+@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
+** You can rewrite 'log10(x)' as 'log(x, 10)'.
+*/
+#define LUA_COMPAT_LOG10
+
+/*
+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
+** library. You can rewrite 'loadstring(s)' as 'load(s)'.
+*/
+#define LUA_COMPAT_LOADSTRING
+
+/*
+@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
+*/
+#define LUA_COMPAT_MAXN
+
+/*
+@@ The following macros supply trivial compatibility for some
+** changes in the API. The macros themselves document how to
+** change your code to avoid using them.
+*/
+#define lua_strlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_objlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
+
+/*
+@@ LUA_COMPAT_MODULE controls compatibility with previous
+** module functions 'module' (Lua) and 'luaL_register' (C).
+*/
+#define LUA_COMPAT_MODULE
+
+#endif				/* } */
+
+/* }================================================================== */
+
+
+#undef INT_MAX
+#define	INT_MAX	2147483647L
+
+/*
+@@ LUAI_BITSINT defines the number of bits in an int.
+** CHANGE here if Lua cannot automatically detect the number of bits of
+** your machine. Probably you do not need to change this.
+*/
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760		/* { */
+#define LUAI_BITSINT	16
+#elif INT_MAX > 2147483640L	/* }{ */
+/* int has at least 32 bits */
+#define LUAI_BITSINT	32
+#else				/* }{ */
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif				/* } */
+
+
+/*
+@@ LUA_INT32 is a signed integer with exactly 32 bits.
+@@ LUAI_UMEM is an unsigned integer big enough to count the total
+@* memory used by Lua.
+@@ LUAI_MEM is a signed integer big enough to count the total memory
+@* used by Lua.
+** CHANGE here if for some weird reason the default definitions are not
+** good enough for your machine. Probably you do not need to change
+** this.
+*/
+#if LUAI_BITSINT >= 32		/* { */
+#define LUA_INT32	int
+#define LUAI_UMEM	size_t
+#define LUAI_MEM	ptrdiff_t
+#else				/* }{ */
+/* 16-bit ints */
+#define LUA_INT32	long
+#define LUAI_UMEM	unsigned long
+#define LUAI_MEM	long
+#endif				/* } */
+
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_MAXSTACK		1000000
+#else
+#define LUAI_MAXSTACK		15000
+#endif
+
+/* reserve some space for error handling */
+#define LUAI_FIRSTPSEUDOIDX	(-LUAI_MAXSTACK - 1000)
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+** CHANGE it if it uses too much C-stack space.
+*/
+#ifdef __linux__
+#define LUAL_BUFFERSIZE		512
+#else
+#define LUAL_BUFFERSIZE		1024
+#endif
+
+
+/*
+** {==================================================================
+@@ LUA_NUMBER is the type of numbers in Lua.
+** CHANGE the following definitions only if you want to build Lua
+** with a number type different from double. You may also need to
+** change lua_number2int & lua_number2integer.
+** ===================================================================
+*/
+
+#define LUA_NUMBER	int64_t
+
+/*
+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
+@* over a number.
+*/
+#define LUAI_UACNUMBER	int64_t
+
+
+/*
+@@ LUA_NUMBER_SCAN is the format for reading numbers.
+@@ LUA_NUMBER_FMT is the format for writing numbers.
+@@ lua_number2str converts a number to a string.
+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
+*/
+#ifndef	PRId64
+#define	PRId64	"lld"
+#endif
+
+#define LUAI_MAXNUMBER2STR	32 /* 16 digits, sign, point, and \0 */
+#define LUA_NUMBER_FMT		"%" PRId64
+#define lua_number2str(s,n)	\
+	lcompat_sprintf((s), LUAI_MAXNUMBER2STR, LUA_NUMBER_FMT, (n))
+
+
+/*
+@@ l_mathop allows the addition of an 'l' or 'f' to all math operations
+*/
+#define l_mathop(x)		(x ## l)
+
+
+/*
+@@ lua_str2number converts a decimal numeric string to a number.
+@@ lua_strx2number converts an hexadecimal numeric string to a number.
+** In C99, 'strtod' does both conversions. C89, however, has no function
+** to convert floating hexadecimal strings to numbers. For these
+** systems, you can leave 'lua_strx2number' undefined and Lua will
+** provide its own implementation.
+*/
+#define lua_str2number(s,p)	lcompat_strtoll((s), (p))
+
+#if defined(LUA_USE_STRTODHEX)
+#define lua_strx2number(s,p)	lcompat_strtoll((s), (p))
+#endif
+
+
+/*
+@@ The luai_num* macros define the primitive operations over numbers.
+*/
+
+/* the following operations need the math library */
+#if defined(lobject_c) || defined(lvm_c)
+#define luai_nummod(L,a,b)	((a) % (b))
+#define luai_numpow(L,a,b)	(lcompat_pow((a),(b)))
+#endif
+
+/* these are quite standard operations */
+#if defined(LUA_CORE)
+#define luai_numadd(L,a,b)	((a)+(b))
+#define luai_numsub(L,a,b)	((a)-(b))
+#define luai_nummul(L,a,b)	((a)*(b))
+#define luai_numdiv(L,a,b)	((a)/(b))
+#define luai_numunm(L,a)	(-(a))
+#define luai_numeq(a,b)		((a)==(b))
+#define luai_numlt(L,a,b)	((a)<(b))
+#define luai_numle(L,a,b)	((a)<=(b))
+#define luai_numisnan(L,a)	(!luai_numeq((a), (a)))
+#endif
+
+
+
+/*
+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
+** machines, ptrdiff_t gives a good choice between int or long.)
+*/
+#define LUA_INTEGER	ptrdiff_t
+
+/*
+@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned.
+** It must have at least 32 bits.
+*/
+#define LUA_UNSIGNED	uint64_t
+
+
+
+/*
+** Some tricks with doubles
+*/
+
+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI)	/* { */
+/*
+** The next definitions activate some tricks to speed up the
+** conversion from doubles to integer types, mainly to LUA_UNSIGNED.
+**
+@@ LUA_MSASMTRICK uses Microsoft assembler to avoid clashes with a
+** DirectX idiosyncrasy.
+**
+@@ LUA_IEEE754TRICK uses a trick that should work on any machine
+** using IEEE754 with a 32-bit integer type.
+**
+@@ LUA_IEEELL extends the trick to LUA_INTEGER; should only be
+** defined when LUA_INTEGER is a 32-bit integer.
+**
+@@ LUA_IEEEENDIAN is the endianness of doubles in your machine
+** (0 for little endian, 1 for big endian); if not defined, Lua will
+** check it dynamically for LUA_IEEE754TRICK (but not for LUA_NANTRICK).
+**
+@@ LUA_NANTRICK controls the use of a trick to pack all types into
+** a single double value, using NaN values to represent non-number
+** values. The trick only works on 32-bit machines (ints and pointers
+** are 32-bit values) with numbers represented as IEEE 754-2008 doubles
+** with conventional endianness (12345678 or 87654321), in CPUs that do
+** not produce signaling NaN values (all NaNs are quiet).
+*/
+
+/* Microsoft compiler on a Pentium (32 bit) ? */
+#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86)	/* { */
+
+#define LUA_MSASMTRICK
+#define LUA_IEEEENDIAN		0
+#define LUA_NANTRICK
+
+
+/* pentium 32 bits? */
+#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEELL
+#define LUA_IEEEENDIAN		0
+#define LUA_NANTRICK
+
+/* pentium 64 bits? */
+#elif defined(__x86_64)						/* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEEENDIAN		0
+
+#elif defined(__POWERPC__) || defined(__ppc__)			/* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEEENDIAN		1
+
+#else								/* }{ */
+
+/* assume IEEE754 and a 32-bit integer type */
+#define LUA_IEEE754TRICK
+
+#endif								/* } */
+
+#endif							/* } */
+
+/* }================================================================== */
+
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+#define	getlocaledecpoint() ('.')
+
+#ifndef abs
+#define abs(x) (((x) < 0) ? -(x) : (x))
+#endif
+
+#if !defined(UCHAR_MAX)
+#define	UCHAR_MAX (0xff)
+#endif
+
+#endif
+/* END CSTYLED */
diff --git a/include/sys/lua/lualib.h b/include/sys/lua/lualib.h
new file mode 100644
index 0000000000000..7b848787c8f09
--- /dev/null
+++ b/include/sys/lua/lualib.h
@@ -0,0 +1,57 @@
+/* BEGIN CSTYLED */
+/*
+** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include <sys/lua/lua.h>
+
+
+
+LUAMOD_API int (luaopen_base) (lua_State *L);
+
+#define LUA_COLIBNAME	"coroutine"
+LUAMOD_API int (luaopen_coroutine) (lua_State *L);
+
+#define LUA_TABLIBNAME	"table"
+LUAMOD_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME	"io"
+LUAMOD_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME	"os"
+LUAMOD_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME	"string"
+LUAMOD_API int (luaopen_string) (lua_State *L);
+
+#define LUA_BITLIBNAME	"bit32"
+LUAMOD_API int (luaopen_bit32) (lua_State *L);
+
+#define LUA_MATHLIBNAME	"math"
+LUAMOD_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME	"debug"
+LUAMOD_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME	"package"
+LUAMOD_API int (luaopen_package) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L);
+
+
+
+#if !defined(lua_assert)
+#define lua_assert(x)	((void)0)
+#endif
+
+
+#endif
+/* END CSTYLED */
diff --git a/include/sys/metaslab.h b/include/sys/metaslab.h
new file mode 100644
index 0000000000000..b3b7f865536ed
--- /dev/null
+++ b/include/sys/metaslab.h
@@ -0,0 +1,147 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2017, Intel Corporation.
+ */
+
+#ifndef _SYS_METASLAB_H
+#define	_SYS_METASLAB_H
+
+#include <sys/spa.h>
+#include <sys/space_map.h>
+#include <sys/txg.h>
+#include <sys/zio.h>
+#include <sys/avl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+typedef struct metaslab_ops {
+	uint64_t (*msop_alloc)(metaslab_t *, uint64_t);
+} metaslab_ops_t;
+
+
+extern metaslab_ops_t *zfs_metaslab_ops;
+
+int metaslab_init(metaslab_group_t *, uint64_t, uint64_t, uint64_t,
+    metaslab_t **);
+void metaslab_fini(metaslab_t *);
+
+void metaslab_set_unflushed_txg(metaslab_t *, uint64_t, dmu_tx_t *);
+void metaslab_set_estimated_condensed_size(metaslab_t *, uint64_t, dmu_tx_t *);
+uint64_t metaslab_unflushed_txg(metaslab_t *);
+uint64_t metaslab_estimated_condensed_size(metaslab_t *);
+int metaslab_sort_by_flushed(const void *, const void *);
+uint64_t metaslab_unflushed_changes_memused(metaslab_t *);
+
+int metaslab_load(metaslab_t *);
+void metaslab_unload(metaslab_t *);
+boolean_t metaslab_flush(metaslab_t *, dmu_tx_t *);
+
+uint64_t metaslab_allocated_space(metaslab_t *);
+
+void metaslab_sync(metaslab_t *, uint64_t);
+void metaslab_sync_done(metaslab_t *, uint64_t);
+void metaslab_sync_reassess(metaslab_group_t *);
+uint64_t metaslab_largest_allocatable(metaslab_t *);
+
+/*
+ * metaslab alloc flags
+ */
+#define	METASLAB_HINTBP_FAVOR		0x0
+#define	METASLAB_HINTBP_AVOID		0x1
+#define	METASLAB_GANG_HEADER		0x2
+#define	METASLAB_GANG_CHILD		0x4
+#define	METASLAB_ASYNC_ALLOC		0x8
+#define	METASLAB_DONT_THROTTLE		0x10
+#define	METASLAB_MUST_RESERVE		0x20
+#define	METASLAB_FASTWRITE		0x40
+
+int metaslab_alloc(spa_t *, metaslab_class_t *, uint64_t,
+    blkptr_t *, int, uint64_t, blkptr_t *, int, zio_alloc_list_t *, zio_t *,
+	int);
+int metaslab_alloc_dva(spa_t *, metaslab_class_t *, uint64_t,
+    dva_t *, int, dva_t *, uint64_t, int, zio_alloc_list_t *, int);
+void metaslab_free(spa_t *, const blkptr_t *, uint64_t, boolean_t);
+void metaslab_free_concrete(vdev_t *, uint64_t, uint64_t, boolean_t);
+void metaslab_free_dva(spa_t *, const dva_t *, boolean_t);
+void metaslab_free_impl_cb(uint64_t, vdev_t *, uint64_t, uint64_t, void *);
+void metaslab_unalloc_dva(spa_t *, const dva_t *, uint64_t);
+int metaslab_claim(spa_t *, const blkptr_t *, uint64_t);
+int metaslab_claim_impl(vdev_t *, uint64_t, uint64_t, uint64_t);
+void metaslab_check_free(spa_t *, const blkptr_t *);
+void metaslab_fastwrite_mark(spa_t *, const blkptr_t *);
+void metaslab_fastwrite_unmark(spa_t *, const blkptr_t *);
+
+void metaslab_stat_init(void);
+void metaslab_stat_fini(void);
+void metaslab_trace_init(zio_alloc_list_t *);
+void metaslab_trace_fini(zio_alloc_list_t *);
+
+metaslab_class_t *metaslab_class_create(spa_t *, metaslab_ops_t *);
+void metaslab_class_destroy(metaslab_class_t *);
+int metaslab_class_validate(metaslab_class_t *);
+void metaslab_class_histogram_verify(metaslab_class_t *);
+uint64_t metaslab_class_fragmentation(metaslab_class_t *);
+uint64_t metaslab_class_expandable_space(metaslab_class_t *);
+boolean_t metaslab_class_throttle_reserve(metaslab_class_t *, int, int,
+    zio_t *, int);
+void metaslab_class_throttle_unreserve(metaslab_class_t *, int, int, zio_t *);
+void metaslab_class_evict_old(metaslab_class_t *, uint64_t);
+uint64_t metaslab_class_get_alloc(metaslab_class_t *);
+uint64_t metaslab_class_get_space(metaslab_class_t *);
+uint64_t metaslab_class_get_dspace(metaslab_class_t *);
+uint64_t metaslab_class_get_deferred(metaslab_class_t *);
+
+void metaslab_space_update(vdev_t *, metaslab_class_t *,
+    int64_t, int64_t, int64_t);
+
+metaslab_group_t *metaslab_group_create(metaslab_class_t *, vdev_t *, int);
+void metaslab_group_destroy(metaslab_group_t *);
+void metaslab_group_activate(metaslab_group_t *);
+void metaslab_group_passivate(metaslab_group_t *);
+boolean_t metaslab_group_initialized(metaslab_group_t *);
+uint64_t metaslab_group_get_space(metaslab_group_t *);
+void metaslab_group_histogram_verify(metaslab_group_t *);
+uint64_t metaslab_group_fragmentation(metaslab_group_t *);
+void metaslab_group_histogram_remove(metaslab_group_t *, metaslab_t *);
+void metaslab_group_alloc_decrement(spa_t *, uint64_t, void *, int, int,
+    boolean_t);
+void metaslab_group_alloc_verify(spa_t *, const blkptr_t *, void *, int);
+void metaslab_recalculate_weight_and_sort(metaslab_t *);
+void metaslab_disable(metaslab_t *);
+void metaslab_enable(metaslab_t *, boolean_t, boolean_t);
+void metaslab_set_selected_txg(metaslab_t *, uint64_t);
+
+extern int metaslab_debug_load;
+
+range_seg_type_t metaslab_calculate_range_tree_type(vdev_t *vdev,
+    metaslab_t *msp, uint64_t *start, uint64_t *shift);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_METASLAB_H */
diff --git a/include/sys/metaslab_impl.h b/include/sys/metaslab_impl.h
new file mode 100644
index 0000000000000..4a7475256a2bb
--- /dev/null
+++ b/include/sys/metaslab_impl.h
@@ -0,0 +1,562 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2011, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_METASLAB_IMPL_H
+#define	_SYS_METASLAB_IMPL_H
+
+#include <sys/metaslab.h>
+#include <sys/space_map.h>
+#include <sys/range_tree.h>
+#include <sys/vdev.h>
+#include <sys/txg.h>
+#include <sys/avl.h>
+#include <sys/multilist.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Metaslab allocation tracing record.
+ */
+typedef struct metaslab_alloc_trace {
+	list_node_t			mat_list_node;
+	metaslab_group_t		*mat_mg;
+	metaslab_t			*mat_msp;
+	uint64_t			mat_size;
+	uint64_t			mat_weight;
+	uint32_t			mat_dva_id;
+	uint64_t			mat_offset;
+	int					mat_allocator;
+} metaslab_alloc_trace_t;
+
+/*
+ * Used by the metaslab allocation tracing facility to indicate
+ * error conditions. These errors are stored to the offset member
+ * of the metaslab_alloc_trace_t record and displayed by mdb.
+ */
+typedef enum trace_alloc_type {
+	TRACE_ALLOC_FAILURE	= -1ULL,
+	TRACE_TOO_SMALL		= -2ULL,
+	TRACE_FORCE_GANG	= -3ULL,
+	TRACE_NOT_ALLOCATABLE	= -4ULL,
+	TRACE_GROUP_FAILURE	= -5ULL,
+	TRACE_ENOSPC		= -6ULL,
+	TRACE_CONDENSING	= -7ULL,
+	TRACE_VDEV_ERROR	= -8ULL,
+	TRACE_DISABLED		= -9ULL,
+} trace_alloc_type_t;
+
+#define	METASLAB_WEIGHT_PRIMARY		(1ULL << 63)
+#define	METASLAB_WEIGHT_SECONDARY	(1ULL << 62)
+#define	METASLAB_WEIGHT_CLAIM		(1ULL << 61)
+#define	METASLAB_WEIGHT_TYPE		(1ULL << 60)
+#define	METASLAB_ACTIVE_MASK		\
+	(METASLAB_WEIGHT_PRIMARY | METASLAB_WEIGHT_SECONDARY | \
+	METASLAB_WEIGHT_CLAIM)
+
+/*
+ * The metaslab weight is used to encode the amount of free space in a
+ * metaslab, such that the "best" metaslab appears first when sorting the
+ * metaslabs by weight. The weight (and therefore the "best" metaslab) can
+ * be determined in two different ways: by computing a weighted sum of all
+ * the free space in the metaslab (a space based weight) or by counting only
+ * the free segments of the largest size (a segment based weight). We prefer
+ * the segment based weight because it reflects how the free space is
+ * comprised, but we cannot always use it -- legacy pools do not have the
+ * space map histogram information necessary to determine the largest
+ * contiguous regions. Pools that have the space map histogram determine
+ * the segment weight by looking at each bucket in the histogram and
+ * determining the free space whose size in bytes is in the range:
+ *	[2^i, 2^(i+1))
+ * We then encode the largest index, i, that contains regions into the
+ * segment-weighted value.
+ *
+ * Space-based weight:
+ *
+ *      64      56      48      40      32      24      16      8       0
+ *      +-------+-------+-------+-------+-------+-------+-------+-------+
+ *      |PSC1|                  weighted-free space                     |
+ *      +-------+-------+-------+-------+-------+-------+-------+-------+
+ *
+ *	PS - indicates primary and secondary activation
+ *	C - indicates activation for claimed block zio
+ *	space - the fragmentation-weighted space
+ *
+ * Segment-based weight:
+ *
+ *      64      56      48      40      32      24      16      8       0
+ *      +-------+-------+-------+-------+-------+-------+-------+-------+
+ *      |PSC0| idx|            count of segments in region              |
+ *      +-------+-------+-------+-------+-------+-------+-------+-------+
+ *
+ *	PS - indicates primary and secondary activation
+ *	C - indicates activation for claimed block zio
+ *	idx - index for the highest bucket in the histogram
+ *	count - number of segments in the specified bucket
+ */
+#define	WEIGHT_GET_ACTIVE(weight)		BF64_GET((weight), 61, 3)
+#define	WEIGHT_SET_ACTIVE(weight, x)		BF64_SET((weight), 61, 3, x)
+
+#define	WEIGHT_IS_SPACEBASED(weight)		\
+	((weight) == 0 || BF64_GET((weight), 60, 1))
+#define	WEIGHT_SET_SPACEBASED(weight)		BF64_SET((weight), 60, 1, 1)
+
+/*
+ * These macros are only applicable to segment-based weighting.
+ */
+#define	WEIGHT_GET_INDEX(weight)		BF64_GET((weight), 54, 6)
+#define	WEIGHT_SET_INDEX(weight, x)		BF64_SET((weight), 54, 6, x)
+#define	WEIGHT_GET_COUNT(weight)		BF64_GET((weight), 0, 54)
+#define	WEIGHT_SET_COUNT(weight, x)		BF64_SET((weight), 0, 54, x)
+
+/*
+ * A metaslab class encompasses a category of allocatable top-level vdevs.
+ * Each top-level vdev is associated with a metaslab group which defines
+ * the allocatable region for that vdev. Examples of these categories include
+ * "normal" for data block allocations (i.e. main pool allocations) or "log"
+ * for allocations designated for intent log devices (i.e. slog devices).
+ * When a block allocation is requested from the SPA it is associated with a
+ * metaslab_class_t, and only top-level vdevs (i.e. metaslab groups) belonging
+ * to the class can be used to satisfy that request. Allocations are done
+ * by traversing the metaslab groups that are linked off of the mc_rotor field.
+ * This rotor points to the next metaslab group where allocations will be
+ * attempted. Allocating a block is a 3 step process -- select the metaslab
+ * group, select the metaslab, and then allocate the block. The metaslab
+ * class defines the low-level block allocator that will be used as the
+ * final step in allocation. These allocators are pluggable allowing each class
+ * to use a block allocator that best suits that class.
+ */
+struct metaslab_class {
+	kmutex_t		mc_lock;
+	spa_t			*mc_spa;
+	metaslab_group_t	*mc_rotor;
+	metaslab_ops_t		*mc_ops;
+	uint64_t		mc_aliquot;
+
+	/*
+	 * Track the number of metaslab groups that have been initialized
+	 * and can accept allocations. An initialized metaslab group is
+	 * one has been completely added to the config (i.e. we have
+	 * updated the MOS config and the space has been added to the pool).
+	 */
+	uint64_t		mc_groups;
+
+	/*
+	 * Toggle to enable/disable the allocation throttle.
+	 */
+	boolean_t		mc_alloc_throttle_enabled;
+
+	/*
+	 * The allocation throttle works on a reservation system. Whenever
+	 * an asynchronous zio wants to perform an allocation it must
+	 * first reserve the number of blocks that it wants to allocate.
+	 * If there aren't sufficient slots available for the pending zio
+	 * then that I/O is throttled until more slots free up. The current
+	 * number of reserved allocations is maintained by the mc_alloc_slots
+	 * refcount. The mc_alloc_max_slots value determines the maximum
+	 * number of allocations that the system allows. Gang blocks are
+	 * allowed to reserve slots even if we've reached the maximum
+	 * number of allocations allowed.
+	 */
+	uint64_t		*mc_alloc_max_slots;
+	zfs_refcount_t		*mc_alloc_slots;
+
+	uint64_t		mc_alloc_groups; /* # of allocatable groups */
+
+	uint64_t		mc_alloc;	/* total allocated space */
+	uint64_t		mc_deferred;	/* total deferred frees */
+	uint64_t		mc_space;	/* total space (alloc + free) */
+	uint64_t		mc_dspace;	/* total deflated space */
+	uint64_t		mc_histogram[RANGE_TREE_HISTOGRAM_SIZE];
+
+	/*
+	 * List of all loaded metaslabs in the class, sorted in order of most
+	 * recent use.
+	 */
+	multilist_t		*mc_metaslab_txg_list;
+};
+
+/*
+ * Per-allocator data structure.
+ */
+typedef struct metaslab_group_allocator {
+	uint64_t	mga_cur_max_alloc_queue_depth;
+	zfs_refcount_t	mga_alloc_queue_depth;
+	metaslab_t	*mga_primary;
+	metaslab_t	*mga_secondary;
+} metaslab_group_allocator_t;
+
+/*
+ * Metaslab groups encapsulate all the allocatable regions (i.e. metaslabs)
+ * of a top-level vdev. They are linked together to form a circular linked
+ * list and can belong to only one metaslab class. Metaslab groups may become
+ * ineligible for allocations for a number of reasons such as limited free
+ * space, fragmentation, or going offline. When this happens the allocator will
+ * simply find the next metaslab group in the linked list and attempt
+ * to allocate from that group instead.
+ */
+struct metaslab_group {
+	kmutex_t		mg_lock;
+	avl_tree_t		mg_metaslab_tree;
+	uint64_t		mg_aliquot;
+	boolean_t		mg_allocatable;		/* can we allocate? */
+	uint64_t		mg_ms_ready;
+
+	/*
+	 * A metaslab group is considered to be initialized only after
+	 * we have updated the MOS config and added the space to the pool.
+	 * We only allow allocation attempts to a metaslab group if it
+	 * has been initialized.
+	 */
+	boolean_t		mg_initialized;
+
+	uint64_t		mg_free_capacity;	/* percentage free */
+	int64_t			mg_bias;
+	int64_t			mg_activation_count;
+	metaslab_class_t	*mg_class;
+	vdev_t			*mg_vd;
+	taskq_t			*mg_taskq;
+	metaslab_group_t	*mg_prev;
+	metaslab_group_t	*mg_next;
+
+	/*
+	 * In order for the allocation throttle to function properly, we cannot
+	 * have too many IOs going to each disk by default; the throttle
+	 * operates by allocating more work to disks that finish quickly, so
+	 * allocating larger chunks to each disk reduces its effectiveness.
+	 * However, if the number of IOs going to each allocator is too small,
+	 * we will not perform proper aggregation at the vdev_queue layer,
+	 * also resulting in decreased performance. Therefore, we will use a
+	 * ramp-up strategy.
+	 *
+	 * Each allocator in each metaslab group has a current queue depth
+	 * (mg_alloc_queue_depth[allocator]) and a current max queue depth
+	 * (mg_cur_max_alloc_queue_depth[allocator]), and each metaslab group
+	 * has an absolute max queue depth (mg_max_alloc_queue_depth).  We
+	 * add IOs to an allocator until the mg_alloc_queue_depth for that
+	 * allocator hits the cur_max. Every time an IO completes for a given
+	 * allocator on a given metaslab group, we increment its cur_max until
+	 * it reaches mg_max_alloc_queue_depth. The cur_max resets every txg to
+	 * help protect against disks that decrease in performance over time.
+	 *
+	 * It's possible for an allocator to handle more allocations than
+	 * its max. This can occur when gang blocks are required or when other
+	 * groups are unable to handle their share of allocations.
+	 */
+	uint64_t		mg_max_alloc_queue_depth;
+	int			mg_allocators;
+	metaslab_group_allocator_t *mg_allocator; /* array */
+	/*
+	 * A metalab group that can no longer allocate the minimum block
+	 * size will set mg_no_free_space. Once a metaslab group is out
+	 * of space then its share of work must be distributed to other
+	 * groups.
+	 */
+	boolean_t		mg_no_free_space;
+
+	uint64_t		mg_allocations;
+	uint64_t		mg_failed_allocations;
+	uint64_t		mg_fragmentation;
+	uint64_t		mg_histogram[RANGE_TREE_HISTOGRAM_SIZE];
+
+	int			mg_ms_disabled;
+	boolean_t		mg_disabled_updating;
+	kmutex_t		mg_ms_disabled_lock;
+	kcondvar_t		mg_ms_disabled_cv;
+};
+
+/*
+ * This value defines the number of elements in the ms_lbas array. The value
+ * of 64 was chosen as it covers all power of 2 buckets up to UINT64_MAX.
+ * This is the equivalent of highbit(UINT64_MAX).
+ */
+#define	MAX_LBAS	64
+
+/*
+ * Each metaslab maintains a set of in-core trees to track metaslab
+ * operations.  The in-core free tree (ms_allocatable) contains the list of
+ * free segments which are eligible for allocation.  As blocks are
+ * allocated, the allocated segment are removed from the ms_allocatable and
+ * added to a per txg allocation tree (ms_allocating).  As blocks are
+ * freed, they are added to the free tree (ms_freeing).  These trees
+ * allow us to process all allocations and frees in syncing context
+ * where it is safe to update the on-disk space maps.  An additional set
+ * of in-core trees is maintained to track deferred frees
+ * (ms_defer).  Once a block is freed it will move from the
+ * ms_freed to the ms_defer tree.  A deferred free means that a block
+ * has been freed but cannot be used by the pool until TXG_DEFER_SIZE
+ * transactions groups later.  For example, a block that is freed in txg
+ * 50 will not be available for reallocation until txg 52 (50 +
+ * TXG_DEFER_SIZE).  This provides a safety net for uberblock rollback.
+ * A pool could be safely rolled back TXG_DEFERS_SIZE transactions
+ * groups and ensure that no block has been reallocated.
+ *
+ * The simplified transition diagram looks like this:
+ *
+ *
+ *      ALLOCATE
+ *         |
+ *         V
+ *    free segment (ms_allocatable) -> ms_allocating[4] -> (write to space map)
+ *         ^
+ *         |                        ms_freeing <--- FREE
+ *         |                             |
+ *         |                             v
+ *         |                         ms_freed
+ *         |                             |
+ *         +-------- ms_defer[2] <-------+-------> (write to space map)
+ *
+ *
+ * Each metaslab's space is tracked in a single space map in the MOS,
+ * which is only updated in syncing context.  Each time we sync a txg,
+ * we append the allocs and frees from that txg to the space map.  The
+ * pool space is only updated once all metaslabs have finished syncing.
+ *
+ * To load the in-core free tree we read the space map from disk.  This
+ * object contains a series of alloc and free records that are combined
+ * to make up the list of all free segments in this metaslab.  These
+ * segments are represented in-core by the ms_allocatable and are stored
+ * in an AVL tree.
+ *
+ * As the space map grows (as a result of the appends) it will
+ * eventually become space-inefficient.  When the metaslab's in-core
+ * free tree is zfs_condense_pct/100 times the size of the minimal
+ * on-disk representation, we rewrite it in its minimized form.  If a
+ * metaslab needs to condense then we must set the ms_condensing flag to
+ * ensure that allocations are not performed on the metaslab that is
+ * being written.
+ */
+struct metaslab {
+	/*
+	 * This is the main lock of the metaslab and its purpose is to
+	 * coordinate our allocations and frees [e.g metaslab_block_alloc(),
+	 * metaslab_free_concrete(), ..etc] with our various syncing
+	 * procedures [e.g. metaslab_sync(), metaslab_sync_done(), ..etc].
+	 *
+	 * The lock is also used during some miscellaneous operations like
+	 * using the metaslab's histogram for the metaslab group's histogram
+	 * aggregation, or marking the metaslab for initialization.
+	 */
+	kmutex_t	ms_lock;
+
+	/*
+	 * Acquired together with the ms_lock whenever we expect to
+	 * write to metaslab data on-disk (i.e flushing entries to
+	 * the metaslab's space map). It helps coordinate readers of
+	 * the metaslab's space map [see spa_vdev_remove_thread()]
+	 * with writers [see metaslab_sync() or metaslab_flush()].
+	 *
+	 * Note that metaslab_load(), even though a reader, uses
+	 * a completely different mechanism to deal with the reading
+	 * of the metaslab's space map based on ms_synced_length. That
+	 * said, the function still uses the ms_sync_lock after it
+	 * has read the ms_sm [see relevant comment in metaslab_load()
+	 * as to why].
+	 */
+	kmutex_t	ms_sync_lock;
+
+	kcondvar_t	ms_load_cv;
+	space_map_t	*ms_sm;
+	uint64_t	ms_id;
+	uint64_t	ms_start;
+	uint64_t	ms_size;
+	uint64_t	ms_fragmentation;
+
+	range_tree_t	*ms_allocating[TXG_SIZE];
+	range_tree_t	*ms_allocatable;
+	uint64_t	ms_allocated_this_txg;
+	uint64_t	ms_allocating_total;
+
+	/*
+	 * The following range trees are accessed only from syncing context.
+	 * ms_free*tree only have entries while syncing, and are empty
+	 * between syncs.
+	 */
+	range_tree_t	*ms_freeing;	/* to free this syncing txg */
+	range_tree_t	*ms_freed;	/* already freed this syncing txg */
+	range_tree_t	*ms_defer[TXG_DEFER_SIZE];
+	range_tree_t	*ms_checkpointing; /* to add to the checkpoint */
+
+	/*
+	 * The ms_trim tree is the set of allocatable segments which are
+	 * eligible for trimming. (When the metaslab is loaded, it's a
+	 * subset of ms_allocatable.)  It's kept in-core as long as the
+	 * autotrim property is set and is not vacated when the metaslab
+	 * is unloaded.  Its purpose is to aggregate freed ranges to
+	 * facilitate efficient trimming.
+	 */
+	range_tree_t	*ms_trim;
+
+	boolean_t	ms_condensing;	/* condensing? */
+	boolean_t	ms_condense_wanted;
+
+	/*
+	 * The number of consumers which have disabled the metaslab.
+	 */
+	uint64_t	ms_disabled;
+
+	/*
+	 * We must always hold the ms_lock when modifying ms_loaded
+	 * and ms_loading.
+	 */
+	boolean_t	ms_loaded;
+	boolean_t	ms_loading;
+	kcondvar_t	ms_flush_cv;
+	boolean_t	ms_flushing;
+
+	/*
+	 * The following histograms count entries that are in the
+	 * metaslab's space map (and its histogram) but are not in
+	 * ms_allocatable yet, because they are in ms_freed, ms_freeing,
+	 * or ms_defer[].
+	 *
+	 * When the metaslab is not loaded, its ms_weight needs to
+	 * reflect what is allocatable (i.e. what will be part of
+	 * ms_allocatable if it is loaded).  The weight is computed from
+	 * the spacemap histogram, but that includes ranges that are
+	 * not yet allocatable (because they are in ms_freed,
+	 * ms_freeing, or ms_defer[]).  Therefore, when calculating the
+	 * weight, we need to remove those ranges.
+	 *
+	 * The ranges in the ms_freed and ms_defer[] range trees are all
+	 * present in the spacemap.  However, the spacemap may have
+	 * multiple entries to represent a contiguous range, because it
+	 * is written across multiple sync passes, but the changes of
+	 * all sync passes are consolidated into the range trees.
+	 * Adjacent ranges that are freed in different sync passes of
+	 * one txg will be represented separately (as 2 or more entries)
+	 * in the space map (and its histogram), but these adjacent
+	 * ranges will be consolidated (represented as one entry) in the
+	 * ms_freed/ms_defer[] range trees (and their histograms).
+	 *
+	 * When calculating the weight, we can not simply subtract the
+	 * range trees' histograms from the spacemap's histogram,
+	 * because the range trees' histograms may have entries in
+	 * higher buckets than the spacemap, due to consolidation.
+	 * Instead we must subtract the exact entries that were added to
+	 * the spacemap's histogram.  ms_synchist and ms_deferhist[]
+	 * represent these exact entries, so we can subtract them from
+	 * the spacemap's histogram when calculating ms_weight.
+	 *
+	 * ms_synchist represents the same ranges as ms_freeing +
+	 * ms_freed, but without consolidation across sync passes.
+	 *
+	 * ms_deferhist[i] represents the same ranges as ms_defer[i],
+	 * but without consolidation across sync passes.
+	 */
+	uint64_t	ms_synchist[SPACE_MAP_HISTOGRAM_SIZE];
+	uint64_t	ms_deferhist[TXG_DEFER_SIZE][SPACE_MAP_HISTOGRAM_SIZE];
+
+	/*
+	 * Tracks the exact amount of allocated space of this metaslab
+	 * (and specifically the metaslab's space map) up to the most
+	 * recently completed sync pass [see usage in metaslab_sync()].
+	 */
+	uint64_t	ms_allocated_space;
+	int64_t		ms_deferspace;	/* sum of ms_defermap[] space	*/
+	uint64_t	ms_weight;	/* weight vs. others in group	*/
+	uint64_t	ms_activation_weight;	/* activation weight	*/
+
+	/*
+	 * Track of whenever a metaslab is selected for loading or allocation.
+	 * We use this value to determine how long the metaslab should
+	 * stay cached.
+	 */
+	uint64_t	ms_selected_txg;
+	/*
+	 * ms_load/unload_time can be used for performance monitoring
+	 * (e.g. by dtrace or mdb).
+	 */
+	hrtime_t	ms_load_time;	/* time last loaded */
+	hrtime_t	ms_unload_time;	/* time last unloaded */
+	hrtime_t	ms_selected_time; /* time last allocated from */
+
+	uint64_t	ms_alloc_txg;	/* last successful alloc (debug only) */
+	uint64_t	ms_max_size;	/* maximum allocatable size	*/
+
+	/*
+	 * -1 if it's not active in an allocator, otherwise set to the allocator
+	 * this metaslab is active for.
+	 */
+	int		ms_allocator;
+	boolean_t	ms_primary; /* Only valid if ms_allocator is not -1 */
+
+	/*
+	 * The metaslab block allocators can optionally use a size-ordered
+	 * range tree and/or an array of LBAs. Not all allocators use
+	 * this functionality. The ms_allocatable_by_size should always
+	 * contain the same number of segments as the ms_allocatable. The
+	 * only difference is that the ms_allocatable_by_size is ordered by
+	 * segment sizes.
+	 */
+	zfs_btree_t		ms_allocatable_by_size;
+	zfs_btree_t		ms_unflushed_frees_by_size;
+	uint64_t	ms_lbas[MAX_LBAS];
+
+	metaslab_group_t *ms_group;	/* metaslab group		*/
+	avl_node_t	ms_group_node;	/* node in metaslab group tree	*/
+	txg_node_t	ms_txg_node;	/* per-txg dirty metaslab links	*/
+	avl_node_t	ms_spa_txg_node; /* node in spa_metaslabs_by_txg */
+	/*
+	 * Node in metaslab class's selected txg list
+	 */
+	multilist_node_t	ms_class_txg_node;
+
+	/*
+	 * Allocs and frees that are committed to the vdev log spacemap but
+	 * not yet to this metaslab's spacemap.
+	 */
+	range_tree_t	*ms_unflushed_allocs;
+	range_tree_t	*ms_unflushed_frees;
+
+	/*
+	 * We have flushed entries up to but not including this TXG. In
+	 * other words, all changes from this TXG and onward should not
+	 * be in this metaslab's space map and must be read from the
+	 * log space maps.
+	 */
+	uint64_t	ms_unflushed_txg;
+
+	/* updated every time we are done syncing the metaslab's space map */
+	uint64_t	ms_synced_length;
+
+	boolean_t	ms_new;
+};
+
+typedef struct metaslab_unflushed_phys {
+	/* on-disk counterpart of ms_unflushed_txg */
+	uint64_t	msp_unflushed_txg;
+} metaslab_unflushed_phys_t;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_METASLAB_IMPL_H */
diff --git a/include/sys/mmp.h b/include/sys/mmp.h
new file mode 100644
index 0000000000000..ce9c4496a04ff
--- /dev/null
+++ b/include/sys/mmp.h
@@ -0,0 +1,75 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (C) 2017 by Lawrence Livermore National Security, LLC.
+ */
+
+#ifndef _SYS_MMP_H
+#define	_SYS_MMP_H
+
+#include <sys/spa.h>
+#include <sys/zfs_context.h>
+#include <sys/uberblock_impl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	MMP_MIN_INTERVAL		100	/* ms */
+#define	MMP_DEFAULT_INTERVAL		1000	/* ms */
+#define	MMP_DEFAULT_IMPORT_INTERVALS	20
+#define	MMP_DEFAULT_FAIL_INTERVALS	10
+#define	MMP_MIN_FAIL_INTERVALS		2	/* min if != 0 */
+#define	MMP_IMPORT_SAFETY_FACTOR	200	/* pct */
+#define	MMP_INTERVAL_OK(interval)	MAX(interval, MMP_MIN_INTERVAL)
+#define	MMP_FAIL_INTVS_OK(fails)	(fails == 0 ? 0 : MAX(fails, \
+					    MMP_MIN_FAIL_INTERVALS))
+
+typedef struct mmp_thread {
+	kmutex_t	mmp_thread_lock; /* protect thread mgmt fields */
+	kcondvar_t	mmp_thread_cv;
+	kthread_t	*mmp_thread;
+	uint8_t		mmp_thread_exiting;
+	kmutex_t	mmp_io_lock;	/* protect below */
+	hrtime_t	mmp_last_write;	/* last successful MMP write */
+	uint64_t	mmp_delay;	/* decaying avg ns between MMP writes */
+	uberblock_t	mmp_ub;		/* last ub written by sync */
+	zio_t		*mmp_zio_root;	/* root of mmp write zios */
+	uint64_t	mmp_kstat_id;	/* unique id for next MMP write kstat */
+	int		mmp_skip_error; /* reason for last skipped write */
+	vdev_t		*mmp_last_leaf;	/* last mmp write sent here */
+	uint64_t	mmp_leaf_last_gen;	/* last mmp write sent here */
+	uint32_t	mmp_seq;	/* intra-second update counter */
+} mmp_thread_t;
+
+
+extern void mmp_init(struct spa *spa);
+extern void mmp_fini(struct spa *spa);
+extern void mmp_thread_start(struct spa *spa);
+extern void mmp_thread_stop(struct spa *spa);
+extern void mmp_update_uberblock(struct spa *spa, struct uberblock *ub);
+extern void mmp_signal_all_threads(void);
+
+/* Global tuning */
+extern int param_set_multihost_interval(ZFS_MODULE_PARAM_ARGS);
+extern ulong_t zfs_multihost_interval;
+extern uint_t zfs_multihost_fail_intervals;
+extern uint_t zfs_multihost_import_intervals;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_MMP_H */
diff --git a/include/sys/mntent.h b/include/sys/mntent.h
new file mode 100644
index 0000000000000..8d578f67b8a7b
--- /dev/null
+++ b/include/sys/mntent.h
@@ -0,0 +1,112 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ *
+ *	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T
+ *		All Rights Reserved
+ */
+
+#ifndef _SYS_MNTENT_H
+#define	_SYS_MNTENT_H
+
+#define	MNTMAXSTR	128
+
+#define	MNTTYPE_ZFS	"zfs"		/* ZFS file system */
+
+#define	MOUNT_SUCCESS	0x00		/* Success */
+#define	MOUNT_USAGE	0x01		/* Invalid invocation or permissions */
+#define	MOUNT_SYSERR	0x02		/* System error (ENOMEM, etc) */
+#define	MOUNT_SOFTWARE	0x04		/* Internal mount bug */
+#define	MOUNT_USER	0x08		/* Interrupted by user (EINTR) */
+#define	MOUNT_FILEIO	0x10		/* Error updating/locking /etc/mtab */
+#define	MOUNT_FAIL	0x20		/* Mount failed */
+#define	MOUNT_SOMEOK	0x40		/* At least on mount succeeded */
+#define	MOUNT_BUSY	0x80		/* Mount failed due to EBUSY */
+
+#define	MNTOPT_ASYNC	"async"		/* all I/O is asynchronous */
+#define	MNTOPT_ATIME	"atime"		/* update atime for files */
+#define	MNTOPT_NOATIME	"noatime"	/* do not update atime for files */
+#define	MNTOPT_AUTO	"auto"		/* automount */
+#define	MNTOPT_NOAUTO	"noauto"	/* do not automount */
+#define	MNTOPT_CONTEXT	"context"	/* selinux context */
+#define	MNTOPT_FSCONTEXT "fscontext"	/* selinux fscontext */
+#define	MNTOPT_DEFCONTEXT "defcontext"	/* selinux defcontext */
+#define	MNTOPT_ROOTCONTEXT "rootcontext" /* selinux rootcontext */
+#define	MNTOPT_DEFAULTS	"defaults"	/* defaults */
+#define	MNTOPT_DEVICES	"dev"		/* device-special allowed */
+#define	MNTOPT_NODEVICES "nodev"	/* device-special disallowed */
+#define	MNTOPT_DIRATIME	"diratime"	/* update atime for dirs */
+#define	MNTOPT_NODIRATIME "nodiratime"	/* do not update atime for dirs */
+#define	MNTOPT_DIRSYNC	"dirsync"	/* do dir updates synchronously */
+#define	MNTOPT_EXEC	"exec"		/* enable executables */
+#define	MNTOPT_NOEXEC	"noexec"	/* disable executables */
+#define	MNTOPT_GROUP	"group"		/* allow group mount */
+#define	MNTOPT_NOGROUP	"nogroup"	/* do not allow group mount */
+#define	MNTOPT_IVERSION	"iversion"	/* update inode version */
+#define	MNTOPT_NOIVERSION "noiversion"	/* do not update inode version */
+#define	MNTOPT_NBMAND	"mand"		/* allow non-blocking mandatory locks */
+#define	MNTOPT_NONBMAND	"nomand"	/* deny non-blocking mandatory locks */
+#define	MNTOPT_NETDEV	"_netdev"	/* network device */
+#define	MNTOPT_NOFAIL	"nofail"	/* no failure */
+#define	MNTOPT_RELATIME	"relatime"	/* allow relative time updates */
+#define	MNTOPT_NORELATIME "norelatime"	/* do not allow relative time updates */
+#define	MNTOPT_STRICTATIME "strictatime" /* strict access time updates */
+#define	MNTOPT_NOSTRICTATIME "nostrictatime" /* No strict access time updates */
+#define	MNTOPT_LAZYTIME "lazytime"	/* Defer access time writing */
+#ifdef __linux__
+#define	MNTOPT_SETUID	"suid"		/* Both setuid and devices allowed */
+#define	MNTOPT_NOSETUID	"nosuid"	/* Neither setuid nor devices allowed */
+#elif defined(__FreeBSD__)
+#define	MNTOPT_SETUID	"setuid"	/* Set uid allowed */
+#define	MNTOPT_NOSETUID	"nosetuid"	/* Set uid not allowed */
+#else
+#error "unknown OS"
+#endif
+#define	MNTOPT_OWNER	"owner"		/* allow owner mount */
+#define	MNTOPT_NOOWNER	"noowner"	/* do not allow owner mount */
+#define	MNTOPT_REMOUNT	"remount"	/* change mount options */
+#define	MNTOPT_RO	"ro"		/* read only */
+#define	MNTOPT_RW	"rw"		/* read/write */
+#define	MNTOPT_SYNC	"sync"		/* all I/O is synchronous */
+#define	MNTOPT_USER	"user"		/* allow user mount */
+#define	MNTOPT_NOUSER	"nouser"	/* do not allow user mount */
+#define	MNTOPT_USERS	"users"		/* allow user mount */
+#define	MNTOPT_NOUSERS	"nousers"	/* do not allow user mount */
+#define	MNTOPT_SUB	"sub"		/* allow mounts on subdirs */
+#define	MNTOPT_NOSUB	"nosub"		/* do not allow mounts on subdirs */
+#define	MNTOPT_QUIET	"quiet"		/* quiet mount */
+#define	MNTOPT_LOUD	"loud"		/* verbose mount */
+#define	MNTOPT_BIND	"bind"		/* remount part of a tree */
+#define	MNTOPT_RBIND	"rbind"		/* include subtrees */
+#define	MNTOPT_DIRXATTR	"dirxattr"	/* enable directory xattrs */
+#define	MNTOPT_SAXATTR	"saxattr"	/* enable system-attribute xattrs */
+#define	MNTOPT_XATTR	"xattr"		/* enable extended attributes */
+#define	MNTOPT_NOXATTR	"noxattr"	/* disable extended attributes */
+#define	MNTOPT_COMMENT	"comment"	/* comment */
+#define	MNTOPT_ZFSUTIL	"zfsutil"	/* called by zfs utility */
+#define	MNTOPT_ACL	"acl"		/* passed by util-linux-2.24 mount */
+#define	MNTOPT_NOACL	"noacl"		/* likewise */
+#define	MNTOPT_POSIXACL	"posixacl"	/* likewise */
+#define	MNTOPT_MNTPOINT	"mntpoint"	/* mount point hint */
+
+#endif	/* _SYS_MNTENT_H */
diff --git a/include/sys/mod.h b/include/sys/mod.h
new file mode 100644
index 0000000000000..0ad7704afe99c
--- /dev/null
+++ b/include/sys/mod.h
@@ -0,0 +1,41 @@
+/*
+ *  Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
+ *  Copyright (C) 2007 The Regents of the University of California.
+ *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
+ *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
+ *  UCRL-CODE-235197
+ *
+ *  This file is part of the SPL, Solaris Porting Layer.
+ *  For details, see <http://zfsonlinux.org/>.
+ *
+ *  The SPL is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the
+ *  Free Software Foundation; either version 2 of the License, or (at your
+ *  option) any later version.
+ *
+ *  The SPL is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ *  for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with the SPL.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef _SYS_MOD_H
+#define	_SYS_MOD_H
+
+#ifdef _KERNEL
+#include <sys/mod_os.h>
+#else
+/*
+ * Exported symbols
+ */
+#define	EXPORT_SYMBOL(x)
+
+#define	ZFS_MODULE_DESCRIPTION(s)
+#define	ZFS_MODULE_AUTHOR(s)
+#define	ZFS_MODULE_LICENSE(s)
+#define	ZFS_MODULE_VERSION(s)
+#endif
+
+#endif /* SYS_MOD_H */
diff --git a/include/sys/multilist.h b/include/sys/multilist.h
new file mode 100644
index 0000000000000..0c7b4075d9a3b
--- /dev/null
+++ b/include/sys/multilist.h
@@ -0,0 +1,107 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (c) 2013, 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_MULTILIST_H
+#define	_SYS_MULTILIST_H
+
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef list_node_t multilist_node_t;
+typedef struct multilist multilist_t;
+typedef struct multilist_sublist multilist_sublist_t;
+typedef unsigned int multilist_sublist_index_func_t(multilist_t *, void *);
+
+struct multilist_sublist {
+	/*
+	 * The mutex used internally to implement thread safe insertions
+	 * and removals to this individual sublist. It can also be locked
+	 * by a consumer using multilist_sublist_{lock,unlock}, which is
+	 * useful if a consumer needs to traverse the list in a thread
+	 * safe manner.
+	 */
+	kmutex_t	mls_lock;
+	/*
+	 * The actual list object containing all objects in this sublist.
+	 */
+	list_t		mls_list;
+	/*
+	 * Pad to cache line, in an effort to try and prevent cache line
+	 * contention.
+	 */
+} ____cacheline_aligned;
+
+struct multilist {
+	/*
+	 * This is used to get to the multilist_node_t structure given
+	 * the void *object contained on the list.
+	 */
+	size_t				ml_offset;
+	/*
+	 * The number of sublists used internally by this multilist.
+	 */
+	uint64_t			ml_num_sublists;
+	/*
+	 * The array of pointers to the actual sublists.
+	 */
+	multilist_sublist_t		*ml_sublists;
+	/*
+	 * Pointer to function which determines the sublist to use
+	 * when inserting and removing objects from this multilist.
+	 * Please see the comment above multilist_create for details.
+	 */
+	multilist_sublist_index_func_t	*ml_index_func;
+};
+
+void multilist_destroy(multilist_t *);
+multilist_t *multilist_create(size_t, size_t, multilist_sublist_index_func_t *);
+
+void multilist_insert(multilist_t *, void *);
+void multilist_remove(multilist_t *, void *);
+int  multilist_is_empty(multilist_t *);
+
+unsigned int multilist_get_num_sublists(multilist_t *);
+unsigned int multilist_get_random_index(multilist_t *);
+
+multilist_sublist_t *multilist_sublist_lock(multilist_t *, unsigned int);
+multilist_sublist_t *multilist_sublist_lock_obj(multilist_t *, void *);
+void multilist_sublist_unlock(multilist_sublist_t *);
+
+void multilist_sublist_insert_head(multilist_sublist_t *, void *);
+void multilist_sublist_insert_tail(multilist_sublist_t *, void *);
+void multilist_sublist_move_forward(multilist_sublist_t *mls, void *obj);
+void multilist_sublist_remove(multilist_sublist_t *, void *);
+int  multilist_sublist_is_empty(multilist_sublist_t *);
+int  multilist_sublist_is_empty_idx(multilist_t *, unsigned int);
+
+void *multilist_sublist_head(multilist_sublist_t *);
+void *multilist_sublist_tail(multilist_sublist_t *);
+void *multilist_sublist_next(multilist_sublist_t *, void *);
+void *multilist_sublist_prev(multilist_sublist_t *, void *);
+
+void multilist_link_init(multilist_node_t *);
+int  multilist_link_active(multilist_node_t *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_MULTILIST_H */
diff --git a/include/sys/note.h b/include/sys/note.h
new file mode 100644
index 0000000000000..33b5476686ea6
--- /dev/null
+++ b/include/sys/note.h
@@ -0,0 +1,56 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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) 1994 by Sun Microsystems, Inc.
+ */
+
+/*
+ * sys/note.h:	interface for annotating source with info for tools
+ *
+ * This is the underlying interface; NOTE (/usr/include/note.h) is the
+ * preferred interface, but all exported header files should include this
+ * file directly and use _NOTE so as not to take "NOTE" from the user's
+ * namespace.  For consistency, *all* kernel source should use _NOTE.
+ *
+ * By default, annotations expand to nothing.  This file implements
+ * that.  Tools using annotations will interpose a different version
+ * of this file that will expand annotations as needed.
+ */
+
+#ifndef	_SYS_NOTE_H
+#define	_SYS_NOTE_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifndef _NOTE
+#define	_NOTE(s)
+#endif
+
+#define	NOTE(s)	_NOTE(s)
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_NOTE_H */
diff --git a/include/sys/nvpair.h b/include/sys/nvpair.h
new file mode 100644
index 0000000000000..e8567933d2bc8
--- /dev/null
+++ b/include/sys/nvpair.h
@@ -0,0 +1,358 @@
+/*
+ * 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) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_NVPAIR_H
+#define	_SYS_NVPAIR_H
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/errno.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	DATA_TYPE_DONTCARE = -1,
+	DATA_TYPE_UNKNOWN = 0,
+	DATA_TYPE_BOOLEAN,
+	DATA_TYPE_BYTE,
+	DATA_TYPE_INT16,
+	DATA_TYPE_UINT16,
+	DATA_TYPE_INT32,
+	DATA_TYPE_UINT32,
+	DATA_TYPE_INT64,
+	DATA_TYPE_UINT64,
+	DATA_TYPE_STRING,
+	DATA_TYPE_BYTE_ARRAY,
+	DATA_TYPE_INT16_ARRAY,
+	DATA_TYPE_UINT16_ARRAY,
+	DATA_TYPE_INT32_ARRAY,
+	DATA_TYPE_UINT32_ARRAY,
+	DATA_TYPE_INT64_ARRAY,
+	DATA_TYPE_UINT64_ARRAY,
+	DATA_TYPE_STRING_ARRAY,
+	DATA_TYPE_HRTIME,
+	DATA_TYPE_NVLIST,
+	DATA_TYPE_NVLIST_ARRAY,
+	DATA_TYPE_BOOLEAN_VALUE,
+	DATA_TYPE_INT8,
+	DATA_TYPE_UINT8,
+	DATA_TYPE_BOOLEAN_ARRAY,
+	DATA_TYPE_INT8_ARRAY,
+#if !defined(_KERNEL)
+	DATA_TYPE_UINT8_ARRAY,
+	DATA_TYPE_DOUBLE
+#else
+	DATA_TYPE_UINT8_ARRAY
+#endif
+} data_type_t;
+
+typedef struct nvpair {
+	int32_t nvp_size;	/* size of this nvpair */
+	int16_t	nvp_name_sz;	/* length of name string */
+	int16_t	nvp_reserve;	/* not used */
+	int32_t	nvp_value_elem;	/* number of elements for array types */
+	data_type_t nvp_type;	/* type of value */
+	/* name string */
+	/* aligned ptr array for string arrays */
+	/* aligned array of data for value */
+} nvpair_t;
+
+/* nvlist header */
+typedef struct nvlist {
+	int32_t		nvl_version;
+	uint32_t	nvl_nvflag;	/* persistent flags */
+	uint64_t	nvl_priv;	/* ptr to private data if not packed */
+	uint32_t	nvl_flag;
+	int32_t		nvl_pad;	/* currently not used, for alignment */
+} nvlist_t;
+
+/* nvp implementation version */
+#define	NV_VERSION	0
+
+/* nvlist pack encoding */
+#define	NV_ENCODE_NATIVE	0
+#define	NV_ENCODE_XDR		1
+
+/* nvlist persistent unique name flags, stored in nvl_nvflags */
+#define	NV_UNIQUE_NAME		0x1
+#define	NV_UNIQUE_NAME_TYPE	0x2
+
+/* nvlist lookup pairs related flags */
+#define	NV_FLAG_NOENTOK		0x1
+
+/* convenience macros */
+#define	NV_ALIGN(x)		(((ulong_t)(x) + 7ul) & ~7ul)
+#define	NV_ALIGN4(x)		(((x) + 3) & ~3)
+
+#define	NVP_SIZE(nvp)		((nvp)->nvp_size)
+#define	NVP_NAME(nvp)		((char *)(nvp) + sizeof (nvpair_t))
+#define	NVP_TYPE(nvp)		((nvp)->nvp_type)
+#define	NVP_NELEM(nvp)		((nvp)->nvp_value_elem)
+#define	NVP_VALUE(nvp)		((char *)(nvp) + NV_ALIGN(sizeof (nvpair_t) \
+				+ (nvp)->nvp_name_sz))
+
+#define	NVL_VERSION(nvl)	((nvl)->nvl_version)
+#define	NVL_SIZE(nvl)		((nvl)->nvl_size)
+#define	NVL_FLAG(nvl)		((nvl)->nvl_flag)
+
+/* NV allocator framework */
+typedef struct nv_alloc_ops nv_alloc_ops_t;
+
+typedef struct nv_alloc {
+	const nv_alloc_ops_t *nva_ops;
+	void *nva_arg;
+} nv_alloc_t;
+
+struct nv_alloc_ops {
+	int (*nv_ao_init)(nv_alloc_t *, va_list);
+	void (*nv_ao_fini)(nv_alloc_t *);
+	void *(*nv_ao_alloc)(nv_alloc_t *, size_t);
+	void (*nv_ao_free)(nv_alloc_t *, void *, size_t);
+	void (*nv_ao_reset)(nv_alloc_t *);
+};
+
+extern const nv_alloc_ops_t *nv_fixed_ops;
+extern nv_alloc_t *nv_alloc_nosleep;
+
+#if defined(_KERNEL)
+extern nv_alloc_t *nv_alloc_sleep;
+extern nv_alloc_t *nv_alloc_pushpage;
+#endif
+
+int nv_alloc_init(nv_alloc_t *, const nv_alloc_ops_t *, /* args */ ...);
+void nv_alloc_reset(nv_alloc_t *);
+void nv_alloc_fini(nv_alloc_t *);
+
+/* list management */
+int nvlist_alloc(nvlist_t **, uint_t, int);
+void nvlist_free(nvlist_t *);
+int nvlist_size(nvlist_t *, size_t *, int);
+int nvlist_pack(nvlist_t *, char **, size_t *, int, int);
+int nvlist_unpack(char *, size_t, nvlist_t **, int);
+int nvlist_dup(nvlist_t *, nvlist_t **, int);
+int nvlist_merge(nvlist_t *, nvlist_t *, int);
+
+uint_t nvlist_nvflag(nvlist_t *);
+
+int nvlist_xalloc(nvlist_t **, uint_t, nv_alloc_t *);
+int nvlist_xpack(nvlist_t *, char **, size_t *, int, nv_alloc_t *);
+int nvlist_xunpack(char *, size_t, nvlist_t **, nv_alloc_t *);
+int nvlist_xdup(nvlist_t *, nvlist_t **, nv_alloc_t *);
+nv_alloc_t *nvlist_lookup_nv_alloc(nvlist_t *);
+
+int nvlist_add_nvpair(nvlist_t *, nvpair_t *);
+int nvlist_add_boolean(nvlist_t *, const char *);
+int nvlist_add_boolean_value(nvlist_t *, const char *, boolean_t);
+int nvlist_add_byte(nvlist_t *, const char *, uchar_t);
+int nvlist_add_int8(nvlist_t *, const char *, int8_t);
+int nvlist_add_uint8(nvlist_t *, const char *, uint8_t);
+int nvlist_add_int16(nvlist_t *, const char *, int16_t);
+int nvlist_add_uint16(nvlist_t *, const char *, uint16_t);
+int nvlist_add_int32(nvlist_t *, const char *, int32_t);
+int nvlist_add_uint32(nvlist_t *, const char *, uint32_t);
+int nvlist_add_int64(nvlist_t *, const char *, int64_t);
+int nvlist_add_uint64(nvlist_t *, const char *, uint64_t);
+int nvlist_add_string(nvlist_t *, const char *, const char *);
+int nvlist_add_nvlist(nvlist_t *, const char *, nvlist_t *);
+int nvlist_add_boolean_array(nvlist_t *, const char *, boolean_t *, uint_t);
+int nvlist_add_byte_array(nvlist_t *, const char *, uchar_t *, uint_t);
+int nvlist_add_int8_array(nvlist_t *, const char *, int8_t *, uint_t);
+int nvlist_add_uint8_array(nvlist_t *, const char *, uint8_t *, uint_t);
+int nvlist_add_int16_array(nvlist_t *, const char *, int16_t *, uint_t);
+int nvlist_add_uint16_array(nvlist_t *, const char *, uint16_t *, uint_t);
+int nvlist_add_int32_array(nvlist_t *, const char *, int32_t *, uint_t);
+int nvlist_add_uint32_array(nvlist_t *, const char *, uint32_t *, uint_t);
+int nvlist_add_int64_array(nvlist_t *, const char *, int64_t *, uint_t);
+int nvlist_add_uint64_array(nvlist_t *, const char *, uint64_t *, uint_t);
+int nvlist_add_string_array(nvlist_t *, const char *, char *const *, uint_t);
+int nvlist_add_nvlist_array(nvlist_t *, const char *, nvlist_t **, uint_t);
+int nvlist_add_hrtime(nvlist_t *, const char *, hrtime_t);
+#if !defined(_KERNEL)
+int nvlist_add_double(nvlist_t *, const char *, double);
+#endif
+
+int nvlist_remove(nvlist_t *, const char *, data_type_t);
+int nvlist_remove_all(nvlist_t *, const char *);
+int nvlist_remove_nvpair(nvlist_t *, nvpair_t *);
+
+int nvlist_lookup_boolean(nvlist_t *, const char *);
+int nvlist_lookup_boolean_value(nvlist_t *, const char *, boolean_t *);
+int nvlist_lookup_byte(nvlist_t *, const char *, uchar_t *);
+int nvlist_lookup_int8(nvlist_t *, const char *, int8_t *);
+int nvlist_lookup_uint8(nvlist_t *, const char *, uint8_t *);
+int nvlist_lookup_int16(nvlist_t *, const char *, int16_t *);
+int nvlist_lookup_uint16(nvlist_t *, const char *, uint16_t *);
+int nvlist_lookup_int32(nvlist_t *, const char *, int32_t *);
+int nvlist_lookup_uint32(nvlist_t *, const char *, uint32_t *);
+int nvlist_lookup_int64(nvlist_t *, const char *, int64_t *);
+int nvlist_lookup_uint64(nvlist_t *, const char *, uint64_t *);
+int nvlist_lookup_string(nvlist_t *, const char *, char **);
+int nvlist_lookup_nvlist(nvlist_t *, const char *, nvlist_t **);
+int nvlist_lookup_boolean_array(nvlist_t *, const char *,
+    boolean_t **, uint_t *);
+int nvlist_lookup_byte_array(nvlist_t *, const char *, uchar_t **, uint_t *);
+int nvlist_lookup_int8_array(nvlist_t *, const char *, int8_t **, uint_t *);
+int nvlist_lookup_uint8_array(nvlist_t *, const char *, uint8_t **, uint_t *);
+int nvlist_lookup_int16_array(nvlist_t *, const char *, int16_t **, uint_t *);
+int nvlist_lookup_uint16_array(nvlist_t *, const char *, uint16_t **, uint_t *);
+int nvlist_lookup_int32_array(nvlist_t *, const char *, int32_t **, uint_t *);
+int nvlist_lookup_uint32_array(nvlist_t *, const char *, uint32_t **, uint_t *);
+int nvlist_lookup_int64_array(nvlist_t *, const char *, int64_t **, uint_t *);
+int nvlist_lookup_uint64_array(nvlist_t *, const char *, uint64_t **, uint_t *);
+int nvlist_lookup_string_array(nvlist_t *, const char *, char ***, uint_t *);
+int nvlist_lookup_nvlist_array(nvlist_t *, const char *,
+    nvlist_t ***, uint_t *);
+int nvlist_lookup_hrtime(nvlist_t *, const char *, hrtime_t *);
+int nvlist_lookup_pairs(nvlist_t *, int, ...);
+#if !defined(_KERNEL)
+int nvlist_lookup_double(nvlist_t *, const char *, double *);
+#endif
+
+int nvlist_lookup_nvpair(nvlist_t *, const char *, nvpair_t **);
+int nvlist_lookup_nvpair_embedded_index(nvlist_t *, const char *, nvpair_t **,
+    int *, char **);
+boolean_t nvlist_exists(nvlist_t *, const char *);
+boolean_t nvlist_empty(nvlist_t *);
+
+/* processing nvpair */
+nvpair_t *nvlist_next_nvpair(nvlist_t *, nvpair_t *);
+nvpair_t *nvlist_prev_nvpair(nvlist_t *, nvpair_t *);
+char *nvpair_name(nvpair_t *);
+data_type_t nvpair_type(nvpair_t *);
+int nvpair_type_is_array(nvpair_t *);
+int nvpair_value_boolean_value(nvpair_t *, boolean_t *);
+int nvpair_value_byte(nvpair_t *, uchar_t *);
+int nvpair_value_int8(nvpair_t *, int8_t *);
+int nvpair_value_uint8(nvpair_t *, uint8_t *);
+int nvpair_value_int16(nvpair_t *, int16_t *);
+int nvpair_value_uint16(nvpair_t *, uint16_t *);
+int nvpair_value_int32(nvpair_t *, int32_t *);
+int nvpair_value_uint32(nvpair_t *, uint32_t *);
+int nvpair_value_int64(nvpair_t *, int64_t *);
+int nvpair_value_uint64(nvpair_t *, uint64_t *);
+int nvpair_value_string(nvpair_t *, char **);
+int nvpair_value_nvlist(nvpair_t *, nvlist_t **);
+int nvpair_value_boolean_array(nvpair_t *, boolean_t **, uint_t *);
+int nvpair_value_byte_array(nvpair_t *, uchar_t **, uint_t *);
+int nvpair_value_int8_array(nvpair_t *, int8_t **, uint_t *);
+int nvpair_value_uint8_array(nvpair_t *, uint8_t **, uint_t *);
+int nvpair_value_int16_array(nvpair_t *, int16_t **, uint_t *);
+int nvpair_value_uint16_array(nvpair_t *, uint16_t **, uint_t *);
+int nvpair_value_int32_array(nvpair_t *, int32_t **, uint_t *);
+int nvpair_value_uint32_array(nvpair_t *, uint32_t **, uint_t *);
+int nvpair_value_int64_array(nvpair_t *, int64_t **, uint_t *);
+int nvpair_value_uint64_array(nvpair_t *, uint64_t **, uint_t *);
+int nvpair_value_string_array(nvpair_t *, char ***, uint_t *);
+int nvpair_value_nvlist_array(nvpair_t *, nvlist_t ***, uint_t *);
+int nvpair_value_hrtime(nvpair_t *, hrtime_t *);
+#if !defined(_KERNEL)
+int nvpair_value_double(nvpair_t *, double *);
+#endif
+
+nvlist_t *fnvlist_alloc(void);
+void fnvlist_free(nvlist_t *);
+size_t fnvlist_size(nvlist_t *);
+char *fnvlist_pack(nvlist_t *, size_t *);
+void fnvlist_pack_free(char *, size_t);
+nvlist_t *fnvlist_unpack(char *, size_t);
+nvlist_t *fnvlist_dup(nvlist_t *);
+void fnvlist_merge(nvlist_t *, nvlist_t *);
+size_t fnvlist_num_pairs(nvlist_t *);
+
+void fnvlist_add_boolean(nvlist_t *, const char *);
+void fnvlist_add_boolean_value(nvlist_t *, const char *, boolean_t);
+void fnvlist_add_byte(nvlist_t *, const char *, uchar_t);
+void fnvlist_add_int8(nvlist_t *, const char *, int8_t);
+void fnvlist_add_uint8(nvlist_t *, const char *, uint8_t);
+void fnvlist_add_int16(nvlist_t *, const char *, int16_t);
+void fnvlist_add_uint16(nvlist_t *, const char *, uint16_t);
+void fnvlist_add_int32(nvlist_t *, const char *, int32_t);
+void fnvlist_add_uint32(nvlist_t *, const char *, uint32_t);
+void fnvlist_add_int64(nvlist_t *, const char *, int64_t);
+void fnvlist_add_uint64(nvlist_t *, const char *, uint64_t);
+void fnvlist_add_string(nvlist_t *, const char *, const char *);
+void fnvlist_add_nvlist(nvlist_t *, const char *, nvlist_t *);
+void fnvlist_add_nvpair(nvlist_t *, nvpair_t *);
+void fnvlist_add_boolean_array(nvlist_t *, const char *, boolean_t *, uint_t);
+void fnvlist_add_byte_array(nvlist_t *, const char *, uchar_t *, uint_t);
+void fnvlist_add_int8_array(nvlist_t *, const char *, int8_t *, uint_t);
+void fnvlist_add_uint8_array(nvlist_t *, const char *, uint8_t *, uint_t);
+void fnvlist_add_int16_array(nvlist_t *, const char *, int16_t *, uint_t);
+void fnvlist_add_uint16_array(nvlist_t *, const char *, uint16_t *, uint_t);
+void fnvlist_add_int32_array(nvlist_t *, const char *, int32_t *, uint_t);
+void fnvlist_add_uint32_array(nvlist_t *, const char *, uint32_t *, uint_t);
+void fnvlist_add_int64_array(nvlist_t *, const char *, int64_t *, uint_t);
+void fnvlist_add_uint64_array(nvlist_t *, const char *, uint64_t *, uint_t);
+void fnvlist_add_string_array(nvlist_t *, const char *, char * const *, uint_t);
+void fnvlist_add_nvlist_array(nvlist_t *, const char *, nvlist_t **, uint_t);
+
+void fnvlist_remove(nvlist_t *, const char *);
+void fnvlist_remove_nvpair(nvlist_t *, nvpair_t *);
+
+nvpair_t *fnvlist_lookup_nvpair(nvlist_t *, const char *);
+boolean_t fnvlist_lookup_boolean(nvlist_t *, const char *);
+boolean_t fnvlist_lookup_boolean_value(nvlist_t *, const char *);
+uchar_t fnvlist_lookup_byte(nvlist_t *, const char *);
+int8_t fnvlist_lookup_int8(nvlist_t *, const char *);
+int16_t fnvlist_lookup_int16(nvlist_t *, const char *);
+int32_t fnvlist_lookup_int32(nvlist_t *, const char *);
+int64_t fnvlist_lookup_int64(nvlist_t *, const char *);
+uint8_t fnvlist_lookup_uint8(nvlist_t *, const char *);
+uint16_t fnvlist_lookup_uint16(nvlist_t *, const char *);
+uint32_t fnvlist_lookup_uint32(nvlist_t *, const char *);
+uint64_t fnvlist_lookup_uint64(nvlist_t *, const char *);
+char *fnvlist_lookup_string(nvlist_t *, const char *);
+nvlist_t *fnvlist_lookup_nvlist(nvlist_t *, const char *);
+boolean_t *fnvlist_lookup_boolean_array(nvlist_t *, const char *, uint_t *);
+uchar_t *fnvlist_lookup_byte_array(nvlist_t *, const char *, uint_t *);
+int8_t *fnvlist_lookup_int8_array(nvlist_t *, const char *, uint_t *);
+uint8_t *fnvlist_lookup_uint8_array(nvlist_t *, const char *, uint_t *);
+int16_t *fnvlist_lookup_int16_array(nvlist_t *, const char *, uint_t *);
+uint16_t *fnvlist_lookup_uint16_array(nvlist_t *, const char *, uint_t *);
+int32_t *fnvlist_lookup_int32_array(nvlist_t *, const char *, uint_t *);
+uint32_t *fnvlist_lookup_uint32_array(nvlist_t *, const char *, uint_t *);
+int64_t *fnvlist_lookup_int64_array(nvlist_t *, const char *, uint_t *);
+uint64_t *fnvlist_lookup_uint64_array(nvlist_t *, const char *, uint_t *);
+
+boolean_t fnvpair_value_boolean_value(nvpair_t *nvp);
+uchar_t fnvpair_value_byte(nvpair_t *nvp);
+int8_t fnvpair_value_int8(nvpair_t *nvp);
+int16_t fnvpair_value_int16(nvpair_t *nvp);
+int32_t fnvpair_value_int32(nvpair_t *nvp);
+int64_t fnvpair_value_int64(nvpair_t *nvp);
+uint8_t fnvpair_value_uint8(nvpair_t *nvp);
+uint16_t fnvpair_value_uint16(nvpair_t *nvp);
+uint32_t fnvpair_value_uint32(nvpair_t *nvp);
+uint64_t fnvpair_value_uint64(nvpair_t *nvp);
+char *fnvpair_value_string(nvpair_t *nvp);
+nvlist_t *fnvpair_value_nvlist(nvpair_t *nvp);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_NVPAIR_H */
diff --git a/include/sys/nvpair_impl.h b/include/sys/nvpair_impl.h
new file mode 100644
index 0000000000000..c9874b3e4db7e
--- /dev/null
+++ b/include/sys/nvpair_impl.h
@@ -0,0 +1,90 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2004 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef	_NVPAIR_IMPL_H
+#define	_NVPAIR_IMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/nvpair.h>
+
+/*
+ * The structures here provided for information and debugging purposes only
+ * may be changed in the future.
+ */
+
+/*
+ * implementation linked list for pre-packed data
+ */
+typedef struct i_nvp i_nvp_t;
+
+struct i_nvp {
+	union {
+		/* ensure alignment */
+		uint64_t	_nvi_align;
+
+		struct {
+			/* pointer to next nvpair */
+			i_nvp_t	*_nvi_next;
+
+			/* pointer to prev nvpair */
+			i_nvp_t	*_nvi_prev;
+
+			/* next pair in table bucket */
+			i_nvp_t	*_nvi_hashtable_next;
+		} _nvi;
+	} _nvi_un;
+
+	/* nvpair */
+	nvpair_t nvi_nvp;
+};
+#define	nvi_next	_nvi_un._nvi._nvi_next
+#define	nvi_prev	_nvi_un._nvi._nvi_prev
+#define	nvi_hashtable_next	_nvi_un._nvi._nvi_hashtable_next
+
+typedef struct {
+	i_nvp_t		*nvp_list;	/* linked list of nvpairs */
+	i_nvp_t		*nvp_last;	/* last nvpair */
+	i_nvp_t		*nvp_curr;	/* current walker nvpair */
+	nv_alloc_t	*nvp_nva;	/* pluggable allocator */
+	uint32_t	nvp_stat;	/* internal state */
+
+	i_nvp_t		**nvp_hashtable; /* table of entries used for lookup */
+	uint32_t	nvp_nbuckets;	/* # of buckets in hash table */
+	uint32_t	nvp_nentries;	/* # of entries in hash table */
+} nvpriv_t;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _NVPAIR_IMPL_H */
diff --git a/include/sys/objlist.h b/include/sys/objlist.h
new file mode 100644
index 0000000000000..a124a61fdc953
--- /dev/null
+++ b/include/sys/objlist.h
@@ -0,0 +1,51 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (c) 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef	_OBJLIST_H
+#define	_OBJLIST_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include	<sys/zfs_context.h>
+
+typedef struct objlist_node {
+	list_node_t	on_node;
+	uint64_t	on_object;
+} objlist_node_t;
+
+typedef struct objlist {
+	list_t		ol_list; /* List of struct objnode. */
+	/*
+	 * Last object looked up. Used to assert that objects are being looked
+	 * up in ascending order.
+	 */
+	uint64_t	ol_last_lookup;
+} objlist_t;
+
+objlist_t *objlist_create(void);
+void objlist_destroy(objlist_t *);
+boolean_t objlist_exists(objlist_t *, uint64_t);
+void objlist_insert(objlist_t *, uint64_t);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _OBJLIST_H */
diff --git a/include/sys/pathname.h b/include/sys/pathname.h
new file mode 100644
index 0000000000000..d79cc5c01afda
--- /dev/null
+++ b/include/sys/pathname.h
@@ -0,0 +1,72 @@
+/*
+ * 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) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
+ */
+
+/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
+/*	  All Rights Reserved  	*/
+
+/*
+ * Portions of this source code were derived from Berkeley 4.3 BSD
+ * under license from the Regents of the University of California.
+ */
+
+#ifndef _SYS_PATHNAME_H
+#define	_SYS_PATHNAME_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Pathname structure.
+ * System calls that operate on path names gather the path name
+ * from the system call into this structure and reduce it by
+ * peeling off translated components.  If a symbolic link is
+ * encountered the new path name to be translated is also
+ * assembled in this structure.
+ *
+ * By convention pn_buf is not changed once it's been set to point
+ * to the underlying storage; routines which manipulate the pathname
+ * do so by changing pn_path and pn_pathlen.  pn_pathlen is redundant
+ * since the path name is null-terminated, but is provided to make
+ * some computations faster.
+ */
+typedef struct pathname {
+	char	*pn_buf;		/* underlying storage */
+#if 0 /* unused in ZoL */
+	char	*pn_path;		/* remaining pathname */
+	size_t	pn_pathlen;		/* remaining length */
+#endif
+	size_t	pn_bufsize;		/* total size of pn_buf */
+} pathname_t;
+
+extern void	pn_alloc(struct pathname *);
+extern void	pn_alloc_sz(struct pathname *, size_t);
+extern void	pn_free(struct pathname *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_PATHNAME_H */
diff --git a/include/sys/qat.h b/include/sys/qat.h
new file mode 100644
index 0000000000000..9ae8eb1735723
--- /dev/null
+++ b/include/sys/qat.h
@@ -0,0 +1,199 @@
+/*
+ * 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
+ */
+
+#ifndef	_SYS_QAT_H
+#define	_SYS_QAT_H
+
+typedef enum qat_compress_dir {
+	QAT_DECOMPRESS = 0,
+	QAT_COMPRESS = 1,
+} qat_compress_dir_t;
+
+typedef enum qat_encrypt_dir {
+	QAT_DECRYPT = 0,
+	QAT_ENCRYPT = 1,
+} qat_encrypt_dir_t;
+
+
+#if defined(_KERNEL) && defined(HAVE_QAT)
+#include <sys/zio.h>
+#include <sys/crypto/api.h>
+#include "cpa.h"
+#include "dc/cpa_dc.h"
+#include "lac/cpa_cy_sym.h"
+
+/*
+ * The minimal and maximal buffer size which are not restricted
+ * in the QAT hardware, but with the input buffer size between 4KB
+ * and 128KB the hardware can provide the optimal performance.
+ */
+#define	QAT_MIN_BUF_SIZE	(4*1024)
+#define	QAT_MAX_BUF_SIZE	(128*1024)
+
+/*
+ * Used for QAT kstat.
+ */
+typedef struct qat_stats {
+	/*
+	 * Number of jobs submitted to QAT compression engine.
+	 */
+	kstat_named_t comp_requests;
+	/*
+	 * Total bytes sent to QAT compression engine.
+	 */
+	kstat_named_t comp_total_in_bytes;
+	/*
+	 * Total bytes output from QAT compression engine.
+	 */
+	kstat_named_t comp_total_out_bytes;
+	/*
+	 * Number of jobs submitted to QAT de-compression engine.
+	 */
+	kstat_named_t decomp_requests;
+	/*
+	 * Total bytes sent to QAT de-compression engine.
+	 */
+	kstat_named_t decomp_total_in_bytes;
+	/*
+	 * Total bytes output from QAT de-compression engine.
+	 */
+	kstat_named_t decomp_total_out_bytes;
+	/*
+	 * Number of fails in the QAT compression / decompression engine.
+	 * Note: when a QAT error happens, it doesn't necessarily indicate a
+	 * critical hardware issue. Sometimes it is because the output buffer
+	 * is not big enough. The compression job will be transferred to the
+	 * gzip software implementation so the functionality of ZFS is not
+	 * impacted.
+	 */
+	kstat_named_t dc_fails;
+
+	/*
+	 * Number of jobs submitted to QAT encryption engine.
+	 */
+	kstat_named_t encrypt_requests;
+	/*
+	 * Total bytes sent to QAT encryption engine.
+	 */
+	kstat_named_t encrypt_total_in_bytes;
+	/*
+	 * Total bytes output from QAT encryption engine.
+	 */
+	kstat_named_t encrypt_total_out_bytes;
+	/*
+	 * Number of jobs submitted to QAT decryption engine.
+	 */
+	kstat_named_t decrypt_requests;
+	/*
+	 * Total bytes sent to QAT decryption engine.
+	 */
+	kstat_named_t decrypt_total_in_bytes;
+	/*
+	 * Total bytes output from QAT decryption engine.
+	 */
+	kstat_named_t decrypt_total_out_bytes;
+	/*
+	 * Number of fails in the QAT encryption / decryption engine.
+	 * Note: when a QAT error happens, it doesn't necessarily indicate a
+	 * critical hardware issue. The encryption job will be transferred
+	 * to the software implementation so the functionality of ZFS is
+	 * not impacted.
+	 */
+	kstat_named_t crypt_fails;
+
+	/*
+	 * Number of jobs submitted to QAT checksum engine.
+	 */
+	kstat_named_t cksum_requests;
+	/*
+	 * Total bytes sent to QAT checksum engine.
+	 */
+	kstat_named_t cksum_total_in_bytes;
+	/*
+	 * Number of fails in the QAT checksum engine.
+	 * Note: when a QAT error happens, it doesn't necessarily indicate a
+	 * critical hardware issue. The checksum job will be transferred to the
+	 * software implementation so the functionality of ZFS is not impacted.
+	 */
+	kstat_named_t cksum_fails;
+} qat_stats_t;
+
+#define	QAT_STAT_INCR(stat, val) \
+	atomic_add_64(&qat_stats.stat.value.ui64, (val))
+#define	QAT_STAT_BUMP(stat) \
+	QAT_STAT_INCR(stat, 1)
+
+extern qat_stats_t qat_stats;
+extern int zfs_qat_compress_disable;
+extern int zfs_qat_checksum_disable;
+extern int zfs_qat_encrypt_disable;
+
+/* inlined for performance */
+static inline struct page *
+qat_mem_to_page(void *addr)
+{
+	if (!is_vmalloc_addr(addr))
+		return (virt_to_page(addr));
+
+	return (vmalloc_to_page(addr));
+}
+
+CpaStatus qat_mem_alloc_contig(void **pp_mem_addr, Cpa32U size_bytes);
+void qat_mem_free_contig(void **pp_mem_addr);
+#define	QAT_PHYS_CONTIG_ALLOC(pp_mem_addr, size_bytes)	\
+	qat_mem_alloc_contig((void *)(pp_mem_addr), (size_bytes))
+#define	QAT_PHYS_CONTIG_FREE(p_mem_addr)	\
+	qat_mem_free_contig((void *)&(p_mem_addr))
+
+extern int qat_dc_init(void);
+extern void qat_dc_fini(void);
+extern int qat_cy_init(void);
+extern void qat_cy_fini(void);
+extern int qat_init(void);
+extern void qat_fini(void);
+
+/* fake CpaStatus used to indicate data was not compressible */
+#define	CPA_STATUS_INCOMPRESSIBLE				(-127)
+
+extern boolean_t qat_dc_use_accel(size_t s_len);
+extern boolean_t qat_crypt_use_accel(size_t s_len);
+extern boolean_t qat_checksum_use_accel(size_t s_len);
+extern int qat_compress(qat_compress_dir_t dir, char *src, int src_len,
+    char *dst, int dst_len, size_t *c_len);
+extern int qat_crypt(qat_encrypt_dir_t dir, uint8_t *src_buf, uint8_t *dst_buf,
+    uint8_t *aad_buf, uint32_t aad_len, uint8_t *iv_buf, uint8_t *digest_buf,
+    crypto_key_t *key, uint64_t crypt, uint32_t enc_len);
+extern int qat_checksum(uint64_t cksum, uint8_t *buf, uint64_t size,
+    zio_cksum_t *zcp);
+#else
+#define	CPA_STATUS_SUCCESS					0
+#define	CPA_STATUS_INCOMPRESSIBLE				(-127)
+#define	qat_init()
+#define	qat_fini()
+#define	qat_dc_use_accel(s_len)					0
+#define	qat_crypt_use_accel(s_len)				0
+#define	qat_checksum_use_accel(s_len)				0
+#define	qat_compress(dir, s, sl, d, dl, cl)			0
+#define	qat_crypt(dir, s, d, a, al, i, db, k, c, el)		0
+#define	qat_checksum(c, buf, s, z)				0
+#endif
+
+#endif /* _SYS_QAT_H */
diff --git a/include/sys/range_tree.h b/include/sys/range_tree.h
new file mode 100644
index 0000000000000..fef3d4d7bd218
--- /dev/null
+++ b/include/sys/range_tree.h
@@ -0,0 +1,330 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2013, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_RANGE_TREE_H
+#define	_SYS_RANGE_TREE_H
+
+#include <sys/btree.h>
+#include <sys/dmu.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	RANGE_TREE_HISTOGRAM_SIZE	64
+
+typedef struct range_tree_ops range_tree_ops_t;
+
+typedef enum range_seg_type {
+	RANGE_SEG32,
+	RANGE_SEG64,
+	RANGE_SEG_GAP,
+	RANGE_SEG_NUM_TYPES,
+} range_seg_type_t;
+
+/*
+ * Note: the range_tree may not be accessed concurrently; consumers
+ * must provide external locking if required.
+ */
+typedef struct range_tree {
+	zfs_btree_t	rt_root;	/* offset-ordered segment b-tree */
+	uint64_t	rt_space;	/* sum of all segments in the map */
+	range_seg_type_t rt_type;	/* type of range_seg_t in use */
+	/*
+	 * All data that is stored in the range tree must have a start higher
+	 * than or equal to rt_start, and all sizes and offsets must be
+	 * multiples of 1 << rt_shift.
+	 */
+	uint8_t		rt_shift;
+	uint64_t	rt_start;
+	range_tree_ops_t *rt_ops;
+
+	/* rt_btree_compare should only be set if rt_arg is a b-tree */
+	void		*rt_arg;
+	int (*rt_btree_compare)(const void *, const void *);
+
+	uint64_t	rt_gap;		/* allowable inter-segment gap */
+
+	/*
+	 * The rt_histogram maintains a histogram of ranges. Each bucket,
+	 * rt_histogram[i], contains the number of ranges whose size is:
+	 * 2^i <= size of range in bytes < 2^(i+1)
+	 */
+	uint64_t	rt_histogram[RANGE_TREE_HISTOGRAM_SIZE];
+} range_tree_t;
+
+typedef struct range_seg32 {
+	uint32_t	rs_start;	/* starting offset of this segment */
+	uint32_t	rs_end;		/* ending offset (non-inclusive) */
+} range_seg32_t;
+
+/*
+ * Extremely large metaslabs, vdev-wide trees, and dnode-wide trees may
+ * require 64-bit integers for ranges.
+ */
+typedef struct range_seg64 {
+	uint64_t	rs_start;	/* starting offset of this segment */
+	uint64_t	rs_end;		/* ending offset (non-inclusive) */
+} range_seg64_t;
+
+typedef struct range_seg_gap {
+	uint64_t	rs_start;	/* starting offset of this segment */
+	uint64_t	rs_end;		/* ending offset (non-inclusive) */
+	uint64_t	rs_fill;	/* actual fill if gap mode is on */
+} range_seg_gap_t;
+
+/*
+ * This type needs to be the largest of the range segs, since it will be stack
+ * allocated and then cast the actual type to do tree operations.
+ */
+typedef range_seg_gap_t range_seg_max_t;
+
+/*
+ * This is just for clarity of code purposes, so we can make it clear that a
+ * pointer is to a range seg of some type; when we need to do the actual math,
+ * we'll figure out the real type.
+ */
+typedef void range_seg_t;
+
+struct range_tree_ops {
+	void    (*rtop_create)(range_tree_t *rt, void *arg);
+	void    (*rtop_destroy)(range_tree_t *rt, void *arg);
+	void	(*rtop_add)(range_tree_t *rt, void *rs, void *arg);
+	void    (*rtop_remove)(range_tree_t *rt, void *rs, void *arg);
+	void	(*rtop_vacate)(range_tree_t *rt, void *arg);
+};
+
+static inline uint64_t
+rs_get_start_raw(const range_seg_t *rs, const range_tree_t *rt)
+{
+	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	switch (rt->rt_type) {
+	case RANGE_SEG32:
+		return (((const range_seg32_t *)rs)->rs_start);
+	case RANGE_SEG64:
+		return (((const range_seg64_t *)rs)->rs_start);
+	case RANGE_SEG_GAP:
+		return (((const range_seg_gap_t *)rs)->rs_start);
+	default:
+		VERIFY(0);
+		return (0);
+	}
+}
+
+static inline uint64_t
+rs_get_end_raw(const range_seg_t *rs, const range_tree_t *rt)
+{
+	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	switch (rt->rt_type) {
+	case RANGE_SEG32:
+		return (((const range_seg32_t *)rs)->rs_end);
+	case RANGE_SEG64:
+		return (((const range_seg64_t *)rs)->rs_end);
+	case RANGE_SEG_GAP:
+		return (((const range_seg_gap_t *)rs)->rs_end);
+	default:
+		VERIFY(0);
+		return (0);
+	}
+}
+
+static inline uint64_t
+rs_get_fill_raw(const range_seg_t *rs, const range_tree_t *rt)
+{
+	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	switch (rt->rt_type) {
+	case RANGE_SEG32: {
+		const range_seg32_t *r32 = (const range_seg32_t *)rs;
+		return (r32->rs_end - r32->rs_start);
+	}
+	case RANGE_SEG64: {
+		const range_seg64_t *r64 = (const range_seg64_t *)rs;
+		return (r64->rs_end - r64->rs_start);
+	}
+	case RANGE_SEG_GAP:
+		return (((const range_seg_gap_t *)rs)->rs_fill);
+	default:
+		VERIFY(0);
+		return (0);
+	}
+
+}
+
+static inline uint64_t
+rs_get_start(const range_seg_t *rs, const range_tree_t *rt)
+{
+	return ((rs_get_start_raw(rs, rt) << rt->rt_shift) + rt->rt_start);
+}
+
+static inline uint64_t
+rs_get_end(const range_seg_t *rs, const range_tree_t *rt)
+{
+	return ((rs_get_end_raw(rs, rt) << rt->rt_shift) + rt->rt_start);
+}
+
+static inline uint64_t
+rs_get_fill(const range_seg_t *rs, const range_tree_t *rt)
+{
+	return (rs_get_fill_raw(rs, rt) << rt->rt_shift);
+}
+
+static inline void
+rs_set_start_raw(range_seg_t *rs, range_tree_t *rt, uint64_t start)
+{
+	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	switch (rt->rt_type) {
+	case RANGE_SEG32:
+		ASSERT3U(start, <=, UINT32_MAX);
+		((range_seg32_t *)rs)->rs_start = (uint32_t)start;
+		break;
+	case RANGE_SEG64:
+		((range_seg64_t *)rs)->rs_start = start;
+		break;
+	case RANGE_SEG_GAP:
+		((range_seg_gap_t *)rs)->rs_start = start;
+		break;
+	default:
+		VERIFY(0);
+	}
+}
+
+static inline void
+rs_set_end_raw(range_seg_t *rs, range_tree_t *rt, uint64_t end)
+{
+	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	switch (rt->rt_type) {
+	case RANGE_SEG32:
+		ASSERT3U(end, <=, UINT32_MAX);
+		((range_seg32_t *)rs)->rs_end = (uint32_t)end;
+		break;
+	case RANGE_SEG64:
+		((range_seg64_t *)rs)->rs_end = end;
+		break;
+	case RANGE_SEG_GAP:
+		((range_seg_gap_t *)rs)->rs_end = end;
+		break;
+	default:
+		VERIFY(0);
+	}
+}
+
+static inline void
+rs_set_fill_raw(range_seg_t *rs, range_tree_t *rt, uint64_t fill)
+{
+	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	switch (rt->rt_type) {
+	case RANGE_SEG32:
+		/* fall through */
+	case RANGE_SEG64:
+		ASSERT3U(fill, ==, rs_get_end_raw(rs, rt) - rs_get_start_raw(rs,
+		    rt));
+		break;
+	case RANGE_SEG_GAP:
+		((range_seg_gap_t *)rs)->rs_fill = fill;
+		break;
+	default:
+		VERIFY(0);
+	}
+}
+
+static inline void
+rs_set_start(range_seg_t *rs, range_tree_t *rt, uint64_t start)
+{
+	ASSERT3U(start, >=, rt->rt_start);
+	ASSERT(IS_P2ALIGNED(start, 1ULL << rt->rt_shift));
+	rs_set_start_raw(rs, rt, (start - rt->rt_start) >> rt->rt_shift);
+}
+
+static inline void
+rs_set_end(range_seg_t *rs, range_tree_t *rt, uint64_t end)
+{
+	ASSERT3U(end, >=, rt->rt_start);
+	ASSERT(IS_P2ALIGNED(end, 1ULL << rt->rt_shift));
+	rs_set_end_raw(rs, rt, (end - rt->rt_start) >> rt->rt_shift);
+}
+
+static inline void
+rs_set_fill(range_seg_t *rs, range_tree_t *rt, uint64_t fill)
+{
+	ASSERT(IS_P2ALIGNED(fill, 1ULL << rt->rt_shift));
+	rs_set_fill_raw(rs, rt, fill >> rt->rt_shift);
+}
+
+typedef void range_tree_func_t(void *arg, uint64_t start, uint64_t size);
+
+range_tree_t *range_tree_create_impl(range_tree_ops_t *ops,
+    range_seg_type_t type, void *arg, uint64_t start, uint64_t shift,
+    int (*zfs_btree_compare) (const void *, const void *), uint64_t gap);
+range_tree_t *range_tree_create(range_tree_ops_t *ops, range_seg_type_t type,
+    void *arg, uint64_t start, uint64_t shift);
+void range_tree_destroy(range_tree_t *rt);
+boolean_t range_tree_contains(range_tree_t *rt, uint64_t start, uint64_t size);
+range_seg_t *range_tree_find(range_tree_t *rt, uint64_t start, uint64_t size);
+boolean_t range_tree_find_in(range_tree_t *rt, uint64_t start, uint64_t size,
+    uint64_t *ostart, uint64_t *osize);
+void range_tree_verify_not_present(range_tree_t *rt,
+    uint64_t start, uint64_t size);
+void range_tree_resize_segment(range_tree_t *rt, range_seg_t *rs,
+    uint64_t newstart, uint64_t newsize);
+uint64_t range_tree_space(range_tree_t *rt);
+uint64_t range_tree_numsegs(range_tree_t *rt);
+boolean_t range_tree_is_empty(range_tree_t *rt);
+void range_tree_swap(range_tree_t **rtsrc, range_tree_t **rtdst);
+void range_tree_stat_verify(range_tree_t *rt);
+uint64_t range_tree_min(range_tree_t *rt);
+uint64_t range_tree_max(range_tree_t *rt);
+uint64_t range_tree_span(range_tree_t *rt);
+
+void range_tree_add(void *arg, uint64_t start, uint64_t size);
+void range_tree_remove(void *arg, uint64_t start, uint64_t size);
+void range_tree_remove_fill(range_tree_t *rt, uint64_t start, uint64_t size);
+void range_tree_adjust_fill(range_tree_t *rt, range_seg_t *rs, int64_t delta);
+void range_tree_clear(range_tree_t *rt, uint64_t start, uint64_t size);
+
+void range_tree_vacate(range_tree_t *rt, range_tree_func_t *func, void *arg);
+void range_tree_walk(range_tree_t *rt, range_tree_func_t *func, void *arg);
+range_seg_t *range_tree_first(range_tree_t *rt);
+
+void range_tree_remove_xor_add_segment(uint64_t start, uint64_t end,
+    range_tree_t *removefrom, range_tree_t *addto);
+void range_tree_remove_xor_add(range_tree_t *rt, range_tree_t *removefrom,
+    range_tree_t *addto);
+
+void rt_btree_create(range_tree_t *rt, void *arg);
+void rt_btree_destroy(range_tree_t *rt, void *arg);
+void rt_btree_add(range_tree_t *rt, range_seg_t *rs, void *arg);
+void rt_btree_remove(range_tree_t *rt, range_seg_t *rs, void *arg);
+void rt_btree_vacate(range_tree_t *rt, void *arg);
+extern range_tree_ops_t rt_btree_ops;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_RANGE_TREE_H */
diff --git a/include/sys/rrwlock.h b/include/sys/rrwlock.h
new file mode 100644
index 0000000000000..8d296ef28ffac
--- /dev/null
+++ b/include/sys/rrwlock.h
@@ -0,0 +1,117 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*
+ * Copyright (c) 2012 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_RR_RW_LOCK_H
+#define	_SYS_RR_RW_LOCK_H
+
+
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <sys/inttypes.h>
+#include <sys/zfs_context.h>
+#include <sys/zfs_refcount.h>
+
+extern uint_t rrw_tsd_key;
+
+/*
+ * A reader-writer lock implementation that allows re-entrant reads, but
+ * still gives writers priority on "new" reads.
+ *
+ * See rrwlock.c for more details about the implementation.
+ *
+ * Fields of the rrwlock_t structure:
+ * - rr_lock: protects modification and reading of rrwlock_t fields
+ * - rr_cv: cv for waking up readers or waiting writers
+ * - rr_writer: thread id of the current writer
+ * - rr_anon_rount: number of active anonymous readers
+ * - rr_linked_rcount: total number of non-anonymous active readers
+ * - rr_writer_wanted: a writer wants the lock
+ */
+typedef struct rrwlock {
+	kmutex_t	rr_lock;
+	kcondvar_t	rr_cv;
+	kthread_t	*rr_writer;
+	zfs_refcount_t	rr_anon_rcount;
+	zfs_refcount_t	rr_linked_rcount;
+	boolean_t	rr_writer_wanted;
+	boolean_t	rr_track_all;
+} rrwlock_t;
+
+/*
+ * 'tag' is used in reference counting tracking.  The
+ * 'tag' must be the same in a rrw_enter() as in its
+ * corresponding rrw_exit().
+ */
+void rrw_init(rrwlock_t *rrl, boolean_t track_all);
+void rrw_destroy(rrwlock_t *rrl);
+void rrw_enter(rrwlock_t *rrl, krw_t rw, void *tag);
+void rrw_enter_read(rrwlock_t *rrl, void *tag);
+void rrw_enter_read_prio(rrwlock_t *rrl, void *tag);
+void rrw_enter_write(rrwlock_t *rrl);
+void rrw_exit(rrwlock_t *rrl, void *tag);
+boolean_t rrw_held(rrwlock_t *rrl, krw_t rw);
+void rrw_tsd_destroy(void *arg);
+
+#define	RRW_READ_HELD(x)	rrw_held(x, RW_READER)
+#define	RRW_WRITE_HELD(x)	rrw_held(x, RW_WRITER)
+#define	RRW_LOCK_HELD(x) \
+	(rrw_held(x, RW_WRITER) || rrw_held(x, RW_READER))
+
+/*
+ * A reader-mostly lock implementation, tuning above reader-writer locks
+ * for hightly parallel read acquisitions, pessimizing write acquisitions.
+ *
+ * This should be a prime number.  See comment in rrwlock.c near
+ * RRM_TD_LOCK() for details.
+ */
+#define	RRM_NUM_LOCKS		17
+typedef struct rrmlock {
+	rrwlock_t	locks[RRM_NUM_LOCKS];
+} rrmlock_t;
+
+void rrm_init(rrmlock_t *rrl, boolean_t track_all);
+void rrm_destroy(rrmlock_t *rrl);
+void rrm_enter(rrmlock_t *rrl, krw_t rw, void *tag);
+void rrm_enter_read(rrmlock_t *rrl, void *tag);
+void rrm_enter_write(rrmlock_t *rrl);
+void rrm_exit(rrmlock_t *rrl, void *tag);
+boolean_t rrm_held(rrmlock_t *rrl, krw_t rw);
+
+#define	RRM_READ_HELD(x)	rrm_held(x, RW_READER)
+#define	RRM_WRITE_HELD(x)	rrm_held(x, RW_WRITER)
+#define	RRM_LOCK_HELD(x) \
+	(rrm_held(x, RW_WRITER) || rrm_held(x, RW_READER))
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_RR_RW_LOCK_H */
diff --git a/include/sys/sa.h b/include/sys/sa.h
new file mode 100644
index 0000000000000..432e0bc415c9a
--- /dev/null
+++ b/include/sys/sa.h
@@ -0,0 +1,174 @@
+/*
+ * 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) 2010, Oracle and/or its affiliates. All rights reserved.
+ */
+
+#ifndef	_SYS_SA_H
+#define	_SYS_SA_H
+
+#include <sys/dmu.h>
+
+/*
+ * Currently available byteswap functions.
+ * If it all possible new attributes should used
+ * one of the already defined byteswap functions.
+ * If a new byteswap function is added then the
+ * ZPL/Pool version will need to be bumped.
+ */
+
+typedef enum sa_bswap_type {
+	SA_UINT64_ARRAY,
+	SA_UINT32_ARRAY,
+	SA_UINT16_ARRAY,
+	SA_UINT8_ARRAY,
+	SA_ACL,
+} sa_bswap_type_t;
+
+typedef uint16_t	sa_attr_type_t;
+
+/*
+ * Attribute to register support for.
+ */
+typedef struct sa_attr_reg {
+	char 			*sa_name;	/* attribute name */
+	uint16_t 		sa_length;
+	sa_bswap_type_t		sa_byteswap;	/* bswap function enum */
+	sa_attr_type_t 		sa_attr; /* filled in during registration */
+} sa_attr_reg_t;
+
+
+typedef void (sa_data_locator_t)(void **, uint32_t *, uint32_t,
+    boolean_t, void *userptr);
+
+/*
+ * array of attributes to store.
+ *
+ * This array should be treated as opaque/private data.
+ * The SA_BULK_ADD_ATTR() macro should be used for manipulating
+ * the array.
+ *
+ * When sa_replace_all_by_template() is used the attributes
+ * will be stored in the order defined in the array, except that
+ * the attributes may be split between the bonus and the spill buffer
+ *
+ */
+typedef struct sa_bulk_attr {
+	void			*sa_data;
+	sa_data_locator_t	*sa_data_func;
+	uint16_t		sa_length;
+	sa_attr_type_t		sa_attr;
+	/* the following are private to the sa framework */
+	void 			*sa_addr;
+	uint16_t		sa_buftype;
+	uint16_t		sa_size;
+} sa_bulk_attr_t;
+
+/*
+ * The on-disk format of sa_hdr_phys_t limits SA lengths to 16-bit values.
+ */
+#define	SA_ATTR_MAX_LEN UINT16_MAX
+
+/*
+ * special macro for adding entries for bulk attr support
+ * bulk - sa_bulk_attr_t
+ * count - integer that will be incremented during each add
+ * attr - attribute to manipulate
+ * func - function for accessing data.
+ * data - pointer to data.
+ * len - length of data
+ */
+
+#define	SA_ADD_BULK_ATTR(b, idx, attr, func, data, len) \
+{ \
+	ASSERT3U(len, <=, SA_ATTR_MAX_LEN); \
+	b[idx].sa_attr = attr;\
+	b[idx].sa_data_func = func; \
+	b[idx].sa_data = data; \
+	b[idx++].sa_length = len; \
+}
+
+typedef struct sa_os sa_os_t;
+
+typedef enum sa_handle_type {
+	SA_HDL_SHARED,
+	SA_HDL_PRIVATE
+} sa_handle_type_t;
+
+struct sa_handle;
+typedef void *sa_lookup_tab_t;
+typedef struct sa_handle sa_handle_t;
+
+typedef void (sa_update_cb_t)(sa_handle_t *, dmu_tx_t *tx);
+
+int sa_handle_get(objset_t *, uint64_t, void *userp,
+    sa_handle_type_t, sa_handle_t **);
+int sa_handle_get_from_db(objset_t *, dmu_buf_t *, void *userp,
+    sa_handle_type_t, sa_handle_t **);
+void sa_handle_destroy(sa_handle_t *);
+int sa_buf_hold(objset_t *, uint64_t, void *, dmu_buf_t **);
+void sa_buf_rele(dmu_buf_t *, void *);
+int sa_lookup(sa_handle_t *, sa_attr_type_t, void *buf, uint32_t buflen);
+int sa_update(sa_handle_t *, sa_attr_type_t, void *buf,
+    uint32_t buflen, dmu_tx_t *);
+int sa_remove(sa_handle_t *, sa_attr_type_t, dmu_tx_t *);
+int sa_bulk_lookup(sa_handle_t *, sa_bulk_attr_t *, int count);
+int sa_bulk_lookup_locked(sa_handle_t *, sa_bulk_attr_t *, int count);
+int sa_bulk_update(sa_handle_t *, sa_bulk_attr_t *, int count, dmu_tx_t *);
+int sa_size(sa_handle_t *, sa_attr_type_t, int *);
+void sa_object_info(sa_handle_t *, dmu_object_info_t *);
+void sa_object_size(sa_handle_t *, uint32_t *, u_longlong_t *);
+void *sa_get_userdata(sa_handle_t *);
+void sa_set_userp(sa_handle_t *, void *);
+dmu_buf_t *sa_get_db(sa_handle_t *);
+uint64_t sa_handle_object(sa_handle_t *);
+boolean_t sa_attr_would_spill(sa_handle_t *, sa_attr_type_t, int size);
+void sa_spill_rele(sa_handle_t *);
+void sa_register_update_callback(objset_t *, sa_update_cb_t *);
+int sa_setup(objset_t *, uint64_t, sa_attr_reg_t *, int, sa_attr_type_t **);
+void sa_tear_down(objset_t *);
+int sa_replace_all_by_template(sa_handle_t *, sa_bulk_attr_t *,
+    int, dmu_tx_t *);
+int sa_replace_all_by_template_locked(sa_handle_t *, sa_bulk_attr_t *,
+    int, dmu_tx_t *);
+boolean_t sa_enabled(objset_t *);
+void sa_cache_init(void);
+void sa_cache_fini(void);
+int sa_set_sa_object(objset_t *, uint64_t);
+int sa_hdrsize(void *);
+void sa_handle_lock(sa_handle_t *);
+void sa_handle_unlock(sa_handle_t *);
+
+#ifdef _KERNEL
+int sa_lookup_uio(sa_handle_t *, sa_attr_type_t, uio_t *);
+int sa_add_projid(sa_handle_t *, dmu_tx_t *, uint64_t);
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_SA_H */
diff --git a/include/sys/sa_impl.h b/include/sys/sa_impl.h
new file mode 100644
index 0000000000000..fa10aff8a3064
--- /dev/null
+++ b/include/sys/sa_impl.h
@@ -0,0 +1,289 @@
+/*
+ * 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) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013 by Delphix. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ */
+
+#ifndef	_SYS_SA_IMPL_H
+#define	_SYS_SA_IMPL_H
+
+#include <sys/dmu.h>
+#include <sys/zfs_refcount.h>
+#include <sys/list.h>
+
+/*
+ * Array of known attributes and their
+ * various characteristics.
+ */
+typedef struct sa_attr_table {
+	sa_attr_type_t	sa_attr;
+	uint8_t sa_registered;
+	uint16_t sa_length;
+	sa_bswap_type_t sa_byteswap;
+	char *sa_name;
+} sa_attr_table_t;
+
+/*
+ * Zap attribute format for attribute registration
+ *
+ * 64      56      48      40      32      24      16      8       0
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * |        unused         |      len      | bswap |   attr num    |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ *
+ * Zap attribute format for layout information.
+ *
+ * layout information is stored as an array of attribute numbers
+ * The name of the attribute is the layout number (0, 1, 2, ...)
+ *
+ * 16       0
+ * +---- ---+
+ * | attr # |
+ * +--------+
+ * | attr # |
+ * +--- ----+
+ *  ......
+ *
+ */
+
+#define	ATTR_BSWAP(x)	BF32_GET(x, 16, 8)
+#define	ATTR_LENGTH(x)	BF32_GET(x, 24, 16)
+#define	ATTR_NUM(x)	BF32_GET(x, 0, 16)
+#define	ATTR_ENCODE(x, attr, length, bswap) \
+{ \
+	BF64_SET(x, 24, 16, length); \
+	BF64_SET(x, 16, 8, bswap); \
+	BF64_SET(x, 0, 16, attr); \
+}
+
+#define	TOC_OFF(x)		BF32_GET(x, 0, 23)
+#define	TOC_ATTR_PRESENT(x)	BF32_GET(x, 31, 1)
+#define	TOC_LEN_IDX(x)		BF32_GET(x, 24, 4)
+#define	TOC_ATTR_ENCODE(x, len_idx, offset) \
+{ \
+	BF32_SET(x, 31, 1, 1); \
+	BF32_SET(x, 24, 7, len_idx); \
+	BF32_SET(x, 0, 24, offset); \
+}
+
+#define	SA_LAYOUTS	"LAYOUTS"
+#define	SA_REGISTRY	"REGISTRY"
+
+/*
+ * Each unique layout will have their own table
+ * sa_lot (layout_table)
+ */
+typedef struct sa_lot {
+	avl_node_t lot_num_node;
+	avl_node_t lot_hash_node;
+	uint64_t lot_num;
+	uint64_t lot_hash;
+	sa_attr_type_t *lot_attrs;	/* array of attr #'s */
+	uint32_t lot_var_sizes;	/* how many aren't fixed size */
+	uint32_t lot_attr_count;	/* total attr count */
+	list_t 	lot_idx_tab;	/* should be only a couple of entries */
+	int	lot_instance;	/* used with lot_hash to identify entry */
+} sa_lot_t;
+
+/* index table of offsets */
+typedef struct sa_idx_tab {
+	list_node_t	sa_next;
+	sa_lot_t	*sa_layout;
+	uint16_t	*sa_variable_lengths;
+	zfs_refcount_t	sa_refcount;
+	uint32_t	*sa_idx_tab;	/* array of offsets */
+} sa_idx_tab_t;
+
+/*
+ * Since the offset/index information into the actual data
+ * will usually be identical we can share that information with
+ * all handles that have the exact same offsets.
+ *
+ * You would typically only have a large number of different table of
+ * contents if you had a several variable sized attributes.
+ *
+ * Two AVL trees are used to track the attribute layout numbers.
+ * one is keyed by number and will be consulted when a DMU_OT_SA
+ * object is first read.  The second tree is keyed by the hash signature
+ * of the attributes and will be consulted when an attribute is added
+ * to determine if we already have an instance of that layout.  Both
+ * of these tree's are interconnected.  The only difference is that
+ * when an entry is found in the "hash" tree the list of attributes will
+ * need to be compared against the list of attributes you have in hand.
+ * The assumption is that typically attributes will just be updated and
+ * adding a completely new attribute is a very rare operation.
+ */
+struct sa_os {
+	kmutex_t 	sa_lock;
+	boolean_t	sa_need_attr_registration;
+	boolean_t	sa_force_spill;
+	uint64_t	sa_master_obj;
+	uint64_t	sa_reg_attr_obj;
+	uint64_t	sa_layout_attr_obj;
+	int		sa_num_attrs;
+	sa_attr_table_t *sa_attr_table;	 /* private attr table */
+	sa_update_cb_t	*sa_update_cb;
+	avl_tree_t	sa_layout_num_tree;  /* keyed by layout number */
+	avl_tree_t	sa_layout_hash_tree; /* keyed by layout hash value */
+	int		sa_user_table_sz;
+	sa_attr_type_t	*sa_user_table; /* user name->attr mapping table */
+};
+
+/*
+ * header for all bonus and spill buffers.
+ *
+ * The header has a fixed portion with a variable number
+ * of "lengths" depending on the number of variable sized
+ * attributes which are determined by the "layout number"
+ */
+
+#define	SA_MAGIC	0x2F505A  /* ZFS SA */
+typedef struct sa_hdr_phys {
+	uint32_t sa_magic;
+	/*
+	 * Encoded with hdrsize and layout number as follows:
+	 * 16      10       0
+	 * +--------+-------+
+	 * | hdrsz  |layout |
+	 * +--------+-------+
+	 *
+	 * Bits 0-10 are the layout number
+	 * Bits 11-16 are the size of the header.
+	 * The hdrsize is the number * 8
+	 *
+	 * For example.
+	 * hdrsz of 1 ==> 8 byte header
+	 *          2 ==> 16 byte header
+	 *
+	 */
+	uint16_t sa_layout_info;
+	uint16_t sa_lengths[1];	/* optional sizes for variable length attrs */
+	/* ... Data follows the lengths.  */
+} sa_hdr_phys_t;
+
+#define	SA_HDR_LAYOUT_NUM(hdr) BF32_GET(hdr->sa_layout_info, 0, 10)
+#define	SA_HDR_SIZE(hdr) BF32_GET_SB(hdr->sa_layout_info, 10, 6, 3, 0)
+#define	SA_HDR_LAYOUT_INFO_ENCODE(x, num, size) \
+{ \
+	BF32_SET_SB(x, 10, 6, 3, 0, size); \
+	BF32_SET(x, 0, 10, num); \
+}
+
+typedef enum sa_buf_type {
+	SA_BONUS = 1,
+	SA_SPILL = 2
+} sa_buf_type_t;
+
+typedef enum sa_data_op {
+	SA_LOOKUP,
+	SA_UPDATE,
+	SA_ADD,
+	SA_REPLACE,
+	SA_REMOVE
+} sa_data_op_t;
+
+/*
+ * Opaque handle used for most sa functions
+ *
+ * This needs to be kept as small as possible.
+ */
+
+struct sa_handle {
+	dmu_buf_user_t	sa_dbu;
+	kmutex_t	sa_lock;
+	dmu_buf_t	*sa_bonus;
+	dmu_buf_t	*sa_spill;
+	objset_t	*sa_os;
+	void		*sa_userp;
+	sa_idx_tab_t	*sa_bonus_tab;	 /* idx of bonus */
+	sa_idx_tab_t	*sa_spill_tab; /* only present if spill activated */
+};
+
+#define	SA_GET_DB(hdl, type)	\
+	(dmu_buf_impl_t *)((type == SA_BONUS) ? hdl->sa_bonus : hdl->sa_spill)
+
+#define	SA_GET_HDR(hdl, type) \
+	((sa_hdr_phys_t *)((dmu_buf_impl_t *)(SA_GET_DB(hdl, \
+	type))->db.db_data))
+
+#define	SA_IDX_TAB_GET(hdl, type) \
+	(type == SA_BONUS ? hdl->sa_bonus_tab : hdl->sa_spill_tab)
+
+#define	IS_SA_BONUSTYPE(a)	\
+	((a == DMU_OT_SA) ? B_TRUE : B_FALSE)
+
+#define	SA_BONUSTYPE_FROM_DB(db) \
+	(dmu_get_bonustype((dmu_buf_t *)db))
+
+#define	SA_BLKPTR_SPACE	(DN_OLD_MAX_BONUSLEN - sizeof (blkptr_t))
+
+#define	SA_LAYOUT_NUM(x, type) \
+	((!IS_SA_BONUSTYPE(type) ? 0 : (((IS_SA_BONUSTYPE(type)) && \
+	((SA_HDR_LAYOUT_NUM(x)) == 0)) ? 1 : SA_HDR_LAYOUT_NUM(x))))
+
+
+#define	SA_REGISTERED_LEN(sa, attr) sa->sa_attr_table[attr].sa_length
+
+#define	SA_ATTR_LEN(sa, idx, attr, hdr) ((SA_REGISTERED_LEN(sa, attr) == 0) ?\
+	hdr->sa_lengths[TOC_LEN_IDX(idx->sa_idx_tab[attr])] : \
+	SA_REGISTERED_LEN(sa, attr))
+
+#define	SA_SET_HDR(hdr, num, size) \
+	{ \
+		hdr->sa_magic = SA_MAGIC; \
+		SA_HDR_LAYOUT_INFO_ENCODE(hdr->sa_layout_info, num, size); \
+	}
+
+#define	SA_ATTR_INFO(sa, idx, hdr, attr, bulk, type, hdl) \
+	{ \
+		bulk.sa_size = SA_ATTR_LEN(sa, idx, attr, hdr); \
+		bulk.sa_buftype = type; \
+		bulk.sa_addr = \
+		    (void *)((uintptr_t)TOC_OFF(idx->sa_idx_tab[attr]) + \
+		    (uintptr_t)hdr); \
+}
+
+#define	SA_HDR_SIZE_MATCH_LAYOUT(hdr, tb) \
+	(SA_HDR_SIZE(hdr) == (sizeof (sa_hdr_phys_t) + \
+	(tb->lot_var_sizes > 1 ? P2ROUNDUP((tb->lot_var_sizes - 1) * \
+	sizeof (uint16_t), 8) : 0)))
+
+int sa_add_impl(sa_handle_t *, sa_attr_type_t,
+    uint32_t, sa_data_locator_t, void *, dmu_tx_t *);
+
+void sa_register_update_callback_locked(objset_t *, sa_update_cb_t *);
+int sa_size_locked(sa_handle_t *, sa_attr_type_t, int *);
+
+void sa_default_locator(void **, uint32_t *, uint32_t, boolean_t, void *);
+int sa_attr_size(sa_os_t *, sa_idx_tab_t *, sa_attr_type_t,
+    uint16_t *, sa_hdr_phys_t *);
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_SA_IMPL_H */
diff --git a/include/sys/skein.h b/include/sys/skein.h
new file mode 100644
index 0000000000000..2f649d6b269a1
--- /dev/null
+++ b/include/sys/skein.h
@@ -0,0 +1,183 @@
+/*
+ * Interface declarations for Skein hashing.
+ * Source code author: Doug Whiting, 2008.
+ * This algorithm and source code is released to the public domain.
+ *
+ * The following compile-time switches may be defined to control some
+ * tradeoffs between speed, code size, error checking, and security.
+ *
+ * The "default" note explains what happens when the switch is not defined.
+ *
+ *  SKEIN_DEBUG            -- make callouts from inside Skein code
+ *                            to examine/display intermediate values.
+ *                            [default: no callouts (no overhead)]
+ *
+ *  SKEIN_ERR_CHECK        -- how error checking is handled inside Skein
+ *                            code. If not defined, most error checking
+ *                            is disabled (for performance). Otherwise,
+ *                            the switch value is interpreted as:
+ *                                0: use assert()      to flag errors
+ *                                1: return SKEIN_FAIL to flag errors
+ */
+/* Copyright 2013 Doug Whiting. This code is released to the public domain. */
+#ifndef	_SYS_SKEIN_H_
+#define	_SYS_SKEIN_H_
+
+#ifdef  _KERNEL
+#include <sys/types.h>		/* get size_t definition */
+#else
+#include <stdint.h>
+#include <stdlib.h>
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+enum {
+	SKEIN_SUCCESS = 0,	/* return codes from Skein calls */
+	SKEIN_FAIL = 1,
+	SKEIN_BAD_HASHLEN = 2
+};
+
+#define	SKEIN_MODIFIER_WORDS	(2)	/* number of modifier (tweak) words */
+
+#define	SKEIN_256_STATE_WORDS	(4)
+#define	SKEIN_512_STATE_WORDS	(8)
+#define	SKEIN1024_STATE_WORDS	(16)
+#define	SKEIN_MAX_STATE_WORDS	(16)
+
+#define	SKEIN_256_STATE_BYTES	(8 * SKEIN_256_STATE_WORDS)
+#define	SKEIN_512_STATE_BYTES	(8 * SKEIN_512_STATE_WORDS)
+#define	SKEIN1024_STATE_BYTES	(8 * SKEIN1024_STATE_WORDS)
+
+#define	SKEIN_256_STATE_BITS	(64 * SKEIN_256_STATE_WORDS)
+#define	SKEIN_512_STATE_BITS	(64 * SKEIN_512_STATE_WORDS)
+#define	SKEIN1024_STATE_BITS	(64 * SKEIN1024_STATE_WORDS)
+
+#define	SKEIN_256_BLOCK_BYTES	(8 * SKEIN_256_STATE_WORDS)
+#define	SKEIN_512_BLOCK_BYTES	(8 * SKEIN_512_STATE_WORDS)
+#define	SKEIN1024_BLOCK_BYTES	(8 * SKEIN1024_STATE_WORDS)
+
+typedef struct {
+	size_t hashBitLen;	/* size of hash result, in bits */
+	size_t bCnt;		/* current byte count in buffer b[] */
+	/* tweak words: T[0]=byte cnt, T[1]=flags */
+	uint64_t T[SKEIN_MODIFIER_WORDS];
+} Skein_Ctxt_Hdr_t;
+
+typedef struct {		/*  256-bit Skein hash context structure */
+	Skein_Ctxt_Hdr_t h;	/* common header context variables */
+	uint64_t X[SKEIN_256_STATE_WORDS];	/* chaining variables */
+	/* partial block buffer (8-byte aligned) */
+	uint8_t b[SKEIN_256_BLOCK_BYTES];
+} Skein_256_Ctxt_t;
+
+typedef struct {		/*  512-bit Skein hash context structure */
+	Skein_Ctxt_Hdr_t h;	/* common header context variables */
+	uint64_t X[SKEIN_512_STATE_WORDS];	/* chaining variables */
+	/* partial block buffer (8-byte aligned) */
+	uint8_t b[SKEIN_512_BLOCK_BYTES];
+} Skein_512_Ctxt_t;
+
+typedef struct {		/* 1024-bit Skein hash context structure */
+	Skein_Ctxt_Hdr_t h;	/* common header context variables */
+	uint64_t X[SKEIN1024_STATE_WORDS];	/* chaining variables */
+	/* partial block buffer (8-byte aligned) */
+	uint8_t b[SKEIN1024_BLOCK_BYTES];
+} Skein1024_Ctxt_t;
+
+/*   Skein APIs for (incremental) "straight hashing" */
+int Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen);
+int Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen);
+int Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen);
+
+int Skein_256_Update(Skein_256_Ctxt_t *ctx, const uint8_t *msg,
+    size_t msgByteCnt);
+int Skein_512_Update(Skein_512_Ctxt_t *ctx, const uint8_t *msg,
+    size_t msgByteCnt);
+int Skein1024_Update(Skein1024_Ctxt_t *ctx, const uint8_t *msg,
+    size_t msgByteCnt);
+
+int Skein_256_Final(Skein_256_Ctxt_t *ctx, uint8_t *hashVal);
+int Skein_512_Final(Skein_512_Ctxt_t *ctx, uint8_t *hashVal);
+int Skein1024_Final(Skein1024_Ctxt_t *ctx, uint8_t *hashVal);
+
+/*
+ * Skein APIs for "extended" initialization: MAC keys, tree hashing.
+ * After an InitExt() call, just use Update/Final calls as with Init().
+ *
+ * Notes: Same parameters as _Init() calls, plus treeInfo/key/keyBytes.
+ *          When keyBytes == 0 and treeInfo == SKEIN_SEQUENTIAL,
+ *              the results of InitExt() are identical to calling Init().
+ *          The function Init() may be called once to "precompute" the IV for
+ *              a given hashBitLen value, then by saving a copy of the context
+ *              the IV computation may be avoided in later calls.
+ *          Similarly, the function InitExt() may be called once per MAC key
+ *              to precompute the MAC IV, then a copy of the context saved and
+ *              reused for each new MAC computation.
+ */
+int Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen,
+    uint64_t treeInfo, const uint8_t *key, size_t keyBytes);
+int Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen,
+    uint64_t treeInfo, const uint8_t *key, size_t keyBytes);
+int Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen,
+    uint64_t treeInfo, const uint8_t *key, size_t keyBytes);
+
+/*
+ * Skein APIs for MAC and tree hash:
+ *	Final_Pad: pad, do final block, but no OUTPUT type
+ *	Output:    do just the output stage
+ */
+int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, uint8_t *hashVal);
+int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, uint8_t *hashVal);
+int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, uint8_t *hashVal);
+
+#ifndef	SKEIN_TREE_HASH
+#define	SKEIN_TREE_HASH (1)
+#endif
+#if	SKEIN_TREE_HASH
+int Skein_256_Output(Skein_256_Ctxt_t *ctx, uint8_t *hashVal);
+int Skein_512_Output(Skein_512_Ctxt_t *ctx, uint8_t *hashVal);
+int Skein1024_Output(Skein1024_Ctxt_t *ctx, uint8_t *hashVal);
+#endif
+
+/*
+ * When you initialize a Skein KCF hashing method you can pass this param
+ * structure in cm_param to fine-tune the algorithm's defaults.
+ */
+typedef struct skein_param {
+	size_t	sp_digest_bitlen;		/* length of digest in bits */
+} skein_param_t;
+
+/* Module definitions */
+#ifdef	SKEIN_MODULE_IMPL
+#define	CKM_SKEIN_256				"CKM_SKEIN_256"
+#define	CKM_SKEIN_512				"CKM_SKEIN_512"
+#define	CKM_SKEIN1024				"CKM_SKEIN1024"
+#define	CKM_SKEIN_256_MAC			"CKM_SKEIN_256_MAC"
+#define	CKM_SKEIN_512_MAC			"CKM_SKEIN_512_MAC"
+#define	CKM_SKEIN1024_MAC			"CKM_SKEIN1024_MAC"
+
+typedef enum skein_mech_type {
+	SKEIN_256_MECH_INFO_TYPE,
+	SKEIN_512_MECH_INFO_TYPE,
+	SKEIN1024_MECH_INFO_TYPE,
+	SKEIN_256_MAC_MECH_INFO_TYPE,
+	SKEIN_512_MAC_MECH_INFO_TYPE,
+	SKEIN1024_MAC_MECH_INFO_TYPE
+} skein_mech_type_t;
+
+#define	VALID_SKEIN_DIGEST_MECH(__mech)				\
+	((int)(__mech) >= SKEIN_256_MECH_INFO_TYPE &&		\
+	(__mech) <= SKEIN1024_MECH_INFO_TYPE)
+#define	VALID_SKEIN_MAC_MECH(__mech)				\
+	((int)(__mech) >= SKEIN_256_MAC_MECH_INFO_TYPE &&	\
+	(__mech) <= SKEIN1024_MAC_MECH_INFO_TYPE)
+#endif	/* SKEIN_MODULE_IMPL */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_SKEIN_H_ */
diff --git a/include/sys/spa.h b/include/sys/spa.h
new file mode 100644
index 0000000000000..e53d0d64c302b
--- /dev/null
+++ b/include/sys/spa.h
@@ -0,0 +1,1224 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2019 by Delphix. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ * Copyright 2013 Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2014 Integros [integros.com]
+ * Copyright 2017 Joyent, Inc.
+ * Copyright (c) 2017, 2019, Datto Inc. All rights reserved.
+ * Copyright (c) 2017, Intel Corporation.
+ * Copyright (c) 2019, Allan Jude
+ * Copyright (c) 2019, Klara Inc.
+ */
+
+#ifndef _SYS_SPA_H
+#define	_SYS_SPA_H
+
+#include <sys/avl.h>
+#include <sys/zfs_context.h>
+#include <sys/kstat.h>
+#include <sys/nvpair.h>
+#include <sys/sysmacros.h>
+#include <sys/types.h>
+#include <sys/fs/zfs.h>
+#include <sys/spa_checksum.h>
+#include <sys/dmu.h>
+#include <sys/space_map.h>
+#include <sys/bitops.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Forward references that lots of things need.
+ */
+typedef struct spa spa_t;
+typedef struct vdev vdev_t;
+typedef struct metaslab metaslab_t;
+typedef struct metaslab_group metaslab_group_t;
+typedef struct metaslab_class metaslab_class_t;
+typedef struct zio zio_t;
+typedef struct zilog zilog_t;
+typedef struct spa_aux_vdev spa_aux_vdev_t;
+typedef struct ddt ddt_t;
+typedef struct ddt_entry ddt_entry_t;
+typedef struct zbookmark_phys zbookmark_phys_t;
+
+struct bpobj;
+struct bplist;
+struct dsl_pool;
+struct dsl_dataset;
+struct dsl_crypto_params;
+
+/*
+ * We currently support block sizes from 512 bytes to 16MB.
+ * The benefits of larger blocks, and thus larger IO, need to be weighed
+ * against the cost of COWing a giant block to modify one byte, and the
+ * large latency of reading or writing a large block.
+ *
+ * Note that although blocks up to 16MB are supported, the recordsize
+ * property can not be set larger than zfs_max_recordsize (default 1MB).
+ * See the comment near zfs_max_recordsize in dsl_dataset.c for details.
+ *
+ * Note that although the LSIZE field of the blkptr_t can store sizes up
+ * to 32MB, the dnode's dn_datablkszsec can only store sizes up to
+ * 32MB - 512 bytes.  Therefore, we limit SPA_MAXBLOCKSIZE to 16MB.
+ */
+#define	SPA_MINBLOCKSHIFT	9
+#define	SPA_OLD_MAXBLOCKSHIFT	17
+#define	SPA_MAXBLOCKSHIFT	24
+#define	SPA_MINBLOCKSIZE	(1ULL << SPA_MINBLOCKSHIFT)
+#define	SPA_OLD_MAXBLOCKSIZE	(1ULL << SPA_OLD_MAXBLOCKSHIFT)
+#define	SPA_MAXBLOCKSIZE	(1ULL << SPA_MAXBLOCKSHIFT)
+
+/*
+ * Alignment Shift (ashift) is an immutable, internal top-level vdev property
+ * which can only be set at vdev creation time. Physical writes are always done
+ * according to it, which makes 2^ashift the smallest possible IO on a vdev.
+ *
+ * We currently allow values ranging from 512 bytes (2^9 = 512) to 64 KiB
+ * (2^16 = 65,536).
+ */
+#define	ASHIFT_MIN		9
+#define	ASHIFT_MAX		16
+
+/*
+ * Size of block to hold the configuration data (a packed nvlist)
+ */
+#define	SPA_CONFIG_BLOCKSIZE	(1ULL << 14)
+
+/*
+ * The DVA size encodings for LSIZE and PSIZE support blocks up to 32MB.
+ * The ASIZE encoding should be at least 64 times larger (6 more bits)
+ * to support up to 4-way RAID-Z mirror mode with worst-case gang block
+ * overhead, three DVAs per bp, plus one more bit in case we do anything
+ * else that expands the ASIZE.
+ */
+#define	SPA_LSIZEBITS		16	/* LSIZE up to 32M (2^16 * 512)	*/
+#define	SPA_PSIZEBITS		16	/* PSIZE up to 32M (2^16 * 512)	*/
+#define	SPA_ASIZEBITS		24	/* ASIZE up to 64 times larger	*/
+
+#define	SPA_COMPRESSBITS	7
+#define	SPA_VDEVBITS		24
+#define	SPA_COMPRESSMASK	((1U << SPA_COMPRESSBITS) - 1)
+
+/*
+ * All SPA data is represented by 128-bit data virtual addresses (DVAs).
+ * The members of the dva_t should be considered opaque outside the SPA.
+ */
+typedef struct dva {
+	uint64_t	dva_word[2];
+} dva_t;
+
+
+/*
+ * Some checksums/hashes need a 256-bit initialization salt. This salt is kept
+ * secret and is suitable for use in MAC algorithms as the key.
+ */
+typedef struct zio_cksum_salt {
+	uint8_t		zcs_bytes[32];
+} zio_cksum_salt_t;
+
+/*
+ * Each block is described by its DVAs, time of birth, checksum, etc.
+ * The word-by-word, bit-by-bit layout of the blkptr is as follows:
+ *
+ *	64	56	48	40	32	24	16	8	0
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 0	|  pad  |	  vdev1         | GRID  |	  ASIZE		|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 1	|G|			 offset1				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 2	|  pad  |	  vdev2         | GRID  |	  ASIZE		|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 3	|G|			 offset2				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 4	|  pad  |	  vdev3         | GRID  |	  ASIZE		|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 5	|G|			 offset3				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 6	|BDX|lvl| type	| cksum |E| comp|    PSIZE	|     LSIZE	|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 7	|			padding					|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 8	|			padding					|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 9	|			physical birth txg			|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * a	|			logical birth txg			|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * b	|			fill count				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * c	|			checksum[0]				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * d	|			checksum[1]				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * e	|			checksum[2]				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * f	|			checksum[3]				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ *
+ * Legend:
+ *
+ * vdev		virtual device ID
+ * offset	offset into virtual device
+ * LSIZE	logical size
+ * PSIZE	physical size (after compression)
+ * ASIZE	allocated size (including RAID-Z parity and gang block headers)
+ * GRID		RAID-Z layout information (reserved for future use)
+ * cksum	checksum function
+ * comp		compression function
+ * G		gang block indicator
+ * B		byteorder (endianness)
+ * D		dedup
+ * X		encryption
+ * E		blkptr_t contains embedded data (see below)
+ * lvl		level of indirection
+ * type		DMU object type
+ * phys birth	txg when dva[0] was written; zero if same as logical birth txg
+ *              note that typically all the dva's would be written in this
+ *              txg, but they could be different if they were moved by
+ *              device removal.
+ * log. birth	transaction group in which the block was logically born
+ * fill count	number of non-zero blocks under this bp
+ * checksum[4]	256-bit checksum of the data this bp describes
+ */
+
+/*
+ * The blkptr_t's of encrypted blocks also need to store the encryption
+ * parameters so that the block can be decrypted. This layout is as follows:
+ *
+ *	64	56	48	40	32	24	16	8	0
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 0	|		vdev1		| GRID  |	  ASIZE		|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 1	|G|			 offset1				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 2	|		vdev2		| GRID  |	  ASIZE		|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 3	|G|			 offset2				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 4	|			salt					|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 5	|			IV1					|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 6	|BDX|lvl| type	| cksum |E| comp|    PSIZE	|     LSIZE	|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 7	|			padding					|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 8	|			padding					|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 9	|			physical birth txg			|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * a	|			logical birth txg			|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * b	|		IV2		|	    fill count		|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * c	|			checksum[0]				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * d	|			checksum[1]				|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * e	|			MAC[0]					|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * f	|			MAC[1]					|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ *
+ * Legend:
+ *
+ * salt		Salt for generating encryption keys
+ * IV1		First 64 bits of encryption IV
+ * X		Block requires encryption handling (set to 1)
+ * E		blkptr_t contains embedded data (set to 0, see below)
+ * fill count	number of non-zero blocks under this bp (truncated to 32 bits)
+ * IV2		Last 32 bits of encryption IV
+ * checksum[2]	128-bit checksum of the data this bp describes
+ * MAC[2]	128-bit message authentication code for this data
+ *
+ * The X bit being set indicates that this block is one of 3 types. If this is
+ * a level 0 block with an encrypted object type, the block is encrypted
+ * (see BP_IS_ENCRYPTED()). If this is a level 0 block with an unencrypted
+ * object type, this block is authenticated with an HMAC (see
+ * BP_IS_AUTHENTICATED()). Otherwise (if level > 0), this bp will use the MAC
+ * words to store a checksum-of-MACs from the level below (see
+ * BP_HAS_INDIRECT_MAC_CKSUM()). For convenience in the code, BP_IS_PROTECTED()
+ * refers to both encrypted and authenticated blocks and BP_USES_CRYPT()
+ * refers to any of these 3 kinds of blocks.
+ *
+ * The additional encryption parameters are the salt, IV, and MAC which are
+ * explained in greater detail in the block comment at the top of zio_crypt.c.
+ * The MAC occupies half of the checksum space since it serves a very similar
+ * purpose: to prevent data corruption on disk. The only functional difference
+ * is that the checksum is used to detect on-disk corruption whether or not the
+ * encryption key is loaded and the MAC provides additional protection against
+ * malicious disk tampering. We use the 3rd DVA to store the salt and first
+ * 64 bits of the IV. As a result encrypted blocks can only have 2 copies
+ * maximum instead of the normal 3. The last 32 bits of the IV are stored in
+ * the upper bits of what is usually the fill count. Note that only blocks at
+ * level 0 or -2 are ever encrypted, which allows us to guarantee that these
+ * 32 bits are not trampled over by other code (see zio_crypt.c for details).
+ * The salt and IV are not used for authenticated bps or bps with an indirect
+ * MAC checksum, so these blocks can utilize all 3 DVAs and the full 64 bits
+ * for the fill count.
+ */
+
+/*
+ * "Embedded" blkptr_t's don't actually point to a block, instead they
+ * have a data payload embedded in the blkptr_t itself.  See the comment
+ * in blkptr.c for more details.
+ *
+ * The blkptr_t is laid out as follows:
+ *
+ *	64	56	48	40	32	24	16	8	0
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 0	|      payload                                                  |
+ * 1	|      payload                                                  |
+ * 2	|      payload                                                  |
+ * 3	|      payload                                                  |
+ * 4	|      payload                                                  |
+ * 5	|      payload                                                  |
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 6	|BDX|lvl| type	| etype |E| comp| PSIZE|              LSIZE	|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * 7	|      payload                                                  |
+ * 8	|      payload                                                  |
+ * 9	|      payload                                                  |
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * a	|			logical birth txg			|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ * b	|      payload                                                  |
+ * c	|      payload                                                  |
+ * d	|      payload                                                  |
+ * e	|      payload                                                  |
+ * f	|      payload                                                  |
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ *
+ * Legend:
+ *
+ * payload		contains the embedded data
+ * B (byteorder)	byteorder (endianness)
+ * D (dedup)		padding (set to zero)
+ * X			encryption (set to zero)
+ * E (embedded)		set to one
+ * lvl			indirection level
+ * type			DMU object type
+ * etype		how to interpret embedded data (BP_EMBEDDED_TYPE_*)
+ * comp			compression function of payload
+ * PSIZE		size of payload after compression, in bytes
+ * LSIZE		logical size of payload, in bytes
+ *			note that 25 bits is enough to store the largest
+ *			"normal" BP's LSIZE (2^16 * 2^9) in bytes
+ * log. birth		transaction group in which the block was logically born
+ *
+ * Note that LSIZE and PSIZE are stored in bytes, whereas for non-embedded
+ * bp's they are stored in units of SPA_MINBLOCKSHIFT.
+ * Generally, the generic BP_GET_*() macros can be used on embedded BP's.
+ * The B, D, X, lvl, type, and comp fields are stored the same as with normal
+ * BP's so the BP_SET_* macros can be used with them.  etype, PSIZE, LSIZE must
+ * be set with the BPE_SET_* macros.  BP_SET_EMBEDDED() should be called before
+ * other macros, as they assert that they are only used on BP's of the correct
+ * "embedded-ness". Encrypted blkptr_t's cannot be embedded because they use
+ * the payload space for encryption parameters (see the comment above on
+ * how encryption parameters are stored).
+ */
+
+#define	BPE_GET_ETYPE(bp)	\
+	(ASSERT(BP_IS_EMBEDDED(bp)), \
+	BF64_GET((bp)->blk_prop, 40, 8))
+#define	BPE_SET_ETYPE(bp, t)	do { \
+	ASSERT(BP_IS_EMBEDDED(bp)); \
+	BF64_SET((bp)->blk_prop, 40, 8, t); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	BPE_GET_LSIZE(bp)	\
+	(ASSERT(BP_IS_EMBEDDED(bp)), \
+	BF64_GET_SB((bp)->blk_prop, 0, 25, 0, 1))
+#define	BPE_SET_LSIZE(bp, x)	do { \
+	ASSERT(BP_IS_EMBEDDED(bp)); \
+	BF64_SET_SB((bp)->blk_prop, 0, 25, 0, 1, x); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	BPE_GET_PSIZE(bp)	\
+	(ASSERT(BP_IS_EMBEDDED(bp)), \
+	BF64_GET_SB((bp)->blk_prop, 25, 7, 0, 1))
+#define	BPE_SET_PSIZE(bp, x)	do { \
+	ASSERT(BP_IS_EMBEDDED(bp)); \
+	BF64_SET_SB((bp)->blk_prop, 25, 7, 0, 1, x); \
+_NOTE(CONSTCOND) } while (0)
+
+typedef enum bp_embedded_type {
+	BP_EMBEDDED_TYPE_DATA,
+	BP_EMBEDDED_TYPE_RESERVED, /* Reserved for Delphix byteswap feature. */
+	BP_EMBEDDED_TYPE_REDACTED,
+	NUM_BP_EMBEDDED_TYPES
+} bp_embedded_type_t;
+
+#define	BPE_NUM_WORDS 14
+#define	BPE_PAYLOAD_SIZE (BPE_NUM_WORDS * sizeof (uint64_t))
+#define	BPE_IS_PAYLOADWORD(bp, wp) \
+	((wp) != &(bp)->blk_prop && (wp) != &(bp)->blk_birth)
+
+#define	SPA_BLKPTRSHIFT	7		/* blkptr_t is 128 bytes	*/
+#define	SPA_DVAS_PER_BP	3		/* Number of DVAs in a bp	*/
+#define	SPA_SYNC_MIN_VDEVS 3		/* min vdevs to update during sync */
+
+/*
+ * A block is a hole when it has either 1) never been written to, or
+ * 2) is zero-filled. In both cases, ZFS can return all zeroes for all reads
+ * without physically allocating disk space. Holes are represented in the
+ * blkptr_t structure by zeroed blk_dva. Correct checking for holes is
+ * done through the BP_IS_HOLE macro. For holes, the logical size, level,
+ * DMU object type, and birth times are all also stored for holes that
+ * were written to at some point (i.e. were punched after having been filled).
+ */
+typedef struct blkptr {
+	dva_t		blk_dva[SPA_DVAS_PER_BP]; /* Data Virtual Addresses */
+	uint64_t	blk_prop;	/* size, compression, type, etc	    */
+	uint64_t	blk_pad[2];	/* Extra space for the future	    */
+	uint64_t	blk_phys_birth;	/* txg when block was allocated	    */
+	uint64_t	blk_birth;	/* transaction group at birth	    */
+	uint64_t	blk_fill;	/* fill count			    */
+	zio_cksum_t	blk_cksum;	/* 256-bit checksum		    */
+} blkptr_t;
+
+/*
+ * Macros to get and set fields in a bp or DVA.
+ */
+#define	DVA_GET_ASIZE(dva)	\
+	BF64_GET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, SPA_MINBLOCKSHIFT, 0)
+#define	DVA_SET_ASIZE(dva, x)	\
+	BF64_SET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, \
+	SPA_MINBLOCKSHIFT, 0, x)
+
+#define	DVA_GET_GRID(dva)	BF64_GET((dva)->dva_word[0], 24, 8)
+#define	DVA_SET_GRID(dva, x)	BF64_SET((dva)->dva_word[0], 24, 8, x)
+
+#define	DVA_GET_VDEV(dva)	BF64_GET((dva)->dva_word[0], 32, SPA_VDEVBITS)
+#define	DVA_SET_VDEV(dva, x)	\
+	BF64_SET((dva)->dva_word[0], 32, SPA_VDEVBITS, x)
+
+#define	DVA_GET_OFFSET(dva)	\
+	BF64_GET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0)
+#define	DVA_SET_OFFSET(dva, x)	\
+	BF64_SET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0, x)
+
+#define	DVA_GET_GANG(dva)	BF64_GET((dva)->dva_word[1], 63, 1)
+#define	DVA_SET_GANG(dva, x)	BF64_SET((dva)->dva_word[1], 63, 1, x)
+
+#define	BP_GET_LSIZE(bp)	\
+	(BP_IS_EMBEDDED(bp) ?	\
+	(BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA ? BPE_GET_LSIZE(bp) : 0): \
+	BF64_GET_SB((bp)->blk_prop, 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1))
+#define	BP_SET_LSIZE(bp, x)	do { \
+	ASSERT(!BP_IS_EMBEDDED(bp)); \
+	BF64_SET_SB((bp)->blk_prop, \
+	    0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1, x); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	BP_GET_PSIZE(bp)	\
+	(BP_IS_EMBEDDED(bp) ? 0 : \
+	BF64_GET_SB((bp)->blk_prop, 16, SPA_PSIZEBITS, SPA_MINBLOCKSHIFT, 1))
+#define	BP_SET_PSIZE(bp, x)	do { \
+	ASSERT(!BP_IS_EMBEDDED(bp)); \
+	BF64_SET_SB((bp)->blk_prop, \
+	    16, SPA_PSIZEBITS, SPA_MINBLOCKSHIFT, 1, x); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	BP_GET_COMPRESS(bp)		\
+	BF64_GET((bp)->blk_prop, 32, SPA_COMPRESSBITS)
+#define	BP_SET_COMPRESS(bp, x)		\
+	BF64_SET((bp)->blk_prop, 32, SPA_COMPRESSBITS, x)
+
+#define	BP_IS_EMBEDDED(bp)		BF64_GET((bp)->blk_prop, 39, 1)
+#define	BP_SET_EMBEDDED(bp, x)		BF64_SET((bp)->blk_prop, 39, 1, x)
+
+#define	BP_GET_CHECKSUM(bp)		\
+	(BP_IS_EMBEDDED(bp) ? ZIO_CHECKSUM_OFF : \
+	BF64_GET((bp)->blk_prop, 40, 8))
+#define	BP_SET_CHECKSUM(bp, x)		do { \
+	ASSERT(!BP_IS_EMBEDDED(bp)); \
+	BF64_SET((bp)->blk_prop, 40, 8, x); \
+_NOTE(CONSTCOND) } while (0)
+
+#define	BP_GET_TYPE(bp)			BF64_GET((bp)->blk_prop, 48, 8)
+#define	BP_SET_TYPE(bp, x)		BF64_SET((bp)->blk_prop, 48, 8, x)
+
+#define	BP_GET_LEVEL(bp)		BF64_GET((bp)->blk_prop, 56, 5)
+#define	BP_SET_LEVEL(bp, x)		BF64_SET((bp)->blk_prop, 56, 5, x)
+
+/* encrypted, authenticated, and MAC cksum bps use the same bit */
+#define	BP_USES_CRYPT(bp)		BF64_GET((bp)->blk_prop, 61, 1)
+#define	BP_SET_CRYPT(bp, x)		BF64_SET((bp)->blk_prop, 61, 1, x)
+
+#define	BP_IS_ENCRYPTED(bp)			\
+	(BP_USES_CRYPT(bp) &&			\
+	BP_GET_LEVEL(bp) <= 0 &&		\
+	DMU_OT_IS_ENCRYPTED(BP_GET_TYPE(bp)))
+
+#define	BP_IS_AUTHENTICATED(bp)			\
+	(BP_USES_CRYPT(bp) &&			\
+	BP_GET_LEVEL(bp) <= 0 &&		\
+	!DMU_OT_IS_ENCRYPTED(BP_GET_TYPE(bp)))
+
+#define	BP_HAS_INDIRECT_MAC_CKSUM(bp)		\
+	(BP_USES_CRYPT(bp) && BP_GET_LEVEL(bp) > 0)
+
+#define	BP_IS_PROTECTED(bp)			\
+	(BP_IS_ENCRYPTED(bp) || BP_IS_AUTHENTICATED(bp))
+
+#define	BP_GET_DEDUP(bp)		BF64_GET((bp)->blk_prop, 62, 1)
+#define	BP_SET_DEDUP(bp, x)		BF64_SET((bp)->blk_prop, 62, 1, x)
+
+#define	BP_GET_BYTEORDER(bp)		BF64_GET((bp)->blk_prop, 63, 1)
+#define	BP_SET_BYTEORDER(bp, x)		BF64_SET((bp)->blk_prop, 63, 1, x)
+
+#define	BP_GET_FREE(bp)			BF64_GET((bp)->blk_fill, 0, 1)
+#define	BP_SET_FREE(bp, x)		BF64_SET((bp)->blk_fill, 0, 1, x)
+
+#define	BP_PHYSICAL_BIRTH(bp)		\
+	(BP_IS_EMBEDDED(bp) ? 0 : \
+	(bp)->blk_phys_birth ? (bp)->blk_phys_birth : (bp)->blk_birth)
+
+#define	BP_SET_BIRTH(bp, logical, physical)	\
+{						\
+	ASSERT(!BP_IS_EMBEDDED(bp));		\
+	(bp)->blk_birth = (logical);		\
+	(bp)->blk_phys_birth = ((logical) == (physical) ? 0 : (physical)); \
+}
+
+#define	BP_GET_FILL(bp)				\
+	((BP_IS_ENCRYPTED(bp)) ? BF64_GET((bp)->blk_fill, 0, 32) : \
+	((BP_IS_EMBEDDED(bp)) ? 1 : (bp)->blk_fill))
+
+#define	BP_SET_FILL(bp, fill)			\
+{						\
+	if (BP_IS_ENCRYPTED(bp))			\
+		BF64_SET((bp)->blk_fill, 0, 32, fill); \
+	else					\
+		(bp)->blk_fill = fill;		\
+}
+
+#define	BP_GET_IV2(bp)				\
+	(ASSERT(BP_IS_ENCRYPTED(bp)),		\
+	BF64_GET((bp)->blk_fill, 32, 32))
+#define	BP_SET_IV2(bp, iv2)			\
+{						\
+	ASSERT(BP_IS_ENCRYPTED(bp));		\
+	BF64_SET((bp)->blk_fill, 32, 32, iv2);	\
+}
+
+#define	BP_IS_METADATA(bp)	\
+	(BP_GET_LEVEL(bp) > 0 || DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
+
+#define	BP_GET_ASIZE(bp)	\
+	(BP_IS_EMBEDDED(bp) ? 0 : \
+	DVA_GET_ASIZE(&(bp)->blk_dva[0]) + \
+	DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \
+	(DVA_GET_ASIZE(&(bp)->blk_dva[2]) * !BP_IS_ENCRYPTED(bp)))
+
+#define	BP_GET_UCSIZE(bp)	\
+	(BP_IS_METADATA(bp) ? BP_GET_PSIZE(bp) : BP_GET_LSIZE(bp))
+
+#define	BP_GET_NDVAS(bp)	\
+	(BP_IS_EMBEDDED(bp) ? 0 : \
+	!!DVA_GET_ASIZE(&(bp)->blk_dva[0]) + \
+	!!DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \
+	(!!DVA_GET_ASIZE(&(bp)->blk_dva[2]) * !BP_IS_ENCRYPTED(bp)))
+
+#define	BP_COUNT_GANG(bp)	\
+	(BP_IS_EMBEDDED(bp) ? 0 : \
+	(DVA_GET_GANG(&(bp)->blk_dva[0]) + \
+	DVA_GET_GANG(&(bp)->blk_dva[1]) + \
+	(DVA_GET_GANG(&(bp)->blk_dva[2]) * !BP_IS_ENCRYPTED(bp))))
+
+#define	DVA_EQUAL(dva1, dva2)	\
+	((dva1)->dva_word[1] == (dva2)->dva_word[1] && \
+	(dva1)->dva_word[0] == (dva2)->dva_word[0])
+
+#define	BP_EQUAL(bp1, bp2)	\
+	(BP_PHYSICAL_BIRTH(bp1) == BP_PHYSICAL_BIRTH(bp2) &&	\
+	(bp1)->blk_birth == (bp2)->blk_birth &&			\
+	DVA_EQUAL(&(bp1)->blk_dva[0], &(bp2)->blk_dva[0]) &&	\
+	DVA_EQUAL(&(bp1)->blk_dva[1], &(bp2)->blk_dva[1]) &&	\
+	DVA_EQUAL(&(bp1)->blk_dva[2], &(bp2)->blk_dva[2]))
+
+
+#define	DVA_IS_VALID(dva)	(DVA_GET_ASIZE(dva) != 0)
+
+#define	BP_IDENTITY(bp)		(ASSERT(!BP_IS_EMBEDDED(bp)), &(bp)->blk_dva[0])
+#define	BP_IS_GANG(bp)		\
+	(BP_IS_EMBEDDED(bp) ? B_FALSE : DVA_GET_GANG(BP_IDENTITY(bp)))
+#define	DVA_IS_EMPTY(dva)	((dva)->dva_word[0] == 0ULL &&	\
+				(dva)->dva_word[1] == 0ULL)
+#define	BP_IS_HOLE(bp) \
+	(!BP_IS_EMBEDDED(bp) && DVA_IS_EMPTY(BP_IDENTITY(bp)))
+
+#define	BP_SET_REDACTED(bp) \
+{							\
+	BP_SET_EMBEDDED(bp, B_TRUE);			\
+	BPE_SET_ETYPE(bp, BP_EMBEDDED_TYPE_REDACTED);	\
+}
+#define	BP_IS_REDACTED(bp) \
+	(BP_IS_EMBEDDED(bp) && BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_REDACTED)
+
+/* BP_IS_RAIDZ(bp) assumes no block compression */
+#define	BP_IS_RAIDZ(bp)		(DVA_GET_ASIZE(&(bp)->blk_dva[0]) > \
+				BP_GET_PSIZE(bp))
+
+#define	BP_ZERO(bp)				\
+{						\
+	(bp)->blk_dva[0].dva_word[0] = 0;	\
+	(bp)->blk_dva[0].dva_word[1] = 0;	\
+	(bp)->blk_dva[1].dva_word[0] = 0;	\
+	(bp)->blk_dva[1].dva_word[1] = 0;	\
+	(bp)->blk_dva[2].dva_word[0] = 0;	\
+	(bp)->blk_dva[2].dva_word[1] = 0;	\
+	(bp)->blk_prop = 0;			\
+	(bp)->blk_pad[0] = 0;			\
+	(bp)->blk_pad[1] = 0;			\
+	(bp)->blk_phys_birth = 0;		\
+	(bp)->blk_birth = 0;			\
+	(bp)->blk_fill = 0;			\
+	ZIO_SET_CHECKSUM(&(bp)->blk_cksum, 0, 0, 0, 0);	\
+}
+
+#ifdef _ZFS_BIG_ENDIAN
+#define	ZFS_HOST_BYTEORDER	(0ULL)
+#else
+#define	ZFS_HOST_BYTEORDER	(1ULL)
+#endif
+
+#define	BP_SHOULD_BYTESWAP(bp)	(BP_GET_BYTEORDER(bp) != ZFS_HOST_BYTEORDER)
+
+#define	BP_SPRINTF_LEN	400
+
+/*
+ * This macro allows code sharing between zfs, libzpool, and mdb.
+ * 'func' is either snprintf() or mdb_snprintf().
+ * 'ws' (whitespace) can be ' ' for single-line format, '\n' for multi-line.
+ */
+
+#define	SNPRINTF_BLKPTR(func, ws, buf, size, bp, type, checksum, compress) \
+{									\
+	static const char *copyname[] =					\
+	    { "zero", "single", "double", "triple" };			\
+	int len = 0;							\
+	int copies = 0;							\
+	const char *crypt_type;						\
+	if (bp != NULL) {						\
+		if (BP_IS_ENCRYPTED(bp)) {				\
+			crypt_type = "encrypted";			\
+			/* LINTED E_SUSPICIOUS_COMPARISON */		\
+		} else if (BP_IS_AUTHENTICATED(bp)) {			\
+			crypt_type = "authenticated";			\
+		} else if (BP_HAS_INDIRECT_MAC_CKSUM(bp)) {		\
+			crypt_type = "indirect-MAC";			\
+		} else {						\
+			crypt_type = "unencrypted";			\
+		}							\
+	}								\
+	if (bp == NULL) {						\
+		len += func(buf + len, size - len, "<NULL>");		\
+	} else if (BP_IS_HOLE(bp)) {					\
+		len += func(buf + len, size - len,			\
+		    "HOLE [L%llu %s] "					\
+		    "size=%llxL birth=%lluL",				\
+		    (u_longlong_t)BP_GET_LEVEL(bp),			\
+		    type,						\
+		    (u_longlong_t)BP_GET_LSIZE(bp),			\
+		    (u_longlong_t)bp->blk_birth);			\
+	} else if (BP_IS_EMBEDDED(bp)) {				\
+		len = func(buf + len, size - len,			\
+		    "EMBEDDED [L%llu %s] et=%u %s "			\
+		    "size=%llxL/%llxP birth=%lluL",			\
+		    (u_longlong_t)BP_GET_LEVEL(bp),			\
+		    type,						\
+		    (int)BPE_GET_ETYPE(bp),				\
+		    compress,						\
+		    (u_longlong_t)BPE_GET_LSIZE(bp),			\
+		    (u_longlong_t)BPE_GET_PSIZE(bp),			\
+		    (u_longlong_t)bp->blk_birth);			\
+	} else if (BP_IS_REDACTED(bp)) {				\
+		len += func(buf + len, size - len,			\
+		    "REDACTED [L%llu %s] size=%llxL birth=%lluL",	\
+		    (u_longlong_t)BP_GET_LEVEL(bp),			\
+		    type,						\
+		    (u_longlong_t)BP_GET_LSIZE(bp),			\
+		    (u_longlong_t)bp->blk_birth);			\
+	} else {							\
+		for (int d = 0; d < BP_GET_NDVAS(bp); d++) {		\
+			const dva_t *dva = &bp->blk_dva[d];		\
+			if (DVA_IS_VALID(dva))				\
+				copies++;				\
+			len += func(buf + len, size - len,		\
+			    "DVA[%d]=<%llu:%llx:%llx>%c", d,		\
+			    (u_longlong_t)DVA_GET_VDEV(dva),		\
+			    (u_longlong_t)DVA_GET_OFFSET(dva),		\
+			    (u_longlong_t)DVA_GET_ASIZE(dva),		\
+			    ws);					\
+		}							\
+		if (BP_IS_ENCRYPTED(bp)) {				\
+			len += func(buf + len, size - len,		\
+			    "salt=%llx iv=%llx:%llx%c",			\
+			    (u_longlong_t)bp->blk_dva[2].dva_word[0],	\
+			    (u_longlong_t)bp->blk_dva[2].dva_word[1],	\
+			    (u_longlong_t)BP_GET_IV2(bp),		\
+			    ws);					\
+		}							\
+		if (BP_IS_GANG(bp) &&					\
+		    DVA_GET_ASIZE(&bp->blk_dva[2]) <=			\
+		    DVA_GET_ASIZE(&bp->blk_dva[1]) / 2)			\
+			copies--;					\
+		len += func(buf + len, size - len,			\
+		    "[L%llu %s] %s %s %s %s %s %s %s%c"			\
+		    "size=%llxL/%llxP birth=%lluL/%lluP fill=%llu%c"	\
+		    "cksum=%llx:%llx:%llx:%llx",			\
+		    (u_longlong_t)BP_GET_LEVEL(bp),			\
+		    type,						\
+		    checksum,						\
+		    compress,						\
+		    crypt_type,						\
+		    BP_GET_BYTEORDER(bp) == 0 ? "BE" : "LE",		\
+		    BP_IS_GANG(bp) ? "gang" : "contiguous",		\
+		    BP_GET_DEDUP(bp) ? "dedup" : "unique",		\
+		    copyname[copies],					\
+		    ws,							\
+		    (u_longlong_t)BP_GET_LSIZE(bp),			\
+		    (u_longlong_t)BP_GET_PSIZE(bp),			\
+		    (u_longlong_t)bp->blk_birth,			\
+		    (u_longlong_t)BP_PHYSICAL_BIRTH(bp),		\
+		    (u_longlong_t)BP_GET_FILL(bp),			\
+		    ws,							\
+		    (u_longlong_t)bp->blk_cksum.zc_word[0],		\
+		    (u_longlong_t)bp->blk_cksum.zc_word[1],		\
+		    (u_longlong_t)bp->blk_cksum.zc_word[2],		\
+		    (u_longlong_t)bp->blk_cksum.zc_word[3]);		\
+	}								\
+	ASSERT(len < size);						\
+}
+
+#define	BP_GET_BUFC_TYPE(bp)						\
+	(BP_IS_METADATA(bp) ? ARC_BUFC_METADATA : ARC_BUFC_DATA)
+
+typedef enum spa_import_type {
+	SPA_IMPORT_EXISTING,
+	SPA_IMPORT_ASSEMBLE
+} spa_import_type_t;
+
+typedef enum spa_mode {
+	SPA_MODE_UNINIT = 0,
+	SPA_MODE_READ = 1,
+	SPA_MODE_WRITE = 2,
+} spa_mode_t;
+
+/*
+ * Send TRIM commands in-line during normal pool operation while deleting.
+ *	OFF: no
+ *	ON: yes
+ * NB: IN_FREEBSD_BASE is defined within the FreeBSD sources.
+ */
+typedef enum {
+	SPA_AUTOTRIM_OFF = 0,	/* default */
+	SPA_AUTOTRIM_ON,
+#ifdef IN_FREEBSD_BASE
+	SPA_AUTOTRIM_DEFAULT = SPA_AUTOTRIM_ON,
+#else
+	SPA_AUTOTRIM_DEFAULT = SPA_AUTOTRIM_OFF,
+#endif
+} spa_autotrim_t;
+
+/*
+ * Reason TRIM command was issued, used internally for accounting purposes.
+ */
+typedef enum trim_type {
+	TRIM_TYPE_MANUAL = 0,
+	TRIM_TYPE_AUTO = 1,
+	TRIM_TYPE_SIMPLE = 2
+} trim_type_t;
+
+/* state manipulation functions */
+extern int spa_open(const char *pool, spa_t **, void *tag);
+extern int spa_open_rewind(const char *pool, spa_t **, void *tag,
+    nvlist_t *policy, nvlist_t **config);
+extern int spa_get_stats(const char *pool, nvlist_t **config, char *altroot,
+    size_t buflen);
+extern int spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props,
+    nvlist_t *zplprops, struct dsl_crypto_params *dcp);
+extern int spa_import(char *pool, nvlist_t *config, nvlist_t *props,
+    uint64_t flags);
+extern nvlist_t *spa_tryimport(nvlist_t *tryconfig);
+extern int spa_destroy(char *pool);
+extern int spa_checkpoint(const char *pool);
+extern int spa_checkpoint_discard(const char *pool);
+extern int spa_export(char *pool, nvlist_t **oldconfig, boolean_t force,
+    boolean_t hardforce);
+extern int spa_reset(char *pool);
+extern void spa_async_request(spa_t *spa, int flag);
+extern void spa_async_unrequest(spa_t *spa, int flag);
+extern void spa_async_suspend(spa_t *spa);
+extern void spa_async_resume(spa_t *spa);
+extern int spa_async_tasks(spa_t *spa);
+extern spa_t *spa_inject_addref(char *pool);
+extern void spa_inject_delref(spa_t *spa);
+extern void spa_scan_stat_init(spa_t *spa);
+extern int spa_scan_get_stats(spa_t *spa, pool_scan_stat_t *ps);
+extern int bpobj_enqueue_alloc_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx);
+extern int bpobj_enqueue_free_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx);
+
+#define	SPA_ASYNC_CONFIG_UPDATE			0x01
+#define	SPA_ASYNC_REMOVE			0x02
+#define	SPA_ASYNC_PROBE				0x04
+#define	SPA_ASYNC_RESILVER_DONE			0x08
+#define	SPA_ASYNC_RESILVER			0x10
+#define	SPA_ASYNC_AUTOEXPAND			0x20
+#define	SPA_ASYNC_REMOVE_DONE			0x40
+#define	SPA_ASYNC_REMOVE_STOP			0x80
+#define	SPA_ASYNC_INITIALIZE_RESTART		0x100
+#define	SPA_ASYNC_TRIM_RESTART			0x200
+#define	SPA_ASYNC_AUTOTRIM_RESTART		0x400
+#define	SPA_ASYNC_L2CACHE_REBUILD		0x800
+#define	SPA_ASYNC_L2CACHE_TRIM			0x1000
+#define	SPA_ASYNC_REBUILD_DONE			0x2000
+
+/* device manipulation */
+extern int spa_vdev_add(spa_t *spa, nvlist_t *nvroot);
+extern int spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot,
+    int replacing, int rebuild);
+extern int spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid,
+    int replace_done);
+extern int spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare);
+extern boolean_t spa_vdev_remove_active(spa_t *spa);
+extern int spa_vdev_initialize(spa_t *spa, nvlist_t *nv, uint64_t cmd_type,
+    nvlist_t *vdev_errlist);
+extern int spa_vdev_trim(spa_t *spa, nvlist_t *nv, uint64_t cmd_type,
+    uint64_t rate, boolean_t partial, boolean_t secure, nvlist_t *vdev_errlist);
+extern int spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath);
+extern int spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru);
+extern int spa_vdev_split_mirror(spa_t *spa, char *newname, nvlist_t *config,
+    nvlist_t *props, boolean_t exp);
+
+/* spare state (which is global across all pools) */
+extern void spa_spare_add(vdev_t *vd);
+extern void spa_spare_remove(vdev_t *vd);
+extern boolean_t spa_spare_exists(uint64_t guid, uint64_t *pool, int *refcnt);
+extern void spa_spare_activate(vdev_t *vd);
+
+/* L2ARC state (which is global across all pools) */
+extern void spa_l2cache_add(vdev_t *vd);
+extern void spa_l2cache_remove(vdev_t *vd);
+extern boolean_t spa_l2cache_exists(uint64_t guid, uint64_t *pool);
+extern void spa_l2cache_activate(vdev_t *vd);
+extern void spa_l2cache_drop(spa_t *spa);
+
+/* scanning */
+extern int spa_scan(spa_t *spa, pool_scan_func_t func);
+extern int spa_scan_stop(spa_t *spa);
+extern int spa_scrub_pause_resume(spa_t *spa, pool_scrub_cmd_t flag);
+
+/* spa syncing */
+extern void spa_sync(spa_t *spa, uint64_t txg); /* only for DMU use */
+extern void spa_sync_allpools(void);
+
+extern int zfs_sync_pass_deferred_free;
+
+/* spa namespace global mutex */
+extern kmutex_t spa_namespace_lock;
+
+/*
+ * SPA configuration functions in spa_config.c
+ */
+
+#define	SPA_CONFIG_UPDATE_POOL	0
+#define	SPA_CONFIG_UPDATE_VDEVS	1
+
+extern void spa_write_cachefile(spa_t *, boolean_t, boolean_t);
+extern void spa_config_load(void);
+extern nvlist_t *spa_all_configs(uint64_t *);
+extern void spa_config_set(spa_t *spa, nvlist_t *config);
+extern nvlist_t *spa_config_generate(spa_t *spa, vdev_t *vd, uint64_t txg,
+    int getstats);
+extern void spa_config_update(spa_t *spa, int what);
+extern int spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv,
+    vdev_t *parent, uint_t id, int atype);
+
+
+/*
+ * Miscellaneous SPA routines in spa_misc.c
+ */
+
+/* Namespace manipulation */
+extern spa_t *spa_lookup(const char *name);
+extern spa_t *spa_add(const char *name, nvlist_t *config, const char *altroot);
+extern void spa_remove(spa_t *spa);
+extern spa_t *spa_next(spa_t *prev);
+
+/* Refcount functions */
+extern void spa_open_ref(spa_t *spa, void *tag);
+extern void spa_close(spa_t *spa, void *tag);
+extern void spa_async_close(spa_t *spa, void *tag);
+extern boolean_t spa_refcount_zero(spa_t *spa);
+
+#define	SCL_NONE	0x00
+#define	SCL_CONFIG	0x01
+#define	SCL_STATE	0x02
+#define	SCL_L2ARC	0x04		/* hack until L2ARC 2.0 */
+#define	SCL_ALLOC	0x08
+#define	SCL_ZIO		0x10
+#define	SCL_FREE	0x20
+#define	SCL_VDEV	0x40
+#define	SCL_LOCKS	7
+#define	SCL_ALL		((1 << SCL_LOCKS) - 1)
+#define	SCL_STATE_ALL	(SCL_STATE | SCL_L2ARC | SCL_ZIO)
+
+/* Historical pool statistics */
+typedef struct spa_history_kstat {
+	kmutex_t		lock;
+	uint64_t		count;
+	uint64_t		size;
+	kstat_t			*kstat;
+	void			*priv;
+	list_t			list;
+} spa_history_kstat_t;
+
+typedef struct spa_history_list {
+	uint64_t		size;
+	procfs_list_t		procfs_list;
+} spa_history_list_t;
+
+typedef struct spa_stats {
+	spa_history_list_t	read_history;
+	spa_history_list_t	txg_history;
+	spa_history_kstat_t	tx_assign_histogram;
+	spa_history_kstat_t	io_history;
+	spa_history_list_t	mmp_history;
+	spa_history_kstat_t	state;		/* pool state */
+	spa_history_kstat_t	iostats;
+} spa_stats_t;
+
+typedef enum txg_state {
+	TXG_STATE_BIRTH		= 0,
+	TXG_STATE_OPEN		= 1,
+	TXG_STATE_QUIESCED	= 2,
+	TXG_STATE_WAIT_FOR_SYNC	= 3,
+	TXG_STATE_SYNCED	= 4,
+	TXG_STATE_COMMITTED	= 5,
+} txg_state_t;
+
+typedef struct txg_stat {
+	vdev_stat_t		vs1;
+	vdev_stat_t		vs2;
+	uint64_t		txg;
+	uint64_t		ndirty;
+} txg_stat_t;
+
+/* Assorted pool IO kstats */
+typedef struct spa_iostats {
+	kstat_named_t	trim_extents_written;
+	kstat_named_t	trim_bytes_written;
+	kstat_named_t	trim_extents_skipped;
+	kstat_named_t	trim_bytes_skipped;
+	kstat_named_t	trim_extents_failed;
+	kstat_named_t	trim_bytes_failed;
+	kstat_named_t	autotrim_extents_written;
+	kstat_named_t	autotrim_bytes_written;
+	kstat_named_t	autotrim_extents_skipped;
+	kstat_named_t	autotrim_bytes_skipped;
+	kstat_named_t	autotrim_extents_failed;
+	kstat_named_t	autotrim_bytes_failed;
+	kstat_named_t	simple_trim_extents_written;
+	kstat_named_t	simple_trim_bytes_written;
+	kstat_named_t	simple_trim_extents_skipped;
+	kstat_named_t	simple_trim_bytes_skipped;
+	kstat_named_t	simple_trim_extents_failed;
+	kstat_named_t	simple_trim_bytes_failed;
+} spa_iostats_t;
+
+extern void spa_stats_init(spa_t *spa);
+extern void spa_stats_destroy(spa_t *spa);
+extern void spa_read_history_add(spa_t *spa, const zbookmark_phys_t *zb,
+    uint32_t aflags);
+extern void spa_txg_history_add(spa_t *spa, uint64_t txg, hrtime_t birth_time);
+extern int spa_txg_history_set(spa_t *spa,  uint64_t txg,
+    txg_state_t completed_state, hrtime_t completed_time);
+extern txg_stat_t *spa_txg_history_init_io(spa_t *, uint64_t,
+    struct dsl_pool *);
+extern void spa_txg_history_fini_io(spa_t *, txg_stat_t *);
+extern void spa_tx_assign_add_nsecs(spa_t *spa, uint64_t nsecs);
+extern int spa_mmp_history_set_skip(spa_t *spa, uint64_t mmp_kstat_id);
+extern int spa_mmp_history_set(spa_t *spa, uint64_t mmp_kstat_id, int io_error,
+    hrtime_t duration);
+extern void spa_mmp_history_add(spa_t *spa, uint64_t txg, uint64_t timestamp,
+    uint64_t mmp_delay, vdev_t *vd, int label, uint64_t mmp_kstat_id,
+    int error);
+extern void spa_iostats_trim_add(spa_t *spa, trim_type_t type,
+    uint64_t extents_written, uint64_t bytes_written,
+    uint64_t extents_skipped, uint64_t bytes_skipped,
+    uint64_t extents_failed, uint64_t bytes_failed);
+extern void spa_import_progress_add(spa_t *spa);
+extern void spa_import_progress_remove(uint64_t spa_guid);
+extern int spa_import_progress_set_mmp_check(uint64_t pool_guid,
+    uint64_t mmp_sec_remaining);
+extern int spa_import_progress_set_max_txg(uint64_t pool_guid,
+    uint64_t max_txg);
+extern int spa_import_progress_set_state(uint64_t pool_guid,
+    spa_load_state_t spa_load_state);
+
+/* Pool configuration locks */
+extern int spa_config_tryenter(spa_t *spa, int locks, void *tag, krw_t rw);
+extern void spa_config_enter(spa_t *spa, int locks, const void *tag, krw_t rw);
+extern void spa_config_exit(spa_t *spa, int locks, const void *tag);
+extern int spa_config_held(spa_t *spa, int locks, krw_t rw);
+
+/* Pool vdev add/remove lock */
+extern uint64_t spa_vdev_enter(spa_t *spa);
+extern uint64_t spa_vdev_detach_enter(spa_t *spa, uint64_t guid);
+extern uint64_t spa_vdev_config_enter(spa_t *spa);
+extern void spa_vdev_config_exit(spa_t *spa, vdev_t *vd, uint64_t txg,
+    int error, char *tag);
+extern int spa_vdev_exit(spa_t *spa, vdev_t *vd, uint64_t txg, int error);
+
+/* Pool vdev state change lock */
+extern void spa_vdev_state_enter(spa_t *spa, int oplock);
+extern int spa_vdev_state_exit(spa_t *spa, vdev_t *vd, int error);
+
+/* Log state */
+typedef enum spa_log_state {
+	SPA_LOG_UNKNOWN = 0,	/* unknown log state */
+	SPA_LOG_MISSING,	/* missing log(s) */
+	SPA_LOG_CLEAR,		/* clear the log(s) */
+	SPA_LOG_GOOD,		/* log(s) are good */
+} spa_log_state_t;
+
+extern spa_log_state_t spa_get_log_state(spa_t *spa);
+extern void spa_set_log_state(spa_t *spa, spa_log_state_t state);
+extern int spa_reset_logs(spa_t *spa);
+
+/* Log claim callback */
+extern void spa_claim_notify(zio_t *zio);
+extern void spa_deadman(void *);
+
+/* Accessor functions */
+extern boolean_t spa_shutting_down(spa_t *spa);
+extern struct dsl_pool *spa_get_dsl(spa_t *spa);
+extern boolean_t spa_is_initializing(spa_t *spa);
+extern boolean_t spa_indirect_vdevs_loaded(spa_t *spa);
+extern blkptr_t *spa_get_rootblkptr(spa_t *spa);
+extern void spa_set_rootblkptr(spa_t *spa, const blkptr_t *bp);
+extern void spa_altroot(spa_t *, char *, size_t);
+extern int spa_sync_pass(spa_t *spa);
+extern char *spa_name(spa_t *spa);
+extern uint64_t spa_guid(spa_t *spa);
+extern uint64_t spa_load_guid(spa_t *spa);
+extern uint64_t spa_last_synced_txg(spa_t *spa);
+extern uint64_t spa_first_txg(spa_t *spa);
+extern uint64_t spa_syncing_txg(spa_t *spa);
+extern uint64_t spa_final_dirty_txg(spa_t *spa);
+extern uint64_t spa_version(spa_t *spa);
+extern pool_state_t spa_state(spa_t *spa);
+extern spa_load_state_t spa_load_state(spa_t *spa);
+extern uint64_t spa_freeze_txg(spa_t *spa);
+extern uint64_t spa_get_worst_case_asize(spa_t *spa, uint64_t lsize);
+extern uint64_t spa_get_dspace(spa_t *spa);
+extern uint64_t spa_get_checkpoint_space(spa_t *spa);
+extern uint64_t spa_get_slop_space(spa_t *spa);
+extern void spa_update_dspace(spa_t *spa);
+extern uint64_t spa_version(spa_t *spa);
+extern boolean_t spa_deflate(spa_t *spa);
+extern metaslab_class_t *spa_normal_class(spa_t *spa);
+extern metaslab_class_t *spa_log_class(spa_t *spa);
+extern metaslab_class_t *spa_special_class(spa_t *spa);
+extern metaslab_class_t *spa_dedup_class(spa_t *spa);
+extern metaslab_class_t *spa_preferred_class(spa_t *spa, uint64_t size,
+    dmu_object_type_t objtype, uint_t level, uint_t special_smallblk);
+
+extern void spa_evicting_os_register(spa_t *, objset_t *os);
+extern void spa_evicting_os_deregister(spa_t *, objset_t *os);
+extern void spa_evicting_os_wait(spa_t *spa);
+extern int spa_max_replication(spa_t *spa);
+extern int spa_prev_software_version(spa_t *spa);
+extern uint64_t spa_get_failmode(spa_t *spa);
+extern uint64_t spa_get_deadman_failmode(spa_t *spa);
+extern void spa_set_deadman_failmode(spa_t *spa, const char *failmode);
+extern boolean_t spa_suspended(spa_t *spa);
+extern uint64_t spa_bootfs(spa_t *spa);
+extern uint64_t spa_delegation(spa_t *spa);
+extern objset_t *spa_meta_objset(spa_t *spa);
+extern space_map_t *spa_syncing_log_sm(spa_t *spa);
+extern uint64_t spa_deadman_synctime(spa_t *spa);
+extern uint64_t spa_deadman_ziotime(spa_t *spa);
+extern uint64_t spa_dirty_data(spa_t *spa);
+extern spa_autotrim_t spa_get_autotrim(spa_t *spa);
+
+/* Miscellaneous support routines */
+extern void spa_load_failed(spa_t *spa, const char *fmt, ...);
+extern void spa_load_note(spa_t *spa, const char *fmt, ...);
+extern void spa_activate_mos_feature(spa_t *spa, const char *feature,
+    dmu_tx_t *tx);
+extern void spa_deactivate_mos_feature(spa_t *spa, const char *feature);
+extern spa_t *spa_by_guid(uint64_t pool_guid, uint64_t device_guid);
+extern boolean_t spa_guid_exists(uint64_t pool_guid, uint64_t device_guid);
+extern char *spa_strdup(const char *);
+extern void spa_strfree(char *);
+extern uint64_t spa_get_random(uint64_t range);
+extern uint64_t spa_generate_guid(spa_t *spa);
+extern void snprintf_blkptr(char *buf, size_t buflen, const blkptr_t *bp);
+extern void spa_freeze(spa_t *spa);
+extern int spa_change_guid(spa_t *spa);
+extern void spa_upgrade(spa_t *spa, uint64_t version);
+extern void spa_evict_all(void);
+extern vdev_t *spa_lookup_by_guid(spa_t *spa, uint64_t guid,
+    boolean_t l2cache);
+extern boolean_t spa_has_spare(spa_t *, uint64_t guid);
+extern uint64_t dva_get_dsize_sync(spa_t *spa, const dva_t *dva);
+extern uint64_t bp_get_dsize_sync(spa_t *spa, const blkptr_t *bp);
+extern uint64_t bp_get_dsize(spa_t *spa, const blkptr_t *bp);
+extern boolean_t spa_has_slogs(spa_t *spa);
+extern boolean_t spa_is_root(spa_t *spa);
+extern boolean_t spa_writeable(spa_t *spa);
+extern boolean_t spa_has_pending_synctask(spa_t *spa);
+extern int spa_maxblocksize(spa_t *spa);
+extern int spa_maxdnodesize(spa_t *spa);
+extern boolean_t spa_has_checkpoint(spa_t *spa);
+extern boolean_t spa_importing_readonly_checkpoint(spa_t *spa);
+extern boolean_t spa_suspend_async_destroy(spa_t *spa);
+extern uint64_t spa_min_claim_txg(spa_t *spa);
+extern boolean_t zfs_dva_valid(spa_t *spa, const dva_t *dva,
+    const blkptr_t *bp);
+typedef void (*spa_remap_cb_t)(uint64_t vdev, uint64_t offset, uint64_t size,
+    void *arg);
+extern boolean_t spa_remap_blkptr(spa_t *spa, blkptr_t *bp,
+    spa_remap_cb_t callback, void *arg);
+extern uint64_t spa_get_last_removal_txg(spa_t *spa);
+extern boolean_t spa_trust_config(spa_t *spa);
+extern uint64_t spa_missing_tvds_allowed(spa_t *spa);
+extern void spa_set_missing_tvds(spa_t *spa, uint64_t missing);
+extern boolean_t spa_top_vdevs_spacemap_addressable(spa_t *spa);
+extern uint64_t spa_total_metaslabs(spa_t *spa);
+extern boolean_t spa_multihost(spa_t *spa);
+extern uint32_t spa_get_hostid(spa_t *spa);
+extern void spa_activate_allocation_classes(spa_t *, dmu_tx_t *);
+extern boolean_t spa_livelist_delete_check(spa_t *spa);
+
+extern spa_mode_t spa_mode(spa_t *spa);
+extern uint64_t zfs_strtonum(const char *str, char **nptr);
+
+extern char *spa_his_ievent_table[];
+
+extern void spa_history_create_obj(spa_t *spa, dmu_tx_t *tx);
+extern int spa_history_get(spa_t *spa, uint64_t *offset, uint64_t *len_read,
+    char *his_buf);
+extern int spa_history_log(spa_t *spa, const char *his_buf);
+extern int spa_history_log_nvl(spa_t *spa, nvlist_t *nvl);
+extern void spa_history_log_version(spa_t *spa, const char *operation,
+    dmu_tx_t *tx);
+extern void spa_history_log_internal(spa_t *spa, const char *operation,
+    dmu_tx_t *tx, const char *fmt, ...) __printflike(4, 5);
+extern void spa_history_log_internal_ds(struct dsl_dataset *ds, const char *op,
+    dmu_tx_t *tx, const char *fmt, ...)  __printflike(4, 5);
+extern void spa_history_log_internal_dd(dsl_dir_t *dd, const char *operation,
+    dmu_tx_t *tx, const char *fmt, ...) __printflike(4, 5);
+
+extern const char *spa_state_to_name(spa_t *spa);
+
+/* error handling */
+struct zbookmark_phys;
+extern void spa_log_error(spa_t *spa, const zbookmark_phys_t *zb);
+extern int zfs_ereport_post(const char *clazz, spa_t *spa, vdev_t *vd,
+    const zbookmark_phys_t *zb, zio_t *zio, uint64_t stateoroffset,
+    uint64_t length);
+extern boolean_t zfs_ereport_is_valid(const char *clazz, spa_t *spa, vdev_t *vd,
+    zio_t *zio);
+extern nvlist_t *zfs_event_create(spa_t *spa, vdev_t *vd, const char *type,
+    const char *name, nvlist_t *aux);
+extern void zfs_post_remove(spa_t *spa, vdev_t *vd);
+extern void zfs_post_state_change(spa_t *spa, vdev_t *vd, uint64_t laststate);
+extern void zfs_post_autoreplace(spa_t *spa, vdev_t *vd);
+extern uint64_t spa_get_errlog_size(spa_t *spa);
+extern int spa_get_errlog(spa_t *spa, void *uaddr, size_t *count);
+extern void spa_errlog_rotate(spa_t *spa);
+extern void spa_errlog_drain(spa_t *spa);
+extern void spa_errlog_sync(spa_t *spa, uint64_t txg);
+extern void spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub);
+
+/* vdev cache */
+extern void vdev_cache_stat_init(void);
+extern void vdev_cache_stat_fini(void);
+
+/* vdev mirror */
+extern void vdev_mirror_stat_init(void);
+extern void vdev_mirror_stat_fini(void);
+
+/* Initialization and termination */
+extern void spa_init(spa_mode_t mode);
+extern void spa_fini(void);
+extern void spa_boot_init(void);
+
+/* properties */
+extern int spa_prop_set(spa_t *spa, nvlist_t *nvp);
+extern int spa_prop_get(spa_t *spa, nvlist_t **nvp);
+extern void spa_prop_clear_bootfs(spa_t *spa, uint64_t obj, dmu_tx_t *tx);
+extern void spa_configfile_set(spa_t *, nvlist_t *, boolean_t);
+
+/* asynchronous event notification */
+extern void spa_event_notify(spa_t *spa, vdev_t *vdev, nvlist_t *hist_nvl,
+    const char *name);
+
+/* waiting for pool activities to complete */
+extern int spa_wait(const char *pool, zpool_wait_activity_t activity,
+    boolean_t *waited);
+extern int spa_wait_tag(const char *name, zpool_wait_activity_t activity,
+    uint64_t tag, boolean_t *waited);
+extern void spa_notify_waiters(spa_t *spa);
+extern void spa_wake_waiters(spa_t *spa);
+
+/* module param call functions */
+int param_set_deadman_ziotime(ZFS_MODULE_PARAM_ARGS);
+int param_set_deadman_synctime(ZFS_MODULE_PARAM_ARGS);
+int param_set_slop_shift(ZFS_MODULE_PARAM_ARGS);
+int param_set_deadman_failmode(ZFS_MODULE_PARAM_ARGS);
+
+#ifdef ZFS_DEBUG
+#define	dprintf_bp(bp, fmt, ...) do {				\
+	if (zfs_flags & ZFS_DEBUG_DPRINTF) {			\
+	char *__blkbuf = kmem_alloc(BP_SPRINTF_LEN, KM_SLEEP);	\
+	snprintf_blkptr(__blkbuf, BP_SPRINTF_LEN, (bp));	\
+	dprintf(fmt " %s\n", __VA_ARGS__, __blkbuf);		\
+	kmem_free(__blkbuf, BP_SPRINTF_LEN);			\
+	} \
+_NOTE(CONSTCOND) } while (0)
+#else
+#define	dprintf_bp(bp, fmt, ...)
+#endif
+
+extern spa_mode_t spa_mode_global;
+extern int zfs_deadman_enabled;
+extern unsigned long zfs_deadman_synctime_ms;
+extern unsigned long zfs_deadman_ziotime_ms;
+extern unsigned long zfs_deadman_checktime_ms;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_SPA_H */
diff --git a/include/sys/spa_boot.h b/include/sys/spa_boot.h
new file mode 100644
index 0000000000000..1d3622f5a108b
--- /dev/null
+++ b/include/sys/spa_boot.h
@@ -0,0 +1,42 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_SPA_BOOT_H
+#define	_SYS_SPA_BOOT_H
+
+#include <sys/nvpair.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern char *spa_get_bootprop(char *prop);
+extern void spa_free_bootprop(char *prop);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_SPA_BOOT_H */
diff --git a/include/sys/spa_checkpoint.h b/include/sys/spa_checkpoint.h
new file mode 100644
index 0000000000000..9be2b6eeab3c2
--- /dev/null
+++ b/include/sys/spa_checkpoint.h
@@ -0,0 +1,44 @@
+/*
+ * 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) 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_SPA_CHECKPOINT_H
+#define	_SYS_SPA_CHECKPOINT_H
+
+#include <sys/zthr.h>
+
+typedef struct spa_checkpoint_info {
+	uint64_t sci_timestamp; /* when checkpointed uberblock was synced  */
+	uint64_t sci_dspace;    /* disk space used by checkpoint in bytes */
+} spa_checkpoint_info_t;
+
+int spa_checkpoint(const char *);
+int spa_checkpoint_discard(const char *);
+
+boolean_t spa_checkpoint_discard_thread_check(void *, zthr_t *);
+void spa_checkpoint_discard_thread(void *, zthr_t *);
+
+int spa_checkpoint_get_stats(spa_t *, pool_checkpoint_stat_t *);
+
+#endif /* _SYS_SPA_CHECKPOINT_H */
diff --git a/include/sys/spa_checksum.h b/include/sys/spa_checksum.h
new file mode 100644
index 0000000000000..b87990105a71b
--- /dev/null
+++ b/include/sys/spa_checksum.h
@@ -0,0 +1,72 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SPA_CHECKSUM_H
+#define	_SPA_CHECKSUM_H
+
+#include <sys/types.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Each block has a 256-bit checksum -- strong enough for cryptographic hashes.
+ */
+typedef struct zio_cksum {
+	uint64_t	zc_word[4];
+} zio_cksum_t;
+
+#define	ZIO_SET_CHECKSUM(zcp, w0, w1, w2, w3)	\
+{						\
+	(zcp)->zc_word[0] = w0;			\
+	(zcp)->zc_word[1] = w1;			\
+	(zcp)->zc_word[2] = w2;			\
+	(zcp)->zc_word[3] = w3;			\
+}
+
+#define	ZIO_CHECKSUM_EQUAL(zc1, zc2) \
+	(0 == (((zc1).zc_word[0] - (zc2).zc_word[0]) | \
+	((zc1).zc_word[1] - (zc2).zc_word[1]) | \
+	((zc1).zc_word[2] - (zc2).zc_word[2]) | \
+	((zc1).zc_word[3] - (zc2).zc_word[3])))
+
+#define	ZIO_CHECKSUM_IS_ZERO(zc) \
+	(0 == ((zc)->zc_word[0] | (zc)->zc_word[1] | \
+	(zc)->zc_word[2] | (zc)->zc_word[3]))
+
+#define	ZIO_CHECKSUM_BSWAP(zcp)					\
+{								\
+	(zcp)->zc_word[0] = BSWAP_64((zcp)->zc_word[0]);	\
+	(zcp)->zc_word[1] = BSWAP_64((zcp)->zc_word[1]);	\
+	(zcp)->zc_word[2] = BSWAP_64((zcp)->zc_word[2]);	\
+	(zcp)->zc_word[3] = BSWAP_64((zcp)->zc_word[3]);	\
+}
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif
diff --git a/include/sys/spa_impl.h b/include/sys/spa_impl.h
new file mode 100644
index 0000000000000..69de75fb6d3f8
--- /dev/null
+++ b/include/sys/spa_impl.h
@@ -0,0 +1,458 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2019 by Delphix. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ * Copyright 2013 Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2016 Actifio, Inc. All rights reserved.
+ * Copyright (c) 2017 Datto Inc.
+ * Copyright (c) 2017, Intel Corporation.
+ */
+
+#ifndef _SYS_SPA_IMPL_H
+#define	_SYS_SPA_IMPL_H
+
+#include <sys/spa.h>
+#include <sys/spa_checkpoint.h>
+#include <sys/spa_log_spacemap.h>
+#include <sys/vdev.h>
+#include <sys/vdev_rebuild.h>
+#include <sys/vdev_removal.h>
+#include <sys/metaslab.h>
+#include <sys/dmu.h>
+#include <sys/dsl_pool.h>
+#include <sys/uberblock_impl.h>
+#include <sys/zfs_context.h>
+#include <sys/avl.h>
+#include <sys/zfs_refcount.h>
+#include <sys/bplist.h>
+#include <sys/bpobj.h>
+#include <sys/dsl_crypt.h>
+#include <sys/zfeature.h>
+#include <sys/zthr.h>
+#include <sys/dsl_deadlist.h>
+#include <zfeature_common.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct spa_error_entry {
+	zbookmark_phys_t	se_bookmark;
+	char			*se_name;
+	avl_node_t		se_avl;
+} spa_error_entry_t;
+
+typedef struct spa_history_phys {
+	uint64_t sh_pool_create_len;	/* ending offset of zpool create */
+	uint64_t sh_phys_max_off;	/* physical EOF */
+	uint64_t sh_bof;		/* logical BOF */
+	uint64_t sh_eof;		/* logical EOF */
+	uint64_t sh_records_lost;	/* num of records overwritten */
+} spa_history_phys_t;
+
+/*
+ * All members must be uint64_t, for byteswap purposes.
+ */
+typedef struct spa_removing_phys {
+	uint64_t sr_state; /* dsl_scan_state_t */
+
+	/*
+	 * The vdev ID that we most recently attempted to remove,
+	 * or -1 if no removal has been attempted.
+	 */
+	uint64_t sr_removing_vdev;
+
+	/*
+	 * The vdev ID that we most recently successfully removed,
+	 * or -1 if no devices have been removed.
+	 */
+	uint64_t sr_prev_indirect_vdev;
+
+	uint64_t sr_start_time;
+	uint64_t sr_end_time;
+
+	/*
+	 * Note that we can not use the space map's or indirect mapping's
+	 * accounting as a substitute for these values, because we need to
+	 * count frees of not-yet-copied data as though it did the copy.
+	 * Otherwise, we could get into a situation where copied > to_copy,
+	 * or we complete before copied == to_copy.
+	 */
+	uint64_t sr_to_copy; /* bytes that need to be copied */
+	uint64_t sr_copied; /* bytes that have been copied or freed */
+} spa_removing_phys_t;
+
+/*
+ * This struct is stored as an entry in the DMU_POOL_DIRECTORY_OBJECT
+ * (with key DMU_POOL_CONDENSING_INDIRECT).  It is present if a condense
+ * of an indirect vdev's mapping object is in progress.
+ */
+typedef struct spa_condensing_indirect_phys {
+	/*
+	 * The vdev ID of the indirect vdev whose indirect mapping is
+	 * being condensed.
+	 */
+	uint64_t	scip_vdev;
+
+	/*
+	 * The vdev's old obsolete spacemap.  This spacemap's contents are
+	 * being integrated into the new mapping.
+	 */
+	uint64_t	scip_prev_obsolete_sm_object;
+
+	/*
+	 * The new mapping object that is being created.
+	 */
+	uint64_t	scip_next_mapping_object;
+} spa_condensing_indirect_phys_t;
+
+struct spa_aux_vdev {
+	uint64_t	sav_object;		/* MOS object for device list */
+	nvlist_t	*sav_config;		/* cached device config */
+	vdev_t		**sav_vdevs;		/* devices */
+	int		sav_count;		/* number devices */
+	boolean_t	sav_sync;		/* sync the device list */
+	nvlist_t	**sav_pending;		/* pending device additions */
+	uint_t		sav_npending;		/* # pending devices */
+};
+
+typedef struct spa_config_lock {
+	kmutex_t	scl_lock;
+	kthread_t	*scl_writer;
+	int		scl_write_wanted;
+	kcondvar_t	scl_cv;
+	zfs_refcount_t	scl_count;
+} spa_config_lock_t;
+
+typedef struct spa_config_dirent {
+	list_node_t	scd_link;
+	char		*scd_path;
+} spa_config_dirent_t;
+
+typedef enum zio_taskq_type {
+	ZIO_TASKQ_ISSUE = 0,
+	ZIO_TASKQ_ISSUE_HIGH,
+	ZIO_TASKQ_INTERRUPT,
+	ZIO_TASKQ_INTERRUPT_HIGH,
+	ZIO_TASKQ_TYPES
+} zio_taskq_type_t;
+
+/*
+ * State machine for the zpool-poolname process.  The states transitions
+ * are done as follows:
+ *
+ *	From		   To			Routine
+ *	PROC_NONE	-> PROC_CREATED		spa_activate()
+ *	PROC_CREATED	-> PROC_ACTIVE		spa_thread()
+ *	PROC_ACTIVE	-> PROC_DEACTIVATE	spa_deactivate()
+ *	PROC_DEACTIVATE	-> PROC_GONE		spa_thread()
+ *	PROC_GONE	-> PROC_NONE		spa_deactivate()
+ */
+typedef enum spa_proc_state {
+	SPA_PROC_NONE,		/* spa_proc = &p0, no process created */
+	SPA_PROC_CREATED,	/* spa_activate() has proc, is waiting */
+	SPA_PROC_ACTIVE,	/* taskqs created, spa_proc set */
+	SPA_PROC_DEACTIVATE,	/* spa_deactivate() requests process exit */
+	SPA_PROC_GONE		/* spa_thread() is exiting, spa_proc = &p0 */
+} spa_proc_state_t;
+
+typedef struct spa_taskqs {
+	uint_t stqs_count;
+	taskq_t **stqs_taskq;
+} spa_taskqs_t;
+
+typedef enum spa_all_vdev_zap_action {
+	AVZ_ACTION_NONE = 0,
+	AVZ_ACTION_DESTROY,	/* Destroy all per-vdev ZAPs and the AVZ. */
+	AVZ_ACTION_REBUILD,	/* Populate the new AVZ, see spa_avz_rebuild */
+	AVZ_ACTION_INITIALIZE
+} spa_avz_action_t;
+
+typedef enum spa_config_source {
+	SPA_CONFIG_SRC_NONE = 0,
+	SPA_CONFIG_SRC_SCAN,		/* scan of path (default: /dev/dsk) */
+	SPA_CONFIG_SRC_CACHEFILE,	/* any cachefile */
+	SPA_CONFIG_SRC_TRYIMPORT,	/* returned from call to tryimport */
+	SPA_CONFIG_SRC_SPLIT,		/* new pool in a pool split */
+	SPA_CONFIG_SRC_MOS		/* MOS, but not always from right txg */
+} spa_config_source_t;
+
+struct spa {
+	/*
+	 * Fields protected by spa_namespace_lock.
+	 */
+	char		spa_name[ZFS_MAX_DATASET_NAME_LEN];	/* pool name */
+	char		*spa_comment;		/* comment */
+	avl_node_t	spa_avl;		/* node in spa_namespace_avl */
+	nvlist_t	*spa_config;		/* last synced config */
+	nvlist_t	*spa_config_syncing;	/* currently syncing config */
+	nvlist_t	*spa_config_splitting;	/* config for splitting */
+	nvlist_t	*spa_load_info;		/* info and errors from load */
+	uint64_t	spa_config_txg;		/* txg of last config change */
+	int		spa_sync_pass;		/* iterate-to-convergence */
+	pool_state_t	spa_state;		/* pool state */
+	int		spa_inject_ref;		/* injection references */
+	uint8_t		spa_sync_on;		/* sync threads are running */
+	spa_load_state_t spa_load_state;	/* current load operation */
+	boolean_t	spa_indirect_vdevs_loaded; /* mappings loaded? */
+	boolean_t	spa_trust_config;	/* do we trust vdev tree? */
+	boolean_t	spa_is_splitting;	/* in the middle of a split? */
+	spa_config_source_t spa_config_source;	/* where config comes from? */
+	uint64_t	spa_import_flags;	/* import specific flags */
+	spa_taskqs_t	spa_zio_taskq[ZIO_TYPES][ZIO_TASKQ_TYPES];
+	dsl_pool_t	*spa_dsl_pool;
+	boolean_t	spa_is_initializing;	/* true while opening pool */
+	boolean_t	spa_is_exporting;	/* true while exporting pool */
+	metaslab_class_t *spa_normal_class;	/* normal data class */
+	metaslab_class_t *spa_log_class;	/* intent log data class */
+	metaslab_class_t *spa_special_class;	/* special allocation class */
+	metaslab_class_t *spa_dedup_class;	/* dedup allocation class */
+	uint64_t	spa_first_txg;		/* first txg after spa_open() */
+	uint64_t	spa_final_txg;		/* txg of export/destroy */
+	uint64_t	spa_freeze_txg;		/* freeze pool at this txg */
+	uint64_t	spa_load_max_txg;	/* best initial ub_txg */
+	uint64_t	spa_claim_max_txg;	/* highest claimed birth txg */
+	inode_timespec_t spa_loaded_ts;		/* 1st successful open time */
+	objset_t	*spa_meta_objset;	/* copy of dp->dp_meta_objset */
+	kmutex_t	spa_evicting_os_lock;	/* Evicting objset list lock */
+	list_t		spa_evicting_os_list;	/* Objsets being evicted. */
+	kcondvar_t	spa_evicting_os_cv;	/* Objset Eviction Completion */
+	txg_list_t	spa_vdev_txg_list;	/* per-txg dirty vdev list */
+	vdev_t		*spa_root_vdev;		/* top-level vdev container */
+	int		spa_min_ashift;		/* of vdevs in normal class */
+	int		spa_max_ashift;		/* of vdevs in normal class */
+	uint64_t	spa_config_guid;	/* config pool guid */
+	uint64_t	spa_load_guid;		/* spa_load initialized guid */
+	uint64_t	spa_last_synced_guid;	/* last synced guid */
+	list_t		spa_config_dirty_list;	/* vdevs with dirty config */
+	list_t		spa_state_dirty_list;	/* vdevs with dirty state */
+	/*
+	 * spa_alloc_locks and spa_alloc_trees are arrays, whose lengths are
+	 * stored in spa_alloc_count. There is one tree and one lock for each
+	 * allocator, to help improve allocation performance in write-heavy
+	 * workloads.
+	 */
+	kmutex_t	*spa_alloc_locks;
+	avl_tree_t	*spa_alloc_trees;
+	int		spa_alloc_count;
+
+	spa_aux_vdev_t	spa_spares;		/* hot spares */
+	spa_aux_vdev_t	spa_l2cache;		/* L2ARC cache devices */
+	nvlist_t	*spa_label_features;	/* Features for reading MOS */
+	uint64_t	spa_config_object;	/* MOS object for pool config */
+	uint64_t	spa_config_generation;	/* config generation number */
+	uint64_t	spa_syncing_txg;	/* txg currently syncing */
+	bpobj_t		spa_deferred_bpobj;	/* deferred-free bplist */
+	bplist_t	spa_free_bplist[TXG_SIZE]; /* bplist of stuff to free */
+	zio_cksum_salt_t spa_cksum_salt;	/* secret salt for cksum */
+	/* checksum context templates */
+	kmutex_t	spa_cksum_tmpls_lock;
+	void		*spa_cksum_tmpls[ZIO_CHECKSUM_FUNCTIONS];
+	uberblock_t	spa_ubsync;		/* last synced uberblock */
+	uberblock_t	spa_uberblock;		/* current uberblock */
+	boolean_t	spa_extreme_rewind;	/* rewind past deferred frees */
+	kmutex_t	spa_scrub_lock;		/* resilver/scrub lock */
+	uint64_t	spa_scrub_inflight;	/* in-flight scrub bytes */
+
+	/* in-flight verification bytes */
+	uint64_t	spa_load_verify_bytes;
+	kcondvar_t	spa_scrub_io_cv;	/* scrub I/O completion */
+	uint8_t		spa_scrub_active;	/* active or suspended? */
+	uint8_t		spa_scrub_type;		/* type of scrub we're doing */
+	uint8_t		spa_scrub_finished;	/* indicator to rotate logs */
+	uint8_t		spa_scrub_started;	/* started since last boot */
+	uint8_t		spa_scrub_reopen;	/* scrub doing vdev_reopen */
+	uint64_t	spa_scan_pass_start;	/* start time per pass/reboot */
+	uint64_t	spa_scan_pass_scrub_pause; /* scrub pause time */
+	uint64_t	spa_scan_pass_scrub_spent_paused; /* total paused */
+	uint64_t	spa_scan_pass_exam;	/* examined bytes per pass */
+	uint64_t	spa_scan_pass_issued;	/* issued bytes per pass */
+
+	/*
+	 * We are in the middle of a resilver, and another resilver
+	 * is needed once this one completes. This is set iff any
+	 * vdev_resilver_deferred is set.
+	 */
+	boolean_t	spa_resilver_deferred;
+	kmutex_t	spa_async_lock;		/* protect async state */
+	kthread_t	*spa_async_thread;	/* thread doing async task */
+	int		spa_async_suspended;	/* async tasks suspended */
+	kcondvar_t	spa_async_cv;		/* wait for thread_exit() */
+	uint16_t	spa_async_tasks;	/* async task mask */
+	uint64_t	spa_missing_tvds;	/* unopenable tvds on load */
+	uint64_t	spa_missing_tvds_allowed; /* allow loading spa? */
+
+	spa_removing_phys_t spa_removing_phys;
+	spa_vdev_removal_t *spa_vdev_removal;
+
+	spa_condensing_indirect_phys_t	spa_condensing_indirect_phys;
+	spa_condensing_indirect_t	*spa_condensing_indirect;
+	zthr_t		*spa_condense_zthr;	/* zthr doing condense. */
+
+	uint64_t	spa_checkpoint_txg;	/* the txg of the checkpoint */
+	spa_checkpoint_info_t spa_checkpoint_info; /* checkpoint accounting */
+	zthr_t		*spa_checkpoint_discard_zthr;
+
+	space_map_t	*spa_syncing_log_sm;	/* current log space map */
+	avl_tree_t	spa_sm_logs_by_txg;
+	kmutex_t	spa_flushed_ms_lock;	/* for metaslabs_by_flushed */
+	avl_tree_t	spa_metaslabs_by_flushed;
+	spa_unflushed_stats_t	spa_unflushed_stats;
+	list_t		spa_log_summary;
+	uint64_t	spa_log_flushall_txg;
+
+	zthr_t		*spa_livelist_delete_zthr; /* deleting livelists */
+	zthr_t		*spa_livelist_condense_zthr; /* condensing livelists */
+	uint64_t	spa_livelists_to_delete; /* set of livelists to free */
+	livelist_condense_entry_t	spa_to_condense; /* next to condense */
+
+	char		*spa_root;		/* alternate root directory */
+	uint64_t	spa_ena;		/* spa-wide ereport ENA */
+	int		spa_last_open_failed;	/* error if last open failed */
+	uint64_t	spa_last_ubsync_txg;	/* "best" uberblock txg */
+	uint64_t	spa_last_ubsync_txg_ts;	/* timestamp from that ub */
+	uint64_t	spa_load_txg;		/* ub txg that loaded */
+	uint64_t	spa_load_txg_ts;	/* timestamp from that ub */
+	uint64_t	spa_load_meta_errors;	/* verify metadata err count */
+	uint64_t	spa_load_data_errors;	/* verify data err count */
+	uint64_t	spa_verify_min_txg;	/* start txg of verify scrub */
+	kmutex_t	spa_errlog_lock;	/* error log lock */
+	uint64_t	spa_errlog_last;	/* last error log object */
+	uint64_t	spa_errlog_scrub;	/* scrub error log object */
+	kmutex_t	spa_errlist_lock;	/* error list/ereport lock */
+	avl_tree_t	spa_errlist_last;	/* last error list */
+	avl_tree_t	spa_errlist_scrub;	/* scrub error list */
+	uint64_t	spa_deflate;		/* should we deflate? */
+	uint64_t	spa_history;		/* history object */
+	kmutex_t	spa_history_lock;	/* history lock */
+	vdev_t		*spa_pending_vdev;	/* pending vdev additions */
+	kmutex_t	spa_props_lock;		/* property lock */
+	uint64_t	spa_pool_props_object;	/* object for properties */
+	uint64_t	spa_bootfs;		/* default boot filesystem */
+	uint64_t	spa_failmode;		/* failure mode for the pool */
+	uint64_t	spa_deadman_failmode;	/* failure mode for deadman */
+	uint64_t	spa_delegation;		/* delegation on/off */
+	list_t		spa_config_list;	/* previous cache file(s) */
+	/* per-CPU array of root of async I/O: */
+	zio_t		**spa_async_zio_root;
+	zio_t		*spa_suspend_zio_root;	/* root of all suspended I/O */
+	zio_t		*spa_txg_zio[TXG_SIZE]; /* spa_sync() waits for this */
+	kmutex_t	spa_suspend_lock;	/* protects suspend_zio_root */
+	kcondvar_t	spa_suspend_cv;		/* notification of resume */
+	zio_suspend_reason_t	spa_suspended;	/* pool is suspended */
+	uint8_t		spa_claiming;		/* pool is doing zil_claim() */
+	boolean_t	spa_is_root;		/* pool is root */
+	int		spa_minref;		/* num refs when first opened */
+	spa_mode_t	spa_mode;		/* SPA_MODE_{READ|WRITE} */
+	spa_log_state_t spa_log_state;		/* log state */
+	uint64_t	spa_autoexpand;		/* lun expansion on/off */
+	ddt_t		*spa_ddt[ZIO_CHECKSUM_FUNCTIONS]; /* in-core DDTs */
+	uint64_t	spa_ddt_stat_object;	/* DDT statistics */
+	uint64_t	spa_dedup_dspace;	/* Cache get_dedup_dspace() */
+	uint64_t	spa_dedup_checksum;	/* default dedup checksum */
+	uint64_t	spa_dspace;		/* dspace in normal class */
+	kmutex_t	spa_vdev_top_lock;	/* dueling offline/remove */
+	kmutex_t	spa_proc_lock;		/* protects spa_proc* */
+	kcondvar_t	spa_proc_cv;		/* spa_proc_state transitions */
+	spa_proc_state_t spa_proc_state;	/* see definition */
+	proc_t		*spa_proc;		/* "zpool-poolname" process */
+	uint64_t	spa_did;		/* if procp != p0, did of t1 */
+	boolean_t	spa_autoreplace;	/* autoreplace set in open */
+	int		spa_vdev_locks;		/* locks grabbed */
+	uint64_t	spa_creation_version;	/* version at pool creation */
+	uint64_t	spa_prev_software_version; /* See ub_software_version */
+	uint64_t	spa_feat_for_write_obj;	/* required to write to pool */
+	uint64_t	spa_feat_for_read_obj;	/* required to read from pool */
+	uint64_t	spa_feat_desc_obj;	/* Feature descriptions */
+	uint64_t	spa_feat_enabled_txg_obj; /* Feature enabled txg */
+	kmutex_t	spa_feat_stats_lock;	/* protects spa_feat_stats */
+	nvlist_t	*spa_feat_stats;	/* Cache of enabled features */
+	/* cache feature refcounts */
+	uint64_t	spa_feat_refcount_cache[SPA_FEATURES];
+	taskqid_t	spa_deadman_tqid;	/* Task id */
+	uint64_t	spa_deadman_calls;	/* number of deadman calls */
+	hrtime_t	spa_sync_starttime;	/* starting time of spa_sync */
+	uint64_t	spa_deadman_synctime;	/* deadman sync expiration */
+	uint64_t	spa_deadman_ziotime;	/* deadman zio expiration */
+	uint64_t	spa_all_vdev_zaps;	/* ZAP of per-vd ZAP obj #s */
+	spa_avz_action_t	spa_avz_action;	/* destroy/rebuild AVZ? */
+	uint64_t	spa_autotrim;		/* automatic background trim? */
+	uint64_t	spa_errata;		/* errata issues detected */
+	spa_stats_t	spa_stats;		/* assorted spa statistics */
+	spa_keystore_t	spa_keystore;		/* loaded crypto keys */
+
+	/* arc_memory_throttle() parameters during low memory condition */
+	uint64_t	spa_lowmem_page_load;	/* memory load during txg */
+	uint64_t	spa_lowmem_last_txg;	/* txg window start */
+
+	hrtime_t	spa_ccw_fail_time;	/* Conf cache write fail time */
+	taskq_t		*spa_zvol_taskq;	/* Taskq for minor management */
+	taskq_t		*spa_prefetch_taskq;	/* Taskq for prefetch threads */
+	uint64_t	spa_multihost;		/* multihost aware (mmp) */
+	mmp_thread_t	spa_mmp;		/* multihost mmp thread */
+	list_t		spa_leaf_list;		/* list of leaf vdevs */
+	uint64_t	spa_leaf_list_gen;	/* track leaf_list changes */
+	uint32_t	spa_hostid;		/* cached system hostid */
+
+	/* synchronization for threads in spa_wait */
+	kmutex_t	spa_activities_lock;
+	kcondvar_t	spa_activities_cv;
+	kcondvar_t	spa_waiters_cv;
+	int		spa_waiters;		/* number of waiting threads */
+	boolean_t	spa_waiters_cancel;	/* waiters should return */
+
+	/*
+	 * spa_refcount & spa_config_lock must be the last elements
+	 * because zfs_refcount_t changes size based on compilation options.
+	 * In order for the MDB module to function correctly, the other
+	 * fields must remain in the same location.
+	 */
+	spa_config_lock_t spa_config_lock[SCL_LOCKS]; /* config changes */
+	zfs_refcount_t	spa_refcount;		/* number of opens */
+
+	taskq_t		*spa_upgrade_taskq;	/* taskq for upgrade jobs */
+};
+
+extern char *spa_config_path;
+extern char *zfs_deadman_failmode;
+extern int spa_slop_shift;
+extern void spa_taskq_dispatch_ent(spa_t *spa, zio_type_t t, zio_taskq_type_t q,
+    task_func_t *func, void *arg, uint_t flags, taskq_ent_t *ent);
+extern void spa_taskq_dispatch_sync(spa_t *, zio_type_t t, zio_taskq_type_t q,
+    task_func_t *func, void *arg, uint_t flags);
+extern void spa_load_spares(spa_t *spa);
+extern void spa_load_l2cache(spa_t *spa);
+extern sysevent_t *spa_event_create(spa_t *spa, vdev_t *vd, nvlist_t *hist_nvl,
+    const char *name);
+extern void spa_event_post(sysevent_t *ev);
+extern int param_set_deadman_failmode_common(const char *val);
+extern void spa_set_deadman_synctime(hrtime_t ns);
+extern void spa_set_deadman_ziotime(hrtime_t ns);
+extern const char *spa_history_zone(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_SPA_IMPL_H */
diff --git a/include/sys/spa_log_spacemap.h b/include/sys/spa_log_spacemap.h
new file mode 100644
index 0000000000000..b2ed77fac3e40
--- /dev/null
+++ b/include/sys/spa_log_spacemap.h
@@ -0,0 +1,79 @@
+/*
+ * 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) 2018, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_SPA_LOG_SPACEMAP_H
+#define	_SYS_SPA_LOG_SPACEMAP_H
+
+#include <sys/avl.h>
+
+typedef struct log_summary_entry {
+	uint64_t lse_start;	/* start TXG */
+	uint64_t lse_mscount;	/* # of metaslabs needed to be flushed */
+	uint64_t lse_blkcount;	/* blocks held by this entry  */
+	list_node_t lse_node;
+} log_summary_entry_t;
+
+typedef struct spa_unflushed_stats  {
+	/* used for memory heuristic */
+	uint64_t sus_memused;	/* current memory used for unflushed trees */
+
+	/* used for block heuristic */
+	uint64_t sus_blocklimit;	/* max # of log blocks allowed */
+	uint64_t sus_nblocks;	/* # of blocks in log space maps currently */
+} spa_unflushed_stats_t;
+
+typedef struct spa_log_sm {
+	uint64_t sls_sm_obj;	/* space map object ID */
+	uint64_t sls_txg;	/* txg logged on the space map */
+	uint64_t sls_nblocks;	/* number of blocks in this log */
+	uint64_t sls_mscount;	/* # of metaslabs flushed in the log's txg */
+	avl_node_t sls_node;	/* node in spa_sm_logs_by_txg */
+} spa_log_sm_t;
+
+int spa_ld_log_spacemaps(spa_t *);
+
+void spa_generate_syncing_log_sm(spa_t *, dmu_tx_t *);
+void spa_flush_metaslabs(spa_t *, dmu_tx_t *);
+void spa_sync_close_syncing_log_sm(spa_t *);
+
+void spa_cleanup_old_sm_logs(spa_t *, dmu_tx_t *);
+
+uint64_t spa_log_sm_blocklimit(spa_t *);
+void spa_log_sm_set_blocklimit(spa_t *);
+uint64_t spa_log_sm_nblocks(spa_t *);
+uint64_t spa_log_sm_memused(spa_t *);
+
+void spa_log_sm_decrement_mscount(spa_t *, uint64_t);
+void spa_log_sm_increment_current_mscount(spa_t *);
+
+void spa_log_summary_add_flushed_metaslab(spa_t *);
+void spa_log_summary_decrement_mscount(spa_t *, uint64_t);
+void spa_log_summary_decrement_blkcount(spa_t *, uint64_t);
+
+boolean_t spa_flush_all_logs_requested(spa_t *);
+
+extern int zfs_keep_log_spacemaps_at_export;
+
+#endif /* _SYS_SPA_LOG_SPACEMAP_H */
diff --git a/include/sys/space_map.h b/include/sys/space_map.h
new file mode 100644
index 0000000000000..cb81e710bd1e8
--- /dev/null
+++ b/include/sys/space_map.h
@@ -0,0 +1,246 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2012, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_SPACE_MAP_H
+#define	_SYS_SPACE_MAP_H
+
+#include <sys/avl.h>
+#include <sys/range_tree.h>
+#include <sys/dmu.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * The size of the space map object has increased to include a histogram.
+ * The SPACE_MAP_SIZE_V0 designates the original size and is used to
+ * maintain backward compatibility.
+ */
+#define	SPACE_MAP_SIZE_V0	(3 * sizeof (uint64_t))
+#define	SPACE_MAP_HISTOGRAM_SIZE	32
+
+/*
+ * The space_map_phys is the on-disk representation of the space map.
+ * Consumers of space maps should never reference any of the members of this
+ * structure directly. These members may only be updated in syncing context.
+ *
+ * Note the smp_object is no longer used but remains in the structure
+ * for backward compatibility.
+ */
+typedef struct space_map_phys {
+	/* object number: not needed but kept for backwards compatibility */
+	uint64_t	smp_object;
+
+	/* length of the object in bytes */
+	uint64_t	smp_length;
+
+	/* space allocated from the map */
+	int64_t		smp_alloc;
+
+	/* reserved */
+	uint64_t	smp_pad[5];
+
+	/*
+	 * The smp_histogram maintains a histogram of free regions. Each
+	 * bucket, smp_histogram[i], contains the number of free regions
+	 * whose size is:
+	 * 2^(i+sm_shift) <= size of free region in bytes < 2^(i+sm_shift+1)
+	 *
+	 * Note that, if log space map feature is enabled, histograms of
+	 * space maps that belong to metaslabs will take into account any
+	 * unflushed changes for their metaslabs, even though the actual
+	 * space map doesn't have entries for these changes.
+	 */
+	uint64_t	smp_histogram[SPACE_MAP_HISTOGRAM_SIZE];
+} space_map_phys_t;
+
+/*
+ * The space map object defines a region of space, its size, how much is
+ * allocated, and the on-disk object that stores this information.
+ * Consumers of space maps may only access the members of this structure.
+ *
+ * Note: the space_map may not be accessed concurrently; consumers
+ * must provide external locking if required.
+ */
+typedef struct space_map {
+	uint64_t	sm_start;	/* start of map */
+	uint64_t	sm_size;	/* size of map */
+	uint8_t		sm_shift;	/* unit shift */
+	objset_t	*sm_os;		/* objset for this map */
+	uint64_t	sm_object;	/* object id for this map */
+	uint32_t	sm_blksz;	/* block size for space map */
+	dmu_buf_t	*sm_dbuf;	/* space_map_phys_t dbuf */
+	space_map_phys_t *sm_phys;	/* on-disk space map */
+} space_map_t;
+
+/*
+ * debug entry
+ *
+ *     2     2        10                     50
+ *  +-----+-----+------------+----------------------------------+
+ *  | 1 0 | act |  syncpass  |        txg (lower bits)          |
+ *  +-----+-----+------------+----------------------------------+
+ *   63 62 61 60 59        50 49                                0
+ *
+ *
+ * one-word entry
+ *
+ *    1               47                   1           15
+ *  +-----------------------------------------------------------+
+ *  | 0 |   offset (sm_shift units)    | type |       run       |
+ *  +-----------------------------------------------------------+
+ *   63  62                          16   15   14               0
+ *
+ *
+ * two-word entry
+ *
+ *     2     2               36                      24
+ *  +-----+-----+---------------------------+-------------------+
+ *  | 1 1 | pad |            run            |       vdev        |
+ *  +-----+-----+---------------------------+-------------------+
+ *   63 62 61 60 59                       24 23                 0
+ *
+ *     1                            63
+ *  +------+----------------------------------------------------+
+ *  | type |                      offset                        |
+ *  +------+----------------------------------------------------+
+ *     63   62                                                  0
+ *
+ * Note that a two-word entry will not straddle a block boundary.
+ * If necessary, the last word of a block will be padded with a
+ * debug entry (with act = syncpass = txg = 0).
+ */
+
+typedef enum {
+	SM_ALLOC,
+	SM_FREE
+} maptype_t;
+
+typedef struct space_map_entry {
+	maptype_t sme_type;
+	uint32_t sme_vdev;	/* max is 2^24-1; SM_NO_VDEVID if not present */
+	uint64_t sme_offset;	/* max is 2^63-1; units of sm_shift */
+	uint64_t sme_run;	/* max is 2^36; units of sm_shift */
+
+	/*
+	 * The following fields are not part of the actual space map entry
+	 * on-disk and they are populated with the values from the debug
+	 * entry most recently visited starting from the beginning to the
+	 * end of the space map.
+	 */
+	uint64_t sme_txg;
+	uint64_t sme_sync_pass;
+} space_map_entry_t;
+
+#define	SM_NO_VDEVID	(1 << SPA_VDEVBITS)
+
+/* one-word entry constants */
+#define	SM_DEBUG_PREFIX	2
+#define	SM_OFFSET_BITS	47
+#define	SM_RUN_BITS	15
+
+/* two-word entry constants */
+#define	SM2_PREFIX	3
+#define	SM2_OFFSET_BITS	63
+#define	SM2_RUN_BITS	36
+
+#define	SM_PREFIX_DECODE(x)	BF64_DECODE(x, 62, 2)
+#define	SM_PREFIX_ENCODE(x)	BF64_ENCODE(x, 62, 2)
+
+#define	SM_DEBUG_ACTION_DECODE(x)	BF64_DECODE(x, 60, 2)
+#define	SM_DEBUG_ACTION_ENCODE(x)	BF64_ENCODE(x, 60, 2)
+#define	SM_DEBUG_SYNCPASS_DECODE(x)	BF64_DECODE(x, 50, 10)
+#define	SM_DEBUG_SYNCPASS_ENCODE(x)	BF64_ENCODE(x, 50, 10)
+#define	SM_DEBUG_TXG_DECODE(x)		BF64_DECODE(x, 0, 50)
+#define	SM_DEBUG_TXG_ENCODE(x)		BF64_ENCODE(x, 0, 50)
+
+#define	SM_OFFSET_DECODE(x)	BF64_DECODE(x, 16, SM_OFFSET_BITS)
+#define	SM_OFFSET_ENCODE(x)	BF64_ENCODE(x, 16, SM_OFFSET_BITS)
+#define	SM_TYPE_DECODE(x)	BF64_DECODE(x, 15, 1)
+#define	SM_TYPE_ENCODE(x)	BF64_ENCODE(x, 15, 1)
+#define	SM_RUN_DECODE(x)	(BF64_DECODE(x, 0, SM_RUN_BITS) + 1)
+#define	SM_RUN_ENCODE(x)	BF64_ENCODE((x) - 1, 0, SM_RUN_BITS)
+#define	SM_RUN_MAX		SM_RUN_DECODE(~0ULL)
+#define	SM_OFFSET_MAX		SM_OFFSET_DECODE(~0ULL)
+
+#define	SM2_RUN_DECODE(x)	(BF64_DECODE(x, SPA_VDEVBITS, SM2_RUN_BITS) + 1)
+#define	SM2_RUN_ENCODE(x)	BF64_ENCODE((x) - 1, SPA_VDEVBITS, SM2_RUN_BITS)
+#define	SM2_VDEV_DECODE(x)	BF64_DECODE(x, 0, SPA_VDEVBITS)
+#define	SM2_VDEV_ENCODE(x)	BF64_ENCODE(x, 0, SPA_VDEVBITS)
+#define	SM2_TYPE_DECODE(x)	BF64_DECODE(x, SM2_OFFSET_BITS, 1)
+#define	SM2_TYPE_ENCODE(x)	BF64_ENCODE(x, SM2_OFFSET_BITS, 1)
+#define	SM2_OFFSET_DECODE(x)	BF64_DECODE(x, 0, SM2_OFFSET_BITS)
+#define	SM2_OFFSET_ENCODE(x)	BF64_ENCODE(x, 0, SM2_OFFSET_BITS)
+#define	SM2_RUN_MAX		SM2_RUN_DECODE(~0ULL)
+#define	SM2_OFFSET_MAX		SM2_OFFSET_DECODE(~0ULL)
+
+boolean_t sm_entry_is_debug(uint64_t e);
+boolean_t sm_entry_is_single_word(uint64_t e);
+boolean_t sm_entry_is_double_word(uint64_t e);
+
+typedef int (*sm_cb_t)(space_map_entry_t *sme, void *arg);
+
+int space_map_load(space_map_t *sm, range_tree_t *rt, maptype_t maptype);
+int space_map_load_length(space_map_t *sm, range_tree_t *rt, maptype_t maptype,
+    uint64_t length);
+int space_map_iterate(space_map_t *sm, uint64_t length,
+    sm_cb_t callback, void *arg);
+int space_map_incremental_destroy(space_map_t *sm, sm_cb_t callback, void *arg,
+    dmu_tx_t *tx);
+
+boolean_t space_map_histogram_verify(space_map_t *sm, range_tree_t *rt);
+void space_map_histogram_clear(space_map_t *sm);
+void space_map_histogram_add(space_map_t *sm, range_tree_t *rt,
+    dmu_tx_t *tx);
+
+uint64_t space_map_object(space_map_t *sm);
+int64_t space_map_allocated(space_map_t *sm);
+uint64_t space_map_length(space_map_t *sm);
+uint64_t space_map_entries(space_map_t *sm, range_tree_t *rt);
+uint64_t space_map_nblocks(space_map_t *sm);
+
+void space_map_write(space_map_t *sm, range_tree_t *rt, maptype_t maptype,
+    uint64_t vdev_id, dmu_tx_t *tx);
+uint64_t space_map_estimate_optimal_size(space_map_t *sm, range_tree_t *rt,
+    uint64_t vdev_id);
+void space_map_truncate(space_map_t *sm, int blocksize, dmu_tx_t *tx);
+uint64_t space_map_alloc(objset_t *os, int blocksize, dmu_tx_t *tx);
+void space_map_free(space_map_t *sm, dmu_tx_t *tx);
+void space_map_free_obj(objset_t *os, uint64_t smobj, dmu_tx_t *tx);
+
+int space_map_open(space_map_t **smp, objset_t *os, uint64_t object,
+    uint64_t start, uint64_t size, uint8_t shift);
+void space_map_close(space_map_t *sm);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_SPACE_MAP_H */
diff --git a/include/sys/space_reftree.h b/include/sys/space_reftree.h
new file mode 100644
index 0000000000000..ca9d41dc1388e
--- /dev/null
+++ b/include/sys/space_reftree.h
@@ -0,0 +1,57 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2013 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_SPACE_REFTREE_H
+#define	_SYS_SPACE_REFTREE_H
+
+#include <sys/range_tree.h>
+#include <sys/avl.h>
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct space_ref {
+	avl_node_t	sr_node;	/* AVL node */
+	uint64_t	sr_offset;	/* range offset (start or end) */
+	int64_t		sr_refcnt;	/* associated reference count */
+} space_ref_t;
+
+void space_reftree_create(avl_tree_t *t);
+void space_reftree_destroy(avl_tree_t *t);
+void space_reftree_add_seg(avl_tree_t *t, uint64_t start, uint64_t end,
+    int64_t refcnt);
+void space_reftree_add_map(avl_tree_t *t, range_tree_t *rt, int64_t refcnt);
+void space_reftree_generate_map(avl_tree_t *t, range_tree_t *rt,
+    int64_t minref);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_SPACE_REFTREE_H */
diff --git a/include/sys/sysevent.h b/include/sys/sysevent.h
new file mode 100644
index 0000000000000..6510297d601fe
--- /dev/null
+++ b/include/sys/sysevent.h
@@ -0,0 +1,36 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_SYSEVENT_H
+#define	_SYS_SYSEVENT_H
+
+#include <sys/nvpair.h>
+
+typedef struct sysevent {
+	nvlist_t *resource;
+} sysevent_t;
+
+#endif
diff --git a/include/sys/sysevent/Makefile.am b/include/sys/sysevent/Makefile.am
new file mode 100644
index 0000000000000..64e53763951aa
--- /dev/null
+++ b/include/sys/sysevent/Makefile.am
@@ -0,0 +1,15 @@
+COMMON_H = \
+	eventdefs.h \
+	dev.h
+
+if CONFIG_USER
+libzfsdir = $(includedir)/libzfs/sys/sysevent
+libzfs_HEADERS = $(COMMON_H)
+endif
+
+if CONFIG_KERNEL
+if BUILD_LINUX
+kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys/sysevent
+kernel_HEADERS = $(COMMON_H)
+endif
+endif
diff --git a/include/sys/sysevent/dev.h b/include/sys/sysevent/dev.h
new file mode 100644
index 0000000000000..1117538d822da
--- /dev/null
+++ b/include/sys/sysevent/dev.h
@@ -0,0 +1,261 @@
+/*
+ * 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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_SYSEVENT_DEV_H
+#define	_SYS_SYSEVENT_DEV_H
+
+#include <sys/sysevent/eventdefs.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Event schema for EC_DEV_ADD/ESC_DISK
+ *
+ *	Event Class 	- EC_DEV_ADD
+ *	Event Sub-Class - ESC_DISK
+ *
+ *	Attribute Name	- EV_VERSION
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- event version number
+ *
+ *	Attribute Name	- DEV_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- /dev name to the raw device.
+ *			  The name does not include the slice number component.
+ *
+ *	Attribute Name	- DEV_PHYS_PATH
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- physical path of the device without the "/devices"
+ *			  prefix.
+ *
+ *	Attribute Name	- DEV_DRIVER_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- driver name
+ *
+ *	Attribute Name	- DEV_INSTANCE
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- driver instance number
+ *
+ *	Attribute Name	- DEV_PROP_PREFIX<devinfo_node_property>
+ *	Attribute Type	- data type of the devinfo_node_property
+ *	Attribute Value	- value of the devinfo_node_property
+ *
+ *
+ * Event schema for EC_DEV_ADD/ESC_NETWORK
+ *
+ *	Event Class 	- EC_DEV_ADD
+ *	Event Sub-Class - ESC_NETWORK
+ *
+ *	Attribute Name	- EV_VERSION
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- event version number
+ *
+ *	Attribute Name	- DEV_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- /dev name associated with the device if exists.
+ *			  /dev name associated with the driver for DLPI
+ *			  Style-2 only drivers.
+ *
+ *	Attribute Name	- DEV_PHYS_PATH
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- physical path of the device without the "/devices"
+ *			  prefix.
+ *
+ *	Attribute Name	- DEV_DRIVER_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- driver name
+ *
+ *	Attribute Name	- DEV_INSTANCE
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- driver instance number
+ *
+ *	Attribute Name	- DEV_PROP_PREFIX<devinfo_node_property>
+ *	Attribute Type	- data type of the devinfo_node_property
+ *	Attribute Value	- value of the devinfo_node_property
+ *
+ *
+ * Event schema for EC_DEV_ADD/ESC_PRINTER
+ *
+ *	Event Class 	- EC_DEV_ADD
+ *	Event Sub-Class - ESC_PRINTER
+ *
+ *	Attribute Name	- EV_VERSION
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- event version number
+ *
+ *	Attribute Name	- DEV_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- /dev/printers name associated with the device
+ *			  if exists.
+ *			  /dev name associated with the device if it exists
+ *
+ *	Attribute Name	- DEV_PHYS_PATH
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- physical path of the device without the "/devices"
+ *			  prefix.
+ *
+ *	Attribute Name	- DEV_DRIVER_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- driver name
+ *
+ *	Attribute Name	- DEV_INSTANCE
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- driver instance number
+ *
+ *	Attribute Name	- DEV_PROP_PREFIX<devinfo_node_property>
+ *	Attribute Type	- data type of the devinfo_node_property
+ *	Attribute Value	- value of the devinfo_node_property
+ *
+ *
+ * Event schema for EC_DEV_REMOVE/ESC_DISK
+ *
+ *	Event Class 	- EC_DEV_REMOVE
+ *	Event Sub-Class - ESC_DISK
+ *
+ *	Attribute Name	- EV_VERSION
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- event version number
+ *
+ *	Attribute Name	- DEV_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- /dev name to the raw device.
+ *			  The name does not include the slice number component.
+ *
+ *	Attribute Name	- DEV_PHYS_PATH
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- physical path of the device without the "/devices"
+ *			  prefix.
+ *
+ *	Attribute Name	- DEV_DRIVER_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- driver name
+ *
+ *	Attribute Name	- DEV_INSTANCE
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- driver instance number
+ *
+ *
+ * Event schema for EC_DEV_REMOVE/ESC_NETWORK
+ *
+ *	Event Class 	- EC_DEV_REMOVE
+ *	Event Sub-Class - ESC_NETWORK
+ *
+ *	Attribute Name	- EV_VERSION
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- event version number
+ *
+ *	Attribute Name	- DEV_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- /dev name associated with the device if exists.
+ *			  /dev name associated with the driver for DLPI
+ *			  Style-2 only drivers.
+ *
+ *	Attribute Name	- DEV_PHYS_PATH
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- physical path of the device without the "/devices"
+ *			  prefix.
+ *
+ *	Attribute Name	- DEV_DRIVER_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- driver name
+ *
+ *	Attribute Name	- DEV_INSTANCE
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- driver instance number
+ *
+ *
+ * Event schema for EC_DEV_REMOVE/ESC_PRINTER
+ *
+ *	Event Class 	- EC_DEV_REMOVE
+ *	Event Sub-Class - ESC_PRINTER
+ *
+ *	Attribute Name	- EV_VERSION
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- event version number
+ *
+ *	Attribute Name	- DEV_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- /dev/printers name associated with the device
+ *			  if exists.
+ *			  /dev name associated with the device if it exists
+ *
+ *	Attribute Name	- DEV_PHYS_PATH
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- physical path of the device without the "/devices"
+ *			  prefix.
+ *
+ *	Attribute Name	- DEV_DRIVER_NAME
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- driver name
+ *
+ *	Attribute Name	- DEV_INSTANCE
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- driver instance number
+ *
+ *
+ * Event schema for EC_DEV_BRANCH/ESC_DEV_BRANCH_ADD or ESC_DEV_BRANCH_REMOVE
+ *
+ *	Event Class 	- EC_DEV_BRANCH
+ *	Event Sub-Class - ESC_DEV_BRANCH_ADD or ESC_DEV_BRANCH_REMOVE
+ *
+ *	Attribute Name	- EV_VERSION
+ *	Attribute Type	- DATA_TYPE_INT32
+ *	Attribute Value	- event version number
+ *
+ *	Attribute Name	- DEV_PHYS_PATH
+ *	Attribute Type	- DATA_TYPE_STRING
+ *	Attribute Value	- physical path to the root node of the device subtree
+ *			  without the "/devices" prefix.
+ */
+
+#define	EV_VERSION		"version"
+#define	DEV_PHYS_PATH		"phys_path"
+#define	DEV_NAME		"dev_name"
+#define	DEV_DRIVER_NAME		"driver_name"
+#define	DEV_INSTANCE		"instance"
+#define	DEV_PROP_PREFIX		"prop-"
+
+#ifdef __linux__
+#define	DEV_IDENTIFIER		"devid"
+#define	DEV_PATH		"path"
+#define	DEV_IS_PART		"is_slice"
+#define	DEV_SIZE		"dev_size"
+#endif /* __linux__ */
+
+#define	EV_V1			1
+
+/* maximum number of devinfo node properties added to the event */
+#define	MAX_PROP_COUNT		100
+
+/* only properties with size less than PROP_LEN_LIMIT are added to the event */
+#define	PROP_LEN_LIMIT		1024
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_SYSEVENT_DEV_H */
diff --git a/include/sys/sysevent/eventdefs.h b/include/sys/sysevent/eventdefs.h
new file mode 100644
index 0000000000000..2067b355afb48
--- /dev/null
+++ b/include/sys/sysevent/eventdefs.h
@@ -0,0 +1,136 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
+ * Copyright 2017 Joyent, Inc.
+ */
+
+#ifndef	_SYS_SYSEVENT_EVENTDEFS_H
+#define	_SYS_SYSEVENT_EVENTDEFS_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * eventdefs.h contains public definitions for sysevent types (classes
+ * and subclasses).  All additions/removal/changes are subject
+ * to PSARC approval.
+ */
+
+/* Sysevent Class definitions */
+#define	EC_NONE		"EC_none"
+#define	EC_PRIV		"EC_priv"
+#define	EC_PLATFORM	"EC_platform"	/* events private to platform */
+#define	EC_DR		"EC_dr"	/* Dynamic reconfiguration event class */
+#define	EC_ENV		"EC_env"	/* Environmental monitor event class */
+#define	EC_DOMAIN	"EC_domain"	/* Domain event class */
+#define	EC_AP_DRIVER	"EC_ap_driver"	/* Alternate Pathing event class */
+#define	EC_IPMP		"EC_ipmp"	/* IP Multipathing event class */
+#define	EC_DEV_ADD	"EC_dev_add"	/* device add event class */
+#define	EC_DEV_REMOVE	"EC_dev_remove"	/* device remove event class */
+#define	EC_DEV_BRANCH	"EC_dev_branch"	/* device tree branch event class */
+#define	EC_DEV_STATUS	"EC_dev_status"	/* device status event class */
+#define	EC_FM		"EC_fm"		/* FMA error report event */
+#define	EC_ZFS		"EC_zfs"	/* ZFS event */
+#define	EC_DATALINK	"EC_datalink"	/* datalink event */
+#define	EC_VRRP		"EC_vrrp"	/* VRRP event */
+
+/*
+ * EC_DEV_ADD and EC_DEV_REMOVE subclass definitions - supporting attributes
+ * (name/value pairs) are found in sys/sysevent/dev.h
+ */
+#define	ESC_DISK	"disk"		/* disk device */
+#define	ESC_NETWORK	"network"	/* network interface */
+#define	ESC_PRINTER	"printer"	/* printer device */
+#define	ESC_LOFI	"lofi"		/* lofi device */
+
+/*
+ * EC_DEV_BRANCH subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/dev.h
+ */
+
+/* device tree branch added */
+#define	ESC_DEV_BRANCH_ADD	"dev_branch_add"
+
+/* device tree branch removed */
+#define	ESC_DEV_BRANCH_REMOVE	"dev_branch_remove"
+
+/*
+ * EC_DEV_STATUS subclass definitions
+ *
+ * device capacity dynamically changed
+ */
+#define	ESC_DEV_DLE		"dev_dle"
+
+/* LUN has received an eject request from the user */
+#define	ESC_DEV_EJECT_REQUEST	"dev_eject_request"
+
+/* FMA Fault and Error event protocol subclass */
+#define	ESC_FM_ERROR		"error"
+#define	ESC_FM_ERROR_REPLAY	"error_replay"
+
+/*
+ * ZFS subclass definitions.  supporting attributes (name/value paris) are found
+ * in sys/fs/zfs.h
+ */
+#define	ESC_ZFS_RESILVER_START		"resilver_start"
+#define	ESC_ZFS_RESILVER_FINISH		"resilver_finish"
+#define	ESC_ZFS_VDEV_REMOVE		"vdev_remove"
+#define	ESC_ZFS_VDEV_REMOVE_AUX		"vdev_remove_aux"
+#define	ESC_ZFS_VDEV_REMOVE_DEV		"vdev_remove_dev"
+#define	ESC_ZFS_POOL_CREATE		"pool_create"
+#define	ESC_ZFS_POOL_DESTROY		"pool_destroy"
+#define	ESC_ZFS_POOL_IMPORT		"pool_import"
+#define	ESC_ZFS_POOL_EXPORT		"pool_export"
+#define	ESC_ZFS_VDEV_ADD		"vdev_add"
+#define	ESC_ZFS_VDEV_ATTACH		"vdev_attach"
+#define	ESC_ZFS_VDEV_CLEAR		"vdev_clear"
+#define	ESC_ZFS_VDEV_CHECK		"vdev_check"
+#define	ESC_ZFS_VDEV_ONLINE		"vdev_online"
+#define	ESC_ZFS_CONFIG_SYNC		"config_sync"
+#define	ESC_ZFS_SCRUB_START		"scrub_start"
+#define	ESC_ZFS_SCRUB_FINISH		"scrub_finish"
+#define	ESC_ZFS_SCRUB_ABORT		"scrub_abort"
+#define	ESC_ZFS_SCRUB_RESUME		"scrub_resume"
+#define	ESC_ZFS_SCRUB_PAUSED		"scrub_paused"
+#define	ESC_ZFS_VDEV_SPARE		"vdev_spare"
+#define	ESC_ZFS_VDEV_AUTOEXPAND		"vdev_autoexpand"
+#define	ESC_ZFS_BOOTFS_VDEV_ATTACH	"bootfs_vdev_attach"
+#define	ESC_ZFS_POOL_REGUID		"pool_reguid"
+#define	ESC_ZFS_HISTORY_EVENT		"history_event"
+#define	ESC_ZFS_TRIM_START		"trim_start"
+#define	ESC_ZFS_TRIM_FINISH		"trim_finish"
+#define	ESC_ZFS_TRIM_CANCEL		"trim_cancel"
+#define	ESC_ZFS_TRIM_RESUME		"trim_resume"
+#define	ESC_ZFS_TRIM_SUSPEND		"trim_suspend"
+
+/*
+ * datalink subclass definitions.
+ */
+#define	ESC_DATALINK_PHYS_ADD	"datalink_phys_add"	/* new physical link */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_SYSEVENT_EVENTDEFS_H */
diff --git a/include/sys/txg.h b/include/sys/txg.h
new file mode 100644
index 0000000000000..260a3b43cfe87
--- /dev/null
+++ b/include/sys/txg.h
@@ -0,0 +1,153 @@
+/*
+ * 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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*
+ * Copyright (c) 2012, 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_TXG_H
+#define	_SYS_TXG_H
+
+#include <sys/spa.h>
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	TXG_CONCURRENT_STATES	3	/* open, quiescing, syncing	*/
+#define	TXG_SIZE		4		/* next power of 2	*/
+#define	TXG_MASK		(TXG_SIZE - 1)	/* mask for size	*/
+#define	TXG_INITIAL		TXG_SIZE	/* initial txg 		*/
+#define	TXG_IDX			(txg & TXG_MASK)
+
+/* Number of txgs worth of frees we defer adding to in-core spacemaps */
+#define	TXG_DEFER_SIZE		2
+
+typedef struct tx_cpu tx_cpu_t;
+
+typedef struct txg_handle {
+	tx_cpu_t	*th_cpu;
+	uint64_t	th_txg;
+} txg_handle_t;
+
+typedef struct txg_node {
+	struct txg_node	*tn_next[TXG_SIZE];
+	uint8_t		tn_member[TXG_SIZE];
+} txg_node_t;
+
+typedef struct txg_list {
+	kmutex_t	tl_lock;
+	size_t		tl_offset;
+	spa_t		*tl_spa;
+	txg_node_t	*tl_head[TXG_SIZE];
+} txg_list_t;
+
+struct dsl_pool;
+
+extern void txg_init(struct dsl_pool *dp, uint64_t txg);
+extern void txg_fini(struct dsl_pool *dp);
+extern void txg_sync_start(struct dsl_pool *dp);
+extern void txg_sync_stop(struct dsl_pool *dp);
+extern uint64_t txg_hold_open(struct dsl_pool *dp, txg_handle_t *txghp);
+extern void txg_rele_to_quiesce(txg_handle_t *txghp);
+extern void txg_rele_to_sync(txg_handle_t *txghp);
+extern void txg_register_callbacks(txg_handle_t *txghp, list_t *tx_callbacks);
+
+extern void txg_delay(struct dsl_pool *dp, uint64_t txg, hrtime_t delta,
+    hrtime_t resolution);
+extern void txg_kick(struct dsl_pool *dp);
+
+/*
+ * Wait until the given transaction group has finished syncing.
+ * Try to make this happen as soon as possible (eg. kick off any
+ * necessary syncs immediately).  If txg==0, wait for the currently open
+ * txg to finish syncing.
+ */
+extern void txg_wait_synced(struct dsl_pool *dp, uint64_t txg);
+
+/*
+ * Wait as above. Returns true if the thread was signaled while waiting.
+ */
+extern boolean_t txg_wait_synced_sig(struct dsl_pool *dp, uint64_t txg);
+
+/*
+ * Wait until the given transaction group, or one after it, is
+ * the open transaction group.  Try to make this happen as soon
+ * as possible (eg. kick off any necessary syncs immediately) when
+ * should_quiesce is set.  If txg == 0, wait for the next open txg.
+ */
+extern void txg_wait_open(struct dsl_pool *dp, uint64_t txg,
+    boolean_t should_quiesce);
+
+/*
+ * Returns TRUE if we are "backed up" waiting for the syncing
+ * transaction to complete; otherwise returns FALSE.
+ */
+extern boolean_t txg_stalled(struct dsl_pool *dp);
+
+/* returns TRUE if someone is waiting for the next txg to sync */
+extern boolean_t txg_sync_waiting(struct dsl_pool *dp);
+
+extern void txg_verify(spa_t *spa, uint64_t txg);
+
+/*
+ * Wait for pending commit callbacks of already-synced transactions to finish
+ * processing.
+ */
+extern void txg_wait_callbacks(struct dsl_pool *dp);
+
+/*
+ * Per-txg object lists.
+ */
+
+#define	TXG_CLEAN(txg)	((txg) - 1)
+
+extern void txg_list_create(txg_list_t *tl, spa_t *spa, size_t offset);
+extern void txg_list_destroy(txg_list_t *tl);
+extern boolean_t txg_list_empty(txg_list_t *tl, uint64_t txg);
+extern boolean_t txg_all_lists_empty(txg_list_t *tl);
+extern boolean_t txg_list_add(txg_list_t *tl, void *p, uint64_t txg);
+extern boolean_t txg_list_add_tail(txg_list_t *tl, void *p, uint64_t txg);
+extern void *txg_list_remove(txg_list_t *tl, uint64_t txg);
+extern void *txg_list_remove_this(txg_list_t *tl, void *p, uint64_t txg);
+extern boolean_t txg_list_member(txg_list_t *tl, void *p, uint64_t txg);
+extern void *txg_list_head(txg_list_t *tl, uint64_t txg);
+extern void *txg_list_next(txg_list_t *tl, void *p, uint64_t txg);
+
+/* Global tuning */
+extern int zfs_txg_timeout;
+
+
+#ifdef ZFS_DEBUG
+#define	TXG_VERIFY(spa, txg)		txg_verify(spa, txg)
+#else
+#define	TXG_VERIFY(spa, txg)
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_TXG_H */
diff --git a/include/sys/txg_impl.h b/include/sys/txg_impl.h
new file mode 100644
index 0000000000000..047d51b94c66b
--- /dev/null
+++ b/include/sys/txg_impl.h
@@ -0,0 +1,125 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2013, 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_TXG_IMPL_H
+#define	_SYS_TXG_IMPL_H
+
+#include <sys/spa.h>
+#include <sys/txg.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * The tx_cpu structure is a per-cpu structure that is used to track
+ * the number of active transaction holds (tc_count). As transactions
+ * are assigned into a transaction group the appropriate tc_count is
+ * incremented to indicate that there are pending changes that have yet
+ * to quiesce. Consumers eventually call txg_rele_to_sync() to decrement
+ * the tc_count. A transaction group is not considered quiesced until all
+ * tx_cpu structures have reached a tc_count of zero.
+ *
+ * This structure is a per-cpu structure by design. Updates to this structure
+ * are frequent and concurrent. Having a single structure would result in
+ * heavy lock contention so a per-cpu design was implemented. With the fanned
+ * out mutex design, consumers only need to lock the mutex associated with
+ * thread's cpu.
+ *
+ * The tx_cpu contains two locks, the tc_lock and tc_open_lock.
+ * The tc_lock is used to protect all members of the tx_cpu structure with
+ * the exception of the tc_open_lock. This lock should only be held for a
+ * short period of time, typically when updating the value of tc_count.
+ *
+ * The tc_open_lock protects the tx_open_txg member of the tx_state structure.
+ * This lock is used to ensure that transactions are only assigned into
+ * the current open transaction group. In order to move the current open
+ * transaction group to the quiesce phase, the txg_quiesce thread must
+ * grab all tc_open_locks, increment the tx_open_txg, and drop the locks.
+ * The tc_open_lock is held until the transaction is assigned into the
+ * transaction group. Typically, this is a short operation but if throttling
+ * is occurring it may be held for longer periods of time.
+ */
+struct tx_cpu {
+	kmutex_t	tc_open_lock;	/* protects tx_open_txg */
+	kmutex_t	tc_lock;	/* protects the rest of this struct */
+	kcondvar_t	tc_cv[TXG_SIZE];
+	uint64_t	tc_count[TXG_SIZE];	/* tx hold count on each txg */
+	list_t		tc_callbacks[TXG_SIZE]; /* commit cb list */
+	char		tc_pad[8];		/* pad to fill 3 cache lines */
+};
+
+/*
+ * The tx_state structure maintains the state information about the different
+ * stages of the pool's transaction groups. A per pool tx_state structure
+ * is used to track this information. The tx_state structure also points to
+ * an array of tx_cpu structures (described above). Although the tx_sync_lock
+ * is used to protect the members of this structure, it is not used to
+ * protect the tx_open_txg. Instead a special lock in the tx_cpu structure
+ * is used. Readers of tx_open_txg must grab the per-cpu tc_open_lock.
+ * Any thread wishing to update tx_open_txg must grab the tc_open_lock on
+ * every cpu (see txg_quiesce()).
+ */
+typedef struct tx_state {
+	tx_cpu_t	*tx_cpu;	/* protects access to tx_open_txg */
+	kmutex_t	tx_sync_lock;	/* protects the rest of this struct */
+
+	uint64_t	tx_open_txg;	/* currently open txg id */
+	uint64_t	tx_quiescing_txg; /* currently quiescing txg id */
+	uint64_t	tx_quiesced_txg; /* quiesced txg waiting for sync */
+	uint64_t	tx_syncing_txg;	/* currently syncing txg id */
+	uint64_t	tx_synced_txg;	/* last synced txg id */
+
+	hrtime_t	tx_open_time;	/* start time of tx_open_txg */
+
+	uint64_t	tx_sync_txg_waiting; /* txg we're waiting to sync */
+	uint64_t	tx_quiesce_txg_waiting; /* txg we're waiting to open */
+
+	kcondvar_t	tx_sync_more_cv;
+	kcondvar_t	tx_sync_done_cv;
+	kcondvar_t	tx_quiesce_more_cv;
+	kcondvar_t	tx_quiesce_done_cv;
+	kcondvar_t	tx_timeout_cv;
+	kcondvar_t	tx_exit_cv;	/* wait for all threads to exit */
+
+	uint8_t		tx_threads;	/* number of threads */
+	uint8_t		tx_exiting;	/* set when we're exiting */
+
+	kthread_t	*tx_sync_thread;
+	kthread_t	*tx_quiesce_thread;
+
+	taskq_t		*tx_commit_cb_taskq; /* commit callback taskq */
+} tx_state_t;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_TXG_IMPL_H */
diff --git a/include/sys/u8_textprep.h b/include/sys/u8_textprep.h
new file mode 100644
index 0000000000000..f8b5bed6e420a
--- /dev/null
+++ b/include/sys/u8_textprep.h
@@ -0,0 +1,113 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_U8_TEXTPREP_H
+#define	_SYS_U8_TEXTPREP_H
+
+
+
+#include <sys/isa_defs.h>
+#include <sys/types.h>
+#include <sys/errno.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Unicode encoding conversion functions and their macros.
+ */
+#define	UCONV_IN_BIG_ENDIAN		0x0001
+#define	UCONV_OUT_BIG_ENDIAN		0x0002
+#define	UCONV_IN_SYSTEM_ENDIAN		0x0004
+#define	UCONV_OUT_SYSTEM_ENDIAN		0x0008
+#define	UCONV_IN_LITTLE_ENDIAN		0x0010
+#define	UCONV_OUT_LITTLE_ENDIAN		0x0020
+#define	UCONV_IGNORE_NULL		0x0040
+#define	UCONV_IN_ACCEPT_BOM		0x0080
+#define	UCONV_OUT_EMIT_BOM		0x0100
+
+extern int uconv_u16tou32(const uint16_t *, size_t *, uint32_t *, size_t *,
+	int);
+extern int uconv_u16tou8(const uint16_t *, size_t *, uchar_t *, size_t *, int);
+extern int uconv_u32tou16(const uint32_t *, size_t *, uint16_t *, size_t *,
+	int);
+extern int uconv_u32tou8(const uint32_t *, size_t *, uchar_t *, size_t *, int);
+extern int uconv_u8tou16(const uchar_t *, size_t *, uint16_t *, size_t *, int);
+extern int uconv_u8tou32(const uchar_t *, size_t *, uint32_t *, size_t *, int);
+
+/*
+ * UTF-8 text preparation functions and their macros.
+ *
+ * Among the macros defined, U8_CANON_DECOMP, U8_COMPAT_DECOMP, and
+ * U8_CANON_COMP are not public interfaces and must not be used directly
+ * at the flag input argument.
+ */
+#define	U8_STRCMP_CS			(0x00000001)
+#define	U8_STRCMP_CI_UPPER		(0x00000002)
+#define	U8_STRCMP_CI_LOWER		(0x00000004)
+
+#define	U8_CANON_DECOMP			(0x00000010)
+#define	U8_COMPAT_DECOMP		(0x00000020)
+#define	U8_CANON_COMP			(0x00000040)
+
+#define	U8_STRCMP_NFD			(U8_CANON_DECOMP)
+#define	U8_STRCMP_NFC			(U8_CANON_DECOMP | U8_CANON_COMP)
+#define	U8_STRCMP_NFKD			(U8_COMPAT_DECOMP)
+#define	U8_STRCMP_NFKC			(U8_COMPAT_DECOMP | U8_CANON_COMP)
+
+#define	U8_TEXTPREP_TOUPPER		(U8_STRCMP_CI_UPPER)
+#define	U8_TEXTPREP_TOLOWER		(U8_STRCMP_CI_LOWER)
+
+#define	U8_TEXTPREP_NFD			(U8_STRCMP_NFD)
+#define	U8_TEXTPREP_NFC			(U8_STRCMP_NFC)
+#define	U8_TEXTPREP_NFKD		(U8_STRCMP_NFKD)
+#define	U8_TEXTPREP_NFKC		(U8_STRCMP_NFKC)
+
+#define	U8_TEXTPREP_IGNORE_NULL		(0x00010000)
+#define	U8_TEXTPREP_IGNORE_INVALID	(0x00020000)
+#define	U8_TEXTPREP_NOWAIT		(0x00040000)
+
+#define	U8_UNICODE_320			(0)
+#define	U8_UNICODE_500			(1)
+#define	U8_UNICODE_LATEST		(U8_UNICODE_500)
+
+#define	U8_VALIDATE_ENTIRE		(0x00100000)
+#define	U8_VALIDATE_CHECK_ADDITIONAL	(0x00200000)
+#define	U8_VALIDATE_UCS2_RANGE		(0x00400000)
+
+#define	U8_ILLEGAL_CHAR			(-1)
+#define	U8_OUT_OF_RANGE_CHAR		(-2)
+
+extern int u8_validate(char *, size_t, char **, int, int *);
+extern int u8_strcmp(const char *, const char *, size_t, int, size_t, int *);
+extern size_t u8_textprep_str(char *, size_t *, char *, size_t *, int, size_t,
+	int *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_U8_TEXTPREP_H */
diff --git a/include/sys/u8_textprep_data.h b/include/sys/u8_textprep_data.h
new file mode 100644
index 0000000000000..03f71f26c9e1b
--- /dev/null
+++ b/include/sys/u8_textprep_data.h
@@ -0,0 +1,35376 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*
+ * COPYRIGHT AND PERMISSION NOTICE
+ *
+ * Copyright (c) 1991-2006 Unicode, Inc. All rights reserved. Distributed under
+ * the Terms of Use in http://www.unicode.org/copyright.html.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of the Unicode data files and any associated documentation (the
+ * "Data Files") or Unicode software and any associated documentation (the
+ * "Software") to deal in the Data Files or Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Data Files or Software, and
+ * to permit persons to whom the Data Files or Software are furnished to do so,
+ * provided that (a) the above copyright notice(s) and this permission notice
+ * appear with all copies of the Data Files or Software, (b) both the above
+ * copyright notice(s) and this permission notice appear in associated
+ * documentation, and (c) there is clear notice in each modified Data File or
+ * in the Software as well as in the documentation associated with the Data
+ * File(s) or Software that the data or software has been modified.
+ *
+ * THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+ * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+ * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
+ * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR
+ * CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THE DATA FILES OR SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder shall not
+ * be used in advertising or otherwise to promote the sale, use or other
+ * dealings in these Data Files or Software without prior written authorization
+ * of the copyright holder.
+ *
+ * Unicode and the Unicode logo are trademarks of Unicode, Inc., and may be
+ * registered in some jurisdictions. All other trademarks and registered
+ * trademarks mentioned herein are the property of their respective owners.
+ */
+/*
+ * This file has been modified by Sun Microsystems, Inc.
+ */
+
+#ifndef _SYS_U8_TEXTPREP_DATA_H
+#define	_SYS_U8_TEXTPREP_DATA_H
+
+
+
+#include <sys/types.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * To get to the combining class data, composition mappings, decomposition
+ * mappings, and case conversion mappings of Unicode, the data structures
+ * formulated and their meanings are like the following:
+ *
+ * Each UTF-8 character is seen as a 4-byte entity so that U+0061 (or 0x61 in
+ * UTF-8) would be seen as 0x00 0x00 0x00 0x61. Similarly, U+1D15E would be
+ * 0xF0 0x9D 0x85 0x9E in UTF-8.
+ *
+ * The first byte (MSB) value is an index to the b1_tbl, such as
+ * u8_common_b1_tbl and u8_composition_b1_tbl tables. A b1_tbl has
+ * indices to b2_tbl tables that have indices to b3_tbl. Each b3_tbl has
+ * either indices to b4_tbl or indices to b4_tbl and base values for
+ * displacement calculations later by using the u8_displacement_t type at
+ * below. Each b4_tbl table then has indices to the final tables.
+ *
+ * As an example, if we have a character with code value of U+1D15E which is
+ * 0xF0 0x9D 0x85 0x9E in UTF-8, the target decomposition character bytes
+ * that will be mapped by the mapping procedure would be the ones between
+ * the start_index and the end_index computed as like the following:
+ *
+ *	b2_tbl_id = u8_common_b1_tbl[0][0xF0];
+ *	b3_tbl_id = u8_decomp_b2_tbl[0][b2_tbl_id][0x9D];
+ *	b4_tbl_id = u8_decomp_b3_tbl[0][b3_tbl_id][0x85].tbl_id;
+ *	b4_base = u8_decomp_b3_tbl[0][b3_tbl_id][0x85].base;
+ *	if (b4_tbl_id >= 0x8000) {
+ *		b4_tbl_id -= 0x8000;
+ *      	start_index = u8_decomp_b4_16bit_tbl[0][b4_tbl_id][0x9E];
+ *      	end_index = u8_decomp_b4_16bit_tbl[0][b4_tbl_id][0x9E + 1];
+ *	} else {
+ *      	start_index = u8_decomp_b4_tbl[0][b4_tbl_id][0x9E];
+ *      	end_index = u8_decomp_b4_tbl[0][b4_tbl_id][0x9E + 1];
+ *	}
+ *
+ * The start_index and the end_index can be used to retrieve the bytes
+ * possibly of multiple UTF-8 characters from the final tables.
+ *
+ * The "[0]" at the above indicates this is for Unicode Version 3.2.0 data
+ * as of today.  Consequently, the "[1]" indicates another Unicode version
+ * data and it is Unicode 5.0.0 as of today.
+ *
+ * The mapping procedures and the data structures are more or less similar or
+ * alike among different mappings. You might want to read the u8_textprep.c
+ * for specific details.
+ *
+ * The tool programs created and used to generate the tables in this file are
+ * saved at PSARC/2007/149/materials/ as tools.tar.gz file.
+ */
+
+/* The following is a component type for the b4_tbl vectors. */
+typedef struct {
+	uint16_t	tbl_id;
+	uint16_t	base;
+} u8_displacement_t;
+
+/*
+ * The U8_TBL_ELEMENT_NOT_DEF macro indicates a byte that is not defined or
+ * used. The U8_TBL_ELEMENT_FILLER indicates the end of a UTF-8 character at
+ * the final tables.
+ */
+#define	U8_TBL_ELEMENT_NOT_DEF		(0xff)
+#define	N_				U8_TBL_ELEMENT_NOT_DEF
+
+#define	U8_TBL_ELEMENT_FILLER		(0xf7)
+#define	FIL_				U8_TBL_ELEMENT_FILLER
+
+/*
+ * The common b1_tbl for combining class, decompositions, tolower, and
+ * toupper case conversion mappings.
+ */
+static const uchar_t u8_common_b1_tbl[2][256] = {
+	{
+		0,  N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		1,  N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+	},
+	{
+		0,  N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		1,  N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+	},
+};
+
+static const uchar_t u8_combining_class_b2_tbl[2][2][256] = {
+	{
+		{
+			0,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			1,  2,  3,  4,  N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, 5,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, 6,  N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+
+	},
+	{
+		{
+			0,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			1,  2,  3,  4,  N_, N_, N_, N_,
+			N_, N_, 5,  N_, N_, N_, N_, 6,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			7,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, 8,  N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+
+	},
+
+};
+
+static const uchar_t u8_combining_class_b3_tbl[2][9][256] = {
+	{
+		{	/* Third byte table 0. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, 0,  1,  N_, N_,
+			N_, N_, 2,  N_, N_, N_, 3,  4,
+			N_, 5,  N_, 6,  7,  8,  N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 1. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, 9,  10, 11, 12,
+			13, 14, 15, 16, 17, 18, N_, 19,
+			N_, 20, N_, 21, N_, 22, N_, 23,
+			24, 25, 26, 27, 28, 29, 30, 31,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 2. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			32, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, 33, N_, N_, 34,
+			N_, N_, 35, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 3. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, 36, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 4. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			37, N_, 38, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 5. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, 39, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			40, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 6. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, 41, 42, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 7. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 8. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+	},
+	{
+		{	/* Third byte table 0. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, 0,  1,  N_, N_,
+			N_, N_, 2,  N_, N_, N_, 3,  4,
+			5,  6,  N_, 7,  8,  9,  N_, 10,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 1. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, 11, 12, 13, 14,
+			15, 16, 17, 18, 19, 20, N_, 21,
+			N_, 22, 23, 24, N_, 25, N_, 26,
+			27, 28, 29, 30, 31, 32, 33, 34,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 2. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			35, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, 36, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, 37, N_, N_, 38,
+			N_, N_, 39, N_, 40, N_, N_, N_,
+			41, N_, N_, N_, 42, 43, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, 44,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 3. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, 45, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 4. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			46, N_, 47, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 5. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			48, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 6. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, 49, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			50, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 7. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			51, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{	/* Third byte table 8. */
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, 52, 53, N_,
+			N_, 54, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+	},
+};
+
+/*
+ * Unlike other b4_tbl, the b4_tbl for combining class data has
+ * the combining class values not indices to the final tables.
+ */
+static const uchar_t u8_combining_class_b4_tbl[2][55][256] = {
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 230, 230, 230, 230, 230, 230,
+			230, 230, 230, 230, 230, 230, 230, 230,
+			230, 230, 230, 230, 230, 232, 220, 220,
+			220, 220, 232, 216, 220, 220, 220, 220,
+			220, 202, 202, 220, 220, 220, 220, 202,
+			202, 220, 220, 220, 220, 220, 220, 220,
+			220, 220, 220, 220, 1,   1,   1,   1,
+			1,   220, 220, 220, 220, 230, 230, 230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 230, 230, 230, 240, 230, 220,
+			220, 220, 230, 230, 230, 220, 220, 0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			234, 234, 233, 230, 230, 230, 230, 230,
+			230, 230, 230, 230, 230, 230, 230, 230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   230, 230, 230, 230, 0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   220, 230, 230, 230, 230, 220, 230,
+			230, 230, 222, 220, 230, 230, 230, 230,
+			230, 230, 0,   220, 220, 220, 220, 220,
+			230, 230, 220, 230, 230, 222, 228, 230,
+			10,  11,  12,  13,  14,  15,  16,  17,
+			18,  19,  0,   20,  21,  22,  0,   23,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   24,  25,  0,   230, 0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   27,  28,  29,  30,  31,
+			32,  33,  34,  230, 230, 220, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			35,  0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   230, 230,
+			230, 230, 230, 230, 230, 0,   0,   230,
+			230, 230, 230, 220, 230, 0,   0,   230,
+			230, 0,   220, 230, 230, 220, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   36,  0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 220, 230, 230, 220, 230, 230, 220,
+			220, 220, 230, 220, 220, 230, 220, 230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 220, 230, 220, 230, 220, 230,
+			220, 230, 230, 0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   230, 220, 230, 230, 0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   84,  91,  0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   9,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			103, 103, 9,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			107, 107, 107, 107, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			118, 118, 0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			122, 122, 122, 122, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			220, 220, 0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   220, 0,   220,
+			0,   216, 0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   129, 130, 0,   132, 0,   0,   0,
+			0,   0,   130, 130, 130, 130, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			130, 0,   230, 230, 9,   0,   230, 230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   220, 0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			0,   9,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   9,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   9,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   9,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   228, 0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 36. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 1,   1,   230, 230, 230, 230,
+			1,   1,   1,   230, 230, 0,   0,   0,
+			0,   230, 0,   0,   0,   1,   1,   230,
+			220, 230, 1,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 37. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   218, 228, 232, 222, 224, 224,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 38. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   8,   8,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 39. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   26,  0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 40. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 230, 230, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 41. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   216, 216, 1,
+			1,   1,   0,   0,   0,   226, 216, 216,
+			216, 216, 216, 0,   0,   0,   0,   0,
+			0,   0,   0,   220, 220, 220, 220, 220,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 42. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			220, 220, 220, 0,   0,   230, 230, 230,
+			230, 230, 220, 220, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   230, 230, 230, 230, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 43. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 44. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 45. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 46. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 47. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 48. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 49. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 50. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 51. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 52. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 53. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 54. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+	},
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 230, 230, 230, 230, 230, 230,
+			230, 230, 230, 230, 230, 230, 230, 230,
+			230, 230, 230, 230, 230, 232, 220, 220,
+			220, 220, 232, 216, 220, 220, 220, 220,
+			220, 202, 202, 220, 220, 220, 220, 202,
+			202, 220, 220, 220, 220, 220, 220, 220,
+			220, 220, 220, 220, 1,   1,   1,   1,
+			1,   220, 220, 220, 220, 230, 230, 230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 230, 230, 230, 240, 230, 220,
+			220, 220, 230, 230, 230, 220, 220, 0,
+			230, 230, 230, 220, 220, 220, 220, 230,
+			232, 220, 220, 230, 233, 234, 234, 233,
+			234, 234, 233, 230, 230, 230, 230, 230,
+			230, 230, 230, 230, 230, 230, 230, 230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   230, 230, 230, 230, 0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   220, 230, 230, 230, 230, 220, 230,
+			230, 230, 222, 220, 230, 230, 230, 230,
+			230, 230, 220, 220, 220, 220, 220, 220,
+			230, 230, 220, 230, 230, 222, 228, 230,
+			10,  11,  12,  13,  14,  15,  16,  17,
+			18,  19,  19,  20,  21,  22,  0,   23,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   24,  25,  0,   230, 220, 0,   18,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 230, 230, 230, 230, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   27,  28,  29,  30,  31,
+			32,  33,  34,  230, 230, 220, 220, 230,
+			230, 230, 230, 230, 220, 230, 230, 0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			35,  0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   230, 230,
+			230, 230, 230, 230, 230, 0,   0,   230,
+			230, 230, 230, 220, 230, 0,   0,   230,
+			230, 0,   220, 230, 230, 220, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   36,  0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 220, 230, 230, 220, 230, 230, 220,
+			220, 220, 230, 220, 220, 230, 220, 230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 220, 230, 220, 230, 220, 230,
+			220, 230, 230, 0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   230, 230, 230, 230, 230,
+			230, 230, 220, 230, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   230, 220, 230, 230, 0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   84,  91,  0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   9,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   9,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			103, 103, 9,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			107, 107, 107, 107, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			118, 118, 0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			122, 122, 122, 122, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			220, 220, 0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   220, 0,   220,
+			0,   216, 0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   129, 130, 0,   132, 0,   0,   0,
+			0,   0,   130, 130, 130, 130, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			130, 0,   230, 230, 9,   0,   230, 230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   220, 0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			0,   9,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 36. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 37. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   9,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   9,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 38. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   9,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   230, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 39. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   228, 0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 40. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   222, 230, 220, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 41. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   230,
+			220, 0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 42. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 43. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   9,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   230, 220, 230, 230, 230,
+			230, 230, 230, 230, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 44. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 220, 230, 230, 230, 230, 230,
+			230, 230, 220, 0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   230, 220,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 45. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 1,   1,   230, 230, 230, 230,
+			1,   1,   1,   230, 230, 0,   0,   0,
+			0,   230, 0,   0,   0,   1,   1,   230,
+			220, 230, 1,   1,   220, 220, 220, 220,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 46. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   218, 228, 232, 222, 224, 224,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 47. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   8,   8,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 48. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   9,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 49. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   26,  0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 50. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 230, 230, 230, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 51. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   220, 0,   230,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			230, 1,   220, 0,   0,   0,   0,   9,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 52. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   216, 216, 1,
+			1,   1,   0,   0,   0,   226, 216, 216,
+			216, 216, 216, 0,   0,   0,   0,   0,
+			0,   0,   0,   220, 220, 220, 220, 220,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 53. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			220, 220, 220, 0,   0,   230, 230, 230,
+			230, 230, 220, 220, 0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   230, 230, 230, 230, 0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+		{	/* Fourth byte table 54. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   230, 230, 230, 0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+		},
+	},
+};
+
+static const uchar_t u8_composition_b1_tbl[2][256] = {
+	{
+		0,  N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+	},
+	{
+		0,  N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+		N_, N_, N_, N_, N_, N_, N_, N_,
+	},
+};
+
+static const uchar_t u8_composition_b2_tbl[2][1][256] = {
+	{
+		{
+			0,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			1,  2,  3,  4,  N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+
+	},
+	{
+		{
+			0,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			1,  2,  3,  4,  N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+
+	},
+
+};
+
+static const u8_displacement_t u8_composition_b3_tbl[2][5][256] = {
+	{
+		{	/* Third byte table 0. */
+			{ 0x8000, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0, 2470 },
+			{ 0x8001, 2491 }, { 1, 2871 }, { 2, 2959 },
+			{ 3, 3061 }, { 4, 3212 }, { 5, 3226 },
+			{ N_, 0 }, { 6, 3270 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0x8002, 3277 },
+			{ 7, 3774 }, { 8, 3949 }, { 9, 4198 },
+			{ N_, 0 }, { 10, 4265 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 11, 4293 }, { 12, 4312 }, { N_, 0 },
+			{ 13, 4326 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 1. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 14, 4347 },
+			{ N_, 0 }, { N_, 0 }, { 15, 4374 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 16, 4391 },
+			{ 17, 4416 }, { 18, 4425 }, { N_, 0 },
+			{ 19, 4451 }, { 20, 4460 }, { 21, 4469 },
+			{ N_, 0 }, { 22, 4503 }, { N_, 0 },
+			{ 23, 4529 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 2. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 24, 4563 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 25, 4572 }, { 26, 4588 },
+			{ 27, 4620 }, { 28, 4666 }, { 0x8003, 4682 },
+			{ 0x8004, 5254 }, { 29, 5616 }, { 30, 5646 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 3. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 31, 5684 },
+			{ 32, 5708 }, { 33, 5732 }, { 34, 5780 },
+			{ 35, 5900 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 4. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 36, 6012 }, { 37, 6241 }, { 38, 6358 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+	},
+	{
+		{	/* Third byte table 0. */
+			{ 0x8000, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0, 2470 },
+			{ 0x8001, 2491 }, { 1, 2871 }, { 2, 2959 },
+			{ 3, 3061 }, { 4, 3212 }, { 5, 3226 },
+			{ N_, 0 }, { 6, 3270 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0x8002, 3277 },
+			{ 7, 3774 }, { 8, 3949 }, { 9, 4198 },
+			{ N_, 0 }, { 10, 4265 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 11, 4293 }, { 12, 4312 }, { N_, 0 },
+			{ 13, 4326 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 1. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 14, 4347 },
+			{ N_, 0 }, { N_, 0 }, { 15, 4374 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 16, 4391 },
+			{ 17, 4416 }, { 18, 4425 }, { N_, 0 },
+			{ 19, 4451 }, { 20, 4460 }, { 21, 4469 },
+			{ N_, 0 }, { 22, 4503 }, { N_, 0 },
+			{ 23, 4529 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 2. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 24, 4563 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 25, 4572 }, { 26, 4662 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 27, 4671 }, { 28, 4687 },
+			{ 29, 4719 }, { 30, 4765 }, { 0x8003, 4781 },
+			{ 0x8004, 5353 }, { 31, 5715 }, { 32, 5745 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 3. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 33, 5783 },
+			{ 34, 5807 }, { 35, 5831 }, { 36, 5879 },
+			{ 37, 5999 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 4. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 38, 6111 }, { 39, 6340 }, { 40, 6457 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+	},
+};
+
+static const uchar_t u8_composition_b4_tbl[2][41][257] = {
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   29,  58,  58,  58,  58,
+			58,  58,  58,  58,  58,  58,  58,  58,
+			58,  58,  58,  73,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   15,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  38,  46,  46,  46,  46,
+			46,  54,  62,  62,  62,  62,  62,  62,
+			62,  70,  78,  86,  94,  94,  94,  94,
+			94,  94,  94,  94,  94,  94,  94,  94,
+			94,  94,  94,  94,  94,  94,  94,  94,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   36,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			108, 144, 144, 144, 144, 144, 144, 144,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			14,  22,  30,  30,  30,  30,  30,  37,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   15,  15,  15,  15,  70,  70,
+			70,  70,  112, 133, 154, 154, 154, 162,
+			162, 162, 162, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   20,  20,  20,  27,  27,  46,  59,
+			66,  91,  91,  98,  98,  98,  98,  105,
+			105, 105, 105, 105, 130, 130, 130, 130,
+			137, 137, 137, 137, 144, 144, 151, 151,
+			151, 164, 164, 164, 171, 171, 190, 203,
+			210, 235, 235, 242, 242, 242, 242, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   25,  25,  25,  25,
+			32,  32,  32,  32,  39,  39,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  53,
+			53,  53,  53,  53,  53,  53,  53,  53,
+			53,  53,  53,  53,  53,  53,  53,  53,
+			53,  53,  53,  53,  53,  53,  53,  53,
+			53,  53,  53,  53,  53,  60,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  21,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   14,  14,  14,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   9,   9,   9,   9,   9,   9,   9,
+			9,   18,  18,  18,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   17,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   25,
+			25,  25,  25,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   17,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   25,  25,  25,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   8,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   8,   16,  16,  16,  16,
+			16,  16,  16,  24,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   15,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  38,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   8,   16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   16,
+			16,  16,  16,  16,  16,  16,  16,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   8,   8,   16,  16,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   8,   8,   16,  16,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   8,   8,   8,   8,
+			8,   16,  16,  16,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  32,  32,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   8,   8,   16,  16,
+			16,  24,  24,  24,  24,  24,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  40,  40,  40,  48,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  64,  72,  72,  72,  80,
+			88,  88,  88,  96,  104, 112, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   8,   16,  16,  16,  24,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  40,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  56,  56,  56,  56,  56,
+			56,  64,  72,  72,  80,  80,  80,  80,
+			80,  80,  80,  88,  96,  104, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112,
+		},
+		{	/* Fourth byte table 36. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   9,
+			9,   9,   9,   9,   18,  18,  27,  27,
+			36,  36,  45,  45,  54,  54,  63,  63,
+			72,  72,  81,  81,  90,  90,  99,  99,
+			108, 108, 117, 117, 117, 126, 126, 135,
+			135, 144, 144, 144, 144, 144, 144, 144,
+			161, 161, 161, 178, 178, 178, 195, 195,
+			195, 212, 212, 212, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229,
+		},
+		{	/* Fourth byte table 37. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   18,
+			18,  18,  18,  18,  27,  27,  36,  36,
+			45,  45,  54,  54,  63,  63,  72,  72,
+			81,  81,  90,  90,  99,  99,  108, 108,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117,
+		},
+		{	/* Fourth byte table 38. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   9,   9,   9,   18,  18,  27,
+			27,  36,  36,  36,  36,  36,  36,  36,
+			53,  53,  53,  70,  70,  70,  87,  87,
+			87,  104, 104, 104, 121, 121, 121, 121,
+			121, 121, 121, 121, 121, 121, 121, 121,
+			121, 121, 121, 121, 121, 121, 121, 121,
+			130, 139, 148, 157, 157, 157, 157, 157,
+			157, 157, 157, 157, 157, 157, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166,
+		},
+		{	/* Fourth byte table 39. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 40. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+	},
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   29,  58,  58,  58,  58,
+			58,  58,  58,  58,  58,  58,  58,  58,
+			58,  58,  58,  73,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   15,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  38,  46,  46,  46,  46,
+			46,  54,  62,  62,  62,  62,  62,  62,
+			62,  70,  78,  86,  94,  94,  94,  94,
+			94,  94,  94,  94,  94,  94,  94,  94,
+			94,  94,  94,  94,  94,  94,  94,  94,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102, 102, 102, 102, 102, 102, 102, 102,
+			102,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   36,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			108, 144, 144, 144, 144, 144, 144, 144,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151, 151, 151, 151, 151, 151, 151, 151,
+			151,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			14,  22,  30,  30,  30,  30,  30,  37,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   15,  15,  15,  15,  70,  70,
+			70,  70,  112, 133, 154, 154, 154, 162,
+			162, 162, 162, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   20,  20,  20,  27,  27,  46,  59,
+			66,  91,  91,  98,  98,  98,  98,  105,
+			105, 105, 105, 105, 130, 130, 130, 130,
+			137, 137, 137, 137, 144, 144, 151, 151,
+			151, 164, 164, 164, 171, 171, 190, 203,
+			210, 235, 235, 242, 242, 242, 242, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249, 249, 249, 249, 249, 249, 249, 249,
+			249,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   25,  25,  25,  25,
+			32,  32,  32,  32,  39,  39,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  53,
+			53,  53,  53,  53,  53,  53,  53,  53,
+			53,  53,  53,  53,  53,  53,  53,  53,
+			53,  53,  53,  53,  53,  53,  53,  53,
+			53,  53,  53,  53,  53,  60,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  21,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   14,  14,  14,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   9,   9,   9,   9,   9,   9,   9,
+			9,   18,  18,  18,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   17,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   25,
+			25,  25,  25,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   17,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   25,  25,  25,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  34,  34,
+			34,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   9,   9,
+			18,  18,  27,  27,  36,  36,  45,  45,
+			45,  45,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  63,  63,  72,  72,  81,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   8,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   8,   16,  16,  16,  16,
+			16,  16,  16,  24,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   15,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  38,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   8,   16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   16,
+			16,  16,  16,  16,  16,  16,  16,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   8,   8,   16,  16,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   8,   8,   16,  16,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   8,   8,   8,   8,
+			8,   16,  16,  16,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  32,  32,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 36. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   8,   8,   16,  16,
+			16,  24,  24,  24,  24,  24,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  40,  40,  40,  48,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  64,  72,  72,  72,  80,
+			88,  88,  88,  96,  104, 112, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120, 120, 120, 120, 120, 120, 120, 120,
+			120,
+		},
+		{	/* Fourth byte table 37. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   8,   16,  16,  16,  24,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  40,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  56,  56,  56,  56,  56,
+			56,  64,  72,  72,  80,  80,  80,  80,
+			80,  80,  80,  88,  96,  104, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112,
+		},
+		{	/* Fourth byte table 38. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   9,
+			9,   9,   9,   9,   18,  18,  27,  27,
+			36,  36,  45,  45,  54,  54,  63,  63,
+			72,  72,  81,  81,  90,  90,  99,  99,
+			108, 108, 117, 117, 117, 126, 126, 135,
+			135, 144, 144, 144, 144, 144, 144, 144,
+			161, 161, 161, 178, 178, 178, 195, 195,
+			195, 212, 212, 212, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229, 229, 229, 229, 229, 229, 229, 229,
+			229,
+		},
+		{	/* Fourth byte table 39. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   18,
+			18,  18,  18,  18,  27,  27,  36,  36,
+			45,  45,  54,  54,  63,  63,  72,  72,
+			81,  81,  90,  90,  99,  99,  108, 108,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117, 117, 117, 117, 117, 117, 117, 117,
+			117,
+		},
+		{	/* Fourth byte table 40. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   9,   9,   9,   18,  18,  27,
+			27,  36,  36,  36,  36,  36,  36,  36,
+			53,  53,  53,  70,  70,  70,  87,  87,
+			87,  104, 104, 104, 121, 121, 121, 121,
+			121, 121, 121, 121, 121, 121, 121, 121,
+			121, 121, 121, 121, 121, 121, 121, 121,
+			130, 139, 148, 157, 157, 157, 157, 157,
+			157, 157, 157, 157, 157, 157, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166, 166, 166, 166, 166, 166, 166, 166,
+			166,
+		},
+	},
+};
+
+static const uint16_t u8_composition_b4_16bit_tbl[2][5][257] = {
+	{
+		{	/* Fourth byte 16-bit table 0. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    8,    16,   24,
+			24,   24,   124,  146,  177,  219,  327,  335,
+			379,  427,  521,  528,  562,  602,  624,  683,
+			782,  797,  797,  849,  894,  941,  1061, 1076,
+			1118, 1133, 1193, 1233, 1233, 1233, 1233, 1233,
+			1233, 1233, 1333, 1355, 1386, 1428, 1536, 1544,
+			1588, 1643, 1731, 1744, 1778, 1818, 1840, 1899,
+			1998, 2013, 2013, 2065, 2110, 2164, 2284, 2299,
+			2348, 2363, 2430, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470,
+		},
+		{	/* Fourth byte 16-bit table 1. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    29,   29,   36,   43,   56,
+			64,   64,   64,   93,   93,   93,   93,   93,
+			101,  101,  101,  101,  101,  130,  151,  158,
+			158,  165,  165,  165,  165,  190,  190,  190,
+			190,  190,  190,  219,  219,  226,  233,  246,
+			254,  254,  254,  283,  283,  283,  283,  283,
+			291,  291,  291,  291,  291,  320,  341,  348,
+			348,  355,  355,  355,  355,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,
+		},
+		{	/* Fourth byte 16-bit table 2. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    49,   49,   49,   49,   77,   77,
+			112,  112,  160,  160,  160,  160,  160,  160,
+			188,  188,  196,  196,  196,  196,  237,  237,
+			237,  237,  272,  272,  272,  280,  280,  288,
+			288,  288,  344,  344,  344,  344,  372,  372,
+			414,  414,  469,  469,  469,  469,  469,  469,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,
+		},
+		{	/* Fourth byte 16-bit table 3. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    29,   58,   66,   74,   82,   90,   98,
+			106,  135,  164,  172,  180,  188,  196,  204,
+			212,  227,  242,  242,  242,  242,  242,  242,
+			242,  257,  272,  272,  272,  272,  272,  272,
+			272,  301,  330,  338,  346,  354,  362,  370,
+			378,  407,  436,  444,  452,  460,  468,  476,
+			484,  506,  528,  528,  528,  528,  528,  528,
+			528,  550,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,
+		},
+		{	/* Fourth byte 16-bit table 4. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    15,   30,   30,   30,   30,   30,   30,
+			30,   45,   60,   60,   60,   60,   60,   60,
+			60,   82,   104,  104,  104,  104,  104,  104,
+			104,  104,  126,  126,  126,  126,  126,  126,
+			126,  155,  184,  192,  200,  208,  216,  224,
+			232,  261,  290,  298,  306,  314,  322,  330,
+			338,  346,  346,  346,  346,  354,  354,  354,
+			354,  354,  354,  354,  354,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,
+		},
+	},
+	{
+		{	/* Fourth byte 16-bit table 0. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    8,    16,   24,
+			24,   24,   124,  146,  177,  219,  327,  335,
+			379,  427,  521,  528,  562,  602,  624,  683,
+			782,  797,  797,  849,  894,  941,  1061, 1076,
+			1118, 1133, 1193, 1233, 1233, 1233, 1233, 1233,
+			1233, 1233, 1333, 1355, 1386, 1428, 1536, 1544,
+			1588, 1643, 1731, 1744, 1778, 1818, 1840, 1899,
+			1998, 2013, 2013, 2065, 2110, 2164, 2284, 2299,
+			2348, 2363, 2430, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470,
+			2470,
+		},
+		{	/* Fourth byte 16-bit table 1. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    29,   29,   36,   43,   56,
+			64,   64,   64,   93,   93,   93,   93,   93,
+			101,  101,  101,  101,  101,  130,  151,  158,
+			158,  165,  165,  165,  165,  190,  190,  190,
+			190,  190,  190,  219,  219,  226,  233,  246,
+			254,  254,  254,  283,  283,  283,  283,  283,
+			291,  291,  291,  291,  291,  320,  341,  348,
+			348,  355,  355,  355,  355,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,  380,  380,  380,  380,  380,  380,  380,
+			380,
+		},
+		{	/* Fourth byte 16-bit table 2. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    49,   49,   49,   49,   77,   77,
+			112,  112,  160,  160,  160,  160,  160,  160,
+			188,  188,  196,  196,  196,  196,  237,  237,
+			237,  237,  272,  272,  272,  280,  280,  288,
+			288,  288,  344,  344,  344,  344,  372,  372,
+			414,  414,  469,  469,  469,  469,  469,  469,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,  497,  497,  497,  497,  497,  497,  497,
+			497,
+		},
+		{	/* Fourth byte 16-bit table 3. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    29,   58,   66,   74,   82,   90,   98,
+			106,  135,  164,  172,  180,  188,  196,  204,
+			212,  227,  242,  242,  242,  242,  242,  242,
+			242,  257,  272,  272,  272,  272,  272,  272,
+			272,  301,  330,  338,  346,  354,  362,  370,
+			378,  407,  436,  444,  452,  460,  468,  476,
+			484,  506,  528,  528,  528,  528,  528,  528,
+			528,  550,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,  572,  572,  572,  572,  572,  572,  572,
+			572,
+		},
+		{	/* Fourth byte 16-bit table 4. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    15,   30,   30,   30,   30,   30,   30,
+			30,   45,   60,   60,   60,   60,   60,   60,
+			60,   82,   104,  104,  104,  104,  104,  104,
+			104,  104,  126,  126,  126,  126,  126,  126,
+			126,  155,  184,  192,  200,  208,  216,  224,
+			232,  261,  290,  298,  306,  314,  322,  330,
+			338,  346,  346,  346,  346,  354,  354,  354,
+			354,  354,  354,  354,  354,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,  362,  362,  362,  362,  362,  362,  362,
+			362,
+		},
+	},
+};
+
+static const uchar_t u8_composition_final_tbl[2][6623] = {
+	{
+		0x01, 0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xAE, FIL_,
+		0x01, 0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xA0, FIL_,
+		0x01, 0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xAF, FIL_,
+		0x10, 0xCC, 0x86, FIL_, 0xC4, 0x82, FIL_, 0xCC,
+		0x87, FIL_, 0xC8, 0xA6, FIL_, 0xCC, 0x8F, FIL_,
+		0xC8, 0x80, FIL_, 0xCC, 0x82, FIL_, 0xC3, 0x82,
+		FIL_, 0xCC, 0x81, FIL_, 0xC3, 0x81, FIL_, 0xCC,
+		0x80, FIL_, 0xC3, 0x80, FIL_, 0xCC, 0x83, FIL_,
+		0xC3, 0x83, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBA,
+		0xA0, FIL_, 0xCC, 0xA5, FIL_, 0xE1, 0xB8, 0x80,
+		FIL_, 0xCC, 0x91, FIL_, 0xC8, 0x82, FIL_, 0xCC,
+		0x84, FIL_, 0xC4, 0x80, FIL_, 0xCC, 0x88, FIL_,
+		0xC3, 0x84, FIL_, 0xCC, 0x8A, FIL_, 0xC3, 0x85,
+		FIL_, 0xCC, 0xA8, FIL_, 0xC4, 0x84, FIL_, 0xCC,
+		0x89, FIL_, 0xE1, 0xBA, 0xA2, FIL_, 0xCC, 0x8C,
+		FIL_, 0xC7, 0x8D, FIL_, 0x03, 0xCC, 0x87, FIL_,
+		0xE1, 0xB8, 0x82, FIL_, 0xCC, 0xB1, FIL_, 0xE1,
+		0xB8, 0x86, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB8,
+		0x84, FIL_, 0x05, 0xCC, 0xA7, FIL_, 0xC3, 0x87,
+		FIL_, 0xCC, 0x81, FIL_, 0xC4, 0x86, FIL_, 0xCC,
+		0x8C, FIL_, 0xC4, 0x8C, FIL_, 0xCC, 0x87, FIL_,
+		0xC4, 0x8A, FIL_, 0xCC, 0x82, FIL_, 0xC4, 0x88,
+		FIL_, 0x06, 0xCC, 0xB1, FIL_, 0xE1, 0xB8, 0x8E,
+		FIL_, 0xCC, 0xA7, FIL_, 0xE1, 0xB8, 0x90, FIL_,
+		0xCC, 0xAD, FIL_, 0xE1, 0xB8, 0x92, FIL_, 0xCC,
+		0x87, FIL_, 0xE1, 0xB8, 0x8A, FIL_, 0xCC, 0x8C,
+		FIL_, 0xC4, 0x8E, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xB8, 0x8C, FIL_, 0x11, 0xCC, 0x80, FIL_, 0xC3,
+		0x88, FIL_, 0xCC, 0x81, FIL_, 0xC3, 0x89, FIL_,
+		0xCC, 0x82, FIL_, 0xC3, 0x8A, FIL_, 0xCC, 0x88,
+		FIL_, 0xC3, 0x8B, FIL_, 0xCC, 0xA7, FIL_, 0xC8,
+		0xA8, FIL_, 0xCC, 0x91, FIL_, 0xC8, 0x86, FIL_,
+		0xCC, 0x8F, FIL_, 0xC8, 0x84, FIL_, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBA, 0xBA, FIL_, 0xCC, 0xB0, FIL_,
+		0xE1, 0xB8, 0x9A, FIL_, 0xCC, 0xAD, FIL_, 0xE1,
+		0xB8, 0x98, FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBA,
+		0xBC, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBA, 0xB8,
+		FIL_, 0xCC, 0x84, FIL_, 0xC4, 0x92, FIL_, 0xCC,
+		0x86, FIL_, 0xC4, 0x94, FIL_, 0xCC, 0x87, FIL_,
+		0xC4, 0x96, FIL_, 0xCC, 0xA8, FIL_, 0xC4, 0x98,
+		FIL_, 0xCC, 0x8C, FIL_, 0xC4, 0x9A, FIL_, 0x01,
+		0xCC, 0x87, FIL_, 0xE1, 0xB8, 0x9E, FIL_, 0x07,
+		0xCC, 0x8C, FIL_, 0xC7, 0xA6, FIL_, 0xCC, 0x87,
+		FIL_, 0xC4, 0xA0, FIL_, 0xCC, 0x84, FIL_, 0xE1,
+		0xB8, 0xA0, FIL_, 0xCC, 0x82, FIL_, 0xC4, 0x9C,
+		FIL_, 0xCC, 0x81, FIL_, 0xC7, 0xB4, FIL_, 0xCC,
+		0xA7, FIL_, 0xC4, 0xA2, FIL_, 0xCC, 0x86, FIL_,
+		0xC4, 0x9E, FIL_, 0x07, 0xCC, 0xAE, FIL_, 0xE1,
+		0xB8, 0xAA, FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xB8,
+		0xA2, FIL_, 0xCC, 0x88, FIL_, 0xE1, 0xB8, 0xA6,
+		FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB8, 0xA4, FIL_,
+		0xCC, 0xA7, FIL_, 0xE1, 0xB8, 0xA8, FIL_, 0xCC,
+		0x8C, FIL_, 0xC8, 0x9E, FIL_, 0xCC, 0x82, FIL_,
+		0xC4, 0xA4, FIL_, 0x0F, 0xCC, 0x84, FIL_, 0xC4,
+		0xAA, FIL_, 0xCC, 0x80, FIL_, 0xC3, 0x8C, FIL_,
+		0xCC, 0xA8, FIL_, 0xC4, 0xAE, FIL_, 0xCC, 0x83,
+		FIL_, 0xC4, 0xA8, FIL_, 0xCC, 0x88, FIL_, 0xC3,
+		0x8F, FIL_, 0xCC, 0x81, FIL_, 0xC3, 0x8D, FIL_,
+		0xCC, 0x8F, FIL_, 0xC8, 0x88, FIL_, 0xCC, 0x86,
+		FIL_, 0xC4, 0xAC, FIL_, 0xCC, 0x91, FIL_, 0xC8,
+		0x8A, FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0x8F, FIL_,
+		0xCC, 0x89, FIL_, 0xE1, 0xBB, 0x88, FIL_, 0xCC,
+		0x87, FIL_, 0xC4, 0xB0, FIL_, 0xCC, 0xA3, FIL_,
+		0xE1, 0xBB, 0x8A, FIL_, 0xCC, 0xB0, FIL_, 0xE1,
+		0xB8, 0xAC, FIL_, 0xCC, 0x82, FIL_, 0xC3, 0x8E,
+		FIL_, 0x01, 0xCC, 0x82, FIL_, 0xC4, 0xB4, FIL_,
+		0x05, 0xCC, 0x8C, FIL_, 0xC7, 0xA8, FIL_, 0xCC,
+		0xB1, FIL_, 0xE1, 0xB8, 0xB4, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB8, 0xB0, FIL_, 0xCC, 0xA7, FIL_,
+		0xC4, 0xB6, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB8,
+		0xB2, FIL_, 0x06, 0xCC, 0xA7, FIL_, 0xC4, 0xBB,
+		FIL_, 0xCC, 0x8C, FIL_, 0xC4, 0xBD, FIL_, 0xCC,
+		0xB1, FIL_, 0xE1, 0xB8, 0xBA, FIL_, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xB8, 0xB6, FIL_, 0xCC, 0xAD, FIL_,
+		0xE1, 0xB8, 0xBC, FIL_, 0xCC, 0x81, FIL_, 0xC4,
+		0xB9, FIL_, 0x03, 0xCC, 0x81, FIL_, 0xE1, 0xB8,
+		0xBE, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x82,
+		FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xB9, 0x80, FIL_,
+		0x09, 0xCC, 0x80, FIL_, 0xC7, 0xB8, FIL_, 0xCC,
+		0xAD, FIL_, 0xE1, 0xB9, 0x8A, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0x84, FIL_, 0xCC, 0xB1, FIL_,
+		0xE1, 0xB9, 0x88, FIL_, 0xCC, 0x83, FIL_, 0xC3,
+		0x91, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x86,
+		FIL_, 0xCC, 0x81, FIL_, 0xC5, 0x83, FIL_, 0xCC,
+		0xA7, FIL_, 0xC5, 0x85, FIL_, 0xCC, 0x8C, FIL_,
+		0xC5, 0x87, FIL_, 0x10, 0xCC, 0xA8, FIL_, 0xC7,
+		0xAA, FIL_, 0xCC, 0x91, FIL_, 0xC8, 0x8E, FIL_,
+		0xCC, 0x80, FIL_, 0xC3, 0x92, FIL_, 0xCC, 0x9B,
+		FIL_, 0xC6, 0xA0, FIL_, 0xCC, 0x8F, FIL_, 0xC8,
+		0x8C, FIL_, 0xCC, 0x81, FIL_, 0xC3, 0x93, FIL_,
+		0xCC, 0x87, FIL_, 0xC8, 0xAE, FIL_, 0xCC, 0x8C,
+		FIL_, 0xC7, 0x91, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xBB, 0x8C, FIL_, 0xCC, 0x82, FIL_, 0xC3, 0x94,
+		FIL_, 0xCC, 0x84, FIL_, 0xC5, 0x8C, FIL_, 0xCC,
+		0x83, FIL_, 0xC3, 0x95, FIL_, 0xCC, 0x86, FIL_,
+		0xC5, 0x8E, FIL_, 0xCC, 0x88, FIL_, 0xC3, 0x96,
+		FIL_, 0xCC, 0x8B, FIL_, 0xC5, 0x90, FIL_, 0xCC,
+		0x89, FIL_, 0xE1, 0xBB, 0x8E, FIL_, 0x02, 0xCC,
+		0x87, FIL_, 0xE1, 0xB9, 0x96, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0x94, FIL_, 0x08, 0xCC, 0x91,
+		FIL_, 0xC8, 0x92, FIL_, 0xCC, 0xA7, FIL_, 0xC5,
+		0x96, FIL_, 0xCC, 0x8C, FIL_, 0xC5, 0x98, FIL_,
+		0xCC, 0xB1, FIL_, 0xE1, 0xB9, 0x9E, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xB9, 0x9A, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0x98, FIL_, 0xCC, 0x81, FIL_,
+		0xC5, 0x94, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x90,
+		FIL_, 0x07, 0xCC, 0x81, FIL_, 0xC5, 0x9A, FIL_,
+		0xCC, 0x82, FIL_, 0xC5, 0x9C, FIL_, 0xCC, 0xA7,
+		FIL_, 0xC5, 0x9E, FIL_, 0xCC, 0x8C, FIL_, 0xC5,
+		0xA0, FIL_, 0xCC, 0xA6, FIL_, 0xC8, 0x98, FIL_,
+		0xCC, 0x87, FIL_, 0xE1, 0xB9, 0xA0, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xB9, 0xA2, FIL_, 0x07, 0xCC,
+		0x8C, FIL_, 0xC5, 0xA4, FIL_, 0xCC, 0xB1, FIL_,
+		0xE1, 0xB9, 0xAE, FIL_, 0xCC, 0xA6, FIL_, 0xC8,
+		0x9A, FIL_, 0xCC, 0xA7, FIL_, 0xC5, 0xA2, FIL_,
+		0xCC, 0x87, FIL_, 0xE1, 0xB9, 0xAA, FIL_, 0xCC,
+		0xAD, FIL_, 0xE1, 0xB9, 0xB0, FIL_, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xB9, 0xAC, FIL_, 0x13, 0xCC, 0xA8,
+		FIL_, 0xC5, 0xB2, FIL_, 0xCC, 0x83, FIL_, 0xC5,
+		0xA8, FIL_, 0xCC, 0x84, FIL_, 0xC5, 0xAA, FIL_,
+		0xCC, 0x81, FIL_, 0xC3, 0x9A, FIL_, 0xCC, 0x86,
+		FIL_, 0xC5, 0xAC, FIL_, 0xCC, 0x8A, FIL_, 0xC5,
+		0xAE, FIL_, 0xCC, 0x80, FIL_, 0xC3, 0x99, FIL_,
+		0xCC, 0x91, FIL_, 0xC8, 0x96, FIL_, 0xCC, 0x8B,
+		FIL_, 0xC5, 0xB0, FIL_, 0xCC, 0xA4, FIL_, 0xE1,
+		0xB9, 0xB2, FIL_, 0xCC, 0xB0, FIL_, 0xE1, 0xB9,
+		0xB4, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x94, FIL_,
+		0xCC, 0xAD, FIL_, 0xE1, 0xB9, 0xB6, FIL_, 0xCC,
+		0x9B, FIL_, 0xC6, 0xAF, FIL_, 0xCC, 0x82, FIL_,
+		0xC3, 0x9B, FIL_, 0xCC, 0x88, FIL_, 0xC3, 0x9C,
+		FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0x93, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xBB, 0xA4, FIL_, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBB, 0xA6, FIL_, 0x02, 0xCC, 0x83,
+		FIL_, 0xE1, 0xB9, 0xBC, FIL_, 0xCC, 0xA3, FIL_,
+		0xE1, 0xB9, 0xBE, FIL_, 0x06, 0xCC, 0x82, FIL_,
+		0xC5, 0xB4, FIL_, 0xCC, 0x88, FIL_, 0xE1, 0xBA,
+		0x84, FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xBA, 0x86,
+		FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBA, 0x88, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xBA, 0x82, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBA, 0x80, FIL_, 0x02, 0xCC,
+		0x87, FIL_, 0xE1, 0xBA, 0x8A, FIL_, 0xCC, 0x88,
+		FIL_, 0xE1, 0xBA, 0x8C, FIL_, 0x09, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBB, 0xB6, FIL_, 0xCC, 0x87, FIL_,
+		0xE1, 0xBA, 0x8E, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xBB, 0xB4, FIL_, 0xCC, 0x81, FIL_, 0xC3, 0x9D,
+		FIL_, 0xCC, 0x84, FIL_, 0xC8, 0xB2, FIL_, 0xCC,
+		0x82, FIL_, 0xC5, 0xB6, FIL_, 0xCC, 0x88, FIL_,
+		0xC5, 0xB8, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBB,
+		0xB2, FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBB, 0xB8,
+		FIL_, 0x06, 0xCC, 0x87, FIL_, 0xC5, 0xBB, FIL_,
+		0xCC, 0xA3, FIL_, 0xE1, 0xBA, 0x92, FIL_, 0xCC,
+		0x8C, FIL_, 0xC5, 0xBD, FIL_, 0xCC, 0xB1, FIL_,
+		0xE1, 0xBA, 0x94, FIL_, 0xCC, 0x82, FIL_, 0xE1,
+		0xBA, 0x90, FIL_, 0xCC, 0x81, FIL_, 0xC5, 0xB9,
+		FIL_, 0x10, 0xCC, 0x8C, FIL_, 0xC7, 0x8E, FIL_,
+		0xCC, 0x8F, FIL_, 0xC8, 0x81, FIL_, 0xCC, 0xA8,
+		FIL_, 0xC4, 0x85, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xBA, 0xA1, FIL_, 0xCC, 0x86, FIL_, 0xC4, 0x83,
+		FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBA, 0xA3, FIL_,
+		0xCC, 0x84, FIL_, 0xC4, 0x81, FIL_, 0xCC, 0x91,
+		FIL_, 0xC8, 0x83, FIL_, 0xCC, 0x8A, FIL_, 0xC3,
+		0xA5, FIL_, 0xCC, 0x88, FIL_, 0xC3, 0xA4, FIL_,
+		0xCC, 0x83, FIL_, 0xC3, 0xA3, FIL_, 0xCC, 0x82,
+		FIL_, 0xC3, 0xA2, FIL_, 0xCC, 0x81, FIL_, 0xC3,
+		0xA1, FIL_, 0xCC, 0x80, FIL_, 0xC3, 0xA0, FIL_,
+		0xCC, 0x87, FIL_, 0xC8, 0xA7, FIL_, 0xCC, 0xA5,
+		FIL_, 0xE1, 0xB8, 0x81, FIL_, 0x03, 0xCC, 0xB1,
+		FIL_, 0xE1, 0xB8, 0x87, FIL_, 0xCC, 0xA3, FIL_,
+		0xE1, 0xB8, 0x85, FIL_, 0xCC, 0x87, FIL_, 0xE1,
+		0xB8, 0x83, FIL_, 0x05, 0xCC, 0x87, FIL_, 0xC4,
+		0x8B, FIL_, 0xCC, 0xA7, FIL_, 0xC3, 0xA7, FIL_,
+		0xCC, 0x82, FIL_, 0xC4, 0x89, FIL_, 0xCC, 0x8C,
+		FIL_, 0xC4, 0x8D, FIL_, 0xCC, 0x81, FIL_, 0xC4,
+		0x87, FIL_, 0x06, 0xCC, 0xAD, FIL_, 0xE1, 0xB8,
+		0x93, FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xB8, 0x8B,
+		FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB8, 0x8D, FIL_,
+		0xCC, 0xB1, FIL_, 0xE1, 0xB8, 0x8F, FIL_, 0xCC,
+		0xA7, FIL_, 0xE1, 0xB8, 0x91, FIL_, 0xCC, 0x8C,
+		FIL_, 0xC4, 0x8F, FIL_, 0x11, 0xCC, 0xA8, FIL_,
+		0xC4, 0x99, FIL_, 0xCC, 0x8C, FIL_, 0xC4, 0x9B,
+		FIL_, 0xCC, 0x87, FIL_, 0xC4, 0x97, FIL_, 0xCC,
+		0x88, FIL_, 0xC3, 0xAB, FIL_, 0xCC, 0xA3, FIL_,
+		0xE1, 0xBA, 0xB9, FIL_, 0xCC, 0xB0, FIL_, 0xE1,
+		0xB8, 0x9B, FIL_, 0xCC, 0x84, FIL_, 0xC4, 0x93,
+		FIL_, 0xCC, 0xAD, FIL_, 0xE1, 0xB8, 0x99, FIL_,
+		0xCC, 0x83, FIL_, 0xE1, 0xBA, 0xBD, FIL_, 0xCC,
+		0x86, FIL_, 0xC4, 0x95, FIL_, 0xCC, 0xA7, FIL_,
+		0xC8, 0xA9, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBA,
+		0xBB, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x85, FIL_,
+		0xCC, 0x81, FIL_, 0xC3, 0xA9, FIL_, 0xCC, 0x91,
+		FIL_, 0xC8, 0x87, FIL_, 0xCC, 0x80, FIL_, 0xC3,
+		0xA8, FIL_, 0xCC, 0x82, FIL_, 0xC3, 0xAA, FIL_,
+		0x01, 0xCC, 0x87, FIL_, 0xE1, 0xB8, 0x9F, FIL_,
+		0x07, 0xCC, 0x86, FIL_, 0xC4, 0x9F, FIL_, 0xCC,
+		0xA7, FIL_, 0xC4, 0xA3, FIL_, 0xCC, 0x81, FIL_,
+		0xC7, 0xB5, FIL_, 0xCC, 0x82, FIL_, 0xC4, 0x9D,
+		FIL_, 0xCC, 0x87, FIL_, 0xC4, 0xA1, FIL_, 0xCC,
+		0x8C, FIL_, 0xC7, 0xA7, FIL_, 0xCC, 0x84, FIL_,
+		0xE1, 0xB8, 0xA1, FIL_, 0x08, 0xCC, 0x8C, FIL_,
+		0xC8, 0x9F, FIL_, 0xCC, 0x82, FIL_, 0xC4, 0xA5,
+		FIL_, 0xCC, 0x88, FIL_, 0xE1, 0xB8, 0xA7, FIL_,
+		0xCC, 0x87, FIL_, 0xE1, 0xB8, 0xA3, FIL_, 0xCC,
+		0xB1, FIL_, 0xE1, 0xBA, 0x96, FIL_, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xB8, 0xA5, FIL_, 0xCC, 0xA7, FIL_,
+		0xE1, 0xB8, 0xA9, FIL_, 0xCC, 0xAE, FIL_, 0xE1,
+		0xB8, 0xAB, FIL_, 0x0E, 0xCC, 0x81, FIL_, 0xC3,
+		0xAD, FIL_, 0xCC, 0x80, FIL_, 0xC3, 0xAC, FIL_,
+		0xCC, 0xA3, FIL_, 0xE1, 0xBB, 0x8B, FIL_, 0xCC,
+		0x8C, FIL_, 0xC7, 0x90, FIL_, 0xCC, 0x89, FIL_,
+		0xE1, 0xBB, 0x89, FIL_, 0xCC, 0x91, FIL_, 0xC8,
+		0x8B, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x89, FIL_,
+		0xCC, 0x82, FIL_, 0xC3, 0xAE, FIL_, 0xCC, 0xB0,
+		FIL_, 0xE1, 0xB8, 0xAD, FIL_, 0xCC, 0xA8, FIL_,
+		0xC4, 0xAF, FIL_, 0xCC, 0x86, FIL_, 0xC4, 0xAD,
+		FIL_, 0xCC, 0x84, FIL_, 0xC4, 0xAB, FIL_, 0xCC,
+		0x83, FIL_, 0xC4, 0xA9, FIL_, 0xCC, 0x88, FIL_,
+		0xC3, 0xAF, FIL_, 0x02, 0xCC, 0x82, FIL_, 0xC4,
+		0xB5, FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0xB0, FIL_,
+		0x05, 0xCC, 0xA3, FIL_, 0xE1, 0xB8, 0xB3, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xB8, 0xB1, FIL_, 0xCC,
+		0xA7, FIL_, 0xC4, 0xB7, FIL_, 0xCC, 0x8C, FIL_,
+		0xC7, 0xA9, FIL_, 0xCC, 0xB1, FIL_, 0xE1, 0xB8,
+		0xB5, FIL_, 0x06, 0xCC, 0xA3, FIL_, 0xE1, 0xB8,
+		0xB7, FIL_, 0xCC, 0x81, FIL_, 0xC4, 0xBA, FIL_,
+		0xCC, 0xA7, FIL_, 0xC4, 0xBC, FIL_, 0xCC, 0x8C,
+		FIL_, 0xC4, 0xBE, FIL_, 0xCC, 0xB1, FIL_, 0xE1,
+		0xB8, 0xBB, FIL_, 0xCC, 0xAD, FIL_, 0xE1, 0xB8,
+		0xBD, FIL_, 0x03, 0xCC, 0xA3, FIL_, 0xE1, 0xB9,
+		0x83, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0xBF,
+		FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xB9, 0x81, FIL_,
+		0x09, 0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x87, FIL_,
+		0xCC, 0x83, FIL_, 0xC3, 0xB1, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0x85, FIL_, 0xCC, 0xB1, FIL_,
+		0xE1, 0xB9, 0x89, FIL_, 0xCC, 0x81, FIL_, 0xC5,
+		0x84, FIL_, 0xCC, 0xA7, FIL_, 0xC5, 0x86, FIL_,
+		0xCC, 0xAD, FIL_, 0xE1, 0xB9, 0x8B, FIL_, 0xCC,
+		0x8C, FIL_, 0xC5, 0x88, FIL_, 0xCC, 0x80, FIL_,
+		0xC7, 0xB9, FIL_, 0x10, 0xCC, 0x89, FIL_, 0xE1,
+		0xBB, 0x8F, FIL_, 0xCC, 0x81, FIL_, 0xC3, 0xB3,
+		FIL_, 0xCC, 0x80, FIL_, 0xC3, 0xB2, FIL_, 0xCC,
+		0x87, FIL_, 0xC8, 0xAF, FIL_, 0xCC, 0x8F, FIL_,
+		0xC8, 0x8D, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBB,
+		0x8D, FIL_, 0xCC, 0x84, FIL_, 0xC5, 0x8D, FIL_,
+		0xCC, 0x8C, FIL_, 0xC7, 0x92, FIL_, 0xCC, 0x86,
+		FIL_, 0xC5, 0x8F, FIL_, 0xCC, 0x8B, FIL_, 0xC5,
+		0x91, FIL_, 0xCC, 0x9B, FIL_, 0xC6, 0xA1, FIL_,
+		0xCC, 0x91, FIL_, 0xC8, 0x8F, FIL_, 0xCC, 0xA8,
+		FIL_, 0xC7, 0xAB, FIL_, 0xCC, 0x88, FIL_, 0xC3,
+		0xB6, FIL_, 0xCC, 0x83, FIL_, 0xC3, 0xB5, FIL_,
+		0xCC, 0x82, FIL_, 0xC3, 0xB4, FIL_, 0x02, 0xCC,
+		0x87, FIL_, 0xE1, 0xB9, 0x97, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0x95, FIL_, 0x08, 0xCC, 0xB1,
+		FIL_, 0xE1, 0xB9, 0x9F, FIL_, 0xCC, 0x87, FIL_,
+		0xE1, 0xB9, 0x99, FIL_, 0xCC, 0x81, FIL_, 0xC5,
+		0x95, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x91, FIL_,
+		0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x9B, FIL_, 0xCC,
+		0x8C, FIL_, 0xC5, 0x99, FIL_, 0xCC, 0x91, FIL_,
+		0xC8, 0x93, FIL_, 0xCC, 0xA7, FIL_, 0xC5, 0x97,
+		FIL_, 0x07, 0xCC, 0xA6, FIL_, 0xC8, 0x99, FIL_,
+		0xCC, 0x8C, FIL_, 0xC5, 0xA1, FIL_, 0xCC, 0x81,
+		FIL_, 0xC5, 0x9B, FIL_, 0xCC, 0x87, FIL_, 0xE1,
+		0xB9, 0xA1, FIL_, 0xCC, 0x82, FIL_, 0xC5, 0x9D,
+		FIL_, 0xCC, 0xA7, FIL_, 0xC5, 0x9F, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xB9, 0xA3, FIL_, 0x08, 0xCC,
+		0x88, FIL_, 0xE1, 0xBA, 0x97, FIL_, 0xCC, 0xAD,
+		FIL_, 0xE1, 0xB9, 0xB1, FIL_, 0xCC, 0xB1, FIL_,
+		0xE1, 0xB9, 0xAF, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xB9, 0xAD, FIL_, 0xCC, 0x8C, FIL_, 0xC5, 0xA5,
+		FIL_, 0xCC, 0xA7, FIL_, 0xC5, 0xA3, FIL_, 0xCC,
+		0x87, FIL_, 0xE1, 0xB9, 0xAB, FIL_, 0xCC, 0xA6,
+		FIL_, 0xC8, 0x9B, FIL_, 0x13, 0xCC, 0x81, FIL_,
+		0xC3, 0xBA, FIL_, 0xCC, 0x91, FIL_, 0xC8, 0x97,
+		FIL_, 0xCC, 0x83, FIL_, 0xC5, 0xA9, FIL_, 0xCC,
+		0x8F, FIL_, 0xC8, 0x95, FIL_, 0xCC, 0xA8, FIL_,
+		0xC5, 0xB3, FIL_, 0xCC, 0x82, FIL_, 0xC3, 0xBB,
+		FIL_, 0xCC, 0x88, FIL_, 0xC3, 0xBC, FIL_, 0xCC,
+		0x80, FIL_, 0xC3, 0xB9, FIL_, 0xCC, 0xA3, FIL_,
+		0xE1, 0xBB, 0xA5, FIL_, 0xCC, 0xA4, FIL_, 0xE1,
+		0xB9, 0xB3, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBB,
+		0xA7, FIL_, 0xCC, 0xB0, FIL_, 0xE1, 0xB9, 0xB5,
+		FIL_, 0xCC, 0xAD, FIL_, 0xE1, 0xB9, 0xB7, FIL_,
+		0xCC, 0x9B, FIL_, 0xC6, 0xB0, FIL_, 0xCC, 0x84,
+		FIL_, 0xC5, 0xAB, FIL_, 0xCC, 0x8B, FIL_, 0xC5,
+		0xB1, FIL_, 0xCC, 0x86, FIL_, 0xC5, 0xAD, FIL_,
+		0xCC, 0x8C, FIL_, 0xC7, 0x94, FIL_, 0xCC, 0x8A,
+		FIL_, 0xC5, 0xAF, FIL_, 0x02, 0xCC, 0x83, FIL_,
+		0xE1, 0xB9, 0xBD, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xB9, 0xBF, FIL_, 0x07, 0xCC, 0x82, FIL_, 0xC5,
+		0xB5, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBA, 0x81,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBA, 0x83, FIL_,
+		0xCC, 0x88, FIL_, 0xE1, 0xBA, 0x85, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xBA, 0x89, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xBA, 0x87, FIL_, 0xCC, 0x8A, FIL_,
+		0xE1, 0xBA, 0x98, FIL_, 0x02, 0xCC, 0x87, FIL_,
+		0xE1, 0xBA, 0x8B, FIL_, 0xCC, 0x88, FIL_, 0xE1,
+		0xBA, 0x8D, FIL_, 0x0A, 0xCC, 0x87, FIL_, 0xE1,
+		0xBA, 0x8F, FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBB,
+		0xB9, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBB, 0xB3,
+		FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBB, 0xB7, FIL_,
+		0xCC, 0xA3, FIL_, 0xE1, 0xBB, 0xB5, FIL_, 0xCC,
+		0x82, FIL_, 0xC5, 0xB7, FIL_, 0xCC, 0x84, FIL_,
+		0xC8, 0xB3, FIL_, 0xCC, 0x8A, FIL_, 0xE1, 0xBA,
+		0x99, FIL_, 0xCC, 0x88, FIL_, 0xC3, 0xBF, FIL_,
+		0xCC, 0x81, FIL_, 0xC3, 0xBD, FIL_, 0x06, 0xCC,
+		0x8C, FIL_, 0xC5, 0xBE, FIL_, 0xCC, 0x87, FIL_,
+		0xC5, 0xBC, FIL_, 0xCC, 0xB1, FIL_, 0xE1, 0xBA,
+		0x95, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBA, 0x93,
+		FIL_, 0xCC, 0x81, FIL_, 0xC5, 0xBA, FIL_, 0xCC,
+		0x82, FIL_, 0xE1, 0xBA, 0x91, FIL_, 0x03, 0xCC,
+		0x80, FIL_, 0xE1, 0xBF, 0xAD, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBF, 0x81, FIL_, 0xCC, 0x81, FIL_,
+		0xCE, 0x85, FIL_, 0x04, 0xCC, 0x89, FIL_, 0xE1,
+		0xBA, 0xA8, FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBA,
+		0xAA, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBA, 0xA4,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBA, 0xA6, FIL_,
+		0x01, 0xCC, 0x84, FIL_, 0xC7, 0x9E, FIL_, 0x01,
+		0xCC, 0x81, FIL_, 0xC7, 0xBA, FIL_, 0x02, 0xCC,
+		0x84, FIL_, 0xC7, 0xA2, FIL_, 0xCC, 0x81, FIL_,
+		0xC7, 0xBC, FIL_, 0x01, 0xCC, 0x81, FIL_, 0xE1,
+		0xB8, 0x88, FIL_, 0x04, 0xCC, 0x81, FIL_, 0xE1,
+		0xBA, 0xBE, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBB,
+		0x80, FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBB, 0x84,
+		FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBB, 0x82, FIL_,
+		0x01, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0xAE, FIL_,
+		0x04, 0xCC, 0x83, FIL_, 0xE1, 0xBB, 0x96, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xBB, 0x90, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBB, 0x92, FIL_, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBB, 0x94, FIL_, 0x03, 0xCC, 0x84,
+		FIL_, 0xC8, 0xAC, FIL_, 0xCC, 0x81, FIL_, 0xE1,
+		0xB9, 0x8C, FIL_, 0xCC, 0x88, FIL_, 0xE1, 0xB9,
+		0x8E, FIL_, 0x01, 0xCC, 0x84, FIL_, 0xC8, 0xAA,
+		FIL_, 0x01, 0xCC, 0x81, FIL_, 0xC7, 0xBE, FIL_,
+		0x04, 0xCC, 0x80, FIL_, 0xC7, 0x9B, FIL_, 0xCC,
+		0x84, FIL_, 0xC7, 0x95, FIL_, 0xCC, 0x8C, FIL_,
+		0xC7, 0x99, FIL_, 0xCC, 0x81, FIL_, 0xC7, 0x97,
+		FIL_, 0x04, 0xCC, 0x89, FIL_, 0xE1, 0xBA, 0xA9,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBA, 0xA7, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xBA, 0xA5, FIL_, 0xCC,
+		0x83, FIL_, 0xE1, 0xBA, 0xAB, FIL_, 0x01, 0xCC,
+		0x84, FIL_, 0xC7, 0x9F, FIL_, 0x01, 0xCC, 0x81,
+		FIL_, 0xC7, 0xBB, FIL_, 0x02, 0xCC, 0x84, FIL_,
+		0xC7, 0xA3, FIL_, 0xCC, 0x81, FIL_, 0xC7, 0xBD,
+		FIL_, 0x01, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0x89,
+		FIL_, 0x04, 0xCC, 0x89, FIL_, 0xE1, 0xBB, 0x83,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBA, 0xBF, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBB, 0x81, FIL_, 0xCC,
+		0x83, FIL_, 0xE1, 0xBB, 0x85, FIL_, 0x01, 0xCC,
+		0x81, FIL_, 0xE1, 0xB8, 0xAF, FIL_, 0x04, 0xCC,
+		0x83, FIL_, 0xE1, 0xBB, 0x97, FIL_, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBB, 0x95, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBB, 0x93, FIL_, 0xCC, 0x81, FIL_, 0xE1,
+		0xBB, 0x91, FIL_, 0x03, 0xCC, 0x81, FIL_, 0xE1,
+		0xB9, 0x8D, FIL_, 0xCC, 0x84, FIL_, 0xC8, 0xAD,
+		FIL_, 0xCC, 0x88, FIL_, 0xE1, 0xB9, 0x8F, FIL_,
+		0x01, 0xCC, 0x84, FIL_, 0xC8, 0xAB, FIL_, 0x01,
+		0xCC, 0x81, FIL_, 0xC7, 0xBF, FIL_, 0x04, 0xCC,
+		0x81, FIL_, 0xC7, 0x98, FIL_, 0xCC, 0x84, FIL_,
+		0xC7, 0x96, FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0x9A,
+		FIL_, 0xCC, 0x80, FIL_, 0xC7, 0x9C, FIL_, 0x04,
+		0xCC, 0x80, FIL_, 0xE1, 0xBA, 0xB0, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xBA, 0xAE, FIL_, 0xCC, 0x83,
+		FIL_, 0xE1, 0xBA, 0xB4, FIL_, 0xCC, 0x89, FIL_,
+		0xE1, 0xBA, 0xB2, FIL_, 0x04, 0xCC, 0x80, FIL_,
+		0xE1, 0xBA, 0xB1, FIL_, 0xCC, 0x83, FIL_, 0xE1,
+		0xBA, 0xB5, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBA,
+		0xAF, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBA, 0xB3,
+		FIL_, 0x02, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0x96,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xB8, 0x94, FIL_,
+		0x02, 0xCC, 0x80, FIL_, 0xE1, 0xB8, 0x95, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xB8, 0x97, FIL_, 0x02,
+		0xCC, 0x80, FIL_, 0xE1, 0xB9, 0x90, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xB9, 0x92, FIL_, 0x02, 0xCC,
+		0x80, FIL_, 0xE1, 0xB9, 0x91, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0x93, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA4, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA5, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA6, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA7, FIL_, 0x01, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0xB8, FIL_, 0x01, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0xB9, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xE1, 0xB9, 0xBA, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xE1, 0xB9, 0xBB, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xBA, 0x9B, FIL_, 0x05, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBB, 0x9C, FIL_, 0xCC, 0x81, FIL_,
+		0xE1, 0xBB, 0x9A, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xBB, 0xA2, FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBB,
+		0xA0, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBB, 0x9E,
+		FIL_, 0x05, 0xCC, 0x83, FIL_, 0xE1, 0xBB, 0xA1,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBB, 0x9B, FIL_,
+		0xCC, 0xA3, FIL_, 0xE1, 0xBB, 0xA3, FIL_, 0xCC,
+		0x89, FIL_, 0xE1, 0xBB, 0x9F, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBB, 0x9D, FIL_, 0x05, 0xCC, 0x83,
+		FIL_, 0xE1, 0xBB, 0xAE, FIL_, 0xCC, 0xA3, FIL_,
+		0xE1, 0xBB, 0xB0, FIL_, 0xCC, 0x89, FIL_, 0xE1,
+		0xBB, 0xAC, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBB,
+		0xA8, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBB, 0xAA,
+		FIL_, 0x05, 0xCC, 0xA3, FIL_, 0xE1, 0xBB, 0xB1,
+		FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBB, 0xAF, FIL_,
+		0xCC, 0x89, FIL_, 0xE1, 0xBB, 0xAD, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xBB, 0xA9, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBB, 0xAB, FIL_, 0x01, 0xCC, 0x8C,
+		FIL_, 0xC7, 0xAE, FIL_, 0x01, 0xCC, 0x84, FIL_,
+		0xC7, 0xAC, FIL_, 0x01, 0xCC, 0x84, FIL_, 0xC7,
+		0xAD, FIL_, 0x01, 0xCC, 0x84, FIL_, 0xC7, 0xA0,
+		FIL_, 0x01, 0xCC, 0x84, FIL_, 0xC7, 0xA1, FIL_,
+		0x01, 0xCC, 0x86, FIL_, 0xE1, 0xB8, 0x9C, FIL_,
+		0x01, 0xCC, 0x86, FIL_, 0xE1, 0xB8, 0x9D, FIL_,
+		0x01, 0xCC, 0x84, FIL_, 0xC8, 0xB0, FIL_, 0x01,
+		0xCC, 0x84, FIL_, 0xC8, 0xB1, FIL_, 0x01, 0xCC,
+		0x8C, FIL_, 0xC7, 0xAF, FIL_, 0x07, 0xCC, 0x93,
+		FIL_, 0xE1, 0xBC, 0x88, FIL_, 0xCC, 0x94, FIL_,
+		0xE1, 0xBC, 0x89, FIL_, 0xCC, 0x81, FIL_, 0xCE,
+		0x86, FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xBC,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBE, 0xBA, FIL_,
+		0xCC, 0x84, FIL_, 0xE1, 0xBE, 0xB9, FIL_, 0xCC,
+		0x86, FIL_, 0xE1, 0xBE, 0xB8, FIL_, 0x04, 0xCC,
+		0x81, FIL_, 0xCE, 0x88, FIL_, 0xCC, 0x94, FIL_,
+		0xE1, 0xBC, 0x99, FIL_, 0xCC, 0x93, FIL_, 0xE1,
+		0xBC, 0x98, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBF,
+		0x88, FIL_, 0x05, 0xCC, 0x94, FIL_, 0xE1, 0xBC,
+		0xA9, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBF, 0x8A,
+		FIL_, 0xCC, 0x81, FIL_, 0xCE, 0x89, FIL_, 0xCD,
+		0x85, FIL_, 0xE1, 0xBF, 0x8C, FIL_, 0xCC, 0x93,
+		FIL_, 0xE1, 0xBC, 0xA8, FIL_, 0x07, 0xCC, 0x81,
+		FIL_, 0xCE, 0x8A, FIL_, 0xCC, 0x88, FIL_, 0xCE,
+		0xAA, FIL_, 0xCC, 0x86, FIL_, 0xE1, 0xBF, 0x98,
+		FIL_, 0xCC, 0x84, FIL_, 0xE1, 0xBF, 0x99, FIL_,
+		0xCC, 0x93, FIL_, 0xE1, 0xBC, 0xB8, FIL_, 0xCC,
+		0x94, FIL_, 0xE1, 0xBC, 0xB9, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBF, 0x9A, FIL_, 0x04, 0xCC, 0x94,
+		FIL_, 0xE1, 0xBD, 0x89, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBF, 0xB8, FIL_, 0xCC, 0x81, FIL_, 0xCE,
+		0x8C, FIL_, 0xCC, 0x93, FIL_, 0xE1, 0xBD, 0x88,
+		FIL_, 0x01, 0xCC, 0x94, FIL_, 0xE1, 0xBF, 0xAC,
+		FIL_, 0x06, 0xCC, 0x81, FIL_, 0xCE, 0x8E, FIL_,
+		0xCC, 0x86, FIL_, 0xE1, 0xBF, 0xA8, FIL_, 0xCC,
+		0x94, FIL_, 0xE1, 0xBD, 0x99, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBF, 0xAA, FIL_, 0xCC, 0x84, FIL_,
+		0xE1, 0xBF, 0xA9, FIL_, 0xCC, 0x88, FIL_, 0xCE,
+		0xAB, FIL_, 0x05, 0xCC, 0x80, FIL_, 0xE1, 0xBF,
+		0xBA, FIL_, 0xCC, 0x81, FIL_, 0xCE, 0x8F, FIL_,
+		0xCD, 0x85, FIL_, 0xE1, 0xBF, 0xBC, FIL_, 0xCC,
+		0x94, FIL_, 0xE1, 0xBD, 0xA9, FIL_, 0xCC, 0x93,
+		FIL_, 0xE1, 0xBD, 0xA8, FIL_, 0x01, 0xCD, 0x85,
+		FIL_, 0xE1, 0xBE, 0xB4, FIL_, 0x01, 0xCD, 0x85,
+		FIL_, 0xE1, 0xBF, 0x84, FIL_, 0x08, 0xCC, 0x81,
+		FIL_, 0xCE, 0xAC, FIL_, 0xCC, 0x80, FIL_, 0xE1,
+		0xBD, 0xB0, FIL_, 0xCC, 0x93, FIL_, 0xE1, 0xBC,
+		0x80, FIL_, 0xCC, 0x94, FIL_, 0xE1, 0xBC, 0x81,
+		FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBE, 0xB6, FIL_,
+		0xCC, 0x86, FIL_, 0xE1, 0xBE, 0xB0, FIL_, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xB3, FIL_, 0xCC, 0x84,
+		FIL_, 0xE1, 0xBE, 0xB1, FIL_, 0x04, 0xCC, 0x81,
+		FIL_, 0xCE, 0xAD, FIL_, 0xCC, 0x94, FIL_, 0xE1,
+		0xBC, 0x91, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD,
+		0xB2, FIL_, 0xCC, 0x93, FIL_, 0xE1, 0xBC, 0x90,
+		FIL_, 0x06, 0xCC, 0x81, FIL_, 0xCE, 0xAE, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBD, 0xB4, FIL_, 0xCD,
+		0x85, FIL_, 0xE1, 0xBF, 0x83, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBF, 0x86, FIL_, 0xCC, 0x94, FIL_,
+		0xE1, 0xBC, 0xA1, FIL_, 0xCC, 0x93, FIL_, 0xE1,
+		0xBC, 0xA0, FIL_, 0x08, 0xCD, 0x82, FIL_, 0xE1,
+		0xBF, 0x96, FIL_, 0xCC, 0x86, FIL_, 0xE1, 0xBF,
+		0x90, FIL_, 0xCC, 0x93, FIL_, 0xE1, 0xBC, 0xB0,
+		FIL_, 0xCC, 0x81, FIL_, 0xCE, 0xAF, FIL_, 0xCC,
+		0x94, FIL_, 0xE1, 0xBC, 0xB1, FIL_, 0xCC, 0x84,
+		FIL_, 0xE1, 0xBF, 0x91, FIL_, 0xCC, 0x88, FIL_,
+		0xCF, 0x8A, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD,
+		0xB6, FIL_, 0x04, 0xCC, 0x81, FIL_, 0xCF, 0x8C,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0xB8, FIL_,
+		0xCC, 0x93, FIL_, 0xE1, 0xBD, 0x80, FIL_, 0xCC,
+		0x94, FIL_, 0xE1, 0xBD, 0x81, FIL_, 0x02, 0xCC,
+		0x93, FIL_, 0xE1, 0xBF, 0xA4, FIL_, 0xCC, 0x94,
+		FIL_, 0xE1, 0xBF, 0xA5, FIL_, 0x08, 0xCC, 0x93,
+		FIL_, 0xE1, 0xBD, 0x90, FIL_, 0xCC, 0x94, FIL_,
+		0xE1, 0xBD, 0x91, FIL_, 0xCC, 0x86, FIL_, 0xE1,
+		0xBF, 0xA0, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBF,
+		0xA6, FIL_, 0xCC, 0x84, FIL_, 0xE1, 0xBF, 0xA1,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0xBA, FIL_,
+		0xCC, 0x81, FIL_, 0xCF, 0x8D, FIL_, 0xCC, 0x88,
+		FIL_, 0xCF, 0x8B, FIL_, 0x06, 0xCC, 0x94, FIL_,
+		0xE1, 0xBD, 0xA1, FIL_, 0xCD, 0x85, FIL_, 0xE1,
+		0xBF, 0xB3, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD,
+		0xBC, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBF, 0xB6,
+		FIL_, 0xCC, 0x93, FIL_, 0xE1, 0xBD, 0xA0, FIL_,
+		0xCC, 0x81, FIL_, 0xCF, 0x8E, FIL_, 0x03, 0xCD,
+		0x82, FIL_, 0xE1, 0xBF, 0x97, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBF, 0x92, FIL_, 0xCC, 0x81, FIL_,
+		0xCE, 0x90, FIL_, 0x03, 0xCC, 0x80, FIL_, 0xE1,
+		0xBF, 0xA2, FIL_, 0xCC, 0x81, FIL_, 0xCE, 0xB0,
+		FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBF, 0xA7, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBF, 0xB4, FIL_,
+		0x02, 0xCC, 0x88, FIL_, 0xCF, 0x94, FIL_, 0xCC,
+		0x81, FIL_, 0xCF, 0x93, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xD0, 0x87, FIL_, 0x02, 0xCC, 0x86, FIL_,
+		0xD3, 0x90, FIL_, 0xCC, 0x88, FIL_, 0xD3, 0x92,
+		FIL_, 0x01, 0xCC, 0x81, FIL_, 0xD0, 0x83, FIL_,
+		0x03, 0xCC, 0x86, FIL_, 0xD3, 0x96, FIL_, 0xCC,
+		0x80, FIL_, 0xD0, 0x80, FIL_, 0xCC, 0x88, FIL_,
+		0xD0, 0x81, FIL_, 0x02, 0xCC, 0x88, FIL_, 0xD3,
+		0x9C, FIL_, 0xCC, 0x86, FIL_, 0xD3, 0x81, FIL_,
+		0x01, 0xCC, 0x88, FIL_, 0xD3, 0x9E, FIL_, 0x04,
+		0xCC, 0x80, FIL_, 0xD0, 0x8D, FIL_, 0xCC, 0x88,
+		FIL_, 0xD3, 0xA4, FIL_, 0xCC, 0x86, FIL_, 0xD0,
+		0x99, FIL_, 0xCC, 0x84, FIL_, 0xD3, 0xA2, FIL_,
+		0x01, 0xCC, 0x81, FIL_, 0xD0, 0x8C, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xA6, FIL_, 0x04, 0xCC,
+		0x86, FIL_, 0xD0, 0x8E, FIL_, 0xCC, 0x8B, FIL_,
+		0xD3, 0xB2, FIL_, 0xCC, 0x88, FIL_, 0xD3, 0xB0,
+		FIL_, 0xCC, 0x84, FIL_, 0xD3, 0xAE, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xB4, FIL_, 0x01, 0xCC,
+		0x88, FIL_, 0xD3, 0xB8, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xD3, 0xAC, FIL_, 0x02, 0xCC, 0x86, FIL_,
+		0xD3, 0x91, FIL_, 0xCC, 0x88, FIL_, 0xD3, 0x93,
+		FIL_, 0x01, 0xCC, 0x81, FIL_, 0xD1, 0x93, FIL_,
+		0x03, 0xCC, 0x80, FIL_, 0xD1, 0x90, FIL_, 0xCC,
+		0x88, FIL_, 0xD1, 0x91, FIL_, 0xCC, 0x86, FIL_,
+		0xD3, 0x97, FIL_, 0x02, 0xCC, 0x88, FIL_, 0xD3,
+		0x9D, FIL_, 0xCC, 0x86, FIL_, 0xD3, 0x82, FIL_,
+		0x01, 0xCC, 0x88, FIL_, 0xD3, 0x9F, FIL_, 0x04,
+		0xCC, 0x88, FIL_, 0xD3, 0xA5, FIL_, 0xCC, 0x86,
+		FIL_, 0xD0, 0xB9, FIL_, 0xCC, 0x80, FIL_, 0xD1,
+		0x9D, FIL_, 0xCC, 0x84, FIL_, 0xD3, 0xA3, FIL_,
+		0x01, 0xCC, 0x81, FIL_, 0xD1, 0x9C, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xA7, FIL_, 0x04, 0xCC,
+		0x84, FIL_, 0xD3, 0xAF, FIL_, 0xCC, 0x86, FIL_,
+		0xD1, 0x9E, FIL_, 0xCC, 0x8B, FIL_, 0xD3, 0xB3,
+		FIL_, 0xCC, 0x88, FIL_, 0xD3, 0xB1, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xB5, FIL_, 0x01, 0xCC,
+		0x88, FIL_, 0xD3, 0xB9, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xD3, 0xAD, FIL_, 0x01, 0xCC, 0x88, FIL_,
+		0xD1, 0x97, FIL_, 0x01, 0xCC, 0x8F, FIL_, 0xD1,
+		0xB6, FIL_, 0x01, 0xCC, 0x8F, FIL_, 0xD1, 0xB7,
+		FIL_, 0x01, 0xCC, 0x88, FIL_, 0xD3, 0x9A, FIL_,
+		0x01, 0xCC, 0x88, FIL_, 0xD3, 0x9B, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xAA, FIL_, 0x01, 0xCC,
+		0x88, FIL_, 0xD3, 0xAB, FIL_, 0x03, 0xD9, 0x94,
+		FIL_, 0xD8, 0xA3, FIL_, 0xD9, 0x93, FIL_, 0xD8,
+		0xA2, FIL_, 0xD9, 0x95, FIL_, 0xD8, 0xA5, FIL_,
+		0x01, 0xD9, 0x94, FIL_, 0xD8, 0xA4, FIL_, 0x01,
+		0xD9, 0x94, FIL_, 0xD8, 0xA6, FIL_, 0x01, 0xD9,
+		0x94, FIL_, 0xDB, 0x82, FIL_, 0x01, 0xD9, 0x94,
+		FIL_, 0xDB, 0x93, FIL_, 0x01, 0xD9, 0x94, FIL_,
+		0xDB, 0x80, FIL_, 0x01, 0xE0, 0xA4, 0xBC, FIL_,
+		0xE0, 0xA4, 0xA9, FIL_, 0x01, 0xE0, 0xA4, 0xBC,
+		FIL_, 0xE0, 0xA4, 0xB1, FIL_, 0x01, 0xE0, 0xA4,
+		0xBC, FIL_, 0xE0, 0xA4, 0xB4, FIL_, 0x02, 0xE0,
+		0xA6, 0xBE, FIL_, 0xE0, 0xA7, 0x8B, FIL_, 0xE0,
+		0xA7, 0x97, FIL_, 0xE0, 0xA7, 0x8C, FIL_, 0x03,
+		0xE0, 0xAD, 0x97, FIL_, 0xE0, 0xAD, 0x8C, FIL_,
+		0xE0, 0xAC, 0xBE, FIL_, 0xE0, 0xAD, 0x8B, FIL_,
+		0xE0, 0xAD, 0x96, FIL_, 0xE0, 0xAD, 0x88, FIL_,
+		0x01, 0xE0, 0xAF, 0x97, FIL_, 0xE0, 0xAE, 0x94,
+		FIL_, 0x02, 0xE0, 0xAE, 0xBE, FIL_, 0xE0, 0xAF,
+		0x8A, FIL_, 0xE0, 0xAF, 0x97, FIL_, 0xE0, 0xAF,
+		0x8C, FIL_, 0x01, 0xE0, 0xAE, 0xBE, FIL_, 0xE0,
+		0xAF, 0x8B, FIL_, 0x01, 0xE0, 0xB1, 0x96, FIL_,
+		0xE0, 0xB1, 0x88, FIL_, 0x01, 0xE0, 0xB3, 0x95,
+		FIL_, 0xE0, 0xB3, 0x80, FIL_, 0x03, 0xE0, 0xB3,
+		0x95, FIL_, 0xE0, 0xB3, 0x87, FIL_, 0xE0, 0xB3,
+		0x82, FIL_, 0xE0, 0xB3, 0x8A, FIL_, 0xE0, 0xB3,
+		0x96, FIL_, 0xE0, 0xB3, 0x88, FIL_, 0x01, 0xE0,
+		0xB3, 0x95, FIL_, 0xE0, 0xB3, 0x8B, FIL_, 0x02,
+		0xE0, 0xB4, 0xBE, FIL_, 0xE0, 0xB5, 0x8A, FIL_,
+		0xE0, 0xB5, 0x97, FIL_, 0xE0, 0xB5, 0x8C, FIL_,
+		0x01, 0xE0, 0xB4, 0xBE, FIL_, 0xE0, 0xB5, 0x8B,
+		FIL_, 0x03, 0xE0, 0xB7, 0x8F, FIL_, 0xE0, 0xB7,
+		0x9C, FIL_, 0xE0, 0xB7, 0x8A, FIL_, 0xE0, 0xB7,
+		0x9A, FIL_, 0xE0, 0xB7, 0x9F, FIL_, 0xE0, 0xB7,
+		0x9E, FIL_, 0x01, 0xE0, 0xB7, 0x8A, FIL_, 0xE0,
+		0xB7, 0x9D, FIL_, 0x01, 0xE1, 0x80, 0xAE, FIL_,
+		0xE1, 0x80, 0xA6, FIL_, 0x01, 0xCC, 0x84, FIL_,
+		0xE1, 0xB8, 0xB8, FIL_, 0x01, 0xCC, 0x84, FIL_,
+		0xE1, 0xB8, 0xB9, FIL_, 0x01, 0xCC, 0x84, FIL_,
+		0xE1, 0xB9, 0x9C, FIL_, 0x01, 0xCC, 0x84, FIL_,
+		0xE1, 0xB9, 0x9D, FIL_, 0x01, 0xCC, 0x87, FIL_,
+		0xE1, 0xB9, 0xA8, FIL_, 0x01, 0xCC, 0x87, FIL_,
+		0xE1, 0xB9, 0xA9, FIL_, 0x02, 0xCC, 0x86, FIL_,
+		0xE1, 0xBA, 0xB6, FIL_, 0xCC, 0x82, FIL_, 0xE1,
+		0xBA, 0xAC, FIL_, 0x02, 0xCC, 0x86, FIL_, 0xE1,
+		0xBA, 0xB7, FIL_, 0xCC, 0x82, FIL_, 0xE1, 0xBA,
+		0xAD, FIL_, 0x01, 0xCC, 0x82, FIL_, 0xE1, 0xBB,
+		0x86, FIL_, 0x01, 0xCC, 0x82, FIL_, 0xE1, 0xBB,
+		0x87, FIL_, 0x01, 0xCC, 0x82, FIL_, 0xE1, 0xBB,
+		0x98, FIL_, 0x01, 0xCC, 0x82, FIL_, 0xE1, 0xBB,
+		0x99, FIL_, 0x04, 0xCC, 0x80, FIL_, 0xE1, 0xBC,
+		0x82, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0x84,
+		FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x80, FIL_,
+		0xCD, 0x82, FIL_, 0xE1, 0xBC, 0x86, FIL_, 0x04,
+		0xCD, 0x82, FIL_, 0xE1, 0xBC, 0x87, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBC, 0x83, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBC, 0x85, FIL_, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x81, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x82, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x83, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x84, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x85, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x86, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x87, FIL_, 0x04, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x88, FIL_, 0xCC, 0x80, FIL_, 0xE1,
+		0xBC, 0x8A, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBC,
+		0x8E, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0x8C,
+		FIL_, 0x04, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0x8D,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0x8B, FIL_,
+		0xCD, 0x82, FIL_, 0xE1, 0xBC, 0x8F, FIL_, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x89, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x8A, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x8B, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x8C, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x8D, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x8E, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x8F, FIL_, 0x02, 0xCC,
+		0x80, FIL_, 0xE1, 0xBC, 0x92, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBC, 0x94, FIL_, 0x02, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBC, 0x93, FIL_, 0xCC, 0x81, FIL_,
+		0xE1, 0xBC, 0x95, FIL_, 0x02, 0xCC, 0x80, FIL_,
+		0xE1, 0xBC, 0x9A, FIL_, 0xCC, 0x81, FIL_, 0xE1,
+		0xBC, 0x9C, FIL_, 0x02, 0xCC, 0x80, FIL_, 0xE1,
+		0xBC, 0x9B, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC,
+		0x9D, FIL_, 0x04, 0xCD, 0x82, FIL_, 0xE1, 0xBC,
+		0xA6, FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x90,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0xA4, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xA2, FIL_, 0x04,
+		0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xA3, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xBC, 0xA5, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBC, 0xA7, FIL_, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x91, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x92, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x93, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x94, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x95, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x96, FIL_, 0x01, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0x97, FIL_, 0x04, 0xCD, 0x82, FIL_,
+		0xE1, 0xBC, 0xAE, FIL_, 0xCC, 0x81, FIL_, 0xE1,
+		0xBC, 0xAC, FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE,
+		0x98, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xAA,
+		FIL_, 0x04, 0xCD, 0x82, FIL_, 0xE1, 0xBC, 0xAF,
+		FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x99, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xBC, 0xAD, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBC, 0xAB, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x9A, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x9B, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x9C, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x9D, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x9E, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0x9F, FIL_, 0x03, 0xCC,
+		0x81, FIL_, 0xE1, 0xBC, 0xB4, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBC, 0xB6, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBC, 0xB2, FIL_, 0x03, 0xCC, 0x81, FIL_,
+		0xE1, 0xBC, 0xB5, FIL_, 0xCD, 0x82, FIL_, 0xE1,
+		0xBC, 0xB7, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBC,
+		0xB3, FIL_, 0x03, 0xCC, 0x81, FIL_, 0xE1, 0xBC,
+		0xBC, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xBA,
+		FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBC, 0xBE, FIL_,
+		0x03, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xBB, FIL_,
+		0xCD, 0x82, FIL_, 0xE1, 0xBC, 0xBF, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xBC, 0xBD, FIL_, 0x02, 0xCC,
+		0x80, FIL_, 0xE1, 0xBD, 0x82, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBD, 0x84, FIL_, 0x02, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBD, 0x83, FIL_, 0xCC, 0x81, FIL_,
+		0xE1, 0xBD, 0x85, FIL_, 0x02, 0xCC, 0x81, FIL_,
+		0xE1, 0xBD, 0x8C, FIL_, 0xCC, 0x80, FIL_, 0xE1,
+		0xBD, 0x8A, FIL_, 0x02, 0xCC, 0x81, FIL_, 0xE1,
+		0xBD, 0x8D, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD,
+		0x8B, FIL_, 0x03, 0xCC, 0x81, FIL_, 0xE1, 0xBD,
+		0x94, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBD, 0x96,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0x92, FIL_,
+		0x03, 0xCD, 0x82, FIL_, 0xE1, 0xBD, 0x97, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xBD, 0x95, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBD, 0x93, FIL_, 0x03, 0xCC,
+		0x81, FIL_, 0xE1, 0xBD, 0x9D, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBD, 0x9F, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBD, 0x9B, FIL_, 0x04, 0xCC, 0x81, FIL_,
+		0xE1, 0xBD, 0xA4, FIL_, 0xCC, 0x80, FIL_, 0xE1,
+		0xBD, 0xA2, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBD,
+		0xA6, FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xA0,
+		FIL_, 0x04, 0xCD, 0x82, FIL_, 0xE1, 0xBD, 0xA7,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBD, 0xA5, FIL_,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xA1, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBD, 0xA3, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xA2, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xA3, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xA4, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xA5, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xA6, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xA7, FIL_, 0x04, 0xCC,
+		0x81, FIL_, 0xE1, 0xBD, 0xAC, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBD, 0xAA, FIL_, 0xCD, 0x82, FIL_,
+		0xE1, 0xBD, 0xAE, FIL_, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xA8, FIL_, 0x04, 0xCC, 0x81, FIL_, 0xE1,
+		0xBD, 0xAD, FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE,
+		0xA9, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBD, 0xAF,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0xAB, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xAA, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xAB, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xAC, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xAD, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xAE, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xAF, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xB2, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBF, 0x82, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBF, 0xB2, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xB7, FIL_,
+		0x03, 0xCD, 0x82, FIL_, 0xE1, 0xBF, 0x8F, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBF, 0x8D, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xBF, 0x8E, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBF, 0x87, FIL_, 0x01, 0xCD,
+		0x85, FIL_, 0xE1, 0xBF, 0xB7, FIL_, 0x03, 0xCC,
+		0x80, FIL_, 0xE1, 0xBF, 0x9D, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBF, 0x9F, FIL_, 0xCC, 0x81, FIL_,
+		0xE1, 0xBF, 0x9E, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x86, 0x9A, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x86, 0x9B, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x86, 0xAE, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x87, 0x8D, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x87, 0x8F, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x87, 0x8E, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x88, 0x84, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x88, 0x89, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x88, 0x8C, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x88, 0xA4, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x88, 0xA6, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0x81, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0x84, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0x87, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0x89, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0xAD, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0xA2, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0xB0, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0xB1, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0xB4, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0xB5, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0xB8, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x89, 0xB9, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0x80, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0x81, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8B, 0xA0, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8B, 0xA1, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0x84, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0x85, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0x88, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0x89, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8B, 0xA2, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8B, 0xA3, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0xAC, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0xAD, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0xAE, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8A, 0xAF, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8B, 0xAA, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8B, 0xAB, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8B, 0xAC, FIL_, 0x01, 0xCC, 0xB8, FIL_,
+		0xE2, 0x8B, 0xAD, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x82, 0x94, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x81, 0x8C, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x81, 0x8E, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0x90, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0x92,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81,
+		0x94, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x81, 0x96, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x81, 0x98, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x81, 0x9A, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x81, 0x9C, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x81, 0x9E, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0xA0, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0xA2,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81,
+		0xA5, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x81, 0xA7, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x81, 0xA9, FIL_, 0x02, 0xE3, 0x82, 0x9A,
+		FIL_, 0xE3, 0x81, 0xB1, FIL_, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x81, 0xB0, FIL_, 0x02, 0xE3, 0x82,
+		0x9A, FIL_, 0xE3, 0x81, 0xB4, FIL_, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x81, 0xB3, FIL_, 0x02, 0xE3,
+		0x82, 0x9A, FIL_, 0xE3, 0x81, 0xB7, FIL_, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x81, 0xB6, FIL_, 0x02,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0xB9, FIL_,
+		0xE3, 0x82, 0x9A, FIL_, 0xE3, 0x81, 0xBA, FIL_,
+		0x02, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0xBC,
+		FIL_, 0xE3, 0x82, 0x9A, FIL_, 0xE3, 0x81, 0xBD,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82,
+		0x9E, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x83, 0xB4, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x82, 0xAC, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x82, 0xAE, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x82, 0xB0, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x82, 0xB2, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82, 0xB4, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82, 0xB6,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82,
+		0xB8, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x82, 0xBA, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x82, 0xBC, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x82, 0xBE, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x83, 0x80, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x83, 0x82, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83, 0x85, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83, 0x87,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83,
+		0x89, FIL_, 0x02, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x83, 0x90, FIL_, 0xE3, 0x82, 0x9A, FIL_, 0xE3,
+		0x83, 0x91, FIL_, 0x02, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x83, 0x93, FIL_, 0xE3, 0x82, 0x9A, FIL_,
+		0xE3, 0x83, 0x94, FIL_, 0x02, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x83, 0x96, FIL_, 0xE3, 0x82, 0x9A,
+		FIL_, 0xE3, 0x83, 0x97, FIL_, 0x02, 0xE3, 0x82,
+		0x9A, FIL_, 0xE3, 0x83, 0x9A, FIL_, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x83, 0x99, FIL_, 0x02, 0xE3,
+		0x82, 0x9A, FIL_, 0xE3, 0x83, 0x9D, FIL_, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x83, 0x9C, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83, 0xB7, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83, 0xB8,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83,
+		0xB9, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x83, 0xBA, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x83, 0xBE, FIL_, 0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,
+	},
+	{
+		0x01, 0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xAE, FIL_,
+		0x01, 0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xA0, FIL_,
+		0x01, 0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xAF, FIL_,
+		0x10, 0xCC, 0xA5, FIL_, 0xE1, 0xB8, 0x80, FIL_,
+		0xCC, 0x87, FIL_, 0xC8, 0xA6, FIL_, 0xCC, 0x83,
+		FIL_, 0xC3, 0x83, FIL_, 0xCC, 0x91, FIL_, 0xC8,
+		0x82, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x80, FIL_,
+		0xCC, 0x8A, FIL_, 0xC3, 0x85, FIL_, 0xCC, 0x88,
+		FIL_, 0xC3, 0x84, FIL_, 0xCC, 0x89, FIL_, 0xE1,
+		0xBA, 0xA2, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBA,
+		0xA0, FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0x8D, FIL_,
+		0xCC, 0x80, FIL_, 0xC3, 0x80, FIL_, 0xCC, 0x81,
+		FIL_, 0xC3, 0x81, FIL_, 0xCC, 0x82, FIL_, 0xC3,
+		0x82, FIL_, 0xCC, 0xA8, FIL_, 0xC4, 0x84, FIL_,
+		0xCC, 0x86, FIL_, 0xC4, 0x82, FIL_, 0xCC, 0x84,
+		FIL_, 0xC4, 0x80, FIL_, 0x03, 0xCC, 0xB1, FIL_,
+		0xE1, 0xB8, 0x86, FIL_, 0xCC, 0x87, FIL_, 0xE1,
+		0xB8, 0x82, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB8,
+		0x84, FIL_, 0x05, 0xCC, 0xA7, FIL_, 0xC3, 0x87,
+		FIL_, 0xCC, 0x8C, FIL_, 0xC4, 0x8C, FIL_, 0xCC,
+		0x81, FIL_, 0xC4, 0x86, FIL_, 0xCC, 0x82, FIL_,
+		0xC4, 0x88, FIL_, 0xCC, 0x87, FIL_, 0xC4, 0x8A,
+		FIL_, 0x06, 0xCC, 0xA7, FIL_, 0xE1, 0xB8, 0x90,
+		FIL_, 0xCC, 0x8C, FIL_, 0xC4, 0x8E, FIL_, 0xCC,
+		0xB1, FIL_, 0xE1, 0xB8, 0x8E, FIL_, 0xCC, 0xAD,
+		FIL_, 0xE1, 0xB8, 0x92, FIL_, 0xCC, 0xA3, FIL_,
+		0xE1, 0xB8, 0x8C, FIL_, 0xCC, 0x87, FIL_, 0xE1,
+		0xB8, 0x8A, FIL_, 0x11, 0xCC, 0x84, FIL_, 0xC4,
+		0x92, FIL_, 0xCC, 0x86, FIL_, 0xC4, 0x94, FIL_,
+		0xCC, 0xA3, FIL_, 0xE1, 0xBA, 0xB8, FIL_, 0xCC,
+		0x91, FIL_, 0xC8, 0x86, FIL_, 0xCC, 0x82, FIL_,
+		0xC3, 0x8A, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x84,
+		FIL_, 0xCC, 0xAD, FIL_, 0xE1, 0xB8, 0x98, FIL_,
+		0xCC, 0x89, FIL_, 0xE1, 0xBA, 0xBA, FIL_, 0xCC,
+		0xA7, FIL_, 0xC8, 0xA8, FIL_, 0xCC, 0x8C, FIL_,
+		0xC4, 0x9A, FIL_, 0xCC, 0x80, FIL_, 0xC3, 0x88,
+		FIL_, 0xCC, 0xA8, FIL_, 0xC4, 0x98, FIL_, 0xCC,
+		0x83, FIL_, 0xE1, 0xBA, 0xBC, FIL_, 0xCC, 0x87,
+		FIL_, 0xC4, 0x96, FIL_, 0xCC, 0x81, FIL_, 0xC3,
+		0x89, FIL_, 0xCC, 0x88, FIL_, 0xC3, 0x8B, FIL_,
+		0xCC, 0xB0, FIL_, 0xE1, 0xB8, 0x9A, FIL_, 0x01,
+		0xCC, 0x87, FIL_, 0xE1, 0xB8, 0x9E, FIL_, 0x07,
+		0xCC, 0x8C, FIL_, 0xC7, 0xA6, FIL_, 0xCC, 0x86,
+		FIL_, 0xC4, 0x9E, FIL_, 0xCC, 0x82, FIL_, 0xC4,
+		0x9C, FIL_, 0xCC, 0xA7, FIL_, 0xC4, 0xA2, FIL_,
+		0xCC, 0x84, FIL_, 0xE1, 0xB8, 0xA0, FIL_, 0xCC,
+		0x81, FIL_, 0xC7, 0xB4, FIL_, 0xCC, 0x87, FIL_,
+		0xC4, 0xA0, FIL_, 0x07, 0xCC, 0x87, FIL_, 0xE1,
+		0xB8, 0xA2, FIL_, 0xCC, 0xA7, FIL_, 0xE1, 0xB8,
+		0xA8, FIL_, 0xCC, 0x82, FIL_, 0xC4, 0xA4, FIL_,
+		0xCC, 0x88, FIL_, 0xE1, 0xB8, 0xA6, FIL_, 0xCC,
+		0x8C, FIL_, 0xC8, 0x9E, FIL_, 0xCC, 0xAE, FIL_,
+		0xE1, 0xB8, 0xAA, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xB8, 0xA4, FIL_, 0x0F, 0xCC, 0xB0, FIL_, 0xE1,
+		0xB8, 0xAC, FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0x8F,
+		FIL_, 0xCC, 0x80, FIL_, 0xC3, 0x8C, FIL_, 0xCC,
+		0x89, FIL_, 0xE1, 0xBB, 0x88, FIL_, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xBB, 0x8A, FIL_, 0xCC, 0x91, FIL_,
+		0xC8, 0x8A, FIL_, 0xCC, 0x88, FIL_, 0xC3, 0x8F,
+		FIL_, 0xCC, 0x82, FIL_, 0xC3, 0x8E, FIL_, 0xCC,
+		0x81, FIL_, 0xC3, 0x8D, FIL_, 0xCC, 0x83, FIL_,
+		0xC4, 0xA8, FIL_, 0xCC, 0x87, FIL_, 0xC4, 0xB0,
+		FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x88, FIL_, 0xCC,
+		0xA8, FIL_, 0xC4, 0xAE, FIL_, 0xCC, 0x86, FIL_,
+		0xC4, 0xAC, FIL_, 0xCC, 0x84, FIL_, 0xC4, 0xAA,
+		FIL_, 0x01, 0xCC, 0x82, FIL_, 0xC4, 0xB4, FIL_,
+		0x05, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0xB0, FIL_,
+		0xCC, 0x8C, FIL_, 0xC7, 0xA8, FIL_, 0xCC, 0xB1,
+		FIL_, 0xE1, 0xB8, 0xB4, FIL_, 0xCC, 0xA7, FIL_,
+		0xC4, 0xB6, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB8,
+		0xB2, FIL_, 0x06, 0xCC, 0xA3, FIL_, 0xE1, 0xB8,
+		0xB6, FIL_, 0xCC, 0x8C, FIL_, 0xC4, 0xBD, FIL_,
+		0xCC, 0xAD, FIL_, 0xE1, 0xB8, 0xBC, FIL_, 0xCC,
+		0xB1, FIL_, 0xE1, 0xB8, 0xBA, FIL_, 0xCC, 0xA7,
+		FIL_, 0xC4, 0xBB, FIL_, 0xCC, 0x81, FIL_, 0xC4,
+		0xB9, FIL_, 0x03, 0xCC, 0x81, FIL_, 0xE1, 0xB8,
+		0xBE, FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xB9, 0x80,
+		FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x82, FIL_,
+		0x09, 0xCC, 0x83, FIL_, 0xC3, 0x91, FIL_, 0xCC,
+		0x81, FIL_, 0xC5, 0x83, FIL_, 0xCC, 0xA7, FIL_,
+		0xC5, 0x85, FIL_, 0xCC, 0x8C, FIL_, 0xC5, 0x87,
+		FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xB9, 0x84, FIL_,
+		0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x86, FIL_, 0xCC,
+		0xB1, FIL_, 0xE1, 0xB9, 0x88, FIL_, 0xCC, 0xAD,
+		FIL_, 0xE1, 0xB9, 0x8A, FIL_, 0xCC, 0x80, FIL_,
+		0xC7, 0xB8, FIL_, 0x10, 0xCC, 0x89, FIL_, 0xE1,
+		0xBB, 0x8E, FIL_, 0xCC, 0x84, FIL_, 0xC5, 0x8C,
+		FIL_, 0xCC, 0x82, FIL_, 0xC3, 0x94, FIL_, 0xCC,
+		0x86, FIL_, 0xC5, 0x8E, FIL_, 0xCC, 0x83, FIL_,
+		0xC3, 0x95, FIL_, 0xCC, 0x8B, FIL_, 0xC5, 0x90,
+		FIL_, 0xCC, 0x88, FIL_, 0xC3, 0x96, FIL_, 0xCC,
+		0x9B, FIL_, 0xC6, 0xA0, FIL_, 0xCC, 0x91, FIL_,
+		0xC8, 0x8E, FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0x91,
+		FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x8C, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xBB, 0x8C, FIL_, 0xCC, 0x80,
+		FIL_, 0xC3, 0x92, FIL_, 0xCC, 0xA8, FIL_, 0xC7,
+		0xAA, FIL_, 0xCC, 0x87, FIL_, 0xC8, 0xAE, FIL_,
+		0xCC, 0x81, FIL_, 0xC3, 0x93, FIL_, 0x02, 0xCC,
+		0x87, FIL_, 0xE1, 0xB9, 0x96, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0x94, FIL_, 0x08, 0xCC, 0xA7,
+		FIL_, 0xC5, 0x96, FIL_, 0xCC, 0x8C, FIL_, 0xC5,
+		0x98, FIL_, 0xCC, 0x91, FIL_, 0xC8, 0x92, FIL_,
+		0xCC, 0x8F, FIL_, 0xC8, 0x90, FIL_, 0xCC, 0x81,
+		FIL_, 0xC5, 0x94, FIL_, 0xCC, 0x87, FIL_, 0xE1,
+		0xB9, 0x98, FIL_, 0xCC, 0xB1, FIL_, 0xE1, 0xB9,
+		0x9E, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x9A,
+		FIL_, 0x07, 0xCC, 0xA6, FIL_, 0xC8, 0x98, FIL_,
+		0xCC, 0x81, FIL_, 0xC5, 0x9A, FIL_, 0xCC, 0x82,
+		FIL_, 0xC5, 0x9C, FIL_, 0xCC, 0xA7, FIL_, 0xC5,
+		0x9E, FIL_, 0xCC, 0x8C, FIL_, 0xC5, 0xA0, FIL_,
+		0xCC, 0x87, FIL_, 0xE1, 0xB9, 0xA0, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xB9, 0xA2, FIL_, 0x07, 0xCC,
+		0xA6, FIL_, 0xC8, 0x9A, FIL_, 0xCC, 0x87, FIL_,
+		0xE1, 0xB9, 0xAA, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xB9, 0xAC, FIL_, 0xCC, 0xB1, FIL_, 0xE1, 0xB9,
+		0xAE, FIL_, 0xCC, 0xAD, FIL_, 0xE1, 0xB9, 0xB0,
+		FIL_, 0xCC, 0xA7, FIL_, 0xC5, 0xA2, FIL_, 0xCC,
+		0x8C, FIL_, 0xC5, 0xA4, FIL_, 0x13, 0xCC, 0x8A,
+		FIL_, 0xC5, 0xAE, FIL_, 0xCC, 0x88, FIL_, 0xC3,
+		0x9C, FIL_, 0xCC, 0x8B, FIL_, 0xC5, 0xB0, FIL_,
+		0xCC, 0xAD, FIL_, 0xE1, 0xB9, 0xB6, FIL_, 0xCC,
+		0xA8, FIL_, 0xC5, 0xB2, FIL_, 0xCC, 0x8C, FIL_,
+		0xC7, 0x93, FIL_, 0xCC, 0x80, FIL_, 0xC3, 0x99,
+		FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x94, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xBB, 0xA4, FIL_, 0xCC, 0xA4,
+		FIL_, 0xE1, 0xB9, 0xB2, FIL_, 0xCC, 0x81, FIL_,
+		0xC3, 0x9A, FIL_, 0xCC, 0x82, FIL_, 0xC3, 0x9B,
+		FIL_, 0xCC, 0xB0, FIL_, 0xE1, 0xB9, 0xB4, FIL_,
+		0xCC, 0x83, FIL_, 0xC5, 0xA8, FIL_, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBB, 0xA6, FIL_, 0xCC, 0x84, FIL_,
+		0xC5, 0xAA, FIL_, 0xCC, 0x91, FIL_, 0xC8, 0x96,
+		FIL_, 0xCC, 0x86, FIL_, 0xC5, 0xAC, FIL_, 0xCC,
+		0x9B, FIL_, 0xC6, 0xAF, FIL_, 0x02, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xB9, 0xBE, FIL_, 0xCC, 0x83, FIL_,
+		0xE1, 0xB9, 0xBC, FIL_, 0x06, 0xCC, 0x88, FIL_,
+		0xE1, 0xBA, 0x84, FIL_, 0xCC, 0x81, FIL_, 0xE1,
+		0xBA, 0x82, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBA,
+		0x80, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBA, 0x88,
+		FIL_, 0xCC, 0x82, FIL_, 0xC5, 0xB4, FIL_, 0xCC,
+		0x87, FIL_, 0xE1, 0xBA, 0x86, FIL_, 0x02, 0xCC,
+		0x88, FIL_, 0xE1, 0xBA, 0x8C, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xBA, 0x8A, FIL_, 0x09, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBB, 0xB6, FIL_, 0xCC, 0xA3, FIL_,
+		0xE1, 0xBB, 0xB4, FIL_, 0xCC, 0x80, FIL_, 0xE1,
+		0xBB, 0xB2, FIL_, 0xCC, 0x88, FIL_, 0xC5, 0xB8,
+		FIL_, 0xCC, 0x81, FIL_, 0xC3, 0x9D, FIL_, 0xCC,
+		0x83, FIL_, 0xE1, 0xBB, 0xB8, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xBA, 0x8E, FIL_, 0xCC, 0x84, FIL_,
+		0xC8, 0xB2, FIL_, 0xCC, 0x82, FIL_, 0xC5, 0xB6,
+		FIL_, 0x06, 0xCC, 0x82, FIL_, 0xE1, 0xBA, 0x90,
+		FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBA, 0x92, FIL_,
+		0xCC, 0xB1, FIL_, 0xE1, 0xBA, 0x94, FIL_, 0xCC,
+		0x8C, FIL_, 0xC5, 0xBD, FIL_, 0xCC, 0x87, FIL_,
+		0xC5, 0xBB, FIL_, 0xCC, 0x81, FIL_, 0xC5, 0xB9,
+		FIL_, 0x10, 0xCC, 0xA3, FIL_, 0xE1, 0xBA, 0xA1,
+		FIL_, 0xCC, 0xA8, FIL_, 0xC4, 0x85, FIL_, 0xCC,
+		0x81, FIL_, 0xC3, 0xA1, FIL_, 0xCC, 0x82, FIL_,
+		0xC3, 0xA2, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBA,
+		0xA3, FIL_, 0xCC, 0x83, FIL_, 0xC3, 0xA3, FIL_,
+		0xCC, 0x8C, FIL_, 0xC7, 0x8E, FIL_, 0xCC, 0x8A,
+		FIL_, 0xC3, 0xA5, FIL_, 0xCC, 0x88, FIL_, 0xC3,
+		0xA4, FIL_, 0xCC, 0x87, FIL_, 0xC8, 0xA7, FIL_,
+		0xCC, 0x91, FIL_, 0xC8, 0x83, FIL_, 0xCC, 0xA5,
+		FIL_, 0xE1, 0xB8, 0x81, FIL_, 0xCC, 0x84, FIL_,
+		0xC4, 0x81, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x81,
+		FIL_, 0xCC, 0x86, FIL_, 0xC4, 0x83, FIL_, 0xCC,
+		0x80, FIL_, 0xC3, 0xA0, FIL_, 0x03, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xB8, 0x85, FIL_, 0xCC, 0x87, FIL_,
+		0xE1, 0xB8, 0x83, FIL_, 0xCC, 0xB1, FIL_, 0xE1,
+		0xB8, 0x87, FIL_, 0x05, 0xCC, 0x87, FIL_, 0xC4,
+		0x8B, FIL_, 0xCC, 0x8C, FIL_, 0xC4, 0x8D, FIL_,
+		0xCC, 0x82, FIL_, 0xC4, 0x89, FIL_, 0xCC, 0x81,
+		FIL_, 0xC4, 0x87, FIL_, 0xCC, 0xA7, FIL_, 0xC3,
+		0xA7, FIL_, 0x06, 0xCC, 0x87, FIL_, 0xE1, 0xB8,
+		0x8B, FIL_, 0xCC, 0xA7, FIL_, 0xE1, 0xB8, 0x91,
+		FIL_, 0xCC, 0xB1, FIL_, 0xE1, 0xB8, 0x8F, FIL_,
+		0xCC, 0xA3, FIL_, 0xE1, 0xB8, 0x8D, FIL_, 0xCC,
+		0x8C, FIL_, 0xC4, 0x8F, FIL_, 0xCC, 0xAD, FIL_,
+		0xE1, 0xB8, 0x93, FIL_, 0x11, 0xCC, 0x80, FIL_,
+		0xC3, 0xA8, FIL_, 0xCC, 0x81, FIL_, 0xC3, 0xA9,
+		FIL_, 0xCC, 0x82, FIL_, 0xC3, 0xAA, FIL_, 0xCC,
+		0x88, FIL_, 0xC3, 0xAB, FIL_, 0xCC, 0x84, FIL_,
+		0xC4, 0x93, FIL_, 0xCC, 0x86, FIL_, 0xC4, 0x95,
+		FIL_, 0xCC, 0x87, FIL_, 0xC4, 0x97, FIL_, 0xCC,
+		0xA8, FIL_, 0xC4, 0x99, FIL_, 0xCC, 0x8C, FIL_,
+		0xC4, 0x9B, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x85,
+		FIL_, 0xCC, 0x91, FIL_, 0xC8, 0x87, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xBA, 0xB9, FIL_, 0xCC, 0xA7,
+		FIL_, 0xC8, 0xA9, FIL_, 0xCC, 0x83, FIL_, 0xE1,
+		0xBA, 0xBD, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBA,
+		0xBB, FIL_, 0xCC, 0xAD, FIL_, 0xE1, 0xB8, 0x99,
+		FIL_, 0xCC, 0xB0, FIL_, 0xE1, 0xB8, 0x9B, FIL_,
+		0x01, 0xCC, 0x87, FIL_, 0xE1, 0xB8, 0x9F, FIL_,
+		0x07, 0xCC, 0x86, FIL_, 0xC4, 0x9F, FIL_, 0xCC,
+		0x87, FIL_, 0xC4, 0xA1, FIL_, 0xCC, 0x82, FIL_,
+		0xC4, 0x9D, FIL_, 0xCC, 0x84, FIL_, 0xE1, 0xB8,
+		0xA1, FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0xA7, FIL_,
+		0xCC, 0xA7, FIL_, 0xC4, 0xA3, FIL_, 0xCC, 0x81,
+		FIL_, 0xC7, 0xB5, FIL_, 0x08, 0xCC, 0xA7, FIL_,
+		0xE1, 0xB8, 0xA9, FIL_, 0xCC, 0xB1, FIL_, 0xE1,
+		0xBA, 0x96, FIL_, 0xCC, 0x8C, FIL_, 0xC8, 0x9F,
+		FIL_, 0xCC, 0xAE, FIL_, 0xE1, 0xB8, 0xAB, FIL_,
+		0xCC, 0x88, FIL_, 0xE1, 0xB8, 0xA7, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xB8, 0xA5, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB8, 0xA3, FIL_, 0xCC, 0x82, FIL_,
+		0xC4, 0xA5, FIL_, 0x0E, 0xCC, 0x88, FIL_, 0xC3,
+		0xAF, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBB, 0x89,
+		FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBB, 0x8B, FIL_,
+		0xCC, 0x82, FIL_, 0xC3, 0xAE, FIL_, 0xCC, 0x81,
+		FIL_, 0xC3, 0xAD, FIL_, 0xCC, 0x80, FIL_, 0xC3,
+		0xAC, FIL_, 0xCC, 0x83, FIL_, 0xC4, 0xA9, FIL_,
+		0xCC, 0x84, FIL_, 0xC4, 0xAB, FIL_, 0xCC, 0x86,
+		FIL_, 0xC4, 0xAD, FIL_, 0xCC, 0xA8, FIL_, 0xC4,
+		0xAF, FIL_, 0xCC, 0xB0, FIL_, 0xE1, 0xB8, 0xAD,
+		FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0x90, FIL_, 0xCC,
+		0x91, FIL_, 0xC8, 0x8B, FIL_, 0xCC, 0x8F, FIL_,
+		0xC8, 0x89, FIL_, 0x02, 0xCC, 0x8C, FIL_, 0xC7,
+		0xB0, FIL_, 0xCC, 0x82, FIL_, 0xC4, 0xB5, FIL_,
+		0x05, 0xCC, 0xB1, FIL_, 0xE1, 0xB8, 0xB5, FIL_,
+		0xCC, 0xA7, FIL_, 0xC4, 0xB7, FIL_, 0xCC, 0x8C,
+		FIL_, 0xC7, 0xA9, FIL_, 0xCC, 0x81, FIL_, 0xE1,
+		0xB8, 0xB1, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB8,
+		0xB3, FIL_, 0x06, 0xCC, 0xA3, FIL_, 0xE1, 0xB8,
+		0xB7, FIL_, 0xCC, 0xAD, FIL_, 0xE1, 0xB8, 0xBD,
+		FIL_, 0xCC, 0xB1, FIL_, 0xE1, 0xB8, 0xBB, FIL_,
+		0xCC, 0xA7, FIL_, 0xC4, 0xBC, FIL_, 0xCC, 0x81,
+		FIL_, 0xC4, 0xBA, FIL_, 0xCC, 0x8C, FIL_, 0xC4,
+		0xBE, FIL_, 0x03, 0xCC, 0x87, FIL_, 0xE1, 0xB9,
+		0x81, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x83,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0xBF, FIL_,
+		0x09, 0xCC, 0x80, FIL_, 0xC7, 0xB9, FIL_, 0xCC,
+		0xAD, FIL_, 0xE1, 0xB9, 0x8B, FIL_, 0xCC, 0x83,
+		FIL_, 0xC3, 0xB1, FIL_, 0xCC, 0x81, FIL_, 0xC5,
+		0x84, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0x87,
+		FIL_, 0xCC, 0xB1, FIL_, 0xE1, 0xB9, 0x89, FIL_,
+		0xCC, 0x87, FIL_, 0xE1, 0xB9, 0x85, FIL_, 0xCC,
+		0xA7, FIL_, 0xC5, 0x86, FIL_, 0xCC, 0x8C, FIL_,
+		0xC5, 0x88, FIL_, 0x10, 0xCC, 0xA3, FIL_, 0xE1,
+		0xBB, 0x8D, FIL_, 0xCC, 0x87, FIL_, 0xC8, 0xAF,
+		FIL_, 0xCC, 0x80, FIL_, 0xC3, 0xB2, FIL_, 0xCC,
+		0x91, FIL_, 0xC8, 0x8F, FIL_, 0xCC, 0x89, FIL_,
+		0xE1, 0xBB, 0x8F, FIL_, 0xCC, 0x88, FIL_, 0xC3,
+		0xB6, FIL_, 0xCC, 0x83, FIL_, 0xC3, 0xB5, FIL_,
+		0xCC, 0x81, FIL_, 0xC3, 0xB3, FIL_, 0xCC, 0x8C,
+		FIL_, 0xC7, 0x92, FIL_, 0xCC, 0xA8, FIL_, 0xC7,
+		0xAB, FIL_, 0xCC, 0x9B, FIL_, 0xC6, 0xA1, FIL_,
+		0xCC, 0x84, FIL_, 0xC5, 0x8D, FIL_, 0xCC, 0x86,
+		FIL_, 0xC5, 0x8F, FIL_, 0xCC, 0x8B, FIL_, 0xC5,
+		0x91, FIL_, 0xCC, 0x82, FIL_, 0xC3, 0xB4, FIL_,
+		0xCC, 0x8F, FIL_, 0xC8, 0x8D, FIL_, 0x02, 0xCC,
+		0x87, FIL_, 0xE1, 0xB9, 0x97, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0x95, FIL_, 0x08, 0xCC, 0x8C,
+		FIL_, 0xC5, 0x99, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xB9, 0x9B, FIL_, 0xCC, 0x81, FIL_, 0xC5, 0x95,
+		FIL_, 0xCC, 0xA7, FIL_, 0xC5, 0x97, FIL_, 0xCC,
+		0xB1, FIL_, 0xE1, 0xB9, 0x9F, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0x99, FIL_, 0xCC, 0x91, FIL_,
+		0xC8, 0x93, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x91,
+		FIL_, 0x07, 0xCC, 0xA7, FIL_, 0xC5, 0x9F, FIL_,
+		0xCC, 0x82, FIL_, 0xC5, 0x9D, FIL_, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA1, FIL_, 0xCC, 0xA6, FIL_,
+		0xC8, 0x99, FIL_, 0xCC, 0x81, FIL_, 0xC5, 0x9B,
+		FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB9, 0xA3, FIL_,
+		0xCC, 0x8C, FIL_, 0xC5, 0xA1, FIL_, 0x08, 0xCC,
+		0xA6, FIL_, 0xC8, 0x9B, FIL_, 0xCC, 0xAD, FIL_,
+		0xE1, 0xB9, 0xB1, FIL_, 0xCC, 0xB1, FIL_, 0xE1,
+		0xB9, 0xAF, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xB9,
+		0xAD, FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xB9, 0xAB,
+		FIL_, 0xCC, 0x8C, FIL_, 0xC5, 0xA5, FIL_, 0xCC,
+		0xA7, FIL_, 0xC5, 0xA3, FIL_, 0xCC, 0x88, FIL_,
+		0xE1, 0xBA, 0x97, FIL_, 0x13, 0xCC, 0x8A, FIL_,
+		0xC5, 0xAF, FIL_, 0xCC, 0x8F, FIL_, 0xC8, 0x95,
+		FIL_, 0xCC, 0x8C, FIL_, 0xC7, 0x94, FIL_, 0xCC,
+		0x80, FIL_, 0xC3, 0xB9, FIL_, 0xCC, 0x9B, FIL_,
+		0xC6, 0xB0, FIL_, 0xCC, 0x82, FIL_, 0xC3, 0xBB,
+		FIL_, 0xCC, 0x81, FIL_, 0xC3, 0xBA, FIL_, 0xCC,
+		0x88, FIL_, 0xC3, 0xBC, FIL_, 0xCC, 0x83, FIL_,
+		0xC5, 0xA9, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBB,
+		0xA7, FIL_, 0xCC, 0x84, FIL_, 0xC5, 0xAB, FIL_,
+		0xCC, 0x86, FIL_, 0xC5, 0xAD, FIL_, 0xCC, 0xAD,
+		FIL_, 0xE1, 0xB9, 0xB7, FIL_, 0xCC, 0x8B, FIL_,
+		0xC5, 0xB1, FIL_, 0xCC, 0xA8, FIL_, 0xC5, 0xB3,
+		FIL_, 0xCC, 0x91, FIL_, 0xC8, 0x97, FIL_, 0xCC,
+		0xA4, FIL_, 0xE1, 0xB9, 0xB3, FIL_, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xBB, 0xA5, FIL_, 0xCC, 0xB0, FIL_,
+		0xE1, 0xB9, 0xB5, FIL_, 0x02, 0xCC, 0x83, FIL_,
+		0xE1, 0xB9, 0xBD, FIL_, 0xCC, 0xA3, FIL_, 0xE1,
+		0xB9, 0xBF, FIL_, 0x07, 0xCC, 0x8A, FIL_, 0xE1,
+		0xBA, 0x98, FIL_, 0xCC, 0x87, FIL_, 0xE1, 0xBA,
+		0x87, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBA, 0x83,
+		FIL_, 0xCC, 0x82, FIL_, 0xC5, 0xB5, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBA, 0x81, FIL_, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xBA, 0x89, FIL_, 0xCC, 0x88, FIL_,
+		0xE1, 0xBA, 0x85, FIL_, 0x02, 0xCC, 0x87, FIL_,
+		0xE1, 0xBA, 0x8B, FIL_, 0xCC, 0x88, FIL_, 0xE1,
+		0xBA, 0x8D, FIL_, 0x0A, 0xCC, 0x87, FIL_, 0xE1,
+		0xBA, 0x8F, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBB,
+		0xB5, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBB, 0xB7,
+		FIL_, 0xCC, 0x8A, FIL_, 0xE1, 0xBA, 0x99, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBB, 0xB3, FIL_, 0xCC,
+		0x83, FIL_, 0xE1, 0xBB, 0xB9, FIL_, 0xCC, 0x88,
+		FIL_, 0xC3, 0xBF, FIL_, 0xCC, 0x81, FIL_, 0xC3,
+		0xBD, FIL_, 0xCC, 0x84, FIL_, 0xC8, 0xB3, FIL_,
+		0xCC, 0x82, FIL_, 0xC5, 0xB7, FIL_, 0x06, 0xCC,
+		0xB1, FIL_, 0xE1, 0xBA, 0x95, FIL_, 0xCC, 0xA3,
+		FIL_, 0xE1, 0xBA, 0x93, FIL_, 0xCC, 0x82, FIL_,
+		0xE1, 0xBA, 0x91, FIL_, 0xCC, 0x81, FIL_, 0xC5,
+		0xBA, FIL_, 0xCC, 0x87, FIL_, 0xC5, 0xBC, FIL_,
+		0xCC, 0x8C, FIL_, 0xC5, 0xBE, FIL_, 0x03, 0xCC,
+		0x80, FIL_, 0xE1, 0xBF, 0xAD, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBF, 0x81, FIL_, 0xCC, 0x81, FIL_,
+		0xCE, 0x85, FIL_, 0x04, 0xCC, 0x83, FIL_, 0xE1,
+		0xBA, 0xAA, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBA,
+		0xA4, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBA, 0xA8,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBA, 0xA6, FIL_,
+		0x01, 0xCC, 0x84, FIL_, 0xC7, 0x9E, FIL_, 0x01,
+		0xCC, 0x81, FIL_, 0xC7, 0xBA, FIL_, 0x02, 0xCC,
+		0x84, FIL_, 0xC7, 0xA2, FIL_, 0xCC, 0x81, FIL_,
+		0xC7, 0xBC, FIL_, 0x01, 0xCC, 0x81, FIL_, 0xE1,
+		0xB8, 0x88, FIL_, 0x04, 0xCC, 0x83, FIL_, 0xE1,
+		0xBB, 0x84, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBB,
+		0x80, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBB, 0x82,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBA, 0xBE, FIL_,
+		0x01, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0xAE, FIL_,
+		0x04, 0xCC, 0x81, FIL_, 0xE1, 0xBB, 0x90, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBB, 0x92, FIL_, 0xCC,
+		0x89, FIL_, 0xE1, 0xBB, 0x94, FIL_, 0xCC, 0x83,
+		FIL_, 0xE1, 0xBB, 0x96, FIL_, 0x03, 0xCC, 0x84,
+		FIL_, 0xC8, 0xAC, FIL_, 0xCC, 0x88, FIL_, 0xE1,
+		0xB9, 0x8E, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xB9,
+		0x8C, FIL_, 0x01, 0xCC, 0x84, FIL_, 0xC8, 0xAA,
+		FIL_, 0x01, 0xCC, 0x81, FIL_, 0xC7, 0xBE, FIL_,
+		0x04, 0xCC, 0x80, FIL_, 0xC7, 0x9B, FIL_, 0xCC,
+		0x84, FIL_, 0xC7, 0x95, FIL_, 0xCC, 0x8C, FIL_,
+		0xC7, 0x99, FIL_, 0xCC, 0x81, FIL_, 0xC7, 0x97,
+		FIL_, 0x04, 0xCC, 0x81, FIL_, 0xE1, 0xBA, 0xA5,
+		FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBA, 0xAB, FIL_,
+		0xCC, 0x89, FIL_, 0xE1, 0xBA, 0xA9, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBA, 0xA7, FIL_, 0x01, 0xCC,
+		0x84, FIL_, 0xC7, 0x9F, FIL_, 0x01, 0xCC, 0x81,
+		FIL_, 0xC7, 0xBB, FIL_, 0x02, 0xCC, 0x81, FIL_,
+		0xC7, 0xBD, FIL_, 0xCC, 0x84, FIL_, 0xC7, 0xA3,
+		FIL_, 0x01, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0x89,
+		FIL_, 0x04, 0xCC, 0x89, FIL_, 0xE1, 0xBB, 0x83,
+		FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBB, 0x85, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBB, 0x81, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xBA, 0xBF, FIL_, 0x01, 0xCC,
+		0x81, FIL_, 0xE1, 0xB8, 0xAF, FIL_, 0x04, 0xCC,
+		0x80, FIL_, 0xE1, 0xBB, 0x93, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBB, 0x91, FIL_, 0xCC, 0x83, FIL_,
+		0xE1, 0xBB, 0x97, FIL_, 0xCC, 0x89, FIL_, 0xE1,
+		0xBB, 0x95, FIL_, 0x03, 0xCC, 0x81, FIL_, 0xE1,
+		0xB9, 0x8D, FIL_, 0xCC, 0x88, FIL_, 0xE1, 0xB9,
+		0x8F, FIL_, 0xCC, 0x84, FIL_, 0xC8, 0xAD, FIL_,
+		0x01, 0xCC, 0x84, FIL_, 0xC8, 0xAB, FIL_, 0x01,
+		0xCC, 0x81, FIL_, 0xC7, 0xBF, FIL_, 0x04, 0xCC,
+		0x8C, FIL_, 0xC7, 0x9A, FIL_, 0xCC, 0x84, FIL_,
+		0xC7, 0x96, FIL_, 0xCC, 0x80, FIL_, 0xC7, 0x9C,
+		FIL_, 0xCC, 0x81, FIL_, 0xC7, 0x98, FIL_, 0x04,
+		0xCC, 0x81, FIL_, 0xE1, 0xBA, 0xAE, FIL_, 0xCC,
+		0x83, FIL_, 0xE1, 0xBA, 0xB4, FIL_, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBA, 0xB2, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBA, 0xB0, FIL_, 0x04, 0xCC, 0x83, FIL_,
+		0xE1, 0xBA, 0xB5, FIL_, 0xCC, 0x80, FIL_, 0xE1,
+		0xBA, 0xB1, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBA,
+		0xAF, FIL_, 0xCC, 0x89, FIL_, 0xE1, 0xBA, 0xB3,
+		FIL_, 0x02, 0xCC, 0x81, FIL_, 0xE1, 0xB8, 0x96,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xB8, 0x94, FIL_,
+		0x02, 0xCC, 0x80, FIL_, 0xE1, 0xB8, 0x95, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xB8, 0x97, FIL_, 0x02,
+		0xCC, 0x80, FIL_, 0xE1, 0xB9, 0x90, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xB9, 0x92, FIL_, 0x02, 0xCC,
+		0x81, FIL_, 0xE1, 0xB9, 0x93, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xB9, 0x91, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA4, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA5, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA6, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xB9, 0xA7, FIL_, 0x01, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0xB8, FIL_, 0x01, 0xCC, 0x81,
+		FIL_, 0xE1, 0xB9, 0xB9, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xE1, 0xB9, 0xBA, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xE1, 0xB9, 0xBB, FIL_, 0x01, 0xCC, 0x87,
+		FIL_, 0xE1, 0xBA, 0x9B, FIL_, 0x05, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBB, 0x9C, FIL_, 0xCC, 0x89, FIL_,
+		0xE1, 0xBB, 0x9E, FIL_, 0xCC, 0x83, FIL_, 0xE1,
+		0xBB, 0xA0, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBB,
+		0x9A, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBB, 0xA2,
+		FIL_, 0x05, 0xCC, 0x83, FIL_, 0xE1, 0xBB, 0xA1,
+		FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBB, 0xA3, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xBB, 0x9B, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBB, 0x9D, FIL_, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBB, 0x9F, FIL_, 0x05, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBB, 0xA8, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBB, 0xAA, FIL_, 0xCC, 0x89, FIL_, 0xE1,
+		0xBB, 0xAC, FIL_, 0xCC, 0x83, FIL_, 0xE1, 0xBB,
+		0xAE, FIL_, 0xCC, 0xA3, FIL_, 0xE1, 0xBB, 0xB0,
+		FIL_, 0x05, 0xCC, 0x80, FIL_, 0xE1, 0xBB, 0xAB,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBB, 0xA9, FIL_,
+		0xCC, 0x83, FIL_, 0xE1, 0xBB, 0xAF, FIL_, 0xCC,
+		0xA3, FIL_, 0xE1, 0xBB, 0xB1, FIL_, 0xCC, 0x89,
+		FIL_, 0xE1, 0xBB, 0xAD, FIL_, 0x01, 0xCC, 0x8C,
+		FIL_, 0xC7, 0xAE, FIL_, 0x01, 0xCC, 0x84, FIL_,
+		0xC7, 0xAC, FIL_, 0x01, 0xCC, 0x84, FIL_, 0xC7,
+		0xAD, FIL_, 0x01, 0xCC, 0x84, FIL_, 0xC7, 0xA0,
+		FIL_, 0x01, 0xCC, 0x84, FIL_, 0xC7, 0xA1, FIL_,
+		0x01, 0xCC, 0x86, FIL_, 0xE1, 0xB8, 0x9C, FIL_,
+		0x01, 0xCC, 0x86, FIL_, 0xE1, 0xB8, 0x9D, FIL_,
+		0x01, 0xCC, 0x84, FIL_, 0xC8, 0xB0, FIL_, 0x01,
+		0xCC, 0x84, FIL_, 0xC8, 0xB1, FIL_, 0x01, 0xCC,
+		0x8C, FIL_, 0xC7, 0xAF, FIL_, 0x07, 0xCC, 0x93,
+		FIL_, 0xE1, 0xBC, 0x88, FIL_, 0xCC, 0x81, FIL_,
+		0xCE, 0x86, FIL_, 0xCC, 0x86, FIL_, 0xE1, 0xBE,
+		0xB8, FIL_, 0xCC, 0x84, FIL_, 0xE1, 0xBE, 0xB9,
+		FIL_, 0xCC, 0x94, FIL_, 0xE1, 0xBC, 0x89, FIL_,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xBC, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBE, 0xBA, FIL_, 0x04, 0xCC,
+		0x94, FIL_, 0xE1, 0xBC, 0x99, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBF, 0x88, FIL_, 0xCC, 0x81, FIL_,
+		0xCE, 0x88, FIL_, 0xCC, 0x93, FIL_, 0xE1, 0xBC,
+		0x98, FIL_, 0x05, 0xCD, 0x85, FIL_, 0xE1, 0xBF,
+		0x8C, FIL_, 0xCC, 0x81, FIL_, 0xCE, 0x89, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBF, 0x8A, FIL_, 0xCC,
+		0x93, FIL_, 0xE1, 0xBC, 0xA8, FIL_, 0xCC, 0x94,
+		FIL_, 0xE1, 0xBC, 0xA9, FIL_, 0x07, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBF, 0x9A, FIL_, 0xCC, 0x84, FIL_,
+		0xE1, 0xBF, 0x99, FIL_, 0xCC, 0x93, FIL_, 0xE1,
+		0xBC, 0xB8, FIL_, 0xCC, 0x94, FIL_, 0xE1, 0xBC,
+		0xB9, FIL_, 0xCC, 0x86, FIL_, 0xE1, 0xBF, 0x98,
+		FIL_, 0xCC, 0x81, FIL_, 0xCE, 0x8A, FIL_, 0xCC,
+		0x88, FIL_, 0xCE, 0xAA, FIL_, 0x04, 0xCC, 0x81,
+		FIL_, 0xCE, 0x8C, FIL_, 0xCC, 0x94, FIL_, 0xE1,
+		0xBD, 0x89, FIL_, 0xCC, 0x93, FIL_, 0xE1, 0xBD,
+		0x88, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBF, 0xB8,
+		FIL_, 0x01, 0xCC, 0x94, FIL_, 0xE1, 0xBF, 0xAC,
+		FIL_, 0x06, 0xCC, 0x94, FIL_, 0xE1, 0xBD, 0x99,
+		FIL_, 0xCC, 0x86, FIL_, 0xE1, 0xBF, 0xA8, FIL_,
+		0xCC, 0x88, FIL_, 0xCE, 0xAB, FIL_, 0xCC, 0x84,
+		FIL_, 0xE1, 0xBF, 0xA9, FIL_, 0xCC, 0x81, FIL_,
+		0xCE, 0x8E, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBF,
+		0xAA, FIL_, 0x05, 0xCC, 0x93, FIL_, 0xE1, 0xBD,
+		0xA8, FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBF, 0xBC,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBF, 0xBA, FIL_,
+		0xCC, 0x94, FIL_, 0xE1, 0xBD, 0xA9, FIL_, 0xCC,
+		0x81, FIL_, 0xCE, 0x8F, FIL_, 0x01, 0xCD, 0x85,
+		FIL_, 0xE1, 0xBE, 0xB4, FIL_, 0x01, 0xCD, 0x85,
+		FIL_, 0xE1, 0xBF, 0x84, FIL_, 0x08, 0xCD, 0x85,
+		FIL_, 0xE1, 0xBE, 0xB3, FIL_, 0xCC, 0x84, FIL_,
+		0xE1, 0xBE, 0xB1, FIL_, 0xCC, 0x86, FIL_, 0xE1,
+		0xBE, 0xB0, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD,
+		0xB0, FIL_, 0xCC, 0x81, FIL_, 0xCE, 0xAC, FIL_,
+		0xCC, 0x94, FIL_, 0xE1, 0xBC, 0x81, FIL_, 0xCC,
+		0x93, FIL_, 0xE1, 0xBC, 0x80, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBE, 0xB6, FIL_, 0x04, 0xCC, 0x93,
+		FIL_, 0xE1, 0xBC, 0x90, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBD, 0xB2, FIL_, 0xCC, 0x94, FIL_, 0xE1,
+		0xBC, 0x91, FIL_, 0xCC, 0x81, FIL_, 0xCE, 0xAD,
+		FIL_, 0x06, 0xCC, 0x94, FIL_, 0xE1, 0xBC, 0xA1,
+		FIL_, 0xCC, 0x81, FIL_, 0xCE, 0xAE, FIL_, 0xCD,
+		0x85, FIL_, 0xE1, 0xBF, 0x83, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBF, 0x86, FIL_, 0xCC, 0x93, FIL_,
+		0xE1, 0xBC, 0xA0, FIL_, 0xCC, 0x80, FIL_, 0xE1,
+		0xBD, 0xB4, FIL_, 0x08, 0xCC, 0x88, FIL_, 0xCF,
+		0x8A, FIL_, 0xCC, 0x81, FIL_, 0xCE, 0xAF, FIL_,
+		0xCC, 0x93, FIL_, 0xE1, 0xBC, 0xB0, FIL_, 0xCC,
+		0x94, FIL_, 0xE1, 0xBC, 0xB1, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBD, 0xB6, FIL_, 0xCC, 0x86, FIL_,
+		0xE1, 0xBF, 0x90, FIL_, 0xCC, 0x84, FIL_, 0xE1,
+		0xBF, 0x91, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBF,
+		0x96, FIL_, 0x04, 0xCC, 0x93, FIL_, 0xE1, 0xBD,
+		0x80, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0xB8,
+		FIL_, 0xCC, 0x94, FIL_, 0xE1, 0xBD, 0x81, FIL_,
+		0xCC, 0x81, FIL_, 0xCF, 0x8C, FIL_, 0x02, 0xCC,
+		0x93, FIL_, 0xE1, 0xBF, 0xA4, FIL_, 0xCC, 0x94,
+		FIL_, 0xE1, 0xBF, 0xA5, FIL_, 0x08, 0xCC, 0x81,
+		FIL_, 0xCF, 0x8D, FIL_, 0xCC, 0x94, FIL_, 0xE1,
+		0xBD, 0x91, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBF,
+		0xA6, FIL_, 0xCC, 0x88, FIL_, 0xCF, 0x8B, FIL_,
+		0xCC, 0x84, FIL_, 0xE1, 0xBF, 0xA1, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBD, 0xBA, FIL_, 0xCC, 0x93,
+		FIL_, 0xE1, 0xBD, 0x90, FIL_, 0xCC, 0x86, FIL_,
+		0xE1, 0xBF, 0xA0, FIL_, 0x06, 0xCC, 0x80, FIL_,
+		0xE1, 0xBD, 0xBC, FIL_, 0xCC, 0x94, FIL_, 0xE1,
+		0xBD, 0xA1, FIL_, 0xCC, 0x93, FIL_, 0xE1, 0xBD,
+		0xA0, FIL_, 0xCC, 0x81, FIL_, 0xCF, 0x8E, FIL_,
+		0xCD, 0x85, FIL_, 0xE1, 0xBF, 0xB3, FIL_, 0xCD,
+		0x82, FIL_, 0xE1, 0xBF, 0xB6, FIL_, 0x03, 0xCC,
+		0x80, FIL_, 0xE1, 0xBF, 0x92, FIL_, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBF, 0x97, FIL_, 0xCC, 0x81, FIL_,
+		0xCE, 0x90, FIL_, 0x03, 0xCD, 0x82, FIL_, 0xE1,
+		0xBF, 0xA7, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBF,
+		0xA2, FIL_, 0xCC, 0x81, FIL_, 0xCE, 0xB0, FIL_,
+		0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBF, 0xB4, FIL_,
+		0x02, 0xCC, 0x88, FIL_, 0xCF, 0x94, FIL_, 0xCC,
+		0x81, FIL_, 0xCF, 0x93, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xD0, 0x87, FIL_, 0x02, 0xCC, 0x88, FIL_,
+		0xD3, 0x92, FIL_, 0xCC, 0x86, FIL_, 0xD3, 0x90,
+		FIL_, 0x01, 0xCC, 0x81, FIL_, 0xD0, 0x83, FIL_,
+		0x03, 0xCC, 0x88, FIL_, 0xD0, 0x81, FIL_, 0xCC,
+		0x80, FIL_, 0xD0, 0x80, FIL_, 0xCC, 0x86, FIL_,
+		0xD3, 0x96, FIL_, 0x02, 0xCC, 0x86, FIL_, 0xD3,
+		0x81, FIL_, 0xCC, 0x88, FIL_, 0xD3, 0x9C, FIL_,
+		0x01, 0xCC, 0x88, FIL_, 0xD3, 0x9E, FIL_, 0x04,
+		0xCC, 0x84, FIL_, 0xD3, 0xA2, FIL_, 0xCC, 0x88,
+		FIL_, 0xD3, 0xA4, FIL_, 0xCC, 0x86, FIL_, 0xD0,
+		0x99, FIL_, 0xCC, 0x80, FIL_, 0xD0, 0x8D, FIL_,
+		0x01, 0xCC, 0x81, FIL_, 0xD0, 0x8C, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xA6, FIL_, 0x04, 0xCC,
+		0x8B, FIL_, 0xD3, 0xB2, FIL_, 0xCC, 0x88, FIL_,
+		0xD3, 0xB0, FIL_, 0xCC, 0x86, FIL_, 0xD0, 0x8E,
+		FIL_, 0xCC, 0x84, FIL_, 0xD3, 0xAE, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xB4, FIL_, 0x01, 0xCC,
+		0x88, FIL_, 0xD3, 0xB8, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xD3, 0xAC, FIL_, 0x02, 0xCC, 0x86, FIL_,
+		0xD3, 0x91, FIL_, 0xCC, 0x88, FIL_, 0xD3, 0x93,
+		FIL_, 0x01, 0xCC, 0x81, FIL_, 0xD1, 0x93, FIL_,
+		0x03, 0xCC, 0x80, FIL_, 0xD1, 0x90, FIL_, 0xCC,
+		0x86, FIL_, 0xD3, 0x97, FIL_, 0xCC, 0x88, FIL_,
+		0xD1, 0x91, FIL_, 0x02, 0xCC, 0x86, FIL_, 0xD3,
+		0x82, FIL_, 0xCC, 0x88, FIL_, 0xD3, 0x9D, FIL_,
+		0x01, 0xCC, 0x88, FIL_, 0xD3, 0x9F, FIL_, 0x04,
+		0xCC, 0x86, FIL_, 0xD0, 0xB9, FIL_, 0xCC, 0x88,
+		FIL_, 0xD3, 0xA5, FIL_, 0xCC, 0x84, FIL_, 0xD3,
+		0xA3, FIL_, 0xCC, 0x80, FIL_, 0xD1, 0x9D, FIL_,
+		0x01, 0xCC, 0x81, FIL_, 0xD1, 0x9C, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xA7, FIL_, 0x04, 0xCC,
+		0x8B, FIL_, 0xD3, 0xB3, FIL_, 0xCC, 0x84, FIL_,
+		0xD3, 0xAF, FIL_, 0xCC, 0x86, FIL_, 0xD1, 0x9E,
+		FIL_, 0xCC, 0x88, FIL_, 0xD3, 0xB1, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xB5, FIL_, 0x01, 0xCC,
+		0x88, FIL_, 0xD3, 0xB9, FIL_, 0x01, 0xCC, 0x88,
+		FIL_, 0xD3, 0xAD, FIL_, 0x01, 0xCC, 0x88, FIL_,
+		0xD1, 0x97, FIL_, 0x01, 0xCC, 0x8F, FIL_, 0xD1,
+		0xB6, FIL_, 0x01, 0xCC, 0x8F, FIL_, 0xD1, 0xB7,
+		FIL_, 0x01, 0xCC, 0x88, FIL_, 0xD3, 0x9A, FIL_,
+		0x01, 0xCC, 0x88, FIL_, 0xD3, 0x9B, FIL_, 0x01,
+		0xCC, 0x88, FIL_, 0xD3, 0xAA, FIL_, 0x01, 0xCC,
+		0x88, FIL_, 0xD3, 0xAB, FIL_, 0x03, 0xD9, 0x94,
+		FIL_, 0xD8, 0xA3, FIL_, 0xD9, 0x95, FIL_, 0xD8,
+		0xA5, FIL_, 0xD9, 0x93, FIL_, 0xD8, 0xA2, FIL_,
+		0x01, 0xD9, 0x94, FIL_, 0xD8, 0xA4, FIL_, 0x01,
+		0xD9, 0x94, FIL_, 0xD8, 0xA6, FIL_, 0x01, 0xD9,
+		0x94, FIL_, 0xDB, 0x82, FIL_, 0x01, 0xD9, 0x94,
+		FIL_, 0xDB, 0x93, FIL_, 0x01, 0xD9, 0x94, FIL_,
+		0xDB, 0x80, FIL_, 0x01, 0xE0, 0xA4, 0xBC, FIL_,
+		0xE0, 0xA4, 0xA9, FIL_, 0x01, 0xE0, 0xA4, 0xBC,
+		FIL_, 0xE0, 0xA4, 0xB1, FIL_, 0x01, 0xE0, 0xA4,
+		0xBC, FIL_, 0xE0, 0xA4, 0xB4, FIL_, 0x02, 0xE0,
+		0xA6, 0xBE, FIL_, 0xE0, 0xA7, 0x8B, FIL_, 0xE0,
+		0xA7, 0x97, FIL_, 0xE0, 0xA7, 0x8C, FIL_, 0x03,
+		0xE0, 0xAD, 0x96, FIL_, 0xE0, 0xAD, 0x88, FIL_,
+		0xE0, 0xAC, 0xBE, FIL_, 0xE0, 0xAD, 0x8B, FIL_,
+		0xE0, 0xAD, 0x97, FIL_, 0xE0, 0xAD, 0x8C, FIL_,
+		0x01, 0xE0, 0xAF, 0x97, FIL_, 0xE0, 0xAE, 0x94,
+		FIL_, 0x02, 0xE0, 0xAF, 0x97, FIL_, 0xE0, 0xAF,
+		0x8C, FIL_, 0xE0, 0xAE, 0xBE, FIL_, 0xE0, 0xAF,
+		0x8A, FIL_, 0x01, 0xE0, 0xAE, 0xBE, FIL_, 0xE0,
+		0xAF, 0x8B, FIL_, 0x01, 0xE0, 0xB1, 0x96, FIL_,
+		0xE0, 0xB1, 0x88, FIL_, 0x01, 0xE0, 0xB3, 0x95,
+		FIL_, 0xE0, 0xB3, 0x80, FIL_, 0x03, 0xE0, 0xB3,
+		0x82, FIL_, 0xE0, 0xB3, 0x8A, FIL_, 0xE0, 0xB3,
+		0x96, FIL_, 0xE0, 0xB3, 0x88, FIL_, 0xE0, 0xB3,
+		0x95, FIL_, 0xE0, 0xB3, 0x87, FIL_, 0x01, 0xE0,
+		0xB3, 0x95, FIL_, 0xE0, 0xB3, 0x8B, FIL_, 0x02,
+		0xE0, 0xB4, 0xBE, FIL_, 0xE0, 0xB5, 0x8A, FIL_,
+		0xE0, 0xB5, 0x97, FIL_, 0xE0, 0xB5, 0x8C, FIL_,
+		0x01, 0xE0, 0xB4, 0xBE, FIL_, 0xE0, 0xB5, 0x8B,
+		FIL_, 0x03, 0xE0, 0xB7, 0x9F, FIL_, 0xE0, 0xB7,
+		0x9E, FIL_, 0xE0, 0xB7, 0x8A, FIL_, 0xE0, 0xB7,
+		0x9A, FIL_, 0xE0, 0xB7, 0x8F, FIL_, 0xE0, 0xB7,
+		0x9C, FIL_, 0x01, 0xE0, 0xB7, 0x8A, FIL_, 0xE0,
+		0xB7, 0x9D, FIL_, 0x01, 0xE1, 0x80, 0xAE, FIL_,
+		0xE1, 0x80, 0xA6, FIL_, 0x01, 0xE1, 0xAC, 0xB5,
+		FIL_, 0xE1, 0xAC, 0x86, FIL_, 0x01, 0xE1, 0xAC,
+		0xB5, FIL_, 0xE1, 0xAC, 0x88, FIL_, 0x01, 0xE1,
+		0xAC, 0xB5, FIL_, 0xE1, 0xAC, 0x8A, FIL_, 0x01,
+		0xE1, 0xAC, 0xB5, FIL_, 0xE1, 0xAC, 0x8C, FIL_,
+		0x01, 0xE1, 0xAC, 0xB5, FIL_, 0xE1, 0xAC, 0x8E,
+		FIL_, 0x01, 0xE1, 0xAC, 0xB5, FIL_, 0xE1, 0xAC,
+		0x92, FIL_, 0x01, 0xE1, 0xAC, 0xB5, FIL_, 0xE1,
+		0xAC, 0xBB, FIL_, 0x01, 0xE1, 0xAC, 0xB5, FIL_,
+		0xE1, 0xAC, 0xBD, FIL_, 0x01, 0xE1, 0xAC, 0xB5,
+		FIL_, 0xE1, 0xAD, 0x80, FIL_, 0x01, 0xE1, 0xAC,
+		0xB5, FIL_, 0xE1, 0xAD, 0x81, FIL_, 0x01, 0xE1,
+		0xAC, 0xB5, FIL_, 0xE1, 0xAD, 0x83, FIL_, 0x01,
+		0xCC, 0x84, FIL_, 0xE1, 0xB8, 0xB8, FIL_, 0x01,
+		0xCC, 0x84, FIL_, 0xE1, 0xB8, 0xB9, FIL_, 0x01,
+		0xCC, 0x84, FIL_, 0xE1, 0xB9, 0x9C, FIL_, 0x01,
+		0xCC, 0x84, FIL_, 0xE1, 0xB9, 0x9D, FIL_, 0x01,
+		0xCC, 0x87, FIL_, 0xE1, 0xB9, 0xA8, FIL_, 0x01,
+		0xCC, 0x87, FIL_, 0xE1, 0xB9, 0xA9, FIL_, 0x02,
+		0xCC, 0x86, FIL_, 0xE1, 0xBA, 0xB6, FIL_, 0xCC,
+		0x82, FIL_, 0xE1, 0xBA, 0xAC, FIL_, 0x02, 0xCC,
+		0x82, FIL_, 0xE1, 0xBA, 0xAD, FIL_, 0xCC, 0x86,
+		FIL_, 0xE1, 0xBA, 0xB7, FIL_, 0x01, 0xCC, 0x82,
+		FIL_, 0xE1, 0xBB, 0x86, FIL_, 0x01, 0xCC, 0x82,
+		FIL_, 0xE1, 0xBB, 0x87, FIL_, 0x01, 0xCC, 0x82,
+		FIL_, 0xE1, 0xBB, 0x98, FIL_, 0x01, 0xCC, 0x82,
+		FIL_, 0xE1, 0xBB, 0x99, FIL_, 0x04, 0xCD, 0x85,
+		FIL_, 0xE1, 0xBE, 0x80, FIL_, 0xCD, 0x82, FIL_,
+		0xE1, 0xBC, 0x86, FIL_, 0xCC, 0x80, FIL_, 0xE1,
+		0xBC, 0x82, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC,
+		0x84, FIL_, 0x04, 0xCD, 0x82, FIL_, 0xE1, 0xBC,
+		0x87, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0x85,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0x83, FIL_,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x81, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x82, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x83, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x84, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x85, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x86, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x87, FIL_, 0x04,
+		0xCC, 0x81, FIL_, 0xE1, 0xBC, 0x8C, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBC, 0x8A, FIL_, 0xCD, 0x85,
+		FIL_, 0xE1, 0xBE, 0x88, FIL_, 0xCD, 0x82, FIL_,
+		0xE1, 0xBC, 0x8E, FIL_, 0x04, 0xCC, 0x80, FIL_,
+		0xE1, 0xBC, 0x8B, FIL_, 0xCD, 0x82, FIL_, 0xE1,
+		0xBC, 0x8F, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC,
+		0x8D, FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x89,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x8A,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x8B,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x8C,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x8D,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x8E,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x8F,
+		FIL_, 0x02, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0x92,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0x94, FIL_,
+		0x02, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0x93, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xBC, 0x95, FIL_, 0x02,
+		0xCC, 0x80, FIL_, 0xE1, 0xBC, 0x9A, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xBC, 0x9C, FIL_, 0x02, 0xCC,
+		0x80, FIL_, 0xE1, 0xBC, 0x9B, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBC, 0x9D, FIL_, 0x04, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBC, 0xA2, FIL_, 0xCC, 0x81, FIL_,
+		0xE1, 0xBC, 0xA4, FIL_, 0xCD, 0x82, FIL_, 0xE1,
+		0xBC, 0xA6, FIL_, 0xCD, 0x85, FIL_, 0xE1, 0xBE,
+		0x90, FIL_, 0x04, 0xCD, 0x85, FIL_, 0xE1, 0xBE,
+		0x91, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0xA5,
+		FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBC, 0xA7, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xA3, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x92, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x93, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x94, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x95, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x96, FIL_, 0x01,
+		0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x97, FIL_, 0x04,
+		0xCC, 0x81, FIL_, 0xE1, 0xBC, 0xAC, FIL_, 0xCC,
+		0x80, FIL_, 0xE1, 0xBC, 0xAA, FIL_, 0xCD, 0x85,
+		FIL_, 0xE1, 0xBE, 0x98, FIL_, 0xCD, 0x82, FIL_,
+		0xE1, 0xBC, 0xAE, FIL_, 0x04, 0xCD, 0x82, FIL_,
+		0xE1, 0xBC, 0xAF, FIL_, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0x99, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC,
+		0xAD, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xAB,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x9A,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x9B,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x9C,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x9D,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x9E,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0x9F,
+		FIL_, 0x03, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0xB4,
+		FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xB2, FIL_,
+		0xCD, 0x82, FIL_, 0xE1, 0xBC, 0xB6, FIL_, 0x03,
+		0xCC, 0x80, FIL_, 0xE1, 0xBC, 0xB3, FIL_, 0xCD,
+		0x82, FIL_, 0xE1, 0xBC, 0xB7, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBC, 0xB5, FIL_, 0x03, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBC, 0xBC, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBC, 0xBA, FIL_, 0xCD, 0x82, FIL_, 0xE1,
+		0xBC, 0xBE, FIL_, 0x03, 0xCC, 0x80, FIL_, 0xE1,
+		0xBC, 0xBB, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBC,
+		0xBF, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBC, 0xBD,
+		FIL_, 0x02, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0x82,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBD, 0x84, FIL_,
+		0x02, 0xCC, 0x81, FIL_, 0xE1, 0xBD, 0x85, FIL_,
+		0xCC, 0x80, FIL_, 0xE1, 0xBD, 0x83, FIL_, 0x02,
+		0xCC, 0x80, FIL_, 0xE1, 0xBD, 0x8A, FIL_, 0xCC,
+		0x81, FIL_, 0xE1, 0xBD, 0x8C, FIL_, 0x02, 0xCC,
+		0x80, FIL_, 0xE1, 0xBD, 0x8B, FIL_, 0xCC, 0x81,
+		FIL_, 0xE1, 0xBD, 0x8D, FIL_, 0x03, 0xCD, 0x82,
+		FIL_, 0xE1, 0xBD, 0x96, FIL_, 0xCC, 0x80, FIL_,
+		0xE1, 0xBD, 0x92, FIL_, 0xCC, 0x81, FIL_, 0xE1,
+		0xBD, 0x94, FIL_, 0x03, 0xCC, 0x80, FIL_, 0xE1,
+		0xBD, 0x93, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBD,
+		0x97, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBD, 0x95,
+		FIL_, 0x03, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0x9B,
+		FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBD, 0x9F, FIL_,
+		0xCC, 0x81, FIL_, 0xE1, 0xBD, 0x9D, FIL_, 0x04,
+		0xCD, 0x82, FIL_, 0xE1, 0xBD, 0xA6, FIL_, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xA0, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBD, 0xA2, FIL_, 0xCC, 0x81, FIL_,
+		0xE1, 0xBD, 0xA4, FIL_, 0x04, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0xA1, FIL_, 0xCD, 0x82, FIL_, 0xE1,
+		0xBD, 0xA7, FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBD,
+		0xA5, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0xA3,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xA2,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xA3,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xA4,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xA5,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xA6,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBE, 0xA7,
+		FIL_, 0x04, 0xCC, 0x80, FIL_, 0xE1, 0xBD, 0xAA,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBD, 0xAC, FIL_,
+		0xCD, 0x82, FIL_, 0xE1, 0xBD, 0xAE, FIL_, 0xCD,
+		0x85, FIL_, 0xE1, 0xBE, 0xA8, FIL_, 0x04, 0xCD,
+		0x82, FIL_, 0xE1, 0xBD, 0xAF, FIL_, 0xCC, 0x80,
+		FIL_, 0xE1, 0xBD, 0xAB, FIL_, 0xCD, 0x85, FIL_,
+		0xE1, 0xBE, 0xA9, FIL_, 0xCC, 0x81, FIL_, 0xE1,
+		0xBD, 0xAD, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xAA, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xAB, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xAC, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xAD, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xAE, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xAF, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xB2, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBF, 0x82, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBF, 0xB2, FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1,
+		0xBE, 0xB7, FIL_, 0x03, 0xCC, 0x81, FIL_, 0xE1,
+		0xBF, 0x8E, FIL_, 0xCC, 0x80, FIL_, 0xE1, 0xBF,
+		0x8D, FIL_, 0xCD, 0x82, FIL_, 0xE1, 0xBF, 0x8F,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBF, 0x87,
+		FIL_, 0x01, 0xCD, 0x85, FIL_, 0xE1, 0xBF, 0xB7,
+		FIL_, 0x03, 0xCC, 0x80, FIL_, 0xE1, 0xBF, 0x9D,
+		FIL_, 0xCC, 0x81, FIL_, 0xE1, 0xBF, 0x9E, FIL_,
+		0xCD, 0x82, FIL_, 0xE1, 0xBF, 0x9F, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x86, 0x9A, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x86, 0x9B, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x86, 0xAE, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x87, 0x8D, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x87, 0x8F, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x87, 0x8E, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x88, 0x84, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x88, 0x89, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x88, 0x8C, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x88, 0xA4, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x88, 0xA6, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0x81, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0x84, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0x87, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0x89, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xAD, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xA2, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xB0, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xB1, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xB4, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xB5, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xB8, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x89, 0xB9, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0x80, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0x81, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8B, 0xA0, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8B, 0xA1, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0x84, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0x85, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0x88, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0x89, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8B, 0xA2, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8B, 0xA3, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0xAC, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0xAD, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0xAE, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8A, 0xAF, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8B, 0xAA, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8B, 0xAB, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8B, 0xAC, FIL_, 0x01,
+		0xCC, 0xB8, FIL_, 0xE2, 0x8B, 0xAD, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82, 0x94, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0x8C,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81,
+		0x8E, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x81, 0x90, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x81, 0x92, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x81, 0x94, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x81, 0x96, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x81, 0x98, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0x9A, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0x9C,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81,
+		0x9E, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x81, 0xA0, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x81, 0xA2, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x81, 0xA5, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x81, 0xA7, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x81, 0xA9, FIL_, 0x02,
+		0xE3, 0x82, 0x9A, FIL_, 0xE3, 0x81, 0xB1, FIL_,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0xB0, FIL_,
+		0x02, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81, 0xB3,
+		FIL_, 0xE3, 0x82, 0x9A, FIL_, 0xE3, 0x81, 0xB4,
+		FIL_, 0x02, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x81,
+		0xB6, FIL_, 0xE3, 0x82, 0x9A, FIL_, 0xE3, 0x81,
+		0xB7, FIL_, 0x02, 0xE3, 0x82, 0x9A, FIL_, 0xE3,
+		0x81, 0xBA, FIL_, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x81, 0xB9, FIL_, 0x02, 0xE3, 0x82, 0x9A, FIL_,
+		0xE3, 0x81, 0xBD, FIL_, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x81, 0xBC, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x82, 0x9E, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x83, 0xB4, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x82, 0xAC, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82, 0xAE, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82, 0xB0,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82,
+		0xB2, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x82, 0xB4, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x82, 0xB6, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x82, 0xB8, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x82, 0xBA, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x82, 0xBC, FIL_, 0x01,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x82, 0xBE, FIL_,
+		0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83, 0x80,
+		FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83,
+		0x82, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x83, 0x85, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x83, 0x87, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x83, 0x89, FIL_, 0x02, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x83, 0x90, FIL_, 0xE3, 0x82,
+		0x9A, FIL_, 0xE3, 0x83, 0x91, FIL_, 0x02, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x83, 0x93, FIL_, 0xE3,
+		0x82, 0x9A, FIL_, 0xE3, 0x83, 0x94, FIL_, 0x02,
+		0xE3, 0x82, 0x9A, FIL_, 0xE3, 0x83, 0x97, FIL_,
+		0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83, 0x96, FIL_,
+		0x02, 0xE3, 0x82, 0x9A, FIL_, 0xE3, 0x83, 0x9A,
+		FIL_, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83, 0x99,
+		FIL_, 0x02, 0xE3, 0x82, 0x99, FIL_, 0xE3, 0x83,
+		0x9C, FIL_, 0xE3, 0x82, 0x9A, FIL_, 0xE3, 0x83,
+		0x9D, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_, 0xE3,
+		0x83, 0xB7, FIL_, 0x01, 0xE3, 0x82, 0x99, FIL_,
+		0xE3, 0x83, 0xB8, FIL_, 0x01, 0xE3, 0x82, 0x99,
+		FIL_, 0xE3, 0x83, 0xB9, FIL_, 0x01, 0xE3, 0x82,
+		0x99, FIL_, 0xE3, 0x83, 0xBA, FIL_, 0x01, 0xE3,
+		0x82, 0x99, FIL_, 0xE3, 0x83, 0xBE, FIL_,
+	},
+};
+
+static const uchar_t u8_decomp_b2_tbl[2][2][256] = {
+	{
+		{
+			0,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			1,  2,  3,  4,  N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, 5,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, 6,  N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, 7,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+
+	},
+	{
+		{
+			0,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			1,  2,  3,  4,  N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, 5,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, 6,  N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, 7,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+
+	},
+
+};
+
+static const u8_displacement_t u8_decomp_b3_tbl[2][8][256] = {
+	{
+		{	/* Third byte table 0. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0, 0 },
+			{ 1, 35 }, { 2, 247 }, { 3, 474 },
+			{ 4, 693 }, { 5, 709 }, { 6, 951 },
+			{ N_, 0 }, { 7, 1139 }, { 8, 1152 },
+			{ N_, 0 }, { 9, 1177 }, { 10, 1199 },
+			{ 11, 1295 }, { 12, 1360 }, { 13, 1405 },
+			{ N_, 0 }, { 14, 1450 }, { N_, 0 },
+			{ N_, 0 }, { 15, 1620 }, { N_, 0 },
+			{ 16, 1624 }, { 17, 1649 }, { N_, 0 },
+			{ 18, 1665 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 1. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 19, 1680 },
+			{ 20, 1701 }, { N_, 0 }, { 21, 1757 },
+			{ 22, 1792 }, { 23, 1806 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 24, 1834 },
+			{ 25, 1869 }, { 26, 1876 }, { N_, 0 },
+			{ 27, 1897 }, { N_, 0 }, { 28, 1904 },
+			{ N_, 0 }, { 29, 1942 }, { N_, 0 },
+			{ 30, 1963 }, { 31, 1994 }, { N_, 0 },
+			{ 32, 2000 }, { 33, 2006 }, { 34, 2018 },
+			{ 35, 2021 }, { 36, 2109 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 2. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 37, 2158 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 0x8000, 2165 }, { 0x8001, 2445 },
+			{ 0x8002, 2741 }, { 0x8003, 3029 }, { 0x8004, 3337 },
+			{ 0x8005, 3725 }, { 0x8006, 4053 }, { 0x8007, 4536 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 3. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 38, 4895 },
+			{ 39, 4964 }, { 40, 4999 }, { N_, 0 },
+			{ 41, 5018 }, { 42, 5098 }, { 43, 5230 },
+			{ 44, 5248 }, { 45, 5266 }, { 46, 5326 },
+			{ 47, 5410 }, { 48, 5470 }, { 49, 5518 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 50, 5526 }, { 51, 5596 },
+			{ 52, 5767 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 53, 5810 }, { 54, 5822 }, { N_, 0 },
+			{ 55, 5830 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 56, 5836 }, { 57, 5839 }, { 58, 5842 },
+			{ 59, 6034 }, { 60, 6226 }, { 61, 6418 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 4. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 62, 6484 },
+			{ 63, 6497 }, { 64, 6672 }, { 65, 6770 },
+			{ 66, 6923 }, { 67, 6968 }, { 68, 7160 },
+			{ N_, 0 }, { 0x8008, 7247 }, { 69, 7597 },
+			{ 70, 7773 }, { 71, 7950 }, { 0x8009, 8142 },
+			{ 0x800A, 8919 }, { 72, 9351 }, { 73, 9522 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 5. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0x800B, 9743 },
+			{ 0x800C, 9999 }, { 0x800D, 10255 }, { 0x800E, 10511 },
+			{ 74, 10767 }, { 75, 10967 }, { N_, 0 },
+			{ N_, 0 }, { 76, 11139 }, { 77, 11303 },
+			{ 78, 11468 }, { 79, 11576 }, { 0x800F, 11740 },
+			{ 0x8010, 12006 }, { 0x8011, 12280 }, { 0x8012, 12546 },
+			{ 80, 12812 }, { 0x8013, 13060 }, { 0x8014, 13348 },
+			{ 81, 13720 }, { 82, 13898 }, { 83, 13933 },
+			{ 84, 14045 }, { 85, 14197 }, { 86, 14347 },
+			{ 87, 14410 }, { 88, 14540 }, { 89, 14729 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 6. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 90, 14829 }, { 91, 14912 },
+			{ 92, 14969 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 93, 14982 }, { 94, 15046 }, { 95, 15109 },
+			{ 96, 15163 }, { 97, 15225 }, { 98, 15282 },
+			{ 99, 15341 }, { 100, 15405 }, { 101, 15469 },
+			{ 102, 15533 }, { 103, 15597 }, { 104, 15681 },
+			{ 105, 15812 }, { 106, 15942 }, { 107, 16072 },
+			{ 108, 16202 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 7. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 0x8015, 16273 }, { 0x8016, 16536 },
+			{ 0x8017, 16799 }, { 0x8018, 17064 }, { 0x8019, 17329 },
+			{ 0x801A, 17601 }, { 0x801B, 17878 }, { 0x801C, 18147 },
+			{ 109, 18419 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+	},
+	{
+		{	/* Third byte table 0. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0, 0 },
+			{ 1, 35 }, { 2, 247 }, { 3, 474 },
+			{ 4, 693 }, { 5, 709 }, { 6, 951 },
+			{ N_, 0 }, { 7, 1139 }, { 8, 1152 },
+			{ N_, 0 }, { 9, 1177 }, { 10, 1199 },
+			{ 11, 1295 }, { 12, 1362 }, { 13, 1407 },
+			{ N_, 0 }, { 14, 1452 }, { N_, 0 },
+			{ N_, 0 }, { 15, 1622 }, { N_, 0 },
+			{ 16, 1626 }, { 17, 1651 }, { N_, 0 },
+			{ 18, 1667 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 1. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 19, 1682 },
+			{ 20, 1703 }, { N_, 0 }, { 21, 1759 },
+			{ 22, 1794 }, { 23, 1808 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 24, 1836 },
+			{ 25, 1871 }, { 26, 1878 }, { N_, 0 },
+			{ 27, 1899 }, { N_, 0 }, { 28, 1906 },
+			{ N_, 0 }, { 29, 1944 }, { N_, 0 },
+			{ 30, 1965 }, { 31, 1996 }, { N_, 0 },
+			{ 32, 2002 }, { 33, 2008 }, { 34, 2020 },
+			{ 35, 2023 }, { 36, 2111 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 2. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 37, 2160 },
+			{ N_, 0 }, { N_, 0 }, { 38, 2167 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 39, 2170 }, { 40, 2226 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 41, 2247 }, { 42, 2268 }, { 43, 2340 },
+			{ N_, 0 }, { 0x8000, 2414 }, { 0x8001, 2694 },
+			{ 0x8002, 2990 }, { 0x8003, 3278 }, { 0x8004, 3586 },
+			{ 0x8005, 3974 }, { 0x8006, 4302 }, { 0x8007, 4785 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 3. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 44, 5144 },
+			{ 45, 5213 }, { 46, 5248 }, { N_, 0 },
+			{ 47, 5273 }, { 48, 5358 }, { 49, 5490 },
+			{ 50, 5508 }, { 51, 5526 }, { 52, 5586 },
+			{ 53, 5670 }, { 54, 5730 }, { 55, 5778 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 56, 5786 }, { 57, 5856 },
+			{ 58, 6027 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 59, 6070 }, { 60, 6082 }, { N_, 0 },
+			{ 61, 6090 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 62, 6096 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 63, 6099 }, { 64, 6102 }, { 65, 6105 },
+			{ 66, 6297 }, { 67, 6489 }, { 68, 6681 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 4. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 69, 6747 },
+			{ 70, 6760 }, { 71, 6935 }, { 72, 7033 },
+			{ 73, 7186 }, { 74, 7231 }, { 75, 7423 },
+			{ N_, 0 }, { 0x8008, 7510 }, { 76, 7891 },
+			{ 77, 8103 }, { 78, 8280 }, { 0x8009, 8482 },
+			{ 0x800A, 9259 }, { 79, 9701 }, { 80, 9872 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 5. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0x800B, 10106 },
+			{ 0x800C, 10362 }, { 0x800D, 10618 }, { 0x800E, 10874 },
+			{ 81, 11130 }, { 82, 11330 }, { 0x800F, 11566 },
+			{ 83, 11822 }, { 84, 11932 }, { 85, 12096 },
+			{ 86, 12261 }, { 87, 12369 }, { 0x8010, 12533 },
+			{ 0x8011, 12799 }, { 0x8012, 13073 }, { 0x8013, 13339 },
+			{ 88, 13605 }, { 0x8014, 13853 }, { 0x8015, 14141 },
+			{ 89, 14513 }, { 90, 14691 }, { 91, 14746 },
+			{ 92, 14860 }, { 93, 15012 }, { 94, 15162 },
+			{ 95, 15225 }, { 96, 15355 }, { 97, 15544 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 6. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 98, 15644 }, { 99, 15727 },
+			{ 100, 15784 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 101, 15797 }, { 102, 15861 }, { 103, 15924 },
+			{ 104, 15978 }, { 105, 16041 }, { 106, 16098 },
+			{ 107, 16157 }, { 108, 16221 }, { 109, 16285 },
+			{ 110, 16349 }, { 111, 16413 }, { 112, 16501 },
+			{ 113, 16632 }, { 114, 16762 }, { 115, 16892 },
+			{ 116, 17022 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+		{	/* Third byte table 7. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 0x8016, 17097 }, { 0x8017, 17360 },
+			{ 0x8018, 17623 }, { 0x8019, 17888 }, { 0x801A, 18153 },
+			{ 0x801B, 18425 }, { 0x801C, 18702 }, { 0x801D, 18971 },
+			{ 117, 19243 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 },
+		},
+	},
+};
+
+static const uchar_t u8_decomp_b4_tbl[2][118][257] = {
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   1,   1,   1,   1,   1,   1,
+			1,   4,   4,   5,   5,   5,   5,   5,
+			8,   8,   8,   9,   10,  13,  15,  15,
+			15,  18,  19,  20,  20,  25,  30,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  24,
+			28,  32,  36,  40,  44,  48,  52,  56,
+			60,  60,  64,  68,  72,  76,  80,  84,
+			84,  84,  88,  92,  96,  100, 104, 104,
+			104, 108, 112, 116, 120, 124, 128, 128,
+			132, 136, 140, 144, 148, 152, 156, 160,
+			164, 164, 168, 172, 176, 180, 184, 188,
+			188, 188, 192, 196, 200, 204, 208, 208,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  64,  64,  68,  72,  76,  80,  84,
+			88,  92,  96,  100, 104, 108, 112, 116,
+			120, 124, 128, 132, 136, 140, 144, 144,
+			144, 148, 152, 156, 160, 164, 168, 172,
+			176, 180, 180, 182, 184, 188, 192, 196,
+			200, 200, 204, 208, 212, 216, 220, 224,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   3,   7,   11,  15,  19,
+			23,  27,  30,  30,  30,  34,  38,  42,
+			46,  50,  54,  54,  54,  58,  62,  66,
+			70,  74,  78,  82,  86,  90,  94,  98,
+			102, 106, 110, 114, 118, 122, 126, 126,
+			126, 130, 134, 138, 142, 146, 150, 154,
+			158, 162, 166, 170, 174, 178, 182, 186,
+			190, 194, 198, 202, 206, 210, 214, 218,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			12,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   4,   8,   12,
+			14,  16,  18,  20,  22,  24,  28,  32,
+			36,  40,  44,  48,  52,  56,  62,  68,
+			74,  80,  86,  92,  98,  104, 104, 110,
+			116, 122, 128, 133, 138, 138, 138, 142,
+			146, 150, 154, 158, 162, 168, 174, 179,
+			184, 188, 190, 192, 194, 198, 202, 202,
+			202, 206, 210, 216, 222, 227, 232, 237,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  100, 104, 108, 112, 112, 112, 116,
+			120, 120, 120, 120, 120, 120, 120, 124,
+			128, 132, 136, 142, 148, 154, 160, 164,
+			168, 174, 180, 184, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   3,   4,   5,   7,   9,   11,
+			12,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  18,
+			18,  20,  21,  22,  23,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   6,   9,   14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  17,  17,  17,
+			17,  17,  17,  20,  20,  20,  20,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   3,   14,  19,
+			22,  27,  32,  37,  37,  42,  42,  47,
+			52,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  64,  69,  74,  79,  84,
+			89,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   5,   10,  15,  20,  25,
+			25,  27,  29,  31,  41,  51,  53,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  57,  59,  61,  61,  63,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,  65,  65,  65,  65,  65,  65,  65,
+			65,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   10,  10,  15,  15,  15,  15,
+			20,  20,  20,  20,  20,  25,  30,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   10,  10,  15,  15,  15,  15,
+			20,  20,  20,  20,  20,  25,  30,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  40,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   5,   10,  10,  10,  10,  10,
+			10,  10,  10,  10,  10,  10,  10,  10,
+			10,  15,  20,  25,  30,  30,  30,  35,
+			40,  40,  40,  45,  50,  55,  60,  65,
+			70,  70,  70,  75,  80,  85,  90,  95,
+			100, 100, 100, 105, 110, 115, 120, 125,
+			130, 135, 140, 145, 150, 155, 160, 160,
+			160, 165, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   5,   10,  15,  20,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   4,   8,
+			12,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   5,   10,  10,  10,  10,  10,
+			10,  10,  10,  10,  10,  10,  10,  10,
+			10,  10,  10,  10,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   7,   7,   7,   7,   7,   7,
+			7,   7,   14,  14,  14,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   14,  21,  28,  35,  42,  49,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  21,  28,  28,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   7,   7,   14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   7,   14,  21,  21,  21,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   7,   14,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  28,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   14,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   7,   7,   7,   7,   7,
+			14,  21,  21,  28,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   14,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   7,   14,  24,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   6,   12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   14,  14,
+			14,  14,  14,  21,  21,  21,  21,  21,
+			28,  28,  28,  28,  28,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  49,  49,  56,  63,
+			72,  79,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,
+		},
+		{	/* Fourth byte table 36. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  21,  21,
+			21,  21,  21,  28,  28,  28,  28,  28,
+			35,  35,  35,  35,  35,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,
+		},
+		{	/* Fourth byte table 37. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,
+		},
+		{	/* Fourth byte table 38. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   6,   12,  13,  14,  15,  16,  17,
+			18,  19,  20,  21,  21,  21,  21,  21,
+			21,  21,  24,  24,  24,  24,  24,  24,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  28,  30,  33,
+			33,  33,  33,  33,  33,  33,  33,  33,
+			34,  34,  34,  34,  40,  49,  49,  55,
+			64,  64,  64,  64,  64,  66,  66,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,
+		},
+		{	/* Fourth byte table 39. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			2,   4,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  20,  21,  21,  21,  22,  23,  24,
+			25,  26,  27,  28,  31,  32,  33,  34,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 40. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  14,  15,  16,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  17,  17,  17,  17,  17,  17,  17,
+			17,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,
+		},
+		{	/* Fourth byte table 41. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   7,   10,  10,  13,  16,
+			18,  18,  21,  22,  23,  24,  25,  26,
+			28,  29,  30,  31,  32,  32,  33,  35,
+			35,  35,  36,  37,  38,  39,  40,  40,
+			40,  42,  45,  47,  47,  48,  48,  51,
+			51,  52,  52,  54,  58,  59,  60,  60,
+			61,  62,  63,  63,  64,  65,  67,  69,
+			71,  73,  74,  74,  74,  74,  76,  78,
+			80,  80,  80,  80,  80,  80,  80,  80,
+			80,  80,  80,  80,  80,  80,  80,  80,
+			80,  80,  80,  80,  80,  80,  80,  80,
+			80,  80,  80,  80,  80,  80,  80,  80,
+			80,  80,  80,  80,  80,  80,  80,  80,
+			80,  80,  80,  80,  80,  80,  80,  80,
+			80,  80,  80,  80,  80,  80,  80,  80,
+			80,  80,  80,  80,  80,  80,  80,  80,
+			80,
+		},
+		{	/* Fourth byte table 42. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   3,   3,   3,   4,   5,
+			6,   7,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   13,  18,  23,  28,
+			33,  38,  43,  48,  53,  58,  63,  68,
+			72,  73,  75,  78,  80,  81,  83,  86,
+			90,  92,  93,  95,  98,  99,  100, 101,
+			102, 103, 105, 108, 110, 111, 113, 116,
+			120, 122, 123, 125, 128, 129, 130, 131,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132,
+		},
+		{	/* Fourth byte table 43. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   6,   12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,
+		},
+		{	/* Fourth byte table 44. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   6,   12,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,
+		},
+		{	/* Fourth byte table 45. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   6,   6,   6,
+			6,   6,   12,  12,  12,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  24,  24,  30,
+			30,  30,  30,  30,  30,  36,  45,  45,
+			51,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,
+		},
+		{	/* Fourth byte table 46. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   6,   6,   6,   12,  12,  12,
+			18,  18,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  28,  28,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  40,  44,
+			48,  54,  60,  60,  60,  66,  72,  72,
+			72,  78,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,
+		},
+		{	/* Fourth byte table 47. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   6,   12,  12,  12,  18,  24,  24,
+			24,  30,  36,  36,  36,  36,  36,  36,
+			36,  36,  36,  36,  36,  36,  36,  36,
+			36,  36,  36,  36,  36,  36,  36,  36,
+			36,  36,  36,  36,  36,  36,  36,  36,
+			36,  36,  36,  36,  36,  42,  48,  54,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,
+		},
+		{	/* Fourth byte table 48. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   6,   12,  18,  24,  24,  24,  24,
+			24,  24,  24,  30,  36,  42,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 49. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   4,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,
+		},
+		{	/* Fourth byte table 50. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   11,  13,  15,  17,  19,  21,
+			23,  25,  27,  29,  31,  34,  37,  40,
+			43,  46,  49,  52,  55,  58,  62,  66,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,
+		},
+		{	/* Fourth byte table 51. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  53,  56,  59,  62,  65,  68,
+			71,  74,  77,  80,  83,  86,  89,  92,
+			95,  98,  101, 104, 107, 110, 113, 116,
+			119, 122, 125, 128, 131, 134, 137, 140,
+			143, 146, 149, 152, 155, 158, 161, 162,
+			163, 164, 165, 166, 167, 168, 169, 170,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171,
+		},
+		{	/* Fourth byte table 52. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,
+		},
+		{	/* Fourth byte table 53. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,
+		},
+		{	/* Fourth byte table 54. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   3,   5,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,
+		},
+		{	/* Fourth byte table 55. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,
+		},
+		{	/* Fourth byte table 56. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 57. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 58. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 59. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 60. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 61. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,
+		},
+		{	/* Fourth byte table 62. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   4,
+			4,   7,   10,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,
+		},
+		{	/* Fourth byte table 63. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   7,   7,   14,
+			14,  21,  21,  28,  28,  35,  35,  42,
+			42,  49,  49,  56,  56,  63,  63,  70,
+			70,  77,  77,  84,  84,  84,  91,  91,
+			98,  98,  105, 105, 105, 105, 105, 105,
+			105, 112, 119, 119, 126, 133, 133, 140,
+			147, 147, 154, 161, 161, 168, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175,
+		},
+		{	/* Fourth byte table 64. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   7,   7,   7,
+			7,   7,   7,   7,   11,  15,  15,  22,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  35,  35,  42,
+			42,  49,  49,  56,  56,  63,  63,  70,
+			70,  77,  77,  84,  84,  91,  91,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,
+		},
+		{	/* Fourth byte table 65. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   14,  14,  14,  21,  21,
+			28,  28,  35,  35,  35,  35,  35,  35,
+			35,  42,  49,  49,  56,  63,  63,  70,
+			77,  77,  84,  91,  91,  98,  105, 105,
+			105, 105, 105, 105, 105, 105, 105, 105,
+			105, 105, 105, 105, 105, 105, 105, 105,
+			105, 105, 105, 105, 105, 112, 112, 112,
+			119, 126, 133, 140, 140, 140, 140, 147,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153,
+		},
+		{	/* Fourth byte table 66. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   6,   9,   12,  15,  18,
+			21,  24,  27,  30,  33,  36,  39,  42,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,
+		},
+		{	/* Fourth byte table 67. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 68. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			45,  45,  45,  48,  51,  54,  57,  60,
+			63,  66,  69,  72,  75,  78,  81,  84,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,
+		},
+		{	/* Fourth byte table 69. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   10,  15,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  22,  24,  26,  28,  30,  32,
+			34,  36,  38,  40,  42,  44,  46,  48,
+			50,  53,  56,  59,  62,  65,  68,  71,
+			74,  77,  80,  83,  86,  89,  92,  98,
+			104, 110, 116, 122, 128, 134, 140, 146,
+			152, 158, 164, 170, 176, 176, 176, 176,
+			176, 176, 176, 176, 176, 176, 176, 176,
+			176, 176, 176, 176, 176, 176, 176, 176,
+			176, 176, 176, 176, 176, 176, 176, 176,
+			176, 176, 176, 176, 176, 176, 176, 176,
+			176, 176, 176, 176, 176, 176, 176, 176,
+			176, 176, 176, 176, 176, 176, 176, 176,
+			176, 176, 176, 176, 176, 176, 176, 176,
+			176, 176, 176, 176, 176, 176, 176, 176,
+			176,
+		},
+		{	/* Fourth byte table 70. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 149, 151, 153, 155, 157, 159,
+			161, 163, 165, 167, 169, 171, 173, 175,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177,
+		},
+		{	/* Fourth byte table 71. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  41,  46,  51,  51,  51,  51,
+			51,  54,  57,  60,  63,  66,  69,  72,
+			75,  78,  81,  84,  87,  90,  93,  96,
+			99,  102, 105, 108, 111, 114, 117, 120,
+			123, 126, 129, 132, 135, 138, 141, 144,
+			147, 150, 153, 156, 159, 162, 165, 168,
+			171, 174, 177, 180, 183, 186, 189, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 72. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   7,   9,   11,  13,  15,
+			17,  20,  24,  26,  28,  31,  34,  36,
+			38,  40,  43,  46,  49,  52,  55,  57,
+			59,  61,  63,  65,  68,  70,  72,  74,
+			77,  80,  82,  85,  88,  91,  93,  96,
+			101, 107, 109, 112, 115, 118, 121, 128,
+			136, 138, 140, 143, 145, 147, 149, 152,
+			154, 156, 158, 160, 162, 165, 167, 169,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171,
+		},
+		{	/* Fourth byte table 73. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   10,  12,  14,  16,  22,
+			25,  27,  29,  31,  33,  35,  37,  39,
+			41,  43,  45,  48,  50,  52,  55,  58,
+			60,  64,  67,  69,  71,  73,  75,  75,
+			75,  79,  83,  87,  91,  95,  99,  103,
+			107, 111, 116, 121, 126, 131, 136, 141,
+			146, 151, 156, 161, 166, 171, 176, 181,
+			186, 191, 196, 201, 206, 211, 216, 221,
+			221, 221, 221, 221, 221, 221, 221, 221,
+			221, 221, 221, 221, 221, 221, 221, 221,
+			221, 221, 221, 221, 221, 221, 221, 221,
+			221, 221, 221, 221, 221, 221, 221, 221,
+			221, 221, 221, 221, 221, 221, 221, 221,
+			221, 221, 221, 221, 221, 221, 221, 221,
+			221, 221, 221, 221, 221, 221, 221, 221,
+			221, 221, 221, 221, 221, 221, 221, 221,
+			221,
+		},
+		{	/* Fourth byte table 74. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  56,
+			56,  60,  60,  64,  64,  64,  68,  72,
+			76,  80,  84,  88,  92,  96,  100, 104,
+			104, 108, 108, 112, 112, 112, 116, 120,
+			120, 120, 120, 124, 128, 132, 136, 136,
+			136, 140, 144, 148, 152, 156, 160, 164,
+			168, 172, 176, 180, 184, 188, 192, 196,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200,
+		},
+		{	/* Fourth byte table 75. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  100, 104, 108, 112, 116, 120, 124,
+			128, 132, 136, 140, 144, 148, 152, 156,
+			160, 164, 168, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172, 172, 172, 172, 172, 172, 172, 172,
+			172,
+		},
+		{	/* Fourth byte table 76. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   9,   12,  14,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  20,  24,  28,  32,
+			36,  36,  36,  36,  36,  36,  41,  41,
+			46,  48,  50,  52,  54,  56,  58,  60,
+			62,  64,  65,  70,  75,  82,  89,  94,
+			99,  104, 109, 114, 119, 124, 129, 134,
+			134, 139, 144, 149, 154, 159, 159, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164,
+		},
+		{	/* Fourth byte table 77. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   10,  10,  15,  20,  20,  25,
+			30,  35,  40,  45,  50,  55,  60,  65,
+			69,  71,  73,  75,  77,  79,  81,  83,
+			85,  87,  89,  91,  93,  95,  97,  99,
+			101, 103, 105, 107, 109, 111, 113, 115,
+			117, 119, 121, 123, 125, 127, 129, 131,
+			133, 135, 137, 139, 141, 143, 145, 147,
+			149, 151, 153, 155, 157, 159, 161, 163,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165,
+		},
+		{	/* Fourth byte table 78. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  52,  54,  56,  58,  60,  62,
+			64,  66,  68,  70,  72,  76,  80,  82,
+			84,  86,  88,  90,  92,  94,  96,  98,
+			100, 104, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108,
+		},
+		{	/* Fourth byte table 79. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   2,   4,   6,   8,
+			10,  12,  14,  16,  18,  20,  24,  26,
+			28,  30,  32,  34,  36,  38,  40,  42,
+			44,  46,  48,  54,  60,  66,  72,  78,
+			84,  90,  96,  102, 108, 114, 120, 126,
+			132, 138, 144, 150, 156, 158, 160, 162,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164,
+		},
+		{	/* Fourth byte table 80. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  100, 104, 108, 112, 116, 120, 124,
+			128, 132, 136, 140, 144, 148, 152, 156,
+			160, 164, 168, 172, 176, 180, 184, 188,
+			192, 196, 200, 204, 208, 212, 216, 220,
+			224, 228, 232, 236, 240, 244, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248,
+		},
+		{	/* Fourth byte table 81. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   6,   12,  18,  24,  30,  36,  42,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  54,  60,  68,  76,  84,  92,  100,
+			108, 116, 122, 155, 170, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178,
+		},
+		{	/* Fourth byte table 82. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   5,   8,   9,   10,  11,  12,
+			13,  14,  17,  20,  23,  26,  29,  32,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 83. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  15,  15,
+			15,  15,  18,  21,  24,  27,  28,  29,
+			30,  31,  34,  35,  35,  36,  37,  38,
+			39,  42,  43,  44,  45,  46,  49,  52,
+			53,  54,  55,  56,  57,  58,  59,  60,
+			60,  61,  62,  63,  64,  64,  64,  64,
+			64,  67,  71,  74,  74,  77,  77,  80,
+			84,  87,  91,  94,  98,  101, 105, 108,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112,
+		},
+		{	/* Fourth byte table 84. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   6,   10,  14,  18,  22,  26,
+			30,  34,  38,  42,  46,  50,  52,  54,
+			56,  58,  60,  62,  64,  66,  68,  70,
+			72,  74,  76,  78,  80,  82,  84,  86,
+			88,  90,  92,  94,  96,  98,  100, 102,
+			104, 106, 108, 110, 112, 114, 116, 118,
+			120, 122, 124, 126, 128, 130, 132, 134,
+			136, 138, 140, 142, 144, 146, 148, 150,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152,
+		},
+		{	/* Fourth byte table 85. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  52,  54,  56,  58,  60,  62,
+			64,  66,  68,  70,  72,  74,  76,  78,
+			80,  82,  84,  86,  88,  90,  92,  94,
+			96,  98,  100, 102, 104, 106, 112, 118,
+			124, 130, 136, 142, 146, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150,
+		},
+		{	/* Fourth byte table 86. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   1,   2,   3,   4,   5,   6,
+			7,   8,   9,   10,  11,  12,  13,  14,
+			15,  16,  17,  18,  19,  20,  21,  22,
+			23,  24,  25,  26,  27,  28,  29,  30,
+			31,  32,  33,  34,  35,  36,  37,  38,
+			39,  40,  41,  42,  43,  44,  45,  46,
+			47,  48,  49,  50,  51,  52,  53,  54,
+			55,  56,  57,  58,  59,  60,  61,  62,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 87. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			34,  37,  40,  43,  46,  49,  52,  55,
+			58,  61,  64,  67,  70,  73,  76,  79,
+			82,  85,  88,  91,  94,  97,  100, 103,
+			106, 109, 112, 115, 118, 121, 124, 127,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130,
+		},
+		{	/* Fourth byte table 88. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189,
+		},
+		{	/* Fourth byte table 89. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   3,   6,   9,   12,  15,
+			18,  18,  18,  21,  24,  27,  30,  33,
+			36,  36,  36,  39,  42,  45,  48,  51,
+			54,  54,  54,  57,  60,  63,  63,  63,
+			63,  65,  67,  69,  72,  74,  76,  79,
+			79,  82,  85,  88,  91,  94,  97,  100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100,
+		},
+		{	/* Fourth byte table 90. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   9,
+			18,  31,  44,  57,  70,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,
+		},
+		{	/* Fourth byte table 91. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   9,   18,  31,  44,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,
+		},
+		{	/* Fourth byte table 92. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,
+		},
+		{	/* Fourth byte table 93. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 94. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  21,  22,
+			23,  24,  25,  26,  27,  28,  29,  30,
+			31,  32,  33,  34,  35,  36,  37,  38,
+			39,  40,  41,  42,  43,  44,  45,  46,
+			47,  48,  49,  50,  51,  52,  53,  54,
+			55,  56,  57,  58,  59,  60,  61,  62,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 95. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  29,  30,
+			31,  31,  31,  32,  32,  32,  33,  34,
+			34,  34,  35,  36,  37,  38,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  50,  51,  51,  52,  53,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,
+		},
+		{	/* Fourth byte table 96. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   1,   2,   3,   3,   4,   5,
+			6,   7,   8,   9,   10,  11,  12,  13,
+			14,  15,  16,  17,  18,  19,  20,  21,
+			22,  23,  24,  25,  26,  27,  28,  29,
+			30,  31,  32,  33,  34,  35,  36,  37,
+			38,  39,  40,  41,  42,  43,  44,  45,
+			46,  47,  48,  49,  50,  51,  52,  53,
+			54,  55,  56,  57,  58,  59,  60,  61,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 97. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   6,
+			7,   8,   9,   10,  10,  10,  11,  12,
+			13,  14,  15,  16,  17,  18,  18,  19,
+			20,  21,  22,  23,  24,  25,  25,  26,
+			27,  28,  29,  30,  31,  32,  33,  34,
+			35,  36,  37,  38,  39,  40,  41,  42,
+			43,  44,  45,  46,  47,  48,  49,  50,
+			51,  52,  53,  53,  54,  55,  56,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,
+		},
+		{	/* Fourth byte table 98. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   5,   6,
+			6,   6,   6,   7,   8,   9,   10,  11,
+			12,  13,  13,  14,  15,  16,  17,  18,
+			19,  20,  21,  22,  23,  24,  25,  26,
+			27,  28,  29,  30,  31,  32,  33,  34,
+			35,  36,  37,  38,  39,  40,  41,  42,
+			43,  44,  45,  46,  47,  48,  49,  50,
+			51,  52,  53,  54,  55,  56,  57,  58,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,
+		},
+		{	/* Fourth byte table 99. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 100. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 101. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 102. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 103. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  36,  36,  36,
+			36,  38,  40,  42,  44,  46,  48,  50,
+			52,  54,  56,  58,  60,  62,  64,  66,
+			68,  70,  72,  74,  76,  78,  80,  82,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,
+		},
+		{	/* Fourth byte table 104. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   5,   7,   9,   11,  13,  15,
+			17,  19,  21,  23,  25,  27,  29,  31,
+			33,  35,  37,  39,  41,  43,  45,  47,
+			49,  51,  53,  55,  58,  60,  62,  64,
+			66,  68,  70,  72,  74,  76,  78,  80,
+			82,  84,  86,  88,  90,  92,  94,  96,
+			98,  100, 102, 104, 106, 108, 110, 112,
+			114, 116, 118, 120, 123, 125, 127, 129,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131,
+		},
+		{	/* Fourth byte table 105. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  45,  47,
+			49,  51,  53,  55,  57,  59,  61,  63,
+			65,  67,  69,  71,  73,  75,  77,  79,
+			81,  83,  85,  87,  89,  91,  93,  95,
+			97,  99,  101, 103, 105, 107, 110, 112,
+			114, 116, 118, 120, 122, 124, 126, 128,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130,
+		},
+		{	/* Fourth byte table 106. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			33,  35,  37,  39,  41,  43,  45,  47,
+			49,  51,  53,  55,  57,  59,  61,  63,
+			65,  67,  69,  71,  73,  75,  77,  79,
+			81,  83,  85,  87,  89,  91,  93,  95,
+			98,  100, 102, 104, 106, 108, 110, 112,
+			114, 116, 118, 120, 122, 124, 126, 128,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130,
+		},
+		{	/* Fourth byte table 107. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  21,  23,  25,  27,  29,  31,
+			33,  35,  37,  39,  41,  43,  45,  47,
+			49,  51,  53,  55,  57,  59,  61,  63,
+			65,  67,  69,  71,  73,  75,  77,  79,
+			81,  83,  86,  88,  90,  92,  94,  96,
+			98,  100, 102, 104, 106, 108, 110, 112,
+			114, 116, 118, 120, 122, 124, 126, 128,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130,
+		},
+		{	/* Fourth byte table 108. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   9,   11,  13,  15,
+			17,  19,  21,  21,  21,  21,  21,  22,
+			23,  24,  25,  26,  27,  28,  29,  30,
+			31,  32,  33,  34,  35,  36,  37,  38,
+			39,  40,  41,  42,  43,  44,  45,  46,
+			47,  48,  49,  50,  51,  52,  53,  54,
+			55,  56,  57,  58,  59,  60,  61,  62,
+			63,  64,  65,  66,  67,  68,  69,  70,
+			71,  71,  71,  71,  71,  71,  71,  71,
+			71,  71,  71,  71,  71,  71,  71,  71,
+			71,  71,  71,  71,  71,  71,  71,  71,
+			71,  71,  71,  71,  71,  71,  71,  71,
+			71,  71,  71,  71,  71,  71,  71,  71,
+			71,  71,  71,  71,  71,  71,  71,  71,
+			71,  71,  71,  71,  71,  71,  71,  71,
+			71,  71,  71,  71,  71,  71,  71,  71,
+			71,
+		},
+		{	/* Fourth byte table 109. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   9,   13,  17,  21,  25,  29,
+			33,  37,  42,  46,  50,  54,  58,  62,
+			66,  71,  75,  80,  85,  90,  94,  98,
+			102, 106, 110, 114, 118, 122, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127,
+		},
+		{	/* Fourth byte table 110. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 111. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 112. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 113. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 114. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 115. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 116. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 117. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+	},
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   1,   1,   1,   1,   1,   1,
+			1,   4,   4,   5,   5,   5,   5,   5,
+			8,   8,   8,   9,   10,  13,  15,  15,
+			15,  18,  19,  20,  20,  25,  30,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  24,
+			28,  32,  36,  40,  44,  48,  52,  56,
+			60,  60,  64,  68,  72,  76,  80,  84,
+			84,  84,  88,  92,  96,  100, 104, 104,
+			104, 108, 112, 116, 120, 124, 128, 128,
+			132, 136, 140, 144, 148, 152, 156, 160,
+			164, 164, 168, 172, 176, 180, 184, 188,
+			188, 188, 192, 196, 200, 204, 208, 208,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  64,  64,  68,  72,  76,  80,  84,
+			88,  92,  96,  100, 104, 108, 112, 116,
+			120, 124, 128, 132, 136, 140, 144, 144,
+			144, 148, 152, 156, 160, 164, 168, 172,
+			176, 180, 180, 182, 184, 188, 192, 196,
+			200, 200, 204, 208, 212, 216, 220, 224,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227, 227, 227, 227, 227, 227, 227, 227,
+			227,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   3,   7,   11,  15,  19,
+			23,  27,  30,  30,  30,  34,  38,  42,
+			46,  50,  54,  54,  54,  58,  62,  66,
+			70,  74,  78,  82,  86,  90,  94,  98,
+			102, 106, 110, 114, 118, 122, 126, 126,
+			126, 130, 134, 138, 142, 146, 150, 154,
+			158, 162, 166, 170, 174, 178, 182, 186,
+			190, 194, 198, 202, 206, 210, 214, 218,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219, 219, 219, 219, 219, 219, 219, 219,
+			219,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			12,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   4,   8,   12,
+			14,  16,  18,  20,  22,  24,  28,  32,
+			36,  40,  44,  48,  52,  56,  62,  68,
+			74,  80,  86,  92,  98,  104, 104, 110,
+			116, 122, 128, 133, 138, 138, 138, 142,
+			146, 150, 154, 158, 162, 168, 174, 179,
+			184, 188, 190, 192, 194, 198, 202, 202,
+			202, 206, 210, 216, 222, 227, 232, 237,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242, 242, 242, 242, 242, 242, 242, 242,
+			242,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  100, 104, 108, 112, 112, 112, 116,
+			120, 120, 120, 120, 120, 120, 120, 124,
+			128, 132, 136, 142, 148, 154, 160, 164,
+			168, 174, 180, 184, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188, 188, 188, 188, 188, 188, 188, 188,
+			188,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   3,   4,   5,   7,   9,   11,
+			12,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  18,
+			18,  20,  21,  22,  23,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   6,   9,   14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  17,  17,  17,
+			17,  17,  17,  20,  20,  20,  20,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   3,   14,  19,
+			22,  27,  32,  37,  37,  42,  42,  47,
+			52,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  64,  69,  74,  79,  84,
+			89,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   5,   10,  15,  20,  25,
+			25,  27,  29,  31,  41,  51,  53,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  57,  59,  61,  61,  63,  65,  65,
+			65,  65,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,  67,  67,  67,  67,  67,  67,  67,
+			67,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   10,  10,  15,  15,  15,  15,
+			20,  20,  20,  20,  20,  25,  30,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  40,  40,  40,  40,  40,  40,
+			40,  40,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   10,  10,  15,  15,  15,  15,
+			20,  20,  20,  20,  20,  25,  30,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  40,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   5,   10,  10,  10,  10,  10,
+			10,  10,  10,  10,  10,  10,  10,  10,
+			10,  15,  20,  25,  30,  30,  30,  35,
+			40,  40,  40,  45,  50,  55,  60,  65,
+			70,  70,  70,  75,  80,  85,  90,  95,
+			100, 100, 100, 105, 110, 115, 120, 125,
+			130, 135, 140, 145, 150, 155, 160, 160,
+			160, 165, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170, 170, 170, 170, 170, 170, 170, 170,
+			170,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,   4,   4,   4,   4,   4,   4,   4,
+			4,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   5,   10,  15,  20,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   4,   8,
+			12,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   5,   10,  10,  10,  10,  10,
+			10,  10,  10,  10,  10,  10,  10,  10,
+			10,  10,  10,  10,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   7,   7,   7,   7,   7,   7,
+			7,   7,   14,  14,  14,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   14,  21,  28,  35,  42,  49,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  21,  28,  28,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   7,   7,   14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   7,   14,  21,  21,  21,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   7,   14,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  28,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   14,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   7,   7,   7,   7,   7,
+			14,  21,  21,  28,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   14,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   7,   7,   14,  24,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,  31,  31,  31,  31,  31,  31,  31,
+			31,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   6,   12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   14,  14,
+			14,  14,  14,  21,  21,  21,  21,  21,
+			28,  28,  28,  28,  28,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  49,  49,  56,  63,
+			72,  79,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,
+		},
+		{	/* Fourth byte table 36. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  21,  21,
+			21,  21,  21,  28,  28,  28,  28,  28,
+			35,  35,  35,  35,  35,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,  49,  49,  49,  49,  49,  49,  49,
+			49,
+		},
+		{	/* Fourth byte table 37. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,   7,   7,   7,   7,   7,   7,   7,
+			7,
+		},
+		{	/* Fourth byte table 38. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 39. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   7,
+			7,   14,  14,  21,  21,  28,  28,  35,
+			35,  35,  35,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  49,  49,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,
+		},
+		{	/* Fourth byte table 40. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   14,  14,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 41. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   1,   3,   4,
+			4,   5,   6,   8,   9,   10,  11,  12,
+			13,  14,  15,  16,  16,  17,  19,  20,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 42. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   6,   8,   11,
+			12,  13,  14,  16,  18,  20,  21,  21,
+			22,  23,  25,  26,  28,  31,  34,  35,
+			36,  37,  40,  42,  43,  46,  48,  50,
+			52,  54,  56,  57,  58,  59,  60,  62,
+			64,  66,  68,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,
+		},
+		{	/* Fourth byte table 43. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   2,   3,   5,   7,
+			9,   10,  12,  14,  16,  18,  20,  22,
+			25,  27,  29,  32,  34,  36,  38,  40,
+			42,  44,  46,  48,  50,  52,  54,  56,
+			58,  61,  63,  65,  66,  68,  70,  72,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,
+		},
+		{	/* Fourth byte table 44. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   6,   12,  13,  14,  15,  16,  17,
+			18,  19,  20,  21,  21,  21,  21,  21,
+			21,  21,  24,  24,  24,  24,  24,  24,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  28,  30,  33,
+			33,  33,  33,  33,  33,  33,  33,  33,
+			34,  34,  34,  34,  40,  49,  49,  55,
+			64,  64,  64,  64,  64,  66,  66,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,  69,  69,  69,  69,  69,  69,  69,
+			69,
+		},
+		{	/* Fourth byte table 45. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			2,   4,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  19,  19,
+			19,  20,  21,  21,  21,  22,  23,  24,
+			25,  26,  27,  28,  31,  32,  33,  34,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,  35,  35,  35,  35,  35,  35,  35,
+			35,
+		},
+		{	/* Fourth byte table 46. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  14,  15,  16,  17,
+			17,  18,  19,  20,  21,  23,  23,  23,
+			23,  23,  23,  23,  23,  23,  23,  23,
+			23,  23,  23,  23,  23,  23,  23,  23,
+			23,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,  25,  25,  25,  25,  25,  25,  25,
+			25,
+		},
+		{	/* Fourth byte table 47. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   7,   10,  10,  13,  16,
+			18,  18,  21,  22,  23,  24,  25,  26,
+			28,  29,  30,  31,  32,  32,  33,  35,
+			35,  35,  36,  37,  38,  39,  40,  40,
+			40,  42,  45,  47,  47,  48,  48,  51,
+			51,  52,  52,  54,  58,  59,  60,  60,
+			61,  62,  63,  63,  64,  65,  67,  69,
+			71,  73,  74,  74,  77,  79,  81,  83,
+			85,  85,  85,  85,  85,  85,  85,  85,
+			85,  85,  85,  85,  85,  85,  85,  85,
+			85,  85,  85,  85,  85,  85,  85,  85,
+			85,  85,  85,  85,  85,  85,  85,  85,
+			85,  85,  85,  85,  85,  85,  85,  85,
+			85,  85,  85,  85,  85,  85,  85,  85,
+			85,  85,  85,  85,  85,  85,  85,  85,
+			85,  85,  85,  85,  85,  85,  85,  85,
+			85,
+		},
+		{	/* Fourth byte table 48. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   3,   3,   3,   4,   5,
+			6,   7,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   13,  18,  23,  28,
+			33,  38,  43,  48,  53,  58,  63,  68,
+			72,  73,  75,  78,  80,  81,  83,  86,
+			90,  92,  93,  95,  98,  99,  100, 101,
+			102, 103, 105, 108, 110, 111, 113, 116,
+			120, 122, 123, 125, 128, 129, 130, 131,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132, 132, 132, 132, 132, 132, 132, 132,
+			132,
+		},
+		{	/* Fourth byte table 49. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   6,   12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,
+		},
+		{	/* Fourth byte table 50. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   6,   12,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,
+		},
+		{	/* Fourth byte table 51. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   6,   6,   6,
+			6,   6,   12,  12,  12,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  24,  24,  30,
+			30,  30,  30,  30,  30,  36,  45,  45,
+			51,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,
+		},
+		{	/* Fourth byte table 52. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   6,   6,   6,   12,  12,  12,
+			18,  18,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  28,  28,  34,  34,  34,  34,  34,
+			34,  34,  34,  34,  34,  34,  40,  44,
+			48,  54,  60,  60,  60,  66,  72,  72,
+			72,  78,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,
+		},
+		{	/* Fourth byte table 53. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   6,   12,  12,  12,  18,  24,  24,
+			24,  30,  36,  36,  36,  36,  36,  36,
+			36,  36,  36,  36,  36,  36,  36,  36,
+			36,  36,  36,  36,  36,  36,  36,  36,
+			36,  36,  36,  36,  36,  36,  36,  36,
+			36,  36,  36,  36,  36,  42,  48,  54,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,
+		},
+		{	/* Fourth byte table 54. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   6,   12,  18,  24,  24,  24,  24,
+			24,  24,  24,  30,  36,  42,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 55. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   4,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,
+		},
+		{	/* Fourth byte table 56. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   11,  13,  15,  17,  19,  21,
+			23,  25,  27,  29,  31,  34,  37,  40,
+			43,  46,  49,  52,  55,  58,  62,  66,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,
+		},
+		{	/* Fourth byte table 57. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  53,  56,  59,  62,  65,  68,
+			71,  74,  77,  80,  83,  86,  89,  92,
+			95,  98,  101, 104, 107, 110, 113, 116,
+			119, 122, 125, 128, 131, 134, 137, 140,
+			143, 146, 149, 152, 155, 158, 161, 162,
+			163, 164, 165, 166, 167, 168, 169, 170,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171,
+		},
+		{	/* Fourth byte table 58. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,  43,  43,  43,  43,  43,  43,  43,
+			43,
+		},
+		{	/* Fourth byte table 59. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,
+		},
+		{	/* Fourth byte table 60. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   3,   5,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,
+		},
+		{	/* Fourth byte table 61. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,   6,   6,   6,   6,   6,   6,   6,
+			6,
+		},
+		{	/* Fourth byte table 62. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 63. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 64. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 65. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 66. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 67. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 68. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,
+		},
+		{	/* Fourth byte table 69. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   1,
+			1,   1,   1,   1,   1,   1,   1,   4,
+			4,   7,   10,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,
+		},
+		{	/* Fourth byte table 70. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   7,   7,   14,
+			14,  21,  21,  28,  28,  35,  35,  42,
+			42,  49,  49,  56,  56,  63,  63,  70,
+			70,  77,  77,  84,  84,  84,  91,  91,
+			98,  98,  105, 105, 105, 105, 105, 105,
+			105, 112, 119, 119, 126, 133, 133, 140,
+			147, 147, 154, 161, 161, 168, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175, 175, 175, 175, 175, 175, 175, 175,
+			175,
+		},
+		{	/* Fourth byte table 71. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   7,   7,   7,
+			7,   7,   7,   7,   11,  15,  15,  22,
+			28,  28,  28,  28,  28,  28,  28,  28,
+			28,  28,  28,  28,  28,  35,  35,  42,
+			42,  49,  49,  56,  56,  63,  63,  70,
+			70,  77,  77,  84,  84,  91,  91,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,  98,  98,  98,  98,  98,  98,  98,
+			98,
+		},
+		{	/* Fourth byte table 72. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   7,   7,   14,  14,  14,  21,  21,
+			28,  28,  35,  35,  35,  35,  35,  35,
+			35,  42,  49,  49,  56,  63,  63,  70,
+			77,  77,  84,  91,  91,  98,  105, 105,
+			105, 105, 105, 105, 105, 105, 105, 105,
+			105, 105, 105, 105, 105, 105, 105, 105,
+			105, 105, 105, 105, 105, 112, 112, 112,
+			119, 126, 133, 140, 140, 140, 140, 147,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153, 153, 153, 153, 153, 153, 153, 153,
+			153,
+		},
+		{	/* Fourth byte table 73. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   6,   9,   12,  15,  18,
+			21,  24,  27,  30,  33,  36,  39,  42,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,  45,  45,  45,  45,  45,  45,  45,
+			45,
+		},
+		{	/* Fourth byte table 74. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192, 192, 192, 192, 192, 192, 192, 192,
+			192,
+		},
+		{	/* Fourth byte table 75. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			45,  45,  45,  48,  51,  54,  57,  60,
+			63,  66,  69,  72,  75,  78,  81,  84,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,
+		},
+		{	/* Fourth byte table 76. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   10,  15,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  23,  25,  27,  29,  31,  33,  35,
+			37,  39,  41,  43,  45,  47,  49,  51,
+			53,  56,  59,  62,  65,  68,  71,  74,
+			77,  80,  83,  86,  89,  92,  95,  101,
+			107, 113, 119, 125, 131, 137, 143, 149,
+			155, 161, 167, 173, 179, 194, 206, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212, 212, 212, 212, 212, 212, 212, 212,
+			212,
+		},
+		{	/* Fourth byte table 77. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 149, 151, 153, 155, 157, 159,
+			161, 163, 165, 167, 169, 171, 173, 175,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177, 177, 177, 177, 177, 177, 177, 177,
+			177,
+		},
+		{	/* Fourth byte table 78. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  41,  46,  51,  53,  56,  58,
+			61,  64,  67,  70,  73,  76,  79,  82,
+			85,  88,  91,  94,  97,  100, 103, 106,
+			109, 112, 115, 118, 121, 124, 127, 130,
+			133, 136, 139, 142, 145, 148, 151, 154,
+			157, 160, 163, 166, 169, 172, 175, 178,
+			181, 184, 187, 190, 193, 196, 199, 202,
+			202, 202, 202, 202, 202, 202, 202, 202,
+			202, 202, 202, 202, 202, 202, 202, 202,
+			202, 202, 202, 202, 202, 202, 202, 202,
+			202, 202, 202, 202, 202, 202, 202, 202,
+			202, 202, 202, 202, 202, 202, 202, 202,
+			202, 202, 202, 202, 202, 202, 202, 202,
+			202, 202, 202, 202, 202, 202, 202, 202,
+			202, 202, 202, 202, 202, 202, 202, 202,
+			202,
+		},
+		{	/* Fourth byte table 79. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   7,   9,   11,  13,  15,
+			17,  20,  24,  26,  28,  31,  34,  36,
+			38,  40,  43,  46,  49,  52,  55,  57,
+			59,  61,  63,  65,  68,  70,  72,  74,
+			77,  80,  82,  85,  88,  91,  93,  96,
+			101, 107, 109, 112, 115, 118, 121, 128,
+			136, 138, 140, 143, 145, 147, 149, 152,
+			154, 156, 158, 160, 162, 165, 167, 169,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171, 171, 171, 171, 171, 171, 171, 171,
+			171,
+		},
+		{	/* Fourth byte table 80. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   10,  12,  14,  16,  22,
+			25,  27,  29,  31,  33,  35,  37,  39,
+			41,  43,  45,  48,  50,  52,  55,  58,
+			60,  64,  67,  69,  71,  73,  75,  80,
+			85,  89,  93,  97,  101, 105, 109, 113,
+			117, 121, 126, 131, 136, 141, 146, 151,
+			156, 161, 166, 171, 176, 181, 186, 191,
+			196, 201, 206, 211, 216, 221, 226, 231,
+			234, 234, 234, 234, 234, 234, 234, 234,
+			234, 234, 234, 234, 234, 234, 234, 234,
+			234, 234, 234, 234, 234, 234, 234, 234,
+			234, 234, 234, 234, 234, 234, 234, 234,
+			234, 234, 234, 234, 234, 234, 234, 234,
+			234, 234, 234, 234, 234, 234, 234, 234,
+			234, 234, 234, 234, 234, 234, 234, 234,
+			234, 234, 234, 234, 234, 234, 234, 234,
+			234,
+		},
+		{	/* Fourth byte table 81. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  56,
+			56,  60,  60,  64,  64,  64,  68,  72,
+			76,  80,  84,  88,  92,  96,  100, 104,
+			104, 108, 108, 112, 112, 112, 116, 120,
+			120, 120, 120, 124, 128, 132, 136, 136,
+			136, 140, 144, 148, 152, 156, 160, 164,
+			168, 172, 176, 180, 184, 188, 192, 196,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200, 200, 200, 200, 200, 200, 200, 200,
+			200,
+		},
+		{	/* Fourth byte table 82. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  100, 104, 108, 112, 116, 120, 124,
+			128, 132, 136, 140, 144, 148, 152, 156,
+			160, 164, 168, 172, 172, 172, 172, 172,
+			172, 176, 180, 184, 188, 192, 196, 200,
+			204, 208, 212, 216, 220, 224, 228, 232,
+			236, 236, 236, 236, 236, 236, 236, 236,
+			236, 236, 236, 236, 236, 236, 236, 236,
+			236, 236, 236, 236, 236, 236, 236, 236,
+			236, 236, 236, 236, 236, 236, 236, 236,
+			236, 236, 236, 236, 236, 236, 236, 236,
+			236, 236, 236, 236, 236, 236, 236, 236,
+			236, 236, 236, 236, 236, 236, 236, 236,
+			236, 236, 236, 236, 236, 236, 236, 236,
+			236,
+		},
+		{	/* Fourth byte table 83. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			65,  70,  75,  79,  83,  87,  92,  97,
+			102, 106, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110, 110, 110, 110, 110, 110, 110, 110,
+			110,
+		},
+		{	/* Fourth byte table 84. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   9,   12,  14,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  20,  24,  28,  32,
+			36,  36,  36,  36,  36,  36,  41,  41,
+			46,  48,  50,  52,  54,  56,  58,  60,
+			62,  64,  65,  70,  75,  82,  89,  94,
+			99,  104, 109, 114, 119, 124, 129, 134,
+			134, 139, 144, 149, 154, 159, 159, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164,
+		},
+		{	/* Fourth byte table 85. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   5,   10,  10,  15,  20,  20,  25,
+			30,  35,  40,  45,  50,  55,  60,  65,
+			69,  71,  73,  75,  77,  79,  81,  83,
+			85,  87,  89,  91,  93,  95,  97,  99,
+			101, 103, 105, 107, 109, 111, 113, 115,
+			117, 119, 121, 123, 125, 127, 129, 131,
+			133, 135, 137, 139, 141, 143, 145, 147,
+			149, 151, 153, 155, 157, 159, 161, 163,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165, 165, 165, 165, 165, 165, 165, 165,
+			165,
+		},
+		{	/* Fourth byte table 86. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  52,  54,  56,  58,  60,  62,
+			64,  66,  68,  70,  72,  76,  80,  82,
+			84,  86,  88,  90,  92,  94,  96,  98,
+			100, 104, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108, 108, 108, 108, 108, 108, 108, 108,
+			108,
+		},
+		{	/* Fourth byte table 87. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   2,   4,   6,   8,
+			10,  12,  14,  16,  18,  20,  24,  26,
+			28,  30,  32,  34,  36,  38,  40,  42,
+			44,  46,  48,  54,  60,  66,  72,  78,
+			84,  90,  96,  102, 108, 114, 120, 126,
+			132, 138, 144, 150, 156, 158, 160, 162,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164, 164, 164, 164, 164, 164, 164, 164,
+			164,
+		},
+		{	/* Fourth byte table 88. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  100, 104, 108, 112, 116, 120, 124,
+			128, 132, 136, 140, 144, 148, 152, 156,
+			160, 164, 168, 172, 176, 180, 184, 188,
+			192, 196, 200, 204, 208, 212, 216, 220,
+			224, 228, 232, 236, 240, 244, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248, 248, 248, 248, 248, 248, 248, 248,
+			248,
+		},
+		{	/* Fourth byte table 89. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   6,   12,  18,  24,  30,  36,  42,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  54,  60,  68,  76,  84,  92,  100,
+			108, 116, 122, 155, 170, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178, 178, 178, 178, 178, 178, 178, 178,
+			178,
+		},
+		{	/* Fourth byte table 90. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   4,   7,   8,   9,   10,  11,
+			14,  17,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  22,  25,  28,  29,  30,  31,  32,
+			33,  34,  37,  40,  43,  46,  49,  52,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,  55,  55,  55,  55,  55,  55,  55,
+			55,
+		},
+		{	/* Fourth byte table 91. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  15,  15,
+			16,  17,  20,  23,  26,  29,  30,  31,
+			32,  33,  36,  37,  37,  38,  39,  40,
+			41,  44,  45,  46,  47,  48,  51,  54,
+			55,  56,  57,  58,  59,  60,  61,  62,
+			62,  63,  64,  65,  66,  66,  66,  66,
+			66,  69,  73,  76,  76,  79,  79,  82,
+			86,  89,  93,  96,  100, 103, 107, 110,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114,
+		},
+		{	/* Fourth byte table 92. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   6,   10,  14,  18,  22,  26,
+			30,  34,  38,  42,  46,  50,  52,  54,
+			56,  58,  60,  62,  64,  66,  68,  70,
+			72,  74,  76,  78,  80,  82,  84,  86,
+			88,  90,  92,  94,  96,  98,  100, 102,
+			104, 106, 108, 110, 112, 114, 116, 118,
+			120, 122, 124, 126, 128, 130, 132, 134,
+			136, 138, 140, 142, 144, 146, 148, 150,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152,
+		},
+		{	/* Fourth byte table 93. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  52,  54,  56,  58,  60,  62,
+			64,  66,  68,  70,  72,  74,  76,  78,
+			80,  82,  84,  86,  88,  90,  92,  94,
+			96,  98,  100, 102, 104, 106, 112, 118,
+			124, 130, 136, 142, 146, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150, 150, 150, 150, 150, 150, 150, 150,
+			150,
+		},
+		{	/* Fourth byte table 94. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   1,   2,   3,   4,   5,   6,
+			7,   8,   9,   10,  11,  12,  13,  14,
+			15,  16,  17,  18,  19,  20,  21,  22,
+			23,  24,  25,  26,  27,  28,  29,  30,
+			31,  32,  33,  34,  35,  36,  37,  38,
+			39,  40,  41,  42,  43,  44,  45,  46,
+			47,  48,  49,  50,  51,  52,  53,  54,
+			55,  56,  57,  58,  59,  60,  61,  62,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 95. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			34,  37,  40,  43,  46,  49,  52,  55,
+			58,  61,  64,  67,  70,  73,  76,  79,
+			82,  85,  88,  91,  94,  97,  100, 103,
+			106, 109, 112, 115, 118, 121, 124, 127,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130,
+		},
+		{	/* Fourth byte table 96. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			144, 147, 150, 153, 156, 159, 162, 165,
+			168, 171, 174, 177, 180, 183, 186, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189, 189, 189, 189, 189, 189, 189, 189,
+			189,
+		},
+		{	/* Fourth byte table 97. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   3,   6,   9,   12,  15,
+			18,  18,  18,  21,  24,  27,  30,  33,
+			36,  36,  36,  39,  42,  45,  48,  51,
+			54,  54,  54,  57,  60,  63,  63,  63,
+			63,  65,  67,  69,  72,  74,  76,  79,
+			79,  82,  85,  88,  91,  94,  97,  100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100, 100, 100, 100, 100, 100, 100, 100,
+			100,
+		},
+		{	/* Fourth byte table 98. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   9,
+			18,  31,  44,  57,  70,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,
+		},
+		{	/* Fourth byte table 99. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   9,   18,  31,  44,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,
+		},
+		{	/* Fourth byte table 100. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,  13,  13,  13,  13,  13,  13,  13,
+			13,
+		},
+		{	/* Fourth byte table 101. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 102. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  21,  22,
+			23,  24,  25,  26,  27,  28,  29,  30,
+			31,  32,  33,  34,  35,  36,  37,  38,
+			39,  40,  41,  42,  43,  44,  45,  46,
+			47,  48,  49,  50,  51,  52,  53,  54,
+			55,  56,  57,  58,  59,  60,  61,  62,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 103. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  29,  30,
+			31,  31,  31,  32,  32,  32,  33,  34,
+			34,  34,  35,  36,  37,  38,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  50,  51,  51,  52,  53,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,
+		},
+		{	/* Fourth byte table 104. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   4,   5,   6,
+			7,   8,   9,   10,  11,  12,  13,  14,
+			15,  16,  17,  18,  19,  20,  21,  22,
+			23,  24,  25,  26,  27,  28,  29,  30,
+			31,  32,  33,  34,  35,  36,  37,  38,
+			39,  40,  41,  42,  43,  44,  45,  46,
+			47,  48,  49,  50,  51,  52,  53,  54,
+			55,  56,  57,  58,  59,  60,  61,  62,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 105. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   6,
+			7,   8,   9,   10,  10,  10,  11,  12,
+			13,  14,  15,  16,  17,  18,  18,  19,
+			20,  21,  22,  23,  24,  25,  25,  26,
+			27,  28,  29,  30,  31,  32,  33,  34,
+			35,  36,  37,  38,  39,  40,  41,  42,
+			43,  44,  45,  46,  47,  48,  49,  50,
+			51,  52,  53,  53,  54,  55,  56,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,
+		},
+		{	/* Fourth byte table 106. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   5,   6,
+			6,   6,   6,   7,   8,   9,   10,  11,
+			12,  13,  13,  14,  15,  16,  17,  18,
+			19,  20,  21,  22,  23,  24,  25,  26,
+			27,  28,  29,  30,  31,  32,  33,  34,
+			35,  36,  37,  38,  39,  40,  41,  42,
+			43,  44,  45,  46,  47,  48,  49,  50,
+			51,  52,  53,  54,  55,  56,  57,  58,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,  59,  59,  59,  59,  59,  59,  59,
+			59,
+		},
+		{	/* Fourth byte table 107. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 108. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 109. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 110. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  37,  38,  39,
+			40,  41,  42,  43,  44,  45,  46,  47,
+			48,  49,  50,  51,  52,  53,  54,  55,
+			56,  57,  58,  59,  60,  61,  62,  63,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 111. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   1,   2,   3,   4,   5,   6,   7,
+			8,   9,   10,  11,  12,  13,  14,  15,
+			16,  17,  18,  19,  20,  21,  22,  23,
+			24,  25,  26,  27,  28,  29,  30,  31,
+			32,  33,  34,  35,  36,  38,  40,  40,
+			40,  42,  44,  46,  48,  50,  52,  54,
+			56,  58,  60,  62,  64,  66,  68,  70,
+			72,  74,  76,  78,  80,  82,  84,  86,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,  88,  88,  88,  88,  88,  88,  88,
+			88,
+		},
+		{	/* Fourth byte table 112. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   5,   7,   9,   11,  13,  15,
+			17,  19,  21,  23,  25,  27,  29,  31,
+			33,  35,  37,  39,  41,  43,  45,  47,
+			49,  51,  53,  55,  58,  60,  62,  64,
+			66,  68,  70,  72,  74,  76,  78,  80,
+			82,  84,  86,  88,  90,  92,  94,  96,
+			98,  100, 102, 104, 106, 108, 110, 112,
+			114, 116, 118, 120, 123, 125, 127, 129,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131, 131, 131, 131, 131, 131, 131, 131,
+			131,
+		},
+		{	/* Fourth byte table 113. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  45,  47,
+			49,  51,  53,  55,  57,  59,  61,  63,
+			65,  67,  69,  71,  73,  75,  77,  79,
+			81,  83,  85,  87,  89,  91,  93,  95,
+			97,  99,  101, 103, 105, 107, 110, 112,
+			114, 116, 118, 120, 122, 124, 126, 128,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130,
+		},
+		{	/* Fourth byte table 114. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			33,  35,  37,  39,  41,  43,  45,  47,
+			49,  51,  53,  55,  57,  59,  61,  63,
+			65,  67,  69,  71,  73,  75,  77,  79,
+			81,  83,  85,  87,  89,  91,  93,  95,
+			98,  100, 102, 104, 106, 108, 110, 112,
+			114, 116, 118, 120, 122, 124, 126, 128,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130,
+		},
+		{	/* Fourth byte table 115. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  21,  23,  25,  27,  29,  31,
+			33,  35,  37,  39,  41,  43,  45,  47,
+			49,  51,  53,  55,  57,  59,  61,  63,
+			65,  67,  69,  71,  73,  75,  77,  79,
+			81,  83,  86,  88,  90,  92,  94,  96,
+			98,  100, 102, 104, 106, 108, 110, 112,
+			114, 116, 118, 120, 122, 124, 126, 128,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130, 130, 130, 130, 130, 130, 130, 130,
+			130,
+		},
+		{	/* Fourth byte table 116. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   9,   11,  13,  15,
+			17,  19,  21,  23,  25,  25,  25,  26,
+			27,  28,  29,  30,  31,  32,  33,  34,
+			35,  36,  37,  38,  39,  40,  41,  42,
+			43,  44,  45,  46,  47,  48,  49,  50,
+			51,  52,  53,  54,  55,  56,  57,  58,
+			59,  60,  61,  62,  63,  64,  65,  66,
+			67,  68,  69,  70,  71,  72,  73,  74,
+			75,  75,  75,  75,  75,  75,  75,  75,
+			75,  75,  75,  75,  75,  75,  75,  75,
+			75,  75,  75,  75,  75,  75,  75,  75,
+			75,  75,  75,  75,  75,  75,  75,  75,
+			75,  75,  75,  75,  75,  75,  75,  75,
+			75,  75,  75,  75,  75,  75,  75,  75,
+			75,  75,  75,  75,  75,  75,  75,  75,
+			75,  75,  75,  75,  75,  75,  75,  75,
+			75,
+		},
+		{	/* Fourth byte table 117. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   9,   13,  17,  21,  25,  29,
+			33,  37,  42,  46,  50,  54,  58,  62,
+			66,  71,  75,  80,  85,  90,  94,  98,
+			102, 106, 110, 114, 118, 122, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127, 127, 127, 127, 127, 127, 127, 127,
+			127,
+		},
+	},
+};
+
+static const uint16_t u8_decomp_b4_16bit_tbl[2][30][257] = {
+	{
+		{	/* Fourth byte 16-bit table 0. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   38,   44,   48,   52,   56,   60,   64,
+			68,   72,   76,   80,   84,   90,   96,   102,
+			108,  112,  116,  120,  124,  130,  136,  140,
+			144,  148,  152,  156,  160,  164,  168,  172,
+			176,  180,  184,  188,  192,  196,  200,  206,
+			212,  216,  220,  224,  228,  232,  236,  240,
+			244,  250,  256,  260,  264,  268,  272,  276,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,
+		},
+		{	/* Fourth byte 16-bit table 1. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   54,   60,   66,
+			72,   78,   84,   90,   96,   100,  104,  108,
+			112,  116,  120,  124,  128,  134,  140,  144,
+			148,  152,  156,  160,  164,  170,  176,  182,
+			188,  194,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  262,  268,  274,  280,  284,  288,  292,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,
+		},
+		{	/* Fourth byte 16-bit table 2. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  107,  116,  116,  116,  116,
+			116,  120,  124,  128,  132,  138,  144,  150,
+			156,  162,  168,  174,  180,  186,  192,  198,
+			204,  210,  216,  222,  228,  234,  240,  246,
+			252,  256,  260,  264,  268,  272,  276,  282,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,
+		},
+		{	/* Fourth byte 16-bit table 3. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    6,    12,   18,   24,   30,   36,   42,
+			48,   52,   56,   60,   64,   68,   72,   76,
+			80,   86,   92,   98,   104,  110,  116,  122,
+			128,  134,  140,  146,  152,  158,  164,  170,
+			176,  182,  188,  194,  200,  204,  208,  212,
+			216,  222,  228,  234,  240,  246,  252,  258,
+			264,  270,  276,  280,  284,  288,  292,  296,
+			300,  304,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,
+		},
+		{	/* Fourth byte 16-bit table 4. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    5,    10,   17,   24,   31,   38,   45,
+			52,   57,   62,   69,   76,   83,   90,   97,
+			104,  109,  114,  121,  128,  135,  142,  142,
+			142,  147,  152,  159,  166,  173,  180,  180,
+			180,  185,  190,  197,  204,  211,  218,  225,
+			232,  237,  242,  249,  256,  263,  270,  277,
+			284,  289,  294,  301,  308,  315,  322,  329,
+			336,  341,  346,  353,  360,  367,  374,  381,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,
+		},
+		{	/* Fourth byte 16-bit table 5. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    5,    10,   17,   24,   31,   38,   38,
+			38,   43,   48,   55,   62,   69,   76,   76,
+			76,   81,   86,   93,   100,  107,  114,  121,
+			128,  128,  133,  133,  140,  140,  147,  147,
+			154,  159,  164,  171,  178,  185,  192,  199,
+			206,  211,  216,  223,  230,  237,  244,  251,
+			258,  263,  268,  273,  278,  283,  288,  293,
+			298,  303,  308,  313,  318,  323,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,
+		},
+		{	/* Fourth byte 16-bit table 6. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    7,    14,   23,   32,   41,   50,   59,
+			68,   75,   82,   91,   100,  109,  118,  127,
+			136,  143,  150,  159,  168,  177,  186,  195,
+			204,  211,  218,  227,  236,  245,  254,  263,
+			272,  279,  286,  295,  304,  313,  322,  331,
+			340,  347,  354,  363,  372,  381,  390,  399,
+			408,  413,  418,  425,  430,  437,  437,  442,
+			449,  454,  459,  464,  469,  474,  477,  480,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,
+		},
+		{	/* Fourth byte 16-bit table 7. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    3,    14,   21,   26,   33,   33,   38,
+			45,   50,   55,   60,   65,   70,   82,   94,
+			106,  111,  116,  123,  130,  130,  130,  135,
+			142,  147,  152,  157,  162,  162,  174,  186,
+			198,  203,  208,  215,  222,  227,  232,  237,
+			244,  249,  254,  259,  264,  269,  280,  291,
+			293,  293,  293,  300,  305,  312,  312,  317,
+			324,  329,  334,  339,  344,  349,  356,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,
+		},
+		{	/* Fourth byte 16-bit table 8. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    5,    10,   15,   20,   25,   30,   35,
+			40,   45,   50,   55,   60,   65,   70,   78,
+			86,   94,   102,  110,  118,  126,  134,  142,
+			150,  158,  166,  174,  182,  190,  190,  190,
+			190,  195,  200,  205,  210,  215,  220,  225,
+			230,  235,  240,  245,  250,  255,  260,  265,
+			270,  275,  280,  285,  290,  295,  300,  305,
+			310,  315,  320,  325,  330,  335,  340,  345,
+			350,  350,  350,  350,  350,  350,  350,  350,
+			350,  350,  350,  350,  350,  350,  350,  350,
+			350,  350,  350,  350,  350,  350,  350,  350,
+			350,  350,  350,  350,  350,  350,  350,  350,
+			350,  350,  350,  350,  350,  350,  350,  350,
+			350,  350,  350,  350,  350,  350,  350,  350,
+			350,  350,  350,  350,  350,  350,  350,  350,
+			350,  350,  350,  350,  350,  350,  350,  350,
+			350,
+		},
+		{	/* Fourth byte 16-bit table 9. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    15,   27,   42,   51,   66,   75,   84,
+			102,  114,  123,  132,  141,  153,  165,  177,
+			189,  201,  213,  225,  243,  249,  267,  285,
+			300,  312,  330,  348,  360,  369,  378,  390,
+			402,  417,  432,  441,  450,  462,  471,  480,
+			486,  492,  501,  510,  528,  540,  555,  573,
+			585,  594,  603,  621,  633,  651,  660,  675,
+			684,  696,  705,  717,  732,  744,  759,  771,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,
+		},
+		{	/* Fourth byte 16-bit table 10. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    15,   24,   33,   45,   54,   63,   72,
+			87,   99,   105,  123,  132,  147,  159,  171,
+			180,  189,  201,  207,  219,  234,  240,  258,
+			267,  271,  275,  279,  283,  287,  291,  295,
+			299,  303,  307,  312,  317,  322,  327,  332,
+			337,  342,  347,  352,  357,  362,  367,  372,
+			377,  382,  385,  387,  389,  392,  394,  396,
+			396,  396,  396,  396,  402,  408,  414,  420,
+			432,  432,  432,  432,  432,  432,  432,  432,
+			432,  432,  432,  432,  432,  432,  432,  432,
+			432,  432,  432,  432,  432,  432,  432,  432,
+			432,  432,  432,  432,  432,  432,  432,  432,
+			432,  432,  432,  432,  432,  432,  432,  432,
+			432,  432,  432,  432,  432,  432,  432,  432,
+			432,  432,  432,  432,  432,  432,  432,  432,
+			432,  432,  432,  432,  432,  432,  432,  432,
+			432,
+		},
+		{	/* Fourth byte 16-bit table 11. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 12. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 13. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 14. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 15. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    6,    12,   18,   24,   30,   34,   38,
+			42,   46,   50,   54,   58,   62,   66,   70,
+			74,   78,   82,   86,   90,   94,   98,   102,
+			106,  110,  114,  118,  122,  126,  130,  134,
+			138,  142,  146,  150,  154,  158,  162,  166,
+			170,  174,  178,  182,  186,  190,  194,  198,
+			202,  206,  210,  214,  218,  222,  226,  230,
+			234,  238,  242,  246,  250,  254,  258,  262,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,
+		},
+		{	/* Fourth byte 16-bit table 16. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  125,
+			130,  135,  140,  145,  150,  156,  162,  168,
+			174,  180,  186,  190,  194,  198,  202,  206,
+			210,  214,  218,  222,  226,  230,  234,  238,
+			242,  246,  250,  254,  258,  262,  266,  270,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,
+		},
+		{	/* Fourth byte 16-bit table 17. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			98,   104,  110,  116,  122,  126,  130,  134,
+			138,  142,  146,  150,  154,  158,  162,  166,
+			170,  174,  178,  182,  186,  190,  194,  198,
+			202,  206,  210,  214,  218,  222,  226,  230,
+			234,  238,  242,  246,  250,  254,  258,  262,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,
+		},
+		{	/* Fourth byte 16-bit table 18. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			130,  136,  140,  144,  148,  152,  156,  160,
+			164,  168,  172,  176,  180,  184,  188,  192,
+			196,  200,  204,  210,  216,  222,  226,  230,
+			234,  238,  242,  246,  250,  254,  258,  262,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,
+		},
+		{	/* Fourth byte 16-bit table 19. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    6,    12,   18,   24,   30,   36,   42,
+			48,   54,   60,   66,   72,   78,   84,   90,
+			96,   102,  108,  114,  120,  126,  132,  138,
+			144,  150,  156,  162,  168,  174,  180,  186,
+			192,  198,  204,  210,  216,  222,  228,  234,
+			240,  246,  252,  258,  264,  270,  276,  282,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,
+		},
+		{	/* Fourth byte 16-bit table 20. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    6,    12,   18,   24,   30,   36,   42,
+			48,   54,   60,   66,   72,   78,   84,   90,
+			96,   96,   96,   102,  108,  114,  120,  126,
+			132,  138,  144,  150,  156,  162,  168,  174,
+			180,  186,  192,  198,  204,  210,  216,  222,
+			228,  234,  240,  246,  252,  258,  264,  270,
+			276,  282,  288,  294,  300,  306,  312,  318,
+			324,  330,  336,  342,  348,  354,  360,  366,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,
+		},
+		{	/* Fourth byte 16-bit table 21. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   17,   21,   25,   29,
+			33,   37,   41,   45,   49,   53,   58,   62,
+			66,   70,   74,   79,   83,   87,   91,   96,
+			100,  104,  108,  112,  116,  121,  125,  129,
+			133,  137,  141,  145,  149,  153,  157,  161,
+			165,  169,  173,  177,  181,  185,  189,  193,
+			197,  201,  205,  209,  213,  218,  222,  226,
+			230,  235,  239,  243,  247,  251,  255,  259,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,
+		},
+		{	/* Fourth byte 16-bit table 22. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  105,  109,  113,  117,  121,  125,
+			129,  134,  139,  143,  147,  151,  155,  159,
+			163,  167,  171,  175,  179,  184,  188,  192,
+			196,  200,  205,  209,  213,  217,  221,  225,
+			229,  233,  237,  241,  246,  250,  255,  259,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,
+		},
+		{	/* Fourth byte 16-bit table 23. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   41,   45,   49,   53,   57,   61,
+			66,   70,   75,   80,   84,   88,   92,   96,
+			101,  106,  110,  114,  118,  122,  126,  130,
+			134,  138,  142,  146,  150,  155,  159,  163,
+			167,  171,  175,  179,  183,  187,  191,  195,
+			199,  203,  207,  211,  215,  219,  223,  227,
+			231,  236,  240,  244,  248,  252,  256,  261,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,
+		},
+		{	/* Fourth byte 16-bit table 24. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   45,   49,   53,   57,   61,
+			65,   69,   73,   77,   81,   85,   89,   93,
+			97,   101,  105,  109,  113,  117,  122,  126,
+			130,  134,  138,  142,  147,  151,  155,  159,
+			163,  167,  171,  175,  179,  184,  188,  192,
+			196,  201,  205,  209,  213,  217,  221,  225,
+			230,  235,  240,  244,  249,  253,  257,  261,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,
+		},
+		{	/* Fourth byte 16-bit table 25. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   29,
+			33,   37,   41,   45,   49,   53,   58,   62,
+			66,   71,   76,   80,   84,   88,   92,   96,
+			100,  104,  108,  112,  117,  121,  126,  130,
+			135,  139,  143,  147,  152,  156,  160,  165,
+			170,  174,  178,  182,  186,  190,  194,  198,
+			202,  206,  210,  214,  218,  222,  227,  231,
+			236,  240,  245,  249,  254,  259,  264,  268,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,
+		},
+		{	/* Fourth byte 16-bit table 26. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    9,    14,   19,   24,   28,   32,
+			36,   40,   44,   48,   52,   56,   61,   65,
+			69,   73,   77,   82,   86,   91,   96,   100,
+			104,  108,  112,  116,  120,  125,  130,  135,
+			139,  143,  148,  152,  156,  160,  165,  169,
+			173,  177,  181,  185,  190,  194,  198,  202,
+			206,  210,  214,  219,  224,  228,  233,  237,
+			242,  246,  250,  254,  259,  264,  268,  273,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,
+		},
+		{	/* Fourth byte 16-bit table 27. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    5,    9,    13,   17,   21,   25,   29,
+			34,   39,   44,   49,   53,   57,   61,   65,
+			69,   73,   77,   81,   85,   89,   93,   97,
+			102,  106,  110,  114,  118,  122,  126,  130,
+			134,  138,  142,  146,  150,  155,  160,  165,
+			169,  173,  177,  181,  186,  190,  195,  199,
+			203,  208,  213,  217,  221,  225,  229,  233,
+			237,  241,  245,  249,  253,  257,  261,  265,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,
+		},
+		{	/* Fourth byte 16-bit table 28. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   25,   29,
+			33,   37,   41,   45,   50,   55,   59,   63,
+			67,   71,   75,   79,   84,   88,   92,   96,
+			100,  105,  110,  114,  118,  122,  127,  131,
+			135,  140,  145,  149,  153,  157,  162,  166,
+			170,  174,  178,  182,  186,  190,  195,  199,
+			203,  207,  212,  216,  220,  224,  228,  233,
+			238,  242,  246,  250,  255,  259,  264,  268,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,
+		},
+		{	/* Fourth byte 16-bit table 29. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,
+		},
+	},
+	{
+		{	/* Fourth byte 16-bit table 0. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   38,   44,   48,   52,   56,   60,   64,
+			68,   72,   76,   80,   84,   90,   96,   102,
+			108,  112,  116,  120,  124,  130,  136,  140,
+			144,  148,  152,  156,  160,  164,  168,  172,
+			176,  180,  184,  188,  192,  196,  200,  206,
+			212,  216,  220,  224,  228,  232,  236,  240,
+			244,  250,  256,  260,  264,  268,  272,  276,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,  280,  280,  280,  280,  280,  280,  280,
+			280,
+		},
+		{	/* Fourth byte 16-bit table 1. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   54,   60,   66,
+			72,   78,   84,   90,   96,   100,  104,  108,
+			112,  116,  120,  124,  128,  134,  140,  144,
+			148,  152,  156,  160,  164,  170,  176,  182,
+			188,  194,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  262,  268,  274,  280,  284,  288,  292,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,  296,  296,  296,  296,  296,  296,  296,
+			296,
+		},
+		{	/* Fourth byte 16-bit table 2. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  107,  116,  116,  116,  116,
+			116,  120,  124,  128,  132,  138,  144,  150,
+			156,  162,  168,  174,  180,  186,  192,  198,
+			204,  210,  216,  222,  228,  234,  240,  246,
+			252,  256,  260,  264,  268,  272,  276,  282,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,
+		},
+		{	/* Fourth byte 16-bit table 3. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    6,    12,   18,   24,   30,   36,   42,
+			48,   52,   56,   60,   64,   68,   72,   76,
+			80,   86,   92,   98,   104,  110,  116,  122,
+			128,  134,  140,  146,  152,  158,  164,  170,
+			176,  182,  188,  194,  200,  204,  208,  212,
+			216,  222,  228,  234,  240,  246,  252,  258,
+			264,  270,  276,  280,  284,  288,  292,  296,
+			300,  304,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,  308,  308,  308,  308,  308,  308,  308,
+			308,
+		},
+		{	/* Fourth byte 16-bit table 4. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    5,    10,   17,   24,   31,   38,   45,
+			52,   57,   62,   69,   76,   83,   90,   97,
+			104,  109,  114,  121,  128,  135,  142,  142,
+			142,  147,  152,  159,  166,  173,  180,  180,
+			180,  185,  190,  197,  204,  211,  218,  225,
+			232,  237,  242,  249,  256,  263,  270,  277,
+			284,  289,  294,  301,  308,  315,  322,  329,
+			336,  341,  346,  353,  360,  367,  374,  381,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,  388,  388,  388,  388,  388,  388,  388,
+			388,
+		},
+		{	/* Fourth byte 16-bit table 5. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    5,    10,   17,   24,   31,   38,   38,
+			38,   43,   48,   55,   62,   69,   76,   76,
+			76,   81,   86,   93,   100,  107,  114,  121,
+			128,  128,  133,  133,  140,  140,  147,  147,
+			154,  159,  164,  171,  178,  185,  192,  199,
+			206,  211,  216,  223,  230,  237,  244,  251,
+			258,  263,  268,  273,  278,  283,  288,  293,
+			298,  303,  308,  313,  318,  323,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,  328,  328,  328,  328,  328,  328,  328,
+			328,
+		},
+		{	/* Fourth byte 16-bit table 6. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    7,    14,   23,   32,   41,   50,   59,
+			68,   75,   82,   91,   100,  109,  118,  127,
+			136,  143,  150,  159,  168,  177,  186,  195,
+			204,  211,  218,  227,  236,  245,  254,  263,
+			272,  279,  286,  295,  304,  313,  322,  331,
+			340,  347,  354,  363,  372,  381,  390,  399,
+			408,  413,  418,  425,  430,  437,  437,  442,
+			449,  454,  459,  464,  469,  474,  477,  480,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,  483,  483,  483,  483,  483,  483,  483,
+			483,
+		},
+		{	/* Fourth byte 16-bit table 7. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    3,    14,   21,   26,   33,   33,   38,
+			45,   50,   55,   60,   65,   70,   82,   94,
+			106,  111,  116,  123,  130,  130,  130,  135,
+			142,  147,  152,  157,  162,  162,  174,  186,
+			198,  203,  208,  215,  222,  227,  232,  237,
+			244,  249,  254,  259,  264,  269,  280,  291,
+			293,  293,  293,  300,  305,  312,  312,  317,
+			324,  329,  334,  339,  344,  349,  356,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,  359,  359,  359,  359,  359,  359,  359,
+			359,
+		},
+		{	/* Fourth byte 16-bit table 8. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    5,    10,   15,   20,   25,   30,   35,
+			40,   45,   50,   55,   60,   65,   70,   78,
+			86,   94,   102,  110,  118,  126,  134,  142,
+			150,  158,  166,  174,  182,  190,  207,  221,
+			221,  226,  231,  236,  241,  246,  251,  256,
+			261,  266,  271,  276,  281,  286,  291,  296,
+			301,  306,  311,  316,  321,  326,  331,  336,
+			341,  346,  351,  356,  361,  366,  371,  376,
+			381,  381,  381,  381,  381,  381,  381,  381,
+			381,  381,  381,  381,  381,  381,  381,  381,
+			381,  381,  381,  381,  381,  381,  381,  381,
+			381,  381,  381,  381,  381,  381,  381,  381,
+			381,  381,  381,  381,  381,  381,  381,  381,
+			381,  381,  381,  381,  381,  381,  381,  381,
+			381,  381,  381,  381,  381,  381,  381,  381,
+			381,  381,  381,  381,  381,  381,  381,  381,
+			381,
+		},
+		{	/* Fourth byte 16-bit table 9. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    15,   27,   42,   51,   66,   75,   84,
+			102,  114,  123,  132,  141,  153,  165,  177,
+			189,  201,  213,  225,  243,  249,  267,  285,
+			300,  312,  330,  348,  360,  369,  378,  390,
+			402,  417,  432,  441,  450,  462,  471,  480,
+			486,  492,  501,  510,  528,  540,  555,  573,
+			585,  594,  603,  621,  633,  651,  660,  675,
+			684,  696,  705,  717,  732,  744,  759,  771,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,  777,  777,  777,  777,  777,  777,  777,
+			777,
+		},
+		{	/* Fourth byte 16-bit table 10. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    15,   24,   33,   45,   54,   63,   72,
+			87,   99,   105,  123,  132,  147,  159,  171,
+			180,  189,  201,  207,  219,  234,  240,  258,
+			267,  271,  275,  279,  283,  287,  291,  295,
+			299,  303,  307,  312,  317,  322,  327,  332,
+			337,  342,  347,  352,  357,  362,  367,  372,
+			377,  382,  385,  387,  389,  392,  394,  396,
+			398,  401,  404,  406,  412,  418,  424,  430,
+			442,  442,  442,  442,  442,  442,  442,  442,
+			442,  442,  442,  442,  442,  442,  442,  442,
+			442,  442,  442,  442,  442,  442,  442,  442,
+			442,  442,  442,  442,  442,  442,  442,  442,
+			442,  442,  442,  442,  442,  442,  442,  442,
+			442,  442,  442,  442,  442,  442,  442,  442,
+			442,  442,  442,  442,  442,  442,  442,  442,
+			442,  442,  442,  442,  442,  442,  442,  442,
+			442,
+		},
+		{	/* Fourth byte 16-bit table 11. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 12. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 13. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 14. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 15. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			128,  132,  136,  140,  144,  148,  152,  156,
+			160,  164,  168,  172,  176,  180,  184,  188,
+			192,  196,  200,  204,  208,  212,  216,  220,
+			224,  228,  232,  236,  240,  244,  248,  252,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,  256,  256,  256,  256,  256,  256,  256,
+			256,
+		},
+		{	/* Fourth byte 16-bit table 16. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    6,    12,   18,   24,   30,   34,   38,
+			42,   46,   50,   54,   58,   62,   66,   70,
+			74,   78,   82,   86,   90,   94,   98,   102,
+			106,  110,  114,  118,  122,  126,  130,  134,
+			138,  142,  146,  150,  154,  158,  162,  166,
+			170,  174,  178,  182,  186,  190,  194,  198,
+			202,  206,  210,  214,  218,  222,  226,  230,
+			234,  238,  242,  246,  250,  254,  258,  262,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,
+		},
+		{	/* Fourth byte 16-bit table 17. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  125,
+			130,  135,  140,  145,  150,  156,  162,  168,
+			174,  180,  186,  190,  194,  198,  202,  206,
+			210,  214,  218,  222,  226,  230,  234,  238,
+			242,  246,  250,  254,  258,  262,  266,  270,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,  274,  274,  274,  274,  274,  274,  274,
+			274,
+		},
+		{	/* Fourth byte 16-bit table 18. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			98,   104,  110,  116,  122,  126,  130,  134,
+			138,  142,  146,  150,  154,  158,  162,  166,
+			170,  174,  178,  182,  186,  190,  194,  198,
+			202,  206,  210,  214,  218,  222,  226,  230,
+			234,  238,  242,  246,  250,  254,  258,  262,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,
+		},
+		{	/* Fourth byte 16-bit table 19. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  104,  108,  112,  116,  120,  124,
+			130,  136,  140,  144,  148,  152,  156,  160,
+			164,  168,  172,  176,  180,  184,  188,  192,
+			196,  200,  204,  210,  216,  222,  226,  230,
+			234,  238,  242,  246,  250,  254,  258,  262,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,  266,  266,  266,  266,  266,  266,  266,
+			266,
+		},
+		{	/* Fourth byte 16-bit table 20. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    6,    12,   18,   24,   30,   36,   42,
+			48,   54,   60,   66,   72,   78,   84,   90,
+			96,   102,  108,  114,  120,  126,  132,  138,
+			144,  150,  156,  162,  168,  174,  180,  186,
+			192,  198,  204,  210,  216,  222,  228,  234,
+			240,  246,  252,  258,  264,  270,  276,  282,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,  288,  288,  288,  288,  288,  288,  288,
+			288,
+		},
+		{	/* Fourth byte 16-bit table 21. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    6,    12,   18,   24,   30,   36,   42,
+			48,   54,   60,   66,   72,   78,   84,   90,
+			96,   96,   96,   102,  108,  114,  120,  126,
+			132,  138,  144,  150,  156,  162,  168,  174,
+			180,  186,  192,  198,  204,  210,  216,  222,
+			228,  234,  240,  246,  252,  258,  264,  270,
+			276,  282,  288,  294,  300,  306,  312,  318,
+			324,  330,  336,  342,  348,  354,  360,  366,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,  372,  372,  372,  372,  372,  372,  372,
+			372,
+		},
+		{	/* Fourth byte 16-bit table 22. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   17,   21,   25,   29,
+			33,   37,   41,   45,   49,   53,   58,   62,
+			66,   70,   74,   79,   83,   87,   91,   96,
+			100,  104,  108,  112,  116,  121,  125,  129,
+			133,  137,  141,  145,  149,  153,  157,  161,
+			165,  169,  173,  177,  181,  185,  189,  193,
+			197,  201,  205,  209,  213,  218,  222,  226,
+			230,  235,  239,  243,  247,  251,  255,  259,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,
+		},
+		{	/* Fourth byte 16-bit table 23. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   44,   48,   52,   56,   60,
+			64,   68,   72,   76,   80,   84,   88,   92,
+			96,   100,  105,  109,  113,  117,  121,  125,
+			129,  134,  139,  143,  147,  151,  155,  159,
+			163,  167,  171,  175,  179,  184,  188,  192,
+			196,  200,  205,  209,  213,  217,  221,  225,
+			229,  233,  237,  241,  246,  250,  255,  259,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,  263,  263,  263,  263,  263,  263,  263,
+			263,
+		},
+		{	/* Fourth byte 16-bit table 24. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   41,   45,   49,   53,   57,   61,
+			66,   70,   75,   80,   84,   88,   92,   96,
+			101,  106,  110,  114,  118,  122,  126,  130,
+			134,  138,  142,  146,  150,  155,  159,  163,
+			167,  171,  175,  179,  183,  187,  191,  195,
+			199,  203,  207,  211,  215,  219,  223,  227,
+			231,  236,  240,  244,  248,  252,  256,  261,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,
+		},
+		{	/* Fourth byte 16-bit table 25. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   28,
+			32,   36,   40,   45,   49,   53,   57,   61,
+			65,   69,   73,   77,   81,   85,   89,   93,
+			97,   101,  105,  109,  113,  117,  122,  126,
+			130,  134,  138,  142,  147,  151,  155,  159,
+			163,  167,  171,  175,  179,  184,  188,  192,
+			196,  201,  205,  209,  213,  217,  221,  225,
+			230,  235,  240,  244,  249,  253,  257,  261,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,  265,  265,  265,  265,  265,  265,  265,
+			265,
+		},
+		{	/* Fourth byte 16-bit table 26. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   24,   29,
+			33,   37,   41,   45,   49,   53,   58,   62,
+			66,   71,   76,   80,   84,   88,   92,   96,
+			100,  104,  108,  112,  117,  121,  126,  130,
+			135,  139,  143,  147,  152,  156,  160,  165,
+			170,  174,  178,  182,  186,  190,  194,  198,
+			202,  206,  210,  214,  218,  222,  227,  231,
+			236,  240,  245,  249,  254,  259,  264,  268,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,
+		},
+		{	/* Fourth byte 16-bit table 27. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    9,    14,   19,   24,   28,   32,
+			36,   40,   44,   48,   52,   56,   61,   65,
+			69,   73,   77,   82,   86,   91,   96,   100,
+			104,  108,  112,  116,  120,  125,  130,  135,
+			139,  143,  148,  152,  156,  160,  165,  169,
+			173,  177,  181,  185,  190,  194,  198,  202,
+			206,  210,  214,  219,  224,  228,  233,  237,
+			242,  246,  250,  254,  259,  264,  268,  273,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,  277,  277,  277,  277,  277,  277,  277,
+			277,
+		},
+		{	/* Fourth byte 16-bit table 28. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    5,    9,    13,   17,   21,   25,   29,
+			34,   39,   44,   49,   53,   57,   61,   65,
+			69,   73,   77,   81,   85,   89,   93,   97,
+			102,  106,  110,  114,  118,  122,  126,  130,
+			134,  138,  142,  146,  150,  155,  160,  165,
+			169,  173,  177,  181,  186,  190,  195,  199,
+			203,  208,  213,  217,  221,  225,  229,  233,
+			237,  241,  245,  249,  253,  257,  261,  265,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,  269,  269,  269,  269,  269,  269,  269,
+			269,
+		},
+		{	/* Fourth byte 16-bit table 29. */
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    0,    0,    0,    0,    0,    0,    0,
+			0,    4,    8,    12,   16,   20,   25,   29,
+			33,   37,   41,   45,   50,   55,   59,   63,
+			67,   71,   75,   79,   84,   88,   92,   96,
+			100,  105,  110,  114,  118,  122,  127,  131,
+			135,  140,  145,  149,  153,  157,  162,  166,
+			170,  174,  178,  182,  186,  190,  195,  199,
+			203,  207,  212,  216,  220,  224,  228,  233,
+			238,  242,  246,  250,  255,  259,  264,  268,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,  272,  272,  272,  272,  272,  272,  272,
+			272,
+		},
+	},
+};
+
+static const uchar_t u8_decomp_final_tbl[2][19370] = {
+	{
+		0x20, 0x20, 0xCC, 0x88, 0x61, 0x20, 0xCC, 0x84,
+		0x32, 0x33, 0x20, 0xCC, 0x81, 0xCE, 0xBC, 0x20,
+		0xCC, 0xA7, 0x31, 0x6F, 0x31, 0xE2, 0x81, 0x84,
+		0x34, 0x31, 0xE2, 0x81, 0x84, 0x32, 0x33, 0xE2,
+		0x81, 0x84, 0x34, 0xF6, 0x41, 0xCC, 0x80, 0xF6,
+		0x41, 0xCC, 0x81, 0xF6, 0x41, 0xCC, 0x82, 0xF6,
+		0x41, 0xCC, 0x83, 0xF6, 0x41, 0xCC, 0x88, 0xF6,
+		0x41, 0xCC, 0x8A, 0xF6, 0x43, 0xCC, 0xA7, 0xF6,
+		0x45, 0xCC, 0x80, 0xF6, 0x45, 0xCC, 0x81, 0xF6,
+		0x45, 0xCC, 0x82, 0xF6, 0x45, 0xCC, 0x88, 0xF6,
+		0x49, 0xCC, 0x80, 0xF6, 0x49, 0xCC, 0x81, 0xF6,
+		0x49, 0xCC, 0x82, 0xF6, 0x49, 0xCC, 0x88, 0xF6,
+		0x4E, 0xCC, 0x83, 0xF6, 0x4F, 0xCC, 0x80, 0xF6,
+		0x4F, 0xCC, 0x81, 0xF6, 0x4F, 0xCC, 0x82, 0xF6,
+		0x4F, 0xCC, 0x83, 0xF6, 0x4F, 0xCC, 0x88, 0xF6,
+		0x55, 0xCC, 0x80, 0xF6, 0x55, 0xCC, 0x81, 0xF6,
+		0x55, 0xCC, 0x82, 0xF6, 0x55, 0xCC, 0x88, 0xF6,
+		0x59, 0xCC, 0x81, 0xF6, 0x61, 0xCC, 0x80, 0xF6,
+		0x61, 0xCC, 0x81, 0xF6, 0x61, 0xCC, 0x82, 0xF6,
+		0x61, 0xCC, 0x83, 0xF6, 0x61, 0xCC, 0x88, 0xF6,
+		0x61, 0xCC, 0x8A, 0xF6, 0x63, 0xCC, 0xA7, 0xF6,
+		0x65, 0xCC, 0x80, 0xF6, 0x65, 0xCC, 0x81, 0xF6,
+		0x65, 0xCC, 0x82, 0xF6, 0x65, 0xCC, 0x88, 0xF6,
+		0x69, 0xCC, 0x80, 0xF6, 0x69, 0xCC, 0x81, 0xF6,
+		0x69, 0xCC, 0x82, 0xF6, 0x69, 0xCC, 0x88, 0xF6,
+		0x6E, 0xCC, 0x83, 0xF6, 0x6F, 0xCC, 0x80, 0xF6,
+		0x6F, 0xCC, 0x81, 0xF6, 0x6F, 0xCC, 0x82, 0xF6,
+		0x6F, 0xCC, 0x83, 0xF6, 0x6F, 0xCC, 0x88, 0xF6,
+		0x75, 0xCC, 0x80, 0xF6, 0x75, 0xCC, 0x81, 0xF6,
+		0x75, 0xCC, 0x82, 0xF6, 0x75, 0xCC, 0x88, 0xF6,
+		0x79, 0xCC, 0x81, 0xF6, 0x79, 0xCC, 0x88, 0xF6,
+		0x41, 0xCC, 0x84, 0xF6, 0x61, 0xCC, 0x84, 0xF6,
+		0x41, 0xCC, 0x86, 0xF6, 0x61, 0xCC, 0x86, 0xF6,
+		0x41, 0xCC, 0xA8, 0xF6, 0x61, 0xCC, 0xA8, 0xF6,
+		0x43, 0xCC, 0x81, 0xF6, 0x63, 0xCC, 0x81, 0xF6,
+		0x43, 0xCC, 0x82, 0xF6, 0x63, 0xCC, 0x82, 0xF6,
+		0x43, 0xCC, 0x87, 0xF6, 0x63, 0xCC, 0x87, 0xF6,
+		0x43, 0xCC, 0x8C, 0xF6, 0x63, 0xCC, 0x8C, 0xF6,
+		0x44, 0xCC, 0x8C, 0xF6, 0x64, 0xCC, 0x8C, 0xF6,
+		0x45, 0xCC, 0x84, 0xF6, 0x65, 0xCC, 0x84, 0xF6,
+		0x45, 0xCC, 0x86, 0xF6, 0x65, 0xCC, 0x86, 0xF6,
+		0x45, 0xCC, 0x87, 0xF6, 0x65, 0xCC, 0x87, 0xF6,
+		0x45, 0xCC, 0xA8, 0xF6, 0x65, 0xCC, 0xA8, 0xF6,
+		0x45, 0xCC, 0x8C, 0xF6, 0x65, 0xCC, 0x8C, 0xF6,
+		0x47, 0xCC, 0x82, 0xF6, 0x67, 0xCC, 0x82, 0xF6,
+		0x47, 0xCC, 0x86, 0xF6, 0x67, 0xCC, 0x86, 0xF6,
+		0x47, 0xCC, 0x87, 0xF6, 0x67, 0xCC, 0x87, 0xF6,
+		0x47, 0xCC, 0xA7, 0xF6, 0x67, 0xCC, 0xA7, 0xF6,
+		0x48, 0xCC, 0x82, 0xF6, 0x68, 0xCC, 0x82, 0xF6,
+		0x49, 0xCC, 0x83, 0xF6, 0x69, 0xCC, 0x83, 0xF6,
+		0x49, 0xCC, 0x84, 0xF6, 0x69, 0xCC, 0x84, 0xF6,
+		0x49, 0xCC, 0x86, 0xF6, 0x69, 0xCC, 0x86, 0xF6,
+		0x49, 0xCC, 0xA8, 0xF6, 0x69, 0xCC, 0xA8, 0xF6,
+		0x49, 0xCC, 0x87, 0x49, 0x4A, 0x69, 0x6A, 0xF6,
+		0x4A, 0xCC, 0x82, 0xF6, 0x6A, 0xCC, 0x82, 0xF6,
+		0x4B, 0xCC, 0xA7, 0xF6, 0x6B, 0xCC, 0xA7, 0xF6,
+		0x4C, 0xCC, 0x81, 0xF6, 0x6C, 0xCC, 0x81, 0xF6,
+		0x4C, 0xCC, 0xA7, 0xF6, 0x6C, 0xCC, 0xA7, 0xF6,
+		0x4C, 0xCC, 0x8C, 0xF6, 0x6C, 0xCC, 0x8C, 0x4C,
+		0xC2, 0xB7, 0x6C, 0xC2, 0xB7, 0xF6, 0x4E, 0xCC,
+		0x81, 0xF6, 0x6E, 0xCC, 0x81, 0xF6, 0x4E, 0xCC,
+		0xA7, 0xF6, 0x6E, 0xCC, 0xA7, 0xF6, 0x4E, 0xCC,
+		0x8C, 0xF6, 0x6E, 0xCC, 0x8C, 0xCA, 0xBC, 0x6E,
+		0xF6, 0x4F, 0xCC, 0x84, 0xF6, 0x6F, 0xCC, 0x84,
+		0xF6, 0x4F, 0xCC, 0x86, 0xF6, 0x6F, 0xCC, 0x86,
+		0xF6, 0x4F, 0xCC, 0x8B, 0xF6, 0x6F, 0xCC, 0x8B,
+		0xF6, 0x52, 0xCC, 0x81, 0xF6, 0x72, 0xCC, 0x81,
+		0xF6, 0x52, 0xCC, 0xA7, 0xF6, 0x72, 0xCC, 0xA7,
+		0xF6, 0x52, 0xCC, 0x8C, 0xF6, 0x72, 0xCC, 0x8C,
+		0xF6, 0x53, 0xCC, 0x81, 0xF6, 0x73, 0xCC, 0x81,
+		0xF6, 0x53, 0xCC, 0x82, 0xF6, 0x73, 0xCC, 0x82,
+		0xF6, 0x53, 0xCC, 0xA7, 0xF6, 0x73, 0xCC, 0xA7,
+		0xF6, 0x53, 0xCC, 0x8C, 0xF6, 0x73, 0xCC, 0x8C,
+		0xF6, 0x54, 0xCC, 0xA7, 0xF6, 0x74, 0xCC, 0xA7,
+		0xF6, 0x54, 0xCC, 0x8C, 0xF6, 0x74, 0xCC, 0x8C,
+		0xF6, 0x55, 0xCC, 0x83, 0xF6, 0x75, 0xCC, 0x83,
+		0xF6, 0x55, 0xCC, 0x84, 0xF6, 0x75, 0xCC, 0x84,
+		0xF6, 0x55, 0xCC, 0x86, 0xF6, 0x75, 0xCC, 0x86,
+		0xF6, 0x55, 0xCC, 0x8A, 0xF6, 0x75, 0xCC, 0x8A,
+		0xF6, 0x55, 0xCC, 0x8B, 0xF6, 0x75, 0xCC, 0x8B,
+		0xF6, 0x55, 0xCC, 0xA8, 0xF6, 0x75, 0xCC, 0xA8,
+		0xF6, 0x57, 0xCC, 0x82, 0xF6, 0x77, 0xCC, 0x82,
+		0xF6, 0x59, 0xCC, 0x82, 0xF6, 0x79, 0xCC, 0x82,
+		0xF6, 0x59, 0xCC, 0x88, 0xF6, 0x5A, 0xCC, 0x81,
+		0xF6, 0x7A, 0xCC, 0x81, 0xF6, 0x5A, 0xCC, 0x87,
+		0xF6, 0x7A, 0xCC, 0x87, 0xF6, 0x5A, 0xCC, 0x8C,
+		0xF6, 0x7A, 0xCC, 0x8C, 0x73, 0xF6, 0x4F, 0xCC,
+		0x9B, 0xF6, 0x6F, 0xCC, 0x9B, 0xF6, 0x55, 0xCC,
+		0x9B, 0xF6, 0x75, 0xCC, 0x9B, 0x44, 0x5A, 0xCC,
+		0x8C, 0x44, 0x7A, 0xCC, 0x8C, 0x64, 0x7A, 0xCC,
+		0x8C, 0x4C, 0x4A, 0x4C, 0x6A, 0x6C, 0x6A, 0x4E,
+		0x4A, 0x4E, 0x6A, 0x6E, 0x6A, 0xF6, 0x41, 0xCC,
+		0x8C, 0xF6, 0x61, 0xCC, 0x8C, 0xF6, 0x49, 0xCC,
+		0x8C, 0xF6, 0x69, 0xCC, 0x8C, 0xF6, 0x4F, 0xCC,
+		0x8C, 0xF6, 0x6F, 0xCC, 0x8C, 0xF6, 0x55, 0xCC,
+		0x8C, 0xF6, 0x75, 0xCC, 0x8C, 0xF6, 0x55, 0xCC,
+		0x88, 0xCC, 0x84, 0xF6, 0x75, 0xCC, 0x88, 0xCC,
+		0x84, 0xF6, 0x55, 0xCC, 0x88, 0xCC, 0x81, 0xF6,
+		0x75, 0xCC, 0x88, 0xCC, 0x81, 0xF6, 0x55, 0xCC,
+		0x88, 0xCC, 0x8C, 0xF6, 0x75, 0xCC, 0x88, 0xCC,
+		0x8C, 0xF6, 0x55, 0xCC, 0x88, 0xCC, 0x80, 0xF6,
+		0x75, 0xCC, 0x88, 0xCC, 0x80, 0xF6, 0x41, 0xCC,
+		0x88, 0xCC, 0x84, 0xF6, 0x61, 0xCC, 0x88, 0xCC,
+		0x84, 0xF6, 0x41, 0xCC, 0x87, 0xCC, 0x84, 0xF6,
+		0x61, 0xCC, 0x87, 0xCC, 0x84, 0xF6, 0xC3, 0x86,
+		0xCC, 0x84, 0xF6, 0xC3, 0xA6, 0xCC, 0x84, 0xF6,
+		0x47, 0xCC, 0x8C, 0xF6, 0x67, 0xCC, 0x8C, 0xF6,
+		0x4B, 0xCC, 0x8C, 0xF6, 0x6B, 0xCC, 0x8C, 0xF6,
+		0x4F, 0xCC, 0xA8, 0xF6, 0x6F, 0xCC, 0xA8, 0xF6,
+		0x4F, 0xCC, 0xA8, 0xCC, 0x84, 0xF6, 0x6F, 0xCC,
+		0xA8, 0xCC, 0x84, 0xF6, 0xC6, 0xB7, 0xCC, 0x8C,
+		0xF6, 0xCA, 0x92, 0xCC, 0x8C, 0xF6, 0x6A, 0xCC,
+		0x8C, 0x44, 0x5A, 0x44, 0x7A, 0x64, 0x7A, 0xF6,
+		0x47, 0xCC, 0x81, 0xF6, 0x67, 0xCC, 0x81, 0xF6,
+		0x4E, 0xCC, 0x80, 0xF6, 0x6E, 0xCC, 0x80, 0xF6,
+		0x41, 0xCC, 0x8A, 0xCC, 0x81, 0xF6, 0x61, 0xCC,
+		0x8A, 0xCC, 0x81, 0xF6, 0xC3, 0x86, 0xCC, 0x81,
+		0xF6, 0xC3, 0xA6, 0xCC, 0x81, 0xF6, 0xC3, 0x98,
+		0xCC, 0x81, 0xF6, 0xC3, 0xB8, 0xCC, 0x81, 0xF6,
+		0x41, 0xCC, 0x8F, 0xF6, 0x61, 0xCC, 0x8F, 0xF6,
+		0x41, 0xCC, 0x91, 0xF6, 0x61, 0xCC, 0x91, 0xF6,
+		0x45, 0xCC, 0x8F, 0xF6, 0x65, 0xCC, 0x8F, 0xF6,
+		0x45, 0xCC, 0x91, 0xF6, 0x65, 0xCC, 0x91, 0xF6,
+		0x49, 0xCC, 0x8F, 0xF6, 0x69, 0xCC, 0x8F, 0xF6,
+		0x49, 0xCC, 0x91, 0xF6, 0x69, 0xCC, 0x91, 0xF6,
+		0x4F, 0xCC, 0x8F, 0xF6, 0x6F, 0xCC, 0x8F, 0xF6,
+		0x4F, 0xCC, 0x91, 0xF6, 0x6F, 0xCC, 0x91, 0xF6,
+		0x52, 0xCC, 0x8F, 0xF6, 0x72, 0xCC, 0x8F, 0xF6,
+		0x52, 0xCC, 0x91, 0xF6, 0x72, 0xCC, 0x91, 0xF6,
+		0x55, 0xCC, 0x8F, 0xF6, 0x75, 0xCC, 0x8F, 0xF6,
+		0x55, 0xCC, 0x91, 0xF6, 0x75, 0xCC, 0x91, 0xF6,
+		0x53, 0xCC, 0xA6, 0xF6, 0x73, 0xCC, 0xA6, 0xF6,
+		0x54, 0xCC, 0xA6, 0xF6, 0x74, 0xCC, 0xA6, 0xF6,
+		0x48, 0xCC, 0x8C, 0xF6, 0x68, 0xCC, 0x8C, 0xF6,
+		0x41, 0xCC, 0x87, 0xF6, 0x61, 0xCC, 0x87, 0xF6,
+		0x45, 0xCC, 0xA7, 0xF6, 0x65, 0xCC, 0xA7, 0xF6,
+		0x4F, 0xCC, 0x88, 0xCC, 0x84, 0xF6, 0x6F, 0xCC,
+		0x88, 0xCC, 0x84, 0xF6, 0x4F, 0xCC, 0x83, 0xCC,
+		0x84, 0xF6, 0x6F, 0xCC, 0x83, 0xCC, 0x84, 0xF6,
+		0x4F, 0xCC, 0x87, 0xF6, 0x6F, 0xCC, 0x87, 0xF6,
+		0x4F, 0xCC, 0x87, 0xCC, 0x84, 0xF6, 0x6F, 0xCC,
+		0x87, 0xCC, 0x84, 0xF6, 0x59, 0xCC, 0x84, 0xF6,
+		0x79, 0xCC, 0x84, 0x68, 0xC9, 0xA6, 0x6A, 0x72,
+		0xC9, 0xB9, 0xC9, 0xBB, 0xCA, 0x81, 0x77, 0x79,
+		0x20, 0xCC, 0x86, 0x20, 0xCC, 0x87, 0x20, 0xCC,
+		0x8A, 0x20, 0xCC, 0xA8, 0x20, 0xCC, 0x83, 0x20,
+		0xCC, 0x8B, 0xC9, 0xA3, 0x6C, 0x73, 0x78, 0xCA,
+		0x95, 0xF6, 0xCC, 0x80, 0xF6, 0xCC, 0x81, 0xF6,
+		0xCC, 0x93, 0xF6, 0xCC, 0x88, 0xCC, 0x81, 0xF6,
+		0xCA, 0xB9, 0x20, 0xCD, 0x85, 0xF6, 0x3B, 0x20,
+		0xCC, 0x81, 0xF5, 0x05, 0xC2, 0xA8, 0xCC, 0x81,
+		0x20, 0xCC, 0x88, 0xCC, 0x81, 0xF6, 0xCE, 0x91,
+		0xCC, 0x81, 0xF6, 0xC2, 0xB7, 0xF6, 0xCE, 0x95,
+		0xCC, 0x81, 0xF6, 0xCE, 0x97, 0xCC, 0x81, 0xF6,
+		0xCE, 0x99, 0xCC, 0x81, 0xF6, 0xCE, 0x9F, 0xCC,
+		0x81, 0xF6, 0xCE, 0xA5, 0xCC, 0x81, 0xF6, 0xCE,
+		0xA9, 0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCC, 0x88,
+		0xCC, 0x81, 0xF6, 0xCE, 0x99, 0xCC, 0x88, 0xF6,
+		0xCE, 0xA5, 0xCC, 0x88, 0xF6, 0xCE, 0xB1, 0xCC,
+		0x81, 0xF6, 0xCE, 0xB5, 0xCC, 0x81, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCC, 0x81,
+		0xF6, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xF6,
+		0xCE, 0xB9, 0xCC, 0x88, 0xF6, 0xCF, 0x85, 0xCC,
+		0x88, 0xF6, 0xCE, 0xBF, 0xCC, 0x81, 0xF6, 0xCF,
+		0x85, 0xCC, 0x81, 0xF6, 0xCF, 0x89, 0xCC, 0x81,
+		0xCE, 0xB2, 0xCE, 0xB8, 0xCE, 0xA5, 0xF5, 0x05,
+		0xCF, 0x92, 0xCC, 0x81, 0xCE, 0xA5, 0xCC, 0x81,
+		0xF5, 0x05, 0xCF, 0x92, 0xCC, 0x88, 0xCE, 0xA5,
+		0xCC, 0x88, 0xCF, 0x86, 0xCF, 0x80, 0xCE, 0xBA,
+		0xCF, 0x81, 0xCF, 0x82, 0xCE, 0x98, 0xCE, 0xB5,
+		0xF6, 0xD0, 0x95, 0xCC, 0x80, 0xF6, 0xD0, 0x95,
+		0xCC, 0x88, 0xF6, 0xD0, 0x93, 0xCC, 0x81, 0xF6,
+		0xD0, 0x86, 0xCC, 0x88, 0xF6, 0xD0, 0x9A, 0xCC,
+		0x81, 0xF6, 0xD0, 0x98, 0xCC, 0x80, 0xF6, 0xD0,
+		0xA3, 0xCC, 0x86, 0xF6, 0xD0, 0x98, 0xCC, 0x86,
+		0xF6, 0xD0, 0xB8, 0xCC, 0x86, 0xF6, 0xD0, 0xB5,
+		0xCC, 0x80, 0xF6, 0xD0, 0xB5, 0xCC, 0x88, 0xF6,
+		0xD0, 0xB3, 0xCC, 0x81, 0xF6, 0xD1, 0x96, 0xCC,
+		0x88, 0xF6, 0xD0, 0xBA, 0xCC, 0x81, 0xF6, 0xD0,
+		0xB8, 0xCC, 0x80, 0xF6, 0xD1, 0x83, 0xCC, 0x86,
+		0xF6, 0xD1, 0xB4, 0xCC, 0x8F, 0xF6, 0xD1, 0xB5,
+		0xCC, 0x8F, 0xF6, 0xD0, 0x96, 0xCC, 0x86, 0xF6,
+		0xD0, 0xB6, 0xCC, 0x86, 0xF6, 0xD0, 0x90, 0xCC,
+		0x86, 0xF6, 0xD0, 0xB0, 0xCC, 0x86, 0xF6, 0xD0,
+		0x90, 0xCC, 0x88, 0xF6, 0xD0, 0xB0, 0xCC, 0x88,
+		0xF6, 0xD0, 0x95, 0xCC, 0x86, 0xF6, 0xD0, 0xB5,
+		0xCC, 0x86, 0xF6, 0xD3, 0x98, 0xCC, 0x88, 0xF6,
+		0xD3, 0x99, 0xCC, 0x88, 0xF6, 0xD0, 0x96, 0xCC,
+		0x88, 0xF6, 0xD0, 0xB6, 0xCC, 0x88, 0xF6, 0xD0,
+		0x97, 0xCC, 0x88, 0xF6, 0xD0, 0xB7, 0xCC, 0x88,
+		0xF6, 0xD0, 0x98, 0xCC, 0x84, 0xF6, 0xD0, 0xB8,
+		0xCC, 0x84, 0xF6, 0xD0, 0x98, 0xCC, 0x88, 0xF6,
+		0xD0, 0xB8, 0xCC, 0x88, 0xF6, 0xD0, 0x9E, 0xCC,
+		0x88, 0xF6, 0xD0, 0xBE, 0xCC, 0x88, 0xF6, 0xD3,
+		0xA8, 0xCC, 0x88, 0xF6, 0xD3, 0xA9, 0xCC, 0x88,
+		0xF6, 0xD0, 0xAD, 0xCC, 0x88, 0xF6, 0xD1, 0x8D,
+		0xCC, 0x88, 0xF6, 0xD0, 0xA3, 0xCC, 0x84, 0xF6,
+		0xD1, 0x83, 0xCC, 0x84, 0xF6, 0xD0, 0xA3, 0xCC,
+		0x88, 0xF6, 0xD1, 0x83, 0xCC, 0x88, 0xF6, 0xD0,
+		0xA3, 0xCC, 0x8B, 0xF6, 0xD1, 0x83, 0xCC, 0x8B,
+		0xF6, 0xD0, 0xA7, 0xCC, 0x88, 0xF6, 0xD1, 0x87,
+		0xCC, 0x88, 0xF6, 0xD0, 0xAB, 0xCC, 0x88, 0xF6,
+		0xD1, 0x8B, 0xCC, 0x88, 0xD5, 0xA5, 0xD6, 0x82,
+		0xF6, 0xD8, 0xA7, 0xD9, 0x93, 0xF6, 0xD8, 0xA7,
+		0xD9, 0x94, 0xF6, 0xD9, 0x88, 0xD9, 0x94, 0xF6,
+		0xD8, 0xA7, 0xD9, 0x95, 0xF6, 0xD9, 0x8A, 0xD9,
+		0x94, 0xD8, 0xA7, 0xD9, 0xB4, 0xD9, 0x88, 0xD9,
+		0xB4, 0xDB, 0x87, 0xD9, 0xB4, 0xD9, 0x8A, 0xD9,
+		0xB4, 0xF6, 0xDB, 0x95, 0xD9, 0x94, 0xF6, 0xDB,
+		0x81, 0xD9, 0x94, 0xF6, 0xDB, 0x92, 0xD9, 0x94,
+		0xF6, 0xE0, 0xA4, 0xA8, 0xE0, 0xA4, 0xBC, 0xF6,
+		0xE0, 0xA4, 0xB0, 0xE0, 0xA4, 0xBC, 0xF6, 0xE0,
+		0xA4, 0xB3, 0xE0, 0xA4, 0xBC, 0xF6, 0xE0, 0xA4,
+		0x95, 0xE0, 0xA4, 0xBC, 0xF6, 0xE0, 0xA4, 0x96,
+		0xE0, 0xA4, 0xBC, 0xF6, 0xE0, 0xA4, 0x97, 0xE0,
+		0xA4, 0xBC, 0xF6, 0xE0, 0xA4, 0x9C, 0xE0, 0xA4,
+		0xBC, 0xF6, 0xE0, 0xA4, 0xA1, 0xE0, 0xA4, 0xBC,
+		0xF6, 0xE0, 0xA4, 0xA2, 0xE0, 0xA4, 0xBC, 0xF6,
+		0xE0, 0xA4, 0xAB, 0xE0, 0xA4, 0xBC, 0xF6, 0xE0,
+		0xA4, 0xAF, 0xE0, 0xA4, 0xBC, 0xF6, 0xE0, 0xA7,
+		0x87, 0xE0, 0xA6, 0xBE, 0xF6, 0xE0, 0xA7, 0x87,
+		0xE0, 0xA7, 0x97, 0xF6, 0xE0, 0xA6, 0xA1, 0xE0,
+		0xA6, 0xBC, 0xF6, 0xE0, 0xA6, 0xA2, 0xE0, 0xA6,
+		0xBC, 0xF6, 0xE0, 0xA6, 0xAF, 0xE0, 0xA6, 0xBC,
+		0xF6, 0xE0, 0xA8, 0xB2, 0xE0, 0xA8, 0xBC, 0xF6,
+		0xE0, 0xA8, 0xB8, 0xE0, 0xA8, 0xBC, 0xF6, 0xE0,
+		0xA8, 0x96, 0xE0, 0xA8, 0xBC, 0xF6, 0xE0, 0xA8,
+		0x97, 0xE0, 0xA8, 0xBC, 0xF6, 0xE0, 0xA8, 0x9C,
+		0xE0, 0xA8, 0xBC, 0xF6, 0xE0, 0xA8, 0xAB, 0xE0,
+		0xA8, 0xBC, 0xF6, 0xE0, 0xAD, 0x87, 0xE0, 0xAD,
+		0x96, 0xF6, 0xE0, 0xAD, 0x87, 0xE0, 0xAC, 0xBE,
+		0xF6, 0xE0, 0xAD, 0x87, 0xE0, 0xAD, 0x97, 0xF6,
+		0xE0, 0xAC, 0xA1, 0xE0, 0xAC, 0xBC, 0xF6, 0xE0,
+		0xAC, 0xA2, 0xE0, 0xAC, 0xBC, 0xF6, 0xE0, 0xAE,
+		0x92, 0xE0, 0xAF, 0x97, 0xF6, 0xE0, 0xAF, 0x86,
+		0xE0, 0xAE, 0xBE, 0xF6, 0xE0, 0xAF, 0x87, 0xE0,
+		0xAE, 0xBE, 0xF6, 0xE0, 0xAF, 0x86, 0xE0, 0xAF,
+		0x97, 0xF6, 0xE0, 0xB1, 0x86, 0xE0, 0xB1, 0x96,
+		0xF6, 0xE0, 0xB2, 0xBF, 0xE0, 0xB3, 0x95, 0xF6,
+		0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x95, 0xF6, 0xE0,
+		0xB3, 0x86, 0xE0, 0xB3, 0x96, 0xF6, 0xE0, 0xB3,
+		0x86, 0xE0, 0xB3, 0x82, 0xF6, 0xE0, 0xB3, 0x86,
+		0xE0, 0xB3, 0x82, 0xE0, 0xB3, 0x95, 0xF6, 0xE0,
+		0xB5, 0x86, 0xE0, 0xB4, 0xBE, 0xF6, 0xE0, 0xB5,
+		0x87, 0xE0, 0xB4, 0xBE, 0xF6, 0xE0, 0xB5, 0x86,
+		0xE0, 0xB5, 0x97, 0xF6, 0xE0, 0xB7, 0x99, 0xE0,
+		0xB7, 0x8A, 0xF6, 0xE0, 0xB7, 0x99, 0xE0, 0xB7,
+		0x8F, 0xF6, 0xE0, 0xB7, 0x99, 0xE0, 0xB7, 0x8F,
+		0xE0, 0xB7, 0x8A, 0xF6, 0xE0, 0xB7, 0x99, 0xE0,
+		0xB7, 0x9F, 0xE0, 0xB9, 0x8D, 0xE0, 0xB8, 0xB2,
+		0xE0, 0xBB, 0x8D, 0xE0, 0xBA, 0xB2, 0xE0, 0xBA,
+		0xAB, 0xE0, 0xBA, 0x99, 0xE0, 0xBA, 0xAB, 0xE0,
+		0xBA, 0xA1, 0xE0, 0xBC, 0x8B, 0xF6, 0xE0, 0xBD,
+		0x82, 0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBD, 0x8C,
+		0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBD, 0x91, 0xE0,
+		0xBE, 0xB7, 0xF6, 0xE0, 0xBD, 0x96, 0xE0, 0xBE,
+		0xB7, 0xF6, 0xE0, 0xBD, 0x9B, 0xE0, 0xBE, 0xB7,
+		0xF6, 0xE0, 0xBD, 0x80, 0xE0, 0xBE, 0xB5, 0xF6,
+		0xE0, 0xBD, 0xB1, 0xE0, 0xBD, 0xB2, 0xF6, 0xE0,
+		0xBD, 0xB1, 0xE0, 0xBD, 0xB4, 0xF6, 0xE0, 0xBE,
+		0xB2, 0xE0, 0xBE, 0x80, 0xE0, 0xBE, 0xB2, 0xE0,
+		0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0xF6, 0xE0, 0xBE,
+		0xB3, 0xE0, 0xBE, 0x80, 0xE0, 0xBE, 0xB3, 0xE0,
+		0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0xF6, 0xE0, 0xBD,
+		0xB1, 0xE0, 0xBE, 0x80, 0xF6, 0xE0, 0xBE, 0x92,
+		0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBE, 0x9C, 0xE0,
+		0xBE, 0xB7, 0xF6, 0xE0, 0xBE, 0xA1, 0xE0, 0xBE,
+		0xB7, 0xF6, 0xE0, 0xBE, 0xA6, 0xE0, 0xBE, 0xB7,
+		0xF6, 0xE0, 0xBE, 0xAB, 0xE0, 0xBE, 0xB7, 0xF6,
+		0xE0, 0xBE, 0x90, 0xE0, 0xBE, 0xB5, 0xF6, 0xE1,
+		0x80, 0xA5, 0xE1, 0x80, 0xAE, 0xF6, 0x41, 0xCC,
+		0xA5, 0xF6, 0x61, 0xCC, 0xA5, 0xF6, 0x42, 0xCC,
+		0x87, 0xF6, 0x62, 0xCC, 0x87, 0xF6, 0x42, 0xCC,
+		0xA3, 0xF6, 0x62, 0xCC, 0xA3, 0xF6, 0x42, 0xCC,
+		0xB1, 0xF6, 0x62, 0xCC, 0xB1, 0xF6, 0x43, 0xCC,
+		0xA7, 0xCC, 0x81, 0xF6, 0x63, 0xCC, 0xA7, 0xCC,
+		0x81, 0xF6, 0x44, 0xCC, 0x87, 0xF6, 0x64, 0xCC,
+		0x87, 0xF6, 0x44, 0xCC, 0xA3, 0xF6, 0x64, 0xCC,
+		0xA3, 0xF6, 0x44, 0xCC, 0xB1, 0xF6, 0x64, 0xCC,
+		0xB1, 0xF6, 0x44, 0xCC, 0xA7, 0xF6, 0x64, 0xCC,
+		0xA7, 0xF6, 0x44, 0xCC, 0xAD, 0xF6, 0x64, 0xCC,
+		0xAD, 0xF6, 0x45, 0xCC, 0x84, 0xCC, 0x80, 0xF6,
+		0x65, 0xCC, 0x84, 0xCC, 0x80, 0xF6, 0x45, 0xCC,
+		0x84, 0xCC, 0x81, 0xF6, 0x65, 0xCC, 0x84, 0xCC,
+		0x81, 0xF6, 0x45, 0xCC, 0xAD, 0xF6, 0x65, 0xCC,
+		0xAD, 0xF6, 0x45, 0xCC, 0xB0, 0xF6, 0x65, 0xCC,
+		0xB0, 0xF6, 0x45, 0xCC, 0xA7, 0xCC, 0x86, 0xF6,
+		0x65, 0xCC, 0xA7, 0xCC, 0x86, 0xF6, 0x46, 0xCC,
+		0x87, 0xF6, 0x66, 0xCC, 0x87, 0xF6, 0x47, 0xCC,
+		0x84, 0xF6, 0x67, 0xCC, 0x84, 0xF6, 0x48, 0xCC,
+		0x87, 0xF6, 0x68, 0xCC, 0x87, 0xF6, 0x48, 0xCC,
+		0xA3, 0xF6, 0x68, 0xCC, 0xA3, 0xF6, 0x48, 0xCC,
+		0x88, 0xF6, 0x68, 0xCC, 0x88, 0xF6, 0x48, 0xCC,
+		0xA7, 0xF6, 0x68, 0xCC, 0xA7, 0xF6, 0x48, 0xCC,
+		0xAE, 0xF6, 0x68, 0xCC, 0xAE, 0xF6, 0x49, 0xCC,
+		0xB0, 0xF6, 0x69, 0xCC, 0xB0, 0xF6, 0x49, 0xCC,
+		0x88, 0xCC, 0x81, 0xF6, 0x69, 0xCC, 0x88, 0xCC,
+		0x81, 0xF6, 0x4B, 0xCC, 0x81, 0xF6, 0x6B, 0xCC,
+		0x81, 0xF6, 0x4B, 0xCC, 0xA3, 0xF6, 0x6B, 0xCC,
+		0xA3, 0xF6, 0x4B, 0xCC, 0xB1, 0xF6, 0x6B, 0xCC,
+		0xB1, 0xF6, 0x4C, 0xCC, 0xA3, 0xF6, 0x6C, 0xCC,
+		0xA3, 0xF6, 0x4C, 0xCC, 0xA3, 0xCC, 0x84, 0xF6,
+		0x6C, 0xCC, 0xA3, 0xCC, 0x84, 0xF6, 0x4C, 0xCC,
+		0xB1, 0xF6, 0x6C, 0xCC, 0xB1, 0xF6, 0x4C, 0xCC,
+		0xAD, 0xF6, 0x6C, 0xCC, 0xAD, 0xF6, 0x4D, 0xCC,
+		0x81, 0xF6, 0x6D, 0xCC, 0x81, 0xF6, 0x4D, 0xCC,
+		0x87, 0xF6, 0x6D, 0xCC, 0x87, 0xF6, 0x4D, 0xCC,
+		0xA3, 0xF6, 0x6D, 0xCC, 0xA3, 0xF6, 0x4E, 0xCC,
+		0x87, 0xF6, 0x6E, 0xCC, 0x87, 0xF6, 0x4E, 0xCC,
+		0xA3, 0xF6, 0x6E, 0xCC, 0xA3, 0xF6, 0x4E, 0xCC,
+		0xB1, 0xF6, 0x6E, 0xCC, 0xB1, 0xF6, 0x4E, 0xCC,
+		0xAD, 0xF6, 0x6E, 0xCC, 0xAD, 0xF6, 0x4F, 0xCC,
+		0x83, 0xCC, 0x81, 0xF6, 0x6F, 0xCC, 0x83, 0xCC,
+		0x81, 0xF6, 0x4F, 0xCC, 0x83, 0xCC, 0x88, 0xF6,
+		0x6F, 0xCC, 0x83, 0xCC, 0x88, 0xF6, 0x4F, 0xCC,
+		0x84, 0xCC, 0x80, 0xF6, 0x6F, 0xCC, 0x84, 0xCC,
+		0x80, 0xF6, 0x4F, 0xCC, 0x84, 0xCC, 0x81, 0xF6,
+		0x6F, 0xCC, 0x84, 0xCC, 0x81, 0xF6, 0x50, 0xCC,
+		0x81, 0xF6, 0x70, 0xCC, 0x81, 0xF6, 0x50, 0xCC,
+		0x87, 0xF6, 0x70, 0xCC, 0x87, 0xF6, 0x52, 0xCC,
+		0x87, 0xF6, 0x72, 0xCC, 0x87, 0xF6, 0x52, 0xCC,
+		0xA3, 0xF6, 0x72, 0xCC, 0xA3, 0xF6, 0x52, 0xCC,
+		0xA3, 0xCC, 0x84, 0xF6, 0x72, 0xCC, 0xA3, 0xCC,
+		0x84, 0xF6, 0x52, 0xCC, 0xB1, 0xF6, 0x72, 0xCC,
+		0xB1, 0xF6, 0x53, 0xCC, 0x87, 0xF6, 0x73, 0xCC,
+		0x87, 0xF6, 0x53, 0xCC, 0xA3, 0xF6, 0x73, 0xCC,
+		0xA3, 0xF6, 0x53, 0xCC, 0x81, 0xCC, 0x87, 0xF6,
+		0x73, 0xCC, 0x81, 0xCC, 0x87, 0xF6, 0x53, 0xCC,
+		0x8C, 0xCC, 0x87, 0xF6, 0x73, 0xCC, 0x8C, 0xCC,
+		0x87, 0xF6, 0x53, 0xCC, 0xA3, 0xCC, 0x87, 0xF6,
+		0x73, 0xCC, 0xA3, 0xCC, 0x87, 0xF6, 0x54, 0xCC,
+		0x87, 0xF6, 0x74, 0xCC, 0x87, 0xF6, 0x54, 0xCC,
+		0xA3, 0xF6, 0x74, 0xCC, 0xA3, 0xF6, 0x54, 0xCC,
+		0xB1, 0xF6, 0x74, 0xCC, 0xB1, 0xF6, 0x54, 0xCC,
+		0xAD, 0xF6, 0x74, 0xCC, 0xAD, 0xF6, 0x55, 0xCC,
+		0xA4, 0xF6, 0x75, 0xCC, 0xA4, 0xF6, 0x55, 0xCC,
+		0xB0, 0xF6, 0x75, 0xCC, 0xB0, 0xF6, 0x55, 0xCC,
+		0xAD, 0xF6, 0x75, 0xCC, 0xAD, 0xF6, 0x55, 0xCC,
+		0x83, 0xCC, 0x81, 0xF6, 0x75, 0xCC, 0x83, 0xCC,
+		0x81, 0xF6, 0x55, 0xCC, 0x84, 0xCC, 0x88, 0xF6,
+		0x75, 0xCC, 0x84, 0xCC, 0x88, 0xF6, 0x56, 0xCC,
+		0x83, 0xF6, 0x76, 0xCC, 0x83, 0xF6, 0x56, 0xCC,
+		0xA3, 0xF6, 0x76, 0xCC, 0xA3, 0xF6, 0x57, 0xCC,
+		0x80, 0xF6, 0x77, 0xCC, 0x80, 0xF6, 0x57, 0xCC,
+		0x81, 0xF6, 0x77, 0xCC, 0x81, 0xF6, 0x57, 0xCC,
+		0x88, 0xF6, 0x77, 0xCC, 0x88, 0xF6, 0x57, 0xCC,
+		0x87, 0xF6, 0x77, 0xCC, 0x87, 0xF6, 0x57, 0xCC,
+		0xA3, 0xF6, 0x77, 0xCC, 0xA3, 0xF6, 0x58, 0xCC,
+		0x87, 0xF6, 0x78, 0xCC, 0x87, 0xF6, 0x58, 0xCC,
+		0x88, 0xF6, 0x78, 0xCC, 0x88, 0xF6, 0x59, 0xCC,
+		0x87, 0xF6, 0x79, 0xCC, 0x87, 0xF6, 0x5A, 0xCC,
+		0x82, 0xF6, 0x7A, 0xCC, 0x82, 0xF6, 0x5A, 0xCC,
+		0xA3, 0xF6, 0x7A, 0xCC, 0xA3, 0xF6, 0x5A, 0xCC,
+		0xB1, 0xF6, 0x7A, 0xCC, 0xB1, 0xF6, 0x68, 0xCC,
+		0xB1, 0xF6, 0x74, 0xCC, 0x88, 0xF6, 0x77, 0xCC,
+		0x8A, 0xF6, 0x79, 0xCC, 0x8A, 0x61, 0xCA, 0xBE,
+		0xF5, 0x05, 0xC5, 0xBF, 0xCC, 0x87, 0x73, 0xCC,
+		0x87, 0xF6, 0x41, 0xCC, 0xA3, 0xF6, 0x61, 0xCC,
+		0xA3, 0xF6, 0x41, 0xCC, 0x89, 0xF6, 0x61, 0xCC,
+		0x89, 0xF6, 0x41, 0xCC, 0x82, 0xCC, 0x81, 0xF6,
+		0x61, 0xCC, 0x82, 0xCC, 0x81, 0xF6, 0x41, 0xCC,
+		0x82, 0xCC, 0x80, 0xF6, 0x61, 0xCC, 0x82, 0xCC,
+		0x80, 0xF6, 0x41, 0xCC, 0x82, 0xCC, 0x89, 0xF6,
+		0x61, 0xCC, 0x82, 0xCC, 0x89, 0xF6, 0x41, 0xCC,
+		0x82, 0xCC, 0x83, 0xF6, 0x61, 0xCC, 0x82, 0xCC,
+		0x83, 0xF6, 0x41, 0xCC, 0xA3, 0xCC, 0x82, 0xF6,
+		0x61, 0xCC, 0xA3, 0xCC, 0x82, 0xF6, 0x41, 0xCC,
+		0x86, 0xCC, 0x81, 0xF6, 0x61, 0xCC, 0x86, 0xCC,
+		0x81, 0xF6, 0x41, 0xCC, 0x86, 0xCC, 0x80, 0xF6,
+		0x61, 0xCC, 0x86, 0xCC, 0x80, 0xF6, 0x41, 0xCC,
+		0x86, 0xCC, 0x89, 0xF6, 0x61, 0xCC, 0x86, 0xCC,
+		0x89, 0xF6, 0x41, 0xCC, 0x86, 0xCC, 0x83, 0xF6,
+		0x61, 0xCC, 0x86, 0xCC, 0x83, 0xF6, 0x41, 0xCC,
+		0xA3, 0xCC, 0x86, 0xF6, 0x61, 0xCC, 0xA3, 0xCC,
+		0x86, 0xF6, 0x45, 0xCC, 0xA3, 0xF6, 0x65, 0xCC,
+		0xA3, 0xF6, 0x45, 0xCC, 0x89, 0xF6, 0x65, 0xCC,
+		0x89, 0xF6, 0x45, 0xCC, 0x83, 0xF6, 0x65, 0xCC,
+		0x83, 0xF6, 0x45, 0xCC, 0x82, 0xCC, 0x81, 0xF6,
+		0x65, 0xCC, 0x82, 0xCC, 0x81, 0xF6, 0x45, 0xCC,
+		0x82, 0xCC, 0x80, 0xF6, 0x65, 0xCC, 0x82, 0xCC,
+		0x80, 0xF6, 0x45, 0xCC, 0x82, 0xCC, 0x89, 0xF6,
+		0x65, 0xCC, 0x82, 0xCC, 0x89, 0xF6, 0x45, 0xCC,
+		0x82, 0xCC, 0x83, 0xF6, 0x65, 0xCC, 0x82, 0xCC,
+		0x83, 0xF6, 0x45, 0xCC, 0xA3, 0xCC, 0x82, 0xF6,
+		0x65, 0xCC, 0xA3, 0xCC, 0x82, 0xF6, 0x49, 0xCC,
+		0x89, 0xF6, 0x69, 0xCC, 0x89, 0xF6, 0x49, 0xCC,
+		0xA3, 0xF6, 0x69, 0xCC, 0xA3, 0xF6, 0x4F, 0xCC,
+		0xA3, 0xF6, 0x6F, 0xCC, 0xA3, 0xF6, 0x4F, 0xCC,
+		0x89, 0xF6, 0x6F, 0xCC, 0x89, 0xF6, 0x4F, 0xCC,
+		0x82, 0xCC, 0x81, 0xF6, 0x6F, 0xCC, 0x82, 0xCC,
+		0x81, 0xF6, 0x4F, 0xCC, 0x82, 0xCC, 0x80, 0xF6,
+		0x6F, 0xCC, 0x82, 0xCC, 0x80, 0xF6, 0x4F, 0xCC,
+		0x82, 0xCC, 0x89, 0xF6, 0x6F, 0xCC, 0x82, 0xCC,
+		0x89, 0xF6, 0x4F, 0xCC, 0x82, 0xCC, 0x83, 0xF6,
+		0x6F, 0xCC, 0x82, 0xCC, 0x83, 0xF6, 0x4F, 0xCC,
+		0xA3, 0xCC, 0x82, 0xF6, 0x6F, 0xCC, 0xA3, 0xCC,
+		0x82, 0xF6, 0x4F, 0xCC, 0x9B, 0xCC, 0x81, 0xF6,
+		0x6F, 0xCC, 0x9B, 0xCC, 0x81, 0xF6, 0x4F, 0xCC,
+		0x9B, 0xCC, 0x80, 0xF6, 0x6F, 0xCC, 0x9B, 0xCC,
+		0x80, 0xF6, 0x4F, 0xCC, 0x9B, 0xCC, 0x89, 0xF6,
+		0x6F, 0xCC, 0x9B, 0xCC, 0x89, 0xF6, 0x4F, 0xCC,
+		0x9B, 0xCC, 0x83, 0xF6, 0x6F, 0xCC, 0x9B, 0xCC,
+		0x83, 0xF6, 0x4F, 0xCC, 0x9B, 0xCC, 0xA3, 0xF6,
+		0x6F, 0xCC, 0x9B, 0xCC, 0xA3, 0xF6, 0x55, 0xCC,
+		0xA3, 0xF6, 0x75, 0xCC, 0xA3, 0xF6, 0x55, 0xCC,
+		0x89, 0xF6, 0x75, 0xCC, 0x89, 0xF6, 0x55, 0xCC,
+		0x9B, 0xCC, 0x81, 0xF6, 0x75, 0xCC, 0x9B, 0xCC,
+		0x81, 0xF6, 0x55, 0xCC, 0x9B, 0xCC, 0x80, 0xF6,
+		0x75, 0xCC, 0x9B, 0xCC, 0x80, 0xF6, 0x55, 0xCC,
+		0x9B, 0xCC, 0x89, 0xF6, 0x75, 0xCC, 0x9B, 0xCC,
+		0x89, 0xF6, 0x55, 0xCC, 0x9B, 0xCC, 0x83, 0xF6,
+		0x75, 0xCC, 0x9B, 0xCC, 0x83, 0xF6, 0x55, 0xCC,
+		0x9B, 0xCC, 0xA3, 0xF6, 0x75, 0xCC, 0x9B, 0xCC,
+		0xA3, 0xF6, 0x59, 0xCC, 0x80, 0xF6, 0x79, 0xCC,
+		0x80, 0xF6, 0x59, 0xCC, 0xA3, 0xF6, 0x79, 0xCC,
+		0xA3, 0xF6, 0x59, 0xCC, 0x89, 0xF6, 0x79, 0xCC,
+		0x89, 0xF6, 0x59, 0xCC, 0x83, 0xF6, 0x79, 0xCC,
+		0x83, 0xF6, 0xCE, 0xB1, 0xCC, 0x93, 0xF6, 0xCE,
+		0xB1, 0xCC, 0x94, 0xF6, 0xCE, 0xB1, 0xCC, 0x93,
+		0xCC, 0x80, 0xF6, 0xCE, 0xB1, 0xCC, 0x94, 0xCC,
+		0x80, 0xF6, 0xCE, 0xB1, 0xCC, 0x93, 0xCC, 0x81,
+		0xF6, 0xCE, 0xB1, 0xCC, 0x94, 0xCC, 0x81, 0xF6,
+		0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xF6, 0xCE,
+		0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE, 0x91,
+		0xCC, 0x93, 0xF6, 0xCE, 0x91, 0xCC, 0x94, 0xF6,
+		0xCE, 0x91, 0xCC, 0x93, 0xCC, 0x80, 0xF6, 0xCE,
+		0x91, 0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE, 0x91,
+		0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE, 0x91, 0xCC,
+		0x94, 0xCC, 0x81, 0xF6, 0xCE, 0x91, 0xCC, 0x93,
+		0xCD, 0x82, 0xF6, 0xCE, 0x91, 0xCC, 0x94, 0xCD,
+		0x82, 0xF6, 0xCE, 0xB5, 0xCC, 0x93, 0xF6, 0xCE,
+		0xB5, 0xCC, 0x94, 0xF6, 0xCE, 0xB5, 0xCC, 0x93,
+		0xCC, 0x80, 0xF6, 0xCE, 0xB5, 0xCC, 0x94, 0xCC,
+		0x80, 0xF6, 0xCE, 0xB5, 0xCC, 0x93, 0xCC, 0x81,
+		0xF6, 0xCE, 0xB5, 0xCC, 0x94, 0xCC, 0x81, 0xF6,
+		0xCE, 0x95, 0xCC, 0x93, 0xF6, 0xCE, 0x95, 0xCC,
+		0x94, 0xF6, 0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x80,
+		0xF6, 0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x80, 0xF6,
+		0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE,
+		0x95, 0xCC, 0x94, 0xCC, 0x81, 0xF6, 0xCE, 0xB7,
+		0xCC, 0x93, 0xF6, 0xCE, 0xB7, 0xCC, 0x94, 0xF6,
+		0xCE, 0xB7, 0xCC, 0x93, 0xCC, 0x80, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE, 0xB7,
+		0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE, 0xB7, 0xCC,
+		0x94, 0xCC, 0x81, 0xF6, 0xCE, 0xB7, 0xCC, 0x93,
+		0xCD, 0x82, 0xF6, 0xCE, 0xB7, 0xCC, 0x94, 0xCD,
+		0x82, 0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xF6, 0xCE,
+		0x97, 0xCC, 0x94, 0xF6, 0xCE, 0x97, 0xCC, 0x93,
+		0xCC, 0x80, 0xF6, 0xCE, 0x97, 0xCC, 0x94, 0xCC,
+		0x80, 0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xCC, 0x81,
+		0xF6, 0xCE, 0x97, 0xCC, 0x94, 0xCC, 0x81, 0xF6,
+		0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x82, 0xF6, 0xCE,
+		0x97, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE, 0xB9,
+		0xCC, 0x93, 0xF6, 0xCE, 0xB9, 0xCC, 0x94, 0xF6,
+		0xCE, 0xB9, 0xCC, 0x93, 0xCC, 0x80, 0xF6, 0xCE,
+		0xB9, 0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE, 0xB9,
+		0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCC,
+		0x94, 0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCC, 0x93,
+		0xCD, 0x82, 0xF6, 0xCE, 0xB9, 0xCC, 0x94, 0xCD,
+		0x82, 0xF6, 0xCE, 0x99, 0xCC, 0x93, 0xF6, 0xCE,
+		0x99, 0xCC, 0x94, 0xF6, 0xCE, 0x99, 0xCC, 0x93,
+		0xCC, 0x80, 0xF6, 0xCE, 0x99, 0xCC, 0x94, 0xCC,
+		0x80, 0xF6, 0xCE, 0x99, 0xCC, 0x93, 0xCC, 0x81,
+		0xF6, 0xCE, 0x99, 0xCC, 0x94, 0xCC, 0x81, 0xF6,
+		0xCE, 0x99, 0xCC, 0x93, 0xCD, 0x82, 0xF6, 0xCE,
+		0x99, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE, 0xBF,
+		0xCC, 0x93, 0xF6, 0xCE, 0xBF, 0xCC, 0x94, 0xF6,
+		0xCE, 0xBF, 0xCC, 0x93, 0xCC, 0x80, 0xF6, 0xCE,
+		0xBF, 0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE, 0xBF,
+		0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE, 0xBF, 0xCC,
+		0x94, 0xCC, 0x81, 0xF6, 0xCE, 0x9F, 0xCC, 0x93,
+		0xF6, 0xCE, 0x9F, 0xCC, 0x94, 0xF6, 0xCE, 0x9F,
+		0xCC, 0x93, 0xCC, 0x80, 0xF6, 0xCE, 0x9F, 0xCC,
+		0x94, 0xCC, 0x80, 0xF6, 0xCE, 0x9F, 0xCC, 0x93,
+		0xCC, 0x81, 0xF6, 0xCE, 0x9F, 0xCC, 0x94, 0xCC,
+		0x81, 0xF6, 0xCF, 0x85, 0xCC, 0x93, 0xF6, 0xCF,
+		0x85, 0xCC, 0x94, 0xF6, 0xCF, 0x85, 0xCC, 0x93,
+		0xCC, 0x80, 0xF6, 0xCF, 0x85, 0xCC, 0x94, 0xCC,
+		0x80, 0xF6, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x81,
+		0xF6, 0xCF, 0x85, 0xCC, 0x94, 0xCC, 0x81, 0xF6,
+		0xCF, 0x85, 0xCC, 0x93, 0xCD, 0x82, 0xF6, 0xCF,
+		0x85, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE, 0xA5,
+		0xCC, 0x94, 0xF6, 0xCE, 0xA5, 0xCC, 0x94, 0xCC,
+		0x80, 0xF6, 0xCE, 0xA5, 0xCC, 0x94, 0xCC, 0x81,
+		0xF6, 0xCE, 0xA5, 0xCC, 0x94, 0xCD, 0x82, 0xF6,
+		0xCF, 0x89, 0xCC, 0x93, 0xF6, 0xCF, 0x89, 0xCC,
+		0x94, 0xF6, 0xCF, 0x89, 0xCC, 0x93, 0xCC, 0x80,
+		0xF6, 0xCF, 0x89, 0xCC, 0x94, 0xCC, 0x80, 0xF6,
+		0xCF, 0x89, 0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCF,
+		0x89, 0xCC, 0x94, 0xCC, 0x81, 0xF6, 0xCF, 0x89,
+		0xCC, 0x93, 0xCD, 0x82, 0xF6, 0xCF, 0x89, 0xCC,
+		0x94, 0xCD, 0x82, 0xF6, 0xCE, 0xA9, 0xCC, 0x93,
+		0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xF6, 0xCE, 0xA9,
+		0xCC, 0x93, 0xCC, 0x80, 0xF6, 0xCE, 0xA9, 0xCC,
+		0x94, 0xCC, 0x80, 0xF6, 0xCE, 0xA9, 0xCC, 0x93,
+		0xCC, 0x81, 0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xCC,
+		0x81, 0xF6, 0xCE, 0xA9, 0xCC, 0x93, 0xCD, 0x82,
+		0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xCD, 0x82, 0xF6,
+		0xCE, 0xB1, 0xCC, 0x80, 0xF6, 0xCE, 0xB1, 0xCC,
+		0x81, 0xF6, 0xCE, 0xB5, 0xCC, 0x80, 0xF6, 0xCE,
+		0xB5, 0xCC, 0x81, 0xF6, 0xCE, 0xB7, 0xCC, 0x80,
+		0xF6, 0xCE, 0xB7, 0xCC, 0x81, 0xF6, 0xCE, 0xB9,
+		0xCC, 0x80, 0xF6, 0xCE, 0xB9, 0xCC, 0x81, 0xF6,
+		0xCE, 0xBF, 0xCC, 0x80, 0xF6, 0xCE, 0xBF, 0xCC,
+		0x81, 0xF6, 0xCF, 0x85, 0xCC, 0x80, 0xF6, 0xCF,
+		0x85, 0xCC, 0x81, 0xF6, 0xCF, 0x89, 0xCC, 0x80,
+		0xF6, 0xCF, 0x89, 0xCC, 0x81, 0xF6, 0xCE, 0xB1,
+		0xCC, 0x93, 0xCD, 0x85, 0xF6, 0xCE, 0xB1, 0xCC,
+		0x94, 0xCD, 0x85, 0xF6, 0xCE, 0xB1, 0xCC, 0x93,
+		0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE, 0xB1, 0xCC,
+		0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE, 0xB1,
+		0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF6, 0xCE,
+		0xB1, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85, 0xF6,
+		0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xCD, 0x85,
+		0xF6, 0xCE, 0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xCD,
+		0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x93, 0xCD, 0x85,
+		0xF6, 0xCE, 0x91, 0xCC, 0x94, 0xCD, 0x85, 0xF6,
+		0xCE, 0x91, 0xCC, 0x93, 0xCC, 0x80, 0xCD, 0x85,
+		0xF6, 0xCE, 0x91, 0xCC, 0x94, 0xCC, 0x80, 0xCD,
+		0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x93, 0xCC, 0x81,
+		0xCD, 0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x94, 0xCC,
+		0x81, 0xCD, 0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x93,
+		0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0x91, 0xCC,
+		0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0xB7,
+		0xCC, 0x93, 0xCD, 0x85, 0xF6, 0xCE, 0xB7, 0xCC,
+		0x94, 0xCD, 0x85, 0xF6, 0xCE, 0xB7, 0xCC, 0x93,
+		0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE, 0xB7, 0xCC,
+		0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE, 0xB7,
+		0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85, 0xF6,
+		0xCE, 0xB7, 0xCC, 0x93, 0xCD, 0x82, 0xCD, 0x85,
+		0xF6, 0xCE, 0xB7, 0xCC, 0x94, 0xCD, 0x82, 0xCD,
+		0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x85,
+		0xF6, 0xCE, 0x97, 0xCC, 0x94, 0xCD, 0x85, 0xF6,
+		0xCE, 0x97, 0xCC, 0x93, 0xCC, 0x80, 0xCD, 0x85,
+		0xF6, 0xCE, 0x97, 0xCC, 0x94, 0xCC, 0x80, 0xCD,
+		0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xCC, 0x81,
+		0xCD, 0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x94, 0xCC,
+		0x81, 0xCD, 0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x93,
+		0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0x97, 0xCC,
+		0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCF, 0x89,
+		0xCC, 0x93, 0xCD, 0x85, 0xF6, 0xCF, 0x89, 0xCC,
+		0x94, 0xCD, 0x85, 0xF6, 0xCF, 0x89, 0xCC, 0x93,
+		0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCF, 0x89, 0xCC,
+		0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCF, 0x89,
+		0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF6, 0xCF,
+		0x89, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85, 0xF6,
+		0xCF, 0x89, 0xCC, 0x93, 0xCD, 0x82, 0xCD, 0x85,
+		0xF6, 0xCF, 0x89, 0xCC, 0x94, 0xCD, 0x82, 0xCD,
+		0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x93, 0xCD, 0x85,
+		0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xCD, 0x85, 0xF6,
+		0xCE, 0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xCD, 0x85,
+		0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xCC, 0x80, 0xCD,
+		0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x93, 0xCC, 0x81,
+		0xCD, 0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xCC,
+		0x81, 0xCD, 0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x93,
+		0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0xA9, 0xCC,
+		0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0xB1,
+		0xCC, 0x86, 0xF6, 0xCE, 0xB1, 0xCC, 0x84, 0xF6,
+		0xCE, 0xB1, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE,
+		0xB1, 0xCD, 0x85, 0xF6, 0xCE, 0xB1, 0xCC, 0x81,
+		0xCD, 0x85, 0xF6, 0xCE, 0xB1, 0xCD, 0x82, 0xF6,
+		0xCE, 0xB1, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE,
+		0x91, 0xCC, 0x86, 0xF6, 0xCE, 0x91, 0xCC, 0x84,
+		0xF6, 0xCE, 0x91, 0xCC, 0x80, 0xF6, 0xCE, 0x91,
+		0xCC, 0x81, 0xF6, 0xCE, 0x91, 0xCD, 0x85, 0x20,
+		0xCC, 0x93, 0xF6, 0xCE, 0xB9, 0x20, 0xCC, 0x93,
+		0x20, 0xCD, 0x82, 0xF5, 0x05, 0xC2, 0xA8, 0xCD,
+		0x82, 0x20, 0xCC, 0x88, 0xCD, 0x82, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE, 0xB7,
+		0xCD, 0x85, 0xF6, 0xCE, 0xB7, 0xCC, 0x81, 0xCD,
+		0x85, 0xF6, 0xCE, 0xB7, 0xCD, 0x82, 0xF6, 0xCE,
+		0xB7, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0x95,
+		0xCC, 0x80, 0xF6, 0xCE, 0x95, 0xCC, 0x81, 0xF6,
+		0xCE, 0x97, 0xCC, 0x80, 0xF6, 0xCE, 0x97, 0xCC,
+		0x81, 0xF6, 0xCE, 0x97, 0xCD, 0x85, 0xF5, 0x06,
+		0xE1, 0xBE, 0xBF, 0xCC, 0x80, 0x20, 0xCC, 0x93,
+		0xCC, 0x80, 0xF5, 0x06, 0xE1, 0xBE, 0xBF, 0xCC,
+		0x81, 0x20, 0xCC, 0x93, 0xCC, 0x81, 0xF5, 0x06,
+		0xE1, 0xBE, 0xBF, 0xCD, 0x82, 0x20, 0xCC, 0x93,
+		0xCD, 0x82, 0xF6, 0xCE, 0xB9, 0xCC, 0x86, 0xF6,
+		0xCE, 0xB9, 0xCC, 0x84, 0xF6, 0xCE, 0xB9, 0xCC,
+		0x88, 0xCC, 0x80, 0xF6, 0xCE, 0xB9, 0xCC, 0x88,
+		0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCD, 0x82, 0xF6,
+		0xCE, 0xB9, 0xCC, 0x88, 0xCD, 0x82, 0xF6, 0xCE,
+		0x99, 0xCC, 0x86, 0xF6, 0xCE, 0x99, 0xCC, 0x84,
+		0xF6, 0xCE, 0x99, 0xCC, 0x80, 0xF6, 0xCE, 0x99,
+		0xCC, 0x81, 0xF5, 0x06, 0xE1, 0xBF, 0xBE, 0xCC,
+		0x80, 0x20, 0xCC, 0x94, 0xCC, 0x80, 0xF5, 0x06,
+		0xE1, 0xBF, 0xBE, 0xCC, 0x81, 0x20, 0xCC, 0x94,
+		0xCC, 0x81, 0xF5, 0x06, 0xE1, 0xBF, 0xBE, 0xCD,
+		0x82, 0x20, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCF,
+		0x85, 0xCC, 0x86, 0xF6, 0xCF, 0x85, 0xCC, 0x84,
+		0xF6, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x80, 0xF6,
+		0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xF6, 0xCF,
+		0x81, 0xCC, 0x93, 0xF6, 0xCF, 0x81, 0xCC, 0x94,
+		0xF6, 0xCF, 0x85, 0xCD, 0x82, 0xF6, 0xCF, 0x85,
+		0xCC, 0x88, 0xCD, 0x82, 0xF6, 0xCE, 0xA5, 0xCC,
+		0x86, 0xF6, 0xCE, 0xA5, 0xCC, 0x84, 0xF6, 0xCE,
+		0xA5, 0xCC, 0x80, 0xF6, 0xCE, 0xA5, 0xCC, 0x81,
+		0xF6, 0xCE, 0xA1, 0xCC, 0x94, 0xF5, 0x05, 0xC2,
+		0xA8, 0xCC, 0x80, 0x20, 0xCC, 0x88, 0xCC, 0x80,
+		0xF5, 0x05, 0xC2, 0xA8, 0xCC, 0x81, 0x20, 0xCC,
+		0x88, 0xCC, 0x81, 0xF6, 0x60, 0xF6, 0xCF, 0x89,
+		0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCF, 0x89, 0xCD,
+		0x85, 0xF6, 0xCF, 0x89, 0xCC, 0x81, 0xCD, 0x85,
+		0xF6, 0xCF, 0x89, 0xCD, 0x82, 0xF6, 0xCF, 0x89,
+		0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0x9F, 0xCC,
+		0x80, 0xF6, 0xCE, 0x9F, 0xCC, 0x81, 0xF6, 0xCE,
+		0xA9, 0xCC, 0x80, 0xF6, 0xCE, 0xA9, 0xCC, 0x81,
+		0xF6, 0xCE, 0xA9, 0xCD, 0x85, 0xF5, 0x03, 0xC2,
+		0xB4, 0x20, 0xCC, 0x81, 0x20, 0xCC, 0x94, 0xF5,
+		0x04, 0xE2, 0x80, 0x82, 0x20, 0xF5, 0x04, 0xE2,
+		0x80, 0x83, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+		0x20, 0x20, 0x20, 0x20, 0xE2, 0x80, 0x90, 0x20,
+		0xCC, 0xB3, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
+		0x20, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2,
+		0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+		0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0xE2, 0x80,
+		0xB5, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0x21,
+		0x21, 0x20, 0xCC, 0x85, 0x3F, 0x3F, 0x3F, 0x21,
+		0x21, 0x3F, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+		0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2, 0x20, 0x30,
+		0x69, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2B,
+		0xE2, 0x88, 0x92, 0x3D, 0x28, 0x29, 0x6E, 0x30,
+		0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+		0x39, 0x2B, 0xE2, 0x88, 0x92, 0x3D, 0x28, 0x29,
+		0x52, 0x73, 0x61, 0x2F, 0x63, 0x61, 0x2F, 0x73,
+		0x43, 0xC2, 0xB0, 0x43, 0x63, 0x2F, 0x6F, 0x63,
+		0x2F, 0x75, 0xC6, 0x90, 0xC2, 0xB0, 0x46, 0x67,
+		0x48, 0x48, 0x48, 0x68, 0xC4, 0xA7, 0x49, 0x49,
+		0x4C, 0x6C, 0x4E, 0x4E, 0x6F, 0x50, 0x51, 0x52,
+		0x52, 0x52, 0x53, 0x4D, 0x54, 0x45, 0x4C, 0x54,
+		0x4D, 0x5A, 0xF6, 0xCE, 0xA9, 0x5A, 0xF6, 0x4B,
+		0xF6, 0x41, 0xCC, 0x8A, 0x42, 0x43, 0x65, 0x45,
+		0x46, 0x4D, 0x6F, 0xD7, 0x90, 0xD7, 0x91, 0xD7,
+		0x92, 0xD7, 0x93, 0x69, 0xCE, 0xB3, 0xCE, 0x93,
+		0xCE, 0xA0, 0xE2, 0x88, 0x91, 0x44, 0x64, 0x65,
+		0x69, 0x6A, 0x31, 0xE2, 0x81, 0x84, 0x33, 0x32,
+		0xE2, 0x81, 0x84, 0x33, 0x31, 0xE2, 0x81, 0x84,
+		0x35, 0x32, 0xE2, 0x81, 0x84, 0x35, 0x33, 0xE2,
+		0x81, 0x84, 0x35, 0x34, 0xE2, 0x81, 0x84, 0x35,
+		0x31, 0xE2, 0x81, 0x84, 0x36, 0x35, 0xE2, 0x81,
+		0x84, 0x36, 0x31, 0xE2, 0x81, 0x84, 0x38, 0x33,
+		0xE2, 0x81, 0x84, 0x38, 0x35, 0xE2, 0x81, 0x84,
+		0x38, 0x37, 0xE2, 0x81, 0x84, 0x38, 0x31, 0xE2,
+		0x81, 0x84, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+		0x49, 0x56, 0x56, 0x56, 0x49, 0x56, 0x49, 0x49,
+		0x56, 0x49, 0x49, 0x49, 0x49, 0x58, 0x58, 0x58,
+		0x49, 0x58, 0x49, 0x49, 0x4C, 0x43, 0x44, 0x4D,
+		0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x76,
+		0x76, 0x76, 0x69, 0x76, 0x69, 0x69, 0x76, 0x69,
+		0x69, 0x69, 0x69, 0x78, 0x78, 0x78, 0x69, 0x78,
+		0x69, 0x69, 0x6C, 0x63, 0x64, 0x6D, 0xF6, 0xE2,
+		0x86, 0x90, 0xCC, 0xB8, 0xF6, 0xE2, 0x86, 0x92,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x86, 0x94, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x87, 0x90, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x87, 0x94, 0xCC, 0xB8, 0xF6, 0xE2, 0x87, 0x92,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x88, 0x83, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x88, 0x88, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x88, 0x8B, 0xCC, 0xB8, 0xF6, 0xE2, 0x88, 0xA3,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x88, 0xA5, 0xCC, 0xB8,
+		0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88,
+		0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0xE2,
+		0x88, 0xAE, 0xE2, 0x88, 0xAE, 0xE2, 0x88, 0xAE,
+		0xE2, 0x88, 0xAE, 0xE2, 0x88, 0xAE, 0xF6, 0xE2,
+		0x88, 0xBC, 0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0x83,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0x85, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x89, 0x88, 0xCC, 0xB8, 0xF6, 0x3D,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xA1, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x89, 0x8D, 0xCC, 0xB8, 0xF6, 0x3C,
+		0xCC, 0xB8, 0xF6, 0x3E, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x89, 0xA4, 0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xA5,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xB2, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x89, 0xB3, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x89, 0xB6, 0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xB7,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xBA, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x89, 0xBB, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x8A, 0x82, 0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0x83,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0x86, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x8A, 0x87, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x8A, 0xA2, 0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0xA8,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0xA9, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x8A, 0xAB, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x89, 0xBC, 0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xBD,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0x91, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x8A, 0x92, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x8A, 0xB2, 0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0xB3,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0xB4, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x8A, 0xB5, 0xCC, 0xB8, 0xF6, 0xE3,
+		0x80, 0x88, 0xF6, 0xE3, 0x80, 0x89, 0x31, 0x32,
+		0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x31,
+		0x30, 0x31, 0x31, 0x31, 0x32, 0x31, 0x33, 0x31,
+		0x34, 0x31, 0x35, 0x31, 0x36, 0x31, 0x37, 0x31,
+		0x38, 0x31, 0x39, 0x32, 0x30, 0x28, 0x31, 0x29,
+		0x28, 0x32, 0x29, 0x28, 0x33, 0x29, 0x28, 0x34,
+		0x29, 0x28, 0x35, 0x29, 0x28, 0x36, 0x29, 0x28,
+		0x37, 0x29, 0x28, 0x38, 0x29, 0x28, 0x39, 0x29,
+		0x28, 0x31, 0x30, 0x29, 0x28, 0x31, 0x31, 0x29,
+		0x28, 0x31, 0x32, 0x29, 0x28, 0x31, 0x33, 0x29,
+		0x28, 0x31, 0x34, 0x29, 0x28, 0x31, 0x35, 0x29,
+		0x28, 0x31, 0x36, 0x29, 0x28, 0x31, 0x37, 0x29,
+		0x28, 0x31, 0x38, 0x29, 0x28, 0x31, 0x39, 0x29,
+		0x28, 0x32, 0x30, 0x29, 0x31, 0x2E, 0x32, 0x2E,
+		0x33, 0x2E, 0x34, 0x2E, 0x35, 0x2E, 0x36, 0x2E,
+		0x37, 0x2E, 0x38, 0x2E, 0x39, 0x2E, 0x31, 0x30,
+		0x2E, 0x31, 0x31, 0x2E, 0x31, 0x32, 0x2E, 0x31,
+		0x33, 0x2E, 0x31, 0x34, 0x2E, 0x31, 0x35, 0x2E,
+		0x31, 0x36, 0x2E, 0x31, 0x37, 0x2E, 0x31, 0x38,
+		0x2E, 0x31, 0x39, 0x2E, 0x32, 0x30, 0x2E, 0x28,
+		0x61, 0x29, 0x28, 0x62, 0x29, 0x28, 0x63, 0x29,
+		0x28, 0x64, 0x29, 0x28, 0x65, 0x29, 0x28, 0x66,
+		0x29, 0x28, 0x67, 0x29, 0x28, 0x68, 0x29, 0x28,
+		0x69, 0x29, 0x28, 0x6A, 0x29, 0x28, 0x6B, 0x29,
+		0x28, 0x6C, 0x29, 0x28, 0x6D, 0x29, 0x28, 0x6E,
+		0x29, 0x28, 0x6F, 0x29, 0x28, 0x70, 0x29, 0x28,
+		0x71, 0x29, 0x28, 0x72, 0x29, 0x28, 0x73, 0x29,
+		0x28, 0x74, 0x29, 0x28, 0x75, 0x29, 0x28, 0x76,
+		0x29, 0x28, 0x77, 0x29, 0x28, 0x78, 0x29, 0x28,
+		0x79, 0x29, 0x28, 0x7A, 0x29, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x30, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB,
+		0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0x3A, 0x3A,
+		0x3D, 0x3D, 0x3D, 0x3D, 0x3D, 0x3D, 0xF6, 0xE2,
+		0xAB, 0x9D, 0xCC, 0xB8, 0xE6, 0xAF, 0x8D, 0xE9,
+		0xBE, 0x9F, 0xE4, 0xB8, 0x80, 0xE4, 0xB8, 0xA8,
+		0xE4, 0xB8, 0xB6, 0xE4, 0xB8, 0xBF, 0xE4, 0xB9,
+		0x99, 0xE4, 0xBA, 0x85, 0xE4, 0xBA, 0x8C, 0xE4,
+		0xBA, 0xA0, 0xE4, 0xBA, 0xBA, 0xE5, 0x84, 0xBF,
+		0xE5, 0x85, 0xA5, 0xE5, 0x85, 0xAB, 0xE5, 0x86,
+		0x82, 0xE5, 0x86, 0x96, 0xE5, 0x86, 0xAB, 0xE5,
+		0x87, 0xA0, 0xE5, 0x87, 0xB5, 0xE5, 0x88, 0x80,
+		0xE5, 0x8A, 0x9B, 0xE5, 0x8B, 0xB9, 0xE5, 0x8C,
+		0x95, 0xE5, 0x8C, 0x9A, 0xE5, 0x8C, 0xB8, 0xE5,
+		0x8D, 0x81, 0xE5, 0x8D, 0x9C, 0xE5, 0x8D, 0xA9,
+		0xE5, 0x8E, 0x82, 0xE5, 0x8E, 0xB6, 0xE5, 0x8F,
+		0x88, 0xE5, 0x8F, 0xA3, 0xE5, 0x9B, 0x97, 0xE5,
+		0x9C, 0x9F, 0xE5, 0xA3, 0xAB, 0xE5, 0xA4, 0x82,
+		0xE5, 0xA4, 0x8A, 0xE5, 0xA4, 0x95, 0xE5, 0xA4,
+		0xA7, 0xE5, 0xA5, 0xB3, 0xE5, 0xAD, 0x90, 0xE5,
+		0xAE, 0x80, 0xE5, 0xAF, 0xB8, 0xE5, 0xB0, 0x8F,
+		0xE5, 0xB0, 0xA2, 0xE5, 0xB0, 0xB8, 0xE5, 0xB1,
+		0xAE, 0xE5, 0xB1, 0xB1, 0xE5, 0xB7, 0x9B, 0xE5,
+		0xB7, 0xA5, 0xE5, 0xB7, 0xB1, 0xE5, 0xB7, 0xBE,
+		0xE5, 0xB9, 0xB2, 0xE5, 0xB9, 0xBA, 0xE5, 0xB9,
+		0xBF, 0xE5, 0xBB, 0xB4, 0xE5, 0xBB, 0xBE, 0xE5,
+		0xBC, 0x8B, 0xE5, 0xBC, 0x93, 0xE5, 0xBD, 0x90,
+		0xE5, 0xBD, 0xA1, 0xE5, 0xBD, 0xB3, 0xE5, 0xBF,
+		0x83, 0xE6, 0x88, 0x88, 0xE6, 0x88, 0xB6, 0xE6,
+		0x89, 0x8B, 0xE6, 0x94, 0xAF, 0xE6, 0x94, 0xB4,
+		0xE6, 0x96, 0x87, 0xE6, 0x96, 0x97, 0xE6, 0x96,
+		0xA4, 0xE6, 0x96, 0xB9, 0xE6, 0x97, 0xA0, 0xE6,
+		0x97, 0xA5, 0xE6, 0x9B, 0xB0, 0xE6, 0x9C, 0x88,
+		0xE6, 0x9C, 0xA8, 0xE6, 0xAC, 0xA0, 0xE6, 0xAD,
+		0xA2, 0xE6, 0xAD, 0xB9, 0xE6, 0xAE, 0xB3, 0xE6,
+		0xAF, 0x8B, 0xE6, 0xAF, 0x94, 0xE6, 0xAF, 0x9B,
+		0xE6, 0xB0, 0x8F, 0xE6, 0xB0, 0x94, 0xE6, 0xB0,
+		0xB4, 0xE7, 0x81, 0xAB, 0xE7, 0x88, 0xAA, 0xE7,
+		0x88, 0xB6, 0xE7, 0x88, 0xBB, 0xE7, 0x88, 0xBF,
+		0xE7, 0x89, 0x87, 0xE7, 0x89, 0x99, 0xE7, 0x89,
+		0x9B, 0xE7, 0x8A, 0xAC, 0xE7, 0x8E, 0x84, 0xE7,
+		0x8E, 0x89, 0xE7, 0x93, 0x9C, 0xE7, 0x93, 0xA6,
+		0xE7, 0x94, 0x98, 0xE7, 0x94, 0x9F, 0xE7, 0x94,
+		0xA8, 0xE7, 0x94, 0xB0, 0xE7, 0x96, 0x8B, 0xE7,
+		0x96, 0x92, 0xE7, 0x99, 0xB6, 0xE7, 0x99, 0xBD,
+		0xE7, 0x9A, 0xAE, 0xE7, 0x9A, 0xBF, 0xE7, 0x9B,
+		0xAE, 0xE7, 0x9F, 0x9B, 0xE7, 0x9F, 0xA2, 0xE7,
+		0x9F, 0xB3, 0xE7, 0xA4, 0xBA, 0xE7, 0xA6, 0xB8,
+		0xE7, 0xA6, 0xBE, 0xE7, 0xA9, 0xB4, 0xE7, 0xAB,
+		0x8B, 0xE7, 0xAB, 0xB9, 0xE7, 0xB1, 0xB3, 0xE7,
+		0xB3, 0xB8, 0xE7, 0xBC, 0xB6, 0xE7, 0xBD, 0x91,
+		0xE7, 0xBE, 0x8A, 0xE7, 0xBE, 0xBD, 0xE8, 0x80,
+		0x81, 0xE8, 0x80, 0x8C, 0xE8, 0x80, 0x92, 0xE8,
+		0x80, 0xB3, 0xE8, 0x81, 0xBF, 0xE8, 0x82, 0x89,
+		0xE8, 0x87, 0xA3, 0xE8, 0x87, 0xAA, 0xE8, 0x87,
+		0xB3, 0xE8, 0x87, 0xBC, 0xE8, 0x88, 0x8C, 0xE8,
+		0x88, 0x9B, 0xE8, 0x88, 0x9F, 0xE8, 0x89, 0xAE,
+		0xE8, 0x89, 0xB2, 0xE8, 0x89, 0xB8, 0xE8, 0x99,
+		0x8D, 0xE8, 0x99, 0xAB, 0xE8, 0xA1, 0x80, 0xE8,
+		0xA1, 0x8C, 0xE8, 0xA1, 0xA3, 0xE8, 0xA5, 0xBE,
+		0xE8, 0xA6, 0x8B, 0xE8, 0xA7, 0x92, 0xE8, 0xA8,
+		0x80, 0xE8, 0xB0, 0xB7, 0xE8, 0xB1, 0x86, 0xE8,
+		0xB1, 0x95, 0xE8, 0xB1, 0xB8, 0xE8, 0xB2, 0x9D,
+		0xE8, 0xB5, 0xA4, 0xE8, 0xB5, 0xB0, 0xE8, 0xB6,
+		0xB3, 0xE8, 0xBA, 0xAB, 0xE8, 0xBB, 0x8A, 0xE8,
+		0xBE, 0x9B, 0xE8, 0xBE, 0xB0, 0xE8, 0xBE, 0xB5,
+		0xE9, 0x82, 0x91, 0xE9, 0x85, 0x89, 0xE9, 0x87,
+		0x86, 0xE9, 0x87, 0x8C, 0xE9, 0x87, 0x91, 0xE9,
+		0x95, 0xB7, 0xE9, 0x96, 0x80, 0xE9, 0x98, 0x9C,
+		0xE9, 0x9A, 0xB6, 0xE9, 0x9A, 0xB9, 0xE9, 0x9B,
+		0xA8, 0xE9, 0x9D, 0x91, 0xE9, 0x9D, 0x9E, 0xE9,
+		0x9D, 0xA2, 0xE9, 0x9D, 0xA9, 0xE9, 0x9F, 0x8B,
+		0xE9, 0x9F, 0xAD, 0xE9, 0x9F, 0xB3, 0xE9, 0xA0,
+		0x81, 0xE9, 0xA2, 0xA8, 0xE9, 0xA3, 0x9B, 0xE9,
+		0xA3, 0x9F, 0xE9, 0xA6, 0x96, 0xE9, 0xA6, 0x99,
+		0xE9, 0xA6, 0xAC, 0xE9, 0xAA, 0xA8, 0xE9, 0xAB,
+		0x98, 0xE9, 0xAB, 0x9F, 0xE9, 0xAC, 0xA5, 0xE9,
+		0xAC, 0xAF, 0xE9, 0xAC, 0xB2, 0xE9, 0xAC, 0xBC,
+		0xE9, 0xAD, 0x9A, 0xE9, 0xB3, 0xA5, 0xE9, 0xB9,
+		0xB5, 0xE9, 0xB9, 0xBF, 0xE9, 0xBA, 0xA5, 0xE9,
+		0xBA, 0xBB, 0xE9, 0xBB, 0x83, 0xE9, 0xBB, 0x8D,
+		0xE9, 0xBB, 0x91, 0xE9, 0xBB, 0xB9, 0xE9, 0xBB,
+		0xBD, 0xE9, 0xBC, 0x8E, 0xE9, 0xBC, 0x93, 0xE9,
+		0xBC, 0xA0, 0xE9, 0xBC, 0xBB, 0xE9, 0xBD, 0x8A,
+		0xE9, 0xBD, 0x92, 0xE9, 0xBE, 0x8D, 0xE9, 0xBE,
+		0x9C, 0xE9, 0xBE, 0xA0, 0x20, 0xE3, 0x80, 0x92,
+		0xE5, 0x8D, 0x81, 0xE5, 0x8D, 0x84, 0xE5, 0x8D,
+		0x85, 0xF6, 0xE3, 0x81, 0x8B, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x81, 0x8D, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x81, 0x8F, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x81, 0x91, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81,
+		0x93, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0x95,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0x97, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x81, 0x99, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x81, 0x9B, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x81, 0x9D, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x81, 0x9F, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x81, 0xA1, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81,
+		0xA4, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0xA6,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0xA8, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x81, 0xAF, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x9A,
+		0xF6, 0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x9A, 0xF6, 0xE3,
+		0x81, 0xB5, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81,
+		0xB5, 0xE3, 0x82, 0x9A, 0xF6, 0xE3, 0x81, 0xB8,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0xB8, 0xE3,
+		0x82, 0x9A, 0xF6, 0xE3, 0x81, 0xBB, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x9A,
+		0xF6, 0xE3, 0x81, 0x86, 0xE3, 0x82, 0x99, 0x20,
+		0xE3, 0x82, 0x99, 0x20, 0xE3, 0x82, 0x9A, 0xF6,
+		0xE3, 0x82, 0x9D, 0xE3, 0x82, 0x99, 0xE3, 0x82,
+		0x88, 0xE3, 0x82, 0x8A, 0xF6, 0xE3, 0x82, 0xAB,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x82, 0xAD, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x82, 0xAF, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x82, 0xB1, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x82, 0xB3, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x82, 0xB5, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x82, 0xB7, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x82,
+		0xB9, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x82, 0xBB,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x82, 0xBD, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x82, 0xBF, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x83, 0x81, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x83, 0x84, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x83, 0x86, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x83, 0x88, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83,
+		0x8F, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83, 0x8F,
+		0xE3, 0x82, 0x9A, 0xF6, 0xE3, 0x83, 0x92, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x83, 0x92, 0xE3, 0x82,
+		0x9A, 0xF6, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x9A, 0xF6,
+		0xE3, 0x83, 0x98, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x83, 0x98, 0xE3, 0x82, 0x9A, 0xF6, 0xE3, 0x83,
+		0x9B, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83, 0x9B,
+		0xE3, 0x82, 0x9A, 0xF6, 0xE3, 0x82, 0xA6, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x83, 0xAF, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x83, 0xB0, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x83, 0xB1, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x83, 0xB2, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x83, 0xBD, 0xE3, 0x82, 0x99, 0xE3, 0x82, 0xB3,
+		0xE3, 0x83, 0x88, 0xE1, 0x84, 0x80, 0xE1, 0x84,
+		0x81, 0xE1, 0x86, 0xAA, 0xE1, 0x84, 0x82, 0xE1,
+		0x86, 0xAC, 0xE1, 0x86, 0xAD, 0xE1, 0x84, 0x83,
+		0xE1, 0x84, 0x84, 0xE1, 0x84, 0x85, 0xE1, 0x86,
+		0xB0, 0xE1, 0x86, 0xB1, 0xE1, 0x86, 0xB2, 0xE1,
+		0x86, 0xB3, 0xE1, 0x86, 0xB4, 0xE1, 0x86, 0xB5,
+		0xE1, 0x84, 0x9A, 0xE1, 0x84, 0x86, 0xE1, 0x84,
+		0x87, 0xE1, 0x84, 0x88, 0xE1, 0x84, 0xA1, 0xE1,
+		0x84, 0x89, 0xE1, 0x84, 0x8A, 0xE1, 0x84, 0x8B,
+		0xE1, 0x84, 0x8C, 0xE1, 0x84, 0x8D, 0xE1, 0x84,
+		0x8E, 0xE1, 0x84, 0x8F, 0xE1, 0x84, 0x90, 0xE1,
+		0x84, 0x91, 0xE1, 0x84, 0x92, 0xE1, 0x85, 0xA1,
+		0xE1, 0x85, 0xA2, 0xE1, 0x85, 0xA3, 0xE1, 0x85,
+		0xA4, 0xE1, 0x85, 0xA5, 0xE1, 0x85, 0xA6, 0xE1,
+		0x85, 0xA7, 0xE1, 0x85, 0xA8, 0xE1, 0x85, 0xA9,
+		0xE1, 0x85, 0xAA, 0xE1, 0x85, 0xAB, 0xE1, 0x85,
+		0xAC, 0xE1, 0x85, 0xAD, 0xE1, 0x85, 0xAE, 0xE1,
+		0x85, 0xAF, 0xE1, 0x85, 0xB0, 0xE1, 0x85, 0xB1,
+		0xE1, 0x85, 0xB2, 0xE1, 0x85, 0xB3, 0xE1, 0x85,
+		0xB4, 0xE1, 0x85, 0xB5, 0xE1, 0x85, 0xA0, 0xE1,
+		0x84, 0x94, 0xE1, 0x84, 0x95, 0xE1, 0x87, 0x87,
+		0xE1, 0x87, 0x88, 0xE1, 0x87, 0x8C, 0xE1, 0x87,
+		0x8E, 0xE1, 0x87, 0x93, 0xE1, 0x87, 0x97, 0xE1,
+		0x87, 0x99, 0xE1, 0x84, 0x9C, 0xE1, 0x87, 0x9D,
+		0xE1, 0x87, 0x9F, 0xE1, 0x84, 0x9D, 0xE1, 0x84,
+		0x9E, 0xE1, 0x84, 0xA0, 0xE1, 0x84, 0xA2, 0xE1,
+		0x84, 0xA3, 0xE1, 0x84, 0xA7, 0xE1, 0x84, 0xA9,
+		0xE1, 0x84, 0xAB, 0xE1, 0x84, 0xAC, 0xE1, 0x84,
+		0xAD, 0xE1, 0x84, 0xAE, 0xE1, 0x84, 0xAF, 0xE1,
+		0x84, 0xB2, 0xE1, 0x84, 0xB6, 0xE1, 0x85, 0x80,
+		0xE1, 0x85, 0x87, 0xE1, 0x85, 0x8C, 0xE1, 0x87,
+		0xB1, 0xE1, 0x87, 0xB2, 0xE1, 0x85, 0x97, 0xE1,
+		0x85, 0x98, 0xE1, 0x85, 0x99, 0xE1, 0x86, 0x84,
+		0xE1, 0x86, 0x85, 0xE1, 0x86, 0x88, 0xE1, 0x86,
+		0x91, 0xE1, 0x86, 0x92, 0xE1, 0x86, 0x94, 0xE1,
+		0x86, 0x9E, 0xE1, 0x86, 0xA1, 0xE4, 0xB8, 0x80,
+		0xE4, 0xBA, 0x8C, 0xE4, 0xB8, 0x89, 0xE5, 0x9B,
+		0x9B, 0xE4, 0xB8, 0x8A, 0xE4, 0xB8, 0xAD, 0xE4,
+		0xB8, 0x8B, 0xE7, 0x94, 0xB2, 0xE4, 0xB9, 0x99,
+		0xE4, 0xB8, 0x99, 0xE4, 0xB8, 0x81, 0xE5, 0xA4,
+		0xA9, 0xE5, 0x9C, 0xB0, 0xE4, 0xBA, 0xBA, 0x28,
+		0xE1, 0x84, 0x80, 0x29, 0x28, 0xE1, 0x84, 0x82,
+		0x29, 0x28, 0xE1, 0x84, 0x83, 0x29, 0x28, 0xE1,
+		0x84, 0x85, 0x29, 0x28, 0xE1, 0x84, 0x86, 0x29,
+		0x28, 0xE1, 0x84, 0x87, 0x29, 0x28, 0xE1, 0x84,
+		0x89, 0x29, 0x28, 0xE1, 0x84, 0x8B, 0x29, 0x28,
+		0xE1, 0x84, 0x8C, 0x29, 0x28, 0xE1, 0x84, 0x8E,
+		0x29, 0x28, 0xE1, 0x84, 0x8F, 0x29, 0x28, 0xE1,
+		0x84, 0x90, 0x29, 0x28, 0xE1, 0x84, 0x91, 0x29,
+		0x28, 0xE1, 0x84, 0x92, 0x29, 0x28, 0xE1, 0x84,
+		0x80, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x82, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x83, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x85, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x86, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x87, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x89, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x8B, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x8C, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x8E, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x8F, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x90, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x91, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x92, 0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84,
+		0x8C, 0xE1, 0x85, 0xAE, 0x29, 0x28, 0xE4, 0xB8,
+		0x80, 0x29, 0x28, 0xE4, 0xBA, 0x8C, 0x29, 0x28,
+		0xE4, 0xB8, 0x89, 0x29, 0x28, 0xE5, 0x9B, 0x9B,
+		0x29, 0x28, 0xE4, 0xBA, 0x94, 0x29, 0x28, 0xE5,
+		0x85, 0xAD, 0x29, 0x28, 0xE4, 0xB8, 0x83, 0x29,
+		0x28, 0xE5, 0x85, 0xAB, 0x29, 0x28, 0xE4, 0xB9,
+		0x9D, 0x29, 0x28, 0xE5, 0x8D, 0x81, 0x29, 0x28,
+		0xE6, 0x9C, 0x88, 0x29, 0x28, 0xE7, 0x81, 0xAB,
+		0x29, 0x28, 0xE6, 0xB0, 0xB4, 0x29, 0x28, 0xE6,
+		0x9C, 0xA8, 0x29, 0x28, 0xE9, 0x87, 0x91, 0x29,
+		0x28, 0xE5, 0x9C, 0x9F, 0x29, 0x28, 0xE6, 0x97,
+		0xA5, 0x29, 0x28, 0xE6, 0xA0, 0xAA, 0x29, 0x28,
+		0xE6, 0x9C, 0x89, 0x29, 0x28, 0xE7, 0xA4, 0xBE,
+		0x29, 0x28, 0xE5, 0x90, 0x8D, 0x29, 0x28, 0xE7,
+		0x89, 0xB9, 0x29, 0x28, 0xE8, 0xB2, 0xA1, 0x29,
+		0x28, 0xE7, 0xA5, 0x9D, 0x29, 0x28, 0xE5, 0x8A,
+		0xB4, 0x29, 0x28, 0xE4, 0xBB, 0xA3, 0x29, 0x28,
+		0xE5, 0x91, 0xBC, 0x29, 0x28, 0xE5, 0xAD, 0xA6,
+		0x29, 0x28, 0xE7, 0x9B, 0xA3, 0x29, 0x28, 0xE4,
+		0xBC, 0x81, 0x29, 0x28, 0xE8, 0xB3, 0x87, 0x29,
+		0x28, 0xE5, 0x8D, 0x94, 0x29, 0x28, 0xE7, 0xA5,
+		0xAD, 0x29, 0x28, 0xE4, 0xBC, 0x91, 0x29, 0x28,
+		0xE8, 0x87, 0xAA, 0x29, 0x28, 0xE8, 0x87, 0xB3,
+		0x29, 0x32, 0x31, 0x32, 0x32, 0x32, 0x33, 0x32,
+		0x34, 0x32, 0x35, 0x32, 0x36, 0x32, 0x37, 0x32,
+		0x38, 0x32, 0x39, 0x33, 0x30, 0x33, 0x31, 0x33,
+		0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x35, 0xE1,
+		0x84, 0x80, 0xE1, 0x84, 0x82, 0xE1, 0x84, 0x83,
+		0xE1, 0x84, 0x85, 0xE1, 0x84, 0x86, 0xE1, 0x84,
+		0x87, 0xE1, 0x84, 0x89, 0xE1, 0x84, 0x8B, 0xE1,
+		0x84, 0x8C, 0xE1, 0x84, 0x8E, 0xE1, 0x84, 0x8F,
+		0xE1, 0x84, 0x90, 0xE1, 0x84, 0x91, 0xE1, 0x84,
+		0x92, 0xE1, 0x84, 0x80, 0xE1, 0x85, 0xA1, 0xE1,
+		0x84, 0x82, 0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x83,
+		0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x85, 0xE1, 0x85,
+		0xA1, 0xE1, 0x84, 0x86, 0xE1, 0x85, 0xA1, 0xE1,
+		0x84, 0x87, 0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x89,
+		0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x8B, 0xE1, 0x85,
+		0xA1, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xA1, 0xE1,
+		0x84, 0x8E, 0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x8F,
+		0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x90, 0xE1, 0x85,
+		0xA1, 0xE1, 0x84, 0x91, 0xE1, 0x85, 0xA1, 0xE1,
+		0x84, 0x92, 0xE1, 0x85, 0xA1, 0xE4, 0xB8, 0x80,
+		0xE4, 0xBA, 0x8C, 0xE4, 0xB8, 0x89, 0xE5, 0x9B,
+		0x9B, 0xE4, 0xBA, 0x94, 0xE5, 0x85, 0xAD, 0xE4,
+		0xB8, 0x83, 0xE5, 0x85, 0xAB, 0xE4, 0xB9, 0x9D,
+		0xE5, 0x8D, 0x81, 0xE6, 0x9C, 0x88, 0xE7, 0x81,
+		0xAB, 0xE6, 0xB0, 0xB4, 0xE6, 0x9C, 0xA8, 0xE9,
+		0x87, 0x91, 0xE5, 0x9C, 0x9F, 0xE6, 0x97, 0xA5,
+		0xE6, 0xA0, 0xAA, 0xE6, 0x9C, 0x89, 0xE7, 0xA4,
+		0xBE, 0xE5, 0x90, 0x8D, 0xE7, 0x89, 0xB9, 0xE8,
+		0xB2, 0xA1, 0xE7, 0xA5, 0x9D, 0xE5, 0x8A, 0xB4,
+		0xE7, 0xA7, 0x98, 0xE7, 0x94, 0xB7, 0xE5, 0xA5,
+		0xB3, 0xE9, 0x81, 0xA9, 0xE5, 0x84, 0xAA, 0xE5,
+		0x8D, 0xB0, 0xE6, 0xB3, 0xA8, 0xE9, 0xA0, 0x85,
+		0xE4, 0xBC, 0x91, 0xE5, 0x86, 0x99, 0xE6, 0xAD,
+		0xA3, 0xE4, 0xB8, 0x8A, 0xE4, 0xB8, 0xAD, 0xE4,
+		0xB8, 0x8B, 0xE5, 0xB7, 0xA6, 0xE5, 0x8F, 0xB3,
+		0xE5, 0x8C, 0xBB, 0xE5, 0xAE, 0x97, 0xE5, 0xAD,
+		0xA6, 0xE7, 0x9B, 0xA3, 0xE4, 0xBC, 0x81, 0xE8,
+		0xB3, 0x87, 0xE5, 0x8D, 0x94, 0xE5, 0xA4, 0x9C,
+		0x33, 0x36, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39,
+		0x34, 0x30, 0x34, 0x31, 0x34, 0x32, 0x34, 0x33,
+		0x34, 0x34, 0x34, 0x35, 0x34, 0x36, 0x34, 0x37,
+		0x34, 0x38, 0x34, 0x39, 0x35, 0x30, 0x31, 0xE6,
+		0x9C, 0x88, 0x32, 0xE6, 0x9C, 0x88, 0x33, 0xE6,
+		0x9C, 0x88, 0x34, 0xE6, 0x9C, 0x88, 0x35, 0xE6,
+		0x9C, 0x88, 0x36, 0xE6, 0x9C, 0x88, 0x37, 0xE6,
+		0x9C, 0x88, 0x38, 0xE6, 0x9C, 0x88, 0x39, 0xE6,
+		0x9C, 0x88, 0x31, 0x30, 0xE6, 0x9C, 0x88, 0x31,
+		0x31, 0xE6, 0x9C, 0x88, 0x31, 0x32, 0xE6, 0x9C,
+		0x88, 0xE3, 0x82, 0xA2, 0xE3, 0x82, 0xA4, 0xE3,
+		0x82, 0xA6, 0xE3, 0x82, 0xA8, 0xE3, 0x82, 0xAA,
+		0xE3, 0x82, 0xAB, 0xE3, 0x82, 0xAD, 0xE3, 0x82,
+		0xAF, 0xE3, 0x82, 0xB1, 0xE3, 0x82, 0xB3, 0xE3,
+		0x82, 0xB5, 0xE3, 0x82, 0xB7, 0xE3, 0x82, 0xB9,
+		0xE3, 0x82, 0xBB, 0xE3, 0x82, 0xBD, 0xE3, 0x82,
+		0xBF, 0xE3, 0x83, 0x81, 0xE3, 0x83, 0x84, 0xE3,
+		0x83, 0x86, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0x8A,
+		0xE3, 0x83, 0x8B, 0xE3, 0x83, 0x8C, 0xE3, 0x83,
+		0x8D, 0xE3, 0x83, 0x8E, 0xE3, 0x83, 0x8F, 0xE3,
+		0x83, 0x92, 0xE3, 0x83, 0x95, 0xE3, 0x83, 0x98,
+		0xE3, 0x83, 0x9B, 0xE3, 0x83, 0x9E, 0xE3, 0x83,
+		0x9F, 0xE3, 0x83, 0xA0, 0xE3, 0x83, 0xA1, 0xE3,
+		0x83, 0xA2, 0xE3, 0x83, 0xA4, 0xE3, 0x83, 0xA6,
+		0xE3, 0x83, 0xA8, 0xE3, 0x83, 0xA9, 0xE3, 0x83,
+		0xAA, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0xAC, 0xE3,
+		0x83, 0xAD, 0xE3, 0x83, 0xAF, 0xE3, 0x83, 0xB0,
+		0xE3, 0x83, 0xB1, 0xE3, 0x83, 0xB2, 0xE3, 0x82,
+		0xA2, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0xE3,
+		0x83, 0xBC, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0xA2,
+		0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+		0xA1, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xB3, 0xE3,
+		0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xA2,
+		0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+		0xAB, 0xE3, 0x82, 0xA4, 0xE3, 0x83, 0x8B, 0xE3,
+		0x83, 0xB3, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99,
+		0xE3, 0x82, 0xA4, 0xE3, 0x83, 0xB3, 0xE3, 0x83,
+		0x81, 0xE3, 0x82, 0xA6, 0xE3, 0x82, 0xA9, 0xE3,
+		0x83, 0xB3, 0xE3, 0x82, 0xA8, 0xE3, 0x82, 0xB9,
+		0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+		0x88, 0xE3, 0x82, 0x99, 0xE3, 0x82, 0xA8, 0xE3,
+		0x83, 0xBC, 0xE3, 0x82, 0xAB, 0xE3, 0x83, 0xBC,
+		0xE3, 0x82, 0xAA, 0xE3, 0x83, 0xB3, 0xE3, 0x82,
+		0xB9, 0xE3, 0x82, 0xAA, 0xE3, 0x83, 0xBC, 0xE3,
+		0x83, 0xA0, 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0xA4,
+		0xE3, 0x83, 0xAA, 0xE3, 0x82, 0xAB, 0xE3, 0x83,
+		0xA9, 0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88, 0xE3,
+		0x82, 0xAB, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xAA,
+		0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+		0x99, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xB3, 0xE3,
+		0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xB3,
+		0xE3, 0x83, 0x9E, 0xE3, 0x82, 0xAD, 0xE3, 0x82,
+		0x99, 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3,
+		0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0x8B,
+		0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAD, 0xE3, 0x83,
+		0xA5, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC, 0xE3,
+		0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB,
+		0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+		0xBC, 0xE3, 0x82, 0xAD, 0xE3, 0x83, 0xAD, 0xE3,
+		0x82, 0xAD, 0xE3, 0x83, 0xAD, 0xE3, 0x82, 0xAF,
+		0xE3, 0x82, 0x99, 0xE3, 0x83, 0xA9, 0xE3, 0x83,
+		0xA0, 0xE3, 0x82, 0xAD, 0xE3, 0x83, 0xAD, 0xE3,
+		0x83, 0xA1, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88,
+		0xE3, 0x83, 0xAB, 0xE3, 0x82, 0xAD, 0xE3, 0x83,
+		0xAD, 0xE3, 0x83, 0xAF, 0xE3, 0x83, 0x83, 0xE3,
+		0x83, 0x88, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99,
+		0xE3, 0x83, 0xA9, 0xE3, 0x83, 0xA0, 0xE3, 0x82,
+		0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xA9, 0xE3,
+		0x83, 0xA0, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xB3,
+		0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0xE3, 0x82,
+		0xBB, 0xE3, 0x82, 0x99, 0xE3, 0x82, 0xA4, 0xE3,
+		0x83, 0xAD, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAD,
+		0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x8D, 0xE3, 0x82,
+		0xB1, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xB9, 0xE3,
+		0x82, 0xB3, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x8A,
+		0xE3, 0x82, 0xB3, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+		0x9B, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xB5, 0xE3,
+		0x82, 0xA4, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB,
+		0xE3, 0x82, 0xB5, 0xE3, 0x83, 0xB3, 0xE3, 0x83,
+		0x81, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xA0, 0xE3,
+		0x82, 0xB7, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xB3,
+		0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x82,
+		0xBB, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x81, 0xE3,
+		0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88,
+		0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+		0xBC, 0xE3, 0x82, 0xB9, 0xE3, 0x83, 0x86, 0xE3,
+		0x82, 0x99, 0xE3, 0x82, 0xB7, 0xE3, 0x83, 0x88,
+		0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x83,
+		0x88, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x8A, 0xE3,
+		0x83, 0x8E, 0xE3, 0x83, 0x8E, 0xE3, 0x83, 0x83,
+		0xE3, 0x83, 0x88, 0xE3, 0x83, 0x8F, 0xE3, 0x82,
+		0xA4, 0xE3, 0x83, 0x84, 0xE3, 0x83, 0x8F, 0xE3,
+		0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xBB,
+		0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88, 0xE3, 0x83,
+		0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3,
+		0x83, 0x84, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x99,
+		0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xAC, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3,
+		0x82, 0xA2, 0xE3, 0x82, 0xB9, 0xE3, 0x83, 0x88,
+		0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x92, 0xE3, 0x82,
+		0x9A, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0xE3,
+		0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xB3,
+		0xE3, 0x83, 0x92, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0xA1, 0xE3,
+		0x83, 0xA9, 0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88,
+		0xE3, 0x82, 0x99, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+		0xA3, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88, 0xE3,
+		0x83, 0x95, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0x83,
+		0xE3, 0x82, 0xB7, 0xE3, 0x82, 0xA7, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0x95, 0xE3, 0x83, 0xA9, 0xE3,
+		0x83, 0xB3, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0xAF,
+		0xE3, 0x82, 0xBF, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3,
+		0x82, 0xBD, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A,
+		0xE3, 0x83, 0x8B, 0xE3, 0x83, 0x92, 0xE3, 0x83,
+		0x98, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x84, 0xE3,
+		0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xB3,
+		0xE3, 0x82, 0xB9, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+		0x9A, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xB7, 0xE3,
+		0x82, 0x99, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x99,
+		0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xBF, 0xE3, 0x83,
+		0x9B, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xA4, 0xE3,
+		0x83, 0xB3, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0x9B,
+		0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x83,
+		0x88, 0xE3, 0x83, 0x9B, 0xE3, 0x83, 0xB3, 0xE3,
+		0x83, 0x9B, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xB3,
+		0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+		0x9B, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xAB, 0xE3,
+		0x83, 0x9B, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xB3,
+		0xE3, 0x83, 0x9E, 0xE3, 0x82, 0xA4, 0xE3, 0x82,
+		0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0x9E, 0xE3,
+		0x82, 0xA4, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x9E,
+		0xE3, 0x83, 0x83, 0xE3, 0x83, 0x8F, 0xE3, 0x83,
+		0x9E, 0xE3, 0x83, 0xAB, 0xE3, 0x82, 0xAF, 0xE3,
+		0x83, 0x9E, 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB7,
+		0xE3, 0x83, 0xA7, 0xE3, 0x83, 0xB3, 0xE3, 0x83,
+		0x9F, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAD, 0xE3,
+		0x83, 0xB3, 0xE3, 0x83, 0x9F, 0xE3, 0x83, 0xAA,
+		0xE3, 0x83, 0x9F, 0xE3, 0x83, 0xAA, 0xE3, 0x83,
+		0x8F, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3,
+		0x83, 0xAB, 0xE3, 0x83, 0xA1, 0xE3, 0x82, 0xAB,
+		0xE3, 0x82, 0x99, 0xE3, 0x83, 0xA1, 0xE3, 0x82,
+		0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0x88, 0xE3,
+		0x83, 0xB3, 0xE3, 0x83, 0xA1, 0xE3, 0x83, 0xBC,
+		0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0xE3, 0x83,
+		0xA4, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88, 0xE3,
+		0x82, 0x99, 0xE3, 0x83, 0xA4, 0xE3, 0x83, 0xBC,
+		0xE3, 0x83, 0xAB, 0xE3, 0x83, 0xA6, 0xE3, 0x82,
+		0xA2, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0xAA, 0xE3,
+		0x83, 0x83, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB,
+		0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xA9, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3,
+		0x83, 0xBC, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0xBC,
+		0xE3, 0x83, 0x95, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0xAC, 0xE3, 0x83, 0xA0, 0xE3,
+		0x83, 0xAC, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88,
+		0xE3, 0x82, 0xB1, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+		0xB3, 0xE3, 0x83, 0xAF, 0xE3, 0x83, 0x83, 0xE3,
+		0x83, 0x88, 0x30, 0xE7, 0x82, 0xB9, 0x31, 0xE7,
+		0x82, 0xB9, 0x32, 0xE7, 0x82, 0xB9, 0x33, 0xE7,
+		0x82, 0xB9, 0x34, 0xE7, 0x82, 0xB9, 0x35, 0xE7,
+		0x82, 0xB9, 0x36, 0xE7, 0x82, 0xB9, 0x37, 0xE7,
+		0x82, 0xB9, 0x38, 0xE7, 0x82, 0xB9, 0x39, 0xE7,
+		0x82, 0xB9, 0x31, 0x30, 0xE7, 0x82, 0xB9, 0x31,
+		0x31, 0xE7, 0x82, 0xB9, 0x31, 0x32, 0xE7, 0x82,
+		0xB9, 0x31, 0x33, 0xE7, 0x82, 0xB9, 0x31, 0x34,
+		0xE7, 0x82, 0xB9, 0x31, 0x35, 0xE7, 0x82, 0xB9,
+		0x31, 0x36, 0xE7, 0x82, 0xB9, 0x31, 0x37, 0xE7,
+		0x82, 0xB9, 0x31, 0x38, 0xE7, 0x82, 0xB9, 0x31,
+		0x39, 0xE7, 0x82, 0xB9, 0x32, 0x30, 0xE7, 0x82,
+		0xB9, 0x32, 0x31, 0xE7, 0x82, 0xB9, 0x32, 0x32,
+		0xE7, 0x82, 0xB9, 0x32, 0x33, 0xE7, 0x82, 0xB9,
+		0x32, 0x34, 0xE7, 0x82, 0xB9, 0x68, 0x50, 0x61,
+		0x64, 0x61, 0x41, 0x55, 0x62, 0x61, 0x72, 0x6F,
+		0x56, 0x70, 0x63, 0xE5, 0xB9, 0xB3, 0xE6, 0x88,
+		0x90, 0xE6, 0x98, 0xAD, 0xE5, 0x92, 0x8C, 0xE5,
+		0xA4, 0xA7, 0xE6, 0xAD, 0xA3, 0xE6, 0x98, 0x8E,
+		0xE6, 0xB2, 0xBB, 0xE6, 0xA0, 0xAA, 0xE5, 0xBC,
+		0x8F, 0xE4, 0xBC, 0x9A, 0xE7, 0xA4, 0xBE, 0x70,
+		0x41, 0x6E, 0x41, 0xCE, 0xBC, 0x41, 0x6D, 0x41,
+		0x6B, 0x41, 0x4B, 0x42, 0x4D, 0x42, 0x47, 0x42,
+		0x63, 0x61, 0x6C, 0x6B, 0x63, 0x61, 0x6C, 0x70,
+		0x46, 0x6E, 0x46, 0xCE, 0xBC, 0x46, 0xCE, 0xBC,
+		0x67, 0x6D, 0x67, 0x6B, 0x67, 0x48, 0x7A, 0x6B,
+		0x48, 0x7A, 0x4D, 0x48, 0x7A, 0x47, 0x48, 0x7A,
+		0x54, 0x48, 0x7A, 0xCE, 0xBC, 0x6C, 0x6D, 0x6C,
+		0x64, 0x6C, 0x6B, 0x6C, 0x66, 0x6D, 0x6E, 0x6D,
+		0xCE, 0xBC, 0x6D, 0x6D, 0x6D, 0x63, 0x6D, 0x6B,
+		0x6D, 0x6D, 0x6D, 0x32, 0x63, 0x6D, 0x32, 0x6D,
+		0x32, 0x6B, 0x6D, 0x32, 0x6D, 0x6D, 0x33, 0x63,
+		0x6D, 0x33, 0x6D, 0x33, 0x6B, 0x6D, 0x33, 0x6D,
+		0xE2, 0x88, 0x95, 0x73, 0x6D, 0xE2, 0x88, 0x95,
+		0x73, 0x32, 0x50, 0x61, 0x6B, 0x50, 0x61, 0x4D,
+		0x50, 0x61, 0x47, 0x50, 0x61, 0x72, 0x61, 0x64,
+		0x72, 0x61, 0x64, 0xE2, 0x88, 0x95, 0x73, 0x72,
+		0x61, 0x64, 0xE2, 0x88, 0x95, 0x73, 0x32, 0x70,
+		0x73, 0x6E, 0x73, 0xCE, 0xBC, 0x73, 0x6D, 0x73,
+		0x70, 0x56, 0x6E, 0x56, 0xCE, 0xBC, 0x56, 0x6D,
+		0x56, 0x6B, 0x56, 0x4D, 0x56, 0x70, 0x57, 0x6E,
+		0x57, 0xCE, 0xBC, 0x57, 0x6D, 0x57, 0x6B, 0x57,
+		0x4D, 0x57, 0x6B, 0xCE, 0xA9, 0x4D, 0xCE, 0xA9,
+		0x61, 0x2E, 0x6D, 0x2E, 0x42, 0x71, 0x63, 0x63,
+		0x63, 0x64, 0x43, 0xE2, 0x88, 0x95, 0x6B, 0x67,
+		0x43, 0x6F, 0x2E, 0x64, 0x42, 0x47, 0x79, 0x68,
+		0x61, 0x48, 0x50, 0x69, 0x6E, 0x4B, 0x4B, 0x4B,
+		0x4D, 0x6B, 0x74, 0x6C, 0x6D, 0x6C, 0x6E, 0x6C,
+		0x6F, 0x67, 0x6C, 0x78, 0x6D, 0x62, 0x6D, 0x69,
+		0x6C, 0x6D, 0x6F, 0x6C, 0x50, 0x48, 0x70, 0x2E,
+		0x6D, 0x2E, 0x50, 0x50, 0x4D, 0x50, 0x52, 0x73,
+		0x72, 0x53, 0x76, 0x57, 0x62, 0x31, 0xE6, 0x97,
+		0xA5, 0x32, 0xE6, 0x97, 0xA5, 0x33, 0xE6, 0x97,
+		0xA5, 0x34, 0xE6, 0x97, 0xA5, 0x35, 0xE6, 0x97,
+		0xA5, 0x36, 0xE6, 0x97, 0xA5, 0x37, 0xE6, 0x97,
+		0xA5, 0x38, 0xE6, 0x97, 0xA5, 0x39, 0xE6, 0x97,
+		0xA5, 0x31, 0x30, 0xE6, 0x97, 0xA5, 0x31, 0x31,
+		0xE6, 0x97, 0xA5, 0x31, 0x32, 0xE6, 0x97, 0xA5,
+		0x31, 0x33, 0xE6, 0x97, 0xA5, 0x31, 0x34, 0xE6,
+		0x97, 0xA5, 0x31, 0x35, 0xE6, 0x97, 0xA5, 0x31,
+		0x36, 0xE6, 0x97, 0xA5, 0x31, 0x37, 0xE6, 0x97,
+		0xA5, 0x31, 0x38, 0xE6, 0x97, 0xA5, 0x31, 0x39,
+		0xE6, 0x97, 0xA5, 0x32, 0x30, 0xE6, 0x97, 0xA5,
+		0x32, 0x31, 0xE6, 0x97, 0xA5, 0x32, 0x32, 0xE6,
+		0x97, 0xA5, 0x32, 0x33, 0xE6, 0x97, 0xA5, 0x32,
+		0x34, 0xE6, 0x97, 0xA5, 0x32, 0x35, 0xE6, 0x97,
+		0xA5, 0x32, 0x36, 0xE6, 0x97, 0xA5, 0x32, 0x37,
+		0xE6, 0x97, 0xA5, 0x32, 0x38, 0xE6, 0x97, 0xA5,
+		0x32, 0x39, 0xE6, 0x97, 0xA5, 0x33, 0x30, 0xE6,
+		0x97, 0xA5, 0x33, 0x31, 0xE6, 0x97, 0xA5, 0xF6,
+		0xE8, 0xB1, 0x88, 0xF6, 0xE6, 0x9B, 0xB4, 0xF6,
+		0xE8, 0xBB, 0x8A, 0xF6, 0xE8, 0xB3, 0x88, 0xF6,
+		0xE6, 0xBB, 0x91, 0xF6, 0xE4, 0xB8, 0xB2, 0xF6,
+		0xE5, 0x8F, 0xA5, 0xF6, 0xE9, 0xBE, 0x9C, 0xF6,
+		0xE9, 0xBE, 0x9C, 0xF6, 0xE5, 0xA5, 0x91, 0xF6,
+		0xE9, 0x87, 0x91, 0xF6, 0xE5, 0x96, 0x87, 0xF6,
+		0xE5, 0xA5, 0x88, 0xF6, 0xE6, 0x87, 0xB6, 0xF6,
+		0xE7, 0x99, 0xA9, 0xF6, 0xE7, 0xBE, 0x85, 0xF6,
+		0xE8, 0x98, 0xBF, 0xF6, 0xE8, 0x9E, 0xBA, 0xF6,
+		0xE8, 0xA3, 0xB8, 0xF6, 0xE9, 0x82, 0x8F, 0xF6,
+		0xE6, 0xA8, 0x82, 0xF6, 0xE6, 0xB4, 0x9B, 0xF6,
+		0xE7, 0x83, 0x99, 0xF6, 0xE7, 0x8F, 0x9E, 0xF6,
+		0xE8, 0x90, 0xBD, 0xF6, 0xE9, 0x85, 0xAA, 0xF6,
+		0xE9, 0xA7, 0xB1, 0xF6, 0xE4, 0xBA, 0x82, 0xF6,
+		0xE5, 0x8D, 0xB5, 0xF6, 0xE6, 0xAC, 0x84, 0xF6,
+		0xE7, 0x88, 0x9B, 0xF6, 0xE8, 0x98, 0xAD, 0xF6,
+		0xE9, 0xB8, 0x9E, 0xF6, 0xE5, 0xB5, 0x90, 0xF6,
+		0xE6, 0xBF, 0xAB, 0xF6, 0xE8, 0x97, 0x8D, 0xF6,
+		0xE8, 0xA5, 0xA4, 0xF6, 0xE6, 0x8B, 0x89, 0xF6,
+		0xE8, 0x87, 0x98, 0xF6, 0xE8, 0xA0, 0x9F, 0xF6,
+		0xE5, 0xBB, 0x8A, 0xF6, 0xE6, 0x9C, 0x97, 0xF6,
+		0xE6, 0xB5, 0xAA, 0xF6, 0xE7, 0x8B, 0xBC, 0xF6,
+		0xE9, 0x83, 0x8E, 0xF6, 0xE4, 0xBE, 0x86, 0xF6,
+		0xE5, 0x86, 0xB7, 0xF6, 0xE5, 0x8B, 0x9E, 0xF6,
+		0xE6, 0x93, 0x84, 0xF6, 0xE6, 0xAB, 0x93, 0xF6,
+		0xE7, 0x88, 0x90, 0xF6, 0xE7, 0x9B, 0xA7, 0xF6,
+		0xE8, 0x80, 0x81, 0xF6, 0xE8, 0x98, 0x86, 0xF6,
+		0xE8, 0x99, 0x9C, 0xF6, 0xE8, 0xB7, 0xAF, 0xF6,
+		0xE9, 0x9C, 0xB2, 0xF6, 0xE9, 0xAD, 0xAF, 0xF6,
+		0xE9, 0xB7, 0xBA, 0xF6, 0xE7, 0xA2, 0x8C, 0xF6,
+		0xE7, 0xA5, 0xBF, 0xF6, 0xE7, 0xB6, 0xA0, 0xF6,
+		0xE8, 0x8F, 0x89, 0xF6, 0xE9, 0x8C, 0x84, 0xF6,
+		0xE9, 0xB9, 0xBF, 0xF6, 0xE8, 0xAB, 0x96, 0xF6,
+		0xE5, 0xA3, 0x9F, 0xF6, 0xE5, 0xBC, 0x84, 0xF6,
+		0xE7, 0xB1, 0xA0, 0xF6, 0xE8, 0x81, 0xBE, 0xF6,
+		0xE7, 0x89, 0xA2, 0xF6, 0xE7, 0xA3, 0x8A, 0xF6,
+		0xE8, 0xB3, 0x82, 0xF6, 0xE9, 0x9B, 0xB7, 0xF6,
+		0xE5, 0xA3, 0x98, 0xF6, 0xE5, 0xB1, 0xA2, 0xF6,
+		0xE6, 0xA8, 0x93, 0xF6, 0xE6, 0xB7, 0x9A, 0xF6,
+		0xE6, 0xBC, 0x8F, 0xF6, 0xE7, 0xB4, 0xAF, 0xF6,
+		0xE7, 0xB8, 0xB7, 0xF6, 0xE9, 0x99, 0x8B, 0xF6,
+		0xE5, 0x8B, 0x92, 0xF6, 0xE8, 0x82, 0x8B, 0xF6,
+		0xE5, 0x87, 0x9C, 0xF6, 0xE5, 0x87, 0x8C, 0xF6,
+		0xE7, 0xA8, 0x9C, 0xF6, 0xE7, 0xB6, 0xBE, 0xF6,
+		0xE8, 0x8F, 0xB1, 0xF6, 0xE9, 0x99, 0xB5, 0xF6,
+		0xE8, 0xAE, 0x80, 0xF6, 0xE6, 0x8B, 0x8F, 0xF6,
+		0xE6, 0xA8, 0x82, 0xF6, 0xE8, 0xAB, 0xBE, 0xF6,
+		0xE4, 0xB8, 0xB9, 0xF6, 0xE5, 0xAF, 0xA7, 0xF6,
+		0xE6, 0x80, 0x92, 0xF6, 0xE7, 0x8E, 0x87, 0xF6,
+		0xE7, 0x95, 0xB0, 0xF6, 0xE5, 0x8C, 0x97, 0xF6,
+		0xE7, 0xA3, 0xBB, 0xF6, 0xE4, 0xBE, 0xBF, 0xF6,
+		0xE5, 0xBE, 0xA9, 0xF6, 0xE4, 0xB8, 0x8D, 0xF6,
+		0xE6, 0xB3, 0x8C, 0xF6, 0xE6, 0x95, 0xB8, 0xF6,
+		0xE7, 0xB4, 0xA2, 0xF6, 0xE5, 0x8F, 0x83, 0xF6,
+		0xE5, 0xA1, 0x9E, 0xF6, 0xE7, 0x9C, 0x81, 0xF6,
+		0xE8, 0x91, 0x89, 0xF6, 0xE8, 0xAA, 0xAA, 0xF6,
+		0xE6, 0xAE, 0xBA, 0xF6, 0xE8, 0xBE, 0xB0, 0xF6,
+		0xE6, 0xB2, 0x88, 0xF6, 0xE6, 0x8B, 0xBE, 0xF6,
+		0xE8, 0x8B, 0xA5, 0xF6, 0xE6, 0x8E, 0xA0, 0xF6,
+		0xE7, 0x95, 0xA5, 0xF6, 0xE4, 0xBA, 0xAE, 0xF6,
+		0xE5, 0x85, 0xA9, 0xF6, 0xE5, 0x87, 0x89, 0xF6,
+		0xE6, 0xA2, 0x81, 0xF6, 0xE7, 0xB3, 0xA7, 0xF6,
+		0xE8, 0x89, 0xAF, 0xF6, 0xE8, 0xAB, 0x92, 0xF6,
+		0xE9, 0x87, 0x8F, 0xF6, 0xE5, 0x8B, 0xB5, 0xF6,
+		0xE5, 0x91, 0x82, 0xF6, 0xE5, 0xA5, 0xB3, 0xF6,
+		0xE5, 0xBB, 0xAC, 0xF6, 0xE6, 0x97, 0x85, 0xF6,
+		0xE6, 0xBF, 0xBE, 0xF6, 0xE7, 0xA4, 0xAA, 0xF6,
+		0xE9, 0x96, 0xAD, 0xF6, 0xE9, 0xA9, 0xAA, 0xF6,
+		0xE9, 0xBA, 0x97, 0xF6, 0xE9, 0xBB, 0x8E, 0xF6,
+		0xE5, 0x8A, 0x9B, 0xF6, 0xE6, 0x9B, 0x86, 0xF6,
+		0xE6, 0xAD, 0xB7, 0xF6, 0xE8, 0xBD, 0xA2, 0xF6,
+		0xE5, 0xB9, 0xB4, 0xF6, 0xE6, 0x86, 0x90, 0xF6,
+		0xE6, 0x88, 0x80, 0xF6, 0xE6, 0x92, 0x9A, 0xF6,
+		0xE6, 0xBC, 0xA3, 0xF6, 0xE7, 0x85, 0x89, 0xF6,
+		0xE7, 0x92, 0x89, 0xF6, 0xE7, 0xA7, 0x8A, 0xF6,
+		0xE7, 0xB7, 0xB4, 0xF6, 0xE8, 0x81, 0xAF, 0xF6,
+		0xE8, 0xBC, 0xA6, 0xF6, 0xE8, 0x93, 0xAE, 0xF6,
+		0xE9, 0x80, 0xA3, 0xF6, 0xE9, 0x8D, 0x8A, 0xF6,
+		0xE5, 0x88, 0x97, 0xF6, 0xE5, 0x8A, 0xA3, 0xF6,
+		0xE5, 0x92, 0xBD, 0xF6, 0xE7, 0x83, 0x88, 0xF6,
+		0xE8, 0xA3, 0x82, 0xF6, 0xE8, 0xAA, 0xAA, 0xF6,
+		0xE5, 0xBB, 0x89, 0xF6, 0xE5, 0xBF, 0xB5, 0xF6,
+		0xE6, 0x8D, 0xBB, 0xF6, 0xE6, 0xAE, 0xAE, 0xF6,
+		0xE7, 0xB0, 0xBE, 0xF6, 0xE7, 0x8D, 0xB5, 0xF6,
+		0xE4, 0xBB, 0xA4, 0xF6, 0xE5, 0x9B, 0xB9, 0xF6,
+		0xE5, 0xAF, 0xA7, 0xF6, 0xE5, 0xB6, 0xBA, 0xF6,
+		0xE6, 0x80, 0x9C, 0xF6, 0xE7, 0x8E, 0xB2, 0xF6,
+		0xE7, 0x91, 0xA9, 0xF6, 0xE7, 0xBE, 0x9A, 0xF6,
+		0xE8, 0x81, 0x86, 0xF6, 0xE9, 0x88, 0xB4, 0xF6,
+		0xE9, 0x9B, 0xB6, 0xF6, 0xE9, 0x9D, 0x88, 0xF6,
+		0xE9, 0xA0, 0x98, 0xF6, 0xE4, 0xBE, 0x8B, 0xF6,
+		0xE7, 0xA6, 0xAE, 0xF6, 0xE9, 0x86, 0xB4, 0xF6,
+		0xE9, 0x9A, 0xB8, 0xF6, 0xE6, 0x83, 0xA1, 0xF6,
+		0xE4, 0xBA, 0x86, 0xF6, 0xE5, 0x83, 0x9A, 0xF6,
+		0xE5, 0xAF, 0xAE, 0xF6, 0xE5, 0xB0, 0xBF, 0xF6,
+		0xE6, 0x96, 0x99, 0xF6, 0xE6, 0xA8, 0x82, 0xF6,
+		0xE7, 0x87, 0x8E, 0xF6, 0xE7, 0x99, 0x82, 0xF6,
+		0xE8, 0x93, 0xBC, 0xF6, 0xE9, 0x81, 0xBC, 0xF6,
+		0xE9, 0xBE, 0x8D, 0xF6, 0xE6, 0x9A, 0x88, 0xF6,
+		0xE9, 0x98, 0xAE, 0xF6, 0xE5, 0x8A, 0x89, 0xF6,
+		0xE6, 0x9D, 0xBB, 0xF6, 0xE6, 0x9F, 0xB3, 0xF6,
+		0xE6, 0xB5, 0x81, 0xF6, 0xE6, 0xBA, 0x9C, 0xF6,
+		0xE7, 0x90, 0x89, 0xF6, 0xE7, 0x95, 0x99, 0xF6,
+		0xE7, 0xA1, 0xAB, 0xF6, 0xE7, 0xB4, 0x90, 0xF6,
+		0xE9, 0xA1, 0x9E, 0xF6, 0xE5, 0x85, 0xAD, 0xF6,
+		0xE6, 0x88, 0xAE, 0xF6, 0xE9, 0x99, 0xB8, 0xF6,
+		0xE5, 0x80, 0xAB, 0xF6, 0xE5, 0xB4, 0x99, 0xF6,
+		0xE6, 0xB7, 0xAA, 0xF6, 0xE8, 0xBC, 0xAA, 0xF6,
+		0xE5, 0xBE, 0x8B, 0xF6, 0xE6, 0x85, 0x84, 0xF6,
+		0xE6, 0xA0, 0x97, 0xF6, 0xE7, 0x8E, 0x87, 0xF6,
+		0xE9, 0x9A, 0x86, 0xF6, 0xE5, 0x88, 0xA9, 0xF6,
+		0xE5, 0x90, 0x8F, 0xF6, 0xE5, 0xB1, 0xA5, 0xF6,
+		0xE6, 0x98, 0x93, 0xF6, 0xE6, 0x9D, 0x8E, 0xF6,
+		0xE6, 0xA2, 0xA8, 0xF6, 0xE6, 0xB3, 0xA5, 0xF6,
+		0xE7, 0x90, 0x86, 0xF6, 0xE7, 0x97, 0xA2, 0xF6,
+		0xE7, 0xBD, 0xB9, 0xF6, 0xE8, 0xA3, 0x8F, 0xF6,
+		0xE8, 0xA3, 0xA1, 0xF6, 0xE9, 0x87, 0x8C, 0xF6,
+		0xE9, 0x9B, 0xA2, 0xF6, 0xE5, 0x8C, 0xBF, 0xF6,
+		0xE6, 0xBA, 0xBA, 0xF6, 0xE5, 0x90, 0x9D, 0xF6,
+		0xE7, 0x87, 0x90, 0xF6, 0xE7, 0x92, 0x98, 0xF6,
+		0xE8, 0x97, 0xBA, 0xF6, 0xE9, 0x9A, 0xA3, 0xF6,
+		0xE9, 0xB1, 0x97, 0xF6, 0xE9, 0xBA, 0x9F, 0xF6,
+		0xE6, 0x9E, 0x97, 0xF6, 0xE6, 0xB7, 0x8B, 0xF6,
+		0xE8, 0x87, 0xA8, 0xF6, 0xE7, 0xAB, 0x8B, 0xF6,
+		0xE7, 0xAC, 0xA0, 0xF6, 0xE7, 0xB2, 0x92, 0xF6,
+		0xE7, 0x8B, 0x80, 0xF6, 0xE7, 0x82, 0x99, 0xF6,
+		0xE8, 0xAD, 0x98, 0xF6, 0xE4, 0xBB, 0x80, 0xF6,
+		0xE8, 0x8C, 0xB6, 0xF6, 0xE5, 0x88, 0xBA, 0xF6,
+		0xE5, 0x88, 0x87, 0xF6, 0xE5, 0xBA, 0xA6, 0xF6,
+		0xE6, 0x8B, 0x93, 0xF6, 0xE7, 0xB3, 0x96, 0xF6,
+		0xE5, 0xAE, 0x85, 0xF6, 0xE6, 0xB4, 0x9E, 0xF6,
+		0xE6, 0x9A, 0xB4, 0xF6, 0xE8, 0xBC, 0xBB, 0xF6,
+		0xE8, 0xA1, 0x8C, 0xF6, 0xE9, 0x99, 0x8D, 0xF6,
+		0xE8, 0xA6, 0x8B, 0xF6, 0xE5, 0xBB, 0x93, 0xF6,
+		0xE5, 0x85, 0x80, 0xF6, 0xE5, 0x97, 0x80, 0xF6,
+		0xE5, 0xA1, 0x9A, 0xF6, 0xE6, 0x99, 0xB4, 0xF6,
+		0xE5, 0x87, 0x9E, 0xF6, 0xE7, 0x8C, 0xAA, 0xF6,
+		0xE7, 0x9B, 0x8A, 0xF6, 0xE7, 0xA4, 0xBC, 0xF6,
+		0xE7, 0xA5, 0x9E, 0xF6, 0xE7, 0xA5, 0xA5, 0xF6,
+		0xE7, 0xA6, 0x8F, 0xF6, 0xE9, 0x9D, 0x96, 0xF6,
+		0xE7, 0xB2, 0xBE, 0xF6, 0xE7, 0xBE, 0xBD, 0xF6,
+		0xE8, 0x98, 0x92, 0xF6, 0xE8, 0xAB, 0xB8, 0xF6,
+		0xE9, 0x80, 0xB8, 0xF6, 0xE9, 0x83, 0xBD, 0xF6,
+		0xE9, 0xA3, 0xAF, 0xF6, 0xE9, 0xA3, 0xBC, 0xF6,
+		0xE9, 0xA4, 0xA8, 0xF6, 0xE9, 0xB6, 0xB4, 0xF6,
+		0xE4, 0xBE, 0xAE, 0xF6, 0xE5, 0x83, 0xA7, 0xF6,
+		0xE5, 0x85, 0x8D, 0xF6, 0xE5, 0x8B, 0x89, 0xF6,
+		0xE5, 0x8B, 0xA4, 0xF6, 0xE5, 0x8D, 0x91, 0xF6,
+		0xE5, 0x96, 0x9D, 0xF6, 0xE5, 0x98, 0x86, 0xF6,
+		0xE5, 0x99, 0xA8, 0xF6, 0xE5, 0xA1, 0x80, 0xF6,
+		0xE5, 0xA2, 0xA8, 0xF6, 0xE5, 0xB1, 0xA4, 0xF6,
+		0xE5, 0xB1, 0xAE, 0xF6, 0xE6, 0x82, 0x94, 0xF6,
+		0xE6, 0x85, 0xA8, 0xF6, 0xE6, 0x86, 0x8E, 0xF6,
+		0xE6, 0x87, 0xB2, 0xF6, 0xE6, 0x95, 0x8F, 0xF6,
+		0xE6, 0x97, 0xA2, 0xF6, 0xE6, 0x9A, 0x91, 0xF6,
+		0xE6, 0xA2, 0x85, 0xF6, 0xE6, 0xB5, 0xB7, 0xF6,
+		0xE6, 0xB8, 0x9A, 0xF6, 0xE6, 0xBC, 0xA2, 0xF6,
+		0xE7, 0x85, 0xAE, 0xF6, 0xE7, 0x88, 0xAB, 0xF6,
+		0xE7, 0x90, 0xA2, 0xF6, 0xE7, 0xA2, 0x91, 0xF6,
+		0xE7, 0xA4, 0xBE, 0xF6, 0xE7, 0xA5, 0x89, 0xF6,
+		0xE7, 0xA5, 0x88, 0xF6, 0xE7, 0xA5, 0x90, 0xF6,
+		0xE7, 0xA5, 0x96, 0xF6, 0xE7, 0xA5, 0x9D, 0xF6,
+		0xE7, 0xA6, 0x8D, 0xF6, 0xE7, 0xA6, 0x8E, 0xF6,
+		0xE7, 0xA9, 0x80, 0xF6, 0xE7, 0xAA, 0x81, 0xF6,
+		0xE7, 0xAF, 0x80, 0xF6, 0xE7, 0xB7, 0xB4, 0xF6,
+		0xE7, 0xB8, 0x89, 0xF6, 0xE7, 0xB9, 0x81, 0xF6,
+		0xE7, 0xBD, 0xB2, 0xF6, 0xE8, 0x80, 0x85, 0xF6,
+		0xE8, 0x87, 0xAD, 0xF6, 0xE8, 0x89, 0xB9, 0xF6,
+		0xE8, 0x89, 0xB9, 0xF6, 0xE8, 0x91, 0x97, 0xF6,
+		0xE8, 0xA4, 0x90, 0xF6, 0xE8, 0xA6, 0x96, 0xF6,
+		0xE8, 0xAC, 0x81, 0xF6, 0xE8, 0xAC, 0xB9, 0xF6,
+		0xE8, 0xB3, 0x93, 0xF6, 0xE8, 0xB4, 0x88, 0xF6,
+		0xE8, 0xBE, 0xB6, 0xF6, 0xE9, 0x80, 0xB8, 0xF6,
+		0xE9, 0x9B, 0xA3, 0xF6, 0xE9, 0x9F, 0xBF, 0xF6,
+		0xE9, 0xA0, 0xBB, 0x66, 0x66, 0x66, 0x69, 0x66,
+		0x6C, 0x66, 0x66, 0x69, 0x66, 0x66, 0x6C, 0x73,
+		0x74, 0x73, 0x74, 0xD5, 0xB4, 0xD5, 0xB6, 0xD5,
+		0xB4, 0xD5, 0xA5, 0xD5, 0xB4, 0xD5, 0xAB, 0xD5,
+		0xBE, 0xD5, 0xB6, 0xD5, 0xB4, 0xD5, 0xAD, 0xF6,
+		0xD7, 0x99, 0xD6, 0xB4, 0xF6, 0xD7, 0xB2, 0xD6,
+		0xB7, 0xD7, 0xA2, 0xD7, 0x90, 0xD7, 0x93, 0xD7,
+		0x94, 0xD7, 0x9B, 0xD7, 0x9C, 0xD7, 0x9D, 0xD7,
+		0xA8, 0xD7, 0xAA, 0x2B, 0xF6, 0xD7, 0xA9, 0xD7,
+		0x81, 0xF6, 0xD7, 0xA9, 0xD7, 0x82, 0xF6, 0xD7,
+		0xA9, 0xD6, 0xBC, 0xD7, 0x81, 0xF6, 0xD7, 0xA9,
+		0xD6, 0xBC, 0xD7, 0x82, 0xF6, 0xD7, 0x90, 0xD6,
+		0xB7, 0xF6, 0xD7, 0x90, 0xD6, 0xB8, 0xF6, 0xD7,
+		0x90, 0xD6, 0xBC, 0xF6, 0xD7, 0x91, 0xD6, 0xBC,
+		0xF6, 0xD7, 0x92, 0xD6, 0xBC, 0xF6, 0xD7, 0x93,
+		0xD6, 0xBC, 0xF6, 0xD7, 0x94, 0xD6, 0xBC, 0xF6,
+		0xD7, 0x95, 0xD6, 0xBC, 0xF6, 0xD7, 0x96, 0xD6,
+		0xBC, 0xF6, 0xD7, 0x98, 0xD6, 0xBC, 0xF6, 0xD7,
+		0x99, 0xD6, 0xBC, 0xF6, 0xD7, 0x9A, 0xD6, 0xBC,
+		0xF6, 0xD7, 0x9B, 0xD6, 0xBC, 0xF6, 0xD7, 0x9C,
+		0xD6, 0xBC, 0xF6, 0xD7, 0x9E, 0xD6, 0xBC, 0xF6,
+		0xD7, 0xA0, 0xD6, 0xBC, 0xF6, 0xD7, 0xA1, 0xD6,
+		0xBC, 0xF6, 0xD7, 0xA3, 0xD6, 0xBC, 0xF6, 0xD7,
+		0xA4, 0xD6, 0xBC, 0xF6, 0xD7, 0xA6, 0xD6, 0xBC,
+		0xF6, 0xD7, 0xA7, 0xD6, 0xBC, 0xF6, 0xD7, 0xA8,
+		0xD6, 0xBC, 0xF6, 0xD7, 0xA9, 0xD6, 0xBC, 0xF6,
+		0xD7, 0xAA, 0xD6, 0xBC, 0xF6, 0xD7, 0x95, 0xD6,
+		0xB9, 0xF6, 0xD7, 0x91, 0xD6, 0xBF, 0xF6, 0xD7,
+		0x9B, 0xD6, 0xBF, 0xF6, 0xD7, 0xA4, 0xD6, 0xBF,
+		0xD7, 0x90, 0xD7, 0x9C, 0xD9, 0xB1, 0xD9, 0xB1,
+		0xD9, 0xBB, 0xD9, 0xBB, 0xD9, 0xBB, 0xD9, 0xBB,
+		0xD9, 0xBE, 0xD9, 0xBE, 0xD9, 0xBE, 0xD9, 0xBE,
+		0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80,
+		0xD9, 0xBA, 0xD9, 0xBA, 0xD9, 0xBA, 0xD9, 0xBA,
+		0xD9, 0xBF, 0xD9, 0xBF, 0xD9, 0xBF, 0xD9, 0xBF,
+		0xD9, 0xB9, 0xD9, 0xB9, 0xD9, 0xB9, 0xD9, 0xB9,
+		0xDA, 0xA4, 0xDA, 0xA4, 0xDA, 0xA4, 0xDA, 0xA4,
+		0xDA, 0xA6, 0xDA, 0xA6, 0xDA, 0xA6, 0xDA, 0xA6,
+		0xDA, 0x84, 0xDA, 0x84, 0xDA, 0x84, 0xDA, 0x84,
+		0xDA, 0x83, 0xDA, 0x83, 0xDA, 0x83, 0xDA, 0x83,
+		0xDA, 0x86, 0xDA, 0x86, 0xDA, 0x86, 0xDA, 0x86,
+		0xDA, 0x87, 0xDA, 0x87, 0xDA, 0x87, 0xDA, 0x87,
+		0xDA, 0x8D, 0xDA, 0x8D, 0xDA, 0x8C, 0xDA, 0x8C,
+		0xDA, 0x8E, 0xDA, 0x8E, 0xDA, 0x88, 0xDA, 0x88,
+		0xDA, 0x98, 0xDA, 0x98, 0xDA, 0x91, 0xDA, 0x91,
+		0xDA, 0xA9, 0xDA, 0xA9, 0xDA, 0xA9, 0xDA, 0xA9,
+		0xDA, 0xAF, 0xDA, 0xAF, 0xDA, 0xAF, 0xDA, 0xAF,
+		0xDA, 0xB3, 0xDA, 0xB3, 0xDA, 0xB3, 0xDA, 0xB3,
+		0xDA, 0xB1, 0xDA, 0xB1, 0xDA, 0xB1, 0xDA, 0xB1,
+		0xDA, 0xBA, 0xDA, 0xBA, 0xDA, 0xBB, 0xDA, 0xBB,
+		0xDA, 0xBB, 0xDA, 0xBB, 0xDB, 0x95, 0xD9, 0x94,
+		0xDB, 0x95, 0xD9, 0x94, 0xDB, 0x81, 0xDB, 0x81,
+		0xDB, 0x81, 0xDB, 0x81, 0xDA, 0xBE, 0xDA, 0xBE,
+		0xDA, 0xBE, 0xDA, 0xBE, 0xDB, 0x92, 0xDB, 0x92,
+		0xDB, 0x92, 0xD9, 0x94, 0xDB, 0x92, 0xD9, 0x94,
+		0xDA, 0xAD, 0xDA, 0xAD, 0xDA, 0xAD, 0xDA, 0xAD,
+		0xDB, 0x87, 0xDB, 0x87, 0xDB, 0x86, 0xDB, 0x86,
+		0xDB, 0x88, 0xDB, 0x88, 0xDB, 0x87, 0xD9, 0xB4,
+		0xDB, 0x8B, 0xDB, 0x8B, 0xDB, 0x85, 0xDB, 0x85,
+		0xDB, 0x89, 0xDB, 0x89, 0xDB, 0x90, 0xDB, 0x90,
+		0xDB, 0x90, 0xDB, 0x90, 0xD9, 0x89, 0xD9, 0x89,
+		0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xA7, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD8, 0xA7, 0xD9, 0x8A, 0xD9, 0x94,
+		0xDB, 0x95, 0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x95,
+		0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x88, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD9, 0x88, 0xD9, 0x8A, 0xD9, 0x94,
+		0xDB, 0x87, 0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x87,
+		0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x86, 0xD9, 0x8A,
+		0xD9, 0x94, 0xDB, 0x86, 0xD9, 0x8A, 0xD9, 0x94,
+		0xDB, 0x88, 0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x88,
+		0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x90, 0xD9, 0x8A,
+		0xD9, 0x94, 0xDB, 0x90, 0xD9, 0x8A, 0xD9, 0x94,
+		0xDB, 0x90, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x89,
+		0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x89, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD9, 0x89, 0xDB, 0x8C, 0xDB, 0x8C,
+		0xDB, 0x8C, 0xDB, 0x8C, 0xD9, 0x8A, 0xD9, 0x94,
+		0xD8, 0xAC, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAD,
+		0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x85, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD9, 0x89, 0xD9, 0x8A, 0xD9, 0x94,
+		0xD9, 0x8A, 0xD8, 0xA8, 0xD8, 0xAC, 0xD8, 0xA8,
+		0xD8, 0xAD, 0xD8, 0xA8, 0xD8, 0xAE, 0xD8, 0xA8,
+		0xD9, 0x85, 0xD8, 0xA8, 0xD9, 0x89, 0xD8, 0xA8,
+		0xD9, 0x8A, 0xD8, 0xAA, 0xD8, 0xAC, 0xD8, 0xAA,
+		0xD8, 0xAD, 0xD8, 0xAA, 0xD8, 0xAE, 0xD8, 0xAA,
+		0xD9, 0x85, 0xD8, 0xAA, 0xD9, 0x89, 0xD8, 0xAA,
+		0xD9, 0x8A, 0xD8, 0xAB, 0xD8, 0xAC, 0xD8, 0xAB,
+		0xD9, 0x85, 0xD8, 0xAB, 0xD9, 0x89, 0xD8, 0xAB,
+		0xD9, 0x8A, 0xD8, 0xAC, 0xD8, 0xAD, 0xD8, 0xAC,
+		0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xAC, 0xD8, 0xAD,
+		0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xAC, 0xD8, 0xAE,
+		0xD8, 0xAD, 0xD8, 0xAE, 0xD9, 0x85, 0xD8, 0xB3,
+		0xD8, 0xAC, 0xD8, 0xB3, 0xD8, 0xAD, 0xD8, 0xB3,
+		0xD8, 0xAE, 0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xB5,
+		0xD8, 0xAD, 0xD8, 0xB5, 0xD9, 0x85, 0xD8, 0xB6,
+		0xD8, 0xAC, 0xD8, 0xB6, 0xD8, 0xAD, 0xD8, 0xB6,
+		0xD8, 0xAE, 0xD8, 0xB6, 0xD9, 0x85, 0xD8, 0xB7,
+		0xD8, 0xAD, 0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xB8,
+		0xD9, 0x85, 0xD8, 0xB9, 0xD8, 0xAC, 0xD8, 0xB9,
+		0xD9, 0x85, 0xD8, 0xBA, 0xD8, 0xAC, 0xD8, 0xBA,
+		0xD9, 0x85, 0xD9, 0x81, 0xD8, 0xAC, 0xD9, 0x81,
+		0xD8, 0xAD, 0xD9, 0x81, 0xD8, 0xAE, 0xD9, 0x81,
+		0xD9, 0x85, 0xD9, 0x81, 0xD9, 0x89, 0xD9, 0x81,
+		0xD9, 0x8A, 0xD9, 0x82, 0xD8, 0xAD, 0xD9, 0x82,
+		0xD9, 0x85, 0xD9, 0x82, 0xD9, 0x89, 0xD9, 0x82,
+		0xD9, 0x8A, 0xD9, 0x83, 0xD8, 0xA7, 0xD9, 0x83,
+		0xD8, 0xAC, 0xD9, 0x83, 0xD8, 0xAD, 0xD9, 0x83,
+		0xD8, 0xAE, 0xD9, 0x83, 0xD9, 0x84, 0xD9, 0x83,
+		0xD9, 0x85, 0xD9, 0x83, 0xD9, 0x89, 0xD9, 0x83,
+		0xD9, 0x8A, 0xD9, 0x84, 0xD8, 0xAC, 0xD9, 0x84,
+		0xD8, 0xAD, 0xD9, 0x84, 0xD8, 0xAE, 0xD9, 0x84,
+		0xD9, 0x85, 0xD9, 0x84, 0xD9, 0x89, 0xD9, 0x84,
+		0xD9, 0x8A, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x85,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAE, 0xD9, 0x85,
+		0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x89, 0xD9, 0x85,
+		0xD9, 0x8A, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x86,
+		0xD8, 0xAD, 0xD9, 0x86, 0xD8, 0xAE, 0xD9, 0x86,
+		0xD9, 0x85, 0xD9, 0x86, 0xD9, 0x89, 0xD9, 0x86,
+		0xD9, 0x8A, 0xD9, 0x87, 0xD8, 0xAC, 0xD9, 0x87,
+		0xD9, 0x85, 0xD9, 0x87, 0xD9, 0x89, 0xD9, 0x87,
+		0xD9, 0x8A, 0xD9, 0x8A, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD8, 0xAD, 0xD9, 0x8A, 0xD8, 0xAE, 0xD9, 0x8A,
+		0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x89, 0xD9, 0x8A,
+		0xD9, 0x8A, 0xD8, 0xB0, 0xD9, 0xB0, 0xD8, 0xB1,
+		0xD9, 0xB0, 0xD9, 0x89, 0xD9, 0xB0, 0x20, 0xD9,
+		0x8C, 0xD9, 0x91, 0x20, 0xD9, 0x8D, 0xD9, 0x91,
+		0x20, 0xD9, 0x8E, 0xD9, 0x91, 0x20, 0xD9, 0x8F,
+		0xD9, 0x91, 0x20, 0xD9, 0x90, 0xD9, 0x91, 0x20,
+		0xD9, 0x91, 0xD9, 0xB0, 0xD9, 0x8A, 0xD9, 0x94,
+		0xD8, 0xB1, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xB2,
+		0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x85, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD9, 0x86, 0xD9, 0x8A, 0xD9, 0x94,
+		0xD9, 0x89, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x8A,
+		0xD8, 0xA8, 0xD8, 0xB1, 0xD8, 0xA8, 0xD8, 0xB2,
+		0xD8, 0xA8, 0xD9, 0x85, 0xD8, 0xA8, 0xD9, 0x86,
+		0xD8, 0xA8, 0xD9, 0x89, 0xD8, 0xA8, 0xD9, 0x8A,
+		0xD8, 0xAA, 0xD8, 0xB1, 0xD8, 0xAA, 0xD8, 0xB2,
+		0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAA, 0xD9, 0x86,
+		0xD8, 0xAA, 0xD9, 0x89, 0xD8, 0xAA, 0xD9, 0x8A,
+		0xD8, 0xAB, 0xD8, 0xB1, 0xD8, 0xAB, 0xD8, 0xB2,
+		0xD8, 0xAB, 0xD9, 0x85, 0xD8, 0xAB, 0xD9, 0x86,
+		0xD8, 0xAB, 0xD9, 0x89, 0xD8, 0xAB, 0xD9, 0x8A,
+		0xD9, 0x81, 0xD9, 0x89, 0xD9, 0x81, 0xD9, 0x8A,
+		0xD9, 0x82, 0xD9, 0x89, 0xD9, 0x82, 0xD9, 0x8A,
+		0xD9, 0x83, 0xD8, 0xA7, 0xD9, 0x83, 0xD9, 0x84,
+		0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x83, 0xD9, 0x89,
+		0xD9, 0x83, 0xD9, 0x8A, 0xD9, 0x84, 0xD9, 0x85,
+		0xD9, 0x84, 0xD9, 0x89, 0xD9, 0x84, 0xD9, 0x8A,
+		0xD9, 0x85, 0xD8, 0xA7, 0xD9, 0x85, 0xD9, 0x85,
+		0xD9, 0x86, 0xD8, 0xB1, 0xD9, 0x86, 0xD8, 0xB2,
+		0xD9, 0x86, 0xD9, 0x85, 0xD9, 0x86, 0xD9, 0x86,
+		0xD9, 0x86, 0xD9, 0x89, 0xD9, 0x86, 0xD9, 0x8A,
+		0xD9, 0x89, 0xD9, 0xB0, 0xD9, 0x8A, 0xD8, 0xB1,
+		0xD9, 0x8A, 0xD8, 0xB2, 0xD9, 0x8A, 0xD9, 0x85,
+		0xD9, 0x8A, 0xD9, 0x86, 0xD9, 0x8A, 0xD9, 0x89,
+		0xD9, 0x8A, 0xD9, 0x8A, 0xD9, 0x8A, 0xD9, 0x94,
+		0xD8, 0xAC, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAD,
+		0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAE, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x94,
+		0xD9, 0x87, 0xD8, 0xA8, 0xD8, 0xAC, 0xD8, 0xA8,
+		0xD8, 0xAD, 0xD8, 0xA8, 0xD8, 0xAE, 0xD8, 0xA8,
+		0xD9, 0x85, 0xD8, 0xA8, 0xD9, 0x87, 0xD8, 0xAA,
+		0xD8, 0xAC, 0xD8, 0xAA, 0xD8, 0xAD, 0xD8, 0xAA,
+		0xD8, 0xAE, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAA,
+		0xD9, 0x87, 0xD8, 0xAB, 0xD9, 0x85, 0xD8, 0xAC,
+		0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x85, 0xD8, 0xAD,
+		0xD8, 0xAC, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAE,
+		0xD8, 0xAC, 0xD8, 0xAE, 0xD9, 0x85, 0xD8, 0xB3,
+		0xD8, 0xAC, 0xD8, 0xB3, 0xD8, 0xAD, 0xD8, 0xB3,
+		0xD8, 0xAE, 0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xB5,
+		0xD8, 0xAD, 0xD8, 0xB5, 0xD8, 0xAE, 0xD8, 0xB5,
+		0xD9, 0x85, 0xD8, 0xB6, 0xD8, 0xAC, 0xD8, 0xB6,
+		0xD8, 0xAD, 0xD8, 0xB6, 0xD8, 0xAE, 0xD8, 0xB6,
+		0xD9, 0x85, 0xD8, 0xB7, 0xD8, 0xAD, 0xD8, 0xB8,
+		0xD9, 0x85, 0xD8, 0xB9, 0xD8, 0xAC, 0xD8, 0xB9,
+		0xD9, 0x85, 0xD8, 0xBA, 0xD8, 0xAC, 0xD8, 0xBA,
+		0xD9, 0x85, 0xD9, 0x81, 0xD8, 0xAC, 0xD9, 0x81,
+		0xD8, 0xAD, 0xD9, 0x81, 0xD8, 0xAE, 0xD9, 0x81,
+		0xD9, 0x85, 0xD9, 0x82, 0xD8, 0xAD, 0xD9, 0x82,
+		0xD9, 0x85, 0xD9, 0x83, 0xD8, 0xAC, 0xD9, 0x83,
+		0xD8, 0xAD, 0xD9, 0x83, 0xD8, 0xAE, 0xD9, 0x83,
+		0xD9, 0x84, 0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x84,
+		0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x84,
+		0xD8, 0xAE, 0xD9, 0x84, 0xD9, 0x85, 0xD9, 0x84,
+		0xD9, 0x87, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x85,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAE, 0xD9, 0x85,
+		0xD9, 0x85, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x86,
+		0xD8, 0xAD, 0xD9, 0x86, 0xD8, 0xAE, 0xD9, 0x86,
+		0xD9, 0x85, 0xD9, 0x86, 0xD9, 0x87, 0xD9, 0x87,
+		0xD8, 0xAC, 0xD9, 0x87, 0xD9, 0x85, 0xD9, 0x87,
+		0xD9, 0xB0, 0xD9, 0x8A, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD8, 0xAD, 0xD9, 0x8A, 0xD8, 0xAE, 0xD9, 0x8A,
+		0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x87, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x94,
+		0xD9, 0x87, 0xD8, 0xA8, 0xD9, 0x85, 0xD8, 0xA8,
+		0xD9, 0x87, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAA,
+		0xD9, 0x87, 0xD8, 0xAB, 0xD9, 0x85, 0xD8, 0xAB,
+		0xD9, 0x87, 0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xB3,
+		0xD9, 0x87, 0xD8, 0xB4, 0xD9, 0x85, 0xD8, 0xB4,
+		0xD9, 0x87, 0xD9, 0x83, 0xD9, 0x84, 0xD9, 0x83,
+		0xD9, 0x85, 0xD9, 0x84, 0xD9, 0x85, 0xD9, 0x86,
+		0xD9, 0x85, 0xD9, 0x86, 0xD9, 0x87, 0xD9, 0x8A,
+		0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x87, 0xD9, 0x80,
+		0xD9, 0x8E, 0xD9, 0x91, 0xD9, 0x80, 0xD9, 0x8F,
+		0xD9, 0x91, 0xD9, 0x80, 0xD9, 0x90, 0xD9, 0x91,
+		0xD8, 0xB7, 0xD9, 0x89, 0xD8, 0xB7, 0xD9, 0x8A,
+		0xD8, 0xB9, 0xD9, 0x89, 0xD8, 0xB9, 0xD9, 0x8A,
+		0xD8, 0xBA, 0xD9, 0x89, 0xD8, 0xBA, 0xD9, 0x8A,
+		0xD8, 0xB3, 0xD9, 0x89, 0xD8, 0xB3, 0xD9, 0x8A,
+		0xD8, 0xB4, 0xD9, 0x89, 0xD8, 0xB4, 0xD9, 0x8A,
+		0xD8, 0xAD, 0xD9, 0x89, 0xD8, 0xAD, 0xD9, 0x8A,
+		0xD8, 0xAC, 0xD9, 0x89, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD8, 0xAE, 0xD9, 0x89, 0xD8, 0xAE, 0xD9, 0x8A,
+		0xD8, 0xB5, 0xD9, 0x89, 0xD8, 0xB5, 0xD9, 0x8A,
+		0xD8, 0xB6, 0xD9, 0x89, 0xD8, 0xB6, 0xD9, 0x8A,
+		0xD8, 0xB4, 0xD8, 0xAC, 0xD8, 0xB4, 0xD8, 0xAD,
+		0xD8, 0xB4, 0xD8, 0xAE, 0xD8, 0xB4, 0xD9, 0x85,
+		0xD8, 0xB4, 0xD8, 0xB1, 0xD8, 0xB3, 0xD8, 0xB1,
+		0xD8, 0xB5, 0xD8, 0xB1, 0xD8, 0xB6, 0xD8, 0xB1,
+		0xD8, 0xB7, 0xD9, 0x89, 0xD8, 0xB7, 0xD9, 0x8A,
+		0xD8, 0xB9, 0xD9, 0x89, 0xD8, 0xB9, 0xD9, 0x8A,
+		0xD8, 0xBA, 0xD9, 0x89, 0xD8, 0xBA, 0xD9, 0x8A,
+		0xD8, 0xB3, 0xD9, 0x89, 0xD8, 0xB3, 0xD9, 0x8A,
+		0xD8, 0xB4, 0xD9, 0x89, 0xD8, 0xB4, 0xD9, 0x8A,
+		0xD8, 0xAD, 0xD9, 0x89, 0xD8, 0xAD, 0xD9, 0x8A,
+		0xD8, 0xAC, 0xD9, 0x89, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD8, 0xAE, 0xD9, 0x89, 0xD8, 0xAE, 0xD9, 0x8A,
+		0xD8, 0xB5, 0xD9, 0x89, 0xD8, 0xB5, 0xD9, 0x8A,
+		0xD8, 0xB6, 0xD9, 0x89, 0xD8, 0xB6, 0xD9, 0x8A,
+		0xD8, 0xB4, 0xD8, 0xAC, 0xD8, 0xB4, 0xD8, 0xAD,
+		0xD8, 0xB4, 0xD8, 0xAE, 0xD8, 0xB4, 0xD9, 0x85,
+		0xD8, 0xB4, 0xD8, 0xB1, 0xD8, 0xB3, 0xD8, 0xB1,
+		0xD8, 0xB5, 0xD8, 0xB1, 0xD8, 0xB6, 0xD8, 0xB1,
+		0xD8, 0xB4, 0xD8, 0xAC, 0xD8, 0xB4, 0xD8, 0xAD,
+		0xD8, 0xB4, 0xD8, 0xAE, 0xD8, 0xB4, 0xD9, 0x85,
+		0xD8, 0xB3, 0xD9, 0x87, 0xD8, 0xB4, 0xD9, 0x87,
+		0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xB3, 0xD8, 0xAC,
+		0xD8, 0xB3, 0xD8, 0xAD, 0xD8, 0xB3, 0xD8, 0xAE,
+		0xD8, 0xB4, 0xD8, 0xAC, 0xD8, 0xB4, 0xD8, 0xAD,
+		0xD8, 0xB4, 0xD8, 0xAE, 0xD8, 0xB7, 0xD9, 0x85,
+		0xD8, 0xB8, 0xD9, 0x85, 0xD8, 0xA7, 0xD9, 0x8B,
+		0xD8, 0xA7, 0xD9, 0x8B, 0xD8, 0xAA, 0xD8, 0xAC,
+		0xD9, 0x85, 0xD8, 0xAA, 0xD8, 0xAD, 0xD8, 0xAC,
+		0xD8, 0xAA, 0xD8, 0xAD, 0xD8, 0xAC, 0xD8, 0xAA,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAA, 0xD8, 0xAE,
+		0xD9, 0x85, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAC,
+		0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xAA,
+		0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xAC, 0xD9, 0x85,
+		0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x85, 0xD8, 0xAD,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD9, 0x8A, 0xD8, 0xAD,
+		0xD9, 0x85, 0xD9, 0x89, 0xD8, 0xB3, 0xD8, 0xAD,
+		0xD8, 0xAC, 0xD8, 0xB3, 0xD8, 0xAC, 0xD8, 0xAD,
+		0xD8, 0xB3, 0xD8, 0xAC, 0xD9, 0x89, 0xD8, 0xB3,
+		0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xB3, 0xD9, 0x85,
+		0xD8, 0xAD, 0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xAC,
+		0xD8, 0xB3, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB3,
+		0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB5, 0xD8, 0xAD,
+		0xD8, 0xAD, 0xD8, 0xB5, 0xD8, 0xAD, 0xD8, 0xAD,
+		0xD8, 0xB5, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB4,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xB4, 0xD8, 0xAD,
+		0xD9, 0x85, 0xD8, 0xB4, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD8, 0xB4, 0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xB4,
+		0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xB4, 0xD9, 0x85,
+		0xD9, 0x85, 0xD8, 0xB4, 0xD9, 0x85, 0xD9, 0x85,
+		0xD8, 0xB6, 0xD8, 0xAD, 0xD9, 0x89, 0xD8, 0xB6,
+		0xD8, 0xAE, 0xD9, 0x85, 0xD8, 0xB6, 0xD8, 0xAE,
+		0xD9, 0x85, 0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xAD,
+		0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xB7,
+		0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB7, 0xD9, 0x85,
+		0xD9, 0x8A, 0xD8, 0xB9, 0xD8, 0xAC, 0xD9, 0x85,
+		0xD8, 0xB9, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB9,
+		0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB9, 0xD9, 0x85,
+		0xD9, 0x89, 0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x85,
+		0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x8A, 0xD8, 0xBA,
+		0xD9, 0x85, 0xD9, 0x89, 0xD9, 0x81, 0xD8, 0xAE,
+		0xD9, 0x85, 0xD9, 0x81, 0xD8, 0xAE, 0xD9, 0x85,
+		0xD9, 0x82, 0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x82,
+		0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x84, 0xD8, 0xAD,
+		0xD9, 0x85, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x8A,
+		0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x89, 0xD9, 0x84,
+		0xD8, 0xAC, 0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xAC,
+		0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xAE, 0xD9, 0x85,
+		0xD9, 0x84, 0xD8, 0xAE, 0xD9, 0x85, 0xD9, 0x84,
+		0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x84, 0xD9, 0x85,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xAC,
+		0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x85, 0xD9, 0x85,
+		0xD8, 0xAD, 0xD9, 0x8A, 0xD9, 0x85, 0xD8, 0xAC,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x85,
+		0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xAC, 0xD9, 0x85,
+		0xD8, 0xAE, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xAC,
+		0xD8, 0xAE, 0xD9, 0x87, 0xD9, 0x85, 0xD8, 0xAC,
+		0xD9, 0x87, 0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x86,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD9, 0x86, 0xD8, 0xAD,
+		0xD9, 0x89, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x85,
+		0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x86,
+		0xD8, 0xAC, 0xD9, 0x89, 0xD9, 0x86, 0xD9, 0x85,
+		0xD9, 0x8A, 0xD9, 0x86, 0xD9, 0x85, 0xD9, 0x89,
+		0xD9, 0x8A, 0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x8A,
+		0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xA8, 0xD8, 0xAE,
+		0xD9, 0x8A, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x89, 0xD8, 0xAA,
+		0xD8, 0xAE, 0xD9, 0x8A, 0xD8, 0xAA, 0xD8, 0xAE,
+		0xD9, 0x89, 0xD8, 0xAA, 0xD9, 0x85, 0xD9, 0x8A,
+		0xD8, 0xAA, 0xD9, 0x85, 0xD9, 0x89, 0xD8, 0xAC,
+		0xD9, 0x85, 0xD9, 0x8A, 0xD8, 0xAC, 0xD8, 0xAD,
+		0xD9, 0x89, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x89,
+		0xD8, 0xB3, 0xD8, 0xAE, 0xD9, 0x89, 0xD8, 0xB5,
+		0xD8, 0xAD, 0xD9, 0x8A, 0xD8, 0xB4, 0xD8, 0xAD,
+		0xD9, 0x8A, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9, 0x8A,
+		0xD9, 0x84, 0xD8, 0xAC, 0xD9, 0x8A, 0xD9, 0x84,
+		0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x8A, 0xD8, 0xAD,
+		0xD9, 0x8A, 0xD9, 0x8A, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD9, 0x8A, 0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x85,
+		0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x82, 0xD9, 0x85,
+		0xD9, 0x8A, 0xD9, 0x86, 0xD8, 0xAD, 0xD9, 0x8A,
+		0xD9, 0x82, 0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x84,
+		0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xB9, 0xD9, 0x85,
+		0xD9, 0x8A, 0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x8A,
+		0xD9, 0x86, 0xD8, 0xAC, 0xD8, 0xAD, 0xD9, 0x85,
+		0xD8, 0xAE, 0xD9, 0x8A, 0xD9, 0x84, 0xD8, 0xAC,
+		0xD9, 0x85, 0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x85,
+		0xD9, 0x84, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x86,
+		0xD8, 0xAC, 0xD8, 0xAD, 0xD8, 0xAC, 0xD8, 0xAD,
+		0xD9, 0x8A, 0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x8A, 0xD9, 0x81,
+		0xD9, 0x85, 0xD9, 0x8A, 0xD8, 0xA8, 0xD8, 0xAD,
+		0xD9, 0x8A, 0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x85,
+		0xD8, 0xB9, 0xD8, 0xAC, 0xD9, 0x85, 0xD8, 0xB5,
+		0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB3, 0xD8, 0xAE,
+		0xD9, 0x8A, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x8A,
+		0xD8, 0xB5, 0xD9, 0x84, 0xDB, 0x92, 0xD9, 0x82,
+		0xD9, 0x84, 0xDB, 0x92, 0xD8, 0xA7, 0xD9, 0x84,
+		0xD9, 0x84, 0xD9, 0x87, 0xD8, 0xA7, 0xD9, 0x83,
+		0xD8, 0xA8, 0xD8, 0xB1, 0xD9, 0x85, 0xD8, 0xAD,
+		0xD9, 0x85, 0xD8, 0xAF, 0xD8, 0xB5, 0xD9, 0x84,
+		0xD8, 0xB9, 0xD9, 0x85, 0xD8, 0xB1, 0xD8, 0xB3,
+		0xD9, 0x88, 0xD9, 0x84, 0xD8, 0xB9, 0xD9, 0x84,
+		0xD9, 0x8A, 0xD9, 0x87, 0xD9, 0x88, 0xD8, 0xB3,
+		0xD9, 0x84, 0xD9, 0x85, 0xD8, 0xB5, 0xD9, 0x84,
+		0xD9, 0x89, 0xD8, 0xB5, 0xD9, 0x84, 0xD9, 0x89,
+		0x20, 0xD8, 0xA7, 0xD9, 0x84, 0xD9, 0x84, 0xD9,
+		0x87, 0x20, 0xD8, 0xB9, 0xD9, 0x84, 0xD9, 0x8A,
+		0xD9, 0x87, 0x20, 0xD9, 0x88, 0xD8, 0xB3, 0xD9,
+		0x84, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x84, 0x20,
+		0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x84,
+		0xD9, 0x87, 0xD8, 0xB1, 0xDB, 0x8C, 0xD8, 0xA7,
+		0xD9, 0x84, 0x2E, 0x2E, 0xE2, 0x80, 0x94, 0xE2,
+		0x80, 0x93, 0x5F, 0x5F, 0x28, 0x29, 0x7B, 0x7D,
+		0xE3, 0x80, 0x94, 0xE3, 0x80, 0x95, 0xE3, 0x80,
+		0x90, 0xE3, 0x80, 0x91, 0xE3, 0x80, 0x8A, 0xE3,
+		0x80, 0x8B, 0xE3, 0x80, 0x88, 0xE3, 0x80, 0x89,
+		0xE3, 0x80, 0x8C, 0xE3, 0x80, 0x8D, 0xE3, 0x80,
+		0x8E, 0xE3, 0x80, 0x8F, 0x20, 0xCC, 0x85, 0x20,
+		0xCC, 0x85, 0x20, 0xCC, 0x85, 0x20, 0xCC, 0x85,
+		0x5F, 0x5F, 0x5F, 0x2C, 0xE3, 0x80, 0x81, 0x2E,
+		0x3B, 0x3A, 0x3F, 0x21, 0xE2, 0x80, 0x94, 0x28,
+		0x29, 0x7B, 0x7D, 0xE3, 0x80, 0x94, 0xE3, 0x80,
+		0x95, 0x23, 0x26, 0x2A, 0x2B, 0x2D, 0x3C, 0x3E,
+		0x3D, 0x5C, 0x24, 0x25, 0x40, 0x20, 0xD9, 0x8B,
+		0xD9, 0x80, 0xD9, 0x8B, 0x20, 0xD9, 0x8C, 0x20,
+		0xD9, 0x8D, 0x20, 0xD9, 0x8E, 0xD9, 0x80, 0xD9,
+		0x8E, 0x20, 0xD9, 0x8F, 0xD9, 0x80, 0xD9, 0x8F,
+		0x20, 0xD9, 0x90, 0xD9, 0x80, 0xD9, 0x90, 0x20,
+		0xD9, 0x91, 0xD9, 0x80, 0xD9, 0x91, 0x20, 0xD9,
+		0x92, 0xD9, 0x80, 0xD9, 0x92, 0xD8, 0xA1, 0xD8,
+		0xA7, 0xD9, 0x93, 0xD8, 0xA7, 0xD9, 0x93, 0xD8,
+		0xA7, 0xD9, 0x94, 0xD8, 0xA7, 0xD9, 0x94, 0xD9,
+		0x88, 0xD9, 0x94, 0xD9, 0x88, 0xD9, 0x94, 0xD8,
+		0xA7, 0xD9, 0x95, 0xD8, 0xA7, 0xD9, 0x95, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD9, 0x8A, 0xD9, 0x94, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD9, 0x8A, 0xD9, 0x94, 0xD8,
+		0xA7, 0xD8, 0xA7, 0xD8, 0xA8, 0xD8, 0xA8, 0xD8,
+		0xA8, 0xD8, 0xA8, 0xD8, 0xA9, 0xD8, 0xA9, 0xD8,
+		0xAA, 0xD8, 0xAA, 0xD8, 0xAA, 0xD8, 0xAA, 0xD8,
+		0xAB, 0xD8, 0xAB, 0xD8, 0xAB, 0xD8, 0xAB, 0xD8,
+		0xAC, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8,
+		0xAD, 0xD8, 0xAD, 0xD8, 0xAD, 0xD8, 0xAD, 0xD8,
+		0xAE, 0xD8, 0xAE, 0xD8, 0xAE, 0xD8, 0xAE, 0xD8,
+		0xAF, 0xD8, 0xAF, 0xD8, 0xB0, 0xD8, 0xB0, 0xD8,
+		0xB1, 0xD8, 0xB1, 0xD8, 0xB2, 0xD8, 0xB2, 0xD8,
+		0xB3, 0xD8, 0xB3, 0xD8, 0xB3, 0xD8, 0xB3, 0xD8,
+		0xB4, 0xD8, 0xB4, 0xD8, 0xB4, 0xD8, 0xB4, 0xD8,
+		0xB5, 0xD8, 0xB5, 0xD8, 0xB5, 0xD8, 0xB5, 0xD8,
+		0xB6, 0xD8, 0xB6, 0xD8, 0xB6, 0xD8, 0xB6, 0xD8,
+		0xB7, 0xD8, 0xB7, 0xD8, 0xB7, 0xD8, 0xB7, 0xD8,
+		0xB8, 0xD8, 0xB8, 0xD8, 0xB8, 0xD8, 0xB8, 0xD8,
+		0xB9, 0xD8, 0xB9, 0xD8, 0xB9, 0xD8, 0xB9, 0xD8,
+		0xBA, 0xD8, 0xBA, 0xD8, 0xBA, 0xD8, 0xBA, 0xD9,
+		0x81, 0xD9, 0x81, 0xD9, 0x81, 0xD9, 0x81, 0xD9,
+		0x82, 0xD9, 0x82, 0xD9, 0x82, 0xD9, 0x82, 0xD9,
+		0x83, 0xD9, 0x83, 0xD9, 0x83, 0xD9, 0x83, 0xD9,
+		0x84, 0xD9, 0x84, 0xD9, 0x84, 0xD9, 0x84, 0xD9,
+		0x85, 0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x85, 0xD9,
+		0x86, 0xD9, 0x86, 0xD9, 0x86, 0xD9, 0x86, 0xD9,
+		0x87, 0xD9, 0x87, 0xD9, 0x87, 0xD9, 0x87, 0xD9,
+		0x88, 0xD9, 0x88, 0xD9, 0x89, 0xD9, 0x89, 0xD9,
+		0x8A, 0xD9, 0x8A, 0xD9, 0x8A, 0xD9, 0x8A, 0xD9,
+		0x84, 0xD8, 0xA7, 0xD9, 0x93, 0xD9, 0x84, 0xD8,
+		0xA7, 0xD9, 0x93, 0xD9, 0x84, 0xD8, 0xA7, 0xD9,
+		0x94, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x94, 0xD9,
+		0x84, 0xD8, 0xA7, 0xD9, 0x95, 0xD9, 0x84, 0xD8,
+		0xA7, 0xD9, 0x95, 0xD9, 0x84, 0xD8, 0xA7, 0xD9,
+		0x84, 0xD8, 0xA7, 0x21, 0x22, 0x23, 0x24, 0x25,
+		0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,
+		0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+		0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,
+		0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
+		0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D,
+		0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
+		0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D,
+		0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D,
+		0x7E, 0xE2, 0xA6, 0x85, 0xE2, 0xA6, 0x86, 0xE3,
+		0x80, 0x82, 0xE3, 0x80, 0x8C, 0xE3, 0x80, 0x8D,
+		0xE3, 0x80, 0x81, 0xE3, 0x83, 0xBB, 0xE3, 0x83,
+		0xB2, 0xE3, 0x82, 0xA1, 0xE3, 0x82, 0xA3, 0xE3,
+		0x82, 0xA5, 0xE3, 0x82, 0xA7, 0xE3, 0x82, 0xA9,
+		0xE3, 0x83, 0xA3, 0xE3, 0x83, 0xA5, 0xE3, 0x83,
+		0xA7, 0xE3, 0x83, 0x83, 0xE3, 0x83, 0xBC, 0xE3,
+		0x82, 0xA2, 0xE3, 0x82, 0xA4, 0xE3, 0x82, 0xA6,
+		0xE3, 0x82, 0xA8, 0xE3, 0x82, 0xAA, 0xE3, 0x82,
+		0xAB, 0xE3, 0x82, 0xAD, 0xE3, 0x82, 0xAF, 0xE3,
+		0x82, 0xB1, 0xE3, 0x82, 0xB3, 0xE3, 0x82, 0xB5,
+		0xE3, 0x82, 0xB7, 0xE3, 0x82, 0xB9, 0xE3, 0x82,
+		0xBB, 0xE3, 0x82, 0xBD, 0xE3, 0x82, 0xBF, 0xE3,
+		0x83, 0x81, 0xE3, 0x83, 0x84, 0xE3, 0x83, 0x86,
+		0xE3, 0x83, 0x88, 0xE3, 0x83, 0x8A, 0xE3, 0x83,
+		0x8B, 0xE3, 0x83, 0x8C, 0xE3, 0x83, 0x8D, 0xE3,
+		0x83, 0x8E, 0xE3, 0x83, 0x8F, 0xE3, 0x83, 0x92,
+		0xE3, 0x83, 0x95, 0xE3, 0x83, 0x98, 0xE3, 0x83,
+		0x9B, 0xE3, 0x83, 0x9E, 0xE3, 0x83, 0x9F, 0xE3,
+		0x83, 0xA0, 0xE3, 0x83, 0xA1, 0xE3, 0x83, 0xA2,
+		0xE3, 0x83, 0xA4, 0xE3, 0x83, 0xA6, 0xE3, 0x83,
+		0xA8, 0xE3, 0x83, 0xA9, 0xE3, 0x83, 0xAA, 0xE3,
+		0x83, 0xAB, 0xE3, 0x83, 0xAC, 0xE3, 0x83, 0xAD,
+		0xE3, 0x83, 0xAF, 0xE3, 0x83, 0xB3, 0xE3, 0x82,
+		0x99, 0xE3, 0x82, 0x9A, 0xE1, 0x85, 0xA0, 0xE1,
+		0x84, 0x80, 0xE1, 0x84, 0x81, 0xE1, 0x86, 0xAA,
+		0xE1, 0x84, 0x82, 0xE1, 0x86, 0xAC, 0xE1, 0x86,
+		0xAD, 0xE1, 0x84, 0x83, 0xE1, 0x84, 0x84, 0xE1,
+		0x84, 0x85, 0xE1, 0x86, 0xB0, 0xE1, 0x86, 0xB1,
+		0xE1, 0x86, 0xB2, 0xE1, 0x86, 0xB3, 0xE1, 0x86,
+		0xB4, 0xE1, 0x86, 0xB5, 0xE1, 0x84, 0x9A, 0xE1,
+		0x84, 0x86, 0xE1, 0x84, 0x87, 0xE1, 0x84, 0x88,
+		0xE1, 0x84, 0xA1, 0xE1, 0x84, 0x89, 0xE1, 0x84,
+		0x8A, 0xE1, 0x84, 0x8B, 0xE1, 0x84, 0x8C, 0xE1,
+		0x84, 0x8D, 0xE1, 0x84, 0x8E, 0xE1, 0x84, 0x8F,
+		0xE1, 0x84, 0x90, 0xE1, 0x84, 0x91, 0xE1, 0x84,
+		0x92, 0xE1, 0x85, 0xA1, 0xE1, 0x85, 0xA2, 0xE1,
+		0x85, 0xA3, 0xE1, 0x85, 0xA4, 0xE1, 0x85, 0xA5,
+		0xE1, 0x85, 0xA6, 0xE1, 0x85, 0xA7, 0xE1, 0x85,
+		0xA8, 0xE1, 0x85, 0xA9, 0xE1, 0x85, 0xAA, 0xE1,
+		0x85, 0xAB, 0xE1, 0x85, 0xAC, 0xE1, 0x85, 0xAD,
+		0xE1, 0x85, 0xAE, 0xE1, 0x85, 0xAF, 0xE1, 0x85,
+		0xB0, 0xE1, 0x85, 0xB1, 0xE1, 0x85, 0xB2, 0xE1,
+		0x85, 0xB3, 0xE1, 0x85, 0xB4, 0xE1, 0x85, 0xB5,
+		0xC2, 0xA2, 0xC2, 0xA3, 0xC2, 0xAC, 0x20, 0xCC,
+		0x84, 0xC2, 0xA6, 0xC2, 0xA5, 0xE2, 0x82, 0xA9,
+		0xE2, 0x94, 0x82, 0xE2, 0x86, 0x90, 0xE2, 0x86,
+		0x91, 0xE2, 0x86, 0x92, 0xE2, 0x86, 0x93, 0xE2,
+		0x96, 0xA0, 0xE2, 0x97, 0x8B, 0xF6, 0xF0, 0x9D,
+		0x85, 0x97, 0xF0, 0x9D, 0x85, 0xA5, 0xF6, 0xF0,
+		0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF6,
+		0xF0, 0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5,
+		0xF0, 0x9D, 0x85, 0xAE, 0xF6, 0xF0, 0x9D, 0x85,
+		0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+		0xAF, 0xF6, 0xF0, 0x9D, 0x85, 0x98, 0xF0, 0x9D,
+		0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xB0, 0xF6, 0xF0,
+		0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+		0x9D, 0x85, 0xB1, 0xF6, 0xF0, 0x9D, 0x85, 0x98,
+		0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xB2,
+		0xF6, 0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85,
+		0xA5, 0xF6, 0xF0, 0x9D, 0x86, 0xBA, 0xF0, 0x9D,
+		0x85, 0xA5, 0xF6, 0xF0, 0x9D, 0x86, 0xB9, 0xF0,
+		0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xF6,
+		0xF0, 0x9D, 0x86, 0xBA, 0xF0, 0x9D, 0x85, 0xA5,
+		0xF0, 0x9D, 0x85, 0xAE, 0xF6, 0xF0, 0x9D, 0x86,
+		0xB9, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+		0xAF, 0xF6, 0xF0, 0x9D, 0x86, 0xBA, 0xF0, 0x9D,
+		0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0x41, 0x42,
+		0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
+		0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52,
+		0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A,
+		0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+		0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
+		0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+		0x79, 0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+		0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E,
+		0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
+		0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64,
+		0x65, 0x66, 0x67, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x43, 0x44, 0x47, 0x4A, 0x4B, 0x4E,
+		0x4F, 0x50, 0x51, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x66,
+		0x68, 0x69, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x44,
+		0x45, 0x46, 0x47, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E,
+		0x4F, 0x50, 0x51, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+		0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
+		0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
+		0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x44, 0x45,
+		0x46, 0x47, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4F,
+		0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0xCE, 0x91, 0xCE, 0x92, 0xCE, 0x93, 0xCE,
+		0x94, 0xCE, 0x95, 0xCE, 0x96, 0xCE, 0x97, 0xCE,
+		0x98, 0xCE, 0x99, 0xCE, 0x9A, 0xCE, 0x9B, 0xCE,
+		0x9C, 0xCE, 0x9D, 0xCE, 0x9E, 0xCE, 0x9F, 0xCE,
+		0xA0, 0xCE, 0xA1, 0xCE, 0x98, 0xCE, 0xA3, 0xCE,
+		0xA4, 0xCE, 0xA5, 0xCE, 0xA6, 0xCE, 0xA7, 0xCE,
+		0xA8, 0xCE, 0xA9, 0xE2, 0x88, 0x87, 0xCE, 0xB1,
+		0xCE, 0xB2, 0xCE, 0xB3, 0xCE, 0xB4, 0xCE, 0xB5,
+		0xCE, 0xB6, 0xCE, 0xB7, 0xCE, 0xB8, 0xCE, 0xB9,
+		0xCE, 0xBA, 0xCE, 0xBB, 0xCE, 0xBC, 0xCE, 0xBD,
+		0xCE, 0xBE, 0xCE, 0xBF, 0xCF, 0x80, 0xCF, 0x81,
+		0xCF, 0x82, 0xCF, 0x83, 0xCF, 0x84, 0xCF, 0x85,
+		0xCF, 0x86, 0xCF, 0x87, 0xCF, 0x88, 0xCF, 0x89,
+		0xE2, 0x88, 0x82, 0xCE, 0xB5, 0xCE, 0xB8, 0xCE,
+		0xBA, 0xCF, 0x86, 0xCF, 0x81, 0xCF, 0x80, 0xCE,
+		0x91, 0xCE, 0x92, 0xCE, 0x93, 0xCE, 0x94, 0xCE,
+		0x95, 0xCE, 0x96, 0xCE, 0x97, 0xCE, 0x98, 0xCE,
+		0x99, 0xCE, 0x9A, 0xCE, 0x9B, 0xCE, 0x9C, 0xCE,
+		0x9D, 0xCE, 0x9E, 0xCE, 0x9F, 0xCE, 0xA0, 0xCE,
+		0xA1, 0xCE, 0x98, 0xCE, 0xA3, 0xCE, 0xA4, 0xCE,
+		0xA5, 0xCE, 0xA6, 0xCE, 0xA7, 0xCE, 0xA8, 0xCE,
+		0xA9, 0xE2, 0x88, 0x87, 0xCE, 0xB1, 0xCE, 0xB2,
+		0xCE, 0xB3, 0xCE, 0xB4, 0xCE, 0xB5, 0xCE, 0xB6,
+		0xCE, 0xB7, 0xCE, 0xB8, 0xCE, 0xB9, 0xCE, 0xBA,
+		0xCE, 0xBB, 0xCE, 0xBC, 0xCE, 0xBD, 0xCE, 0xBE,
+		0xCE, 0xBF, 0xCF, 0x80, 0xCF, 0x81, 0xCF, 0x82,
+		0xCF, 0x83, 0xCF, 0x84, 0xCF, 0x85, 0xCF, 0x86,
+		0xCF, 0x87, 0xCF, 0x88, 0xCF, 0x89, 0xE2, 0x88,
+		0x82, 0xCE, 0xB5, 0xCE, 0xB8, 0xCE, 0xBA, 0xCF,
+		0x86, 0xCF, 0x81, 0xCF, 0x80, 0xCE, 0x91, 0xCE,
+		0x92, 0xCE, 0x93, 0xCE, 0x94, 0xCE, 0x95, 0xCE,
+		0x96, 0xCE, 0x97, 0xCE, 0x98, 0xCE, 0x99, 0xCE,
+		0x9A, 0xCE, 0x9B, 0xCE, 0x9C, 0xCE, 0x9D, 0xCE,
+		0x9E, 0xCE, 0x9F, 0xCE, 0xA0, 0xCE, 0xA1, 0xCE,
+		0x98, 0xCE, 0xA3, 0xCE, 0xA4, 0xCE, 0xA5, 0xCE,
+		0xA6, 0xCE, 0xA7, 0xCE, 0xA8, 0xCE, 0xA9, 0xE2,
+		0x88, 0x87, 0xCE, 0xB1, 0xCE, 0xB2, 0xCE, 0xB3,
+		0xCE, 0xB4, 0xCE, 0xB5, 0xCE, 0xB6, 0xCE, 0xB7,
+		0xCE, 0xB8, 0xCE, 0xB9, 0xCE, 0xBA, 0xCE, 0xBB,
+		0xCE, 0xBC, 0xCE, 0xBD, 0xCE, 0xBE, 0xCE, 0xBF,
+		0xCF, 0x80, 0xCF, 0x81, 0xCF, 0x82, 0xCF, 0x83,
+		0xCF, 0x84, 0xCF, 0x85, 0xCF, 0x86, 0xCF, 0x87,
+		0xCF, 0x88, 0xCF, 0x89, 0xE2, 0x88, 0x82, 0xCE,
+		0xB5, 0xCE, 0xB8, 0xCE, 0xBA, 0xCF, 0x86, 0xCF,
+		0x81, 0xCF, 0x80, 0xCE, 0x91, 0xCE, 0x92, 0xCE,
+		0x93, 0xCE, 0x94, 0xCE, 0x95, 0xCE, 0x96, 0xCE,
+		0x97, 0xCE, 0x98, 0xCE, 0x99, 0xCE, 0x9A, 0xCE,
+		0x9B, 0xCE, 0x9C, 0xCE, 0x9D, 0xCE, 0x9E, 0xCE,
+		0x9F, 0xCE, 0xA0, 0xCE, 0xA1, 0xCE, 0x98, 0xCE,
+		0xA3, 0xCE, 0xA4, 0xCE, 0xA5, 0xCE, 0xA6, 0xCE,
+		0xA7, 0xCE, 0xA8, 0xCE, 0xA9, 0xE2, 0x88, 0x87,
+		0xCE, 0xB1, 0xCE, 0xB2, 0xCE, 0xB3, 0xCE, 0xB4,
+		0xCE, 0xB5, 0xCE, 0xB6, 0xCE, 0xB7, 0xCE, 0xB8,
+		0xCE, 0xB9, 0xCE, 0xBA, 0xCE, 0xBB, 0xCE, 0xBC,
+		0xCE, 0xBD, 0xCE, 0xBE, 0xCE, 0xBF, 0xCF, 0x80,
+		0xCF, 0x81, 0xCF, 0x82, 0xCF, 0x83, 0xCF, 0x84,
+		0xCF, 0x85, 0xCF, 0x86, 0xCF, 0x87, 0xCF, 0x88,
+		0xCF, 0x89, 0xE2, 0x88, 0x82, 0xCE, 0xB5, 0xCE,
+		0xB8, 0xCE, 0xBA, 0xCF, 0x86, 0xCF, 0x81, 0xCF,
+		0x80, 0xCE, 0x91, 0xCE, 0x92, 0xCE, 0x93, 0xCE,
+		0x94, 0xCE, 0x95, 0xCE, 0x96, 0xCE, 0x97, 0xCE,
+		0x98, 0xCE, 0x99, 0xCE, 0x9A, 0xCE, 0x9B, 0xCE,
+		0x9C, 0xCE, 0x9D, 0xCE, 0x9E, 0xCE, 0x9F, 0xCE,
+		0xA0, 0xCE, 0xA1, 0xCE, 0x98, 0xCE, 0xA3, 0xCE,
+		0xA4, 0xCE, 0xA5, 0xCE, 0xA6, 0xCE, 0xA7, 0xCE,
+		0xA8, 0xCE, 0xA9, 0xE2, 0x88, 0x87, 0xCE, 0xB1,
+		0xCE, 0xB2, 0xCE, 0xB3, 0xCE, 0xB4, 0xCE, 0xB5,
+		0xCE, 0xB6, 0xCE, 0xB7, 0xCE, 0xB8, 0xCE, 0xB9,
+		0xCE, 0xBA, 0xCE, 0xBB, 0xCE, 0xBC, 0xCE, 0xBD,
+		0xCE, 0xBE, 0xCE, 0xBF, 0xCF, 0x80, 0xCF, 0x81,
+		0xCF, 0x82, 0xCF, 0x83, 0xCF, 0x84, 0xCF, 0x85,
+		0xCF, 0x86, 0xCF, 0x87, 0xCF, 0x88, 0xCF, 0x89,
+		0xE2, 0x88, 0x82, 0xCE, 0xB5, 0xCE, 0xB8, 0xCE,
+		0xBA, 0xCF, 0x86, 0xCF, 0x81, 0xCF, 0x80, 0x30,
+		0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+		0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+		0x37, 0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34,
+		0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0x31, 0x32,
+		0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30,
+		0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+		0x39, 0xF6, 0xE4, 0xB8, 0xBD, 0xF6, 0xE4, 0xB8,
+		0xB8, 0xF6, 0xE4, 0xB9, 0x81, 0xF6, 0xF0, 0xA0,
+		0x84, 0xA2, 0xF6, 0xE4, 0xBD, 0xA0, 0xF6, 0xE4,
+		0xBE, 0xAE, 0xF6, 0xE4, 0xBE, 0xBB, 0xF6, 0xE5,
+		0x80, 0x82, 0xF6, 0xE5, 0x81, 0xBA, 0xF6, 0xE5,
+		0x82, 0x99, 0xF6, 0xE5, 0x83, 0xA7, 0xF6, 0xE5,
+		0x83, 0x8F, 0xF6, 0xE3, 0x92, 0x9E, 0xF6, 0xF0,
+		0xA0, 0x98, 0xBA, 0xF6, 0xE5, 0x85, 0x8D, 0xF6,
+		0xE5, 0x85, 0x94, 0xF6, 0xE5, 0x85, 0xA4, 0xF6,
+		0xE5, 0x85, 0xB7, 0xF6, 0xF0, 0xA0, 0x94, 0x9C,
+		0xF6, 0xE3, 0x92, 0xB9, 0xF6, 0xE5, 0x85, 0xA7,
+		0xF6, 0xE5, 0x86, 0x8D, 0xF6, 0xF0, 0xA0, 0x95,
+		0x8B, 0xF6, 0xE5, 0x86, 0x97, 0xF6, 0xE5, 0x86,
+		0xA4, 0xF6, 0xE4, 0xBB, 0x8C, 0xF6, 0xE5, 0x86,
+		0xAC, 0xF6, 0xE5, 0x86, 0xB5, 0xF6, 0xF0, 0xA9,
+		0x87, 0x9F, 0xF6, 0xE5, 0x87, 0xB5, 0xF6, 0xE5,
+		0x88, 0x83, 0xF6, 0xE3, 0x93, 0x9F, 0xF6, 0xE5,
+		0x88, 0xBB, 0xF6, 0xE5, 0x89, 0x86, 0xF6, 0xE5,
+		0x89, 0xB2, 0xF6, 0xE5, 0x89, 0xB7, 0xF6, 0xE3,
+		0x94, 0x95, 0xF6, 0xE5, 0x8B, 0x87, 0xF6, 0xE5,
+		0x8B, 0x89, 0xF6, 0xE5, 0x8B, 0xA4, 0xF6, 0xE5,
+		0x8B, 0xBA, 0xF6, 0xE5, 0x8C, 0x85, 0xF6, 0xE5,
+		0x8C, 0x86, 0xF6, 0xE5, 0x8C, 0x97, 0xF6, 0xE5,
+		0x8D, 0x89, 0xF6, 0xE5, 0x8D, 0x91, 0xF6, 0xE5,
+		0x8D, 0x9A, 0xF6, 0xE5, 0x8D, 0xB3, 0xF6, 0xE5,
+		0x8D, 0xBD, 0xF6, 0xE5, 0x8D, 0xBF, 0xF6, 0xE5,
+		0x8D, 0xBF, 0xF6, 0xE5, 0x8D, 0xBF, 0xF6, 0xF0,
+		0xA0, 0xA8, 0xAC, 0xF6, 0xE7, 0x81, 0xB0, 0xF6,
+		0xE5, 0x8F, 0x8A, 0xF6, 0xE5, 0x8F, 0x9F, 0xF6,
+		0xF0, 0xA0, 0xAD, 0xA3, 0xF6, 0xE5, 0x8F, 0xAB,
+		0xF6, 0xE5, 0x8F, 0xB1, 0xF6, 0xE5, 0x90, 0x86,
+		0xF6, 0xE5, 0x92, 0x9E, 0xF6, 0xE5, 0x90, 0xB8,
+		0xF6, 0xE5, 0x91, 0x88, 0xF6, 0xE5, 0x91, 0xA8,
+		0xF6, 0xE5, 0x92, 0xA2, 0xF6, 0xE5, 0x93, 0xB6,
+		0xF6, 0xE5, 0x94, 0x90, 0xF6, 0xE5, 0x95, 0x93,
+		0xF6, 0xE5, 0x95, 0xA3, 0xF6, 0xE5, 0x96, 0x84,
+		0xF6, 0xE5, 0x96, 0x84, 0xF6, 0xE5, 0x96, 0x99,
+		0xF6, 0xE5, 0x96, 0xAB, 0xF6, 0xE5, 0x96, 0xB3,
+		0xF6, 0xE5, 0x97, 0x82, 0xF6, 0xE5, 0x9C, 0x96,
+		0xF6, 0xE5, 0x98, 0x86, 0xF6, 0xE5, 0x9C, 0x97,
+		0xF6, 0xE5, 0x99, 0x91, 0xF6, 0xE5, 0x99, 0xB4,
+		0xF6, 0xE5, 0x88, 0x87, 0xF6, 0xE5, 0xA3, 0xAE,
+		0xF6, 0xE5, 0x9F, 0x8E, 0xF6, 0xE5, 0x9F, 0xB4,
+		0xF6, 0xE5, 0xA0, 0x8D, 0xF6, 0xE5, 0x9E, 0x8B,
+		0xF6, 0xE5, 0xA0, 0xB2, 0xF6, 0xE5, 0xA0, 0xB1,
+		0xF6, 0xE5, 0xA2, 0xAC, 0xF6, 0xF0, 0xA1, 0x93,
+		0xA4, 0xF6, 0xE5, 0xA3, 0xB2, 0xF6, 0xE5, 0xA3,
+		0xB7, 0xF6, 0xE5, 0xA4, 0x86, 0xF6, 0xE5, 0xA4,
+		0x9A, 0xF6, 0xE5, 0xA4, 0xA2, 0xF6, 0xE5, 0xA5,
+		0xA2, 0xF6, 0xF0, 0xA1, 0x9A, 0xA8, 0xF6, 0xF0,
+		0xA1, 0x9B, 0xAA, 0xF6, 0xE5, 0xA7, 0xAC, 0xF6,
+		0xE5, 0xA8, 0x9B, 0xF6, 0xE5, 0xA8, 0xA7, 0xF6,
+		0xE5, 0xA7, 0x98, 0xF6, 0xE5, 0xA9, 0xA6, 0xF6,
+		0xE3, 0x9B, 0xAE, 0xF6, 0xE3, 0x9B, 0xBC, 0xF6,
+		0xE5, 0xAC, 0x88, 0xF6, 0xE5, 0xAC, 0xBE, 0xF6,
+		0xE5, 0xAC, 0xBE, 0xF6, 0xF0, 0xA1, 0xA7, 0x88,
+		0xF6, 0xE5, 0xAF, 0x83, 0xF6, 0xE5, 0xAF, 0x98,
+		0xF6, 0xE5, 0xAF, 0xA7, 0xF6, 0xE5, 0xAF, 0xB3,
+		0xF6, 0xF0, 0xA1, 0xAC, 0x98, 0xF6, 0xE5, 0xAF,
+		0xBF, 0xF6, 0xE5, 0xB0, 0x86, 0xF6, 0xE5, 0xBD,
+		0x93, 0xF6, 0xE5, 0xB0, 0xA2, 0xF6, 0xE3, 0x9E,
+		0x81, 0xF6, 0xE5, 0xB1, 0xA0, 0xF6, 0xE5, 0xB1,
+		0xAE, 0xF6, 0xE5, 0xB3, 0x80, 0xF6, 0xE5, 0xB2,
+		0x8D, 0xF6, 0xF0, 0xA1, 0xB7, 0xA4, 0xF6, 0xE5,
+		0xB5, 0x83, 0xF6, 0xF0, 0xA1, 0xB7, 0xA6, 0xF6,
+		0xE5, 0xB5, 0xAE, 0xF6, 0xE5, 0xB5, 0xAB, 0xF6,
+		0xE5, 0xB5, 0xBC, 0xF6, 0xE5, 0xB7, 0xA1, 0xF6,
+		0xE5, 0xB7, 0xA2, 0xF6, 0xE3, 0xA0, 0xAF, 0xF6,
+		0xE5, 0xB7, 0xBD, 0xF6, 0xE5, 0xB8, 0xA8, 0xF6,
+		0xE5, 0xB8, 0xBD, 0xF6, 0xE5, 0xB9, 0xA9, 0xF6,
+		0xE3, 0xA1, 0xA2, 0xF6, 0xF0, 0xA2, 0x86, 0x83,
+		0xF6, 0xE3, 0xA1, 0xBC, 0xF6, 0xE5, 0xBA, 0xB0,
+		0xF6, 0xE5, 0xBA, 0xB3, 0xF6, 0xE5, 0xBA, 0xB6,
+		0xF6, 0xE5, 0xBB, 0x8A, 0xF6, 0xF0, 0xAA, 0x8E,
+		0x92, 0xF6, 0xE5, 0xBB, 0xBE, 0xF6, 0xF0, 0xA2,
+		0x8C, 0xB1, 0xF6, 0xF0, 0xA2, 0x8C, 0xB1, 0xF6,
+		0xE8, 0x88, 0x81, 0xF6, 0xE5, 0xBC, 0xA2, 0xF6,
+		0xE5, 0xBC, 0xA2, 0xF6, 0xE3, 0xA3, 0x87, 0xF6,
+		0xF0, 0xA3, 0x8A, 0xB8, 0xF6, 0xF0, 0xA6, 0x87,
+		0x9A, 0xF6, 0xE5, 0xBD, 0xA2, 0xF6, 0xE5, 0xBD,
+		0xAB, 0xF6, 0xE3, 0xA3, 0xA3, 0xF6, 0xE5, 0xBE,
+		0x9A, 0xF6, 0xE5, 0xBF, 0x8D, 0xF6, 0xE5, 0xBF,
+		0x97, 0xF6, 0xE5, 0xBF, 0xB9, 0xF6, 0xE6, 0x82,
+		0x81, 0xF6, 0xE3, 0xA4, 0xBA, 0xF6, 0xE3, 0xA4,
+		0x9C, 0xF6, 0xE6, 0x82, 0x94, 0xF6, 0xF0, 0xA2,
+		0x9B, 0x94, 0xF6, 0xE6, 0x83, 0x87, 0xF6, 0xE6,
+		0x85, 0x88, 0xF6, 0xE6, 0x85, 0x8C, 0xF6, 0xE6,
+		0x85, 0x8E, 0xF6, 0xE6, 0x85, 0x8C, 0xF6, 0xE6,
+		0x85, 0xBA, 0xF6, 0xE6, 0x86, 0x8E, 0xF6, 0xE6,
+		0x86, 0xB2, 0xF6, 0xE6, 0x86, 0xA4, 0xF6, 0xE6,
+		0x86, 0xAF, 0xF6, 0xE6, 0x87, 0x9E, 0xF6, 0xE6,
+		0x87, 0xB2, 0xF6, 0xE6, 0x87, 0xB6, 0xF6, 0xE6,
+		0x88, 0x90, 0xF6, 0xE6, 0x88, 0x9B, 0xF6, 0xE6,
+		0x89, 0x9D, 0xF6, 0xE6, 0x8A, 0xB1, 0xF6, 0xE6,
+		0x8B, 0x94, 0xF6, 0xE6, 0x8D, 0x90, 0xF6, 0xF0,
+		0xA2, 0xAC, 0x8C, 0xF6, 0xE6, 0x8C, 0xBD, 0xF6,
+		0xE6, 0x8B, 0xBC, 0xF6, 0xE6, 0x8D, 0xA8, 0xF6,
+		0xE6, 0x8E, 0x83, 0xF6, 0xE6, 0x8F, 0xA4, 0xF6,
+		0xF0, 0xA2, 0xAF, 0xB1, 0xF6, 0xE6, 0x90, 0xA2,
+		0xF6, 0xE6, 0x8F, 0x85, 0xF6, 0xE6, 0x8E, 0xA9,
+		0xF6, 0xE3, 0xA8, 0xAE, 0xF6, 0xE6, 0x91, 0xA9,
+		0xF6, 0xE6, 0x91, 0xBE, 0xF6, 0xE6, 0x92, 0x9D,
+		0xF6, 0xE6, 0x91, 0xB7, 0xF6, 0xE3, 0xA9, 0xAC,
+		0xF6, 0xE6, 0x95, 0x8F, 0xF6, 0xE6, 0x95, 0xAC,
+		0xF6, 0xF0, 0xA3, 0x80, 0x8A, 0xF6, 0xE6, 0x97,
+		0xA3, 0xF6, 0xE6, 0x9B, 0xB8, 0xF6, 0xE6, 0x99,
+		0x89, 0xF6, 0xE3, 0xAC, 0x99, 0xF6, 0xE6, 0x9A,
+		0x91, 0xF6, 0xE3, 0xAC, 0x88, 0xF6, 0xE3, 0xAB,
+		0xA4, 0xF6, 0xE5, 0x86, 0x92, 0xF6, 0xE5, 0x86,
+		0x95, 0xF6, 0xE6, 0x9C, 0x80, 0xF6, 0xE6, 0x9A,
+		0x9C, 0xF6, 0xE8, 0x82, 0xAD, 0xF6, 0xE4, 0x8F,
+		0x99, 0xF6, 0xE6, 0x9C, 0x97, 0xF6, 0xE6, 0x9C,
+		0x9B, 0xF6, 0xE6, 0x9C, 0xA1, 0xF6, 0xE6, 0x9D,
+		0x9E, 0xF6, 0xE6, 0x9D, 0x93, 0xF6, 0xF0, 0xA3,
+		0x8F, 0x83, 0xF6, 0xE3, 0xAD, 0x89, 0xF6, 0xE6,
+		0x9F, 0xBA, 0xF6, 0xE6, 0x9E, 0x85, 0xF6, 0xE6,
+		0xA1, 0x92, 0xF6, 0xE6, 0xA2, 0x85, 0xF6, 0xF0,
+		0xA3, 0x91, 0xAD, 0xF6, 0xE6, 0xA2, 0x8E, 0xF6,
+		0xE6, 0xA0, 0x9F, 0xF6, 0xE6, 0xA4, 0x94, 0xF6,
+		0xE3, 0xAE, 0x9D, 0xF6, 0xE6, 0xA5, 0x82, 0xF6,
+		0xE6, 0xA6, 0xA3, 0xF6, 0xE6, 0xA7, 0xAA, 0xF6,
+		0xE6, 0xAA, 0xA8, 0xF6, 0xF0, 0xA3, 0x9A, 0xA3,
+		0xF6, 0xE6, 0xAB, 0x9B, 0xF6, 0xE3, 0xB0, 0x98,
+		0xF6, 0xE6, 0xAC, 0xA1, 0xF6, 0xF0, 0xA3, 0xA2,
+		0xA7, 0xF6, 0xE6, 0xAD, 0x94, 0xF6, 0xE3, 0xB1,
+		0x8E, 0xF6, 0xE6, 0xAD, 0xB2, 0xF6, 0xE6, 0xAE,
+		0x9F, 0xF6, 0xE6, 0xAE, 0xBA, 0xF6, 0xE6, 0xAE,
+		0xBB, 0xF6, 0xF0, 0xA3, 0xAA, 0x8D, 0xF6, 0xF0,
+		0xA1, 0xB4, 0x8B, 0xF6, 0xF0, 0xA3, 0xAB, 0xBA,
+		0xF6, 0xE6, 0xB1, 0x8E, 0xF6, 0xF0, 0xA3, 0xB2,
+		0xBC, 0xF6, 0xE6, 0xB2, 0xBF, 0xF6, 0xE6, 0xB3,
+		0x8D, 0xF6, 0xE6, 0xB1, 0xA7, 0xF6, 0xE6, 0xB4,
+		0x96, 0xF6, 0xE6, 0xB4, 0xBE, 0xF6, 0xE6, 0xB5,
+		0xB7, 0xF6, 0xE6, 0xB5, 0x81, 0xF6, 0xE6, 0xB5,
+		0xA9, 0xF6, 0xE6, 0xB5, 0xB8, 0xF6, 0xE6, 0xB6,
+		0x85, 0xF6, 0xF0, 0xA3, 0xB4, 0x9E, 0xF6, 0xE6,
+		0xB4, 0xB4, 0xF6, 0xE6, 0xB8, 0xAF, 0xF6, 0xE6,
+		0xB9, 0xAE, 0xF6, 0xE3, 0xB4, 0xB3, 0xF6, 0xE6,
+		0xBB, 0x8B, 0xF6, 0xE6, 0xBB, 0x87, 0xF6, 0xF0,
+		0xA3, 0xBB, 0x91, 0xF6, 0xE6, 0xB7, 0xB9, 0xF6,
+		0xE6, 0xBD, 0xAE, 0xF6, 0xF0, 0xA3, 0xBD, 0x9E,
+		0xF6, 0xF0, 0xA3, 0xBE, 0x8E, 0xF6, 0xE6, 0xBF,
+		0x86, 0xF6, 0xE7, 0x80, 0xB9, 0xF6, 0xE7, 0x80,
+		0x9E, 0xF6, 0xE7, 0x80, 0x9B, 0xF6, 0xE3, 0xB6,
+		0x96, 0xF6, 0xE7, 0x81, 0x8A, 0xF6, 0xE7, 0x81,
+		0xBD, 0xF6, 0xE7, 0x81, 0xB7, 0xF6, 0xE7, 0x82,
+		0xAD, 0xF6, 0xF0, 0xA0, 0x94, 0xA5, 0xF6, 0xE7,
+		0x85, 0x85, 0xF6, 0xF0, 0xA4, 0x89, 0xA3, 0xF6,
+		0xE7, 0x86, 0x9C, 0xF6, 0xF0, 0xA4, 0x8E, 0xAB,
+		0xF6, 0xE7, 0x88, 0xA8, 0xF6, 0xE7, 0x88, 0xB5,
+		0xF6, 0xE7, 0x89, 0x90, 0xF6, 0xF0, 0xA4, 0x98,
+		0x88, 0xF6, 0xE7, 0x8A, 0x80, 0xF6, 0xE7, 0x8A,
+		0x95, 0xF6, 0xF0, 0xA4, 0x9C, 0xB5, 0xF6, 0xF0,
+		0xA4, 0xA0, 0x94, 0xF6, 0xE7, 0x8D, 0xBA, 0xF6,
+		0xE7, 0x8E, 0x8B, 0xF6, 0xE3, 0xBA, 0xAC, 0xF6,
+		0xE7, 0x8E, 0xA5, 0xF6, 0xE3, 0xBA, 0xB8, 0xF6,
+		0xE3, 0xBA, 0xB8, 0xF6, 0xE7, 0x91, 0x87, 0xF6,
+		0xE7, 0x91, 0x9C, 0xF6, 0xE7, 0x91, 0xB1, 0xF6,
+		0xE7, 0x92, 0x85, 0xF6, 0xE7, 0x93, 0x8A, 0xF6,
+		0xE3, 0xBC, 0x9B, 0xF6, 0xE7, 0x94, 0xA4, 0xF6,
+		0xF0, 0xA4, 0xB0, 0xB6, 0xF6, 0xE7, 0x94, 0xBE,
+		0xF6, 0xF0, 0xA4, 0xB2, 0x92, 0xF6, 0xE7, 0x95,
+		0xB0, 0xF6, 0xF0, 0xA2, 0x86, 0x9F, 0xF6, 0xE7,
+		0x98, 0x90, 0xF6, 0xF0, 0xA4, 0xBE, 0xA1, 0xF6,
+		0xF0, 0xA4, 0xBE, 0xB8, 0xF6, 0xF0, 0xA5, 0x81,
+		0x84, 0xF6, 0xE3, 0xBF, 0xBC, 0xF6, 0xE4, 0x80,
+		0x88, 0xF6, 0xE7, 0x9B, 0xB4, 0xF6, 0xF0, 0xA5,
+		0x83, 0xB3, 0xF6, 0xF0, 0xA5, 0x83, 0xB2, 0xF6,
+		0xF0, 0xA5, 0x84, 0x99, 0xF6, 0xF0, 0xA5, 0x84,
+		0xB3, 0xF6, 0xE7, 0x9C, 0x9E, 0xF6, 0xE7, 0x9C,
+		0x9F, 0xF6, 0xE7, 0x9C, 0x9F, 0xF6, 0xE7, 0x9D,
+		0x8A, 0xF6, 0xE4, 0x80, 0xB9, 0xF6, 0xE7, 0x9E,
+		0x8B, 0xF6, 0xE4, 0x81, 0x86, 0xF6, 0xE4, 0x82,
+		0x96, 0xF6, 0xF0, 0xA5, 0x90, 0x9D, 0xF6, 0xE7,
+		0xA1, 0x8E, 0xF6, 0xE7, 0xA2, 0x8C, 0xF6, 0xE7,
+		0xA3, 0x8C, 0xF6, 0xE4, 0x83, 0xA3, 0xF6, 0xF0,
+		0xA5, 0x98, 0xA6, 0xF6, 0xE7, 0xA5, 0x96, 0xF6,
+		0xF0, 0xA5, 0x9A, 0x9A, 0xF6, 0xF0, 0xA5, 0x9B,
+		0x85, 0xF6, 0xE7, 0xA6, 0x8F, 0xF6, 0xE7, 0xA7,
+		0xAB, 0xF6, 0xE4, 0x84, 0xAF, 0xF6, 0xE7, 0xA9,
+		0x80, 0xF6, 0xE7, 0xA9, 0x8A, 0xF6, 0xE7, 0xA9,
+		0x8F, 0xF6, 0xF0, 0xA5, 0xA5, 0xBC, 0xF6, 0xF0,
+		0xA5, 0xAA, 0xA7, 0xF6, 0xF0, 0xA5, 0xAA, 0xA7,
+		0xF6, 0xE7, 0xAB, 0xAE, 0xF6, 0xE4, 0x88, 0x82,
+		0xF6, 0xF0, 0xA5, 0xAE, 0xAB, 0xF6, 0xE7, 0xAF,
+		0x86, 0xF6, 0xE7, 0xAF, 0x89, 0xF6, 0xE4, 0x88,
+		0xA7, 0xF6, 0xF0, 0xA5, 0xB2, 0x80, 0xF6, 0xE7,
+		0xB3, 0x92, 0xF6, 0xE4, 0x8A, 0xA0, 0xF6, 0xE7,
+		0xB3, 0xA8, 0xF6, 0xE7, 0xB3, 0xA3, 0xF6, 0xE7,
+		0xB4, 0x80, 0xF6, 0xF0, 0xA5, 0xBE, 0x86, 0xF6,
+		0xE7, 0xB5, 0xA3, 0xF6, 0xE4, 0x8C, 0x81, 0xF6,
+		0xE7, 0xB7, 0x87, 0xF6, 0xE7, 0xB8, 0x82, 0xF6,
+		0xE7, 0xB9, 0x85, 0xF6, 0xE4, 0x8C, 0xB4, 0xF6,
+		0xF0, 0xA6, 0x88, 0xA8, 0xF6, 0xF0, 0xA6, 0x89,
+		0x87, 0xF6, 0xE4, 0x8D, 0x99, 0xF6, 0xF0, 0xA6,
+		0x8B, 0x99, 0xF6, 0xE7, 0xBD, 0xBA, 0xF6, 0xF0,
+		0xA6, 0x8C, 0xBE, 0xF6, 0xE7, 0xBE, 0x95, 0xF6,
+		0xE7, 0xBF, 0xBA, 0xF6, 0xE8, 0x80, 0x85, 0xF6,
+		0xF0, 0xA6, 0x93, 0x9A, 0xF6, 0xF0, 0xA6, 0x94,
+		0xA3, 0xF6, 0xE8, 0x81, 0xA0, 0xF6, 0xF0, 0xA6,
+		0x96, 0xA8, 0xF6, 0xE8, 0x81, 0xB0, 0xF6, 0xF0,
+		0xA3, 0x8D, 0x9F, 0xF6, 0xE4, 0x8F, 0x95, 0xF6,
+		0xE8, 0x82, 0xB2, 0xF6, 0xE8, 0x84, 0x83, 0xF6,
+		0xE4, 0x90, 0x8B, 0xF6, 0xE8, 0x84, 0xBE, 0xF6,
+		0xE5, 0xAA, 0xB5, 0xF6, 0xF0, 0xA6, 0x9E, 0xA7,
+		0xF6, 0xF0, 0xA6, 0x9E, 0xB5, 0xF6, 0xF0, 0xA3,
+		0x8E, 0x93, 0xF6, 0xF0, 0xA3, 0x8E, 0x9C, 0xF6,
+		0xE8, 0x88, 0x81, 0xF6, 0xE8, 0x88, 0x84, 0xF6,
+		0xE8, 0xBE, 0x9E, 0xF6, 0xE4, 0x91, 0xAB, 0xF6,
+		0xE8, 0x8A, 0x91, 0xF6, 0xE8, 0x8A, 0x8B, 0xF6,
+		0xE8, 0x8A, 0x9D, 0xF6, 0xE5, 0x8A, 0xB3, 0xF6,
+		0xE8, 0x8A, 0xB1, 0xF6, 0xE8, 0x8A, 0xB3, 0xF6,
+		0xE8, 0x8A, 0xBD, 0xF6, 0xE8, 0x8B, 0xA6, 0xF6,
+		0xF0, 0xA6, 0xAC, 0xBC, 0xF6, 0xE8, 0x8B, 0xA5,
+		0xF6, 0xE8, 0x8C, 0x9D, 0xF6, 0xE8, 0x8D, 0xA3,
+		0xF6, 0xE8, 0x8E, 0xAD, 0xF6, 0xE8, 0x8C, 0xA3,
+		0xF6, 0xE8, 0x8E, 0xBD, 0xF6, 0xE8, 0x8F, 0xA7,
+		0xF6, 0xE8, 0x91, 0x97, 0xF6, 0xE8, 0x8D, 0x93,
+		0xF6, 0xE8, 0x8F, 0x8A, 0xF6, 0xE8, 0x8F, 0x8C,
+		0xF6, 0xE8, 0x8F, 0x9C, 0xF6, 0xF0, 0xA6, 0xB0,
+		0xB6, 0xF6, 0xF0, 0xA6, 0xB5, 0xAB, 0xF6, 0xF0,
+		0xA6, 0xB3, 0x95, 0xF6, 0xE4, 0x94, 0xAB, 0xF6,
+		0xE8, 0x93, 0xB1, 0xF6, 0xE8, 0x93, 0xB3, 0xF6,
+		0xE8, 0x94, 0x96, 0xF6, 0xF0, 0xA7, 0x8F, 0x8A,
+		0xF6, 0xE8, 0x95, 0xA4, 0xF6, 0xF0, 0xA6, 0xBC,
+		0xAC, 0xF6, 0xE4, 0x95, 0x9D, 0xF6, 0xE4, 0x95,
+		0xA1, 0xF6, 0xF0, 0xA6, 0xBE, 0xB1, 0xF6, 0xF0,
+		0xA7, 0x83, 0x92, 0xF6, 0xE4, 0x95, 0xAB, 0xF6,
+		0xE8, 0x99, 0x90, 0xF6, 0xE8, 0x99, 0x9C, 0xF6,
+		0xE8, 0x99, 0xA7, 0xF6, 0xE8, 0x99, 0xA9, 0xF6,
+		0xE8, 0x9A, 0xA9, 0xF6, 0xE8, 0x9A, 0x88, 0xF6,
+		0xE8, 0x9C, 0x8E, 0xF6, 0xE8, 0x9B, 0xA2, 0xF6,
+		0xE8, 0x9D, 0xB9, 0xF6, 0xE8, 0x9C, 0xA8, 0xF6,
+		0xE8, 0x9D, 0xAB, 0xF6, 0xE8, 0x9E, 0x86, 0xF6,
+		0xE4, 0x97, 0x97, 0xF6, 0xE8, 0x9F, 0xA1, 0xF6,
+		0xE8, 0xA0, 0x81, 0xF6, 0xE4, 0x97, 0xB9, 0xF6,
+		0xE8, 0xA1, 0xA0, 0xF6, 0xE8, 0xA1, 0xA3, 0xF6,
+		0xF0, 0xA7, 0x99, 0xA7, 0xF6, 0xE8, 0xA3, 0x97,
+		0xF6, 0xE8, 0xA3, 0x9E, 0xF6, 0xE4, 0x98, 0xB5,
+		0xF6, 0xE8, 0xA3, 0xBA, 0xF6, 0xE3, 0x92, 0xBB,
+		0xF6, 0xF0, 0xA7, 0xA2, 0xAE, 0xF6, 0xF0, 0xA7,
+		0xA5, 0xA6, 0xF6, 0xE4, 0x9A, 0xBE, 0xF6, 0xE4,
+		0x9B, 0x87, 0xF6, 0xE8, 0xAA, 0xA0, 0xF6, 0xE8,
+		0xAB, 0xAD, 0xF6, 0xE8, 0xAE, 0x8A, 0xF6, 0xE8,
+		0xB1, 0x95, 0xF6, 0xF0, 0xA7, 0xB2, 0xA8, 0xF6,
+		0xE8, 0xB2, 0xAB, 0xF6, 0xE8, 0xB3, 0x81, 0xF6,
+		0xE8, 0xB4, 0x9B, 0xF6, 0xE8, 0xB5, 0xB7, 0xF6,
+		0xF0, 0xA7, 0xBC, 0xAF, 0xF6, 0xF0, 0xA0, 0xA0,
+		0x84, 0xF6, 0xE8, 0xB7, 0x8B, 0xF6, 0xE8, 0xB6,
+		0xBC, 0xF6, 0xE8, 0xB7, 0xB0, 0xF6, 0xF0, 0xA0,
+		0xA3, 0x9E, 0xF6, 0xE8, 0xBB, 0x94, 0xF6, 0xE8,
+		0xBC, 0xB8, 0xF6, 0xF0, 0xA8, 0x97, 0x92, 0xF6,
+		0xF0, 0xA8, 0x97, 0xAD, 0xF6, 0xE9, 0x82, 0x94,
+		0xF6, 0xE9, 0x83, 0xB1, 0xF6, 0xE9, 0x84, 0x91,
+		0xF6, 0xF0, 0xA8, 0x9C, 0xAE, 0xF6, 0xE9, 0x84,
+		0x9B, 0xF6, 0xE9, 0x88, 0xB8, 0xF6, 0xE9, 0x8B,
+		0x97, 0xF6, 0xE9, 0x8B, 0x98, 0xF6, 0xE9, 0x89,
+		0xBC, 0xF6, 0xE9, 0x8F, 0xB9, 0xF6, 0xE9, 0x90,
+		0x95, 0xF6, 0xF0, 0xA8, 0xAF, 0xBA, 0xF6, 0xE9,
+		0x96, 0x8B, 0xF6, 0xE4, 0xA6, 0x95, 0xF6, 0xE9,
+		0x96, 0xB7, 0xF6, 0xF0, 0xA8, 0xB5, 0xB7, 0xF6,
+		0xE4, 0xA7, 0xA6, 0xF6, 0xE9, 0x9B, 0x83, 0xF6,
+		0xE5, 0xB6, 0xB2, 0xF6, 0xE9, 0x9C, 0xA3, 0xF6,
+		0xF0, 0xA9, 0x85, 0x85, 0xF6, 0xF0, 0xA9, 0x88,
+		0x9A, 0xF6, 0xE4, 0xA9, 0xAE, 0xF6, 0xE4, 0xA9,
+		0xB6, 0xF6, 0xE9, 0x9F, 0xA0, 0xF6, 0xF0, 0xA9,
+		0x90, 0x8A, 0xF6, 0xE4, 0xAA, 0xB2, 0xF6, 0xF0,
+		0xA9, 0x92, 0x96, 0xF6, 0xE9, 0xA0, 0x8B, 0xF6,
+		0xE9, 0xA0, 0x8B, 0xF6, 0xE9, 0xA0, 0xA9, 0xF6,
+		0xF0, 0xA9, 0x96, 0xB6, 0xF6, 0xE9, 0xA3, 0xA2,
+		0xF6, 0xE4, 0xAC, 0xB3, 0xF6, 0xE9, 0xA4, 0xA9,
+		0xF6, 0xE9, 0xA6, 0xA7, 0xF6, 0xE9, 0xA7, 0x82,
+		0xF6, 0xE9, 0xA7, 0xBE, 0xF6, 0xE4, 0xAF, 0x8E,
+		0xF6, 0xF0, 0xA9, 0xAC, 0xB0, 0xF6, 0xE9, 0xAC,
+		0x92, 0xF6, 0xE9, 0xB1, 0x80, 0xF6, 0xE9, 0xB3,
+		0xBD, 0xF6, 0xE4, 0xB3, 0x8E, 0xF6, 0xE4, 0xB3,
+		0xAD, 0xF6, 0xE9, 0xB5, 0xA7, 0xF6, 0xF0, 0xAA,
+		0x83, 0x8E, 0xF6, 0xE4, 0xB3, 0xB8, 0xF6, 0xF0,
+		0xAA, 0x84, 0x85, 0xF6, 0xF0, 0xAA, 0x88, 0x8E,
+		0xF6, 0xF0, 0xAA, 0x8A, 0x91, 0xF6, 0xE9, 0xBA,
+		0xBB, 0xF6, 0xE4, 0xB5, 0x96, 0xF6, 0xE9, 0xBB,
+		0xB9, 0xF6, 0xE9, 0xBB, 0xBE, 0xF6, 0xE9, 0xBC,
+		0x85, 0xF6, 0xE9, 0xBC, 0x8F, 0xF6, 0xE9, 0xBC,
+		0x96, 0xF6, 0xE9, 0xBC, 0xBB, 0xF6, 0xF0, 0xAA,
+		0x98, 0x80, 0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,
+	},
+	{
+		0x20, 0x20, 0xCC, 0x88, 0x61, 0x20, 0xCC, 0x84,
+		0x32, 0x33, 0x20, 0xCC, 0x81, 0xCE, 0xBC, 0x20,
+		0xCC, 0xA7, 0x31, 0x6F, 0x31, 0xE2, 0x81, 0x84,
+		0x34, 0x31, 0xE2, 0x81, 0x84, 0x32, 0x33, 0xE2,
+		0x81, 0x84, 0x34, 0xF6, 0x41, 0xCC, 0x80, 0xF6,
+		0x41, 0xCC, 0x81, 0xF6, 0x41, 0xCC, 0x82, 0xF6,
+		0x41, 0xCC, 0x83, 0xF6, 0x41, 0xCC, 0x88, 0xF6,
+		0x41, 0xCC, 0x8A, 0xF6, 0x43, 0xCC, 0xA7, 0xF6,
+		0x45, 0xCC, 0x80, 0xF6, 0x45, 0xCC, 0x81, 0xF6,
+		0x45, 0xCC, 0x82, 0xF6, 0x45, 0xCC, 0x88, 0xF6,
+		0x49, 0xCC, 0x80, 0xF6, 0x49, 0xCC, 0x81, 0xF6,
+		0x49, 0xCC, 0x82, 0xF6, 0x49, 0xCC, 0x88, 0xF6,
+		0x4E, 0xCC, 0x83, 0xF6, 0x4F, 0xCC, 0x80, 0xF6,
+		0x4F, 0xCC, 0x81, 0xF6, 0x4F, 0xCC, 0x82, 0xF6,
+		0x4F, 0xCC, 0x83, 0xF6, 0x4F, 0xCC, 0x88, 0xF6,
+		0x55, 0xCC, 0x80, 0xF6, 0x55, 0xCC, 0x81, 0xF6,
+		0x55, 0xCC, 0x82, 0xF6, 0x55, 0xCC, 0x88, 0xF6,
+		0x59, 0xCC, 0x81, 0xF6, 0x61, 0xCC, 0x80, 0xF6,
+		0x61, 0xCC, 0x81, 0xF6, 0x61, 0xCC, 0x82, 0xF6,
+		0x61, 0xCC, 0x83, 0xF6, 0x61, 0xCC, 0x88, 0xF6,
+		0x61, 0xCC, 0x8A, 0xF6, 0x63, 0xCC, 0xA7, 0xF6,
+		0x65, 0xCC, 0x80, 0xF6, 0x65, 0xCC, 0x81, 0xF6,
+		0x65, 0xCC, 0x82, 0xF6, 0x65, 0xCC, 0x88, 0xF6,
+		0x69, 0xCC, 0x80, 0xF6, 0x69, 0xCC, 0x81, 0xF6,
+		0x69, 0xCC, 0x82, 0xF6, 0x69, 0xCC, 0x88, 0xF6,
+		0x6E, 0xCC, 0x83, 0xF6, 0x6F, 0xCC, 0x80, 0xF6,
+		0x6F, 0xCC, 0x81, 0xF6, 0x6F, 0xCC, 0x82, 0xF6,
+		0x6F, 0xCC, 0x83, 0xF6, 0x6F, 0xCC, 0x88, 0xF6,
+		0x75, 0xCC, 0x80, 0xF6, 0x75, 0xCC, 0x81, 0xF6,
+		0x75, 0xCC, 0x82, 0xF6, 0x75, 0xCC, 0x88, 0xF6,
+		0x79, 0xCC, 0x81, 0xF6, 0x79, 0xCC, 0x88, 0xF6,
+		0x41, 0xCC, 0x84, 0xF6, 0x61, 0xCC, 0x84, 0xF6,
+		0x41, 0xCC, 0x86, 0xF6, 0x61, 0xCC, 0x86, 0xF6,
+		0x41, 0xCC, 0xA8, 0xF6, 0x61, 0xCC, 0xA8, 0xF6,
+		0x43, 0xCC, 0x81, 0xF6, 0x63, 0xCC, 0x81, 0xF6,
+		0x43, 0xCC, 0x82, 0xF6, 0x63, 0xCC, 0x82, 0xF6,
+		0x43, 0xCC, 0x87, 0xF6, 0x63, 0xCC, 0x87, 0xF6,
+		0x43, 0xCC, 0x8C, 0xF6, 0x63, 0xCC, 0x8C, 0xF6,
+		0x44, 0xCC, 0x8C, 0xF6, 0x64, 0xCC, 0x8C, 0xF6,
+		0x45, 0xCC, 0x84, 0xF6, 0x65, 0xCC, 0x84, 0xF6,
+		0x45, 0xCC, 0x86, 0xF6, 0x65, 0xCC, 0x86, 0xF6,
+		0x45, 0xCC, 0x87, 0xF6, 0x65, 0xCC, 0x87, 0xF6,
+		0x45, 0xCC, 0xA8, 0xF6, 0x65, 0xCC, 0xA8, 0xF6,
+		0x45, 0xCC, 0x8C, 0xF6, 0x65, 0xCC, 0x8C, 0xF6,
+		0x47, 0xCC, 0x82, 0xF6, 0x67, 0xCC, 0x82, 0xF6,
+		0x47, 0xCC, 0x86, 0xF6, 0x67, 0xCC, 0x86, 0xF6,
+		0x47, 0xCC, 0x87, 0xF6, 0x67, 0xCC, 0x87, 0xF6,
+		0x47, 0xCC, 0xA7, 0xF6, 0x67, 0xCC, 0xA7, 0xF6,
+		0x48, 0xCC, 0x82, 0xF6, 0x68, 0xCC, 0x82, 0xF6,
+		0x49, 0xCC, 0x83, 0xF6, 0x69, 0xCC, 0x83, 0xF6,
+		0x49, 0xCC, 0x84, 0xF6, 0x69, 0xCC, 0x84, 0xF6,
+		0x49, 0xCC, 0x86, 0xF6, 0x69, 0xCC, 0x86, 0xF6,
+		0x49, 0xCC, 0xA8, 0xF6, 0x69, 0xCC, 0xA8, 0xF6,
+		0x49, 0xCC, 0x87, 0x49, 0x4A, 0x69, 0x6A, 0xF6,
+		0x4A, 0xCC, 0x82, 0xF6, 0x6A, 0xCC, 0x82, 0xF6,
+		0x4B, 0xCC, 0xA7, 0xF6, 0x6B, 0xCC, 0xA7, 0xF6,
+		0x4C, 0xCC, 0x81, 0xF6, 0x6C, 0xCC, 0x81, 0xF6,
+		0x4C, 0xCC, 0xA7, 0xF6, 0x6C, 0xCC, 0xA7, 0xF6,
+		0x4C, 0xCC, 0x8C, 0xF6, 0x6C, 0xCC, 0x8C, 0x4C,
+		0xC2, 0xB7, 0x6C, 0xC2, 0xB7, 0xF6, 0x4E, 0xCC,
+		0x81, 0xF6, 0x6E, 0xCC, 0x81, 0xF6, 0x4E, 0xCC,
+		0xA7, 0xF6, 0x6E, 0xCC, 0xA7, 0xF6, 0x4E, 0xCC,
+		0x8C, 0xF6, 0x6E, 0xCC, 0x8C, 0xCA, 0xBC, 0x6E,
+		0xF6, 0x4F, 0xCC, 0x84, 0xF6, 0x6F, 0xCC, 0x84,
+		0xF6, 0x4F, 0xCC, 0x86, 0xF6, 0x6F, 0xCC, 0x86,
+		0xF6, 0x4F, 0xCC, 0x8B, 0xF6, 0x6F, 0xCC, 0x8B,
+		0xF6, 0x52, 0xCC, 0x81, 0xF6, 0x72, 0xCC, 0x81,
+		0xF6, 0x52, 0xCC, 0xA7, 0xF6, 0x72, 0xCC, 0xA7,
+		0xF6, 0x52, 0xCC, 0x8C, 0xF6, 0x72, 0xCC, 0x8C,
+		0xF6, 0x53, 0xCC, 0x81, 0xF6, 0x73, 0xCC, 0x81,
+		0xF6, 0x53, 0xCC, 0x82, 0xF6, 0x73, 0xCC, 0x82,
+		0xF6, 0x53, 0xCC, 0xA7, 0xF6, 0x73, 0xCC, 0xA7,
+		0xF6, 0x53, 0xCC, 0x8C, 0xF6, 0x73, 0xCC, 0x8C,
+		0xF6, 0x54, 0xCC, 0xA7, 0xF6, 0x74, 0xCC, 0xA7,
+		0xF6, 0x54, 0xCC, 0x8C, 0xF6, 0x74, 0xCC, 0x8C,
+		0xF6, 0x55, 0xCC, 0x83, 0xF6, 0x75, 0xCC, 0x83,
+		0xF6, 0x55, 0xCC, 0x84, 0xF6, 0x75, 0xCC, 0x84,
+		0xF6, 0x55, 0xCC, 0x86, 0xF6, 0x75, 0xCC, 0x86,
+		0xF6, 0x55, 0xCC, 0x8A, 0xF6, 0x75, 0xCC, 0x8A,
+		0xF6, 0x55, 0xCC, 0x8B, 0xF6, 0x75, 0xCC, 0x8B,
+		0xF6, 0x55, 0xCC, 0xA8, 0xF6, 0x75, 0xCC, 0xA8,
+		0xF6, 0x57, 0xCC, 0x82, 0xF6, 0x77, 0xCC, 0x82,
+		0xF6, 0x59, 0xCC, 0x82, 0xF6, 0x79, 0xCC, 0x82,
+		0xF6, 0x59, 0xCC, 0x88, 0xF6, 0x5A, 0xCC, 0x81,
+		0xF6, 0x7A, 0xCC, 0x81, 0xF6, 0x5A, 0xCC, 0x87,
+		0xF6, 0x7A, 0xCC, 0x87, 0xF6, 0x5A, 0xCC, 0x8C,
+		0xF6, 0x7A, 0xCC, 0x8C, 0x73, 0xF6, 0x4F, 0xCC,
+		0x9B, 0xF6, 0x6F, 0xCC, 0x9B, 0xF6, 0x55, 0xCC,
+		0x9B, 0xF6, 0x75, 0xCC, 0x9B, 0x44, 0x5A, 0xCC,
+		0x8C, 0x44, 0x7A, 0xCC, 0x8C, 0x64, 0x7A, 0xCC,
+		0x8C, 0x4C, 0x4A, 0x4C, 0x6A, 0x6C, 0x6A, 0x4E,
+		0x4A, 0x4E, 0x6A, 0x6E, 0x6A, 0xF6, 0x41, 0xCC,
+		0x8C, 0xF6, 0x61, 0xCC, 0x8C, 0xF6, 0x49, 0xCC,
+		0x8C, 0xF6, 0x69, 0xCC, 0x8C, 0xF6, 0x4F, 0xCC,
+		0x8C, 0xF6, 0x6F, 0xCC, 0x8C, 0xF6, 0x55, 0xCC,
+		0x8C, 0xF6, 0x75, 0xCC, 0x8C, 0xF6, 0x55, 0xCC,
+		0x88, 0xCC, 0x84, 0xF6, 0x75, 0xCC, 0x88, 0xCC,
+		0x84, 0xF6, 0x55, 0xCC, 0x88, 0xCC, 0x81, 0xF6,
+		0x75, 0xCC, 0x88, 0xCC, 0x81, 0xF6, 0x55, 0xCC,
+		0x88, 0xCC, 0x8C, 0xF6, 0x75, 0xCC, 0x88, 0xCC,
+		0x8C, 0xF6, 0x55, 0xCC, 0x88, 0xCC, 0x80, 0xF6,
+		0x75, 0xCC, 0x88, 0xCC, 0x80, 0xF6, 0x41, 0xCC,
+		0x88, 0xCC, 0x84, 0xF6, 0x61, 0xCC, 0x88, 0xCC,
+		0x84, 0xF6, 0x41, 0xCC, 0x87, 0xCC, 0x84, 0xF6,
+		0x61, 0xCC, 0x87, 0xCC, 0x84, 0xF6, 0xC3, 0x86,
+		0xCC, 0x84, 0xF6, 0xC3, 0xA6, 0xCC, 0x84, 0xF6,
+		0x47, 0xCC, 0x8C, 0xF6, 0x67, 0xCC, 0x8C, 0xF6,
+		0x4B, 0xCC, 0x8C, 0xF6, 0x6B, 0xCC, 0x8C, 0xF6,
+		0x4F, 0xCC, 0xA8, 0xF6, 0x6F, 0xCC, 0xA8, 0xF6,
+		0x4F, 0xCC, 0xA8, 0xCC, 0x84, 0xF6, 0x6F, 0xCC,
+		0xA8, 0xCC, 0x84, 0xF6, 0xC6, 0xB7, 0xCC, 0x8C,
+		0xF6, 0xCA, 0x92, 0xCC, 0x8C, 0xF6, 0x6A, 0xCC,
+		0x8C, 0x44, 0x5A, 0x44, 0x7A, 0x64, 0x7A, 0xF6,
+		0x47, 0xCC, 0x81, 0xF6, 0x67, 0xCC, 0x81, 0xF6,
+		0x4E, 0xCC, 0x80, 0xF6, 0x6E, 0xCC, 0x80, 0xF6,
+		0x41, 0xCC, 0x8A, 0xCC, 0x81, 0xF6, 0x61, 0xCC,
+		0x8A, 0xCC, 0x81, 0xF6, 0xC3, 0x86, 0xCC, 0x81,
+		0xF6, 0xC3, 0xA6, 0xCC, 0x81, 0xF6, 0xC3, 0x98,
+		0xCC, 0x81, 0xF6, 0xC3, 0xB8, 0xCC, 0x81, 0xF6,
+		0x41, 0xCC, 0x8F, 0xF6, 0x61, 0xCC, 0x8F, 0xF6,
+		0x41, 0xCC, 0x91, 0xF6, 0x61, 0xCC, 0x91, 0xF6,
+		0x45, 0xCC, 0x8F, 0xF6, 0x65, 0xCC, 0x8F, 0xF6,
+		0x45, 0xCC, 0x91, 0xF6, 0x65, 0xCC, 0x91, 0xF6,
+		0x49, 0xCC, 0x8F, 0xF6, 0x69, 0xCC, 0x8F, 0xF6,
+		0x49, 0xCC, 0x91, 0xF6, 0x69, 0xCC, 0x91, 0xF6,
+		0x4F, 0xCC, 0x8F, 0xF6, 0x6F, 0xCC, 0x8F, 0xF6,
+		0x4F, 0xCC, 0x91, 0xF6, 0x6F, 0xCC, 0x91, 0xF6,
+		0x52, 0xCC, 0x8F, 0xF6, 0x72, 0xCC, 0x8F, 0xF6,
+		0x52, 0xCC, 0x91, 0xF6, 0x72, 0xCC, 0x91, 0xF6,
+		0x55, 0xCC, 0x8F, 0xF6, 0x75, 0xCC, 0x8F, 0xF6,
+		0x55, 0xCC, 0x91, 0xF6, 0x75, 0xCC, 0x91, 0xF6,
+		0x53, 0xCC, 0xA6, 0xF6, 0x73, 0xCC, 0xA6, 0xF6,
+		0x54, 0xCC, 0xA6, 0xF6, 0x74, 0xCC, 0xA6, 0xF6,
+		0x48, 0xCC, 0x8C, 0xF6, 0x68, 0xCC, 0x8C, 0xF6,
+		0x41, 0xCC, 0x87, 0xF6, 0x61, 0xCC, 0x87, 0xF6,
+		0x45, 0xCC, 0xA7, 0xF6, 0x65, 0xCC, 0xA7, 0xF6,
+		0x4F, 0xCC, 0x88, 0xCC, 0x84, 0xF6, 0x6F, 0xCC,
+		0x88, 0xCC, 0x84, 0xF6, 0x4F, 0xCC, 0x83, 0xCC,
+		0x84, 0xF6, 0x6F, 0xCC, 0x83, 0xCC, 0x84, 0xF6,
+		0x4F, 0xCC, 0x87, 0xF6, 0x6F, 0xCC, 0x87, 0xF6,
+		0x4F, 0xCC, 0x87, 0xCC, 0x84, 0xF6, 0x6F, 0xCC,
+		0x87, 0xCC, 0x84, 0xF6, 0x59, 0xCC, 0x84, 0xF6,
+		0x79, 0xCC, 0x84, 0x68, 0xC9, 0xA6, 0x6A, 0x72,
+		0xC9, 0xB9, 0xC9, 0xBB, 0xCA, 0x81, 0x77, 0x79,
+		0x20, 0xCC, 0x86, 0x20, 0xCC, 0x87, 0x20, 0xCC,
+		0x8A, 0x20, 0xCC, 0xA8, 0x20, 0xCC, 0x83, 0x20,
+		0xCC, 0x8B, 0xC9, 0xA3, 0x6C, 0x73, 0x78, 0xCA,
+		0x95, 0xF6, 0xCC, 0x80, 0xF6, 0xCC, 0x81, 0xF6,
+		0xCC, 0x93, 0xF6, 0xCC, 0x88, 0xCC, 0x81, 0xF6,
+		0xCA, 0xB9, 0x20, 0xCD, 0x85, 0xF6, 0x3B, 0x20,
+		0xCC, 0x81, 0xF5, 0x05, 0xC2, 0xA8, 0xCC, 0x81,
+		0x20, 0xCC, 0x88, 0xCC, 0x81, 0xF6, 0xCE, 0x91,
+		0xCC, 0x81, 0xF6, 0xC2, 0xB7, 0xF6, 0xCE, 0x95,
+		0xCC, 0x81, 0xF6, 0xCE, 0x97, 0xCC, 0x81, 0xF6,
+		0xCE, 0x99, 0xCC, 0x81, 0xF6, 0xCE, 0x9F, 0xCC,
+		0x81, 0xF6, 0xCE, 0xA5, 0xCC, 0x81, 0xF6, 0xCE,
+		0xA9, 0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCC, 0x88,
+		0xCC, 0x81, 0xF6, 0xCE, 0x99, 0xCC, 0x88, 0xF6,
+		0xCE, 0xA5, 0xCC, 0x88, 0xF6, 0xCE, 0xB1, 0xCC,
+		0x81, 0xF6, 0xCE, 0xB5, 0xCC, 0x81, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCC, 0x81,
+		0xF6, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xF6,
+		0xCE, 0xB9, 0xCC, 0x88, 0xF6, 0xCF, 0x85, 0xCC,
+		0x88, 0xF6, 0xCE, 0xBF, 0xCC, 0x81, 0xF6, 0xCF,
+		0x85, 0xCC, 0x81, 0xF6, 0xCF, 0x89, 0xCC, 0x81,
+		0xCE, 0xB2, 0xCE, 0xB8, 0xCE, 0xA5, 0xF5, 0x05,
+		0xCF, 0x92, 0xCC, 0x81, 0xCE, 0xA5, 0xCC, 0x81,
+		0xF5, 0x05, 0xCF, 0x92, 0xCC, 0x88, 0xCE, 0xA5,
+		0xCC, 0x88, 0xCF, 0x86, 0xCF, 0x80, 0xCE, 0xBA,
+		0xCF, 0x81, 0xCF, 0x82, 0xCE, 0x98, 0xCE, 0xB5,
+		0xCE, 0xA3, 0xF6, 0xD0, 0x95, 0xCC, 0x80, 0xF6,
+		0xD0, 0x95, 0xCC, 0x88, 0xF6, 0xD0, 0x93, 0xCC,
+		0x81, 0xF6, 0xD0, 0x86, 0xCC, 0x88, 0xF6, 0xD0,
+		0x9A, 0xCC, 0x81, 0xF6, 0xD0, 0x98, 0xCC, 0x80,
+		0xF6, 0xD0, 0xA3, 0xCC, 0x86, 0xF6, 0xD0, 0x98,
+		0xCC, 0x86, 0xF6, 0xD0, 0xB8, 0xCC, 0x86, 0xF6,
+		0xD0, 0xB5, 0xCC, 0x80, 0xF6, 0xD0, 0xB5, 0xCC,
+		0x88, 0xF6, 0xD0, 0xB3, 0xCC, 0x81, 0xF6, 0xD1,
+		0x96, 0xCC, 0x88, 0xF6, 0xD0, 0xBA, 0xCC, 0x81,
+		0xF6, 0xD0, 0xB8, 0xCC, 0x80, 0xF6, 0xD1, 0x83,
+		0xCC, 0x86, 0xF6, 0xD1, 0xB4, 0xCC, 0x8F, 0xF6,
+		0xD1, 0xB5, 0xCC, 0x8F, 0xF6, 0xD0, 0x96, 0xCC,
+		0x86, 0xF6, 0xD0, 0xB6, 0xCC, 0x86, 0xF6, 0xD0,
+		0x90, 0xCC, 0x86, 0xF6, 0xD0, 0xB0, 0xCC, 0x86,
+		0xF6, 0xD0, 0x90, 0xCC, 0x88, 0xF6, 0xD0, 0xB0,
+		0xCC, 0x88, 0xF6, 0xD0, 0x95, 0xCC, 0x86, 0xF6,
+		0xD0, 0xB5, 0xCC, 0x86, 0xF6, 0xD3, 0x98, 0xCC,
+		0x88, 0xF6, 0xD3, 0x99, 0xCC, 0x88, 0xF6, 0xD0,
+		0x96, 0xCC, 0x88, 0xF6, 0xD0, 0xB6, 0xCC, 0x88,
+		0xF6, 0xD0, 0x97, 0xCC, 0x88, 0xF6, 0xD0, 0xB7,
+		0xCC, 0x88, 0xF6, 0xD0, 0x98, 0xCC, 0x84, 0xF6,
+		0xD0, 0xB8, 0xCC, 0x84, 0xF6, 0xD0, 0x98, 0xCC,
+		0x88, 0xF6, 0xD0, 0xB8, 0xCC, 0x88, 0xF6, 0xD0,
+		0x9E, 0xCC, 0x88, 0xF6, 0xD0, 0xBE, 0xCC, 0x88,
+		0xF6, 0xD3, 0xA8, 0xCC, 0x88, 0xF6, 0xD3, 0xA9,
+		0xCC, 0x88, 0xF6, 0xD0, 0xAD, 0xCC, 0x88, 0xF6,
+		0xD1, 0x8D, 0xCC, 0x88, 0xF6, 0xD0, 0xA3, 0xCC,
+		0x84, 0xF6, 0xD1, 0x83, 0xCC, 0x84, 0xF6, 0xD0,
+		0xA3, 0xCC, 0x88, 0xF6, 0xD1, 0x83, 0xCC, 0x88,
+		0xF6, 0xD0, 0xA3, 0xCC, 0x8B, 0xF6, 0xD1, 0x83,
+		0xCC, 0x8B, 0xF6, 0xD0, 0xA7, 0xCC, 0x88, 0xF6,
+		0xD1, 0x87, 0xCC, 0x88, 0xF6, 0xD0, 0xAB, 0xCC,
+		0x88, 0xF6, 0xD1, 0x8B, 0xCC, 0x88, 0xD5, 0xA5,
+		0xD6, 0x82, 0xF6, 0xD8, 0xA7, 0xD9, 0x93, 0xF6,
+		0xD8, 0xA7, 0xD9, 0x94, 0xF6, 0xD9, 0x88, 0xD9,
+		0x94, 0xF6, 0xD8, 0xA7, 0xD9, 0x95, 0xF6, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD8, 0xA7, 0xD9, 0xB4, 0xD9,
+		0x88, 0xD9, 0xB4, 0xDB, 0x87, 0xD9, 0xB4, 0xD9,
+		0x8A, 0xD9, 0xB4, 0xF6, 0xDB, 0x95, 0xD9, 0x94,
+		0xF6, 0xDB, 0x81, 0xD9, 0x94, 0xF6, 0xDB, 0x92,
+		0xD9, 0x94, 0xF6, 0xE0, 0xA4, 0xA8, 0xE0, 0xA4,
+		0xBC, 0xF6, 0xE0, 0xA4, 0xB0, 0xE0, 0xA4, 0xBC,
+		0xF6, 0xE0, 0xA4, 0xB3, 0xE0, 0xA4, 0xBC, 0xF6,
+		0xE0, 0xA4, 0x95, 0xE0, 0xA4, 0xBC, 0xF6, 0xE0,
+		0xA4, 0x96, 0xE0, 0xA4, 0xBC, 0xF6, 0xE0, 0xA4,
+		0x97, 0xE0, 0xA4, 0xBC, 0xF6, 0xE0, 0xA4, 0x9C,
+		0xE0, 0xA4, 0xBC, 0xF6, 0xE0, 0xA4, 0xA1, 0xE0,
+		0xA4, 0xBC, 0xF6, 0xE0, 0xA4, 0xA2, 0xE0, 0xA4,
+		0xBC, 0xF6, 0xE0, 0xA4, 0xAB, 0xE0, 0xA4, 0xBC,
+		0xF6, 0xE0, 0xA4, 0xAF, 0xE0, 0xA4, 0xBC, 0xF6,
+		0xE0, 0xA7, 0x87, 0xE0, 0xA6, 0xBE, 0xF6, 0xE0,
+		0xA7, 0x87, 0xE0, 0xA7, 0x97, 0xF6, 0xE0, 0xA6,
+		0xA1, 0xE0, 0xA6, 0xBC, 0xF6, 0xE0, 0xA6, 0xA2,
+		0xE0, 0xA6, 0xBC, 0xF6, 0xE0, 0xA6, 0xAF, 0xE0,
+		0xA6, 0xBC, 0xF6, 0xE0, 0xA8, 0xB2, 0xE0, 0xA8,
+		0xBC, 0xF6, 0xE0, 0xA8, 0xB8, 0xE0, 0xA8, 0xBC,
+		0xF6, 0xE0, 0xA8, 0x96, 0xE0, 0xA8, 0xBC, 0xF6,
+		0xE0, 0xA8, 0x97, 0xE0, 0xA8, 0xBC, 0xF6, 0xE0,
+		0xA8, 0x9C, 0xE0, 0xA8, 0xBC, 0xF6, 0xE0, 0xA8,
+		0xAB, 0xE0, 0xA8, 0xBC, 0xF6, 0xE0, 0xAD, 0x87,
+		0xE0, 0xAD, 0x96, 0xF6, 0xE0, 0xAD, 0x87, 0xE0,
+		0xAC, 0xBE, 0xF6, 0xE0, 0xAD, 0x87, 0xE0, 0xAD,
+		0x97, 0xF6, 0xE0, 0xAC, 0xA1, 0xE0, 0xAC, 0xBC,
+		0xF6, 0xE0, 0xAC, 0xA2, 0xE0, 0xAC, 0xBC, 0xF6,
+		0xE0, 0xAE, 0x92, 0xE0, 0xAF, 0x97, 0xF6, 0xE0,
+		0xAF, 0x86, 0xE0, 0xAE, 0xBE, 0xF6, 0xE0, 0xAF,
+		0x87, 0xE0, 0xAE, 0xBE, 0xF6, 0xE0, 0xAF, 0x86,
+		0xE0, 0xAF, 0x97, 0xF6, 0xE0, 0xB1, 0x86, 0xE0,
+		0xB1, 0x96, 0xF6, 0xE0, 0xB2, 0xBF, 0xE0, 0xB3,
+		0x95, 0xF6, 0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x95,
+		0xF6, 0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x96, 0xF6,
+		0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x82, 0xF6, 0xE0,
+		0xB3, 0x86, 0xE0, 0xB3, 0x82, 0xE0, 0xB3, 0x95,
+		0xF6, 0xE0, 0xB5, 0x86, 0xE0, 0xB4, 0xBE, 0xF6,
+		0xE0, 0xB5, 0x87, 0xE0, 0xB4, 0xBE, 0xF6, 0xE0,
+		0xB5, 0x86, 0xE0, 0xB5, 0x97, 0xF6, 0xE0, 0xB7,
+		0x99, 0xE0, 0xB7, 0x8A, 0xF6, 0xE0, 0xB7, 0x99,
+		0xE0, 0xB7, 0x8F, 0xF6, 0xE0, 0xB7, 0x99, 0xE0,
+		0xB7, 0x8F, 0xE0, 0xB7, 0x8A, 0xF6, 0xE0, 0xB7,
+		0x99, 0xE0, 0xB7, 0x9F, 0xE0, 0xB9, 0x8D, 0xE0,
+		0xB8, 0xB2, 0xE0, 0xBB, 0x8D, 0xE0, 0xBA, 0xB2,
+		0xE0, 0xBA, 0xAB, 0xE0, 0xBA, 0x99, 0xE0, 0xBA,
+		0xAB, 0xE0, 0xBA, 0xA1, 0xE0, 0xBC, 0x8B, 0xF6,
+		0xE0, 0xBD, 0x82, 0xE0, 0xBE, 0xB7, 0xF6, 0xE0,
+		0xBD, 0x8C, 0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBD,
+		0x91, 0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBD, 0x96,
+		0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBD, 0x9B, 0xE0,
+		0xBE, 0xB7, 0xF6, 0xE0, 0xBD, 0x80, 0xE0, 0xBE,
+		0xB5, 0xF6, 0xE0, 0xBD, 0xB1, 0xE0, 0xBD, 0xB2,
+		0xF6, 0xE0, 0xBD, 0xB1, 0xE0, 0xBD, 0xB4, 0xF6,
+		0xE0, 0xBE, 0xB2, 0xE0, 0xBE, 0x80, 0xE0, 0xBE,
+		0xB2, 0xE0, 0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0xF6,
+		0xE0, 0xBE, 0xB3, 0xE0, 0xBE, 0x80, 0xE0, 0xBE,
+		0xB3, 0xE0, 0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0xF6,
+		0xE0, 0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0xF6, 0xE0,
+		0xBE, 0x92, 0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBE,
+		0x9C, 0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBE, 0xA1,
+		0xE0, 0xBE, 0xB7, 0xF6, 0xE0, 0xBE, 0xA6, 0xE0,
+		0xBE, 0xB7, 0xF6, 0xE0, 0xBE, 0xAB, 0xE0, 0xBE,
+		0xB7, 0xF6, 0xE0, 0xBE, 0x90, 0xE0, 0xBE, 0xB5,
+		0xF6, 0xE1, 0x80, 0xA5, 0xE1, 0x80, 0xAE, 0xE1,
+		0x83, 0x9C, 0xF6, 0xE1, 0xAC, 0x85, 0xE1, 0xAC,
+		0xB5, 0xF6, 0xE1, 0xAC, 0x87, 0xE1, 0xAC, 0xB5,
+		0xF6, 0xE1, 0xAC, 0x89, 0xE1, 0xAC, 0xB5, 0xF6,
+		0xE1, 0xAC, 0x8B, 0xE1, 0xAC, 0xB5, 0xF6, 0xE1,
+		0xAC, 0x8D, 0xE1, 0xAC, 0xB5, 0xF6, 0xE1, 0xAC,
+		0x91, 0xE1, 0xAC, 0xB5, 0xF6, 0xE1, 0xAC, 0xBA,
+		0xE1, 0xAC, 0xB5, 0xF6, 0xE1, 0xAC, 0xBC, 0xE1,
+		0xAC, 0xB5, 0xF6, 0xE1, 0xAC, 0xBE, 0xE1, 0xAC,
+		0xB5, 0xF6, 0xE1, 0xAC, 0xBF, 0xE1, 0xAC, 0xB5,
+		0xF6, 0xE1, 0xAD, 0x82, 0xE1, 0xAC, 0xB5, 0x41,
+		0xC3, 0x86, 0x42, 0x44, 0x45, 0xC6, 0x8E, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0xC8, 0xA2, 0x50, 0x52, 0x54, 0x55, 0x57, 0x61,
+		0xC9, 0x90, 0xC9, 0x91, 0xE1, 0xB4, 0x82, 0x62,
+		0x64, 0x65, 0xC9, 0x99, 0xC9, 0x9B, 0xC9, 0x9C,
+		0x67, 0x6B, 0x6D, 0xC5, 0x8B, 0x6F, 0xC9, 0x94,
+		0xE1, 0xB4, 0x96, 0xE1, 0xB4, 0x97, 0x70, 0x74,
+		0x75, 0xE1, 0xB4, 0x9D, 0xC9, 0xAF, 0x76, 0xE1,
+		0xB4, 0xA5, 0xCE, 0xB2, 0xCE, 0xB3, 0xCE, 0xB4,
+		0xCF, 0x86, 0xCF, 0x87, 0x69, 0x72, 0x75, 0x76,
+		0xCE, 0xB2, 0xCE, 0xB3, 0xCF, 0x81, 0xCF, 0x86,
+		0xCF, 0x87, 0xD0, 0xBD, 0xC9, 0x92, 0x63, 0xC9,
+		0x95, 0xC3, 0xB0, 0xC9, 0x9C, 0x66, 0xC9, 0x9F,
+		0xC9, 0xA1, 0xC9, 0xA5, 0xC9, 0xA8, 0xC9, 0xA9,
+		0xC9, 0xAA, 0xE1, 0xB5, 0xBB, 0xCA, 0x9D, 0xC9,
+		0xAD, 0xE1, 0xB6, 0x85, 0xCA, 0x9F, 0xC9, 0xB1,
+		0xC9, 0xB0, 0xC9, 0xB2, 0xC9, 0xB3, 0xC9, 0xB4,
+		0xC9, 0xB5, 0xC9, 0xB8, 0xCA, 0x82, 0xCA, 0x83,
+		0xC6, 0xAB, 0xCA, 0x89, 0xCA, 0x8A, 0xE1, 0xB4,
+		0x9C, 0xCA, 0x8B, 0xCA, 0x8C, 0x7A, 0xCA, 0x90,
+		0xCA, 0x91, 0xCA, 0x92, 0xCE, 0xB8, 0xF6, 0x41,
+		0xCC, 0xA5, 0xF6, 0x61, 0xCC, 0xA5, 0xF6, 0x42,
+		0xCC, 0x87, 0xF6, 0x62, 0xCC, 0x87, 0xF6, 0x42,
+		0xCC, 0xA3, 0xF6, 0x62, 0xCC, 0xA3, 0xF6, 0x42,
+		0xCC, 0xB1, 0xF6, 0x62, 0xCC, 0xB1, 0xF6, 0x43,
+		0xCC, 0xA7, 0xCC, 0x81, 0xF6, 0x63, 0xCC, 0xA7,
+		0xCC, 0x81, 0xF6, 0x44, 0xCC, 0x87, 0xF6, 0x64,
+		0xCC, 0x87, 0xF6, 0x44, 0xCC, 0xA3, 0xF6, 0x64,
+		0xCC, 0xA3, 0xF6, 0x44, 0xCC, 0xB1, 0xF6, 0x64,
+		0xCC, 0xB1, 0xF6, 0x44, 0xCC, 0xA7, 0xF6, 0x64,
+		0xCC, 0xA7, 0xF6, 0x44, 0xCC, 0xAD, 0xF6, 0x64,
+		0xCC, 0xAD, 0xF6, 0x45, 0xCC, 0x84, 0xCC, 0x80,
+		0xF6, 0x65, 0xCC, 0x84, 0xCC, 0x80, 0xF6, 0x45,
+		0xCC, 0x84, 0xCC, 0x81, 0xF6, 0x65, 0xCC, 0x84,
+		0xCC, 0x81, 0xF6, 0x45, 0xCC, 0xAD, 0xF6, 0x65,
+		0xCC, 0xAD, 0xF6, 0x45, 0xCC, 0xB0, 0xF6, 0x65,
+		0xCC, 0xB0, 0xF6, 0x45, 0xCC, 0xA7, 0xCC, 0x86,
+		0xF6, 0x65, 0xCC, 0xA7, 0xCC, 0x86, 0xF6, 0x46,
+		0xCC, 0x87, 0xF6, 0x66, 0xCC, 0x87, 0xF6, 0x47,
+		0xCC, 0x84, 0xF6, 0x67, 0xCC, 0x84, 0xF6, 0x48,
+		0xCC, 0x87, 0xF6, 0x68, 0xCC, 0x87, 0xF6, 0x48,
+		0xCC, 0xA3, 0xF6, 0x68, 0xCC, 0xA3, 0xF6, 0x48,
+		0xCC, 0x88, 0xF6, 0x68, 0xCC, 0x88, 0xF6, 0x48,
+		0xCC, 0xA7, 0xF6, 0x68, 0xCC, 0xA7, 0xF6, 0x48,
+		0xCC, 0xAE, 0xF6, 0x68, 0xCC, 0xAE, 0xF6, 0x49,
+		0xCC, 0xB0, 0xF6, 0x69, 0xCC, 0xB0, 0xF6, 0x49,
+		0xCC, 0x88, 0xCC, 0x81, 0xF6, 0x69, 0xCC, 0x88,
+		0xCC, 0x81, 0xF6, 0x4B, 0xCC, 0x81, 0xF6, 0x6B,
+		0xCC, 0x81, 0xF6, 0x4B, 0xCC, 0xA3, 0xF6, 0x6B,
+		0xCC, 0xA3, 0xF6, 0x4B, 0xCC, 0xB1, 0xF6, 0x6B,
+		0xCC, 0xB1, 0xF6, 0x4C, 0xCC, 0xA3, 0xF6, 0x6C,
+		0xCC, 0xA3, 0xF6, 0x4C, 0xCC, 0xA3, 0xCC, 0x84,
+		0xF6, 0x6C, 0xCC, 0xA3, 0xCC, 0x84, 0xF6, 0x4C,
+		0xCC, 0xB1, 0xF6, 0x6C, 0xCC, 0xB1, 0xF6, 0x4C,
+		0xCC, 0xAD, 0xF6, 0x6C, 0xCC, 0xAD, 0xF6, 0x4D,
+		0xCC, 0x81, 0xF6, 0x6D, 0xCC, 0x81, 0xF6, 0x4D,
+		0xCC, 0x87, 0xF6, 0x6D, 0xCC, 0x87, 0xF6, 0x4D,
+		0xCC, 0xA3, 0xF6, 0x6D, 0xCC, 0xA3, 0xF6, 0x4E,
+		0xCC, 0x87, 0xF6, 0x6E, 0xCC, 0x87, 0xF6, 0x4E,
+		0xCC, 0xA3, 0xF6, 0x6E, 0xCC, 0xA3, 0xF6, 0x4E,
+		0xCC, 0xB1, 0xF6, 0x6E, 0xCC, 0xB1, 0xF6, 0x4E,
+		0xCC, 0xAD, 0xF6, 0x6E, 0xCC, 0xAD, 0xF6, 0x4F,
+		0xCC, 0x83, 0xCC, 0x81, 0xF6, 0x6F, 0xCC, 0x83,
+		0xCC, 0x81, 0xF6, 0x4F, 0xCC, 0x83, 0xCC, 0x88,
+		0xF6, 0x6F, 0xCC, 0x83, 0xCC, 0x88, 0xF6, 0x4F,
+		0xCC, 0x84, 0xCC, 0x80, 0xF6, 0x6F, 0xCC, 0x84,
+		0xCC, 0x80, 0xF6, 0x4F, 0xCC, 0x84, 0xCC, 0x81,
+		0xF6, 0x6F, 0xCC, 0x84, 0xCC, 0x81, 0xF6, 0x50,
+		0xCC, 0x81, 0xF6, 0x70, 0xCC, 0x81, 0xF6, 0x50,
+		0xCC, 0x87, 0xF6, 0x70, 0xCC, 0x87, 0xF6, 0x52,
+		0xCC, 0x87, 0xF6, 0x72, 0xCC, 0x87, 0xF6, 0x52,
+		0xCC, 0xA3, 0xF6, 0x72, 0xCC, 0xA3, 0xF6, 0x52,
+		0xCC, 0xA3, 0xCC, 0x84, 0xF6, 0x72, 0xCC, 0xA3,
+		0xCC, 0x84, 0xF6, 0x52, 0xCC, 0xB1, 0xF6, 0x72,
+		0xCC, 0xB1, 0xF6, 0x53, 0xCC, 0x87, 0xF6, 0x73,
+		0xCC, 0x87, 0xF6, 0x53, 0xCC, 0xA3, 0xF6, 0x73,
+		0xCC, 0xA3, 0xF6, 0x53, 0xCC, 0x81, 0xCC, 0x87,
+		0xF6, 0x73, 0xCC, 0x81, 0xCC, 0x87, 0xF6, 0x53,
+		0xCC, 0x8C, 0xCC, 0x87, 0xF6, 0x73, 0xCC, 0x8C,
+		0xCC, 0x87, 0xF6, 0x53, 0xCC, 0xA3, 0xCC, 0x87,
+		0xF6, 0x73, 0xCC, 0xA3, 0xCC, 0x87, 0xF6, 0x54,
+		0xCC, 0x87, 0xF6, 0x74, 0xCC, 0x87, 0xF6, 0x54,
+		0xCC, 0xA3, 0xF6, 0x74, 0xCC, 0xA3, 0xF6, 0x54,
+		0xCC, 0xB1, 0xF6, 0x74, 0xCC, 0xB1, 0xF6, 0x54,
+		0xCC, 0xAD, 0xF6, 0x74, 0xCC, 0xAD, 0xF6, 0x55,
+		0xCC, 0xA4, 0xF6, 0x75, 0xCC, 0xA4, 0xF6, 0x55,
+		0xCC, 0xB0, 0xF6, 0x75, 0xCC, 0xB0, 0xF6, 0x55,
+		0xCC, 0xAD, 0xF6, 0x75, 0xCC, 0xAD, 0xF6, 0x55,
+		0xCC, 0x83, 0xCC, 0x81, 0xF6, 0x75, 0xCC, 0x83,
+		0xCC, 0x81, 0xF6, 0x55, 0xCC, 0x84, 0xCC, 0x88,
+		0xF6, 0x75, 0xCC, 0x84, 0xCC, 0x88, 0xF6, 0x56,
+		0xCC, 0x83, 0xF6, 0x76, 0xCC, 0x83, 0xF6, 0x56,
+		0xCC, 0xA3, 0xF6, 0x76, 0xCC, 0xA3, 0xF6, 0x57,
+		0xCC, 0x80, 0xF6, 0x77, 0xCC, 0x80, 0xF6, 0x57,
+		0xCC, 0x81, 0xF6, 0x77, 0xCC, 0x81, 0xF6, 0x57,
+		0xCC, 0x88, 0xF6, 0x77, 0xCC, 0x88, 0xF6, 0x57,
+		0xCC, 0x87, 0xF6, 0x77, 0xCC, 0x87, 0xF6, 0x57,
+		0xCC, 0xA3, 0xF6, 0x77, 0xCC, 0xA3, 0xF6, 0x58,
+		0xCC, 0x87, 0xF6, 0x78, 0xCC, 0x87, 0xF6, 0x58,
+		0xCC, 0x88, 0xF6, 0x78, 0xCC, 0x88, 0xF6, 0x59,
+		0xCC, 0x87, 0xF6, 0x79, 0xCC, 0x87, 0xF6, 0x5A,
+		0xCC, 0x82, 0xF6, 0x7A, 0xCC, 0x82, 0xF6, 0x5A,
+		0xCC, 0xA3, 0xF6, 0x7A, 0xCC, 0xA3, 0xF6, 0x5A,
+		0xCC, 0xB1, 0xF6, 0x7A, 0xCC, 0xB1, 0xF6, 0x68,
+		0xCC, 0xB1, 0xF6, 0x74, 0xCC, 0x88, 0xF6, 0x77,
+		0xCC, 0x8A, 0xF6, 0x79, 0xCC, 0x8A, 0x61, 0xCA,
+		0xBE, 0xF5, 0x05, 0xC5, 0xBF, 0xCC, 0x87, 0x73,
+		0xCC, 0x87, 0xF6, 0x41, 0xCC, 0xA3, 0xF6, 0x61,
+		0xCC, 0xA3, 0xF6, 0x41, 0xCC, 0x89, 0xF6, 0x61,
+		0xCC, 0x89, 0xF6, 0x41, 0xCC, 0x82, 0xCC, 0x81,
+		0xF6, 0x61, 0xCC, 0x82, 0xCC, 0x81, 0xF6, 0x41,
+		0xCC, 0x82, 0xCC, 0x80, 0xF6, 0x61, 0xCC, 0x82,
+		0xCC, 0x80, 0xF6, 0x41, 0xCC, 0x82, 0xCC, 0x89,
+		0xF6, 0x61, 0xCC, 0x82, 0xCC, 0x89, 0xF6, 0x41,
+		0xCC, 0x82, 0xCC, 0x83, 0xF6, 0x61, 0xCC, 0x82,
+		0xCC, 0x83, 0xF6, 0x41, 0xCC, 0xA3, 0xCC, 0x82,
+		0xF6, 0x61, 0xCC, 0xA3, 0xCC, 0x82, 0xF6, 0x41,
+		0xCC, 0x86, 0xCC, 0x81, 0xF6, 0x61, 0xCC, 0x86,
+		0xCC, 0x81, 0xF6, 0x41, 0xCC, 0x86, 0xCC, 0x80,
+		0xF6, 0x61, 0xCC, 0x86, 0xCC, 0x80, 0xF6, 0x41,
+		0xCC, 0x86, 0xCC, 0x89, 0xF6, 0x61, 0xCC, 0x86,
+		0xCC, 0x89, 0xF6, 0x41, 0xCC, 0x86, 0xCC, 0x83,
+		0xF6, 0x61, 0xCC, 0x86, 0xCC, 0x83, 0xF6, 0x41,
+		0xCC, 0xA3, 0xCC, 0x86, 0xF6, 0x61, 0xCC, 0xA3,
+		0xCC, 0x86, 0xF6, 0x45, 0xCC, 0xA3, 0xF6, 0x65,
+		0xCC, 0xA3, 0xF6, 0x45, 0xCC, 0x89, 0xF6, 0x65,
+		0xCC, 0x89, 0xF6, 0x45, 0xCC, 0x83, 0xF6, 0x65,
+		0xCC, 0x83, 0xF6, 0x45, 0xCC, 0x82, 0xCC, 0x81,
+		0xF6, 0x65, 0xCC, 0x82, 0xCC, 0x81, 0xF6, 0x45,
+		0xCC, 0x82, 0xCC, 0x80, 0xF6, 0x65, 0xCC, 0x82,
+		0xCC, 0x80, 0xF6, 0x45, 0xCC, 0x82, 0xCC, 0x89,
+		0xF6, 0x65, 0xCC, 0x82, 0xCC, 0x89, 0xF6, 0x45,
+		0xCC, 0x82, 0xCC, 0x83, 0xF6, 0x65, 0xCC, 0x82,
+		0xCC, 0x83, 0xF6, 0x45, 0xCC, 0xA3, 0xCC, 0x82,
+		0xF6, 0x65, 0xCC, 0xA3, 0xCC, 0x82, 0xF6, 0x49,
+		0xCC, 0x89, 0xF6, 0x69, 0xCC, 0x89, 0xF6, 0x49,
+		0xCC, 0xA3, 0xF6, 0x69, 0xCC, 0xA3, 0xF6, 0x4F,
+		0xCC, 0xA3, 0xF6, 0x6F, 0xCC, 0xA3, 0xF6, 0x4F,
+		0xCC, 0x89, 0xF6, 0x6F, 0xCC, 0x89, 0xF6, 0x4F,
+		0xCC, 0x82, 0xCC, 0x81, 0xF6, 0x6F, 0xCC, 0x82,
+		0xCC, 0x81, 0xF6, 0x4F, 0xCC, 0x82, 0xCC, 0x80,
+		0xF6, 0x6F, 0xCC, 0x82, 0xCC, 0x80, 0xF6, 0x4F,
+		0xCC, 0x82, 0xCC, 0x89, 0xF6, 0x6F, 0xCC, 0x82,
+		0xCC, 0x89, 0xF6, 0x4F, 0xCC, 0x82, 0xCC, 0x83,
+		0xF6, 0x6F, 0xCC, 0x82, 0xCC, 0x83, 0xF6, 0x4F,
+		0xCC, 0xA3, 0xCC, 0x82, 0xF6, 0x6F, 0xCC, 0xA3,
+		0xCC, 0x82, 0xF6, 0x4F, 0xCC, 0x9B, 0xCC, 0x81,
+		0xF6, 0x6F, 0xCC, 0x9B, 0xCC, 0x81, 0xF6, 0x4F,
+		0xCC, 0x9B, 0xCC, 0x80, 0xF6, 0x6F, 0xCC, 0x9B,
+		0xCC, 0x80, 0xF6, 0x4F, 0xCC, 0x9B, 0xCC, 0x89,
+		0xF6, 0x6F, 0xCC, 0x9B, 0xCC, 0x89, 0xF6, 0x4F,
+		0xCC, 0x9B, 0xCC, 0x83, 0xF6, 0x6F, 0xCC, 0x9B,
+		0xCC, 0x83, 0xF6, 0x4F, 0xCC, 0x9B, 0xCC, 0xA3,
+		0xF6, 0x6F, 0xCC, 0x9B, 0xCC, 0xA3, 0xF6, 0x55,
+		0xCC, 0xA3, 0xF6, 0x75, 0xCC, 0xA3, 0xF6, 0x55,
+		0xCC, 0x89, 0xF6, 0x75, 0xCC, 0x89, 0xF6, 0x55,
+		0xCC, 0x9B, 0xCC, 0x81, 0xF6, 0x75, 0xCC, 0x9B,
+		0xCC, 0x81, 0xF6, 0x55, 0xCC, 0x9B, 0xCC, 0x80,
+		0xF6, 0x75, 0xCC, 0x9B, 0xCC, 0x80, 0xF6, 0x55,
+		0xCC, 0x9B, 0xCC, 0x89, 0xF6, 0x75, 0xCC, 0x9B,
+		0xCC, 0x89, 0xF6, 0x55, 0xCC, 0x9B, 0xCC, 0x83,
+		0xF6, 0x75, 0xCC, 0x9B, 0xCC, 0x83, 0xF6, 0x55,
+		0xCC, 0x9B, 0xCC, 0xA3, 0xF6, 0x75, 0xCC, 0x9B,
+		0xCC, 0xA3, 0xF6, 0x59, 0xCC, 0x80, 0xF6, 0x79,
+		0xCC, 0x80, 0xF6, 0x59, 0xCC, 0xA3, 0xF6, 0x79,
+		0xCC, 0xA3, 0xF6, 0x59, 0xCC, 0x89, 0xF6, 0x79,
+		0xCC, 0x89, 0xF6, 0x59, 0xCC, 0x83, 0xF6, 0x79,
+		0xCC, 0x83, 0xF6, 0xCE, 0xB1, 0xCC, 0x93, 0xF6,
+		0xCE, 0xB1, 0xCC, 0x94, 0xF6, 0xCE, 0xB1, 0xCC,
+		0x93, 0xCC, 0x80, 0xF6, 0xCE, 0xB1, 0xCC, 0x94,
+		0xCC, 0x80, 0xF6, 0xCE, 0xB1, 0xCC, 0x93, 0xCC,
+		0x81, 0xF6, 0xCE, 0xB1, 0xCC, 0x94, 0xCC, 0x81,
+		0xF6, 0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xF6,
+		0xCE, 0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE,
+		0x91, 0xCC, 0x93, 0xF6, 0xCE, 0x91, 0xCC, 0x94,
+		0xF6, 0xCE, 0x91, 0xCC, 0x93, 0xCC, 0x80, 0xF6,
+		0xCE, 0x91, 0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE,
+		0x91, 0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE, 0x91,
+		0xCC, 0x94, 0xCC, 0x81, 0xF6, 0xCE, 0x91, 0xCC,
+		0x93, 0xCD, 0x82, 0xF6, 0xCE, 0x91, 0xCC, 0x94,
+		0xCD, 0x82, 0xF6, 0xCE, 0xB5, 0xCC, 0x93, 0xF6,
+		0xCE, 0xB5, 0xCC, 0x94, 0xF6, 0xCE, 0xB5, 0xCC,
+		0x93, 0xCC, 0x80, 0xF6, 0xCE, 0xB5, 0xCC, 0x94,
+		0xCC, 0x80, 0xF6, 0xCE, 0xB5, 0xCC, 0x93, 0xCC,
+		0x81, 0xF6, 0xCE, 0xB5, 0xCC, 0x94, 0xCC, 0x81,
+		0xF6, 0xCE, 0x95, 0xCC, 0x93, 0xF6, 0xCE, 0x95,
+		0xCC, 0x94, 0xF6, 0xCE, 0x95, 0xCC, 0x93, 0xCC,
+		0x80, 0xF6, 0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x80,
+		0xF6, 0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x81, 0xF6,
+		0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x81, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x93, 0xF6, 0xCE, 0xB7, 0xCC, 0x94,
+		0xF6, 0xCE, 0xB7, 0xCC, 0x93, 0xCC, 0x80, 0xF6,
+		0xCE, 0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE, 0xB7,
+		0xCC, 0x94, 0xCC, 0x81, 0xF6, 0xCE, 0xB7, 0xCC,
+		0x93, 0xCD, 0x82, 0xF6, 0xCE, 0xB7, 0xCC, 0x94,
+		0xCD, 0x82, 0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xF6,
+		0xCE, 0x97, 0xCC, 0x94, 0xF6, 0xCE, 0x97, 0xCC,
+		0x93, 0xCC, 0x80, 0xF6, 0xCE, 0x97, 0xCC, 0x94,
+		0xCC, 0x80, 0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xCC,
+		0x81, 0xF6, 0xCE, 0x97, 0xCC, 0x94, 0xCC, 0x81,
+		0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x82, 0xF6,
+		0xCE, 0x97, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE,
+		0xB9, 0xCC, 0x93, 0xF6, 0xCE, 0xB9, 0xCC, 0x94,
+		0xF6, 0xCE, 0xB9, 0xCC, 0x93, 0xCC, 0x80, 0xF6,
+		0xCE, 0xB9, 0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE,
+		0xB9, 0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE, 0xB9,
+		0xCC, 0x94, 0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCC,
+		0x93, 0xCD, 0x82, 0xF6, 0xCE, 0xB9, 0xCC, 0x94,
+		0xCD, 0x82, 0xF6, 0xCE, 0x99, 0xCC, 0x93, 0xF6,
+		0xCE, 0x99, 0xCC, 0x94, 0xF6, 0xCE, 0x99, 0xCC,
+		0x93, 0xCC, 0x80, 0xF6, 0xCE, 0x99, 0xCC, 0x94,
+		0xCC, 0x80, 0xF6, 0xCE, 0x99, 0xCC, 0x93, 0xCC,
+		0x81, 0xF6, 0xCE, 0x99, 0xCC, 0x94, 0xCC, 0x81,
+		0xF6, 0xCE, 0x99, 0xCC, 0x93, 0xCD, 0x82, 0xF6,
+		0xCE, 0x99, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE,
+		0xBF, 0xCC, 0x93, 0xF6, 0xCE, 0xBF, 0xCC, 0x94,
+		0xF6, 0xCE, 0xBF, 0xCC, 0x93, 0xCC, 0x80, 0xF6,
+		0xCE, 0xBF, 0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE,
+		0xBF, 0xCC, 0x93, 0xCC, 0x81, 0xF6, 0xCE, 0xBF,
+		0xCC, 0x94, 0xCC, 0x81, 0xF6, 0xCE, 0x9F, 0xCC,
+		0x93, 0xF6, 0xCE, 0x9F, 0xCC, 0x94, 0xF6, 0xCE,
+		0x9F, 0xCC, 0x93, 0xCC, 0x80, 0xF6, 0xCE, 0x9F,
+		0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE, 0x9F, 0xCC,
+		0x93, 0xCC, 0x81, 0xF6, 0xCE, 0x9F, 0xCC, 0x94,
+		0xCC, 0x81, 0xF6, 0xCF, 0x85, 0xCC, 0x93, 0xF6,
+		0xCF, 0x85, 0xCC, 0x94, 0xF6, 0xCF, 0x85, 0xCC,
+		0x93, 0xCC, 0x80, 0xF6, 0xCF, 0x85, 0xCC, 0x94,
+		0xCC, 0x80, 0xF6, 0xCF, 0x85, 0xCC, 0x93, 0xCC,
+		0x81, 0xF6, 0xCF, 0x85, 0xCC, 0x94, 0xCC, 0x81,
+		0xF6, 0xCF, 0x85, 0xCC, 0x93, 0xCD, 0x82, 0xF6,
+		0xCF, 0x85, 0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE,
+		0xA5, 0xCC, 0x94, 0xF6, 0xCE, 0xA5, 0xCC, 0x94,
+		0xCC, 0x80, 0xF6, 0xCE, 0xA5, 0xCC, 0x94, 0xCC,
+		0x81, 0xF6, 0xCE, 0xA5, 0xCC, 0x94, 0xCD, 0x82,
+		0xF6, 0xCF, 0x89, 0xCC, 0x93, 0xF6, 0xCF, 0x89,
+		0xCC, 0x94, 0xF6, 0xCF, 0x89, 0xCC, 0x93, 0xCC,
+		0x80, 0xF6, 0xCF, 0x89, 0xCC, 0x94, 0xCC, 0x80,
+		0xF6, 0xCF, 0x89, 0xCC, 0x93, 0xCC, 0x81, 0xF6,
+		0xCF, 0x89, 0xCC, 0x94, 0xCC, 0x81, 0xF6, 0xCF,
+		0x89, 0xCC, 0x93, 0xCD, 0x82, 0xF6, 0xCF, 0x89,
+		0xCC, 0x94, 0xCD, 0x82, 0xF6, 0xCE, 0xA9, 0xCC,
+		0x93, 0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xF6, 0xCE,
+		0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xF6, 0xCE, 0xA9,
+		0xCC, 0x94, 0xCC, 0x80, 0xF6, 0xCE, 0xA9, 0xCC,
+		0x93, 0xCC, 0x81, 0xF6, 0xCE, 0xA9, 0xCC, 0x94,
+		0xCC, 0x81, 0xF6, 0xCE, 0xA9, 0xCC, 0x93, 0xCD,
+		0x82, 0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xCD, 0x82,
+		0xF6, 0xCE, 0xB1, 0xCC, 0x80, 0xF6, 0xCE, 0xB1,
+		0xCC, 0x81, 0xF6, 0xCE, 0xB5, 0xCC, 0x80, 0xF6,
+		0xCE, 0xB5, 0xCC, 0x81, 0xF6, 0xCE, 0xB7, 0xCC,
+		0x80, 0xF6, 0xCE, 0xB7, 0xCC, 0x81, 0xF6, 0xCE,
+		0xB9, 0xCC, 0x80, 0xF6, 0xCE, 0xB9, 0xCC, 0x81,
+		0xF6, 0xCE, 0xBF, 0xCC, 0x80, 0xF6, 0xCE, 0xBF,
+		0xCC, 0x81, 0xF6, 0xCF, 0x85, 0xCC, 0x80, 0xF6,
+		0xCF, 0x85, 0xCC, 0x81, 0xF6, 0xCF, 0x89, 0xCC,
+		0x80, 0xF6, 0xCF, 0x89, 0xCC, 0x81, 0xF6, 0xCE,
+		0xB1, 0xCC, 0x93, 0xCD, 0x85, 0xF6, 0xCE, 0xB1,
+		0xCC, 0x94, 0xCD, 0x85, 0xF6, 0xCE, 0xB1, 0xCC,
+		0x93, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE, 0xB1,
+		0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE,
+		0xB1, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF6,
+		0xCE, 0xB1, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85,
+		0xF6, 0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+		0x85, 0xF6, 0xCE, 0xB1, 0xCC, 0x94, 0xCD, 0x82,
+		0xCD, 0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x93, 0xCD,
+		0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x94, 0xCD, 0x85,
+		0xF6, 0xCE, 0x91, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+		0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x94, 0xCC, 0x80,
+		0xCD, 0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x93, 0xCC,
+		0x81, 0xCD, 0x85, 0xF6, 0xCE, 0x91, 0xCC, 0x94,
+		0xCC, 0x81, 0xCD, 0x85, 0xF6, 0xCE, 0x91, 0xCC,
+		0x93, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0x91,
+		0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x93, 0xCD, 0x85, 0xF6, 0xCE, 0xB7,
+		0xCC, 0x94, 0xCD, 0x85, 0xF6, 0xCE, 0xB7, 0xCC,
+		0x93, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE, 0xB7,
+		0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE,
+		0xB7, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF6,
+		0xCE, 0xB7, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85,
+		0xF6, 0xCE, 0xB7, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+		0x85, 0xF6, 0xCE, 0xB7, 0xCC, 0x94, 0xCD, 0x82,
+		0xCD, 0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xCD,
+		0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x94, 0xCD, 0x85,
+		0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+		0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x94, 0xCC, 0x80,
+		0xCD, 0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x93, 0xCC,
+		0x81, 0xCD, 0x85, 0xF6, 0xCE, 0x97, 0xCC, 0x94,
+		0xCC, 0x81, 0xCD, 0x85, 0xF6, 0xCE, 0x97, 0xCC,
+		0x93, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0x97,
+		0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCF,
+		0x89, 0xCC, 0x93, 0xCD, 0x85, 0xF6, 0xCF, 0x89,
+		0xCC, 0x94, 0xCD, 0x85, 0xF6, 0xCF, 0x89, 0xCC,
+		0x93, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCF, 0x89,
+		0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCF,
+		0x89, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF6,
+		0xCF, 0x89, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85,
+		0xF6, 0xCF, 0x89, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+		0x85, 0xF6, 0xCF, 0x89, 0xCC, 0x94, 0xCD, 0x82,
+		0xCD, 0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x93, 0xCD,
+		0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xCD, 0x85,
+		0xF6, 0xCE, 0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+		0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x94, 0xCC, 0x80,
+		0xCD, 0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x93, 0xCC,
+		0x81, 0xCD, 0x85, 0xF6, 0xCE, 0xA9, 0xCC, 0x94,
+		0xCC, 0x81, 0xCD, 0x85, 0xF6, 0xCE, 0xA9, 0xCC,
+		0x93, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0xA9,
+		0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE,
+		0xB1, 0xCC, 0x86, 0xF6, 0xCE, 0xB1, 0xCC, 0x84,
+		0xF6, 0xCE, 0xB1, 0xCC, 0x80, 0xCD, 0x85, 0xF6,
+		0xCE, 0xB1, 0xCD, 0x85, 0xF6, 0xCE, 0xB1, 0xCC,
+		0x81, 0xCD, 0x85, 0xF6, 0xCE, 0xB1, 0xCD, 0x82,
+		0xF6, 0xCE, 0xB1, 0xCD, 0x82, 0xCD, 0x85, 0xF6,
+		0xCE, 0x91, 0xCC, 0x86, 0xF6, 0xCE, 0x91, 0xCC,
+		0x84, 0xF6, 0xCE, 0x91, 0xCC, 0x80, 0xF6, 0xCE,
+		0x91, 0xCC, 0x81, 0xF6, 0xCE, 0x91, 0xCD, 0x85,
+		0x20, 0xCC, 0x93, 0xF6, 0xCE, 0xB9, 0x20, 0xCC,
+		0x93, 0x20, 0xCD, 0x82, 0xF5, 0x05, 0xC2, 0xA8,
+		0xCD, 0x82, 0x20, 0xCC, 0x88, 0xCD, 0x82, 0xF6,
+		0xCE, 0xB7, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCE,
+		0xB7, 0xCD, 0x85, 0xF6, 0xCE, 0xB7, 0xCC, 0x81,
+		0xCD, 0x85, 0xF6, 0xCE, 0xB7, 0xCD, 0x82, 0xF6,
+		0xCE, 0xB7, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE,
+		0x95, 0xCC, 0x80, 0xF6, 0xCE, 0x95, 0xCC, 0x81,
+		0xF6, 0xCE, 0x97, 0xCC, 0x80, 0xF6, 0xCE, 0x97,
+		0xCC, 0x81, 0xF6, 0xCE, 0x97, 0xCD, 0x85, 0xF5,
+		0x06, 0xE1, 0xBE, 0xBF, 0xCC, 0x80, 0x20, 0xCC,
+		0x93, 0xCC, 0x80, 0xF5, 0x06, 0xE1, 0xBE, 0xBF,
+		0xCC, 0x81, 0x20, 0xCC, 0x93, 0xCC, 0x81, 0xF5,
+		0x06, 0xE1, 0xBE, 0xBF, 0xCD, 0x82, 0x20, 0xCC,
+		0x93, 0xCD, 0x82, 0xF6, 0xCE, 0xB9, 0xCC, 0x86,
+		0xF6, 0xCE, 0xB9, 0xCC, 0x84, 0xF6, 0xCE, 0xB9,
+		0xCC, 0x88, 0xCC, 0x80, 0xF6, 0xCE, 0xB9, 0xCC,
+		0x88, 0xCC, 0x81, 0xF6, 0xCE, 0xB9, 0xCD, 0x82,
+		0xF6, 0xCE, 0xB9, 0xCC, 0x88, 0xCD, 0x82, 0xF6,
+		0xCE, 0x99, 0xCC, 0x86, 0xF6, 0xCE, 0x99, 0xCC,
+		0x84, 0xF6, 0xCE, 0x99, 0xCC, 0x80, 0xF6, 0xCE,
+		0x99, 0xCC, 0x81, 0xF5, 0x06, 0xE1, 0xBF, 0xBE,
+		0xCC, 0x80, 0x20, 0xCC, 0x94, 0xCC, 0x80, 0xF5,
+		0x06, 0xE1, 0xBF, 0xBE, 0xCC, 0x81, 0x20, 0xCC,
+		0x94, 0xCC, 0x81, 0xF5, 0x06, 0xE1, 0xBF, 0xBE,
+		0xCD, 0x82, 0x20, 0xCC, 0x94, 0xCD, 0x82, 0xF6,
+		0xCF, 0x85, 0xCC, 0x86, 0xF6, 0xCF, 0x85, 0xCC,
+		0x84, 0xF6, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x80,
+		0xF6, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xF6,
+		0xCF, 0x81, 0xCC, 0x93, 0xF6, 0xCF, 0x81, 0xCC,
+		0x94, 0xF6, 0xCF, 0x85, 0xCD, 0x82, 0xF6, 0xCF,
+		0x85, 0xCC, 0x88, 0xCD, 0x82, 0xF6, 0xCE, 0xA5,
+		0xCC, 0x86, 0xF6, 0xCE, 0xA5, 0xCC, 0x84, 0xF6,
+		0xCE, 0xA5, 0xCC, 0x80, 0xF6, 0xCE, 0xA5, 0xCC,
+		0x81, 0xF6, 0xCE, 0xA1, 0xCC, 0x94, 0xF5, 0x05,
+		0xC2, 0xA8, 0xCC, 0x80, 0x20, 0xCC, 0x88, 0xCC,
+		0x80, 0xF5, 0x05, 0xC2, 0xA8, 0xCC, 0x81, 0x20,
+		0xCC, 0x88, 0xCC, 0x81, 0xF6, 0x60, 0xF6, 0xCF,
+		0x89, 0xCC, 0x80, 0xCD, 0x85, 0xF6, 0xCF, 0x89,
+		0xCD, 0x85, 0xF6, 0xCF, 0x89, 0xCC, 0x81, 0xCD,
+		0x85, 0xF6, 0xCF, 0x89, 0xCD, 0x82, 0xF6, 0xCF,
+		0x89, 0xCD, 0x82, 0xCD, 0x85, 0xF6, 0xCE, 0x9F,
+		0xCC, 0x80, 0xF6, 0xCE, 0x9F, 0xCC, 0x81, 0xF6,
+		0xCE, 0xA9, 0xCC, 0x80, 0xF6, 0xCE, 0xA9, 0xCC,
+		0x81, 0xF6, 0xCE, 0xA9, 0xCD, 0x85, 0xF5, 0x03,
+		0xC2, 0xB4, 0x20, 0xCC, 0x81, 0x20, 0xCC, 0x94,
+		0xF5, 0x04, 0xE2, 0x80, 0x82, 0x20, 0xF5, 0x04,
+		0xE2, 0x80, 0x83, 0x20, 0x20, 0x20, 0x20, 0x20,
+		0x20, 0x20, 0x20, 0x20, 0x20, 0xE2, 0x80, 0x90,
+		0x20, 0xCC, 0xB3, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
+		0x2E, 0x20, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+		0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80,
+		0xB2, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0xE2,
+		0x80, 0xB5, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5,
+		0x21, 0x21, 0x20, 0xCC, 0x85, 0x3F, 0x3F, 0x3F,
+		0x21, 0x21, 0x3F, 0xE2, 0x80, 0xB2, 0xE2, 0x80,
+		0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2, 0x20,
+		0x30, 0x69, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+		0x2B, 0xE2, 0x88, 0x92, 0x3D, 0x28, 0x29, 0x6E,
+		0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+		0x38, 0x39, 0x2B, 0xE2, 0x88, 0x92, 0x3D, 0x28,
+		0x29, 0x61, 0x65, 0x6F, 0x78, 0xC9, 0x99, 0x52,
+		0x73, 0x61, 0x2F, 0x63, 0x61, 0x2F, 0x73, 0x43,
+		0xC2, 0xB0, 0x43, 0x63, 0x2F, 0x6F, 0x63, 0x2F,
+		0x75, 0xC6, 0x90, 0xC2, 0xB0, 0x46, 0x67, 0x48,
+		0x48, 0x48, 0x68, 0xC4, 0xA7, 0x49, 0x49, 0x4C,
+		0x6C, 0x4E, 0x4E, 0x6F, 0x50, 0x51, 0x52, 0x52,
+		0x52, 0x53, 0x4D, 0x54, 0x45, 0x4C, 0x54, 0x4D,
+		0x5A, 0xF6, 0xCE, 0xA9, 0x5A, 0xF6, 0x4B, 0xF6,
+		0x41, 0xCC, 0x8A, 0x42, 0x43, 0x65, 0x45, 0x46,
+		0x4D, 0x6F, 0xD7, 0x90, 0xD7, 0x91, 0xD7, 0x92,
+		0xD7, 0x93, 0x69, 0x46, 0x41, 0x58, 0xCF, 0x80,
+		0xCE, 0xB3, 0xCE, 0x93, 0xCE, 0xA0, 0xE2, 0x88,
+		0x91, 0x44, 0x64, 0x65, 0x69, 0x6A, 0x31, 0xE2,
+		0x81, 0x84, 0x33, 0x32, 0xE2, 0x81, 0x84, 0x33,
+		0x31, 0xE2, 0x81, 0x84, 0x35, 0x32, 0xE2, 0x81,
+		0x84, 0x35, 0x33, 0xE2, 0x81, 0x84, 0x35, 0x34,
+		0xE2, 0x81, 0x84, 0x35, 0x31, 0xE2, 0x81, 0x84,
+		0x36, 0x35, 0xE2, 0x81, 0x84, 0x36, 0x31, 0xE2,
+		0x81, 0x84, 0x38, 0x33, 0xE2, 0x81, 0x84, 0x38,
+		0x35, 0xE2, 0x81, 0x84, 0x38, 0x37, 0xE2, 0x81,
+		0x84, 0x38, 0x31, 0xE2, 0x81, 0x84, 0x49, 0x49,
+		0x49, 0x49, 0x49, 0x49, 0x49, 0x56, 0x56, 0x56,
+		0x49, 0x56, 0x49, 0x49, 0x56, 0x49, 0x49, 0x49,
+		0x49, 0x58, 0x58, 0x58, 0x49, 0x58, 0x49, 0x49,
+		0x4C, 0x43, 0x44, 0x4D, 0x69, 0x69, 0x69, 0x69,
+		0x69, 0x69, 0x69, 0x76, 0x76, 0x76, 0x69, 0x76,
+		0x69, 0x69, 0x76, 0x69, 0x69, 0x69, 0x69, 0x78,
+		0x78, 0x78, 0x69, 0x78, 0x69, 0x69, 0x6C, 0x63,
+		0x64, 0x6D, 0xF6, 0xE2, 0x86, 0x90, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x86, 0x92, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x86, 0x94, 0xCC, 0xB8, 0xF6, 0xE2, 0x87, 0x90,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x87, 0x94, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x87, 0x92, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x88, 0x83, 0xCC, 0xB8, 0xF6, 0xE2, 0x88, 0x88,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x88, 0x8B, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x88, 0xA3, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x88, 0xA5, 0xCC, 0xB8, 0xE2, 0x88, 0xAB, 0xE2,
+		0x88, 0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB,
+		0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAE, 0xE2, 0x88,
+		0xAE, 0xE2, 0x88, 0xAE, 0xE2, 0x88, 0xAE, 0xE2,
+		0x88, 0xAE, 0xF6, 0xE2, 0x88, 0xBC, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x89, 0x83, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x89, 0x85, 0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0x88,
+		0xCC, 0xB8, 0xF6, 0x3D, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x89, 0xA1, 0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0x8D,
+		0xCC, 0xB8, 0xF6, 0x3C, 0xCC, 0xB8, 0xF6, 0x3E,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xA4, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x89, 0xA5, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x89, 0xB2, 0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xB3,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xB6, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x89, 0xB7, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x89, 0xBA, 0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xBB,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0x82, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x8A, 0x83, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x8A, 0x86, 0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0x87,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0xA2, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x8A, 0xA8, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x8A, 0xA9, 0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0xAB,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x89, 0xBC, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x89, 0xBD, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x8A, 0x91, 0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0x92,
+		0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0xB2, 0xCC, 0xB8,
+		0xF6, 0xE2, 0x8A, 0xB3, 0xCC, 0xB8, 0xF6, 0xE2,
+		0x8A, 0xB4, 0xCC, 0xB8, 0xF6, 0xE2, 0x8A, 0xB5,
+		0xCC, 0xB8, 0xF6, 0xE3, 0x80, 0x88, 0xF6, 0xE3,
+		0x80, 0x89, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+		0x37, 0x38, 0x39, 0x31, 0x30, 0x31, 0x31, 0x31,
+		0x32, 0x31, 0x33, 0x31, 0x34, 0x31, 0x35, 0x31,
+		0x36, 0x31, 0x37, 0x31, 0x38, 0x31, 0x39, 0x32,
+		0x30, 0x28, 0x31, 0x29, 0x28, 0x32, 0x29, 0x28,
+		0x33, 0x29, 0x28, 0x34, 0x29, 0x28, 0x35, 0x29,
+		0x28, 0x36, 0x29, 0x28, 0x37, 0x29, 0x28, 0x38,
+		0x29, 0x28, 0x39, 0x29, 0x28, 0x31, 0x30, 0x29,
+		0x28, 0x31, 0x31, 0x29, 0x28, 0x31, 0x32, 0x29,
+		0x28, 0x31, 0x33, 0x29, 0x28, 0x31, 0x34, 0x29,
+		0x28, 0x31, 0x35, 0x29, 0x28, 0x31, 0x36, 0x29,
+		0x28, 0x31, 0x37, 0x29, 0x28, 0x31, 0x38, 0x29,
+		0x28, 0x31, 0x39, 0x29, 0x28, 0x32, 0x30, 0x29,
+		0x31, 0x2E, 0x32, 0x2E, 0x33, 0x2E, 0x34, 0x2E,
+		0x35, 0x2E, 0x36, 0x2E, 0x37, 0x2E, 0x38, 0x2E,
+		0x39, 0x2E, 0x31, 0x30, 0x2E, 0x31, 0x31, 0x2E,
+		0x31, 0x32, 0x2E, 0x31, 0x33, 0x2E, 0x31, 0x34,
+		0x2E, 0x31, 0x35, 0x2E, 0x31, 0x36, 0x2E, 0x31,
+		0x37, 0x2E, 0x31, 0x38, 0x2E, 0x31, 0x39, 0x2E,
+		0x32, 0x30, 0x2E, 0x28, 0x61, 0x29, 0x28, 0x62,
+		0x29, 0x28, 0x63, 0x29, 0x28, 0x64, 0x29, 0x28,
+		0x65, 0x29, 0x28, 0x66, 0x29, 0x28, 0x67, 0x29,
+		0x28, 0x68, 0x29, 0x28, 0x69, 0x29, 0x28, 0x6A,
+		0x29, 0x28, 0x6B, 0x29, 0x28, 0x6C, 0x29, 0x28,
+		0x6D, 0x29, 0x28, 0x6E, 0x29, 0x28, 0x6F, 0x29,
+		0x28, 0x70, 0x29, 0x28, 0x71, 0x29, 0x28, 0x72,
+		0x29, 0x28, 0x73, 0x29, 0x28, 0x74, 0x29, 0x28,
+		0x75, 0x29, 0x28, 0x76, 0x29, 0x28, 0x77, 0x29,
+		0x28, 0x78, 0x29, 0x28, 0x79, 0x29, 0x28, 0x7A,
+		0x29, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x30, 0xE2, 0x88,
+		0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0xE2,
+		0x88, 0xAB, 0x3A, 0x3A, 0x3D, 0x3D, 0x3D, 0x3D,
+		0x3D, 0x3D, 0xF6, 0xE2, 0xAB, 0x9D, 0xCC, 0xB8,
+		0xE2, 0xB5, 0xA1, 0xE6, 0xAF, 0x8D, 0xE9, 0xBE,
+		0x9F, 0xE4, 0xB8, 0x80, 0xE4, 0xB8, 0xA8, 0xE4,
+		0xB8, 0xB6, 0xE4, 0xB8, 0xBF, 0xE4, 0xB9, 0x99,
+		0xE4, 0xBA, 0x85, 0xE4, 0xBA, 0x8C, 0xE4, 0xBA,
+		0xA0, 0xE4, 0xBA, 0xBA, 0xE5, 0x84, 0xBF, 0xE5,
+		0x85, 0xA5, 0xE5, 0x85, 0xAB, 0xE5, 0x86, 0x82,
+		0xE5, 0x86, 0x96, 0xE5, 0x86, 0xAB, 0xE5, 0x87,
+		0xA0, 0xE5, 0x87, 0xB5, 0xE5, 0x88, 0x80, 0xE5,
+		0x8A, 0x9B, 0xE5, 0x8B, 0xB9, 0xE5, 0x8C, 0x95,
+		0xE5, 0x8C, 0x9A, 0xE5, 0x8C, 0xB8, 0xE5, 0x8D,
+		0x81, 0xE5, 0x8D, 0x9C, 0xE5, 0x8D, 0xA9, 0xE5,
+		0x8E, 0x82, 0xE5, 0x8E, 0xB6, 0xE5, 0x8F, 0x88,
+		0xE5, 0x8F, 0xA3, 0xE5, 0x9B, 0x97, 0xE5, 0x9C,
+		0x9F, 0xE5, 0xA3, 0xAB, 0xE5, 0xA4, 0x82, 0xE5,
+		0xA4, 0x8A, 0xE5, 0xA4, 0x95, 0xE5, 0xA4, 0xA7,
+		0xE5, 0xA5, 0xB3, 0xE5, 0xAD, 0x90, 0xE5, 0xAE,
+		0x80, 0xE5, 0xAF, 0xB8, 0xE5, 0xB0, 0x8F, 0xE5,
+		0xB0, 0xA2, 0xE5, 0xB0, 0xB8, 0xE5, 0xB1, 0xAE,
+		0xE5, 0xB1, 0xB1, 0xE5, 0xB7, 0x9B, 0xE5, 0xB7,
+		0xA5, 0xE5, 0xB7, 0xB1, 0xE5, 0xB7, 0xBE, 0xE5,
+		0xB9, 0xB2, 0xE5, 0xB9, 0xBA, 0xE5, 0xB9, 0xBF,
+		0xE5, 0xBB, 0xB4, 0xE5, 0xBB, 0xBE, 0xE5, 0xBC,
+		0x8B, 0xE5, 0xBC, 0x93, 0xE5, 0xBD, 0x90, 0xE5,
+		0xBD, 0xA1, 0xE5, 0xBD, 0xB3, 0xE5, 0xBF, 0x83,
+		0xE6, 0x88, 0x88, 0xE6, 0x88, 0xB6, 0xE6, 0x89,
+		0x8B, 0xE6, 0x94, 0xAF, 0xE6, 0x94, 0xB4, 0xE6,
+		0x96, 0x87, 0xE6, 0x96, 0x97, 0xE6, 0x96, 0xA4,
+		0xE6, 0x96, 0xB9, 0xE6, 0x97, 0xA0, 0xE6, 0x97,
+		0xA5, 0xE6, 0x9B, 0xB0, 0xE6, 0x9C, 0x88, 0xE6,
+		0x9C, 0xA8, 0xE6, 0xAC, 0xA0, 0xE6, 0xAD, 0xA2,
+		0xE6, 0xAD, 0xB9, 0xE6, 0xAE, 0xB3, 0xE6, 0xAF,
+		0x8B, 0xE6, 0xAF, 0x94, 0xE6, 0xAF, 0x9B, 0xE6,
+		0xB0, 0x8F, 0xE6, 0xB0, 0x94, 0xE6, 0xB0, 0xB4,
+		0xE7, 0x81, 0xAB, 0xE7, 0x88, 0xAA, 0xE7, 0x88,
+		0xB6, 0xE7, 0x88, 0xBB, 0xE7, 0x88, 0xBF, 0xE7,
+		0x89, 0x87, 0xE7, 0x89, 0x99, 0xE7, 0x89, 0x9B,
+		0xE7, 0x8A, 0xAC, 0xE7, 0x8E, 0x84, 0xE7, 0x8E,
+		0x89, 0xE7, 0x93, 0x9C, 0xE7, 0x93, 0xA6, 0xE7,
+		0x94, 0x98, 0xE7, 0x94, 0x9F, 0xE7, 0x94, 0xA8,
+		0xE7, 0x94, 0xB0, 0xE7, 0x96, 0x8B, 0xE7, 0x96,
+		0x92, 0xE7, 0x99, 0xB6, 0xE7, 0x99, 0xBD, 0xE7,
+		0x9A, 0xAE, 0xE7, 0x9A, 0xBF, 0xE7, 0x9B, 0xAE,
+		0xE7, 0x9F, 0x9B, 0xE7, 0x9F, 0xA2, 0xE7, 0x9F,
+		0xB3, 0xE7, 0xA4, 0xBA, 0xE7, 0xA6, 0xB8, 0xE7,
+		0xA6, 0xBE, 0xE7, 0xA9, 0xB4, 0xE7, 0xAB, 0x8B,
+		0xE7, 0xAB, 0xB9, 0xE7, 0xB1, 0xB3, 0xE7, 0xB3,
+		0xB8, 0xE7, 0xBC, 0xB6, 0xE7, 0xBD, 0x91, 0xE7,
+		0xBE, 0x8A, 0xE7, 0xBE, 0xBD, 0xE8, 0x80, 0x81,
+		0xE8, 0x80, 0x8C, 0xE8, 0x80, 0x92, 0xE8, 0x80,
+		0xB3, 0xE8, 0x81, 0xBF, 0xE8, 0x82, 0x89, 0xE8,
+		0x87, 0xA3, 0xE8, 0x87, 0xAA, 0xE8, 0x87, 0xB3,
+		0xE8, 0x87, 0xBC, 0xE8, 0x88, 0x8C, 0xE8, 0x88,
+		0x9B, 0xE8, 0x88, 0x9F, 0xE8, 0x89, 0xAE, 0xE8,
+		0x89, 0xB2, 0xE8, 0x89, 0xB8, 0xE8, 0x99, 0x8D,
+		0xE8, 0x99, 0xAB, 0xE8, 0xA1, 0x80, 0xE8, 0xA1,
+		0x8C, 0xE8, 0xA1, 0xA3, 0xE8, 0xA5, 0xBE, 0xE8,
+		0xA6, 0x8B, 0xE8, 0xA7, 0x92, 0xE8, 0xA8, 0x80,
+		0xE8, 0xB0, 0xB7, 0xE8, 0xB1, 0x86, 0xE8, 0xB1,
+		0x95, 0xE8, 0xB1, 0xB8, 0xE8, 0xB2, 0x9D, 0xE8,
+		0xB5, 0xA4, 0xE8, 0xB5, 0xB0, 0xE8, 0xB6, 0xB3,
+		0xE8, 0xBA, 0xAB, 0xE8, 0xBB, 0x8A, 0xE8, 0xBE,
+		0x9B, 0xE8, 0xBE, 0xB0, 0xE8, 0xBE, 0xB5, 0xE9,
+		0x82, 0x91, 0xE9, 0x85, 0x89, 0xE9, 0x87, 0x86,
+		0xE9, 0x87, 0x8C, 0xE9, 0x87, 0x91, 0xE9, 0x95,
+		0xB7, 0xE9, 0x96, 0x80, 0xE9, 0x98, 0x9C, 0xE9,
+		0x9A, 0xB6, 0xE9, 0x9A, 0xB9, 0xE9, 0x9B, 0xA8,
+		0xE9, 0x9D, 0x91, 0xE9, 0x9D, 0x9E, 0xE9, 0x9D,
+		0xA2, 0xE9, 0x9D, 0xA9, 0xE9, 0x9F, 0x8B, 0xE9,
+		0x9F, 0xAD, 0xE9, 0x9F, 0xB3, 0xE9, 0xA0, 0x81,
+		0xE9, 0xA2, 0xA8, 0xE9, 0xA3, 0x9B, 0xE9, 0xA3,
+		0x9F, 0xE9, 0xA6, 0x96, 0xE9, 0xA6, 0x99, 0xE9,
+		0xA6, 0xAC, 0xE9, 0xAA, 0xA8, 0xE9, 0xAB, 0x98,
+		0xE9, 0xAB, 0x9F, 0xE9, 0xAC, 0xA5, 0xE9, 0xAC,
+		0xAF, 0xE9, 0xAC, 0xB2, 0xE9, 0xAC, 0xBC, 0xE9,
+		0xAD, 0x9A, 0xE9, 0xB3, 0xA5, 0xE9, 0xB9, 0xB5,
+		0xE9, 0xB9, 0xBF, 0xE9, 0xBA, 0xA5, 0xE9, 0xBA,
+		0xBB, 0xE9, 0xBB, 0x83, 0xE9, 0xBB, 0x8D, 0xE9,
+		0xBB, 0x91, 0xE9, 0xBB, 0xB9, 0xE9, 0xBB, 0xBD,
+		0xE9, 0xBC, 0x8E, 0xE9, 0xBC, 0x93, 0xE9, 0xBC,
+		0xA0, 0xE9, 0xBC, 0xBB, 0xE9, 0xBD, 0x8A, 0xE9,
+		0xBD, 0x92, 0xE9, 0xBE, 0x8D, 0xE9, 0xBE, 0x9C,
+		0xE9, 0xBE, 0xA0, 0x20, 0xE3, 0x80, 0x92, 0xE5,
+		0x8D, 0x81, 0xE5, 0x8D, 0x84, 0xE5, 0x8D, 0x85,
+		0xF6, 0xE3, 0x81, 0x8B, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x81, 0x8D, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x81, 0x8F, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81,
+		0x91, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0x93,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0x95, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x81, 0x97, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x81, 0x99, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x81, 0x9B, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x81, 0x9D, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x81, 0x9F, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81,
+		0xA1, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0xA4,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0xA6, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x81, 0xA8, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x9A, 0xF6,
+		0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x81, 0xB2, 0xE3, 0x82, 0x9A, 0xF6, 0xE3, 0x81,
+		0xB5, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x81, 0xB5,
+		0xE3, 0x82, 0x9A, 0xF6, 0xE3, 0x81, 0xB8, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x81, 0xB8, 0xE3, 0x82,
+		0x9A, 0xF6, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x9A, 0xF6,
+		0xE3, 0x81, 0x86, 0xE3, 0x82, 0x99, 0x20, 0xE3,
+		0x82, 0x99, 0x20, 0xE3, 0x82, 0x9A, 0xF6, 0xE3,
+		0x82, 0x9D, 0xE3, 0x82, 0x99, 0xE3, 0x82, 0x88,
+		0xE3, 0x82, 0x8A, 0xF6, 0xE3, 0x82, 0xAB, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x82, 0xAD, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x82, 0xB1, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x82, 0xB3, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x82, 0xB5, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x82,
+		0xB7, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x82, 0xB9,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x82, 0xBB, 0xE3,
+		0x82, 0x99, 0xF6, 0xE3, 0x82, 0xBD, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x83, 0x81, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x83, 0x84, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x83, 0x86, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83,
+		0x88, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83, 0x8F,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83, 0x8F, 0xE3,
+		0x82, 0x9A, 0xF6, 0xE3, 0x83, 0x92, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A,
+		0xF6, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x83, 0x95, 0xE3, 0x82, 0x9A, 0xF6, 0xE3,
+		0x83, 0x98, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83,
+		0x98, 0xE3, 0x82, 0x9A, 0xF6, 0xE3, 0x83, 0x9B,
+		0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83, 0x9B, 0xE3,
+		0x82, 0x9A, 0xF6, 0xE3, 0x82, 0xA6, 0xE3, 0x82,
+		0x99, 0xF6, 0xE3, 0x83, 0xAF, 0xE3, 0x82, 0x99,
+		0xF6, 0xE3, 0x83, 0xB0, 0xE3, 0x82, 0x99, 0xF6,
+		0xE3, 0x83, 0xB1, 0xE3, 0x82, 0x99, 0xF6, 0xE3,
+		0x83, 0xB2, 0xE3, 0x82, 0x99, 0xF6, 0xE3, 0x83,
+		0xBD, 0xE3, 0x82, 0x99, 0xE3, 0x82, 0xB3, 0xE3,
+		0x83, 0x88, 0xE1, 0x84, 0x80, 0xE1, 0x84, 0x81,
+		0xE1, 0x86, 0xAA, 0xE1, 0x84, 0x82, 0xE1, 0x86,
+		0xAC, 0xE1, 0x86, 0xAD, 0xE1, 0x84, 0x83, 0xE1,
+		0x84, 0x84, 0xE1, 0x84, 0x85, 0xE1, 0x86, 0xB0,
+		0xE1, 0x86, 0xB1, 0xE1, 0x86, 0xB2, 0xE1, 0x86,
+		0xB3, 0xE1, 0x86, 0xB4, 0xE1, 0x86, 0xB5, 0xE1,
+		0x84, 0x9A, 0xE1, 0x84, 0x86, 0xE1, 0x84, 0x87,
+		0xE1, 0x84, 0x88, 0xE1, 0x84, 0xA1, 0xE1, 0x84,
+		0x89, 0xE1, 0x84, 0x8A, 0xE1, 0x84, 0x8B, 0xE1,
+		0x84, 0x8C, 0xE1, 0x84, 0x8D, 0xE1, 0x84, 0x8E,
+		0xE1, 0x84, 0x8F, 0xE1, 0x84, 0x90, 0xE1, 0x84,
+		0x91, 0xE1, 0x84, 0x92, 0xE1, 0x85, 0xA1, 0xE1,
+		0x85, 0xA2, 0xE1, 0x85, 0xA3, 0xE1, 0x85, 0xA4,
+		0xE1, 0x85, 0xA5, 0xE1, 0x85, 0xA6, 0xE1, 0x85,
+		0xA7, 0xE1, 0x85, 0xA8, 0xE1, 0x85, 0xA9, 0xE1,
+		0x85, 0xAA, 0xE1, 0x85, 0xAB, 0xE1, 0x85, 0xAC,
+		0xE1, 0x85, 0xAD, 0xE1, 0x85, 0xAE, 0xE1, 0x85,
+		0xAF, 0xE1, 0x85, 0xB0, 0xE1, 0x85, 0xB1, 0xE1,
+		0x85, 0xB2, 0xE1, 0x85, 0xB3, 0xE1, 0x85, 0xB4,
+		0xE1, 0x85, 0xB5, 0xE1, 0x85, 0xA0, 0xE1, 0x84,
+		0x94, 0xE1, 0x84, 0x95, 0xE1, 0x87, 0x87, 0xE1,
+		0x87, 0x88, 0xE1, 0x87, 0x8C, 0xE1, 0x87, 0x8E,
+		0xE1, 0x87, 0x93, 0xE1, 0x87, 0x97, 0xE1, 0x87,
+		0x99, 0xE1, 0x84, 0x9C, 0xE1, 0x87, 0x9D, 0xE1,
+		0x87, 0x9F, 0xE1, 0x84, 0x9D, 0xE1, 0x84, 0x9E,
+		0xE1, 0x84, 0xA0, 0xE1, 0x84, 0xA2, 0xE1, 0x84,
+		0xA3, 0xE1, 0x84, 0xA7, 0xE1, 0x84, 0xA9, 0xE1,
+		0x84, 0xAB, 0xE1, 0x84, 0xAC, 0xE1, 0x84, 0xAD,
+		0xE1, 0x84, 0xAE, 0xE1, 0x84, 0xAF, 0xE1, 0x84,
+		0xB2, 0xE1, 0x84, 0xB6, 0xE1, 0x85, 0x80, 0xE1,
+		0x85, 0x87, 0xE1, 0x85, 0x8C, 0xE1, 0x87, 0xB1,
+		0xE1, 0x87, 0xB2, 0xE1, 0x85, 0x97, 0xE1, 0x85,
+		0x98, 0xE1, 0x85, 0x99, 0xE1, 0x86, 0x84, 0xE1,
+		0x86, 0x85, 0xE1, 0x86, 0x88, 0xE1, 0x86, 0x91,
+		0xE1, 0x86, 0x92, 0xE1, 0x86, 0x94, 0xE1, 0x86,
+		0x9E, 0xE1, 0x86, 0xA1, 0xE4, 0xB8, 0x80, 0xE4,
+		0xBA, 0x8C, 0xE4, 0xB8, 0x89, 0xE5, 0x9B, 0x9B,
+		0xE4, 0xB8, 0x8A, 0xE4, 0xB8, 0xAD, 0xE4, 0xB8,
+		0x8B, 0xE7, 0x94, 0xB2, 0xE4, 0xB9, 0x99, 0xE4,
+		0xB8, 0x99, 0xE4, 0xB8, 0x81, 0xE5, 0xA4, 0xA9,
+		0xE5, 0x9C, 0xB0, 0xE4, 0xBA, 0xBA, 0x28, 0xE1,
+		0x84, 0x80, 0x29, 0x28, 0xE1, 0x84, 0x82, 0x29,
+		0x28, 0xE1, 0x84, 0x83, 0x29, 0x28, 0xE1, 0x84,
+		0x85, 0x29, 0x28, 0xE1, 0x84, 0x86, 0x29, 0x28,
+		0xE1, 0x84, 0x87, 0x29, 0x28, 0xE1, 0x84, 0x89,
+		0x29, 0x28, 0xE1, 0x84, 0x8B, 0x29, 0x28, 0xE1,
+		0x84, 0x8C, 0x29, 0x28, 0xE1, 0x84, 0x8E, 0x29,
+		0x28, 0xE1, 0x84, 0x8F, 0x29, 0x28, 0xE1, 0x84,
+		0x90, 0x29, 0x28, 0xE1, 0x84, 0x91, 0x29, 0x28,
+		0xE1, 0x84, 0x92, 0x29, 0x28, 0xE1, 0x84, 0x80,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x82,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x83,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x85,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x86,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x87,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x89,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x8B,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x8C,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x8E,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x8F,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x90,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x91,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x92,
+		0xE1, 0x85, 0xA1, 0x29, 0x28, 0xE1, 0x84, 0x8C,
+		0xE1, 0x85, 0xAE, 0x29, 0x28, 0xE1, 0x84, 0x8B,
+		0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x8C, 0xE1, 0x85,
+		0xA5, 0xE1, 0x86, 0xAB, 0x29, 0x28, 0xE1, 0x84,
+		0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x92, 0xE1,
+		0x85, 0xAE, 0x29, 0x28, 0xE4, 0xB8, 0x80, 0x29,
+		0x28, 0xE4, 0xBA, 0x8C, 0x29, 0x28, 0xE4, 0xB8,
+		0x89, 0x29, 0x28, 0xE5, 0x9B, 0x9B, 0x29, 0x28,
+		0xE4, 0xBA, 0x94, 0x29, 0x28, 0xE5, 0x85, 0xAD,
+		0x29, 0x28, 0xE4, 0xB8, 0x83, 0x29, 0x28, 0xE5,
+		0x85, 0xAB, 0x29, 0x28, 0xE4, 0xB9, 0x9D, 0x29,
+		0x28, 0xE5, 0x8D, 0x81, 0x29, 0x28, 0xE6, 0x9C,
+		0x88, 0x29, 0x28, 0xE7, 0x81, 0xAB, 0x29, 0x28,
+		0xE6, 0xB0, 0xB4, 0x29, 0x28, 0xE6, 0x9C, 0xA8,
+		0x29, 0x28, 0xE9, 0x87, 0x91, 0x29, 0x28, 0xE5,
+		0x9C, 0x9F, 0x29, 0x28, 0xE6, 0x97, 0xA5, 0x29,
+		0x28, 0xE6, 0xA0, 0xAA, 0x29, 0x28, 0xE6, 0x9C,
+		0x89, 0x29, 0x28, 0xE7, 0xA4, 0xBE, 0x29, 0x28,
+		0xE5, 0x90, 0x8D, 0x29, 0x28, 0xE7, 0x89, 0xB9,
+		0x29, 0x28, 0xE8, 0xB2, 0xA1, 0x29, 0x28, 0xE7,
+		0xA5, 0x9D, 0x29, 0x28, 0xE5, 0x8A, 0xB4, 0x29,
+		0x28, 0xE4, 0xBB, 0xA3, 0x29, 0x28, 0xE5, 0x91,
+		0xBC, 0x29, 0x28, 0xE5, 0xAD, 0xA6, 0x29, 0x28,
+		0xE7, 0x9B, 0xA3, 0x29, 0x28, 0xE4, 0xBC, 0x81,
+		0x29, 0x28, 0xE8, 0xB3, 0x87, 0x29, 0x28, 0xE5,
+		0x8D, 0x94, 0x29, 0x28, 0xE7, 0xA5, 0xAD, 0x29,
+		0x28, 0xE4, 0xBC, 0x91, 0x29, 0x28, 0xE8, 0x87,
+		0xAA, 0x29, 0x28, 0xE8, 0x87, 0xB3, 0x29, 0x50,
+		0x54, 0x45, 0x32, 0x31, 0x32, 0x32, 0x32, 0x33,
+		0x32, 0x34, 0x32, 0x35, 0x32, 0x36, 0x32, 0x37,
+		0x32, 0x38, 0x32, 0x39, 0x33, 0x30, 0x33, 0x31,
+		0x33, 0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x35,
+		0xE1, 0x84, 0x80, 0xE1, 0x84, 0x82, 0xE1, 0x84,
+		0x83, 0xE1, 0x84, 0x85, 0xE1, 0x84, 0x86, 0xE1,
+		0x84, 0x87, 0xE1, 0x84, 0x89, 0xE1, 0x84, 0x8B,
+		0xE1, 0x84, 0x8C, 0xE1, 0x84, 0x8E, 0xE1, 0x84,
+		0x8F, 0xE1, 0x84, 0x90, 0xE1, 0x84, 0x91, 0xE1,
+		0x84, 0x92, 0xE1, 0x84, 0x80, 0xE1, 0x85, 0xA1,
+		0xE1, 0x84, 0x82, 0xE1, 0x85, 0xA1, 0xE1, 0x84,
+		0x83, 0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x85, 0xE1,
+		0x85, 0xA1, 0xE1, 0x84, 0x86, 0xE1, 0x85, 0xA1,
+		0xE1, 0x84, 0x87, 0xE1, 0x85, 0xA1, 0xE1, 0x84,
+		0x89, 0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x8B, 0xE1,
+		0x85, 0xA1, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xA1,
+		0xE1, 0x84, 0x8E, 0xE1, 0x85, 0xA1, 0xE1, 0x84,
+		0x8F, 0xE1, 0x85, 0xA1, 0xE1, 0x84, 0x90, 0xE1,
+		0x85, 0xA1, 0xE1, 0x84, 0x91, 0xE1, 0x85, 0xA1,
+		0xE1, 0x84, 0x92, 0xE1, 0x85, 0xA1, 0xE1, 0x84,
+		0x8E, 0xE1, 0x85, 0xA1, 0xE1, 0x86, 0xB7, 0xE1,
+		0x84, 0x80, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x8C,
+		0xE1, 0x85, 0xAE, 0xE1, 0x84, 0x8B, 0xE1, 0x85,
+		0xB4, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xAE, 0xE4,
+		0xB8, 0x80, 0xE4, 0xBA, 0x8C, 0xE4, 0xB8, 0x89,
+		0xE5, 0x9B, 0x9B, 0xE4, 0xBA, 0x94, 0xE5, 0x85,
+		0xAD, 0xE4, 0xB8, 0x83, 0xE5, 0x85, 0xAB, 0xE4,
+		0xB9, 0x9D, 0xE5, 0x8D, 0x81, 0xE6, 0x9C, 0x88,
+		0xE7, 0x81, 0xAB, 0xE6, 0xB0, 0xB4, 0xE6, 0x9C,
+		0xA8, 0xE9, 0x87, 0x91, 0xE5, 0x9C, 0x9F, 0xE6,
+		0x97, 0xA5, 0xE6, 0xA0, 0xAA, 0xE6, 0x9C, 0x89,
+		0xE7, 0xA4, 0xBE, 0xE5, 0x90, 0x8D, 0xE7, 0x89,
+		0xB9, 0xE8, 0xB2, 0xA1, 0xE7, 0xA5, 0x9D, 0xE5,
+		0x8A, 0xB4, 0xE7, 0xA7, 0x98, 0xE7, 0x94, 0xB7,
+		0xE5, 0xA5, 0xB3, 0xE9, 0x81, 0xA9, 0xE5, 0x84,
+		0xAA, 0xE5, 0x8D, 0xB0, 0xE6, 0xB3, 0xA8, 0xE9,
+		0xA0, 0x85, 0xE4, 0xBC, 0x91, 0xE5, 0x86, 0x99,
+		0xE6, 0xAD, 0xA3, 0xE4, 0xB8, 0x8A, 0xE4, 0xB8,
+		0xAD, 0xE4, 0xB8, 0x8B, 0xE5, 0xB7, 0xA6, 0xE5,
+		0x8F, 0xB3, 0xE5, 0x8C, 0xBB, 0xE5, 0xAE, 0x97,
+		0xE5, 0xAD, 0xA6, 0xE7, 0x9B, 0xA3, 0xE4, 0xBC,
+		0x81, 0xE8, 0xB3, 0x87, 0xE5, 0x8D, 0x94, 0xE5,
+		0xA4, 0x9C, 0x33, 0x36, 0x33, 0x37, 0x33, 0x38,
+		0x33, 0x39, 0x34, 0x30, 0x34, 0x31, 0x34, 0x32,
+		0x34, 0x33, 0x34, 0x34, 0x34, 0x35, 0x34, 0x36,
+		0x34, 0x37, 0x34, 0x38, 0x34, 0x39, 0x35, 0x30,
+		0x31, 0xE6, 0x9C, 0x88, 0x32, 0xE6, 0x9C, 0x88,
+		0x33, 0xE6, 0x9C, 0x88, 0x34, 0xE6, 0x9C, 0x88,
+		0x35, 0xE6, 0x9C, 0x88, 0x36, 0xE6, 0x9C, 0x88,
+		0x37, 0xE6, 0x9C, 0x88, 0x38, 0xE6, 0x9C, 0x88,
+		0x39, 0xE6, 0x9C, 0x88, 0x31, 0x30, 0xE6, 0x9C,
+		0x88, 0x31, 0x31, 0xE6, 0x9C, 0x88, 0x31, 0x32,
+		0xE6, 0x9C, 0x88, 0x48, 0x67, 0x65, 0x72, 0x67,
+		0x65, 0x56, 0x4C, 0x54, 0x44, 0xE3, 0x82, 0xA2,
+		0xE3, 0x82, 0xA4, 0xE3, 0x82, 0xA6, 0xE3, 0x82,
+		0xA8, 0xE3, 0x82, 0xAA, 0xE3, 0x82, 0xAB, 0xE3,
+		0x82, 0xAD, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0xB1,
+		0xE3, 0x82, 0xB3, 0xE3, 0x82, 0xB5, 0xE3, 0x82,
+		0xB7, 0xE3, 0x82, 0xB9, 0xE3, 0x82, 0xBB, 0xE3,
+		0x82, 0xBD, 0xE3, 0x82, 0xBF, 0xE3, 0x83, 0x81,
+		0xE3, 0x83, 0x84, 0xE3, 0x83, 0x86, 0xE3, 0x83,
+		0x88, 0xE3, 0x83, 0x8A, 0xE3, 0x83, 0x8B, 0xE3,
+		0x83, 0x8C, 0xE3, 0x83, 0x8D, 0xE3, 0x83, 0x8E,
+		0xE3, 0x83, 0x8F, 0xE3, 0x83, 0x92, 0xE3, 0x83,
+		0x95, 0xE3, 0x83, 0x98, 0xE3, 0x83, 0x9B, 0xE3,
+		0x83, 0x9E, 0xE3, 0x83, 0x9F, 0xE3, 0x83, 0xA0,
+		0xE3, 0x83, 0xA1, 0xE3, 0x83, 0xA2, 0xE3, 0x83,
+		0xA4, 0xE3, 0x83, 0xA6, 0xE3, 0x83, 0xA8, 0xE3,
+		0x83, 0xA9, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xAB,
+		0xE3, 0x83, 0xAC, 0xE3, 0x83, 0xAD, 0xE3, 0x83,
+		0xAF, 0xE3, 0x83, 0xB0, 0xE3, 0x83, 0xB1, 0xE3,
+		0x83, 0xB2, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0x8F,
+		0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+		0x88, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xAB, 0xE3,
+		0x83, 0x95, 0xE3, 0x82, 0xA1, 0xE3, 0x82, 0xA2,
+		0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+		0x9A, 0xE3, 0x82, 0xA2, 0xE3, 0x82, 0xA2, 0xE3,
+		0x83, 0xBC, 0xE3, 0x83, 0xAB, 0xE3, 0x82, 0xA4,
+		0xE3, 0x83, 0x8B, 0xE3, 0x83, 0xB3, 0xE3, 0x82,
+		0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x82, 0xA4, 0xE3,
+		0x83, 0xB3, 0xE3, 0x83, 0x81, 0xE3, 0x82, 0xA6,
+		0xE3, 0x82, 0xA9, 0xE3, 0x83, 0xB3, 0xE3, 0x82,
+		0xA8, 0xE3, 0x82, 0xB9, 0xE3, 0x82, 0xAF, 0xE3,
+		0x83, 0xBC, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99,
+		0xE3, 0x82, 0xA8, 0xE3, 0x83, 0xBC, 0xE3, 0x82,
+		0xAB, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAA, 0xE3,
+		0x83, 0xB3, 0xE3, 0x82, 0xB9, 0xE3, 0x82, 0xAA,
+		0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xA0, 0xE3, 0x82,
+		0xAB, 0xE3, 0x82, 0xA4, 0xE3, 0x83, 0xAA, 0xE3,
+		0x82, 0xAB, 0xE3, 0x83, 0xA9, 0xE3, 0x83, 0x83,
+		0xE3, 0x83, 0x88, 0xE3, 0x82, 0xAB, 0xE3, 0x83,
+		0xAD, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC, 0xE3,
+		0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAD,
+		0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+		0x99, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x9E, 0xE3,
+		0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x82, 0xAB,
+		0xE3, 0x82, 0x99, 0xE3, 0x82, 0xAD, 0xE3, 0x82,
+		0x99, 0xE3, 0x83, 0x8B, 0xE3, 0x83, 0xBC, 0xE3,
+		0x82, 0xAD, 0xE3, 0x83, 0xA5, 0xE3, 0x83, 0xAA,
+		0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAD, 0xE3, 0x82,
+		0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x82, 0xBF, 0xE3,
+		0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAD,
+		0xE3, 0x83, 0xAD, 0xE3, 0x82, 0xAD, 0xE3, 0x83,
+		0xAD, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3,
+		0x83, 0xA9, 0xE3, 0x83, 0xA0, 0xE3, 0x82, 0xAD,
+		0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xA1, 0xE3, 0x83,
+		0xBC, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0xE3,
+		0x82, 0xAD, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xAF,
+		0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88, 0xE3, 0x82,
+		0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xA9, 0xE3,
+		0x83, 0xA0, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99,
+		0xE3, 0x83, 0xA9, 0xE3, 0x83, 0xA0, 0xE3, 0x83,
+		0x88, 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xAF, 0xE3,
+		0x83, 0xAB, 0xE3, 0x82, 0xBB, 0xE3, 0x82, 0x99,
+		0xE3, 0x82, 0xA4, 0xE3, 0x83, 0xAD, 0xE3, 0x82,
+		0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xBC, 0xE3,
+		0x83, 0x8D, 0xE3, 0x82, 0xB1, 0xE3, 0x83, 0xBC,
+		0xE3, 0x82, 0xB9, 0xE3, 0x82, 0xB3, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0x8A, 0xE3, 0x82, 0xB3, 0xE3,
+		0x83, 0xBC, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A,
+		0xE3, 0x82, 0xB5, 0xE3, 0x82, 0xA4, 0xE3, 0x82,
+		0xAF, 0xE3, 0x83, 0xAB, 0xE3, 0x82, 0xB5, 0xE3,
+		0x83, 0xB3, 0xE3, 0x83, 0x81, 0xE3, 0x83, 0xBC,
+		0xE3, 0x83, 0xA0, 0xE3, 0x82, 0xB7, 0xE3, 0x83,
+		0xAA, 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xAF, 0xE3,
+		0x82, 0x99, 0xE3, 0x82, 0xBB, 0xE3, 0x83, 0xB3,
+		0xE3, 0x83, 0x81, 0xE3, 0x82, 0xBB, 0xE3, 0x83,
+		0xB3, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0xBF, 0xE3,
+		0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xB9,
+		0xE3, 0x83, 0x86, 0xE3, 0x82, 0x99, 0xE3, 0x82,
+		0xB7, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0xE3,
+		0x83, 0xAB, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xB3,
+		0xE3, 0x83, 0x8A, 0xE3, 0x83, 0x8E, 0xE3, 0x83,
+		0x8E, 0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88, 0xE3,
+		0x83, 0x8F, 0xE3, 0x82, 0xA4, 0xE3, 0x83, 0x84,
+		0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83,
+		0xBC, 0xE3, 0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3,
+		0x83, 0x88, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A,
+		0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x84, 0xE3, 0x83,
+		0x8F, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3,
+		0x83, 0xAC, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x92,
+		0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xA2, 0xE3, 0x82,
+		0xB9, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0xE3,
+		0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xAF,
+		0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x92, 0xE3, 0x82,
+		0x9A, 0xE3, 0x82, 0xB3, 0xE3, 0x83, 0x92, 0xE3,
+		0x82, 0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x95,
+		0xE3, 0x82, 0xA1, 0xE3, 0x83, 0xA9, 0xE3, 0x83,
+		0x83, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0xE3,
+		0x83, 0x95, 0xE3, 0x82, 0xA3, 0xE3, 0x83, 0xBC,
+		0xE3, 0x83, 0x88, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+		0x99, 0xE3, 0x83, 0x83, 0xE3, 0x82, 0xB7, 0xE3,
+		0x82, 0xA7, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x95,
+		0xE3, 0x83, 0xA9, 0xE3, 0x83, 0xB3, 0xE3, 0x83,
+		0x98, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0xBF, 0xE3,
+		0x83, 0xBC, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x98,
+		0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xBD, 0xE3, 0x83,
+		0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0x8B, 0xE3,
+		0x83, 0x92, 0xE3, 0x83, 0x98, 0xE3, 0x83, 0xAB,
+		0xE3, 0x83, 0x84, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+		0x9A, 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB9, 0xE3,
+		0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC,
+		0xE3, 0x82, 0xB7, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+		0x98, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3,
+		0x82, 0xBF, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A,
+		0xE3, 0x82, 0xA4, 0xE3, 0x83, 0xB3, 0xE3, 0x83,
+		0x88, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x99, 0xE3,
+		0x83, 0xAB, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0x9B,
+		0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x9B, 0xE3, 0x82,
+		0x9A, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88, 0xE3,
+		0x82, 0x99, 0xE3, 0x83, 0x9B, 0xE3, 0x83, 0xBC,
+		0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x9B, 0xE3, 0x83,
+		0xBC, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x9E, 0xE3,
+		0x82, 0xA4, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAD,
+		0xE3, 0x83, 0x9E, 0xE3, 0x82, 0xA4, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0x9E, 0xE3, 0x83, 0x83, 0xE3,
+		0x83, 0x8F, 0xE3, 0x83, 0x9E, 0xE3, 0x83, 0xAB,
+		0xE3, 0x82, 0xAF, 0xE3, 0x83, 0x9E, 0xE3, 0x83,
+		0xB3, 0xE3, 0x82, 0xB7, 0xE3, 0x83, 0xA7, 0xE3,
+		0x83, 0xB3, 0xE3, 0x83, 0x9F, 0xE3, 0x82, 0xAF,
+		0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xB3, 0xE3, 0x83,
+		0x9F, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0x9F, 0xE3,
+		0x83, 0xAA, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x99,
+		0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xAB, 0xE3, 0x83,
+		0xA1, 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3,
+		0x83, 0xA1, 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99,
+		0xE3, 0x83, 0x88, 0xE3, 0x83, 0xB3, 0xE3, 0x83,
+		0xA1, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88, 0xE3,
+		0x83, 0xAB, 0xE3, 0x83, 0xA4, 0xE3, 0x83, 0xBC,
+		0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+		0xA4, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xAB, 0xE3,
+		0x83, 0xA6, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xB3,
+		0xE3, 0x83, 0xAA, 0xE3, 0x83, 0x83, 0xE3, 0x83,
+		0x88, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0xAA, 0xE3,
+		0x83, 0xA9, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x92,
+		0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x95, 0xE3,
+		0x82, 0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0xAC,
+		0xE3, 0x83, 0xA0, 0xE3, 0x83, 0xAC, 0xE3, 0x83,
+		0xB3, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0xB1, 0xE3,
+		0x82, 0x99, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0xAF,
+		0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88, 0x30, 0xE7,
+		0x82, 0xB9, 0x31, 0xE7, 0x82, 0xB9, 0x32, 0xE7,
+		0x82, 0xB9, 0x33, 0xE7, 0x82, 0xB9, 0x34, 0xE7,
+		0x82, 0xB9, 0x35, 0xE7, 0x82, 0xB9, 0x36, 0xE7,
+		0x82, 0xB9, 0x37, 0xE7, 0x82, 0xB9, 0x38, 0xE7,
+		0x82, 0xB9, 0x39, 0xE7, 0x82, 0xB9, 0x31, 0x30,
+		0xE7, 0x82, 0xB9, 0x31, 0x31, 0xE7, 0x82, 0xB9,
+		0x31, 0x32, 0xE7, 0x82, 0xB9, 0x31, 0x33, 0xE7,
+		0x82, 0xB9, 0x31, 0x34, 0xE7, 0x82, 0xB9, 0x31,
+		0x35, 0xE7, 0x82, 0xB9, 0x31, 0x36, 0xE7, 0x82,
+		0xB9, 0x31, 0x37, 0xE7, 0x82, 0xB9, 0x31, 0x38,
+		0xE7, 0x82, 0xB9, 0x31, 0x39, 0xE7, 0x82, 0xB9,
+		0x32, 0x30, 0xE7, 0x82, 0xB9, 0x32, 0x31, 0xE7,
+		0x82, 0xB9, 0x32, 0x32, 0xE7, 0x82, 0xB9, 0x32,
+		0x33, 0xE7, 0x82, 0xB9, 0x32, 0x34, 0xE7, 0x82,
+		0xB9, 0x68, 0x50, 0x61, 0x64, 0x61, 0x41, 0x55,
+		0x62, 0x61, 0x72, 0x6F, 0x56, 0x70, 0x63, 0x64,
+		0x6D, 0x64, 0x6D, 0x32, 0x64, 0x6D, 0x33, 0x49,
+		0x55, 0xE5, 0xB9, 0xB3, 0xE6, 0x88, 0x90, 0xE6,
+		0x98, 0xAD, 0xE5, 0x92, 0x8C, 0xE5, 0xA4, 0xA7,
+		0xE6, 0xAD, 0xA3, 0xE6, 0x98, 0x8E, 0xE6, 0xB2,
+		0xBB, 0xE6, 0xA0, 0xAA, 0xE5, 0xBC, 0x8F, 0xE4,
+		0xBC, 0x9A, 0xE7, 0xA4, 0xBE, 0x70, 0x41, 0x6E,
+		0x41, 0xCE, 0xBC, 0x41, 0x6D, 0x41, 0x6B, 0x41,
+		0x4B, 0x42, 0x4D, 0x42, 0x47, 0x42, 0x63, 0x61,
+		0x6C, 0x6B, 0x63, 0x61, 0x6C, 0x70, 0x46, 0x6E,
+		0x46, 0xCE, 0xBC, 0x46, 0xCE, 0xBC, 0x67, 0x6D,
+		0x67, 0x6B, 0x67, 0x48, 0x7A, 0x6B, 0x48, 0x7A,
+		0x4D, 0x48, 0x7A, 0x47, 0x48, 0x7A, 0x54, 0x48,
+		0x7A, 0xCE, 0xBC, 0x6C, 0x6D, 0x6C, 0x64, 0x6C,
+		0x6B, 0x6C, 0x66, 0x6D, 0x6E, 0x6D, 0xCE, 0xBC,
+		0x6D, 0x6D, 0x6D, 0x63, 0x6D, 0x6B, 0x6D, 0x6D,
+		0x6D, 0x32, 0x63, 0x6D, 0x32, 0x6D, 0x32, 0x6B,
+		0x6D, 0x32, 0x6D, 0x6D, 0x33, 0x63, 0x6D, 0x33,
+		0x6D, 0x33, 0x6B, 0x6D, 0x33, 0x6D, 0xE2, 0x88,
+		0x95, 0x73, 0x6D, 0xE2, 0x88, 0x95, 0x73, 0x32,
+		0x50, 0x61, 0x6B, 0x50, 0x61, 0x4D, 0x50, 0x61,
+		0x47, 0x50, 0x61, 0x72, 0x61, 0x64, 0x72, 0x61,
+		0x64, 0xE2, 0x88, 0x95, 0x73, 0x72, 0x61, 0x64,
+		0xE2, 0x88, 0x95, 0x73, 0x32, 0x70, 0x73, 0x6E,
+		0x73, 0xCE, 0xBC, 0x73, 0x6D, 0x73, 0x70, 0x56,
+		0x6E, 0x56, 0xCE, 0xBC, 0x56, 0x6D, 0x56, 0x6B,
+		0x56, 0x4D, 0x56, 0x70, 0x57, 0x6E, 0x57, 0xCE,
+		0xBC, 0x57, 0x6D, 0x57, 0x6B, 0x57, 0x4D, 0x57,
+		0x6B, 0xCE, 0xA9, 0x4D, 0xCE, 0xA9, 0x61, 0x2E,
+		0x6D, 0x2E, 0x42, 0x71, 0x63, 0x63, 0x63, 0x64,
+		0x43, 0xE2, 0x88, 0x95, 0x6B, 0x67, 0x43, 0x6F,
+		0x2E, 0x64, 0x42, 0x47, 0x79, 0x68, 0x61, 0x48,
+		0x50, 0x69, 0x6E, 0x4B, 0x4B, 0x4B, 0x4D, 0x6B,
+		0x74, 0x6C, 0x6D, 0x6C, 0x6E, 0x6C, 0x6F, 0x67,
+		0x6C, 0x78, 0x6D, 0x62, 0x6D, 0x69, 0x6C, 0x6D,
+		0x6F, 0x6C, 0x50, 0x48, 0x70, 0x2E, 0x6D, 0x2E,
+		0x50, 0x50, 0x4D, 0x50, 0x52, 0x73, 0x72, 0x53,
+		0x76, 0x57, 0x62, 0x56, 0xE2, 0x88, 0x95, 0x6D,
+		0x41, 0xE2, 0x88, 0x95, 0x6D, 0x31, 0xE6, 0x97,
+		0xA5, 0x32, 0xE6, 0x97, 0xA5, 0x33, 0xE6, 0x97,
+		0xA5, 0x34, 0xE6, 0x97, 0xA5, 0x35, 0xE6, 0x97,
+		0xA5, 0x36, 0xE6, 0x97, 0xA5, 0x37, 0xE6, 0x97,
+		0xA5, 0x38, 0xE6, 0x97, 0xA5, 0x39, 0xE6, 0x97,
+		0xA5, 0x31, 0x30, 0xE6, 0x97, 0xA5, 0x31, 0x31,
+		0xE6, 0x97, 0xA5, 0x31, 0x32, 0xE6, 0x97, 0xA5,
+		0x31, 0x33, 0xE6, 0x97, 0xA5, 0x31, 0x34, 0xE6,
+		0x97, 0xA5, 0x31, 0x35, 0xE6, 0x97, 0xA5, 0x31,
+		0x36, 0xE6, 0x97, 0xA5, 0x31, 0x37, 0xE6, 0x97,
+		0xA5, 0x31, 0x38, 0xE6, 0x97, 0xA5, 0x31, 0x39,
+		0xE6, 0x97, 0xA5, 0x32, 0x30, 0xE6, 0x97, 0xA5,
+		0x32, 0x31, 0xE6, 0x97, 0xA5, 0x32, 0x32, 0xE6,
+		0x97, 0xA5, 0x32, 0x33, 0xE6, 0x97, 0xA5, 0x32,
+		0x34, 0xE6, 0x97, 0xA5, 0x32, 0x35, 0xE6, 0x97,
+		0xA5, 0x32, 0x36, 0xE6, 0x97, 0xA5, 0x32, 0x37,
+		0xE6, 0x97, 0xA5, 0x32, 0x38, 0xE6, 0x97, 0xA5,
+		0x32, 0x39, 0xE6, 0x97, 0xA5, 0x33, 0x30, 0xE6,
+		0x97, 0xA5, 0x33, 0x31, 0xE6, 0x97, 0xA5, 0x67,
+		0x61, 0x6C, 0xF6, 0xE8, 0xB1, 0x88, 0xF6, 0xE6,
+		0x9B, 0xB4, 0xF6, 0xE8, 0xBB, 0x8A, 0xF6, 0xE8,
+		0xB3, 0x88, 0xF6, 0xE6, 0xBB, 0x91, 0xF6, 0xE4,
+		0xB8, 0xB2, 0xF6, 0xE5, 0x8F, 0xA5, 0xF6, 0xE9,
+		0xBE, 0x9C, 0xF6, 0xE9, 0xBE, 0x9C, 0xF6, 0xE5,
+		0xA5, 0x91, 0xF6, 0xE9, 0x87, 0x91, 0xF6, 0xE5,
+		0x96, 0x87, 0xF6, 0xE5, 0xA5, 0x88, 0xF6, 0xE6,
+		0x87, 0xB6, 0xF6, 0xE7, 0x99, 0xA9, 0xF6, 0xE7,
+		0xBE, 0x85, 0xF6, 0xE8, 0x98, 0xBF, 0xF6, 0xE8,
+		0x9E, 0xBA, 0xF6, 0xE8, 0xA3, 0xB8, 0xF6, 0xE9,
+		0x82, 0x8F, 0xF6, 0xE6, 0xA8, 0x82, 0xF6, 0xE6,
+		0xB4, 0x9B, 0xF6, 0xE7, 0x83, 0x99, 0xF6, 0xE7,
+		0x8F, 0x9E, 0xF6, 0xE8, 0x90, 0xBD, 0xF6, 0xE9,
+		0x85, 0xAA, 0xF6, 0xE9, 0xA7, 0xB1, 0xF6, 0xE4,
+		0xBA, 0x82, 0xF6, 0xE5, 0x8D, 0xB5, 0xF6, 0xE6,
+		0xAC, 0x84, 0xF6, 0xE7, 0x88, 0x9B, 0xF6, 0xE8,
+		0x98, 0xAD, 0xF6, 0xE9, 0xB8, 0x9E, 0xF6, 0xE5,
+		0xB5, 0x90, 0xF6, 0xE6, 0xBF, 0xAB, 0xF6, 0xE8,
+		0x97, 0x8D, 0xF6, 0xE8, 0xA5, 0xA4, 0xF6, 0xE6,
+		0x8B, 0x89, 0xF6, 0xE8, 0x87, 0x98, 0xF6, 0xE8,
+		0xA0, 0x9F, 0xF6, 0xE5, 0xBB, 0x8A, 0xF6, 0xE6,
+		0x9C, 0x97, 0xF6, 0xE6, 0xB5, 0xAA, 0xF6, 0xE7,
+		0x8B, 0xBC, 0xF6, 0xE9, 0x83, 0x8E, 0xF6, 0xE4,
+		0xBE, 0x86, 0xF6, 0xE5, 0x86, 0xB7, 0xF6, 0xE5,
+		0x8B, 0x9E, 0xF6, 0xE6, 0x93, 0x84, 0xF6, 0xE6,
+		0xAB, 0x93, 0xF6, 0xE7, 0x88, 0x90, 0xF6, 0xE7,
+		0x9B, 0xA7, 0xF6, 0xE8, 0x80, 0x81, 0xF6, 0xE8,
+		0x98, 0x86, 0xF6, 0xE8, 0x99, 0x9C, 0xF6, 0xE8,
+		0xB7, 0xAF, 0xF6, 0xE9, 0x9C, 0xB2, 0xF6, 0xE9,
+		0xAD, 0xAF, 0xF6, 0xE9, 0xB7, 0xBA, 0xF6, 0xE7,
+		0xA2, 0x8C, 0xF6, 0xE7, 0xA5, 0xBF, 0xF6, 0xE7,
+		0xB6, 0xA0, 0xF6, 0xE8, 0x8F, 0x89, 0xF6, 0xE9,
+		0x8C, 0x84, 0xF6, 0xE9, 0xB9, 0xBF, 0xF6, 0xE8,
+		0xAB, 0x96, 0xF6, 0xE5, 0xA3, 0x9F, 0xF6, 0xE5,
+		0xBC, 0x84, 0xF6, 0xE7, 0xB1, 0xA0, 0xF6, 0xE8,
+		0x81, 0xBE, 0xF6, 0xE7, 0x89, 0xA2, 0xF6, 0xE7,
+		0xA3, 0x8A, 0xF6, 0xE8, 0xB3, 0x82, 0xF6, 0xE9,
+		0x9B, 0xB7, 0xF6, 0xE5, 0xA3, 0x98, 0xF6, 0xE5,
+		0xB1, 0xA2, 0xF6, 0xE6, 0xA8, 0x93, 0xF6, 0xE6,
+		0xB7, 0x9A, 0xF6, 0xE6, 0xBC, 0x8F, 0xF6, 0xE7,
+		0xB4, 0xAF, 0xF6, 0xE7, 0xB8, 0xB7, 0xF6, 0xE9,
+		0x99, 0x8B, 0xF6, 0xE5, 0x8B, 0x92, 0xF6, 0xE8,
+		0x82, 0x8B, 0xF6, 0xE5, 0x87, 0x9C, 0xF6, 0xE5,
+		0x87, 0x8C, 0xF6, 0xE7, 0xA8, 0x9C, 0xF6, 0xE7,
+		0xB6, 0xBE, 0xF6, 0xE8, 0x8F, 0xB1, 0xF6, 0xE9,
+		0x99, 0xB5, 0xF6, 0xE8, 0xAE, 0x80, 0xF6, 0xE6,
+		0x8B, 0x8F, 0xF6, 0xE6, 0xA8, 0x82, 0xF6, 0xE8,
+		0xAB, 0xBE, 0xF6, 0xE4, 0xB8, 0xB9, 0xF6, 0xE5,
+		0xAF, 0xA7, 0xF6, 0xE6, 0x80, 0x92, 0xF6, 0xE7,
+		0x8E, 0x87, 0xF6, 0xE7, 0x95, 0xB0, 0xF6, 0xE5,
+		0x8C, 0x97, 0xF6, 0xE7, 0xA3, 0xBB, 0xF6, 0xE4,
+		0xBE, 0xBF, 0xF6, 0xE5, 0xBE, 0xA9, 0xF6, 0xE4,
+		0xB8, 0x8D, 0xF6, 0xE6, 0xB3, 0x8C, 0xF6, 0xE6,
+		0x95, 0xB8, 0xF6, 0xE7, 0xB4, 0xA2, 0xF6, 0xE5,
+		0x8F, 0x83, 0xF6, 0xE5, 0xA1, 0x9E, 0xF6, 0xE7,
+		0x9C, 0x81, 0xF6, 0xE8, 0x91, 0x89, 0xF6, 0xE8,
+		0xAA, 0xAA, 0xF6, 0xE6, 0xAE, 0xBA, 0xF6, 0xE8,
+		0xBE, 0xB0, 0xF6, 0xE6, 0xB2, 0x88, 0xF6, 0xE6,
+		0x8B, 0xBE, 0xF6, 0xE8, 0x8B, 0xA5, 0xF6, 0xE6,
+		0x8E, 0xA0, 0xF6, 0xE7, 0x95, 0xA5, 0xF6, 0xE4,
+		0xBA, 0xAE, 0xF6, 0xE5, 0x85, 0xA9, 0xF6, 0xE5,
+		0x87, 0x89, 0xF6, 0xE6, 0xA2, 0x81, 0xF6, 0xE7,
+		0xB3, 0xA7, 0xF6, 0xE8, 0x89, 0xAF, 0xF6, 0xE8,
+		0xAB, 0x92, 0xF6, 0xE9, 0x87, 0x8F, 0xF6, 0xE5,
+		0x8B, 0xB5, 0xF6, 0xE5, 0x91, 0x82, 0xF6, 0xE5,
+		0xA5, 0xB3, 0xF6, 0xE5, 0xBB, 0xAC, 0xF6, 0xE6,
+		0x97, 0x85, 0xF6, 0xE6, 0xBF, 0xBE, 0xF6, 0xE7,
+		0xA4, 0xAA, 0xF6, 0xE9, 0x96, 0xAD, 0xF6, 0xE9,
+		0xA9, 0xAA, 0xF6, 0xE9, 0xBA, 0x97, 0xF6, 0xE9,
+		0xBB, 0x8E, 0xF6, 0xE5, 0x8A, 0x9B, 0xF6, 0xE6,
+		0x9B, 0x86, 0xF6, 0xE6, 0xAD, 0xB7, 0xF6, 0xE8,
+		0xBD, 0xA2, 0xF6, 0xE5, 0xB9, 0xB4, 0xF6, 0xE6,
+		0x86, 0x90, 0xF6, 0xE6, 0x88, 0x80, 0xF6, 0xE6,
+		0x92, 0x9A, 0xF6, 0xE6, 0xBC, 0xA3, 0xF6, 0xE7,
+		0x85, 0x89, 0xF6, 0xE7, 0x92, 0x89, 0xF6, 0xE7,
+		0xA7, 0x8A, 0xF6, 0xE7, 0xB7, 0xB4, 0xF6, 0xE8,
+		0x81, 0xAF, 0xF6, 0xE8, 0xBC, 0xA6, 0xF6, 0xE8,
+		0x93, 0xAE, 0xF6, 0xE9, 0x80, 0xA3, 0xF6, 0xE9,
+		0x8D, 0x8A, 0xF6, 0xE5, 0x88, 0x97, 0xF6, 0xE5,
+		0x8A, 0xA3, 0xF6, 0xE5, 0x92, 0xBD, 0xF6, 0xE7,
+		0x83, 0x88, 0xF6, 0xE8, 0xA3, 0x82, 0xF6, 0xE8,
+		0xAA, 0xAA, 0xF6, 0xE5, 0xBB, 0x89, 0xF6, 0xE5,
+		0xBF, 0xB5, 0xF6, 0xE6, 0x8D, 0xBB, 0xF6, 0xE6,
+		0xAE, 0xAE, 0xF6, 0xE7, 0xB0, 0xBE, 0xF6, 0xE7,
+		0x8D, 0xB5, 0xF6, 0xE4, 0xBB, 0xA4, 0xF6, 0xE5,
+		0x9B, 0xB9, 0xF6, 0xE5, 0xAF, 0xA7, 0xF6, 0xE5,
+		0xB6, 0xBA, 0xF6, 0xE6, 0x80, 0x9C, 0xF6, 0xE7,
+		0x8E, 0xB2, 0xF6, 0xE7, 0x91, 0xA9, 0xF6, 0xE7,
+		0xBE, 0x9A, 0xF6, 0xE8, 0x81, 0x86, 0xF6, 0xE9,
+		0x88, 0xB4, 0xF6, 0xE9, 0x9B, 0xB6, 0xF6, 0xE9,
+		0x9D, 0x88, 0xF6, 0xE9, 0xA0, 0x98, 0xF6, 0xE4,
+		0xBE, 0x8B, 0xF6, 0xE7, 0xA6, 0xAE, 0xF6, 0xE9,
+		0x86, 0xB4, 0xF6, 0xE9, 0x9A, 0xB8, 0xF6, 0xE6,
+		0x83, 0xA1, 0xF6, 0xE4, 0xBA, 0x86, 0xF6, 0xE5,
+		0x83, 0x9A, 0xF6, 0xE5, 0xAF, 0xAE, 0xF6, 0xE5,
+		0xB0, 0xBF, 0xF6, 0xE6, 0x96, 0x99, 0xF6, 0xE6,
+		0xA8, 0x82, 0xF6, 0xE7, 0x87, 0x8E, 0xF6, 0xE7,
+		0x99, 0x82, 0xF6, 0xE8, 0x93, 0xBC, 0xF6, 0xE9,
+		0x81, 0xBC, 0xF6, 0xE9, 0xBE, 0x8D, 0xF6, 0xE6,
+		0x9A, 0x88, 0xF6, 0xE9, 0x98, 0xAE, 0xF6, 0xE5,
+		0x8A, 0x89, 0xF6, 0xE6, 0x9D, 0xBB, 0xF6, 0xE6,
+		0x9F, 0xB3, 0xF6, 0xE6, 0xB5, 0x81, 0xF6, 0xE6,
+		0xBA, 0x9C, 0xF6, 0xE7, 0x90, 0x89, 0xF6, 0xE7,
+		0x95, 0x99, 0xF6, 0xE7, 0xA1, 0xAB, 0xF6, 0xE7,
+		0xB4, 0x90, 0xF6, 0xE9, 0xA1, 0x9E, 0xF6, 0xE5,
+		0x85, 0xAD, 0xF6, 0xE6, 0x88, 0xAE, 0xF6, 0xE9,
+		0x99, 0xB8, 0xF6, 0xE5, 0x80, 0xAB, 0xF6, 0xE5,
+		0xB4, 0x99, 0xF6, 0xE6, 0xB7, 0xAA, 0xF6, 0xE8,
+		0xBC, 0xAA, 0xF6, 0xE5, 0xBE, 0x8B, 0xF6, 0xE6,
+		0x85, 0x84, 0xF6, 0xE6, 0xA0, 0x97, 0xF6, 0xE7,
+		0x8E, 0x87, 0xF6, 0xE9, 0x9A, 0x86, 0xF6, 0xE5,
+		0x88, 0xA9, 0xF6, 0xE5, 0x90, 0x8F, 0xF6, 0xE5,
+		0xB1, 0xA5, 0xF6, 0xE6, 0x98, 0x93, 0xF6, 0xE6,
+		0x9D, 0x8E, 0xF6, 0xE6, 0xA2, 0xA8, 0xF6, 0xE6,
+		0xB3, 0xA5, 0xF6, 0xE7, 0x90, 0x86, 0xF6, 0xE7,
+		0x97, 0xA2, 0xF6, 0xE7, 0xBD, 0xB9, 0xF6, 0xE8,
+		0xA3, 0x8F, 0xF6, 0xE8, 0xA3, 0xA1, 0xF6, 0xE9,
+		0x87, 0x8C, 0xF6, 0xE9, 0x9B, 0xA2, 0xF6, 0xE5,
+		0x8C, 0xBF, 0xF6, 0xE6, 0xBA, 0xBA, 0xF6, 0xE5,
+		0x90, 0x9D, 0xF6, 0xE7, 0x87, 0x90, 0xF6, 0xE7,
+		0x92, 0x98, 0xF6, 0xE8, 0x97, 0xBA, 0xF6, 0xE9,
+		0x9A, 0xA3, 0xF6, 0xE9, 0xB1, 0x97, 0xF6, 0xE9,
+		0xBA, 0x9F, 0xF6, 0xE6, 0x9E, 0x97, 0xF6, 0xE6,
+		0xB7, 0x8B, 0xF6, 0xE8, 0x87, 0xA8, 0xF6, 0xE7,
+		0xAB, 0x8B, 0xF6, 0xE7, 0xAC, 0xA0, 0xF6, 0xE7,
+		0xB2, 0x92, 0xF6, 0xE7, 0x8B, 0x80, 0xF6, 0xE7,
+		0x82, 0x99, 0xF6, 0xE8, 0xAD, 0x98, 0xF6, 0xE4,
+		0xBB, 0x80, 0xF6, 0xE8, 0x8C, 0xB6, 0xF6, 0xE5,
+		0x88, 0xBA, 0xF6, 0xE5, 0x88, 0x87, 0xF6, 0xE5,
+		0xBA, 0xA6, 0xF6, 0xE6, 0x8B, 0x93, 0xF6, 0xE7,
+		0xB3, 0x96, 0xF6, 0xE5, 0xAE, 0x85, 0xF6, 0xE6,
+		0xB4, 0x9E, 0xF6, 0xE6, 0x9A, 0xB4, 0xF6, 0xE8,
+		0xBC, 0xBB, 0xF6, 0xE8, 0xA1, 0x8C, 0xF6, 0xE9,
+		0x99, 0x8D, 0xF6, 0xE8, 0xA6, 0x8B, 0xF6, 0xE5,
+		0xBB, 0x93, 0xF6, 0xE5, 0x85, 0x80, 0xF6, 0xE5,
+		0x97, 0x80, 0xF6, 0xE5, 0xA1, 0x9A, 0xF6, 0xE6,
+		0x99, 0xB4, 0xF6, 0xE5, 0x87, 0x9E, 0xF6, 0xE7,
+		0x8C, 0xAA, 0xF6, 0xE7, 0x9B, 0x8A, 0xF6, 0xE7,
+		0xA4, 0xBC, 0xF6, 0xE7, 0xA5, 0x9E, 0xF6, 0xE7,
+		0xA5, 0xA5, 0xF6, 0xE7, 0xA6, 0x8F, 0xF6, 0xE9,
+		0x9D, 0x96, 0xF6, 0xE7, 0xB2, 0xBE, 0xF6, 0xE7,
+		0xBE, 0xBD, 0xF6, 0xE8, 0x98, 0x92, 0xF6, 0xE8,
+		0xAB, 0xB8, 0xF6, 0xE9, 0x80, 0xB8, 0xF6, 0xE9,
+		0x83, 0xBD, 0xF6, 0xE9, 0xA3, 0xAF, 0xF6, 0xE9,
+		0xA3, 0xBC, 0xF6, 0xE9, 0xA4, 0xA8, 0xF6, 0xE9,
+		0xB6, 0xB4, 0xF6, 0xE4, 0xBE, 0xAE, 0xF6, 0xE5,
+		0x83, 0xA7, 0xF6, 0xE5, 0x85, 0x8D, 0xF6, 0xE5,
+		0x8B, 0x89, 0xF6, 0xE5, 0x8B, 0xA4, 0xF6, 0xE5,
+		0x8D, 0x91, 0xF6, 0xE5, 0x96, 0x9D, 0xF6, 0xE5,
+		0x98, 0x86, 0xF6, 0xE5, 0x99, 0xA8, 0xF6, 0xE5,
+		0xA1, 0x80, 0xF6, 0xE5, 0xA2, 0xA8, 0xF6, 0xE5,
+		0xB1, 0xA4, 0xF6, 0xE5, 0xB1, 0xAE, 0xF6, 0xE6,
+		0x82, 0x94, 0xF6, 0xE6, 0x85, 0xA8, 0xF6, 0xE6,
+		0x86, 0x8E, 0xF6, 0xE6, 0x87, 0xB2, 0xF6, 0xE6,
+		0x95, 0x8F, 0xF6, 0xE6, 0x97, 0xA2, 0xF6, 0xE6,
+		0x9A, 0x91, 0xF6, 0xE6, 0xA2, 0x85, 0xF6, 0xE6,
+		0xB5, 0xB7, 0xF6, 0xE6, 0xB8, 0x9A, 0xF6, 0xE6,
+		0xBC, 0xA2, 0xF6, 0xE7, 0x85, 0xAE, 0xF6, 0xE7,
+		0x88, 0xAB, 0xF6, 0xE7, 0x90, 0xA2, 0xF6, 0xE7,
+		0xA2, 0x91, 0xF6, 0xE7, 0xA4, 0xBE, 0xF6, 0xE7,
+		0xA5, 0x89, 0xF6, 0xE7, 0xA5, 0x88, 0xF6, 0xE7,
+		0xA5, 0x90, 0xF6, 0xE7, 0xA5, 0x96, 0xF6, 0xE7,
+		0xA5, 0x9D, 0xF6, 0xE7, 0xA6, 0x8D, 0xF6, 0xE7,
+		0xA6, 0x8E, 0xF6, 0xE7, 0xA9, 0x80, 0xF6, 0xE7,
+		0xAA, 0x81, 0xF6, 0xE7, 0xAF, 0x80, 0xF6, 0xE7,
+		0xB7, 0xB4, 0xF6, 0xE7, 0xB8, 0x89, 0xF6, 0xE7,
+		0xB9, 0x81, 0xF6, 0xE7, 0xBD, 0xB2, 0xF6, 0xE8,
+		0x80, 0x85, 0xF6, 0xE8, 0x87, 0xAD, 0xF6, 0xE8,
+		0x89, 0xB9, 0xF6, 0xE8, 0x89, 0xB9, 0xF6, 0xE8,
+		0x91, 0x97, 0xF6, 0xE8, 0xA4, 0x90, 0xF6, 0xE8,
+		0xA6, 0x96, 0xF6, 0xE8, 0xAC, 0x81, 0xF6, 0xE8,
+		0xAC, 0xB9, 0xF6, 0xE8, 0xB3, 0x93, 0xF6, 0xE8,
+		0xB4, 0x88, 0xF6, 0xE8, 0xBE, 0xB6, 0xF6, 0xE9,
+		0x80, 0xB8, 0xF6, 0xE9, 0x9B, 0xA3, 0xF6, 0xE9,
+		0x9F, 0xBF, 0xF6, 0xE9, 0xA0, 0xBB, 0xF6, 0xE4,
+		0xB8, 0xA6, 0xF6, 0xE5, 0x86, 0xB5, 0xF6, 0xE5,
+		0x85, 0xA8, 0xF6, 0xE4, 0xBE, 0x80, 0xF6, 0xE5,
+		0x85, 0x85, 0xF6, 0xE5, 0x86, 0x80, 0xF6, 0xE5,
+		0x8B, 0x87, 0xF6, 0xE5, 0x8B, 0xBA, 0xF6, 0xE5,
+		0x96, 0x9D, 0xF6, 0xE5, 0x95, 0x95, 0xF6, 0xE5,
+		0x96, 0x99, 0xF6, 0xE5, 0x97, 0xA2, 0xF6, 0xE5,
+		0xA1, 0x9A, 0xF6, 0xE5, 0xA2, 0xB3, 0xF6, 0xE5,
+		0xA5, 0x84, 0xF6, 0xE5, 0xA5, 0x94, 0xF6, 0xE5,
+		0xA9, 0xA2, 0xF6, 0xE5, 0xAC, 0xA8, 0xF6, 0xE5,
+		0xBB, 0x92, 0xF6, 0xE5, 0xBB, 0x99, 0xF6, 0xE5,
+		0xBD, 0xA9, 0xF6, 0xE5, 0xBE, 0xAD, 0xF6, 0xE6,
+		0x83, 0x98, 0xF6, 0xE6, 0x85, 0x8E, 0xF6, 0xE6,
+		0x84, 0x88, 0xF6, 0xE6, 0x86, 0x8E, 0xF6, 0xE6,
+		0x85, 0xA0, 0xF6, 0xE6, 0x87, 0xB2, 0xF6, 0xE6,
+		0x88, 0xB4, 0xF6, 0xE6, 0x8F, 0x84, 0xF6, 0xE6,
+		0x90, 0x9C, 0xF6, 0xE6, 0x91, 0x92, 0xF6, 0xE6,
+		0x95, 0x96, 0xF6, 0xE6, 0x99, 0xB4, 0xF6, 0xE6,
+		0x9C, 0x97, 0xF6, 0xE6, 0x9C, 0x9B, 0xF6, 0xE6,
+		0x9D, 0x96, 0xF6, 0xE6, 0xAD, 0xB9, 0xF6, 0xE6,
+		0xAE, 0xBA, 0xF6, 0xE6, 0xB5, 0x81, 0xF6, 0xE6,
+		0xBB, 0x9B, 0xF6, 0xE6, 0xBB, 0x8B, 0xF6, 0xE6,
+		0xBC, 0xA2, 0xF6, 0xE7, 0x80, 0x9E, 0xF6, 0xE7,
+		0x85, 0xAE, 0xF6, 0xE7, 0x9E, 0xA7, 0xF6, 0xE7,
+		0x88, 0xB5, 0xF6, 0xE7, 0x8A, 0xAF, 0xF6, 0xE7,
+		0x8C, 0xAA, 0xF6, 0xE7, 0x91, 0xB1, 0xF6, 0xE7,
+		0x94, 0x86, 0xF6, 0xE7, 0x94, 0xBB, 0xF6, 0xE7,
+		0x98, 0x9D, 0xF6, 0xE7, 0x98, 0x9F, 0xF6, 0xE7,
+		0x9B, 0x8A, 0xF6, 0xE7, 0x9B, 0x9B, 0xF6, 0xE7,
+		0x9B, 0xB4, 0xF6, 0xE7, 0x9D, 0x8A, 0xF6, 0xE7,
+		0x9D, 0x80, 0xF6, 0xE7, 0xA3, 0x8C, 0xF6, 0xE7,
+		0xAA, 0xB1, 0xF6, 0xE7, 0xAF, 0x80, 0xF6, 0xE7,
+		0xB1, 0xBB, 0xF6, 0xE7, 0xB5, 0x9B, 0xF6, 0xE7,
+		0xB7, 0xB4, 0xF6, 0xE7, 0xBC, 0xBE, 0xF6, 0xE8,
+		0x80, 0x85, 0xF6, 0xE8, 0x8D, 0x92, 0xF6, 0xE8,
+		0x8F, 0xAF, 0xF6, 0xE8, 0x9D, 0xB9, 0xF6, 0xE8,
+		0xA5, 0x81, 0xF6, 0xE8, 0xA6, 0x86, 0xF6, 0xE8,
+		0xA6, 0x96, 0xF6, 0xE8, 0xAA, 0xBF, 0xF6, 0xE8,
+		0xAB, 0xB8, 0xF6, 0xE8, 0xAB, 0x8B, 0xF6, 0xE8,
+		0xAC, 0x81, 0xF6, 0xE8, 0xAB, 0xBE, 0xF6, 0xE8,
+		0xAB, 0xAD, 0xF6, 0xE8, 0xAC, 0xB9, 0xF6, 0xE8,
+		0xAE, 0x8A, 0xF6, 0xE8, 0xB4, 0x88, 0xF6, 0xE8,
+		0xBC, 0xB8, 0xF6, 0xE9, 0x81, 0xB2, 0xF6, 0xE9,
+		0x86, 0x99, 0xF6, 0xE9, 0x89, 0xB6, 0xF6, 0xE9,
+		0x99, 0xBC, 0xF6, 0xE9, 0x9B, 0xA3, 0xF6, 0xE9,
+		0x9D, 0x96, 0xF6, 0xE9, 0x9F, 0x9B, 0xF6, 0xE9,
+		0x9F, 0xBF, 0xF6, 0xE9, 0xA0, 0x8B, 0xF6, 0xE9,
+		0xA0, 0xBB, 0xF6, 0xE9, 0xAC, 0x92, 0xF6, 0xE9,
+		0xBE, 0x9C, 0xF6, 0xF0, 0xA2, 0xA1, 0x8A, 0xF6,
+		0xF0, 0xA2, 0xA1, 0x84, 0xF6, 0xF0, 0xA3, 0x8F,
+		0x95, 0xF6, 0xE3, 0xAE, 0x9D, 0xF6, 0xE4, 0x80,
+		0x98, 0xF6, 0xE4, 0x80, 0xB9, 0xF6, 0xF0, 0xA5,
+		0x89, 0x89, 0xF6, 0xF0, 0xA5, 0xB3, 0x90, 0xF6,
+		0xF0, 0xA7, 0xBB, 0x93, 0xF6, 0xE9, 0xBD, 0x83,
+		0xF6, 0xE9, 0xBE, 0x8E, 0x66, 0x66, 0x66, 0x69,
+		0x66, 0x6C, 0x66, 0x66, 0x69, 0x66, 0x66, 0x6C,
+		0x73, 0x74, 0x73, 0x74, 0xD5, 0xB4, 0xD5, 0xB6,
+		0xD5, 0xB4, 0xD5, 0xA5, 0xD5, 0xB4, 0xD5, 0xAB,
+		0xD5, 0xBE, 0xD5, 0xB6, 0xD5, 0xB4, 0xD5, 0xAD,
+		0xF6, 0xD7, 0x99, 0xD6, 0xB4, 0xF6, 0xD7, 0xB2,
+		0xD6, 0xB7, 0xD7, 0xA2, 0xD7, 0x90, 0xD7, 0x93,
+		0xD7, 0x94, 0xD7, 0x9B, 0xD7, 0x9C, 0xD7, 0x9D,
+		0xD7, 0xA8, 0xD7, 0xAA, 0x2B, 0xF6, 0xD7, 0xA9,
+		0xD7, 0x81, 0xF6, 0xD7, 0xA9, 0xD7, 0x82, 0xF6,
+		0xD7, 0xA9, 0xD6, 0xBC, 0xD7, 0x81, 0xF6, 0xD7,
+		0xA9, 0xD6, 0xBC, 0xD7, 0x82, 0xF6, 0xD7, 0x90,
+		0xD6, 0xB7, 0xF6, 0xD7, 0x90, 0xD6, 0xB8, 0xF6,
+		0xD7, 0x90, 0xD6, 0xBC, 0xF6, 0xD7, 0x91, 0xD6,
+		0xBC, 0xF6, 0xD7, 0x92, 0xD6, 0xBC, 0xF6, 0xD7,
+		0x93, 0xD6, 0xBC, 0xF6, 0xD7, 0x94, 0xD6, 0xBC,
+		0xF6, 0xD7, 0x95, 0xD6, 0xBC, 0xF6, 0xD7, 0x96,
+		0xD6, 0xBC, 0xF6, 0xD7, 0x98, 0xD6, 0xBC, 0xF6,
+		0xD7, 0x99, 0xD6, 0xBC, 0xF6, 0xD7, 0x9A, 0xD6,
+		0xBC, 0xF6, 0xD7, 0x9B, 0xD6, 0xBC, 0xF6, 0xD7,
+		0x9C, 0xD6, 0xBC, 0xF6, 0xD7, 0x9E, 0xD6, 0xBC,
+		0xF6, 0xD7, 0xA0, 0xD6, 0xBC, 0xF6, 0xD7, 0xA1,
+		0xD6, 0xBC, 0xF6, 0xD7, 0xA3, 0xD6, 0xBC, 0xF6,
+		0xD7, 0xA4, 0xD6, 0xBC, 0xF6, 0xD7, 0xA6, 0xD6,
+		0xBC, 0xF6, 0xD7, 0xA7, 0xD6, 0xBC, 0xF6, 0xD7,
+		0xA8, 0xD6, 0xBC, 0xF6, 0xD7, 0xA9, 0xD6, 0xBC,
+		0xF6, 0xD7, 0xAA, 0xD6, 0xBC, 0xF6, 0xD7, 0x95,
+		0xD6, 0xB9, 0xF6, 0xD7, 0x91, 0xD6, 0xBF, 0xF6,
+		0xD7, 0x9B, 0xD6, 0xBF, 0xF6, 0xD7, 0xA4, 0xD6,
+		0xBF, 0xD7, 0x90, 0xD7, 0x9C, 0xD9, 0xB1, 0xD9,
+		0xB1, 0xD9, 0xBB, 0xD9, 0xBB, 0xD9, 0xBB, 0xD9,
+		0xBB, 0xD9, 0xBE, 0xD9, 0xBE, 0xD9, 0xBE, 0xD9,
+		0xBE, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA,
+		0x80, 0xD9, 0xBA, 0xD9, 0xBA, 0xD9, 0xBA, 0xD9,
+		0xBA, 0xD9, 0xBF, 0xD9, 0xBF, 0xD9, 0xBF, 0xD9,
+		0xBF, 0xD9, 0xB9, 0xD9, 0xB9, 0xD9, 0xB9, 0xD9,
+		0xB9, 0xDA, 0xA4, 0xDA, 0xA4, 0xDA, 0xA4, 0xDA,
+		0xA4, 0xDA, 0xA6, 0xDA, 0xA6, 0xDA, 0xA6, 0xDA,
+		0xA6, 0xDA, 0x84, 0xDA, 0x84, 0xDA, 0x84, 0xDA,
+		0x84, 0xDA, 0x83, 0xDA, 0x83, 0xDA, 0x83, 0xDA,
+		0x83, 0xDA, 0x86, 0xDA, 0x86, 0xDA, 0x86, 0xDA,
+		0x86, 0xDA, 0x87, 0xDA, 0x87, 0xDA, 0x87, 0xDA,
+		0x87, 0xDA, 0x8D, 0xDA, 0x8D, 0xDA, 0x8C, 0xDA,
+		0x8C, 0xDA, 0x8E, 0xDA, 0x8E, 0xDA, 0x88, 0xDA,
+		0x88, 0xDA, 0x98, 0xDA, 0x98, 0xDA, 0x91, 0xDA,
+		0x91, 0xDA, 0xA9, 0xDA, 0xA9, 0xDA, 0xA9, 0xDA,
+		0xA9, 0xDA, 0xAF, 0xDA, 0xAF, 0xDA, 0xAF, 0xDA,
+		0xAF, 0xDA, 0xB3, 0xDA, 0xB3, 0xDA, 0xB3, 0xDA,
+		0xB3, 0xDA, 0xB1, 0xDA, 0xB1, 0xDA, 0xB1, 0xDA,
+		0xB1, 0xDA, 0xBA, 0xDA, 0xBA, 0xDA, 0xBB, 0xDA,
+		0xBB, 0xDA, 0xBB, 0xDA, 0xBB, 0xDB, 0x95, 0xD9,
+		0x94, 0xDB, 0x95, 0xD9, 0x94, 0xDB, 0x81, 0xDB,
+		0x81, 0xDB, 0x81, 0xDB, 0x81, 0xDA, 0xBE, 0xDA,
+		0xBE, 0xDA, 0xBE, 0xDA, 0xBE, 0xDB, 0x92, 0xDB,
+		0x92, 0xDB, 0x92, 0xD9, 0x94, 0xDB, 0x92, 0xD9,
+		0x94, 0xDA, 0xAD, 0xDA, 0xAD, 0xDA, 0xAD, 0xDA,
+		0xAD, 0xDB, 0x87, 0xDB, 0x87, 0xDB, 0x86, 0xDB,
+		0x86, 0xDB, 0x88, 0xDB, 0x88, 0xDB, 0x87, 0xD9,
+		0xB4, 0xDB, 0x8B, 0xDB, 0x8B, 0xDB, 0x85, 0xDB,
+		0x85, 0xDB, 0x89, 0xDB, 0x89, 0xDB, 0x90, 0xDB,
+		0x90, 0xDB, 0x90, 0xDB, 0x90, 0xD9, 0x89, 0xD9,
+		0x89, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xA7, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD8, 0xA7, 0xD9, 0x8A, 0xD9,
+		0x94, 0xDB, 0x95, 0xD9, 0x8A, 0xD9, 0x94, 0xDB,
+		0x95, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x88, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD9, 0x88, 0xD9, 0x8A, 0xD9,
+		0x94, 0xDB, 0x87, 0xD9, 0x8A, 0xD9, 0x94, 0xDB,
+		0x87, 0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x86, 0xD9,
+		0x8A, 0xD9, 0x94, 0xDB, 0x86, 0xD9, 0x8A, 0xD9,
+		0x94, 0xDB, 0x88, 0xD9, 0x8A, 0xD9, 0x94, 0xDB,
+		0x88, 0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x90, 0xD9,
+		0x8A, 0xD9, 0x94, 0xDB, 0x90, 0xD9, 0x8A, 0xD9,
+		0x94, 0xDB, 0x90, 0xD9, 0x8A, 0xD9, 0x94, 0xD9,
+		0x89, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x89, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD9, 0x89, 0xDB, 0x8C, 0xDB,
+		0x8C, 0xDB, 0x8C, 0xDB, 0x8C, 0xD9, 0x8A, 0xD9,
+		0x94, 0xD8, 0xAC, 0xD9, 0x8A, 0xD9, 0x94, 0xD8,
+		0xAD, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x85, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD9, 0x89, 0xD9, 0x8A, 0xD9,
+		0x94, 0xD9, 0x8A, 0xD8, 0xA8, 0xD8, 0xAC, 0xD8,
+		0xA8, 0xD8, 0xAD, 0xD8, 0xA8, 0xD8, 0xAE, 0xD8,
+		0xA8, 0xD9, 0x85, 0xD8, 0xA8, 0xD9, 0x89, 0xD8,
+		0xA8, 0xD9, 0x8A, 0xD8, 0xAA, 0xD8, 0xAC, 0xD8,
+		0xAA, 0xD8, 0xAD, 0xD8, 0xAA, 0xD8, 0xAE, 0xD8,
+		0xAA, 0xD9, 0x85, 0xD8, 0xAA, 0xD9, 0x89, 0xD8,
+		0xAA, 0xD9, 0x8A, 0xD8, 0xAB, 0xD8, 0xAC, 0xD8,
+		0xAB, 0xD9, 0x85, 0xD8, 0xAB, 0xD9, 0x89, 0xD8,
+		0xAB, 0xD9, 0x8A, 0xD8, 0xAC, 0xD8, 0xAD, 0xD8,
+		0xAC, 0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xAC, 0xD8,
+		0xAD, 0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xAC, 0xD8,
+		0xAE, 0xD8, 0xAD, 0xD8, 0xAE, 0xD9, 0x85, 0xD8,
+		0xB3, 0xD8, 0xAC, 0xD8, 0xB3, 0xD8, 0xAD, 0xD8,
+		0xB3, 0xD8, 0xAE, 0xD8, 0xB3, 0xD9, 0x85, 0xD8,
+		0xB5, 0xD8, 0xAD, 0xD8, 0xB5, 0xD9, 0x85, 0xD8,
+		0xB6, 0xD8, 0xAC, 0xD8, 0xB6, 0xD8, 0xAD, 0xD8,
+		0xB6, 0xD8, 0xAE, 0xD8, 0xB6, 0xD9, 0x85, 0xD8,
+		0xB7, 0xD8, 0xAD, 0xD8, 0xB7, 0xD9, 0x85, 0xD8,
+		0xB8, 0xD9, 0x85, 0xD8, 0xB9, 0xD8, 0xAC, 0xD8,
+		0xB9, 0xD9, 0x85, 0xD8, 0xBA, 0xD8, 0xAC, 0xD8,
+		0xBA, 0xD9, 0x85, 0xD9, 0x81, 0xD8, 0xAC, 0xD9,
+		0x81, 0xD8, 0xAD, 0xD9, 0x81, 0xD8, 0xAE, 0xD9,
+		0x81, 0xD9, 0x85, 0xD9, 0x81, 0xD9, 0x89, 0xD9,
+		0x81, 0xD9, 0x8A, 0xD9, 0x82, 0xD8, 0xAD, 0xD9,
+		0x82, 0xD9, 0x85, 0xD9, 0x82, 0xD9, 0x89, 0xD9,
+		0x82, 0xD9, 0x8A, 0xD9, 0x83, 0xD8, 0xA7, 0xD9,
+		0x83, 0xD8, 0xAC, 0xD9, 0x83, 0xD8, 0xAD, 0xD9,
+		0x83, 0xD8, 0xAE, 0xD9, 0x83, 0xD9, 0x84, 0xD9,
+		0x83, 0xD9, 0x85, 0xD9, 0x83, 0xD9, 0x89, 0xD9,
+		0x83, 0xD9, 0x8A, 0xD9, 0x84, 0xD8, 0xAC, 0xD9,
+		0x84, 0xD8, 0xAD, 0xD9, 0x84, 0xD8, 0xAE, 0xD9,
+		0x84, 0xD9, 0x85, 0xD9, 0x84, 0xD9, 0x89, 0xD9,
+		0x84, 0xD9, 0x8A, 0xD9, 0x85, 0xD8, 0xAC, 0xD9,
+		0x85, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAE, 0xD9,
+		0x85, 0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x89, 0xD9,
+		0x85, 0xD9, 0x8A, 0xD9, 0x86, 0xD8, 0xAC, 0xD9,
+		0x86, 0xD8, 0xAD, 0xD9, 0x86, 0xD8, 0xAE, 0xD9,
+		0x86, 0xD9, 0x85, 0xD9, 0x86, 0xD9, 0x89, 0xD9,
+		0x86, 0xD9, 0x8A, 0xD9, 0x87, 0xD8, 0xAC, 0xD9,
+		0x87, 0xD9, 0x85, 0xD9, 0x87, 0xD9, 0x89, 0xD9,
+		0x87, 0xD9, 0x8A, 0xD9, 0x8A, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD8, 0xAD, 0xD9, 0x8A, 0xD8, 0xAE, 0xD9,
+		0x8A, 0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x89, 0xD9,
+		0x8A, 0xD9, 0x8A, 0xD8, 0xB0, 0xD9, 0xB0, 0xD8,
+		0xB1, 0xD9, 0xB0, 0xD9, 0x89, 0xD9, 0xB0, 0x20,
+		0xD9, 0x8C, 0xD9, 0x91, 0x20, 0xD9, 0x8D, 0xD9,
+		0x91, 0x20, 0xD9, 0x8E, 0xD9, 0x91, 0x20, 0xD9,
+		0x8F, 0xD9, 0x91, 0x20, 0xD9, 0x90, 0xD9, 0x91,
+		0x20, 0xD9, 0x91, 0xD9, 0xB0, 0xD9, 0x8A, 0xD9,
+		0x94, 0xD8, 0xB1, 0xD9, 0x8A, 0xD9, 0x94, 0xD8,
+		0xB2, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x85, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD9, 0x86, 0xD9, 0x8A, 0xD9,
+		0x94, 0xD9, 0x89, 0xD9, 0x8A, 0xD9, 0x94, 0xD9,
+		0x8A, 0xD8, 0xA8, 0xD8, 0xB1, 0xD8, 0xA8, 0xD8,
+		0xB2, 0xD8, 0xA8, 0xD9, 0x85, 0xD8, 0xA8, 0xD9,
+		0x86, 0xD8, 0xA8, 0xD9, 0x89, 0xD8, 0xA8, 0xD9,
+		0x8A, 0xD8, 0xAA, 0xD8, 0xB1, 0xD8, 0xAA, 0xD8,
+		0xB2, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAA, 0xD9,
+		0x86, 0xD8, 0xAA, 0xD9, 0x89, 0xD8, 0xAA, 0xD9,
+		0x8A, 0xD8, 0xAB, 0xD8, 0xB1, 0xD8, 0xAB, 0xD8,
+		0xB2, 0xD8, 0xAB, 0xD9, 0x85, 0xD8, 0xAB, 0xD9,
+		0x86, 0xD8, 0xAB, 0xD9, 0x89, 0xD8, 0xAB, 0xD9,
+		0x8A, 0xD9, 0x81, 0xD9, 0x89, 0xD9, 0x81, 0xD9,
+		0x8A, 0xD9, 0x82, 0xD9, 0x89, 0xD9, 0x82, 0xD9,
+		0x8A, 0xD9, 0x83, 0xD8, 0xA7, 0xD9, 0x83, 0xD9,
+		0x84, 0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x83, 0xD9,
+		0x89, 0xD9, 0x83, 0xD9, 0x8A, 0xD9, 0x84, 0xD9,
+		0x85, 0xD9, 0x84, 0xD9, 0x89, 0xD9, 0x84, 0xD9,
+		0x8A, 0xD9, 0x85, 0xD8, 0xA7, 0xD9, 0x85, 0xD9,
+		0x85, 0xD9, 0x86, 0xD8, 0xB1, 0xD9, 0x86, 0xD8,
+		0xB2, 0xD9, 0x86, 0xD9, 0x85, 0xD9, 0x86, 0xD9,
+		0x86, 0xD9, 0x86, 0xD9, 0x89, 0xD9, 0x86, 0xD9,
+		0x8A, 0xD9, 0x89, 0xD9, 0xB0, 0xD9, 0x8A, 0xD8,
+		0xB1, 0xD9, 0x8A, 0xD8, 0xB2, 0xD9, 0x8A, 0xD9,
+		0x85, 0xD9, 0x8A, 0xD9, 0x86, 0xD9, 0x8A, 0xD9,
+		0x89, 0xD9, 0x8A, 0xD9, 0x8A, 0xD9, 0x8A, 0xD9,
+		0x94, 0xD8, 0xAC, 0xD9, 0x8A, 0xD9, 0x94, 0xD8,
+		0xAD, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAE, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD9, 0x85, 0xD9, 0x8A, 0xD9,
+		0x94, 0xD9, 0x87, 0xD8, 0xA8, 0xD8, 0xAC, 0xD8,
+		0xA8, 0xD8, 0xAD, 0xD8, 0xA8, 0xD8, 0xAE, 0xD8,
+		0xA8, 0xD9, 0x85, 0xD8, 0xA8, 0xD9, 0x87, 0xD8,
+		0xAA, 0xD8, 0xAC, 0xD8, 0xAA, 0xD8, 0xAD, 0xD8,
+		0xAA, 0xD8, 0xAE, 0xD8, 0xAA, 0xD9, 0x85, 0xD8,
+		0xAA, 0xD9, 0x87, 0xD8, 0xAB, 0xD9, 0x85, 0xD8,
+		0xAC, 0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x85, 0xD8,
+		0xAD, 0xD8, 0xAC, 0xD8, 0xAD, 0xD9, 0x85, 0xD8,
+		0xAE, 0xD8, 0xAC, 0xD8, 0xAE, 0xD9, 0x85, 0xD8,
+		0xB3, 0xD8, 0xAC, 0xD8, 0xB3, 0xD8, 0xAD, 0xD8,
+		0xB3, 0xD8, 0xAE, 0xD8, 0xB3, 0xD9, 0x85, 0xD8,
+		0xB5, 0xD8, 0xAD, 0xD8, 0xB5, 0xD8, 0xAE, 0xD8,
+		0xB5, 0xD9, 0x85, 0xD8, 0xB6, 0xD8, 0xAC, 0xD8,
+		0xB6, 0xD8, 0xAD, 0xD8, 0xB6, 0xD8, 0xAE, 0xD8,
+		0xB6, 0xD9, 0x85, 0xD8, 0xB7, 0xD8, 0xAD, 0xD8,
+		0xB8, 0xD9, 0x85, 0xD8, 0xB9, 0xD8, 0xAC, 0xD8,
+		0xB9, 0xD9, 0x85, 0xD8, 0xBA, 0xD8, 0xAC, 0xD8,
+		0xBA, 0xD9, 0x85, 0xD9, 0x81, 0xD8, 0xAC, 0xD9,
+		0x81, 0xD8, 0xAD, 0xD9, 0x81, 0xD8, 0xAE, 0xD9,
+		0x81, 0xD9, 0x85, 0xD9, 0x82, 0xD8, 0xAD, 0xD9,
+		0x82, 0xD9, 0x85, 0xD9, 0x83, 0xD8, 0xAC, 0xD9,
+		0x83, 0xD8, 0xAD, 0xD9, 0x83, 0xD8, 0xAE, 0xD9,
+		0x83, 0xD9, 0x84, 0xD9, 0x83, 0xD9, 0x85, 0xD9,
+		0x84, 0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xAD, 0xD9,
+		0x84, 0xD8, 0xAE, 0xD9, 0x84, 0xD9, 0x85, 0xD9,
+		0x84, 0xD9, 0x87, 0xD9, 0x85, 0xD8, 0xAC, 0xD9,
+		0x85, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAE, 0xD9,
+		0x85, 0xD9, 0x85, 0xD9, 0x86, 0xD8, 0xAC, 0xD9,
+		0x86, 0xD8, 0xAD, 0xD9, 0x86, 0xD8, 0xAE, 0xD9,
+		0x86, 0xD9, 0x85, 0xD9, 0x86, 0xD9, 0x87, 0xD9,
+		0x87, 0xD8, 0xAC, 0xD9, 0x87, 0xD9, 0x85, 0xD9,
+		0x87, 0xD9, 0xB0, 0xD9, 0x8A, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD8, 0xAD, 0xD9, 0x8A, 0xD8, 0xAE, 0xD9,
+		0x8A, 0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x87, 0xD9,
+		0x8A, 0xD9, 0x94, 0xD9, 0x85, 0xD9, 0x8A, 0xD9,
+		0x94, 0xD9, 0x87, 0xD8, 0xA8, 0xD9, 0x85, 0xD8,
+		0xA8, 0xD9, 0x87, 0xD8, 0xAA, 0xD9, 0x85, 0xD8,
+		0xAA, 0xD9, 0x87, 0xD8, 0xAB, 0xD9, 0x85, 0xD8,
+		0xAB, 0xD9, 0x87, 0xD8, 0xB3, 0xD9, 0x85, 0xD8,
+		0xB3, 0xD9, 0x87, 0xD8, 0xB4, 0xD9, 0x85, 0xD8,
+		0xB4, 0xD9, 0x87, 0xD9, 0x83, 0xD9, 0x84, 0xD9,
+		0x83, 0xD9, 0x85, 0xD9, 0x84, 0xD9, 0x85, 0xD9,
+		0x86, 0xD9, 0x85, 0xD9, 0x86, 0xD9, 0x87, 0xD9,
+		0x8A, 0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x87, 0xD9,
+		0x80, 0xD9, 0x8E, 0xD9, 0x91, 0xD9, 0x80, 0xD9,
+		0x8F, 0xD9, 0x91, 0xD9, 0x80, 0xD9, 0x90, 0xD9,
+		0x91, 0xD8, 0xB7, 0xD9, 0x89, 0xD8, 0xB7, 0xD9,
+		0x8A, 0xD8, 0xB9, 0xD9, 0x89, 0xD8, 0xB9, 0xD9,
+		0x8A, 0xD8, 0xBA, 0xD9, 0x89, 0xD8, 0xBA, 0xD9,
+		0x8A, 0xD8, 0xB3, 0xD9, 0x89, 0xD8, 0xB3, 0xD9,
+		0x8A, 0xD8, 0xB4, 0xD9, 0x89, 0xD8, 0xB4, 0xD9,
+		0x8A, 0xD8, 0xAD, 0xD9, 0x89, 0xD8, 0xAD, 0xD9,
+		0x8A, 0xD8, 0xAC, 0xD9, 0x89, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD8, 0xAE, 0xD9, 0x89, 0xD8, 0xAE, 0xD9,
+		0x8A, 0xD8, 0xB5, 0xD9, 0x89, 0xD8, 0xB5, 0xD9,
+		0x8A, 0xD8, 0xB6, 0xD9, 0x89, 0xD8, 0xB6, 0xD9,
+		0x8A, 0xD8, 0xB4, 0xD8, 0xAC, 0xD8, 0xB4, 0xD8,
+		0xAD, 0xD8, 0xB4, 0xD8, 0xAE, 0xD8, 0xB4, 0xD9,
+		0x85, 0xD8, 0xB4, 0xD8, 0xB1, 0xD8, 0xB3, 0xD8,
+		0xB1, 0xD8, 0xB5, 0xD8, 0xB1, 0xD8, 0xB6, 0xD8,
+		0xB1, 0xD8, 0xB7, 0xD9, 0x89, 0xD8, 0xB7, 0xD9,
+		0x8A, 0xD8, 0xB9, 0xD9, 0x89, 0xD8, 0xB9, 0xD9,
+		0x8A, 0xD8, 0xBA, 0xD9, 0x89, 0xD8, 0xBA, 0xD9,
+		0x8A, 0xD8, 0xB3, 0xD9, 0x89, 0xD8, 0xB3, 0xD9,
+		0x8A, 0xD8, 0xB4, 0xD9, 0x89, 0xD8, 0xB4, 0xD9,
+		0x8A, 0xD8, 0xAD, 0xD9, 0x89, 0xD8, 0xAD, 0xD9,
+		0x8A, 0xD8, 0xAC, 0xD9, 0x89, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD8, 0xAE, 0xD9, 0x89, 0xD8, 0xAE, 0xD9,
+		0x8A, 0xD8, 0xB5, 0xD9, 0x89, 0xD8, 0xB5, 0xD9,
+		0x8A, 0xD8, 0xB6, 0xD9, 0x89, 0xD8, 0xB6, 0xD9,
+		0x8A, 0xD8, 0xB4, 0xD8, 0xAC, 0xD8, 0xB4, 0xD8,
+		0xAD, 0xD8, 0xB4, 0xD8, 0xAE, 0xD8, 0xB4, 0xD9,
+		0x85, 0xD8, 0xB4, 0xD8, 0xB1, 0xD8, 0xB3, 0xD8,
+		0xB1, 0xD8, 0xB5, 0xD8, 0xB1, 0xD8, 0xB6, 0xD8,
+		0xB1, 0xD8, 0xB4, 0xD8, 0xAC, 0xD8, 0xB4, 0xD8,
+		0xAD, 0xD8, 0xB4, 0xD8, 0xAE, 0xD8, 0xB4, 0xD9,
+		0x85, 0xD8, 0xB3, 0xD9, 0x87, 0xD8, 0xB4, 0xD9,
+		0x87, 0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xB3, 0xD8,
+		0xAC, 0xD8, 0xB3, 0xD8, 0xAD, 0xD8, 0xB3, 0xD8,
+		0xAE, 0xD8, 0xB4, 0xD8, 0xAC, 0xD8, 0xB4, 0xD8,
+		0xAD, 0xD8, 0xB4, 0xD8, 0xAE, 0xD8, 0xB7, 0xD9,
+		0x85, 0xD8, 0xB8, 0xD9, 0x85, 0xD8, 0xA7, 0xD9,
+		0x8B, 0xD8, 0xA7, 0xD9, 0x8B, 0xD8, 0xAA, 0xD8,
+		0xAC, 0xD9, 0x85, 0xD8, 0xAA, 0xD8, 0xAD, 0xD8,
+		0xAC, 0xD8, 0xAA, 0xD8, 0xAD, 0xD8, 0xAC, 0xD8,
+		0xAA, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAA, 0xD8,
+		0xAE, 0xD9, 0x85, 0xD8, 0xAA, 0xD9, 0x85, 0xD8,
+		0xAC, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAD, 0xD8,
+		0xAA, 0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xAC, 0xD9,
+		0x85, 0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x85, 0xD8,
+		0xAD, 0xD8, 0xAD, 0xD9, 0x85, 0xD9, 0x8A, 0xD8,
+		0xAD, 0xD9, 0x85, 0xD9, 0x89, 0xD8, 0xB3, 0xD8,
+		0xAD, 0xD8, 0xAC, 0xD8, 0xB3, 0xD8, 0xAC, 0xD8,
+		0xAD, 0xD8, 0xB3, 0xD8, 0xAC, 0xD9, 0x89, 0xD8,
+		0xB3, 0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xB3, 0xD9,
+		0x85, 0xD8, 0xAD, 0xD8, 0xB3, 0xD9, 0x85, 0xD8,
+		0xAC, 0xD8, 0xB3, 0xD9, 0x85, 0xD9, 0x85, 0xD8,
+		0xB3, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB5, 0xD8,
+		0xAD, 0xD8, 0xAD, 0xD8, 0xB5, 0xD8, 0xAD, 0xD8,
+		0xAD, 0xD8, 0xB5, 0xD9, 0x85, 0xD9, 0x85, 0xD8,
+		0xB4, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xB4, 0xD8,
+		0xAD, 0xD9, 0x85, 0xD8, 0xB4, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD8, 0xB4, 0xD9, 0x85, 0xD8, 0xAE, 0xD8,
+		0xB4, 0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xB4, 0xD9,
+		0x85, 0xD9, 0x85, 0xD8, 0xB4, 0xD9, 0x85, 0xD9,
+		0x85, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9, 0x89, 0xD8,
+		0xB6, 0xD8, 0xAE, 0xD9, 0x85, 0xD8, 0xB6, 0xD8,
+		0xAE, 0xD9, 0x85, 0xD8, 0xB7, 0xD9, 0x85, 0xD8,
+		0xAD, 0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xAD, 0xD8,
+		0xB7, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB7, 0xD9,
+		0x85, 0xD9, 0x8A, 0xD8, 0xB9, 0xD8, 0xAC, 0xD9,
+		0x85, 0xD8, 0xB9, 0xD9, 0x85, 0xD9, 0x85, 0xD8,
+		0xB9, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB9, 0xD9,
+		0x85, 0xD9, 0x89, 0xD8, 0xBA, 0xD9, 0x85, 0xD9,
+		0x85, 0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x8A, 0xD8,
+		0xBA, 0xD9, 0x85, 0xD9, 0x89, 0xD9, 0x81, 0xD8,
+		0xAE, 0xD9, 0x85, 0xD9, 0x81, 0xD8, 0xAE, 0xD9,
+		0x85, 0xD9, 0x82, 0xD9, 0x85, 0xD8, 0xAD, 0xD9,
+		0x82, 0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x84, 0xD8,
+		0xAD, 0xD9, 0x85, 0xD9, 0x84, 0xD8, 0xAD, 0xD9,
+		0x8A, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x89, 0xD9,
+		0x84, 0xD8, 0xAC, 0xD8, 0xAC, 0xD9, 0x84, 0xD8,
+		0xAC, 0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xAE, 0xD9,
+		0x85, 0xD9, 0x84, 0xD8, 0xAE, 0xD9, 0x85, 0xD9,
+		0x84, 0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x84, 0xD9,
+		0x85, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAD, 0xD8,
+		0xAC, 0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x85, 0xD9,
+		0x85, 0xD8, 0xAD, 0xD9, 0x8A, 0xD9, 0x85, 0xD8,
+		0xAC, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAC, 0xD9,
+		0x85, 0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xAC, 0xD9,
+		0x85, 0xD8, 0xAE, 0xD9, 0x85, 0xD9, 0x85, 0xD8,
+		0xAC, 0xD8, 0xAE, 0xD9, 0x87, 0xD9, 0x85, 0xD8,
+		0xAC, 0xD9, 0x87, 0xD9, 0x85, 0xD9, 0x85, 0xD9,
+		0x86, 0xD8, 0xAD, 0xD9, 0x85, 0xD9, 0x86, 0xD8,
+		0xAD, 0xD9, 0x89, 0xD9, 0x86, 0xD8, 0xAC, 0xD9,
+		0x85, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x85, 0xD9,
+		0x86, 0xD8, 0xAC, 0xD9, 0x89, 0xD9, 0x86, 0xD9,
+		0x85, 0xD9, 0x8A, 0xD9, 0x86, 0xD9, 0x85, 0xD9,
+		0x89, 0xD9, 0x8A, 0xD9, 0x85, 0xD9, 0x85, 0xD9,
+		0x8A, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xA8, 0xD8,
+		0xAE, 0xD9, 0x8A, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x89, 0xD8,
+		0xAA, 0xD8, 0xAE, 0xD9, 0x8A, 0xD8, 0xAA, 0xD8,
+		0xAE, 0xD9, 0x89, 0xD8, 0xAA, 0xD9, 0x85, 0xD9,
+		0x8A, 0xD8, 0xAA, 0xD9, 0x85, 0xD9, 0x89, 0xD8,
+		0xAC, 0xD9, 0x85, 0xD9, 0x8A, 0xD8, 0xAC, 0xD8,
+		0xAD, 0xD9, 0x89, 0xD8, 0xAC, 0xD9, 0x85, 0xD9,
+		0x89, 0xD8, 0xB3, 0xD8, 0xAE, 0xD9, 0x89, 0xD8,
+		0xB5, 0xD8, 0xAD, 0xD9, 0x8A, 0xD8, 0xB4, 0xD8,
+		0xAD, 0xD9, 0x8A, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9,
+		0x8A, 0xD9, 0x84, 0xD8, 0xAC, 0xD9, 0x8A, 0xD9,
+		0x84, 0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x8A, 0xD8,
+		0xAD, 0xD9, 0x8A, 0xD9, 0x8A, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD9, 0x8A, 0xD9, 0x85, 0xD9, 0x8A, 0xD9,
+		0x85, 0xD9, 0x85, 0xD9, 0x8A, 0xD9, 0x82, 0xD9,
+		0x85, 0xD9, 0x8A, 0xD9, 0x86, 0xD8, 0xAD, 0xD9,
+		0x8A, 0xD9, 0x82, 0xD9, 0x85, 0xD8, 0xAD, 0xD9,
+		0x84, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xB9, 0xD9,
+		0x85, 0xD9, 0x8A, 0xD9, 0x83, 0xD9, 0x85, 0xD9,
+		0x8A, 0xD9, 0x86, 0xD8, 0xAC, 0xD8, 0xAD, 0xD9,
+		0x85, 0xD8, 0xAE, 0xD9, 0x8A, 0xD9, 0x84, 0xD8,
+		0xAC, 0xD9, 0x85, 0xD9, 0x83, 0xD9, 0x85, 0xD9,
+		0x85, 0xD9, 0x84, 0xD8, 0xAC, 0xD9, 0x85, 0xD9,
+		0x86, 0xD8, 0xAC, 0xD8, 0xAD, 0xD8, 0xAC, 0xD8,
+		0xAD, 0xD9, 0x8A, 0xD8, 0xAD, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x8A, 0xD9,
+		0x81, 0xD9, 0x85, 0xD9, 0x8A, 0xD8, 0xA8, 0xD8,
+		0xAD, 0xD9, 0x8A, 0xD9, 0x83, 0xD9, 0x85, 0xD9,
+		0x85, 0xD8, 0xB9, 0xD8, 0xAC, 0xD9, 0x85, 0xD8,
+		0xB5, 0xD9, 0x85, 0xD9, 0x85, 0xD8, 0xB3, 0xD8,
+		0xAE, 0xD9, 0x8A, 0xD9, 0x86, 0xD8, 0xAC, 0xD9,
+		0x8A, 0xD8, 0xB5, 0xD9, 0x84, 0xDB, 0x92, 0xD9,
+		0x82, 0xD9, 0x84, 0xDB, 0x92, 0xD8, 0xA7, 0xD9,
+		0x84, 0xD9, 0x84, 0xD9, 0x87, 0xD8, 0xA7, 0xD9,
+		0x83, 0xD8, 0xA8, 0xD8, 0xB1, 0xD9, 0x85, 0xD8,
+		0xAD, 0xD9, 0x85, 0xD8, 0xAF, 0xD8, 0xB5, 0xD9,
+		0x84, 0xD8, 0xB9, 0xD9, 0x85, 0xD8, 0xB1, 0xD8,
+		0xB3, 0xD9, 0x88, 0xD9, 0x84, 0xD8, 0xB9, 0xD9,
+		0x84, 0xD9, 0x8A, 0xD9, 0x87, 0xD9, 0x88, 0xD8,
+		0xB3, 0xD9, 0x84, 0xD9, 0x85, 0xD8, 0xB5, 0xD9,
+		0x84, 0xD9, 0x89, 0xD8, 0xB5, 0xD9, 0x84, 0xD9,
+		0x89, 0x20, 0xD8, 0xA7, 0xD9, 0x84, 0xD9, 0x84,
+		0xD9, 0x87, 0x20, 0xD8, 0xB9, 0xD9, 0x84, 0xD9,
+		0x8A, 0xD9, 0x87, 0x20, 0xD9, 0x88, 0xD8, 0xB3,
+		0xD9, 0x84, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x84,
+		0x20, 0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xA7, 0xD9,
+		0x84, 0xD9, 0x87, 0xD8, 0xB1, 0xDB, 0x8C, 0xD8,
+		0xA7, 0xD9, 0x84, 0x2C, 0xE3, 0x80, 0x81, 0xE3,
+		0x80, 0x82, 0x3A, 0x3B, 0x21, 0x3F, 0xE3, 0x80,
+		0x96, 0xE3, 0x80, 0x97, 0x2E, 0x2E, 0x2E, 0x2E,
+		0x2E, 0xE2, 0x80, 0x94, 0xE2, 0x80, 0x93, 0x5F,
+		0x5F, 0x28, 0x29, 0x7B, 0x7D, 0xE3, 0x80, 0x94,
+		0xE3, 0x80, 0x95, 0xE3, 0x80, 0x90, 0xE3, 0x80,
+		0x91, 0xE3, 0x80, 0x8A, 0xE3, 0x80, 0x8B, 0xE3,
+		0x80, 0x88, 0xE3, 0x80, 0x89, 0xE3, 0x80, 0x8C,
+		0xE3, 0x80, 0x8D, 0xE3, 0x80, 0x8E, 0xE3, 0x80,
+		0x8F, 0x5B, 0x5D, 0x20, 0xCC, 0x85, 0x20, 0xCC,
+		0x85, 0x20, 0xCC, 0x85, 0x20, 0xCC, 0x85, 0x5F,
+		0x5F, 0x5F, 0x2C, 0xE3, 0x80, 0x81, 0x2E, 0x3B,
+		0x3A, 0x3F, 0x21, 0xE2, 0x80, 0x94, 0x28, 0x29,
+		0x7B, 0x7D, 0xE3, 0x80, 0x94, 0xE3, 0x80, 0x95,
+		0x23, 0x26, 0x2A, 0x2B, 0x2D, 0x3C, 0x3E, 0x3D,
+		0x5C, 0x24, 0x25, 0x40, 0x20, 0xD9, 0x8B, 0xD9,
+		0x80, 0xD9, 0x8B, 0x20, 0xD9, 0x8C, 0x20, 0xD9,
+		0x8D, 0x20, 0xD9, 0x8E, 0xD9, 0x80, 0xD9, 0x8E,
+		0x20, 0xD9, 0x8F, 0xD9, 0x80, 0xD9, 0x8F, 0x20,
+		0xD9, 0x90, 0xD9, 0x80, 0xD9, 0x90, 0x20, 0xD9,
+		0x91, 0xD9, 0x80, 0xD9, 0x91, 0x20, 0xD9, 0x92,
+		0xD9, 0x80, 0xD9, 0x92, 0xD8, 0xA1, 0xD8, 0xA7,
+		0xD9, 0x93, 0xD8, 0xA7, 0xD9, 0x93, 0xD8, 0xA7,
+		0xD9, 0x94, 0xD8, 0xA7, 0xD9, 0x94, 0xD9, 0x88,
+		0xD9, 0x94, 0xD9, 0x88, 0xD9, 0x94, 0xD8, 0xA7,
+		0xD9, 0x95, 0xD8, 0xA7, 0xD9, 0x95, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x8A,
+		0xD9, 0x94, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xA7,
+		0xD8, 0xA7, 0xD8, 0xA8, 0xD8, 0xA8, 0xD8, 0xA8,
+		0xD8, 0xA8, 0xD8, 0xA9, 0xD8, 0xA9, 0xD8, 0xAA,
+		0xD8, 0xAA, 0xD8, 0xAA, 0xD8, 0xAA, 0xD8, 0xAB,
+		0xD8, 0xAB, 0xD8, 0xAB, 0xD8, 0xAB, 0xD8, 0xAC,
+		0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xAD,
+		0xD8, 0xAD, 0xD8, 0xAD, 0xD8, 0xAD, 0xD8, 0xAE,
+		0xD8, 0xAE, 0xD8, 0xAE, 0xD8, 0xAE, 0xD8, 0xAF,
+		0xD8, 0xAF, 0xD8, 0xB0, 0xD8, 0xB0, 0xD8, 0xB1,
+		0xD8, 0xB1, 0xD8, 0xB2, 0xD8, 0xB2, 0xD8, 0xB3,
+		0xD8, 0xB3, 0xD8, 0xB3, 0xD8, 0xB3, 0xD8, 0xB4,
+		0xD8, 0xB4, 0xD8, 0xB4, 0xD8, 0xB4, 0xD8, 0xB5,
+		0xD8, 0xB5, 0xD8, 0xB5, 0xD8, 0xB5, 0xD8, 0xB6,
+		0xD8, 0xB6, 0xD8, 0xB6, 0xD8, 0xB6, 0xD8, 0xB7,
+		0xD8, 0xB7, 0xD8, 0xB7, 0xD8, 0xB7, 0xD8, 0xB8,
+		0xD8, 0xB8, 0xD8, 0xB8, 0xD8, 0xB8, 0xD8, 0xB9,
+		0xD8, 0xB9, 0xD8, 0xB9, 0xD8, 0xB9, 0xD8, 0xBA,
+		0xD8, 0xBA, 0xD8, 0xBA, 0xD8, 0xBA, 0xD9, 0x81,
+		0xD9, 0x81, 0xD9, 0x81, 0xD9, 0x81, 0xD9, 0x82,
+		0xD9, 0x82, 0xD9, 0x82, 0xD9, 0x82, 0xD9, 0x83,
+		0xD9, 0x83, 0xD9, 0x83, 0xD9, 0x83, 0xD9, 0x84,
+		0xD9, 0x84, 0xD9, 0x84, 0xD9, 0x84, 0xD9, 0x85,
+		0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x85, 0xD9, 0x86,
+		0xD9, 0x86, 0xD9, 0x86, 0xD9, 0x86, 0xD9, 0x87,
+		0xD9, 0x87, 0xD9, 0x87, 0xD9, 0x87, 0xD9, 0x88,
+		0xD9, 0x88, 0xD9, 0x89, 0xD9, 0x89, 0xD9, 0x8A,
+		0xD9, 0x8A, 0xD9, 0x8A, 0xD9, 0x8A, 0xD9, 0x84,
+		0xD8, 0xA7, 0xD9, 0x93, 0xD9, 0x84, 0xD8, 0xA7,
+		0xD9, 0x93, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x94,
+		0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x94, 0xD9, 0x84,
+		0xD8, 0xA7, 0xD9, 0x95, 0xD9, 0x84, 0xD8, 0xA7,
+		0xD9, 0x95, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x84,
+		0xD8, 0xA7, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
+		0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E,
+		0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+		0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E,
+		0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+		0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E,
+		0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
+		0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E,
+		0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+		0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
+		0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
+		0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		0xE2, 0xA6, 0x85, 0xE2, 0xA6, 0x86, 0xE3, 0x80,
+		0x82, 0xE3, 0x80, 0x8C, 0xE3, 0x80, 0x8D, 0xE3,
+		0x80, 0x81, 0xE3, 0x83, 0xBB, 0xE3, 0x83, 0xB2,
+		0xE3, 0x82, 0xA1, 0xE3, 0x82, 0xA3, 0xE3, 0x82,
+		0xA5, 0xE3, 0x82, 0xA7, 0xE3, 0x82, 0xA9, 0xE3,
+		0x83, 0xA3, 0xE3, 0x83, 0xA5, 0xE3, 0x83, 0xA7,
+		0xE3, 0x83, 0x83, 0xE3, 0x83, 0xBC, 0xE3, 0x82,
+		0xA2, 0xE3, 0x82, 0xA4, 0xE3, 0x82, 0xA6, 0xE3,
+		0x82, 0xA8, 0xE3, 0x82, 0xAA, 0xE3, 0x82, 0xAB,
+		0xE3, 0x82, 0xAD, 0xE3, 0x82, 0xAF, 0xE3, 0x82,
+		0xB1, 0xE3, 0x82, 0xB3, 0xE3, 0x82, 0xB5, 0xE3,
+		0x82, 0xB7, 0xE3, 0x82, 0xB9, 0xE3, 0x82, 0xBB,
+		0xE3, 0x82, 0xBD, 0xE3, 0x82, 0xBF, 0xE3, 0x83,
+		0x81, 0xE3, 0x83, 0x84, 0xE3, 0x83, 0x86, 0xE3,
+		0x83, 0x88, 0xE3, 0x83, 0x8A, 0xE3, 0x83, 0x8B,
+		0xE3, 0x83, 0x8C, 0xE3, 0x83, 0x8D, 0xE3, 0x83,
+		0x8E, 0xE3, 0x83, 0x8F, 0xE3, 0x83, 0x92, 0xE3,
+		0x83, 0x95, 0xE3, 0x83, 0x98, 0xE3, 0x83, 0x9B,
+		0xE3, 0x83, 0x9E, 0xE3, 0x83, 0x9F, 0xE3, 0x83,
+		0xA0, 0xE3, 0x83, 0xA1, 0xE3, 0x83, 0xA2, 0xE3,
+		0x83, 0xA4, 0xE3, 0x83, 0xA6, 0xE3, 0x83, 0xA8,
+		0xE3, 0x83, 0xA9, 0xE3, 0x83, 0xAA, 0xE3, 0x83,
+		0xAB, 0xE3, 0x83, 0xAC, 0xE3, 0x83, 0xAD, 0xE3,
+		0x83, 0xAF, 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0x99,
+		0xE3, 0x82, 0x9A, 0xE1, 0x85, 0xA0, 0xE1, 0x84,
+		0x80, 0xE1, 0x84, 0x81, 0xE1, 0x86, 0xAA, 0xE1,
+		0x84, 0x82, 0xE1, 0x86, 0xAC, 0xE1, 0x86, 0xAD,
+		0xE1, 0x84, 0x83, 0xE1, 0x84, 0x84, 0xE1, 0x84,
+		0x85, 0xE1, 0x86, 0xB0, 0xE1, 0x86, 0xB1, 0xE1,
+		0x86, 0xB2, 0xE1, 0x86, 0xB3, 0xE1, 0x86, 0xB4,
+		0xE1, 0x86, 0xB5, 0xE1, 0x84, 0x9A, 0xE1, 0x84,
+		0x86, 0xE1, 0x84, 0x87, 0xE1, 0x84, 0x88, 0xE1,
+		0x84, 0xA1, 0xE1, 0x84, 0x89, 0xE1, 0x84, 0x8A,
+		0xE1, 0x84, 0x8B, 0xE1, 0x84, 0x8C, 0xE1, 0x84,
+		0x8D, 0xE1, 0x84, 0x8E, 0xE1, 0x84, 0x8F, 0xE1,
+		0x84, 0x90, 0xE1, 0x84, 0x91, 0xE1, 0x84, 0x92,
+		0xE1, 0x85, 0xA1, 0xE1, 0x85, 0xA2, 0xE1, 0x85,
+		0xA3, 0xE1, 0x85, 0xA4, 0xE1, 0x85, 0xA5, 0xE1,
+		0x85, 0xA6, 0xE1, 0x85, 0xA7, 0xE1, 0x85, 0xA8,
+		0xE1, 0x85, 0xA9, 0xE1, 0x85, 0xAA, 0xE1, 0x85,
+		0xAB, 0xE1, 0x85, 0xAC, 0xE1, 0x85, 0xAD, 0xE1,
+		0x85, 0xAE, 0xE1, 0x85, 0xAF, 0xE1, 0x85, 0xB0,
+		0xE1, 0x85, 0xB1, 0xE1, 0x85, 0xB2, 0xE1, 0x85,
+		0xB3, 0xE1, 0x85, 0xB4, 0xE1, 0x85, 0xB5, 0xC2,
+		0xA2, 0xC2, 0xA3, 0xC2, 0xAC, 0x20, 0xCC, 0x84,
+		0xC2, 0xA6, 0xC2, 0xA5, 0xE2, 0x82, 0xA9, 0xE2,
+		0x94, 0x82, 0xE2, 0x86, 0x90, 0xE2, 0x86, 0x91,
+		0xE2, 0x86, 0x92, 0xE2, 0x86, 0x93, 0xE2, 0x96,
+		0xA0, 0xE2, 0x97, 0x8B, 0xF6, 0xF0, 0x9D, 0x85,
+		0x97, 0xF0, 0x9D, 0x85, 0xA5, 0xF6, 0xF0, 0x9D,
+		0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF6, 0xF0,
+		0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+		0x9D, 0x85, 0xAE, 0xF6, 0xF0, 0x9D, 0x85, 0x98,
+		0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAF,
+		0xF6, 0xF0, 0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85,
+		0xA5, 0xF0, 0x9D, 0x85, 0xB0, 0xF6, 0xF0, 0x9D,
+		0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D,
+		0x85, 0xB1, 0xF6, 0xF0, 0x9D, 0x85, 0x98, 0xF0,
+		0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xB2, 0xF6,
+		0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85, 0xA5,
+		0xF6, 0xF0, 0x9D, 0x86, 0xBA, 0xF0, 0x9D, 0x85,
+		0xA5, 0xF6, 0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D,
+		0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xF6, 0xF0,
+		0x9D, 0x86, 0xBA, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+		0x9D, 0x85, 0xAE, 0xF6, 0xF0, 0x9D, 0x86, 0xB9,
+		0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAF,
+		0xF6, 0xF0, 0x9D, 0x86, 0xBA, 0xF0, 0x9D, 0x85,
+		0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
+		0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
+		0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x43, 0x44,
+		0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C,
+		0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
+		0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62,
+		0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
+		0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72,
+		0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
+		0x41, 0x43, 0x44, 0x47, 0x4A, 0x4B, 0x4E, 0x4F,
+		0x50, 0x51, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+		0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x66, 0x68,
+		0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x44,
+		0x45, 0x46, 0x47, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E,
+		0x4F, 0x50, 0x51, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+		0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
+		0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
+		0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x44, 0x45,
+		0x46, 0x47, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4F,
+		0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+		0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65,
+		0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
+		0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+		0x76, 0x77, 0x78, 0x79, 0x7A, 0x41, 0x42, 0x43,
+		0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+		0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+		0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61,
+		0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+		0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+		0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+		0x7A, 0xC4, 0xB1, 0xC8, 0xB7, 0xCE, 0x91, 0xCE,
+		0x92, 0xCE, 0x93, 0xCE, 0x94, 0xCE, 0x95, 0xCE,
+		0x96, 0xCE, 0x97, 0xCE, 0x98, 0xCE, 0x99, 0xCE,
+		0x9A, 0xCE, 0x9B, 0xCE, 0x9C, 0xCE, 0x9D, 0xCE,
+		0x9E, 0xCE, 0x9F, 0xCE, 0xA0, 0xCE, 0xA1, 0xCE,
+		0x98, 0xCE, 0xA3, 0xCE, 0xA4, 0xCE, 0xA5, 0xCE,
+		0xA6, 0xCE, 0xA7, 0xCE, 0xA8, 0xCE, 0xA9, 0xE2,
+		0x88, 0x87, 0xCE, 0xB1, 0xCE, 0xB2, 0xCE, 0xB3,
+		0xCE, 0xB4, 0xCE, 0xB5, 0xCE, 0xB6, 0xCE, 0xB7,
+		0xCE, 0xB8, 0xCE, 0xB9, 0xCE, 0xBA, 0xCE, 0xBB,
+		0xCE, 0xBC, 0xCE, 0xBD, 0xCE, 0xBE, 0xCE, 0xBF,
+		0xCF, 0x80, 0xCF, 0x81, 0xCF, 0x82, 0xCF, 0x83,
+		0xCF, 0x84, 0xCF, 0x85, 0xCF, 0x86, 0xCF, 0x87,
+		0xCF, 0x88, 0xCF, 0x89, 0xE2, 0x88, 0x82, 0xCE,
+		0xB5, 0xCE, 0xB8, 0xCE, 0xBA, 0xCF, 0x86, 0xCF,
+		0x81, 0xCF, 0x80, 0xCE, 0x91, 0xCE, 0x92, 0xCE,
+		0x93, 0xCE, 0x94, 0xCE, 0x95, 0xCE, 0x96, 0xCE,
+		0x97, 0xCE, 0x98, 0xCE, 0x99, 0xCE, 0x9A, 0xCE,
+		0x9B, 0xCE, 0x9C, 0xCE, 0x9D, 0xCE, 0x9E, 0xCE,
+		0x9F, 0xCE, 0xA0, 0xCE, 0xA1, 0xCE, 0x98, 0xCE,
+		0xA3, 0xCE, 0xA4, 0xCE, 0xA5, 0xCE, 0xA6, 0xCE,
+		0xA7, 0xCE, 0xA8, 0xCE, 0xA9, 0xE2, 0x88, 0x87,
+		0xCE, 0xB1, 0xCE, 0xB2, 0xCE, 0xB3, 0xCE, 0xB4,
+		0xCE, 0xB5, 0xCE, 0xB6, 0xCE, 0xB7, 0xCE, 0xB8,
+		0xCE, 0xB9, 0xCE, 0xBA, 0xCE, 0xBB, 0xCE, 0xBC,
+		0xCE, 0xBD, 0xCE, 0xBE, 0xCE, 0xBF, 0xCF, 0x80,
+		0xCF, 0x81, 0xCF, 0x82, 0xCF, 0x83, 0xCF, 0x84,
+		0xCF, 0x85, 0xCF, 0x86, 0xCF, 0x87, 0xCF, 0x88,
+		0xCF, 0x89, 0xE2, 0x88, 0x82, 0xCE, 0xB5, 0xCE,
+		0xB8, 0xCE, 0xBA, 0xCF, 0x86, 0xCF, 0x81, 0xCF,
+		0x80, 0xCE, 0x91, 0xCE, 0x92, 0xCE, 0x93, 0xCE,
+		0x94, 0xCE, 0x95, 0xCE, 0x96, 0xCE, 0x97, 0xCE,
+		0x98, 0xCE, 0x99, 0xCE, 0x9A, 0xCE, 0x9B, 0xCE,
+		0x9C, 0xCE, 0x9D, 0xCE, 0x9E, 0xCE, 0x9F, 0xCE,
+		0xA0, 0xCE, 0xA1, 0xCE, 0x98, 0xCE, 0xA3, 0xCE,
+		0xA4, 0xCE, 0xA5, 0xCE, 0xA6, 0xCE, 0xA7, 0xCE,
+		0xA8, 0xCE, 0xA9, 0xE2, 0x88, 0x87, 0xCE, 0xB1,
+		0xCE, 0xB2, 0xCE, 0xB3, 0xCE, 0xB4, 0xCE, 0xB5,
+		0xCE, 0xB6, 0xCE, 0xB7, 0xCE, 0xB8, 0xCE, 0xB9,
+		0xCE, 0xBA, 0xCE, 0xBB, 0xCE, 0xBC, 0xCE, 0xBD,
+		0xCE, 0xBE, 0xCE, 0xBF, 0xCF, 0x80, 0xCF, 0x81,
+		0xCF, 0x82, 0xCF, 0x83, 0xCF, 0x84, 0xCF, 0x85,
+		0xCF, 0x86, 0xCF, 0x87, 0xCF, 0x88, 0xCF, 0x89,
+		0xE2, 0x88, 0x82, 0xCE, 0xB5, 0xCE, 0xB8, 0xCE,
+		0xBA, 0xCF, 0x86, 0xCF, 0x81, 0xCF, 0x80, 0xCE,
+		0x91, 0xCE, 0x92, 0xCE, 0x93, 0xCE, 0x94, 0xCE,
+		0x95, 0xCE, 0x96, 0xCE, 0x97, 0xCE, 0x98, 0xCE,
+		0x99, 0xCE, 0x9A, 0xCE, 0x9B, 0xCE, 0x9C, 0xCE,
+		0x9D, 0xCE, 0x9E, 0xCE, 0x9F, 0xCE, 0xA0, 0xCE,
+		0xA1, 0xCE, 0x98, 0xCE, 0xA3, 0xCE, 0xA4, 0xCE,
+		0xA5, 0xCE, 0xA6, 0xCE, 0xA7, 0xCE, 0xA8, 0xCE,
+		0xA9, 0xE2, 0x88, 0x87, 0xCE, 0xB1, 0xCE, 0xB2,
+		0xCE, 0xB3, 0xCE, 0xB4, 0xCE, 0xB5, 0xCE, 0xB6,
+		0xCE, 0xB7, 0xCE, 0xB8, 0xCE, 0xB9, 0xCE, 0xBA,
+		0xCE, 0xBB, 0xCE, 0xBC, 0xCE, 0xBD, 0xCE, 0xBE,
+		0xCE, 0xBF, 0xCF, 0x80, 0xCF, 0x81, 0xCF, 0x82,
+		0xCF, 0x83, 0xCF, 0x84, 0xCF, 0x85, 0xCF, 0x86,
+		0xCF, 0x87, 0xCF, 0x88, 0xCF, 0x89, 0xE2, 0x88,
+		0x82, 0xCE, 0xB5, 0xCE, 0xB8, 0xCE, 0xBA, 0xCF,
+		0x86, 0xCF, 0x81, 0xCF, 0x80, 0xCE, 0x91, 0xCE,
+		0x92, 0xCE, 0x93, 0xCE, 0x94, 0xCE, 0x95, 0xCE,
+		0x96, 0xCE, 0x97, 0xCE, 0x98, 0xCE, 0x99, 0xCE,
+		0x9A, 0xCE, 0x9B, 0xCE, 0x9C, 0xCE, 0x9D, 0xCE,
+		0x9E, 0xCE, 0x9F, 0xCE, 0xA0, 0xCE, 0xA1, 0xCE,
+		0x98, 0xCE, 0xA3, 0xCE, 0xA4, 0xCE, 0xA5, 0xCE,
+		0xA6, 0xCE, 0xA7, 0xCE, 0xA8, 0xCE, 0xA9, 0xE2,
+		0x88, 0x87, 0xCE, 0xB1, 0xCE, 0xB2, 0xCE, 0xB3,
+		0xCE, 0xB4, 0xCE, 0xB5, 0xCE, 0xB6, 0xCE, 0xB7,
+		0xCE, 0xB8, 0xCE, 0xB9, 0xCE, 0xBA, 0xCE, 0xBB,
+		0xCE, 0xBC, 0xCE, 0xBD, 0xCE, 0xBE, 0xCE, 0xBF,
+		0xCF, 0x80, 0xCF, 0x81, 0xCF, 0x82, 0xCF, 0x83,
+		0xCF, 0x84, 0xCF, 0x85, 0xCF, 0x86, 0xCF, 0x87,
+		0xCF, 0x88, 0xCF, 0x89, 0xE2, 0x88, 0x82, 0xCE,
+		0xB5, 0xCE, 0xB8, 0xCE, 0xBA, 0xCF, 0x86, 0xCF,
+		0x81, 0xCF, 0x80, 0xCF, 0x9C, 0xCF, 0x9D, 0x30,
+		0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+		0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+		0x37, 0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34,
+		0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0x31, 0x32,
+		0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30,
+		0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+		0x39, 0xF6, 0xE4, 0xB8, 0xBD, 0xF6, 0xE4, 0xB8,
+		0xB8, 0xF6, 0xE4, 0xB9, 0x81, 0xF6, 0xF0, 0xA0,
+		0x84, 0xA2, 0xF6, 0xE4, 0xBD, 0xA0, 0xF6, 0xE4,
+		0xBE, 0xAE, 0xF6, 0xE4, 0xBE, 0xBB, 0xF6, 0xE5,
+		0x80, 0x82, 0xF6, 0xE5, 0x81, 0xBA, 0xF6, 0xE5,
+		0x82, 0x99, 0xF6, 0xE5, 0x83, 0xA7, 0xF6, 0xE5,
+		0x83, 0x8F, 0xF6, 0xE3, 0x92, 0x9E, 0xF6, 0xF0,
+		0xA0, 0x98, 0xBA, 0xF6, 0xE5, 0x85, 0x8D, 0xF6,
+		0xE5, 0x85, 0x94, 0xF6, 0xE5, 0x85, 0xA4, 0xF6,
+		0xE5, 0x85, 0xB7, 0xF6, 0xF0, 0xA0, 0x94, 0x9C,
+		0xF6, 0xE3, 0x92, 0xB9, 0xF6, 0xE5, 0x85, 0xA7,
+		0xF6, 0xE5, 0x86, 0x8D, 0xF6, 0xF0, 0xA0, 0x95,
+		0x8B, 0xF6, 0xE5, 0x86, 0x97, 0xF6, 0xE5, 0x86,
+		0xA4, 0xF6, 0xE4, 0xBB, 0x8C, 0xF6, 0xE5, 0x86,
+		0xAC, 0xF6, 0xE5, 0x86, 0xB5, 0xF6, 0xF0, 0xA9,
+		0x87, 0x9F, 0xF6, 0xE5, 0x87, 0xB5, 0xF6, 0xE5,
+		0x88, 0x83, 0xF6, 0xE3, 0x93, 0x9F, 0xF6, 0xE5,
+		0x88, 0xBB, 0xF6, 0xE5, 0x89, 0x86, 0xF6, 0xE5,
+		0x89, 0xB2, 0xF6, 0xE5, 0x89, 0xB7, 0xF6, 0xE3,
+		0x94, 0x95, 0xF6, 0xE5, 0x8B, 0x87, 0xF6, 0xE5,
+		0x8B, 0x89, 0xF6, 0xE5, 0x8B, 0xA4, 0xF6, 0xE5,
+		0x8B, 0xBA, 0xF6, 0xE5, 0x8C, 0x85, 0xF6, 0xE5,
+		0x8C, 0x86, 0xF6, 0xE5, 0x8C, 0x97, 0xF6, 0xE5,
+		0x8D, 0x89, 0xF6, 0xE5, 0x8D, 0x91, 0xF6, 0xE5,
+		0x8D, 0x9A, 0xF6, 0xE5, 0x8D, 0xB3, 0xF6, 0xE5,
+		0x8D, 0xBD, 0xF6, 0xE5, 0x8D, 0xBF, 0xF6, 0xE5,
+		0x8D, 0xBF, 0xF6, 0xE5, 0x8D, 0xBF, 0xF6, 0xF0,
+		0xA0, 0xA8, 0xAC, 0xF6, 0xE7, 0x81, 0xB0, 0xF6,
+		0xE5, 0x8F, 0x8A, 0xF6, 0xE5, 0x8F, 0x9F, 0xF6,
+		0xF0, 0xA0, 0xAD, 0xA3, 0xF6, 0xE5, 0x8F, 0xAB,
+		0xF6, 0xE5, 0x8F, 0xB1, 0xF6, 0xE5, 0x90, 0x86,
+		0xF6, 0xE5, 0x92, 0x9E, 0xF6, 0xE5, 0x90, 0xB8,
+		0xF6, 0xE5, 0x91, 0x88, 0xF6, 0xE5, 0x91, 0xA8,
+		0xF6, 0xE5, 0x92, 0xA2, 0xF6, 0xE5, 0x93, 0xB6,
+		0xF6, 0xE5, 0x94, 0x90, 0xF6, 0xE5, 0x95, 0x93,
+		0xF6, 0xE5, 0x95, 0xA3, 0xF6, 0xE5, 0x96, 0x84,
+		0xF6, 0xE5, 0x96, 0x84, 0xF6, 0xE5, 0x96, 0x99,
+		0xF6, 0xE5, 0x96, 0xAB, 0xF6, 0xE5, 0x96, 0xB3,
+		0xF6, 0xE5, 0x97, 0x82, 0xF6, 0xE5, 0x9C, 0x96,
+		0xF6, 0xE5, 0x98, 0x86, 0xF6, 0xE5, 0x9C, 0x97,
+		0xF6, 0xE5, 0x99, 0x91, 0xF6, 0xE5, 0x99, 0xB4,
+		0xF6, 0xE5, 0x88, 0x87, 0xF6, 0xE5, 0xA3, 0xAE,
+		0xF6, 0xE5, 0x9F, 0x8E, 0xF6, 0xE5, 0x9F, 0xB4,
+		0xF6, 0xE5, 0xA0, 0x8D, 0xF6, 0xE5, 0x9E, 0x8B,
+		0xF6, 0xE5, 0xA0, 0xB2, 0xF6, 0xE5, 0xA0, 0xB1,
+		0xF6, 0xE5, 0xA2, 0xAC, 0xF6, 0xF0, 0xA1, 0x93,
+		0xA4, 0xF6, 0xE5, 0xA3, 0xB2, 0xF6, 0xE5, 0xA3,
+		0xB7, 0xF6, 0xE5, 0xA4, 0x86, 0xF6, 0xE5, 0xA4,
+		0x9A, 0xF6, 0xE5, 0xA4, 0xA2, 0xF6, 0xE5, 0xA5,
+		0xA2, 0xF6, 0xF0, 0xA1, 0x9A, 0xA8, 0xF6, 0xF0,
+		0xA1, 0x9B, 0xAA, 0xF6, 0xE5, 0xA7, 0xAC, 0xF6,
+		0xE5, 0xA8, 0x9B, 0xF6, 0xE5, 0xA8, 0xA7, 0xF6,
+		0xE5, 0xA7, 0x98, 0xF6, 0xE5, 0xA9, 0xA6, 0xF6,
+		0xE3, 0x9B, 0xAE, 0xF6, 0xE3, 0x9B, 0xBC, 0xF6,
+		0xE5, 0xAC, 0x88, 0xF6, 0xE5, 0xAC, 0xBE, 0xF6,
+		0xE5, 0xAC, 0xBE, 0xF6, 0xF0, 0xA1, 0xA7, 0x88,
+		0xF6, 0xE5, 0xAF, 0x83, 0xF6, 0xE5, 0xAF, 0x98,
+		0xF6, 0xE5, 0xAF, 0xA7, 0xF6, 0xE5, 0xAF, 0xB3,
+		0xF6, 0xF0, 0xA1, 0xAC, 0x98, 0xF6, 0xE5, 0xAF,
+		0xBF, 0xF6, 0xE5, 0xB0, 0x86, 0xF6, 0xE5, 0xBD,
+		0x93, 0xF6, 0xE5, 0xB0, 0xA2, 0xF6, 0xE3, 0x9E,
+		0x81, 0xF6, 0xE5, 0xB1, 0xA0, 0xF6, 0xE5, 0xB1,
+		0xAE, 0xF6, 0xE5, 0xB3, 0x80, 0xF6, 0xE5, 0xB2,
+		0x8D, 0xF6, 0xF0, 0xA1, 0xB7, 0xA4, 0xF6, 0xE5,
+		0xB5, 0x83, 0xF6, 0xF0, 0xA1, 0xB7, 0xA6, 0xF6,
+		0xE5, 0xB5, 0xAE, 0xF6, 0xE5, 0xB5, 0xAB, 0xF6,
+		0xE5, 0xB5, 0xBC, 0xF6, 0xE5, 0xB7, 0xA1, 0xF6,
+		0xE5, 0xB7, 0xA2, 0xF6, 0xE3, 0xA0, 0xAF, 0xF6,
+		0xE5, 0xB7, 0xBD, 0xF6, 0xE5, 0xB8, 0xA8, 0xF6,
+		0xE5, 0xB8, 0xBD, 0xF6, 0xE5, 0xB9, 0xA9, 0xF6,
+		0xE3, 0xA1, 0xA2, 0xF6, 0xF0, 0xA2, 0x86, 0x83,
+		0xF6, 0xE3, 0xA1, 0xBC, 0xF6, 0xE5, 0xBA, 0xB0,
+		0xF6, 0xE5, 0xBA, 0xB3, 0xF6, 0xE5, 0xBA, 0xB6,
+		0xF6, 0xE5, 0xBB, 0x8A, 0xF6, 0xF0, 0xAA, 0x8E,
+		0x92, 0xF6, 0xE5, 0xBB, 0xBE, 0xF6, 0xF0, 0xA2,
+		0x8C, 0xB1, 0xF6, 0xF0, 0xA2, 0x8C, 0xB1, 0xF6,
+		0xE8, 0x88, 0x81, 0xF6, 0xE5, 0xBC, 0xA2, 0xF6,
+		0xE5, 0xBC, 0xA2, 0xF6, 0xE3, 0xA3, 0x87, 0xF6,
+		0xF0, 0xA3, 0x8A, 0xB8, 0xF6, 0xF0, 0xA6, 0x87,
+		0x9A, 0xF6, 0xE5, 0xBD, 0xA2, 0xF6, 0xE5, 0xBD,
+		0xAB, 0xF6, 0xE3, 0xA3, 0xA3, 0xF6, 0xE5, 0xBE,
+		0x9A, 0xF6, 0xE5, 0xBF, 0x8D, 0xF6, 0xE5, 0xBF,
+		0x97, 0xF6, 0xE5, 0xBF, 0xB9, 0xF6, 0xE6, 0x82,
+		0x81, 0xF6, 0xE3, 0xA4, 0xBA, 0xF6, 0xE3, 0xA4,
+		0x9C, 0xF6, 0xE6, 0x82, 0x94, 0xF6, 0xF0, 0xA2,
+		0x9B, 0x94, 0xF6, 0xE6, 0x83, 0x87, 0xF6, 0xE6,
+		0x85, 0x88, 0xF6, 0xE6, 0x85, 0x8C, 0xF6, 0xE6,
+		0x85, 0x8E, 0xF6, 0xE6, 0x85, 0x8C, 0xF6, 0xE6,
+		0x85, 0xBA, 0xF6, 0xE6, 0x86, 0x8E, 0xF6, 0xE6,
+		0x86, 0xB2, 0xF6, 0xE6, 0x86, 0xA4, 0xF6, 0xE6,
+		0x86, 0xAF, 0xF6, 0xE6, 0x87, 0x9E, 0xF6, 0xE6,
+		0x87, 0xB2, 0xF6, 0xE6, 0x87, 0xB6, 0xF6, 0xE6,
+		0x88, 0x90, 0xF6, 0xE6, 0x88, 0x9B, 0xF6, 0xE6,
+		0x89, 0x9D, 0xF6, 0xE6, 0x8A, 0xB1, 0xF6, 0xE6,
+		0x8B, 0x94, 0xF6, 0xE6, 0x8D, 0x90, 0xF6, 0xF0,
+		0xA2, 0xAC, 0x8C, 0xF6, 0xE6, 0x8C, 0xBD, 0xF6,
+		0xE6, 0x8B, 0xBC, 0xF6, 0xE6, 0x8D, 0xA8, 0xF6,
+		0xE6, 0x8E, 0x83, 0xF6, 0xE6, 0x8F, 0xA4, 0xF6,
+		0xF0, 0xA2, 0xAF, 0xB1, 0xF6, 0xE6, 0x90, 0xA2,
+		0xF6, 0xE6, 0x8F, 0x85, 0xF6, 0xE6, 0x8E, 0xA9,
+		0xF6, 0xE3, 0xA8, 0xAE, 0xF6, 0xE6, 0x91, 0xA9,
+		0xF6, 0xE6, 0x91, 0xBE, 0xF6, 0xE6, 0x92, 0x9D,
+		0xF6, 0xE6, 0x91, 0xB7, 0xF6, 0xE3, 0xA9, 0xAC,
+		0xF6, 0xE6, 0x95, 0x8F, 0xF6, 0xE6, 0x95, 0xAC,
+		0xF6, 0xF0, 0xA3, 0x80, 0x8A, 0xF6, 0xE6, 0x97,
+		0xA3, 0xF6, 0xE6, 0x9B, 0xB8, 0xF6, 0xE6, 0x99,
+		0x89, 0xF6, 0xE3, 0xAC, 0x99, 0xF6, 0xE6, 0x9A,
+		0x91, 0xF6, 0xE3, 0xAC, 0x88, 0xF6, 0xE3, 0xAB,
+		0xA4, 0xF6, 0xE5, 0x86, 0x92, 0xF6, 0xE5, 0x86,
+		0x95, 0xF6, 0xE6, 0x9C, 0x80, 0xF6, 0xE6, 0x9A,
+		0x9C, 0xF6, 0xE8, 0x82, 0xAD, 0xF6, 0xE4, 0x8F,
+		0x99, 0xF6, 0xE6, 0x9C, 0x97, 0xF6, 0xE6, 0x9C,
+		0x9B, 0xF6, 0xE6, 0x9C, 0xA1, 0xF6, 0xE6, 0x9D,
+		0x9E, 0xF6, 0xE6, 0x9D, 0x93, 0xF6, 0xF0, 0xA3,
+		0x8F, 0x83, 0xF6, 0xE3, 0xAD, 0x89, 0xF6, 0xE6,
+		0x9F, 0xBA, 0xF6, 0xE6, 0x9E, 0x85, 0xF6, 0xE6,
+		0xA1, 0x92, 0xF6, 0xE6, 0xA2, 0x85, 0xF6, 0xF0,
+		0xA3, 0x91, 0xAD, 0xF6, 0xE6, 0xA2, 0x8E, 0xF6,
+		0xE6, 0xA0, 0x9F, 0xF6, 0xE6, 0xA4, 0x94, 0xF6,
+		0xE3, 0xAE, 0x9D, 0xF6, 0xE6, 0xA5, 0x82, 0xF6,
+		0xE6, 0xA6, 0xA3, 0xF6, 0xE6, 0xA7, 0xAA, 0xF6,
+		0xE6, 0xAA, 0xA8, 0xF6, 0xF0, 0xA3, 0x9A, 0xA3,
+		0xF6, 0xE6, 0xAB, 0x9B, 0xF6, 0xE3, 0xB0, 0x98,
+		0xF6, 0xE6, 0xAC, 0xA1, 0xF6, 0xF0, 0xA3, 0xA2,
+		0xA7, 0xF6, 0xE6, 0xAD, 0x94, 0xF6, 0xE3, 0xB1,
+		0x8E, 0xF6, 0xE6, 0xAD, 0xB2, 0xF6, 0xE6, 0xAE,
+		0x9F, 0xF6, 0xE6, 0xAE, 0xBA, 0xF6, 0xE6, 0xAE,
+		0xBB, 0xF6, 0xF0, 0xA3, 0xAA, 0x8D, 0xF6, 0xF0,
+		0xA1, 0xB4, 0x8B, 0xF6, 0xF0, 0xA3, 0xAB, 0xBA,
+		0xF6, 0xE6, 0xB1, 0x8E, 0xF6, 0xF0, 0xA3, 0xB2,
+		0xBC, 0xF6, 0xE6, 0xB2, 0xBF, 0xF6, 0xE6, 0xB3,
+		0x8D, 0xF6, 0xE6, 0xB1, 0xA7, 0xF6, 0xE6, 0xB4,
+		0x96, 0xF6, 0xE6, 0xB4, 0xBE, 0xF6, 0xE6, 0xB5,
+		0xB7, 0xF6, 0xE6, 0xB5, 0x81, 0xF6, 0xE6, 0xB5,
+		0xA9, 0xF6, 0xE6, 0xB5, 0xB8, 0xF6, 0xE6, 0xB6,
+		0x85, 0xF6, 0xF0, 0xA3, 0xB4, 0x9E, 0xF6, 0xE6,
+		0xB4, 0xB4, 0xF6, 0xE6, 0xB8, 0xAF, 0xF6, 0xE6,
+		0xB9, 0xAE, 0xF6, 0xE3, 0xB4, 0xB3, 0xF6, 0xE6,
+		0xBB, 0x8B, 0xF6, 0xE6, 0xBB, 0x87, 0xF6, 0xF0,
+		0xA3, 0xBB, 0x91, 0xF6, 0xE6, 0xB7, 0xB9, 0xF6,
+		0xE6, 0xBD, 0xAE, 0xF6, 0xF0, 0xA3, 0xBD, 0x9E,
+		0xF6, 0xF0, 0xA3, 0xBE, 0x8E, 0xF6, 0xE6, 0xBF,
+		0x86, 0xF6, 0xE7, 0x80, 0xB9, 0xF6, 0xE7, 0x80,
+		0x9E, 0xF6, 0xE7, 0x80, 0x9B, 0xF6, 0xE3, 0xB6,
+		0x96, 0xF6, 0xE7, 0x81, 0x8A, 0xF6, 0xE7, 0x81,
+		0xBD, 0xF6, 0xE7, 0x81, 0xB7, 0xF6, 0xE7, 0x82,
+		0xAD, 0xF6, 0xF0, 0xA0, 0x94, 0xA5, 0xF6, 0xE7,
+		0x85, 0x85, 0xF6, 0xF0, 0xA4, 0x89, 0xA3, 0xF6,
+		0xE7, 0x86, 0x9C, 0xF6, 0xF0, 0xA4, 0x8E, 0xAB,
+		0xF6, 0xE7, 0x88, 0xA8, 0xF6, 0xE7, 0x88, 0xB5,
+		0xF6, 0xE7, 0x89, 0x90, 0xF6, 0xF0, 0xA4, 0x98,
+		0x88, 0xF6, 0xE7, 0x8A, 0x80, 0xF6, 0xE7, 0x8A,
+		0x95, 0xF6, 0xF0, 0xA4, 0x9C, 0xB5, 0xF6, 0xF0,
+		0xA4, 0xA0, 0x94, 0xF6, 0xE7, 0x8D, 0xBA, 0xF6,
+		0xE7, 0x8E, 0x8B, 0xF6, 0xE3, 0xBA, 0xAC, 0xF6,
+		0xE7, 0x8E, 0xA5, 0xF6, 0xE3, 0xBA, 0xB8, 0xF6,
+		0xE3, 0xBA, 0xB8, 0xF6, 0xE7, 0x91, 0x87, 0xF6,
+		0xE7, 0x91, 0x9C, 0xF6, 0xE7, 0x91, 0xB1, 0xF6,
+		0xE7, 0x92, 0x85, 0xF6, 0xE7, 0x93, 0x8A, 0xF6,
+		0xE3, 0xBC, 0x9B, 0xF6, 0xE7, 0x94, 0xA4, 0xF6,
+		0xF0, 0xA4, 0xB0, 0xB6, 0xF6, 0xE7, 0x94, 0xBE,
+		0xF6, 0xF0, 0xA4, 0xB2, 0x92, 0xF6, 0xE7, 0x95,
+		0xB0, 0xF6, 0xF0, 0xA2, 0x86, 0x9F, 0xF6, 0xE7,
+		0x98, 0x90, 0xF6, 0xF0, 0xA4, 0xBE, 0xA1, 0xF6,
+		0xF0, 0xA4, 0xBE, 0xB8, 0xF6, 0xF0, 0xA5, 0x81,
+		0x84, 0xF6, 0xE3, 0xBF, 0xBC, 0xF6, 0xE4, 0x80,
+		0x88, 0xF6, 0xE7, 0x9B, 0xB4, 0xF6, 0xF0, 0xA5,
+		0x83, 0xB3, 0xF6, 0xF0, 0xA5, 0x83, 0xB2, 0xF6,
+		0xF0, 0xA5, 0x84, 0x99, 0xF6, 0xF0, 0xA5, 0x84,
+		0xB3, 0xF6, 0xE7, 0x9C, 0x9E, 0xF6, 0xE7, 0x9C,
+		0x9F, 0xF6, 0xE7, 0x9C, 0x9F, 0xF6, 0xE7, 0x9D,
+		0x8A, 0xF6, 0xE4, 0x80, 0xB9, 0xF6, 0xE7, 0x9E,
+		0x8B, 0xF6, 0xE4, 0x81, 0x86, 0xF6, 0xE4, 0x82,
+		0x96, 0xF6, 0xF0, 0xA5, 0x90, 0x9D, 0xF6, 0xE7,
+		0xA1, 0x8E, 0xF6, 0xE7, 0xA2, 0x8C, 0xF6, 0xE7,
+		0xA3, 0x8C, 0xF6, 0xE4, 0x83, 0xA3, 0xF6, 0xF0,
+		0xA5, 0x98, 0xA6, 0xF6, 0xE7, 0xA5, 0x96, 0xF6,
+		0xF0, 0xA5, 0x9A, 0x9A, 0xF6, 0xF0, 0xA5, 0x9B,
+		0x85, 0xF6, 0xE7, 0xA6, 0x8F, 0xF6, 0xE7, 0xA7,
+		0xAB, 0xF6, 0xE4, 0x84, 0xAF, 0xF6, 0xE7, 0xA9,
+		0x80, 0xF6, 0xE7, 0xA9, 0x8A, 0xF6, 0xE7, 0xA9,
+		0x8F, 0xF6, 0xF0, 0xA5, 0xA5, 0xBC, 0xF6, 0xF0,
+		0xA5, 0xAA, 0xA7, 0xF6, 0xF0, 0xA5, 0xAA, 0xA7,
+		0xF6, 0xE7, 0xAB, 0xAE, 0xF6, 0xE4, 0x88, 0x82,
+		0xF6, 0xF0, 0xA5, 0xAE, 0xAB, 0xF6, 0xE7, 0xAF,
+		0x86, 0xF6, 0xE7, 0xAF, 0x89, 0xF6, 0xE4, 0x88,
+		0xA7, 0xF6, 0xF0, 0xA5, 0xB2, 0x80, 0xF6, 0xE7,
+		0xB3, 0x92, 0xF6, 0xE4, 0x8A, 0xA0, 0xF6, 0xE7,
+		0xB3, 0xA8, 0xF6, 0xE7, 0xB3, 0xA3, 0xF6, 0xE7,
+		0xB4, 0x80, 0xF6, 0xF0, 0xA5, 0xBE, 0x86, 0xF6,
+		0xE7, 0xB5, 0xA3, 0xF6, 0xE4, 0x8C, 0x81, 0xF6,
+		0xE7, 0xB7, 0x87, 0xF6, 0xE7, 0xB8, 0x82, 0xF6,
+		0xE7, 0xB9, 0x85, 0xF6, 0xE4, 0x8C, 0xB4, 0xF6,
+		0xF0, 0xA6, 0x88, 0xA8, 0xF6, 0xF0, 0xA6, 0x89,
+		0x87, 0xF6, 0xE4, 0x8D, 0x99, 0xF6, 0xF0, 0xA6,
+		0x8B, 0x99, 0xF6, 0xE7, 0xBD, 0xBA, 0xF6, 0xF0,
+		0xA6, 0x8C, 0xBE, 0xF6, 0xE7, 0xBE, 0x95, 0xF6,
+		0xE7, 0xBF, 0xBA, 0xF6, 0xE8, 0x80, 0x85, 0xF6,
+		0xF0, 0xA6, 0x93, 0x9A, 0xF6, 0xF0, 0xA6, 0x94,
+		0xA3, 0xF6, 0xE8, 0x81, 0xA0, 0xF6, 0xF0, 0xA6,
+		0x96, 0xA8, 0xF6, 0xE8, 0x81, 0xB0, 0xF6, 0xF0,
+		0xA3, 0x8D, 0x9F, 0xF6, 0xE4, 0x8F, 0x95, 0xF6,
+		0xE8, 0x82, 0xB2, 0xF6, 0xE8, 0x84, 0x83, 0xF6,
+		0xE4, 0x90, 0x8B, 0xF6, 0xE8, 0x84, 0xBE, 0xF6,
+		0xE5, 0xAA, 0xB5, 0xF6, 0xF0, 0xA6, 0x9E, 0xA7,
+		0xF6, 0xF0, 0xA6, 0x9E, 0xB5, 0xF6, 0xF0, 0xA3,
+		0x8E, 0x93, 0xF6, 0xF0, 0xA3, 0x8E, 0x9C, 0xF6,
+		0xE8, 0x88, 0x81, 0xF6, 0xE8, 0x88, 0x84, 0xF6,
+		0xE8, 0xBE, 0x9E, 0xF6, 0xE4, 0x91, 0xAB, 0xF6,
+		0xE8, 0x8A, 0x91, 0xF6, 0xE8, 0x8A, 0x8B, 0xF6,
+		0xE8, 0x8A, 0x9D, 0xF6, 0xE5, 0x8A, 0xB3, 0xF6,
+		0xE8, 0x8A, 0xB1, 0xF6, 0xE8, 0x8A, 0xB3, 0xF6,
+		0xE8, 0x8A, 0xBD, 0xF6, 0xE8, 0x8B, 0xA6, 0xF6,
+		0xF0, 0xA6, 0xAC, 0xBC, 0xF6, 0xE8, 0x8B, 0xA5,
+		0xF6, 0xE8, 0x8C, 0x9D, 0xF6, 0xE8, 0x8D, 0xA3,
+		0xF6, 0xE8, 0x8E, 0xAD, 0xF6, 0xE8, 0x8C, 0xA3,
+		0xF6, 0xE8, 0x8E, 0xBD, 0xF6, 0xE8, 0x8F, 0xA7,
+		0xF6, 0xE8, 0x91, 0x97, 0xF6, 0xE8, 0x8D, 0x93,
+		0xF6, 0xE8, 0x8F, 0x8A, 0xF6, 0xE8, 0x8F, 0x8C,
+		0xF6, 0xE8, 0x8F, 0x9C, 0xF6, 0xF0, 0xA6, 0xB0,
+		0xB6, 0xF6, 0xF0, 0xA6, 0xB5, 0xAB, 0xF6, 0xF0,
+		0xA6, 0xB3, 0x95, 0xF6, 0xE4, 0x94, 0xAB, 0xF6,
+		0xE8, 0x93, 0xB1, 0xF6, 0xE8, 0x93, 0xB3, 0xF6,
+		0xE8, 0x94, 0x96, 0xF6, 0xF0, 0xA7, 0x8F, 0x8A,
+		0xF6, 0xE8, 0x95, 0xA4, 0xF6, 0xF0, 0xA6, 0xBC,
+		0xAC, 0xF6, 0xE4, 0x95, 0x9D, 0xF6, 0xE4, 0x95,
+		0xA1, 0xF6, 0xF0, 0xA6, 0xBE, 0xB1, 0xF6, 0xF0,
+		0xA7, 0x83, 0x92, 0xF6, 0xE4, 0x95, 0xAB, 0xF6,
+		0xE8, 0x99, 0x90, 0xF6, 0xE8, 0x99, 0x9C, 0xF6,
+		0xE8, 0x99, 0xA7, 0xF6, 0xE8, 0x99, 0xA9, 0xF6,
+		0xE8, 0x9A, 0xA9, 0xF6, 0xE8, 0x9A, 0x88, 0xF6,
+		0xE8, 0x9C, 0x8E, 0xF6, 0xE8, 0x9B, 0xA2, 0xF6,
+		0xE8, 0x9D, 0xB9, 0xF6, 0xE8, 0x9C, 0xA8, 0xF6,
+		0xE8, 0x9D, 0xAB, 0xF6, 0xE8, 0x9E, 0x86, 0xF6,
+		0xE4, 0x97, 0x97, 0xF6, 0xE8, 0x9F, 0xA1, 0xF6,
+		0xE8, 0xA0, 0x81, 0xF6, 0xE4, 0x97, 0xB9, 0xF6,
+		0xE8, 0xA1, 0xA0, 0xF6, 0xE8, 0xA1, 0xA3, 0xF6,
+		0xF0, 0xA7, 0x99, 0xA7, 0xF6, 0xE8, 0xA3, 0x97,
+		0xF6, 0xE8, 0xA3, 0x9E, 0xF6, 0xE4, 0x98, 0xB5,
+		0xF6, 0xE8, 0xA3, 0xBA, 0xF6, 0xE3, 0x92, 0xBB,
+		0xF6, 0xF0, 0xA7, 0xA2, 0xAE, 0xF6, 0xF0, 0xA7,
+		0xA5, 0xA6, 0xF6, 0xE4, 0x9A, 0xBE, 0xF6, 0xE4,
+		0x9B, 0x87, 0xF6, 0xE8, 0xAA, 0xA0, 0xF6, 0xE8,
+		0xAB, 0xAD, 0xF6, 0xE8, 0xAE, 0x8A, 0xF6, 0xE8,
+		0xB1, 0x95, 0xF6, 0xF0, 0xA7, 0xB2, 0xA8, 0xF6,
+		0xE8, 0xB2, 0xAB, 0xF6, 0xE8, 0xB3, 0x81, 0xF6,
+		0xE8, 0xB4, 0x9B, 0xF6, 0xE8, 0xB5, 0xB7, 0xF6,
+		0xF0, 0xA7, 0xBC, 0xAF, 0xF6, 0xF0, 0xA0, 0xA0,
+		0x84, 0xF6, 0xE8, 0xB7, 0x8B, 0xF6, 0xE8, 0xB6,
+		0xBC, 0xF6, 0xE8, 0xB7, 0xB0, 0xF6, 0xF0, 0xA0,
+		0xA3, 0x9E, 0xF6, 0xE8, 0xBB, 0x94, 0xF6, 0xE8,
+		0xBC, 0xB8, 0xF6, 0xF0, 0xA8, 0x97, 0x92, 0xF6,
+		0xF0, 0xA8, 0x97, 0xAD, 0xF6, 0xE9, 0x82, 0x94,
+		0xF6, 0xE9, 0x83, 0xB1, 0xF6, 0xE9, 0x84, 0x91,
+		0xF6, 0xF0, 0xA8, 0x9C, 0xAE, 0xF6, 0xE9, 0x84,
+		0x9B, 0xF6, 0xE9, 0x88, 0xB8, 0xF6, 0xE9, 0x8B,
+		0x97, 0xF6, 0xE9, 0x8B, 0x98, 0xF6, 0xE9, 0x89,
+		0xBC, 0xF6, 0xE9, 0x8F, 0xB9, 0xF6, 0xE9, 0x90,
+		0x95, 0xF6, 0xF0, 0xA8, 0xAF, 0xBA, 0xF6, 0xE9,
+		0x96, 0x8B, 0xF6, 0xE4, 0xA6, 0x95, 0xF6, 0xE9,
+		0x96, 0xB7, 0xF6, 0xF0, 0xA8, 0xB5, 0xB7, 0xF6,
+		0xE4, 0xA7, 0xA6, 0xF6, 0xE9, 0x9B, 0x83, 0xF6,
+		0xE5, 0xB6, 0xB2, 0xF6, 0xE9, 0x9C, 0xA3, 0xF6,
+		0xF0, 0xA9, 0x85, 0x85, 0xF6, 0xF0, 0xA9, 0x88,
+		0x9A, 0xF6, 0xE4, 0xA9, 0xAE, 0xF6, 0xE4, 0xA9,
+		0xB6, 0xF6, 0xE9, 0x9F, 0xA0, 0xF6, 0xF0, 0xA9,
+		0x90, 0x8A, 0xF6, 0xE4, 0xAA, 0xB2, 0xF6, 0xF0,
+		0xA9, 0x92, 0x96, 0xF6, 0xE9, 0xA0, 0x8B, 0xF6,
+		0xE9, 0xA0, 0x8B, 0xF6, 0xE9, 0xA0, 0xA9, 0xF6,
+		0xF0, 0xA9, 0x96, 0xB6, 0xF6, 0xE9, 0xA3, 0xA2,
+		0xF6, 0xE4, 0xAC, 0xB3, 0xF6, 0xE9, 0xA4, 0xA9,
+		0xF6, 0xE9, 0xA6, 0xA7, 0xF6, 0xE9, 0xA7, 0x82,
+		0xF6, 0xE9, 0xA7, 0xBE, 0xF6, 0xE4, 0xAF, 0x8E,
+		0xF6, 0xF0, 0xA9, 0xAC, 0xB0, 0xF6, 0xE9, 0xAC,
+		0x92, 0xF6, 0xE9, 0xB1, 0x80, 0xF6, 0xE9, 0xB3,
+		0xBD, 0xF6, 0xE4, 0xB3, 0x8E, 0xF6, 0xE4, 0xB3,
+		0xAD, 0xF6, 0xE9, 0xB5, 0xA7, 0xF6, 0xF0, 0xAA,
+		0x83, 0x8E, 0xF6, 0xE4, 0xB3, 0xB8, 0xF6, 0xF0,
+		0xAA, 0x84, 0x85, 0xF6, 0xF0, 0xAA, 0x88, 0x8E,
+		0xF6, 0xF0, 0xAA, 0x8A, 0x91, 0xF6, 0xE9, 0xBA,
+		0xBB, 0xF6, 0xE4, 0xB5, 0x96, 0xF6, 0xE9, 0xBB,
+		0xB9, 0xF6, 0xE9, 0xBB, 0xBE, 0xF6, 0xE9, 0xBC,
+		0x85, 0xF6, 0xE9, 0xBC, 0x8F, 0xF6, 0xE9, 0xBC,
+		0x96, 0xF6, 0xE9, 0xBC, 0xBB, 0xF6, 0xF0, 0xAA,
+		0x98, 0x80,
+	},
+};
+
+static const uchar_t u8_case_common_b2_tbl[2][2][256] = {
+	{
+		{
+			0,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, 1,  2,  N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, 3,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			4,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+
+	},
+	{
+		{
+			0,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, 1,  2,  N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, 3,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+		{
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			4,  N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+			N_, N_, N_, N_, N_, N_, N_, N_,
+		},
+
+	},
+
+};
+
+static const u8_displacement_t u8_tolower_b3_tbl[2][5][256] = {
+	{
+		{	/* Third byte table 0. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { 0, 0 },
+			{ 1, 60 }, { 2, 123 }, { 3, 185 }, { 4, 257 },
+			{ 5, 321 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 6, 373 }, { 7, 439 },
+			{ 8, 465 }, { 9, 561 }, { 10, 593 }, { 11, 649 },
+			{ 12, 703 }, { 13, 749 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 1. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 14, 795 }, { 15, 891 }, { 16, 987 }, { 17, 1068 },
+			{ 18, 1155 }, { 19, 1245 }, { 20, 1299 }, { 21, 1386 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 2. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 22, 1443 }, { 23, 1448 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 24, 1496 }, { 25, 1526 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 3. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 26, 1574 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 4. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 27, 1652 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+	},
+	{
+		{	/* Third byte table 0. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { 0, 0 },
+			{ 1, 60 }, { 2, 123 }, { 3, 185 }, { 4, 257 },
+			{ 5, 321 }, { 6, 383 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 7, 401 }, { 8, 467 },
+			{ 9, 505 }, { 10, 601 }, { 11, 633 }, { 12, 689 },
+			{ 13, 753 }, { 14, 803 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 1. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 15, 849 }, { 16, 945 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 17, 963 }, { 18, 1059 }, { 19, 1155 }, { 20, 1236 },
+			{ 21, 1323 }, { 22, 1413 }, { 23, 1467 }, { 24, 1554 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 2. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 25, 1611 }, { 26, 1619 }, { 27, 1667 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 28, 1670 }, { 29, 1700 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 30, 1748 }, { 31, 1889 }, { 32, 1911 }, { 33, 2007 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 3. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 34, 2061 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 4. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 35, 2139 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+	},
+};
+
+static const uchar_t u8_tolower_b4_tbl[2][36][257] = {
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			46,  48,  50,  52,  54,  56,  58,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  34,  34,  36,  36,  38,  38,  40,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			48,  49,  49,  51,  51,  53,  53,  55,
+			55,  55,  57,  57,  59,  59,  61,  61,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   8,   10,  10,  12,  12,  14,
+			14,  16,  16,  18,  18,  20,  20,  22,
+			22,  24,  24,  26,  26,  28,  28,  30,
+			30,  32,  32,  34,  34,  36,  36,  38,
+			38,  40,  40,  42,  42,  44,  44,  46,
+			46,  48,  48,  50,  50,  52,  52,  54,
+			54,  56,  58,  58,  60,  60,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   4,   4,   6,   6,   8,
+			10,  10,  12,  14,  16,  16,  16,  18,
+			20,  22,  24,  24,  26,  28,  28,  30,
+			32,  34,  34,  34,  34,  36,  38,  38,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			50,  50,  52,  52,  52,  54,  54,  56,
+			58,  58,  60,  62,  64,  64,  66,  66,
+			68,  70,  70,  70,  70,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   2,   4,   4,
+			6,   8,   8,   10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  28,  30,
+			30,  32,  32,  34,  34,  36,  36,  38,
+			38,  40,  40,  42,  42,  44,  44,  46,
+			46,  46,  48,  50,  50,  52,  52,  54,
+			56,  58,  58,  60,  60,  62,  62,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  34,  34,  36,  36,  38,  38,  40,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			48,  50,  50,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   2,
+			2,   4,   6,   8,   8,   10,  10,  12,
+			14,  14,  16,  18,  20,  22,  24,  26,
+			28,  30,  32,  34,  36,  38,  40,  42,
+			44,  46,  48,  48,  50,  52,  54,  56,
+			58,  60,  62,  64,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  24,  24,  24,  24,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  52,  54,  56,  58,  60,  62,
+			64,  66,  68,  70,  72,  74,  76,  78,
+			80,  82,  84,  86,  88,  90,  92,  94,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  34,  34,  36,  36,  38,  38,  40,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			48,  50,  50,  52,  52,  54,  54,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			14,  16,  16,  18,  18,  20,  20,  22,
+			22,  24,  24,  26,  26,  28,  28,  30,
+			30,  32,  32,  34,  34,  36,  36,  38,
+			38,  40,  40,  42,  42,  44,  44,  46,
+			46,  48,  48,  50,  50,  52,  52,  52,
+			52,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  18,  20,  22,  24,  26,  28,
+			30,  32,  34,  36,  38,  40,  42,  44,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  36,
+			36,  39,  39,  42,  42,  45,  45,  48,
+			48,  51,  51,  54,  54,  57,  57,  60,
+			60,  63,  63,  66,  66,  69,  69,  72,
+			72,  75,  75,  78,  78,  81,  81,  84,
+			84,  87,  87,  90,  90,  93,  93,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  36,
+			36,  39,  39,  42,  42,  45,  45,  48,
+			48,  51,  51,  54,  54,  57,  57,  60,
+			60,  63,  63,  66,  66,  69,  69,  72,
+			72,  75,  75,  78,  78,  81,  81,  84,
+			84,  87,  87,  90,  90,  93,  93,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  33,
+			33,  33,  33,  33,  33,  33,  33,  33,
+			33,  36,  36,  39,  39,  42,  42,  45,
+			45,  48,  48,  51,  51,  54,  54,  57,
+			57,  60,  60,  63,  63,  66,  66,  69,
+			69,  72,  72,  75,  75,  78,  78,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  36,
+			36,  39,  39,  42,  42,  45,  45,  48,
+			48,  51,  51,  54,  54,  57,  57,  60,
+			60,  63,  63,  66,  66,  69,  69,  72,
+			72,  75,  75,  78,  78,  81,  81,  84,
+			84,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  27,  30,  33,  36,  39,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  45,  48,  51,  54,  57,  60,  63,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  69,  72,  75,  78,  81,  84,  87,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  21,  21,  24,  24,  27,  27,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  33,  36,  39,  42,  45,  48,  51,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  75,  78,  81,  84,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  18,  21,  24,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  30,  33,  36,  39,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  45,  48,  51,  54,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   2,
+			2,   2,   2,   3,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,   5,   5,   5,   5,   5,   5,   5,
+			5,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   3,
+			6,   9,   12,  15,  18,  21,  24,  27,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   6,   9,   12,  15,  18,
+			21,  24,  27,  30,  33,  36,  39,  42,
+			45,  48,  51,  54,  57,  60,  63,  66,
+			69,  72,  75,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  100, 104, 108, 112, 116, 120, 124,
+			128, 132, 136, 140, 144, 148, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152, 152, 152, 152, 152, 152, 152, 152,
+			152,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+	},
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			46,  48,  50,  52,  54,  56,  58,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,  60,  60,  60,  60,  60,  60,  60,
+			60,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  34,  34,  36,  36,  38,  38,  40,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			48,  49,  49,  51,  51,  53,  53,  55,
+			55,  55,  57,  57,  59,  59,  61,  61,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   8,   10,  10,  12,  12,  14,
+			14,  16,  16,  18,  18,  20,  20,  22,
+			22,  24,  24,  26,  26,  28,  28,  30,
+			30,  32,  32,  34,  34,  36,  36,  38,
+			38,  40,  40,  42,  42,  44,  44,  46,
+			46,  48,  48,  50,  50,  52,  52,  54,
+			54,  56,  58,  58,  60,  60,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   4,   4,   6,   6,   8,
+			10,  10,  12,  14,  16,  16,  16,  18,
+			20,  22,  24,  24,  26,  28,  28,  30,
+			32,  34,  34,  34,  34,  36,  38,  38,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			50,  50,  52,  52,  52,  54,  54,  56,
+			58,  58,  60,  62,  64,  64,  66,  66,
+			68,  70,  70,  70,  70,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   2,   4,   4,
+			6,   8,   8,   10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  28,  30,
+			30,  32,  32,  34,  34,  36,  36,  38,
+			38,  40,  40,  42,  42,  44,  44,  46,
+			46,  46,  48,  50,  50,  52,  52,  54,
+			56,  58,  58,  60,  60,  62,  62,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  34,  34,  36,  36,  38,  38,  40,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			48,  50,  50,  52,  52,  52,  52,  52,
+			52,  52,  52,  55,  57,  57,  59,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   6,   8,   10,
+			10,  12,  12,  14,  14,  16,  16,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   2,
+			2,   4,   6,   8,   8,   10,  10,  12,
+			14,  14,  16,  18,  20,  22,  24,  26,
+			28,  30,  32,  34,  36,  38,  40,  42,
+			44,  46,  48,  48,  50,  52,  54,  56,
+			58,  60,  62,  64,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  24,  24,  24,  24,  26,  26,  26,
+			28,  28,  30,  32,  32,  32,  34,  36,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  52,  54,  56,  58,  60,  62,
+			64,  66,  68,  70,  72,  74,  76,  78,
+			80,  82,  84,  86,  88,  90,  92,  94,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  34,  34,  36,  36,  38,  38,  40,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			48,  50,  50,  52,  52,  54,  54,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   4,   6,   6,   8,   8,
+			10,  10,  12,  12,  14,  14,  16,  16,
+			16,  18,  18,  20,  20,  22,  22,  24,
+			24,  26,  26,  28,  28,  30,  30,  32,
+			32,  34,  34,  36,  36,  38,  38,  40,
+			40,  42,  42,  44,  44,  46,  46,  48,
+			48,  50,  50,  52,  52,  54,  54,  56,
+			56,  58,  58,  60,  60,  62,  62,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  12,  12,  14,  14,  16,
+			16,  18,  18,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  22,  24,  26,  28,  30,  32,
+			34,  36,  38,  40,  42,  44,  46,  48,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,  46,  46,  46,  46,  46,  46,  46,
+			46,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  36,
+			36,  39,  39,  42,  42,  45,  45,  48,
+			48,  51,  51,  54,  54,  57,  57,  60,
+			60,  63,  63,  66,  66,  69,  69,  72,
+			72,  75,  75,  78,  78,  81,  81,  84,
+			84,  87,  87,  90,  90,  93,  93,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  36,
+			36,  39,  39,  42,  42,  45,  45,  48,
+			48,  51,  51,  54,  54,  57,  57,  60,
+			60,  63,  63,  66,  66,  69,  69,  72,
+			72,  75,  75,  78,  78,  81,  81,  84,
+			84,  87,  87,  90,  90,  93,  93,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  33,
+			33,  33,  33,  33,  33,  33,  33,  33,
+			33,  36,  36,  39,  39,  42,  42,  45,
+			45,  48,  48,  51,  51,  54,  54,  57,
+			57,  60,  60,  63,  63,  66,  66,  69,
+			69,  72,  72,  75,  75,  78,  78,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  81,
+			81,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  36,
+			36,  39,  39,  42,  42,  45,  45,  48,
+			48,  51,  51,  54,  54,  57,  57,  60,
+			60,  63,  63,  66,  66,  69,  69,  72,
+			72,  75,  75,  78,  78,  81,  81,  84,
+			84,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  27,  30,  33,  36,  39,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  45,  48,  51,  54,  57,  60,  63,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  69,  72,  75,  78,  81,  84,  87,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  21,  21,  24,  24,  27,  27,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  33,  36,  39,  42,  45,  48,  51,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  75,  78,  81,  84,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  15,  15,
+			15,  15,  15,  15,  15,  15,  15,  15,
+			15,  18,  21,  24,  27,  27,  27,  27,
+			27,  27,  27,  27,  27,  27,  27,  27,
+			27,  30,  33,  36,  39,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  45,  48,  51,  54,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,  57,  57,  57,  57,  57,  57,  57,
+			57,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   2,
+			2,   2,   2,   3,   5,   5,   5,   5,
+			5,   5,   5,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   3,
+			6,   9,   12,  15,  18,  21,  24,  27,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 117,
+			120, 123, 126, 129, 132, 135, 138, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141, 141, 141, 141, 141, 141, 141, 141,
+			141,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   5,   8,   10,  10,  10,
+			13,  13,  16,  16,  19,  19,  19,  19,
+			19,  19,  19,  19,  19,  19,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,  22,  22,  22,  22,  22,  22,  22,
+			22,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  36,
+			36,  39,  39,  42,  42,  45,  45,  48,
+			48,  51,  51,  54,  54,  57,  57,  60,
+			60,  63,  63,  66,  66,  69,  69,  72,
+			72,  75,  75,  78,  78,  81,  81,  84,
+			84,  87,  87,  90,  90,  93,  93,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   3,   6,   6,   9,   9,   12,
+			12,  15,  15,  18,  18,  21,  21,  24,
+			24,  27,  27,  30,  30,  33,  33,  36,
+			36,  39,  39,  42,  42,  45,  45,  48,
+			48,  51,  51,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   6,   9,   12,  15,  18,
+			21,  24,  27,  30,  33,  36,  39,  42,
+			45,  48,  51,  54,  57,  60,  63,  66,
+			69,  72,  75,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  100, 104, 108, 112, 116, 120, 124,
+			128, 132, 136, 140, 144, 148, 152, 156,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160, 160, 160, 160, 160, 160, 160, 160,
+			160,
+		},
+	},
+};
+
+static const uchar_t u8_tolower_final_tbl[2][2299] = {
+	{
+		0xC3, 0xA0, 0xC3, 0xA1, 0xC3, 0xA2, 0xC3, 0xA3,
+		0xC3, 0xA4, 0xC3, 0xA5, 0xC3, 0xA6, 0xC3, 0xA7,
+		0xC3, 0xA8, 0xC3, 0xA9, 0xC3, 0xAA, 0xC3, 0xAB,
+		0xC3, 0xAC, 0xC3, 0xAD, 0xC3, 0xAE, 0xC3, 0xAF,
+		0xC3, 0xB0, 0xC3, 0xB1, 0xC3, 0xB2, 0xC3, 0xB3,
+		0xC3, 0xB4, 0xC3, 0xB5, 0xC3, 0xB6, 0xC3, 0xB8,
+		0xC3, 0xB9, 0xC3, 0xBA, 0xC3, 0xBB, 0xC3, 0xBC,
+		0xC3, 0xBD, 0xC3, 0xBE, 0xC4, 0x81, 0xC4, 0x83,
+		0xC4, 0x85, 0xC4, 0x87, 0xC4, 0x89, 0xC4, 0x8B,
+		0xC4, 0x8D, 0xC4, 0x8F, 0xC4, 0x91, 0xC4, 0x93,
+		0xC4, 0x95, 0xC4, 0x97, 0xC4, 0x99, 0xC4, 0x9B,
+		0xC4, 0x9D, 0xC4, 0x9F, 0xC4, 0xA1, 0xC4, 0xA3,
+		0xC4, 0xA5, 0xC4, 0xA7, 0xC4, 0xA9, 0xC4, 0xAB,
+		0xC4, 0xAD, 0xC4, 0xAF, 0x69, 0xC4, 0xB3, 0xC4,
+		0xB5, 0xC4, 0xB7, 0xC4, 0xBA, 0xC4, 0xBC, 0xC4,
+		0xBE, 0xC5, 0x80, 0xC5, 0x82, 0xC5, 0x84, 0xC5,
+		0x86, 0xC5, 0x88, 0xC5, 0x8B, 0xC5, 0x8D, 0xC5,
+		0x8F, 0xC5, 0x91, 0xC5, 0x93, 0xC5, 0x95, 0xC5,
+		0x97, 0xC5, 0x99, 0xC5, 0x9B, 0xC5, 0x9D, 0xC5,
+		0x9F, 0xC5, 0xA1, 0xC5, 0xA3, 0xC5, 0xA5, 0xC5,
+		0xA7, 0xC5, 0xA9, 0xC5, 0xAB, 0xC5, 0xAD, 0xC5,
+		0xAF, 0xC5, 0xB1, 0xC5, 0xB3, 0xC5, 0xB5, 0xC5,
+		0xB7, 0xC3, 0xBF, 0xC5, 0xBA, 0xC5, 0xBC, 0xC5,
+		0xBE, 0xC9, 0x93, 0xC6, 0x83, 0xC6, 0x85, 0xC9,
+		0x94, 0xC6, 0x88, 0xC9, 0x96, 0xC9, 0x97, 0xC6,
+		0x8C, 0xC7, 0x9D, 0xC9, 0x99, 0xC9, 0x9B, 0xC6,
+		0x92, 0xC9, 0xA0, 0xC9, 0xA3, 0xC9, 0xA9, 0xC9,
+		0xA8, 0xC6, 0x99, 0xC9, 0xAF, 0xC9, 0xB2, 0xC9,
+		0xB5, 0xC6, 0xA1, 0xC6, 0xA3, 0xC6, 0xA5, 0xCA,
+		0x80, 0xC6, 0xA8, 0xCA, 0x83, 0xC6, 0xAD, 0xCA,
+		0x88, 0xC6, 0xB0, 0xCA, 0x8A, 0xCA, 0x8B, 0xC6,
+		0xB4, 0xC6, 0xB6, 0xCA, 0x92, 0xC6, 0xB9, 0xC6,
+		0xBD, 0xC7, 0x86, 0xC7, 0x86, 0xC7, 0x89, 0xC7,
+		0x89, 0xC7, 0x8C, 0xC7, 0x8C, 0xC7, 0x8E, 0xC7,
+		0x90, 0xC7, 0x92, 0xC7, 0x94, 0xC7, 0x96, 0xC7,
+		0x98, 0xC7, 0x9A, 0xC7, 0x9C, 0xC7, 0x9F, 0xC7,
+		0xA1, 0xC7, 0xA3, 0xC7, 0xA5, 0xC7, 0xA7, 0xC7,
+		0xA9, 0xC7, 0xAB, 0xC7, 0xAD, 0xC7, 0xAF, 0xC7,
+		0xB3, 0xC7, 0xB3, 0xC7, 0xB5, 0xC6, 0x95, 0xC6,
+		0xBF, 0xC7, 0xB9, 0xC7, 0xBB, 0xC7, 0xBD, 0xC7,
+		0xBF, 0xC8, 0x81, 0xC8, 0x83, 0xC8, 0x85, 0xC8,
+		0x87, 0xC8, 0x89, 0xC8, 0x8B, 0xC8, 0x8D, 0xC8,
+		0x8F, 0xC8, 0x91, 0xC8, 0x93, 0xC8, 0x95, 0xC8,
+		0x97, 0xC8, 0x99, 0xC8, 0x9B, 0xC8, 0x9D, 0xC8,
+		0x9F, 0xC6, 0x9E, 0xC8, 0xA3, 0xC8, 0xA5, 0xC8,
+		0xA7, 0xC8, 0xA9, 0xC8, 0xAB, 0xC8, 0xAD, 0xC8,
+		0xAF, 0xC8, 0xB1, 0xC8, 0xB3, 0xCE, 0xAC, 0xCE,
+		0xAD, 0xCE, 0xAE, 0xCE, 0xAF, 0xCF, 0x8C, 0xCF,
+		0x8D, 0xCF, 0x8E, 0xCE, 0xB1, 0xCE, 0xB2, 0xCE,
+		0xB3, 0xCE, 0xB4, 0xCE, 0xB5, 0xCE, 0xB6, 0xCE,
+		0xB7, 0xCE, 0xB8, 0xCE, 0xB9, 0xCE, 0xBA, 0xCE,
+		0xBB, 0xCE, 0xBC, 0xCE, 0xBD, 0xCE, 0xBE, 0xCE,
+		0xBF, 0xCF, 0x80, 0xCF, 0x81, 0xCF, 0x83, 0xCF,
+		0x84, 0xCF, 0x85, 0xCF, 0x86, 0xCF, 0x87, 0xCF,
+		0x88, 0xCF, 0x89, 0xCF, 0x8A, 0xCF, 0x8B, 0xCF,
+		0x99, 0xCF, 0x9B, 0xCF, 0x9D, 0xCF, 0x9F, 0xCF,
+		0xA1, 0xCF, 0xA3, 0xCF, 0xA5, 0xCF, 0xA7, 0xCF,
+		0xA9, 0xCF, 0xAB, 0xCF, 0xAD, 0xCF, 0xAF, 0xCE,
+		0xB8, 0xD1, 0x90, 0xD1, 0x91, 0xD1, 0x92, 0xD1,
+		0x93, 0xD1, 0x94, 0xD1, 0x95, 0xD1, 0x96, 0xD1,
+		0x97, 0xD1, 0x98, 0xD1, 0x99, 0xD1, 0x9A, 0xD1,
+		0x9B, 0xD1, 0x9C, 0xD1, 0x9D, 0xD1, 0x9E, 0xD1,
+		0x9F, 0xD0, 0xB0, 0xD0, 0xB1, 0xD0, 0xB2, 0xD0,
+		0xB3, 0xD0, 0xB4, 0xD0, 0xB5, 0xD0, 0xB6, 0xD0,
+		0xB7, 0xD0, 0xB8, 0xD0, 0xB9, 0xD0, 0xBA, 0xD0,
+		0xBB, 0xD0, 0xBC, 0xD0, 0xBD, 0xD0, 0xBE, 0xD0,
+		0xBF, 0xD1, 0x80, 0xD1, 0x81, 0xD1, 0x82, 0xD1,
+		0x83, 0xD1, 0x84, 0xD1, 0x85, 0xD1, 0x86, 0xD1,
+		0x87, 0xD1, 0x88, 0xD1, 0x89, 0xD1, 0x8A, 0xD1,
+		0x8B, 0xD1, 0x8C, 0xD1, 0x8D, 0xD1, 0x8E, 0xD1,
+		0x8F, 0xD1, 0xA1, 0xD1, 0xA3, 0xD1, 0xA5, 0xD1,
+		0xA7, 0xD1, 0xA9, 0xD1, 0xAB, 0xD1, 0xAD, 0xD1,
+		0xAF, 0xD1, 0xB1, 0xD1, 0xB3, 0xD1, 0xB5, 0xD1,
+		0xB7, 0xD1, 0xB9, 0xD1, 0xBB, 0xD1, 0xBD, 0xD1,
+		0xBF, 0xD2, 0x81, 0xD2, 0x8B, 0xD2, 0x8D, 0xD2,
+		0x8F, 0xD2, 0x91, 0xD2, 0x93, 0xD2, 0x95, 0xD2,
+		0x97, 0xD2, 0x99, 0xD2, 0x9B, 0xD2, 0x9D, 0xD2,
+		0x9F, 0xD2, 0xA1, 0xD2, 0xA3, 0xD2, 0xA5, 0xD2,
+		0xA7, 0xD2, 0xA9, 0xD2, 0xAB, 0xD2, 0xAD, 0xD2,
+		0xAF, 0xD2, 0xB1, 0xD2, 0xB3, 0xD2, 0xB5, 0xD2,
+		0xB7, 0xD2, 0xB9, 0xD2, 0xBB, 0xD2, 0xBD, 0xD2,
+		0xBF, 0xD3, 0x82, 0xD3, 0x84, 0xD3, 0x86, 0xD3,
+		0x88, 0xD3, 0x8A, 0xD3, 0x8C, 0xD3, 0x8E, 0xD3,
+		0x91, 0xD3, 0x93, 0xD3, 0x95, 0xD3, 0x97, 0xD3,
+		0x99, 0xD3, 0x9B, 0xD3, 0x9D, 0xD3, 0x9F, 0xD3,
+		0xA1, 0xD3, 0xA3, 0xD3, 0xA5, 0xD3, 0xA7, 0xD3,
+		0xA9, 0xD3, 0xAB, 0xD3, 0xAD, 0xD3, 0xAF, 0xD3,
+		0xB1, 0xD3, 0xB3, 0xD3, 0xB5, 0xD3, 0xB9, 0xD4,
+		0x81, 0xD4, 0x83, 0xD4, 0x85, 0xD4, 0x87, 0xD4,
+		0x89, 0xD4, 0x8B, 0xD4, 0x8D, 0xD4, 0x8F, 0xD5,
+		0xA1, 0xD5, 0xA2, 0xD5, 0xA3, 0xD5, 0xA4, 0xD5,
+		0xA5, 0xD5, 0xA6, 0xD5, 0xA7, 0xD5, 0xA8, 0xD5,
+		0xA9, 0xD5, 0xAA, 0xD5, 0xAB, 0xD5, 0xAC, 0xD5,
+		0xAD, 0xD5, 0xAE, 0xD5, 0xAF, 0xD5, 0xB0, 0xD5,
+		0xB1, 0xD5, 0xB2, 0xD5, 0xB3, 0xD5, 0xB4, 0xD5,
+		0xB5, 0xD5, 0xB6, 0xD5, 0xB7, 0xD5, 0xB8, 0xD5,
+		0xB9, 0xD5, 0xBA, 0xD5, 0xBB, 0xD5, 0xBC, 0xD5,
+		0xBD, 0xD5, 0xBE, 0xD5, 0xBF, 0xD6, 0x80, 0xD6,
+		0x81, 0xD6, 0x82, 0xD6, 0x83, 0xD6, 0x84, 0xD6,
+		0x85, 0xD6, 0x86, 0xE1, 0xB8, 0x81, 0xE1, 0xB8,
+		0x83, 0xE1, 0xB8, 0x85, 0xE1, 0xB8, 0x87, 0xE1,
+		0xB8, 0x89, 0xE1, 0xB8, 0x8B, 0xE1, 0xB8, 0x8D,
+		0xE1, 0xB8, 0x8F, 0xE1, 0xB8, 0x91, 0xE1, 0xB8,
+		0x93, 0xE1, 0xB8, 0x95, 0xE1, 0xB8, 0x97, 0xE1,
+		0xB8, 0x99, 0xE1, 0xB8, 0x9B, 0xE1, 0xB8, 0x9D,
+		0xE1, 0xB8, 0x9F, 0xE1, 0xB8, 0xA1, 0xE1, 0xB8,
+		0xA3, 0xE1, 0xB8, 0xA5, 0xE1, 0xB8, 0xA7, 0xE1,
+		0xB8, 0xA9, 0xE1, 0xB8, 0xAB, 0xE1, 0xB8, 0xAD,
+		0xE1, 0xB8, 0xAF, 0xE1, 0xB8, 0xB1, 0xE1, 0xB8,
+		0xB3, 0xE1, 0xB8, 0xB5, 0xE1, 0xB8, 0xB7, 0xE1,
+		0xB8, 0xB9, 0xE1, 0xB8, 0xBB, 0xE1, 0xB8, 0xBD,
+		0xE1, 0xB8, 0xBF, 0xE1, 0xB9, 0x81, 0xE1, 0xB9,
+		0x83, 0xE1, 0xB9, 0x85, 0xE1, 0xB9, 0x87, 0xE1,
+		0xB9, 0x89, 0xE1, 0xB9, 0x8B, 0xE1, 0xB9, 0x8D,
+		0xE1, 0xB9, 0x8F, 0xE1, 0xB9, 0x91, 0xE1, 0xB9,
+		0x93, 0xE1, 0xB9, 0x95, 0xE1, 0xB9, 0x97, 0xE1,
+		0xB9, 0x99, 0xE1, 0xB9, 0x9B, 0xE1, 0xB9, 0x9D,
+		0xE1, 0xB9, 0x9F, 0xE1, 0xB9, 0xA1, 0xE1, 0xB9,
+		0xA3, 0xE1, 0xB9, 0xA5, 0xE1, 0xB9, 0xA7, 0xE1,
+		0xB9, 0xA9, 0xE1, 0xB9, 0xAB, 0xE1, 0xB9, 0xAD,
+		0xE1, 0xB9, 0xAF, 0xE1, 0xB9, 0xB1, 0xE1, 0xB9,
+		0xB3, 0xE1, 0xB9, 0xB5, 0xE1, 0xB9, 0xB7, 0xE1,
+		0xB9, 0xB9, 0xE1, 0xB9, 0xBB, 0xE1, 0xB9, 0xBD,
+		0xE1, 0xB9, 0xBF, 0xE1, 0xBA, 0x81, 0xE1, 0xBA,
+		0x83, 0xE1, 0xBA, 0x85, 0xE1, 0xBA, 0x87, 0xE1,
+		0xBA, 0x89, 0xE1, 0xBA, 0x8B, 0xE1, 0xBA, 0x8D,
+		0xE1, 0xBA, 0x8F, 0xE1, 0xBA, 0x91, 0xE1, 0xBA,
+		0x93, 0xE1, 0xBA, 0x95, 0xE1, 0xBA, 0xA1, 0xE1,
+		0xBA, 0xA3, 0xE1, 0xBA, 0xA5, 0xE1, 0xBA, 0xA7,
+		0xE1, 0xBA, 0xA9, 0xE1, 0xBA, 0xAB, 0xE1, 0xBA,
+		0xAD, 0xE1, 0xBA, 0xAF, 0xE1, 0xBA, 0xB1, 0xE1,
+		0xBA, 0xB3, 0xE1, 0xBA, 0xB5, 0xE1, 0xBA, 0xB7,
+		0xE1, 0xBA, 0xB9, 0xE1, 0xBA, 0xBB, 0xE1, 0xBA,
+		0xBD, 0xE1, 0xBA, 0xBF, 0xE1, 0xBB, 0x81, 0xE1,
+		0xBB, 0x83, 0xE1, 0xBB, 0x85, 0xE1, 0xBB, 0x87,
+		0xE1, 0xBB, 0x89, 0xE1, 0xBB, 0x8B, 0xE1, 0xBB,
+		0x8D, 0xE1, 0xBB, 0x8F, 0xE1, 0xBB, 0x91, 0xE1,
+		0xBB, 0x93, 0xE1, 0xBB, 0x95, 0xE1, 0xBB, 0x97,
+		0xE1, 0xBB, 0x99, 0xE1, 0xBB, 0x9B, 0xE1, 0xBB,
+		0x9D, 0xE1, 0xBB, 0x9F, 0xE1, 0xBB, 0xA1, 0xE1,
+		0xBB, 0xA3, 0xE1, 0xBB, 0xA5, 0xE1, 0xBB, 0xA7,
+		0xE1, 0xBB, 0xA9, 0xE1, 0xBB, 0xAB, 0xE1, 0xBB,
+		0xAD, 0xE1, 0xBB, 0xAF, 0xE1, 0xBB, 0xB1, 0xE1,
+		0xBB, 0xB3, 0xE1, 0xBB, 0xB5, 0xE1, 0xBB, 0xB7,
+		0xE1, 0xBB, 0xB9, 0xE1, 0xBC, 0x80, 0xE1, 0xBC,
+		0x81, 0xE1, 0xBC, 0x82, 0xE1, 0xBC, 0x83, 0xE1,
+		0xBC, 0x84, 0xE1, 0xBC, 0x85, 0xE1, 0xBC, 0x86,
+		0xE1, 0xBC, 0x87, 0xE1, 0xBC, 0x90, 0xE1, 0xBC,
+		0x91, 0xE1, 0xBC, 0x92, 0xE1, 0xBC, 0x93, 0xE1,
+		0xBC, 0x94, 0xE1, 0xBC, 0x95, 0xE1, 0xBC, 0xA0,
+		0xE1, 0xBC, 0xA1, 0xE1, 0xBC, 0xA2, 0xE1, 0xBC,
+		0xA3, 0xE1, 0xBC, 0xA4, 0xE1, 0xBC, 0xA5, 0xE1,
+		0xBC, 0xA6, 0xE1, 0xBC, 0xA7, 0xE1, 0xBC, 0xB0,
+		0xE1, 0xBC, 0xB1, 0xE1, 0xBC, 0xB2, 0xE1, 0xBC,
+		0xB3, 0xE1, 0xBC, 0xB4, 0xE1, 0xBC, 0xB5, 0xE1,
+		0xBC, 0xB6, 0xE1, 0xBC, 0xB7, 0xE1, 0xBD, 0x80,
+		0xE1, 0xBD, 0x81, 0xE1, 0xBD, 0x82, 0xE1, 0xBD,
+		0x83, 0xE1, 0xBD, 0x84, 0xE1, 0xBD, 0x85, 0xE1,
+		0xBD, 0x91, 0xE1, 0xBD, 0x93, 0xE1, 0xBD, 0x95,
+		0xE1, 0xBD, 0x97, 0xE1, 0xBD, 0xA0, 0xE1, 0xBD,
+		0xA1, 0xE1, 0xBD, 0xA2, 0xE1, 0xBD, 0xA3, 0xE1,
+		0xBD, 0xA4, 0xE1, 0xBD, 0xA5, 0xE1, 0xBD, 0xA6,
+		0xE1, 0xBD, 0xA7, 0xE1, 0xBE, 0x80, 0xE1, 0xBE,
+		0x81, 0xE1, 0xBE, 0x82, 0xE1, 0xBE, 0x83, 0xE1,
+		0xBE, 0x84, 0xE1, 0xBE, 0x85, 0xE1, 0xBE, 0x86,
+		0xE1, 0xBE, 0x87, 0xE1, 0xBE, 0x90, 0xE1, 0xBE,
+		0x91, 0xE1, 0xBE, 0x92, 0xE1, 0xBE, 0x93, 0xE1,
+		0xBE, 0x94, 0xE1, 0xBE, 0x95, 0xE1, 0xBE, 0x96,
+		0xE1, 0xBE, 0x97, 0xE1, 0xBE, 0xA0, 0xE1, 0xBE,
+		0xA1, 0xE1, 0xBE, 0xA2, 0xE1, 0xBE, 0xA3, 0xE1,
+		0xBE, 0xA4, 0xE1, 0xBE, 0xA5, 0xE1, 0xBE, 0xA6,
+		0xE1, 0xBE, 0xA7, 0xE1, 0xBE, 0xB0, 0xE1, 0xBE,
+		0xB1, 0xE1, 0xBD, 0xB0, 0xE1, 0xBD, 0xB1, 0xE1,
+		0xBE, 0xB3, 0xE1, 0xBD, 0xB2, 0xE1, 0xBD, 0xB3,
+		0xE1, 0xBD, 0xB4, 0xE1, 0xBD, 0xB5, 0xE1, 0xBF,
+		0x83, 0xE1, 0xBF, 0x90, 0xE1, 0xBF, 0x91, 0xE1,
+		0xBD, 0xB6, 0xE1, 0xBD, 0xB7, 0xE1, 0xBF, 0xA0,
+		0xE1, 0xBF, 0xA1, 0xE1, 0xBD, 0xBA, 0xE1, 0xBD,
+		0xBB, 0xE1, 0xBF, 0xA5, 0xE1, 0xBD, 0xB8, 0xE1,
+		0xBD, 0xB9, 0xE1, 0xBD, 0xBC, 0xE1, 0xBD, 0xBD,
+		0xE1, 0xBF, 0xB3, 0xCF, 0x89, 0x6B, 0xC3, 0xA5,
+		0xE2, 0x85, 0xB0, 0xE2, 0x85, 0xB1, 0xE2, 0x85,
+		0xB2, 0xE2, 0x85, 0xB3, 0xE2, 0x85, 0xB4, 0xE2,
+		0x85, 0xB5, 0xE2, 0x85, 0xB6, 0xE2, 0x85, 0xB7,
+		0xE2, 0x85, 0xB8, 0xE2, 0x85, 0xB9, 0xE2, 0x85,
+		0xBA, 0xE2, 0x85, 0xBB, 0xE2, 0x85, 0xBC, 0xE2,
+		0x85, 0xBD, 0xE2, 0x85, 0xBE, 0xE2, 0x85, 0xBF,
+		0xE2, 0x93, 0x90, 0xE2, 0x93, 0x91, 0xE2, 0x93,
+		0x92, 0xE2, 0x93, 0x93, 0xE2, 0x93, 0x94, 0xE2,
+		0x93, 0x95, 0xE2, 0x93, 0x96, 0xE2, 0x93, 0x97,
+		0xE2, 0x93, 0x98, 0xE2, 0x93, 0x99, 0xE2, 0x93,
+		0x9A, 0xE2, 0x93, 0x9B, 0xE2, 0x93, 0x9C, 0xE2,
+		0x93, 0x9D, 0xE2, 0x93, 0x9E, 0xE2, 0x93, 0x9F,
+		0xE2, 0x93, 0xA0, 0xE2, 0x93, 0xA1, 0xE2, 0x93,
+		0xA2, 0xE2, 0x93, 0xA3, 0xE2, 0x93, 0xA4, 0xE2,
+		0x93, 0xA5, 0xE2, 0x93, 0xA6, 0xE2, 0x93, 0xA7,
+		0xE2, 0x93, 0xA8, 0xE2, 0x93, 0xA9, 0xEF, 0xBD,
+		0x81, 0xEF, 0xBD, 0x82, 0xEF, 0xBD, 0x83, 0xEF,
+		0xBD, 0x84, 0xEF, 0xBD, 0x85, 0xEF, 0xBD, 0x86,
+		0xEF, 0xBD, 0x87, 0xEF, 0xBD, 0x88, 0xEF, 0xBD,
+		0x89, 0xEF, 0xBD, 0x8A, 0xEF, 0xBD, 0x8B, 0xEF,
+		0xBD, 0x8C, 0xEF, 0xBD, 0x8D, 0xEF, 0xBD, 0x8E,
+		0xEF, 0xBD, 0x8F, 0xEF, 0xBD, 0x90, 0xEF, 0xBD,
+		0x91, 0xEF, 0xBD, 0x92, 0xEF, 0xBD, 0x93, 0xEF,
+		0xBD, 0x94, 0xEF, 0xBD, 0x95, 0xEF, 0xBD, 0x96,
+		0xEF, 0xBD, 0x97, 0xEF, 0xBD, 0x98, 0xEF, 0xBD,
+		0x99, 0xEF, 0xBD, 0x9A, 0xF0, 0x90, 0x90, 0xA8,
+		0xF0, 0x90, 0x90, 0xA9, 0xF0, 0x90, 0x90, 0xAA,
+		0xF0, 0x90, 0x90, 0xAB, 0xF0, 0x90, 0x90, 0xAC,
+		0xF0, 0x90, 0x90, 0xAD, 0xF0, 0x90, 0x90, 0xAE,
+		0xF0, 0x90, 0x90, 0xAF, 0xF0, 0x90, 0x90, 0xB0,
+		0xF0, 0x90, 0x90, 0xB1, 0xF0, 0x90, 0x90, 0xB2,
+		0xF0, 0x90, 0x90, 0xB3, 0xF0, 0x90, 0x90, 0xB4,
+		0xF0, 0x90, 0x90, 0xB5, 0xF0, 0x90, 0x90, 0xB6,
+		0xF0, 0x90, 0x90, 0xB7, 0xF0, 0x90, 0x90, 0xB8,
+		0xF0, 0x90, 0x90, 0xB9, 0xF0, 0x90, 0x90, 0xBA,
+		0xF0, 0x90, 0x90, 0xBB, 0xF0, 0x90, 0x90, 0xBC,
+		0xF0, 0x90, 0x90, 0xBD, 0xF0, 0x90, 0x90, 0xBE,
+		0xF0, 0x90, 0x90, 0xBF, 0xF0, 0x90, 0x91, 0x80,
+		0xF0, 0x90, 0x91, 0x81, 0xF0, 0x90, 0x91, 0x82,
+		0xF0, 0x90, 0x91, 0x83, 0xF0, 0x90, 0x91, 0x84,
+		0xF0, 0x90, 0x91, 0x85, 0xF0, 0x90, 0x91, 0x86,
+		0xF0, 0x90, 0x91, 0x87, 0xF0, 0x90, 0x91, 0x88,
+		0xF0, 0x90, 0x91, 0x89, 0xF0, 0x90, 0x91, 0x8A,
+		0xF0, 0x90, 0x91, 0x8B, 0xF0, 0x90, 0x91, 0x8C,
+		0xF0, 0x90, 0x91, 0x8D, 0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,
+	},
+	{
+		0xC3, 0xA0, 0xC3, 0xA1, 0xC3, 0xA2, 0xC3, 0xA3,
+		0xC3, 0xA4, 0xC3, 0xA5, 0xC3, 0xA6, 0xC3, 0xA7,
+		0xC3, 0xA8, 0xC3, 0xA9, 0xC3, 0xAA, 0xC3, 0xAB,
+		0xC3, 0xAC, 0xC3, 0xAD, 0xC3, 0xAE, 0xC3, 0xAF,
+		0xC3, 0xB0, 0xC3, 0xB1, 0xC3, 0xB2, 0xC3, 0xB3,
+		0xC3, 0xB4, 0xC3, 0xB5, 0xC3, 0xB6, 0xC3, 0xB8,
+		0xC3, 0xB9, 0xC3, 0xBA, 0xC3, 0xBB, 0xC3, 0xBC,
+		0xC3, 0xBD, 0xC3, 0xBE, 0xC4, 0x81, 0xC4, 0x83,
+		0xC4, 0x85, 0xC4, 0x87, 0xC4, 0x89, 0xC4, 0x8B,
+		0xC4, 0x8D, 0xC4, 0x8F, 0xC4, 0x91, 0xC4, 0x93,
+		0xC4, 0x95, 0xC4, 0x97, 0xC4, 0x99, 0xC4, 0x9B,
+		0xC4, 0x9D, 0xC4, 0x9F, 0xC4, 0xA1, 0xC4, 0xA3,
+		0xC4, 0xA5, 0xC4, 0xA7, 0xC4, 0xA9, 0xC4, 0xAB,
+		0xC4, 0xAD, 0xC4, 0xAF, 0x69, 0xC4, 0xB3, 0xC4,
+		0xB5, 0xC4, 0xB7, 0xC4, 0xBA, 0xC4, 0xBC, 0xC4,
+		0xBE, 0xC5, 0x80, 0xC5, 0x82, 0xC5, 0x84, 0xC5,
+		0x86, 0xC5, 0x88, 0xC5, 0x8B, 0xC5, 0x8D, 0xC5,
+		0x8F, 0xC5, 0x91, 0xC5, 0x93, 0xC5, 0x95, 0xC5,
+		0x97, 0xC5, 0x99, 0xC5, 0x9B, 0xC5, 0x9D, 0xC5,
+		0x9F, 0xC5, 0xA1, 0xC5, 0xA3, 0xC5, 0xA5, 0xC5,
+		0xA7, 0xC5, 0xA9, 0xC5, 0xAB, 0xC5, 0xAD, 0xC5,
+		0xAF, 0xC5, 0xB1, 0xC5, 0xB3, 0xC5, 0xB5, 0xC5,
+		0xB7, 0xC3, 0xBF, 0xC5, 0xBA, 0xC5, 0xBC, 0xC5,
+		0xBE, 0xC9, 0x93, 0xC6, 0x83, 0xC6, 0x85, 0xC9,
+		0x94, 0xC6, 0x88, 0xC9, 0x96, 0xC9, 0x97, 0xC6,
+		0x8C, 0xC7, 0x9D, 0xC9, 0x99, 0xC9, 0x9B, 0xC6,
+		0x92, 0xC9, 0xA0, 0xC9, 0xA3, 0xC9, 0xA9, 0xC9,
+		0xA8, 0xC6, 0x99, 0xC9, 0xAF, 0xC9, 0xB2, 0xC9,
+		0xB5, 0xC6, 0xA1, 0xC6, 0xA3, 0xC6, 0xA5, 0xCA,
+		0x80, 0xC6, 0xA8, 0xCA, 0x83, 0xC6, 0xAD, 0xCA,
+		0x88, 0xC6, 0xB0, 0xCA, 0x8A, 0xCA, 0x8B, 0xC6,
+		0xB4, 0xC6, 0xB6, 0xCA, 0x92, 0xC6, 0xB9, 0xC6,
+		0xBD, 0xC7, 0x86, 0xC7, 0x86, 0xC7, 0x89, 0xC7,
+		0x89, 0xC7, 0x8C, 0xC7, 0x8C, 0xC7, 0x8E, 0xC7,
+		0x90, 0xC7, 0x92, 0xC7, 0x94, 0xC7, 0x96, 0xC7,
+		0x98, 0xC7, 0x9A, 0xC7, 0x9C, 0xC7, 0x9F, 0xC7,
+		0xA1, 0xC7, 0xA3, 0xC7, 0xA5, 0xC7, 0xA7, 0xC7,
+		0xA9, 0xC7, 0xAB, 0xC7, 0xAD, 0xC7, 0xAF, 0xC7,
+		0xB3, 0xC7, 0xB3, 0xC7, 0xB5, 0xC6, 0x95, 0xC6,
+		0xBF, 0xC7, 0xB9, 0xC7, 0xBB, 0xC7, 0xBD, 0xC7,
+		0xBF, 0xC8, 0x81, 0xC8, 0x83, 0xC8, 0x85, 0xC8,
+		0x87, 0xC8, 0x89, 0xC8, 0x8B, 0xC8, 0x8D, 0xC8,
+		0x8F, 0xC8, 0x91, 0xC8, 0x93, 0xC8, 0x95, 0xC8,
+		0x97, 0xC8, 0x99, 0xC8, 0x9B, 0xC8, 0x9D, 0xC8,
+		0x9F, 0xC6, 0x9E, 0xC8, 0xA3, 0xC8, 0xA5, 0xC8,
+		0xA7, 0xC8, 0xA9, 0xC8, 0xAB, 0xC8, 0xAD, 0xC8,
+		0xAF, 0xC8, 0xB1, 0xC8, 0xB3, 0xE2, 0xB1, 0xA5,
+		0xC8, 0xBC, 0xC6, 0x9A, 0xE2, 0xB1, 0xA6, 0xC9,
+		0x82, 0xC6, 0x80, 0xCA, 0x89, 0xCA, 0x8C, 0xC9,
+		0x87, 0xC9, 0x89, 0xC9, 0x8B, 0xC9, 0x8D, 0xC9,
+		0x8F, 0xCE, 0xAC, 0xCE, 0xAD, 0xCE, 0xAE, 0xCE,
+		0xAF, 0xCF, 0x8C, 0xCF, 0x8D, 0xCF, 0x8E, 0xCE,
+		0xB1, 0xCE, 0xB2, 0xCE, 0xB3, 0xCE, 0xB4, 0xCE,
+		0xB5, 0xCE, 0xB6, 0xCE, 0xB7, 0xCE, 0xB8, 0xCE,
+		0xB9, 0xCE, 0xBA, 0xCE, 0xBB, 0xCE, 0xBC, 0xCE,
+		0xBD, 0xCE, 0xBE, 0xCE, 0xBF, 0xCF, 0x80, 0xCF,
+		0x81, 0xCF, 0x83, 0xCF, 0x84, 0xCF, 0x85, 0xCF,
+		0x86, 0xCF, 0x87, 0xCF, 0x88, 0xCF, 0x89, 0xCF,
+		0x8A, 0xCF, 0x8B, 0xCF, 0x99, 0xCF, 0x9B, 0xCF,
+		0x9D, 0xCF, 0x9F, 0xCF, 0xA1, 0xCF, 0xA3, 0xCF,
+		0xA5, 0xCF, 0xA7, 0xCF, 0xA9, 0xCF, 0xAB, 0xCF,
+		0xAD, 0xCF, 0xAF, 0xCE, 0xB8, 0xCF, 0xB8, 0xCF,
+		0xB2, 0xCF, 0xBB, 0xCD, 0xBB, 0xCD, 0xBC, 0xCD,
+		0xBD, 0xD1, 0x90, 0xD1, 0x91, 0xD1, 0x92, 0xD1,
+		0x93, 0xD1, 0x94, 0xD1, 0x95, 0xD1, 0x96, 0xD1,
+		0x97, 0xD1, 0x98, 0xD1, 0x99, 0xD1, 0x9A, 0xD1,
+		0x9B, 0xD1, 0x9C, 0xD1, 0x9D, 0xD1, 0x9E, 0xD1,
+		0x9F, 0xD0, 0xB0, 0xD0, 0xB1, 0xD0, 0xB2, 0xD0,
+		0xB3, 0xD0, 0xB4, 0xD0, 0xB5, 0xD0, 0xB6, 0xD0,
+		0xB7, 0xD0, 0xB8, 0xD0, 0xB9, 0xD0, 0xBA, 0xD0,
+		0xBB, 0xD0, 0xBC, 0xD0, 0xBD, 0xD0, 0xBE, 0xD0,
+		0xBF, 0xD1, 0x80, 0xD1, 0x81, 0xD1, 0x82, 0xD1,
+		0x83, 0xD1, 0x84, 0xD1, 0x85, 0xD1, 0x86, 0xD1,
+		0x87, 0xD1, 0x88, 0xD1, 0x89, 0xD1, 0x8A, 0xD1,
+		0x8B, 0xD1, 0x8C, 0xD1, 0x8D, 0xD1, 0x8E, 0xD1,
+		0x8F, 0xD1, 0xA1, 0xD1, 0xA3, 0xD1, 0xA5, 0xD1,
+		0xA7, 0xD1, 0xA9, 0xD1, 0xAB, 0xD1, 0xAD, 0xD1,
+		0xAF, 0xD1, 0xB1, 0xD1, 0xB3, 0xD1, 0xB5, 0xD1,
+		0xB7, 0xD1, 0xB9, 0xD1, 0xBB, 0xD1, 0xBD, 0xD1,
+		0xBF, 0xD2, 0x81, 0xD2, 0x8B, 0xD2, 0x8D, 0xD2,
+		0x8F, 0xD2, 0x91, 0xD2, 0x93, 0xD2, 0x95, 0xD2,
+		0x97, 0xD2, 0x99, 0xD2, 0x9B, 0xD2, 0x9D, 0xD2,
+		0x9F, 0xD2, 0xA1, 0xD2, 0xA3, 0xD2, 0xA5, 0xD2,
+		0xA7, 0xD2, 0xA9, 0xD2, 0xAB, 0xD2, 0xAD, 0xD2,
+		0xAF, 0xD2, 0xB1, 0xD2, 0xB3, 0xD2, 0xB5, 0xD2,
+		0xB7, 0xD2, 0xB9, 0xD2, 0xBB, 0xD2, 0xBD, 0xD2,
+		0xBF, 0xD3, 0x8F, 0xD3, 0x82, 0xD3, 0x84, 0xD3,
+		0x86, 0xD3, 0x88, 0xD3, 0x8A, 0xD3, 0x8C, 0xD3,
+		0x8E, 0xD3, 0x91, 0xD3, 0x93, 0xD3, 0x95, 0xD3,
+		0x97, 0xD3, 0x99, 0xD3, 0x9B, 0xD3, 0x9D, 0xD3,
+		0x9F, 0xD3, 0xA1, 0xD3, 0xA3, 0xD3, 0xA5, 0xD3,
+		0xA7, 0xD3, 0xA9, 0xD3, 0xAB, 0xD3, 0xAD, 0xD3,
+		0xAF, 0xD3, 0xB1, 0xD3, 0xB3, 0xD3, 0xB5, 0xD3,
+		0xB7, 0xD3, 0xB9, 0xD3, 0xBB, 0xD3, 0xBD, 0xD3,
+		0xBF, 0xD4, 0x81, 0xD4, 0x83, 0xD4, 0x85, 0xD4,
+		0x87, 0xD4, 0x89, 0xD4, 0x8B, 0xD4, 0x8D, 0xD4,
+		0x8F, 0xD4, 0x91, 0xD4, 0x93, 0xD5, 0xA1, 0xD5,
+		0xA2, 0xD5, 0xA3, 0xD5, 0xA4, 0xD5, 0xA5, 0xD5,
+		0xA6, 0xD5, 0xA7, 0xD5, 0xA8, 0xD5, 0xA9, 0xD5,
+		0xAA, 0xD5, 0xAB, 0xD5, 0xAC, 0xD5, 0xAD, 0xD5,
+		0xAE, 0xD5, 0xAF, 0xD5, 0xB0, 0xD5, 0xB1, 0xD5,
+		0xB2, 0xD5, 0xB3, 0xD5, 0xB4, 0xD5, 0xB5, 0xD5,
+		0xB6, 0xD5, 0xB7, 0xD5, 0xB8, 0xD5, 0xB9, 0xD5,
+		0xBA, 0xD5, 0xBB, 0xD5, 0xBC, 0xD5, 0xBD, 0xD5,
+		0xBE, 0xD5, 0xBF, 0xD6, 0x80, 0xD6, 0x81, 0xD6,
+		0x82, 0xD6, 0x83, 0xD6, 0x84, 0xD6, 0x85, 0xD6,
+		0x86, 0xE2, 0xB4, 0x80, 0xE2, 0xB4, 0x81, 0xE2,
+		0xB4, 0x82, 0xE2, 0xB4, 0x83, 0xE2, 0xB4, 0x84,
+		0xE2, 0xB4, 0x85, 0xE2, 0xB4, 0x86, 0xE2, 0xB4,
+		0x87, 0xE2, 0xB4, 0x88, 0xE2, 0xB4, 0x89, 0xE2,
+		0xB4, 0x8A, 0xE2, 0xB4, 0x8B, 0xE2, 0xB4, 0x8C,
+		0xE2, 0xB4, 0x8D, 0xE2, 0xB4, 0x8E, 0xE2, 0xB4,
+		0x8F, 0xE2, 0xB4, 0x90, 0xE2, 0xB4, 0x91, 0xE2,
+		0xB4, 0x92, 0xE2, 0xB4, 0x93, 0xE2, 0xB4, 0x94,
+		0xE2, 0xB4, 0x95, 0xE2, 0xB4, 0x96, 0xE2, 0xB4,
+		0x97, 0xE2, 0xB4, 0x98, 0xE2, 0xB4, 0x99, 0xE2,
+		0xB4, 0x9A, 0xE2, 0xB4, 0x9B, 0xE2, 0xB4, 0x9C,
+		0xE2, 0xB4, 0x9D, 0xE2, 0xB4, 0x9E, 0xE2, 0xB4,
+		0x9F, 0xE2, 0xB4, 0xA0, 0xE2, 0xB4, 0xA1, 0xE2,
+		0xB4, 0xA2, 0xE2, 0xB4, 0xA3, 0xE2, 0xB4, 0xA4,
+		0xE2, 0xB4, 0xA5, 0xE1, 0xB8, 0x81, 0xE1, 0xB8,
+		0x83, 0xE1, 0xB8, 0x85, 0xE1, 0xB8, 0x87, 0xE1,
+		0xB8, 0x89, 0xE1, 0xB8, 0x8B, 0xE1, 0xB8, 0x8D,
+		0xE1, 0xB8, 0x8F, 0xE1, 0xB8, 0x91, 0xE1, 0xB8,
+		0x93, 0xE1, 0xB8, 0x95, 0xE1, 0xB8, 0x97, 0xE1,
+		0xB8, 0x99, 0xE1, 0xB8, 0x9B, 0xE1, 0xB8, 0x9D,
+		0xE1, 0xB8, 0x9F, 0xE1, 0xB8, 0xA1, 0xE1, 0xB8,
+		0xA3, 0xE1, 0xB8, 0xA5, 0xE1, 0xB8, 0xA7, 0xE1,
+		0xB8, 0xA9, 0xE1, 0xB8, 0xAB, 0xE1, 0xB8, 0xAD,
+		0xE1, 0xB8, 0xAF, 0xE1, 0xB8, 0xB1, 0xE1, 0xB8,
+		0xB3, 0xE1, 0xB8, 0xB5, 0xE1, 0xB8, 0xB7, 0xE1,
+		0xB8, 0xB9, 0xE1, 0xB8, 0xBB, 0xE1, 0xB8, 0xBD,
+		0xE1, 0xB8, 0xBF, 0xE1, 0xB9, 0x81, 0xE1, 0xB9,
+		0x83, 0xE1, 0xB9, 0x85, 0xE1, 0xB9, 0x87, 0xE1,
+		0xB9, 0x89, 0xE1, 0xB9, 0x8B, 0xE1, 0xB9, 0x8D,
+		0xE1, 0xB9, 0x8F, 0xE1, 0xB9, 0x91, 0xE1, 0xB9,
+		0x93, 0xE1, 0xB9, 0x95, 0xE1, 0xB9, 0x97, 0xE1,
+		0xB9, 0x99, 0xE1, 0xB9, 0x9B, 0xE1, 0xB9, 0x9D,
+		0xE1, 0xB9, 0x9F, 0xE1, 0xB9, 0xA1, 0xE1, 0xB9,
+		0xA3, 0xE1, 0xB9, 0xA5, 0xE1, 0xB9, 0xA7, 0xE1,
+		0xB9, 0xA9, 0xE1, 0xB9, 0xAB, 0xE1, 0xB9, 0xAD,
+		0xE1, 0xB9, 0xAF, 0xE1, 0xB9, 0xB1, 0xE1, 0xB9,
+		0xB3, 0xE1, 0xB9, 0xB5, 0xE1, 0xB9, 0xB7, 0xE1,
+		0xB9, 0xB9, 0xE1, 0xB9, 0xBB, 0xE1, 0xB9, 0xBD,
+		0xE1, 0xB9, 0xBF, 0xE1, 0xBA, 0x81, 0xE1, 0xBA,
+		0x83, 0xE1, 0xBA, 0x85, 0xE1, 0xBA, 0x87, 0xE1,
+		0xBA, 0x89, 0xE1, 0xBA, 0x8B, 0xE1, 0xBA, 0x8D,
+		0xE1, 0xBA, 0x8F, 0xE1, 0xBA, 0x91, 0xE1, 0xBA,
+		0x93, 0xE1, 0xBA, 0x95, 0xE1, 0xBA, 0xA1, 0xE1,
+		0xBA, 0xA3, 0xE1, 0xBA, 0xA5, 0xE1, 0xBA, 0xA7,
+		0xE1, 0xBA, 0xA9, 0xE1, 0xBA, 0xAB, 0xE1, 0xBA,
+		0xAD, 0xE1, 0xBA, 0xAF, 0xE1, 0xBA, 0xB1, 0xE1,
+		0xBA, 0xB3, 0xE1, 0xBA, 0xB5, 0xE1, 0xBA, 0xB7,
+		0xE1, 0xBA, 0xB9, 0xE1, 0xBA, 0xBB, 0xE1, 0xBA,
+		0xBD, 0xE1, 0xBA, 0xBF, 0xE1, 0xBB, 0x81, 0xE1,
+		0xBB, 0x83, 0xE1, 0xBB, 0x85, 0xE1, 0xBB, 0x87,
+		0xE1, 0xBB, 0x89, 0xE1, 0xBB, 0x8B, 0xE1, 0xBB,
+		0x8D, 0xE1, 0xBB, 0x8F, 0xE1, 0xBB, 0x91, 0xE1,
+		0xBB, 0x93, 0xE1, 0xBB, 0x95, 0xE1, 0xBB, 0x97,
+		0xE1, 0xBB, 0x99, 0xE1, 0xBB, 0x9B, 0xE1, 0xBB,
+		0x9D, 0xE1, 0xBB, 0x9F, 0xE1, 0xBB, 0xA1, 0xE1,
+		0xBB, 0xA3, 0xE1, 0xBB, 0xA5, 0xE1, 0xBB, 0xA7,
+		0xE1, 0xBB, 0xA9, 0xE1, 0xBB, 0xAB, 0xE1, 0xBB,
+		0xAD, 0xE1, 0xBB, 0xAF, 0xE1, 0xBB, 0xB1, 0xE1,
+		0xBB, 0xB3, 0xE1, 0xBB, 0xB5, 0xE1, 0xBB, 0xB7,
+		0xE1, 0xBB, 0xB9, 0xE1, 0xBC, 0x80, 0xE1, 0xBC,
+		0x81, 0xE1, 0xBC, 0x82, 0xE1, 0xBC, 0x83, 0xE1,
+		0xBC, 0x84, 0xE1, 0xBC, 0x85, 0xE1, 0xBC, 0x86,
+		0xE1, 0xBC, 0x87, 0xE1, 0xBC, 0x90, 0xE1, 0xBC,
+		0x91, 0xE1, 0xBC, 0x92, 0xE1, 0xBC, 0x93, 0xE1,
+		0xBC, 0x94, 0xE1, 0xBC, 0x95, 0xE1, 0xBC, 0xA0,
+		0xE1, 0xBC, 0xA1, 0xE1, 0xBC, 0xA2, 0xE1, 0xBC,
+		0xA3, 0xE1, 0xBC, 0xA4, 0xE1, 0xBC, 0xA5, 0xE1,
+		0xBC, 0xA6, 0xE1, 0xBC, 0xA7, 0xE1, 0xBC, 0xB0,
+		0xE1, 0xBC, 0xB1, 0xE1, 0xBC, 0xB2, 0xE1, 0xBC,
+		0xB3, 0xE1, 0xBC, 0xB4, 0xE1, 0xBC, 0xB5, 0xE1,
+		0xBC, 0xB6, 0xE1, 0xBC, 0xB7, 0xE1, 0xBD, 0x80,
+		0xE1, 0xBD, 0x81, 0xE1, 0xBD, 0x82, 0xE1, 0xBD,
+		0x83, 0xE1, 0xBD, 0x84, 0xE1, 0xBD, 0x85, 0xE1,
+		0xBD, 0x91, 0xE1, 0xBD, 0x93, 0xE1, 0xBD, 0x95,
+		0xE1, 0xBD, 0x97, 0xE1, 0xBD, 0xA0, 0xE1, 0xBD,
+		0xA1, 0xE1, 0xBD, 0xA2, 0xE1, 0xBD, 0xA3, 0xE1,
+		0xBD, 0xA4, 0xE1, 0xBD, 0xA5, 0xE1, 0xBD, 0xA6,
+		0xE1, 0xBD, 0xA7, 0xE1, 0xBE, 0x80, 0xE1, 0xBE,
+		0x81, 0xE1, 0xBE, 0x82, 0xE1, 0xBE, 0x83, 0xE1,
+		0xBE, 0x84, 0xE1, 0xBE, 0x85, 0xE1, 0xBE, 0x86,
+		0xE1, 0xBE, 0x87, 0xE1, 0xBE, 0x90, 0xE1, 0xBE,
+		0x91, 0xE1, 0xBE, 0x92, 0xE1, 0xBE, 0x93, 0xE1,
+		0xBE, 0x94, 0xE1, 0xBE, 0x95, 0xE1, 0xBE, 0x96,
+		0xE1, 0xBE, 0x97, 0xE1, 0xBE, 0xA0, 0xE1, 0xBE,
+		0xA1, 0xE1, 0xBE, 0xA2, 0xE1, 0xBE, 0xA3, 0xE1,
+		0xBE, 0xA4, 0xE1, 0xBE, 0xA5, 0xE1, 0xBE, 0xA6,
+		0xE1, 0xBE, 0xA7, 0xE1, 0xBE, 0xB0, 0xE1, 0xBE,
+		0xB1, 0xE1, 0xBD, 0xB0, 0xE1, 0xBD, 0xB1, 0xE1,
+		0xBE, 0xB3, 0xE1, 0xBD, 0xB2, 0xE1, 0xBD, 0xB3,
+		0xE1, 0xBD, 0xB4, 0xE1, 0xBD, 0xB5, 0xE1, 0xBF,
+		0x83, 0xE1, 0xBF, 0x90, 0xE1, 0xBF, 0x91, 0xE1,
+		0xBD, 0xB6, 0xE1, 0xBD, 0xB7, 0xE1, 0xBF, 0xA0,
+		0xE1, 0xBF, 0xA1, 0xE1, 0xBD, 0xBA, 0xE1, 0xBD,
+		0xBB, 0xE1, 0xBF, 0xA5, 0xE1, 0xBD, 0xB8, 0xE1,
+		0xBD, 0xB9, 0xE1, 0xBD, 0xBC, 0xE1, 0xBD, 0xBD,
+		0xE1, 0xBF, 0xB3, 0xCF, 0x89, 0x6B, 0xC3, 0xA5,
+		0xE2, 0x85, 0x8E, 0xE2, 0x85, 0xB0, 0xE2, 0x85,
+		0xB1, 0xE2, 0x85, 0xB2, 0xE2, 0x85, 0xB3, 0xE2,
+		0x85, 0xB4, 0xE2, 0x85, 0xB5, 0xE2, 0x85, 0xB6,
+		0xE2, 0x85, 0xB7, 0xE2, 0x85, 0xB8, 0xE2, 0x85,
+		0xB9, 0xE2, 0x85, 0xBA, 0xE2, 0x85, 0xBB, 0xE2,
+		0x85, 0xBC, 0xE2, 0x85, 0xBD, 0xE2, 0x85, 0xBE,
+		0xE2, 0x85, 0xBF, 0xE2, 0x86, 0x84, 0xE2, 0x93,
+		0x90, 0xE2, 0x93, 0x91, 0xE2, 0x93, 0x92, 0xE2,
+		0x93, 0x93, 0xE2, 0x93, 0x94, 0xE2, 0x93, 0x95,
+		0xE2, 0x93, 0x96, 0xE2, 0x93, 0x97, 0xE2, 0x93,
+		0x98, 0xE2, 0x93, 0x99, 0xE2, 0x93, 0x9A, 0xE2,
+		0x93, 0x9B, 0xE2, 0x93, 0x9C, 0xE2, 0x93, 0x9D,
+		0xE2, 0x93, 0x9E, 0xE2, 0x93, 0x9F, 0xE2, 0x93,
+		0xA0, 0xE2, 0x93, 0xA1, 0xE2, 0x93, 0xA2, 0xE2,
+		0x93, 0xA3, 0xE2, 0x93, 0xA4, 0xE2, 0x93, 0xA5,
+		0xE2, 0x93, 0xA6, 0xE2, 0x93, 0xA7, 0xE2, 0x93,
+		0xA8, 0xE2, 0x93, 0xA9, 0xE2, 0xB0, 0xB0, 0xE2,
+		0xB0, 0xB1, 0xE2, 0xB0, 0xB2, 0xE2, 0xB0, 0xB3,
+		0xE2, 0xB0, 0xB4, 0xE2, 0xB0, 0xB5, 0xE2, 0xB0,
+		0xB6, 0xE2, 0xB0, 0xB7, 0xE2, 0xB0, 0xB8, 0xE2,
+		0xB0, 0xB9, 0xE2, 0xB0, 0xBA, 0xE2, 0xB0, 0xBB,
+		0xE2, 0xB0, 0xBC, 0xE2, 0xB0, 0xBD, 0xE2, 0xB0,
+		0xBE, 0xE2, 0xB0, 0xBF, 0xE2, 0xB1, 0x80, 0xE2,
+		0xB1, 0x81, 0xE2, 0xB1, 0x82, 0xE2, 0xB1, 0x83,
+		0xE2, 0xB1, 0x84, 0xE2, 0xB1, 0x85, 0xE2, 0xB1,
+		0x86, 0xE2, 0xB1, 0x87, 0xE2, 0xB1, 0x88, 0xE2,
+		0xB1, 0x89, 0xE2, 0xB1, 0x8A, 0xE2, 0xB1, 0x8B,
+		0xE2, 0xB1, 0x8C, 0xE2, 0xB1, 0x8D, 0xE2, 0xB1,
+		0x8E, 0xE2, 0xB1, 0x8F, 0xE2, 0xB1, 0x90, 0xE2,
+		0xB1, 0x91, 0xE2, 0xB1, 0x92, 0xE2, 0xB1, 0x93,
+		0xE2, 0xB1, 0x94, 0xE2, 0xB1, 0x95, 0xE2, 0xB1,
+		0x96, 0xE2, 0xB1, 0x97, 0xE2, 0xB1, 0x98, 0xE2,
+		0xB1, 0x99, 0xE2, 0xB1, 0x9A, 0xE2, 0xB1, 0x9B,
+		0xE2, 0xB1, 0x9C, 0xE2, 0xB1, 0x9D, 0xE2, 0xB1,
+		0x9E, 0xE2, 0xB1, 0xA1, 0xC9, 0xAB, 0xE1, 0xB5,
+		0xBD, 0xC9, 0xBD, 0xE2, 0xB1, 0xA8, 0xE2, 0xB1,
+		0xAA, 0xE2, 0xB1, 0xAC, 0xE2, 0xB1, 0xB6, 0xE2,
+		0xB2, 0x81, 0xE2, 0xB2, 0x83, 0xE2, 0xB2, 0x85,
+		0xE2, 0xB2, 0x87, 0xE2, 0xB2, 0x89, 0xE2, 0xB2,
+		0x8B, 0xE2, 0xB2, 0x8D, 0xE2, 0xB2, 0x8F, 0xE2,
+		0xB2, 0x91, 0xE2, 0xB2, 0x93, 0xE2, 0xB2, 0x95,
+		0xE2, 0xB2, 0x97, 0xE2, 0xB2, 0x99, 0xE2, 0xB2,
+		0x9B, 0xE2, 0xB2, 0x9D, 0xE2, 0xB2, 0x9F, 0xE2,
+		0xB2, 0xA1, 0xE2, 0xB2, 0xA3, 0xE2, 0xB2, 0xA5,
+		0xE2, 0xB2, 0xA7, 0xE2, 0xB2, 0xA9, 0xE2, 0xB2,
+		0xAB, 0xE2, 0xB2, 0xAD, 0xE2, 0xB2, 0xAF, 0xE2,
+		0xB2, 0xB1, 0xE2, 0xB2, 0xB3, 0xE2, 0xB2, 0xB5,
+		0xE2, 0xB2, 0xB7, 0xE2, 0xB2, 0xB9, 0xE2, 0xB2,
+		0xBB, 0xE2, 0xB2, 0xBD, 0xE2, 0xB2, 0xBF, 0xE2,
+		0xB3, 0x81, 0xE2, 0xB3, 0x83, 0xE2, 0xB3, 0x85,
+		0xE2, 0xB3, 0x87, 0xE2, 0xB3, 0x89, 0xE2, 0xB3,
+		0x8B, 0xE2, 0xB3, 0x8D, 0xE2, 0xB3, 0x8F, 0xE2,
+		0xB3, 0x91, 0xE2, 0xB3, 0x93, 0xE2, 0xB3, 0x95,
+		0xE2, 0xB3, 0x97, 0xE2, 0xB3, 0x99, 0xE2, 0xB3,
+		0x9B, 0xE2, 0xB3, 0x9D, 0xE2, 0xB3, 0x9F, 0xE2,
+		0xB3, 0xA1, 0xE2, 0xB3, 0xA3, 0xEF, 0xBD, 0x81,
+		0xEF, 0xBD, 0x82, 0xEF, 0xBD, 0x83, 0xEF, 0xBD,
+		0x84, 0xEF, 0xBD, 0x85, 0xEF, 0xBD, 0x86, 0xEF,
+		0xBD, 0x87, 0xEF, 0xBD, 0x88, 0xEF, 0xBD, 0x89,
+		0xEF, 0xBD, 0x8A, 0xEF, 0xBD, 0x8B, 0xEF, 0xBD,
+		0x8C, 0xEF, 0xBD, 0x8D, 0xEF, 0xBD, 0x8E, 0xEF,
+		0xBD, 0x8F, 0xEF, 0xBD, 0x90, 0xEF, 0xBD, 0x91,
+		0xEF, 0xBD, 0x92, 0xEF, 0xBD, 0x93, 0xEF, 0xBD,
+		0x94, 0xEF, 0xBD, 0x95, 0xEF, 0xBD, 0x96, 0xEF,
+		0xBD, 0x97, 0xEF, 0xBD, 0x98, 0xEF, 0xBD, 0x99,
+		0xEF, 0xBD, 0x9A, 0xF0, 0x90, 0x90, 0xA8, 0xF0,
+		0x90, 0x90, 0xA9, 0xF0, 0x90, 0x90, 0xAA, 0xF0,
+		0x90, 0x90, 0xAB, 0xF0, 0x90, 0x90, 0xAC, 0xF0,
+		0x90, 0x90, 0xAD, 0xF0, 0x90, 0x90, 0xAE, 0xF0,
+		0x90, 0x90, 0xAF, 0xF0, 0x90, 0x90, 0xB0, 0xF0,
+		0x90, 0x90, 0xB1, 0xF0, 0x90, 0x90, 0xB2, 0xF0,
+		0x90, 0x90, 0xB3, 0xF0, 0x90, 0x90, 0xB4, 0xF0,
+		0x90, 0x90, 0xB5, 0xF0, 0x90, 0x90, 0xB6, 0xF0,
+		0x90, 0x90, 0xB7, 0xF0, 0x90, 0x90, 0xB8, 0xF0,
+		0x90, 0x90, 0xB9, 0xF0, 0x90, 0x90, 0xBA, 0xF0,
+		0x90, 0x90, 0xBB, 0xF0, 0x90, 0x90, 0xBC, 0xF0,
+		0x90, 0x90, 0xBD, 0xF0, 0x90, 0x90, 0xBE, 0xF0,
+		0x90, 0x90, 0xBF, 0xF0, 0x90, 0x91, 0x80, 0xF0,
+		0x90, 0x91, 0x81, 0xF0, 0x90, 0x91, 0x82, 0xF0,
+		0x90, 0x91, 0x83, 0xF0, 0x90, 0x91, 0x84, 0xF0,
+		0x90, 0x91, 0x85, 0xF0, 0x90, 0x91, 0x86, 0xF0,
+		0x90, 0x91, 0x87, 0xF0, 0x90, 0x91, 0x88, 0xF0,
+		0x90, 0x91, 0x89, 0xF0, 0x90, 0x91, 0x8A, 0xF0,
+		0x90, 0x91, 0x8B, 0xF0, 0x90, 0x91, 0x8C, 0xF0,
+		0x90, 0x91, 0x8D, 0xF0, 0x90, 0x91, 0x8E, 0xF0,
+		0x90, 0x91, 0x8F,
+	},
+};
+
+static const u8_displacement_t u8_toupper_b3_tbl[2][5][256] = {
+	{
+		{	/* Third byte table 0. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0, 0 }, { 1, 2 },
+			{ 2, 64 }, { 3, 125 }, { 4, 188 }, { 5, 226 },
+			{ 6, 288 }, { 7, 338 }, { 8, 364 }, { N_, 0 },
+			{ N_, 0 }, { 9, 376 }, { 10, 378 }, { 11, 416 },
+			{ 12, 486 }, { 13, 518 }, { 14, 614 }, { 15, 670 },
+			{ 16, 724 }, { 17, 740 }, { 18, 802 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 1. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 19, 816 }, { 20, 912 }, { 21, 1008 }, { 22, 1092 },
+			{ 23, 1179 }, { 24, 1269 }, { 25, 1365 }, { 26, 1448 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 2. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 27, 1469 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { 28, 1517 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 3. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 29, 1595 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 4. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 30, 1673 }, { 31, 1769 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+	},
+	{
+		{	/* Third byte table 0. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { 0, 0 }, { 1, 2 },
+			{ 2, 64 }, { 3, 125 }, { 4, 188 }, { 5, 230 },
+			{ 6, 292 }, { 7, 344 }, { 8, 388 }, { N_, 0 },
+			{ N_, 0 }, { 9, 404 }, { 10, 412 }, { 11, 450 },
+			{ 12, 524 }, { 13, 556 }, { 14, 652 }, { 15, 708 },
+			{ 16, 772 }, { 17, 792 }, { 18, 854 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 1. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 19, 868 }, { N_, 0 }, { N_, 0 },
+			{ 20, 871 }, { 21, 967 }, { 22, 1063 }, { 23, 1147 },
+			{ 24, 1234 }, { 25, 1324 }, { 26, 1420 }, { 27, 1503 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 2. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 28, 1524 }, { 29, 1575 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { 30, 1578 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 31, 1656 }, { 32, 1704 }, { 33, 1816 }, { 34, 1912 },
+			{ 35, 1966 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 3. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { 36, 2080 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+		{	/* Third byte table 4. */
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ 37, 2158 }, { 38, 2254 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+			{ N_, 0 }, { N_, 0 }, { N_, 0 }, { N_, 0 },
+		},
+	},
+};
+
+static const uchar_t u8_toupper_b4_tbl[2][39][257] = {
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			46,  48,  50,  52,  54,  56,  58,  60,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  49,  49,  51,  51,  53,  53,
+			55,  55,  55,  57,  57,  59,  59,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  50,  50,  52,  52,  54,  54,
+			56,  56,  56,  58,  58,  60,  60,  62,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   2,   2,   4,   4,
+			4,   6,   6,   6,   6,   8,   8,   8,
+			8,   8,   8,   10,  10,  10,  12,  12,
+			12,  12,  14,  14,  14,  14,  14,  16,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			22,  24,  24,  24,  24,  24,  26,  26,
+			26,  28,  28,  28,  28,  30,  30,  32,
+			32,  32,  34,  34,  34,  34,  36,  36,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   2,   4,
+			4,   6,   8,   8,   10,  12,  12,  14,
+			14,  16,  16,  18,  18,  20,  20,  22,
+			22,  24,  24,  26,  26,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  48,  50,  52,  52,  54,  54,
+			54,  54,  56,  56,  58,  58,  60,  60,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  32,  32,  34,  34,  36,  36,
+			38,  38,  40,  40,  42,  42,  44,  44,
+			46,  46,  48,  48,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  50,  50,  50,
+			50,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   2,   4,   4,   6,
+			8,   8,   10,  10,  12,  12,  12,  12,
+			12,  14,  14,  14,  16,  16,  16,  16,
+			16,  18,  20,  20,  20,  20,  20,  20,
+			22,  22,  22,  24,  24,  24,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,  26,  26,  26,  26,  26,  26,  26,
+			26,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   2,   4,   4,   4,   4,
+			4,   6,   6,   8,   10,  10,  10,  10,
+			10,  10,  10,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,  12,  12,  12,  12,  12,  12,  12,
+			12,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   2,   4,   6,
+			8,   8,   10,  12,  14,  16,  18,  20,
+			22,  24,  26,  28,  30,  32,  34,  36,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			30,  32,  34,  34,  34,  34,  36,  38,
+			38,  38,  40,  40,  42,  42,  44,  44,
+			46,  46,  48,  48,  50,  50,  52,  52,
+			54,  54,  56,  56,  58,  58,  60,  60,
+			62,  64,  66,  68,  68,  68,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,  70,  70,  70,  70,  70,  70,  70,
+			70,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  52,  54,  56,  58,  60,  62,
+			64,  64,  66,  66,  68,  68,  70,  70,
+			72,  72,  74,  74,  76,  76,  78,  78,
+			80,  80,  82,  82,  84,  84,  86,  86,
+			88,  88,  90,  90,  92,  92,  94,  94,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  50,  50,  52,  52,  54,  54,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   2,   2,   4,   4,   6,
+			6,   8,   8,   10,  10,  12,  12,  14,
+			14,  14,  16,  16,  18,  18,  20,  20,
+			22,  22,  24,  24,  26,  26,  28,  28,
+			30,  30,  32,  32,  34,  34,  36,  36,
+			38,  38,  40,  40,  42,  42,  44,  44,
+			46,  46,  48,  48,  50,  50,  52,  52,
+			52,  52,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   4,   6,   8,   10,  12,
+			14,  16,  18,  20,  22,  24,  26,  28,
+			30,  32,  34,  36,  38,  40,  42,  44,
+			46,  48,  50,  52,  54,  56,  58,  60,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  87,  87,  90,  90,  93,  93,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  87,  87,  90,  90,  93,  93,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			33,  33,  33,  33,  36,  36,  36,  36,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  27,  30,  33,  36,  39,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  45,  48,  51,  54,  57,  60,  63,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  69,  72,  75,  78,  81,  84,  87,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  21,  21,  24,  24,  27,  27,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  33,  36,  39,  42,  45,  48,  51,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  57,  60,  63,  66,  69,  72,  75,
+			78,  81,  84,  87,  90,  93,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  75,  78,  78,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   6,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   12,  15,  15,  15,  15,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   6,   9,   12,  15,  18,
+			21,  24,  27,  30,  33,  36,  39,  42,
+			45,  48,  51,  54,  57,  60,  63,  66,
+			69,  72,  75,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 36. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 37. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+		{	/* Fourth byte table 38. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,
+		},
+	},
+	{
+		{	/* Fourth byte table 0. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,
+		},
+		{	/* Fourth byte table 1. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			46,  48,  50,  52,  54,  56,  58,  60,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 2. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  49,  49,  51,  51,  53,  53,
+			55,  55,  55,  57,  57,  59,  59,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,  61,  61,  61,  61,  61,  61,  61,
+			61,
+		},
+		{	/* Fourth byte table 3. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   4,   4,   6,   6,   8,
+			8,   10,  10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  50,  50,  52,  52,  54,  54,
+			56,  56,  56,  58,  58,  60,  60,  62,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,  63,  63,  63,  63,  63,  63,  63,
+			63,
+		},
+		{	/* Fourth byte table 4. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   2,   4,   4,   6,   6,
+			6,   8,   8,   8,   8,   10,  10,  10,
+			10,  10,  10,  12,  12,  12,  14,  14,
+			14,  14,  16,  18,  18,  18,  18,  20,
+			20,  20,  22,  22,  24,  24,  26,  26,
+			26,  28,  28,  28,  28,  28,  30,  30,
+			30,  32,  32,  32,  32,  34,  34,  36,
+			36,  36,  38,  38,  38,  38,  40,  40,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,
+		},
+		{	/* Fourth byte table 5. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   2,   4,
+			4,   6,   8,   8,   10,  12,  12,  14,
+			14,  16,  16,  18,  18,  20,  20,  22,
+			22,  24,  24,  26,  26,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  48,  50,  52,  52,  54,  54,
+			54,  54,  56,  56,  58,  58,  60,  60,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 6. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  32,  32,  34,  34,  36,  36,
+			38,  38,  40,  40,  42,  42,  44,  44,
+			46,  46,  48,  48,  50,  50,  50,  50,
+			50,  50,  50,  50,  50,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,  52,  52,  52,  52,  52,  52,  52,
+			52,
+		},
+		{	/* Fourth byte table 7. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   2,   2,   2,   2,   2,
+			4,   4,   6,   6,   8,   8,   10,  10,
+			12,  12,  12,  12,  14,  16,  16,  18,
+			20,  20,  22,  22,  24,  24,  24,  24,
+			24,  26,  26,  26,  28,  28,  28,  28,
+			28,  30,  32,  32,  35,  35,  35,  35,
+			37,  37,  37,  39,  39,  39,  41,  41,
+			41,  41,  41,  41,  41,  41,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,  44,  44,  44,  44,  44,  44,  44,
+			44,
+		},
+		{	/* Fourth byte table 8. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   2,   2,   4,   4,   4,   4,
+			4,   6,   8,   10,  12,  14,  14,  14,
+			14,  14,  14,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,  16,  16,  16,  16,  16,  16,  16,
+			16,
+		},
+		{	/* Fourth byte table 9. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   4,   6,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,   8,   8,   8,   8,   8,   8,   8,
+			8,
+		},
+		{	/* Fourth byte table 10. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   2,   4,   6,
+			8,   8,   10,  12,  14,  16,  18,  20,
+			22,  24,  26,  28,  30,  32,  34,  36,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,  38,  38,  38,  38,  38,  38,  38,
+			38,
+		},
+		{	/* Fourth byte table 11. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			30,  32,  34,  34,  34,  34,  36,  38,
+			38,  38,  40,  40,  42,  42,  44,  44,
+			46,  46,  48,  48,  50,  50,  52,  52,
+			54,  54,  56,  56,  58,  58,  60,  60,
+			62,  64,  66,  68,  68,  68,  70,  70,
+			70,  72,  72,  72,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,  74,  74,  74,  74,  74,  74,  74,
+			74,
+		},
+		{	/* Fourth byte table 12. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,  32,  32,  32,  32,  32,  32,  32,
+			32,
+		},
+		{	/* Fourth byte table 13. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			16,  18,  20,  22,  24,  26,  28,  30,
+			32,  34,  36,  38,  40,  42,  44,  46,
+			48,  50,  52,  54,  56,  58,  60,  62,
+			64,  64,  66,  66,  68,  68,  70,  70,
+			72,  72,  74,  74,  76,  76,  78,  78,
+			80,  80,  82,  82,  84,  84,  86,  86,
+			88,  88,  90,  90,  92,  92,  94,  94,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 14. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   2,   2,   2,   2,
+			2,   2,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  50,  50,  52,  52,  54,  54,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,  56,  56,  56,  56,  56,  56,  56,
+			56,
+		},
+		{	/* Fourth byte table 15. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   2,   2,   4,   4,   6,
+			6,   8,   8,   10,  10,  12,  12,  14,
+			16,  16,  18,  18,  20,  20,  22,  22,
+			24,  24,  26,  26,  28,  28,  30,  30,
+			32,  32,  34,  34,  36,  36,  38,  38,
+			40,  40,  42,  42,  44,  44,  46,  46,
+			48,  48,  50,  50,  52,  52,  54,  54,
+			56,  56,  58,  58,  60,  60,  62,  62,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+		{	/* Fourth byte table 16. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   2,   4,   4,   6,   6,
+			8,   8,   10,  10,  12,  12,  14,  14,
+			16,  16,  18,  18,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,  20,  20,  20,  20,  20,  20,  20,
+			20,
+		},
+		{	/* Fourth byte table 17. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   2,   4,   6,   8,   10,  12,
+			14,  16,  18,  20,  22,  24,  26,  28,
+			30,  32,  34,  36,  38,  40,  42,  44,
+			46,  48,  50,  52,  54,  56,  58,  60,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,  62,  62,  62,  62,  62,  62,  62,
+			62,
+		},
+		{	/* Fourth byte table 18. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   2,   4,   6,   8,   10,  12,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,  14,  14,  14,  14,  14,  14,  14,
+			14,
+		},
+		{	/* Fourth byte table 19. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 20. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  87,  87,  90,  90,  93,  93,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 21. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  87,  87,  90,  90,  93,  93,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 22. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			33,  33,  33,  33,  36,  36,  36,  36,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,  84,  84,  84,  84,  84,  84,  84,
+			84,
+		},
+		{	/* Fourth byte table 23. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,  87,  87,  87,  87,  87,  87,  87,
+			87,
+		},
+		{	/* Fourth byte table 24. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  27,  30,  33,  36,  39,  42,  42,
+			42,  42,  42,  42,  42,  42,  42,  42,
+			42,  45,  48,  51,  54,  57,  60,  63,
+			66,  66,  66,  66,  66,  66,  66,  66,
+			66,  69,  72,  75,  78,  81,  84,  87,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,  90,  90,  90,  90,  90,  90,  90,
+			90,
+		},
+		{	/* Fourth byte table 25. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  21,  21,  24,  24,  27,  27,
+			30,  30,  30,  30,  30,  30,  30,  30,
+			30,  33,  36,  39,  42,  45,  48,  51,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  57,  60,  63,  66,  69,  72,  75,
+			78,  81,  84,  87,  90,  93,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 26. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  24,  24,  24,  24,  24,  24,  24,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  72,  72,  72,  72,  72,  72,  72,
+			72,  75,  78,  78,  81,  81,  81,  81,
+			81,  81,  81,  81,  81,  81,  81,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,  83,  83,  83,  83,  83,  83,  83,
+			83,
+		},
+		{	/* Fourth byte table 27. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   6,   9,   9,   9,   9,   9,   9,
+			9,   9,   9,   9,   9,   9,   9,   9,
+			9,   12,  15,  15,  15,  15,  18,  18,
+			18,  18,  18,  18,  18,  18,  18,  18,
+			18,  18,  18,  18,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,  21,  21,  21,  21,  21,  21,  21,
+			21,
+		},
+		{	/* Fourth byte table 28. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   6,   9,   12,  15,  18,  21,  24,
+			27,  30,  33,  36,  39,  42,  45,  48,
+			51,  51,  51,  51,  51,  51,  51,  51,
+			51,  51,  51,  51,  51,  51,  51,  51,
+			51,  51,  51,  51,  51,  51,  51,  51,
+			51,  51,  51,  51,  51,  51,  51,  51,
+			51,  51,  51,  51,  51,  51,  51,  51,
+			51,  51,  51,  51,  51,  51,  51,  51,
+			51,  51,  51,  51,  51,  51,  51,  51,
+			51,  51,  51,  51,  51,  51,  51,  51,
+			51,
+		},
+		{	/* Fourth byte table 29. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,   3,   3,   3,   3,   3,   3,   3,
+			3,
+		},
+		{	/* Fourth byte table 30. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,
+		},
+		{	/* Fourth byte table 31. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,  48,  48,  48,  48,  48,  48,  48,
+			48,
+		},
+		{	/* Fourth byte table 32. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			93,  93,  96,  96,  96,  96,  98,  100,
+			100, 103, 103, 106, 106, 109, 109, 109,
+			109, 109, 109, 109, 109, 109, 109, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112, 112, 112, 112, 112, 112, 112, 112,
+			112,
+		},
+		{	/* Fourth byte table 33. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  57,  57,
+			60,  60,  63,  63,  66,  66,  69,  69,
+			72,  72,  75,  75,  78,  78,  81,  81,
+			84,  84,  87,  87,  90,  90,  93,  93,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 34. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   3,   6,   6,   9,   9,
+			12,  12,  15,  15,  18,  18,  21,  21,
+			24,  24,  27,  27,  30,  30,  33,  33,
+			36,  36,  39,  39,  42,  42,  45,  45,
+			48,  48,  51,  51,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,  54,  54,  54,  54,  54,  54,  54,
+			54,
+		},
+		{	/* Fourth byte table 35. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   3,   6,   9,   12,  15,  18,  21,
+			24,  27,  30,  33,  36,  39,  42,  45,
+			48,  51,  54,  57,  60,  63,  66,  69,
+			72,  75,  78,  81,  84,  87,  90,  93,
+			96,  99,  102, 105, 108, 111, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114, 114, 114, 114, 114, 114, 114, 114,
+			114,
+		},
+		{	/* Fourth byte table 36. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   3,   6,   9,   12,  15,  18,
+			21,  24,  27,  30,  33,  36,  39,  42,
+			45,  48,  51,  54,  57,  60,  63,  66,
+			69,  72,  75,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,  78,  78,  78,  78,  78,  78,  78,
+			78,
+		},
+		{	/* Fourth byte table 37. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  68,  72,  76,  80,  84,  88,  92,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,  96,  96,  96,  96,  96,  96,  96,
+			96,
+		},
+		{	/* Fourth byte table 38. */
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   0,   0,   0,   0,   0,   0,   0,
+			0,   4,   8,   12,  16,  20,  24,  28,
+			32,  36,  40,  44,  48,  52,  56,  60,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,  64,  64,  64,  64,  64,  64,  64,
+			64,
+		},
+	},
+};
+
+static const uchar_t u8_toupper_final_tbl[2][2318] = {
+	{
+		0xCE, 0x9C, 0xC3, 0x80, 0xC3, 0x81, 0xC3, 0x82,
+		0xC3, 0x83, 0xC3, 0x84, 0xC3, 0x85, 0xC3, 0x86,
+		0xC3, 0x87, 0xC3, 0x88, 0xC3, 0x89, 0xC3, 0x8A,
+		0xC3, 0x8B, 0xC3, 0x8C, 0xC3, 0x8D, 0xC3, 0x8E,
+		0xC3, 0x8F, 0xC3, 0x90, 0xC3, 0x91, 0xC3, 0x92,
+		0xC3, 0x93, 0xC3, 0x94, 0xC3, 0x95, 0xC3, 0x96,
+		0xC3, 0x98, 0xC3, 0x99, 0xC3, 0x9A, 0xC3, 0x9B,
+		0xC3, 0x9C, 0xC3, 0x9D, 0xC3, 0x9E, 0xC5, 0xB8,
+		0xC4, 0x80, 0xC4, 0x82, 0xC4, 0x84, 0xC4, 0x86,
+		0xC4, 0x88, 0xC4, 0x8A, 0xC4, 0x8C, 0xC4, 0x8E,
+		0xC4, 0x90, 0xC4, 0x92, 0xC4, 0x94, 0xC4, 0x96,
+		0xC4, 0x98, 0xC4, 0x9A, 0xC4, 0x9C, 0xC4, 0x9E,
+		0xC4, 0xA0, 0xC4, 0xA2, 0xC4, 0xA4, 0xC4, 0xA6,
+		0xC4, 0xA8, 0xC4, 0xAA, 0xC4, 0xAC, 0xC4, 0xAE,
+		0x49, 0xC4, 0xB2, 0xC4, 0xB4, 0xC4, 0xB6, 0xC4,
+		0xB9, 0xC4, 0xBB, 0xC4, 0xBD, 0xC4, 0xBF, 0xC5,
+		0x81, 0xC5, 0x83, 0xC5, 0x85, 0xC5, 0x87, 0xC5,
+		0x8A, 0xC5, 0x8C, 0xC5, 0x8E, 0xC5, 0x90, 0xC5,
+		0x92, 0xC5, 0x94, 0xC5, 0x96, 0xC5, 0x98, 0xC5,
+		0x9A, 0xC5, 0x9C, 0xC5, 0x9E, 0xC5, 0xA0, 0xC5,
+		0xA2, 0xC5, 0xA4, 0xC5, 0xA6, 0xC5, 0xA8, 0xC5,
+		0xAA, 0xC5, 0xAC, 0xC5, 0xAE, 0xC5, 0xB0, 0xC5,
+		0xB2, 0xC5, 0xB4, 0xC5, 0xB6, 0xC5, 0xB9, 0xC5,
+		0xBB, 0xC5, 0xBD, 0x53, 0xC6, 0x82, 0xC6, 0x84,
+		0xC6, 0x87, 0xC6, 0x8B, 0xC6, 0x91, 0xC7, 0xB6,
+		0xC6, 0x98, 0xC8, 0xA0, 0xC6, 0xA0, 0xC6, 0xA2,
+		0xC6, 0xA4, 0xC6, 0xA7, 0xC6, 0xAC, 0xC6, 0xAF,
+		0xC6, 0xB3, 0xC6, 0xB5, 0xC6, 0xB8, 0xC6, 0xBC,
+		0xC7, 0xB7, 0xC7, 0x84, 0xC7, 0x84, 0xC7, 0x87,
+		0xC7, 0x87, 0xC7, 0x8A, 0xC7, 0x8A, 0xC7, 0x8D,
+		0xC7, 0x8F, 0xC7, 0x91, 0xC7, 0x93, 0xC7, 0x95,
+		0xC7, 0x97, 0xC7, 0x99, 0xC7, 0x9B, 0xC6, 0x8E,
+		0xC7, 0x9E, 0xC7, 0xA0, 0xC7, 0xA2, 0xC7, 0xA4,
+		0xC7, 0xA6, 0xC7, 0xA8, 0xC7, 0xAA, 0xC7, 0xAC,
+		0xC7, 0xAE, 0xC7, 0xB1, 0xC7, 0xB1, 0xC7, 0xB4,
+		0xC7, 0xB8, 0xC7, 0xBA, 0xC7, 0xBC, 0xC7, 0xBE,
+		0xC8, 0x80, 0xC8, 0x82, 0xC8, 0x84, 0xC8, 0x86,
+		0xC8, 0x88, 0xC8, 0x8A, 0xC8, 0x8C, 0xC8, 0x8E,
+		0xC8, 0x90, 0xC8, 0x92, 0xC8, 0x94, 0xC8, 0x96,
+		0xC8, 0x98, 0xC8, 0x9A, 0xC8, 0x9C, 0xC8, 0x9E,
+		0xC8, 0xA2, 0xC8, 0xA4, 0xC8, 0xA6, 0xC8, 0xA8,
+		0xC8, 0xAA, 0xC8, 0xAC, 0xC8, 0xAE, 0xC8, 0xB0,
+		0xC8, 0xB2, 0xC6, 0x81, 0xC6, 0x86, 0xC6, 0x89,
+		0xC6, 0x8A, 0xC6, 0x8F, 0xC6, 0x90, 0xC6, 0x93,
+		0xC6, 0x94, 0xC6, 0x97, 0xC6, 0x96, 0xC6, 0x9C,
+		0xC6, 0x9D, 0xC6, 0x9F, 0xC6, 0xA6, 0xC6, 0xA9,
+		0xC6, 0xAE, 0xC6, 0xB1, 0xC6, 0xB2, 0xC6, 0xB7,
+		0xCE, 0x99, 0xCE, 0x86, 0xCE, 0x88, 0xCE, 0x89,
+		0xCE, 0x8A, 0xCE, 0x91, 0xCE, 0x92, 0xCE, 0x93,
+		0xCE, 0x94, 0xCE, 0x95, 0xCE, 0x96, 0xCE, 0x97,
+		0xCE, 0x98, 0xCE, 0x99, 0xCE, 0x9A, 0xCE, 0x9B,
+		0xCE, 0x9C, 0xCE, 0x9D, 0xCE, 0x9E, 0xCE, 0x9F,
+		0xCE, 0xA0, 0xCE, 0xA1, 0xCE, 0xA3, 0xCE, 0xA3,
+		0xCE, 0xA4, 0xCE, 0xA5, 0xCE, 0xA6, 0xCE, 0xA7,
+		0xCE, 0xA8, 0xCE, 0xA9, 0xCE, 0xAA, 0xCE, 0xAB,
+		0xCE, 0x8C, 0xCE, 0x8E, 0xCE, 0x8F, 0xCE, 0x92,
+		0xCE, 0x98, 0xCE, 0xA6, 0xCE, 0xA0, 0xCF, 0x98,
+		0xCF, 0x9A, 0xCF, 0x9C, 0xCF, 0x9E, 0xCF, 0xA0,
+		0xCF, 0xA2, 0xCF, 0xA4, 0xCF, 0xA6, 0xCF, 0xA8,
+		0xCF, 0xAA, 0xCF, 0xAC, 0xCF, 0xAE, 0xCE, 0x9A,
+		0xCE, 0xA1, 0xCE, 0xA3, 0xCE, 0x95, 0xD0, 0x90,
+		0xD0, 0x91, 0xD0, 0x92, 0xD0, 0x93, 0xD0, 0x94,
+		0xD0, 0x95, 0xD0, 0x96, 0xD0, 0x97, 0xD0, 0x98,
+		0xD0, 0x99, 0xD0, 0x9A, 0xD0, 0x9B, 0xD0, 0x9C,
+		0xD0, 0x9D, 0xD0, 0x9E, 0xD0, 0x9F, 0xD0, 0xA0,
+		0xD0, 0xA1, 0xD0, 0xA2, 0xD0, 0xA3, 0xD0, 0xA4,
+		0xD0, 0xA5, 0xD0, 0xA6, 0xD0, 0xA7, 0xD0, 0xA8,
+		0xD0, 0xA9, 0xD0, 0xAA, 0xD0, 0xAB, 0xD0, 0xAC,
+		0xD0, 0xAD, 0xD0, 0xAE, 0xD0, 0xAF, 0xD0, 0x80,
+		0xD0, 0x81, 0xD0, 0x82, 0xD0, 0x83, 0xD0, 0x84,
+		0xD0, 0x85, 0xD0, 0x86, 0xD0, 0x87, 0xD0, 0x88,
+		0xD0, 0x89, 0xD0, 0x8A, 0xD0, 0x8B, 0xD0, 0x8C,
+		0xD0, 0x8D, 0xD0, 0x8E, 0xD0, 0x8F, 0xD1, 0xA0,
+		0xD1, 0xA2, 0xD1, 0xA4, 0xD1, 0xA6, 0xD1, 0xA8,
+		0xD1, 0xAA, 0xD1, 0xAC, 0xD1, 0xAE, 0xD1, 0xB0,
+		0xD1, 0xB2, 0xD1, 0xB4, 0xD1, 0xB6, 0xD1, 0xB8,
+		0xD1, 0xBA, 0xD1, 0xBC, 0xD1, 0xBE, 0xD2, 0x80,
+		0xD2, 0x8A, 0xD2, 0x8C, 0xD2, 0x8E, 0xD2, 0x90,
+		0xD2, 0x92, 0xD2, 0x94, 0xD2, 0x96, 0xD2, 0x98,
+		0xD2, 0x9A, 0xD2, 0x9C, 0xD2, 0x9E, 0xD2, 0xA0,
+		0xD2, 0xA2, 0xD2, 0xA4, 0xD2, 0xA6, 0xD2, 0xA8,
+		0xD2, 0xAA, 0xD2, 0xAC, 0xD2, 0xAE, 0xD2, 0xB0,
+		0xD2, 0xB2, 0xD2, 0xB4, 0xD2, 0xB6, 0xD2, 0xB8,
+		0xD2, 0xBA, 0xD2, 0xBC, 0xD2, 0xBE, 0xD3, 0x81,
+		0xD3, 0x83, 0xD3, 0x85, 0xD3, 0x87, 0xD3, 0x89,
+		0xD3, 0x8B, 0xD3, 0x8D, 0xD3, 0x90, 0xD3, 0x92,
+		0xD3, 0x94, 0xD3, 0x96, 0xD3, 0x98, 0xD3, 0x9A,
+		0xD3, 0x9C, 0xD3, 0x9E, 0xD3, 0xA0, 0xD3, 0xA2,
+		0xD3, 0xA4, 0xD3, 0xA6, 0xD3, 0xA8, 0xD3, 0xAA,
+		0xD3, 0xAC, 0xD3, 0xAE, 0xD3, 0xB0, 0xD3, 0xB2,
+		0xD3, 0xB4, 0xD3, 0xB8, 0xD4, 0x80, 0xD4, 0x82,
+		0xD4, 0x84, 0xD4, 0x86, 0xD4, 0x88, 0xD4, 0x8A,
+		0xD4, 0x8C, 0xD4, 0x8E, 0xD4, 0xB1, 0xD4, 0xB2,
+		0xD4, 0xB3, 0xD4, 0xB4, 0xD4, 0xB5, 0xD4, 0xB6,
+		0xD4, 0xB7, 0xD4, 0xB8, 0xD4, 0xB9, 0xD4, 0xBA,
+		0xD4, 0xBB, 0xD4, 0xBC, 0xD4, 0xBD, 0xD4, 0xBE,
+		0xD4, 0xBF, 0xD5, 0x80, 0xD5, 0x81, 0xD5, 0x82,
+		0xD5, 0x83, 0xD5, 0x84, 0xD5, 0x85, 0xD5, 0x86,
+		0xD5, 0x87, 0xD5, 0x88, 0xD5, 0x89, 0xD5, 0x8A,
+		0xD5, 0x8B, 0xD5, 0x8C, 0xD5, 0x8D, 0xD5, 0x8E,
+		0xD5, 0x8F, 0xD5, 0x90, 0xD5, 0x91, 0xD5, 0x92,
+		0xD5, 0x93, 0xD5, 0x94, 0xD5, 0x95, 0xD5, 0x96,
+		0xE1, 0xB8, 0x80, 0xE1, 0xB8, 0x82, 0xE1, 0xB8,
+		0x84, 0xE1, 0xB8, 0x86, 0xE1, 0xB8, 0x88, 0xE1,
+		0xB8, 0x8A, 0xE1, 0xB8, 0x8C, 0xE1, 0xB8, 0x8E,
+		0xE1, 0xB8, 0x90, 0xE1, 0xB8, 0x92, 0xE1, 0xB8,
+		0x94, 0xE1, 0xB8, 0x96, 0xE1, 0xB8, 0x98, 0xE1,
+		0xB8, 0x9A, 0xE1, 0xB8, 0x9C, 0xE1, 0xB8, 0x9E,
+		0xE1, 0xB8, 0xA0, 0xE1, 0xB8, 0xA2, 0xE1, 0xB8,
+		0xA4, 0xE1, 0xB8, 0xA6, 0xE1, 0xB8, 0xA8, 0xE1,
+		0xB8, 0xAA, 0xE1, 0xB8, 0xAC, 0xE1, 0xB8, 0xAE,
+		0xE1, 0xB8, 0xB0, 0xE1, 0xB8, 0xB2, 0xE1, 0xB8,
+		0xB4, 0xE1, 0xB8, 0xB6, 0xE1, 0xB8, 0xB8, 0xE1,
+		0xB8, 0xBA, 0xE1, 0xB8, 0xBC, 0xE1, 0xB8, 0xBE,
+		0xE1, 0xB9, 0x80, 0xE1, 0xB9, 0x82, 0xE1, 0xB9,
+		0x84, 0xE1, 0xB9, 0x86, 0xE1, 0xB9, 0x88, 0xE1,
+		0xB9, 0x8A, 0xE1, 0xB9, 0x8C, 0xE1, 0xB9, 0x8E,
+		0xE1, 0xB9, 0x90, 0xE1, 0xB9, 0x92, 0xE1, 0xB9,
+		0x94, 0xE1, 0xB9, 0x96, 0xE1, 0xB9, 0x98, 0xE1,
+		0xB9, 0x9A, 0xE1, 0xB9, 0x9C, 0xE1, 0xB9, 0x9E,
+		0xE1, 0xB9, 0xA0, 0xE1, 0xB9, 0xA2, 0xE1, 0xB9,
+		0xA4, 0xE1, 0xB9, 0xA6, 0xE1, 0xB9, 0xA8, 0xE1,
+		0xB9, 0xAA, 0xE1, 0xB9, 0xAC, 0xE1, 0xB9, 0xAE,
+		0xE1, 0xB9, 0xB0, 0xE1, 0xB9, 0xB2, 0xE1, 0xB9,
+		0xB4, 0xE1, 0xB9, 0xB6, 0xE1, 0xB9, 0xB8, 0xE1,
+		0xB9, 0xBA, 0xE1, 0xB9, 0xBC, 0xE1, 0xB9, 0xBE,
+		0xE1, 0xBA, 0x80, 0xE1, 0xBA, 0x82, 0xE1, 0xBA,
+		0x84, 0xE1, 0xBA, 0x86, 0xE1, 0xBA, 0x88, 0xE1,
+		0xBA, 0x8A, 0xE1, 0xBA, 0x8C, 0xE1, 0xBA, 0x8E,
+		0xE1, 0xBA, 0x90, 0xE1, 0xBA, 0x92, 0xE1, 0xBA,
+		0x94, 0xE1, 0xB9, 0xA0, 0xE1, 0xBA, 0xA0, 0xE1,
+		0xBA, 0xA2, 0xE1, 0xBA, 0xA4, 0xE1, 0xBA, 0xA6,
+		0xE1, 0xBA, 0xA8, 0xE1, 0xBA, 0xAA, 0xE1, 0xBA,
+		0xAC, 0xE1, 0xBA, 0xAE, 0xE1, 0xBA, 0xB0, 0xE1,
+		0xBA, 0xB2, 0xE1, 0xBA, 0xB4, 0xE1, 0xBA, 0xB6,
+		0xE1, 0xBA, 0xB8, 0xE1, 0xBA, 0xBA, 0xE1, 0xBA,
+		0xBC, 0xE1, 0xBA, 0xBE, 0xE1, 0xBB, 0x80, 0xE1,
+		0xBB, 0x82, 0xE1, 0xBB, 0x84, 0xE1, 0xBB, 0x86,
+		0xE1, 0xBB, 0x88, 0xE1, 0xBB, 0x8A, 0xE1, 0xBB,
+		0x8C, 0xE1, 0xBB, 0x8E, 0xE1, 0xBB, 0x90, 0xE1,
+		0xBB, 0x92, 0xE1, 0xBB, 0x94, 0xE1, 0xBB, 0x96,
+		0xE1, 0xBB, 0x98, 0xE1, 0xBB, 0x9A, 0xE1, 0xBB,
+		0x9C, 0xE1, 0xBB, 0x9E, 0xE1, 0xBB, 0xA0, 0xE1,
+		0xBB, 0xA2, 0xE1, 0xBB, 0xA4, 0xE1, 0xBB, 0xA6,
+		0xE1, 0xBB, 0xA8, 0xE1, 0xBB, 0xAA, 0xE1, 0xBB,
+		0xAC, 0xE1, 0xBB, 0xAE, 0xE1, 0xBB, 0xB0, 0xE1,
+		0xBB, 0xB2, 0xE1, 0xBB, 0xB4, 0xE1, 0xBB, 0xB6,
+		0xE1, 0xBB, 0xB8, 0xE1, 0xBC, 0x88, 0xE1, 0xBC,
+		0x89, 0xE1, 0xBC, 0x8A, 0xE1, 0xBC, 0x8B, 0xE1,
+		0xBC, 0x8C, 0xE1, 0xBC, 0x8D, 0xE1, 0xBC, 0x8E,
+		0xE1, 0xBC, 0x8F, 0xE1, 0xBC, 0x98, 0xE1, 0xBC,
+		0x99, 0xE1, 0xBC, 0x9A, 0xE1, 0xBC, 0x9B, 0xE1,
+		0xBC, 0x9C, 0xE1, 0xBC, 0x9D, 0xE1, 0xBC, 0xA8,
+		0xE1, 0xBC, 0xA9, 0xE1, 0xBC, 0xAA, 0xE1, 0xBC,
+		0xAB, 0xE1, 0xBC, 0xAC, 0xE1, 0xBC, 0xAD, 0xE1,
+		0xBC, 0xAE, 0xE1, 0xBC, 0xAF, 0xE1, 0xBC, 0xB8,
+		0xE1, 0xBC, 0xB9, 0xE1, 0xBC, 0xBA, 0xE1, 0xBC,
+		0xBB, 0xE1, 0xBC, 0xBC, 0xE1, 0xBC, 0xBD, 0xE1,
+		0xBC, 0xBE, 0xE1, 0xBC, 0xBF, 0xE1, 0xBD, 0x88,
+		0xE1, 0xBD, 0x89, 0xE1, 0xBD, 0x8A, 0xE1, 0xBD,
+		0x8B, 0xE1, 0xBD, 0x8C, 0xE1, 0xBD, 0x8D, 0xE1,
+		0xBD, 0x99, 0xE1, 0xBD, 0x9B, 0xE1, 0xBD, 0x9D,
+		0xE1, 0xBD, 0x9F, 0xE1, 0xBD, 0xA8, 0xE1, 0xBD,
+		0xA9, 0xE1, 0xBD, 0xAA, 0xE1, 0xBD, 0xAB, 0xE1,
+		0xBD, 0xAC, 0xE1, 0xBD, 0xAD, 0xE1, 0xBD, 0xAE,
+		0xE1, 0xBD, 0xAF, 0xE1, 0xBE, 0xBA, 0xE1, 0xBE,
+		0xBB, 0xE1, 0xBF, 0x88, 0xE1, 0xBF, 0x89, 0xE1,
+		0xBF, 0x8A, 0xE1, 0xBF, 0x8B, 0xE1, 0xBF, 0x9A,
+		0xE1, 0xBF, 0x9B, 0xE1, 0xBF, 0xB8, 0xE1, 0xBF,
+		0xB9, 0xE1, 0xBF, 0xAA, 0xE1, 0xBF, 0xAB, 0xE1,
+		0xBF, 0xBA, 0xE1, 0xBF, 0xBB, 0xE1, 0xBE, 0x88,
+		0xE1, 0xBE, 0x89, 0xE1, 0xBE, 0x8A, 0xE1, 0xBE,
+		0x8B, 0xE1, 0xBE, 0x8C, 0xE1, 0xBE, 0x8D, 0xE1,
+		0xBE, 0x8E, 0xE1, 0xBE, 0x8F, 0xE1, 0xBE, 0x98,
+		0xE1, 0xBE, 0x99, 0xE1, 0xBE, 0x9A, 0xE1, 0xBE,
+		0x9B, 0xE1, 0xBE, 0x9C, 0xE1, 0xBE, 0x9D, 0xE1,
+		0xBE, 0x9E, 0xE1, 0xBE, 0x9F, 0xE1, 0xBE, 0xA8,
+		0xE1, 0xBE, 0xA9, 0xE1, 0xBE, 0xAA, 0xE1, 0xBE,
+		0xAB, 0xE1, 0xBE, 0xAC, 0xE1, 0xBE, 0xAD, 0xE1,
+		0xBE, 0xAE, 0xE1, 0xBE, 0xAF, 0xE1, 0xBE, 0xB8,
+		0xE1, 0xBE, 0xB9, 0xE1, 0xBE, 0xBC, 0xCE, 0x99,
+		0xE1, 0xBF, 0x8C, 0xE1, 0xBF, 0x98, 0xE1, 0xBF,
+		0x99, 0xE1, 0xBF, 0xA8, 0xE1, 0xBF, 0xA9, 0xE1,
+		0xBF, 0xAC, 0xE1, 0xBF, 0xBC, 0xE2, 0x85, 0xA0,
+		0xE2, 0x85, 0xA1, 0xE2, 0x85, 0xA2, 0xE2, 0x85,
+		0xA3, 0xE2, 0x85, 0xA4, 0xE2, 0x85, 0xA5, 0xE2,
+		0x85, 0xA6, 0xE2, 0x85, 0xA7, 0xE2, 0x85, 0xA8,
+		0xE2, 0x85, 0xA9, 0xE2, 0x85, 0xAA, 0xE2, 0x85,
+		0xAB, 0xE2, 0x85, 0xAC, 0xE2, 0x85, 0xAD, 0xE2,
+		0x85, 0xAE, 0xE2, 0x85, 0xAF, 0xE2, 0x92, 0xB6,
+		0xE2, 0x92, 0xB7, 0xE2, 0x92, 0xB8, 0xE2, 0x92,
+		0xB9, 0xE2, 0x92, 0xBA, 0xE2, 0x92, 0xBB, 0xE2,
+		0x92, 0xBC, 0xE2, 0x92, 0xBD, 0xE2, 0x92, 0xBE,
+		0xE2, 0x92, 0xBF, 0xE2, 0x93, 0x80, 0xE2, 0x93,
+		0x81, 0xE2, 0x93, 0x82, 0xE2, 0x93, 0x83, 0xE2,
+		0x93, 0x84, 0xE2, 0x93, 0x85, 0xE2, 0x93, 0x86,
+		0xE2, 0x93, 0x87, 0xE2, 0x93, 0x88, 0xE2, 0x93,
+		0x89, 0xE2, 0x93, 0x8A, 0xE2, 0x93, 0x8B, 0xE2,
+		0x93, 0x8C, 0xE2, 0x93, 0x8D, 0xE2, 0x93, 0x8E,
+		0xE2, 0x93, 0x8F, 0xEF, 0xBC, 0xA1, 0xEF, 0xBC,
+		0xA2, 0xEF, 0xBC, 0xA3, 0xEF, 0xBC, 0xA4, 0xEF,
+		0xBC, 0xA5, 0xEF, 0xBC, 0xA6, 0xEF, 0xBC, 0xA7,
+		0xEF, 0xBC, 0xA8, 0xEF, 0xBC, 0xA9, 0xEF, 0xBC,
+		0xAA, 0xEF, 0xBC, 0xAB, 0xEF, 0xBC, 0xAC, 0xEF,
+		0xBC, 0xAD, 0xEF, 0xBC, 0xAE, 0xEF, 0xBC, 0xAF,
+		0xEF, 0xBC, 0xB0, 0xEF, 0xBC, 0xB1, 0xEF, 0xBC,
+		0xB2, 0xEF, 0xBC, 0xB3, 0xEF, 0xBC, 0xB4, 0xEF,
+		0xBC, 0xB5, 0xEF, 0xBC, 0xB6, 0xEF, 0xBC, 0xB7,
+		0xEF, 0xBC, 0xB8, 0xEF, 0xBC, 0xB9, 0xEF, 0xBC,
+		0xBA, 0xF0, 0x90, 0x90, 0x80, 0xF0, 0x90, 0x90,
+		0x81, 0xF0, 0x90, 0x90, 0x82, 0xF0, 0x90, 0x90,
+		0x83, 0xF0, 0x90, 0x90, 0x84, 0xF0, 0x90, 0x90,
+		0x85, 0xF0, 0x90, 0x90, 0x86, 0xF0, 0x90, 0x90,
+		0x87, 0xF0, 0x90, 0x90, 0x88, 0xF0, 0x90, 0x90,
+		0x89, 0xF0, 0x90, 0x90, 0x8A, 0xF0, 0x90, 0x90,
+		0x8B, 0xF0, 0x90, 0x90, 0x8C, 0xF0, 0x90, 0x90,
+		0x8D, 0xF0, 0x90, 0x90, 0x8E, 0xF0, 0x90, 0x90,
+		0x8F, 0xF0, 0x90, 0x90, 0x90, 0xF0, 0x90, 0x90,
+		0x91, 0xF0, 0x90, 0x90, 0x92, 0xF0, 0x90, 0x90,
+		0x93, 0xF0, 0x90, 0x90, 0x94, 0xF0, 0x90, 0x90,
+		0x95, 0xF0, 0x90, 0x90, 0x96, 0xF0, 0x90, 0x90,
+		0x97, 0xF0, 0x90, 0x90, 0x98, 0xF0, 0x90, 0x90,
+		0x99, 0xF0, 0x90, 0x90, 0x9A, 0xF0, 0x90, 0x90,
+		0x9B, 0xF0, 0x90, 0x90, 0x9C, 0xF0, 0x90, 0x90,
+		0x9D, 0xF0, 0x90, 0x90, 0x9E, 0xF0, 0x90, 0x90,
+		0x9F, 0xF0, 0x90, 0x90, 0xA0, 0xF0, 0x90, 0x90,
+		0xA1, 0xF0, 0x90, 0x90, 0xA2, 0xF0, 0x90, 0x90,
+		0xA3, 0xF0, 0x90, 0x90, 0xA4, 0xF0, 0x90, 0x90,
+		0xA5, 0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,    0,    0,
+		0,    0,    0,    0,    0,    0,
+	},
+	{
+		0xCE, 0x9C, 0xC3, 0x80, 0xC3, 0x81, 0xC3, 0x82,
+		0xC3, 0x83, 0xC3, 0x84, 0xC3, 0x85, 0xC3, 0x86,
+		0xC3, 0x87, 0xC3, 0x88, 0xC3, 0x89, 0xC3, 0x8A,
+		0xC3, 0x8B, 0xC3, 0x8C, 0xC3, 0x8D, 0xC3, 0x8E,
+		0xC3, 0x8F, 0xC3, 0x90, 0xC3, 0x91, 0xC3, 0x92,
+		0xC3, 0x93, 0xC3, 0x94, 0xC3, 0x95, 0xC3, 0x96,
+		0xC3, 0x98, 0xC3, 0x99, 0xC3, 0x9A, 0xC3, 0x9B,
+		0xC3, 0x9C, 0xC3, 0x9D, 0xC3, 0x9E, 0xC5, 0xB8,
+		0xC4, 0x80, 0xC4, 0x82, 0xC4, 0x84, 0xC4, 0x86,
+		0xC4, 0x88, 0xC4, 0x8A, 0xC4, 0x8C, 0xC4, 0x8E,
+		0xC4, 0x90, 0xC4, 0x92, 0xC4, 0x94, 0xC4, 0x96,
+		0xC4, 0x98, 0xC4, 0x9A, 0xC4, 0x9C, 0xC4, 0x9E,
+		0xC4, 0xA0, 0xC4, 0xA2, 0xC4, 0xA4, 0xC4, 0xA6,
+		0xC4, 0xA8, 0xC4, 0xAA, 0xC4, 0xAC, 0xC4, 0xAE,
+		0x49, 0xC4, 0xB2, 0xC4, 0xB4, 0xC4, 0xB6, 0xC4,
+		0xB9, 0xC4, 0xBB, 0xC4, 0xBD, 0xC4, 0xBF, 0xC5,
+		0x81, 0xC5, 0x83, 0xC5, 0x85, 0xC5, 0x87, 0xC5,
+		0x8A, 0xC5, 0x8C, 0xC5, 0x8E, 0xC5, 0x90, 0xC5,
+		0x92, 0xC5, 0x94, 0xC5, 0x96, 0xC5, 0x98, 0xC5,
+		0x9A, 0xC5, 0x9C, 0xC5, 0x9E, 0xC5, 0xA0, 0xC5,
+		0xA2, 0xC5, 0xA4, 0xC5, 0xA6, 0xC5, 0xA8, 0xC5,
+		0xAA, 0xC5, 0xAC, 0xC5, 0xAE, 0xC5, 0xB0, 0xC5,
+		0xB2, 0xC5, 0xB4, 0xC5, 0xB6, 0xC5, 0xB9, 0xC5,
+		0xBB, 0xC5, 0xBD, 0x53, 0xC9, 0x83, 0xC6, 0x82,
+		0xC6, 0x84, 0xC6, 0x87, 0xC6, 0x8B, 0xC6, 0x91,
+		0xC7, 0xB6, 0xC6, 0x98, 0xC8, 0xBD, 0xC8, 0xA0,
+		0xC6, 0xA0, 0xC6, 0xA2, 0xC6, 0xA4, 0xC6, 0xA7,
+		0xC6, 0xAC, 0xC6, 0xAF, 0xC6, 0xB3, 0xC6, 0xB5,
+		0xC6, 0xB8, 0xC6, 0xBC, 0xC7, 0xB7, 0xC7, 0x84,
+		0xC7, 0x84, 0xC7, 0x87, 0xC7, 0x87, 0xC7, 0x8A,
+		0xC7, 0x8A, 0xC7, 0x8D, 0xC7, 0x8F, 0xC7, 0x91,
+		0xC7, 0x93, 0xC7, 0x95, 0xC7, 0x97, 0xC7, 0x99,
+		0xC7, 0x9B, 0xC6, 0x8E, 0xC7, 0x9E, 0xC7, 0xA0,
+		0xC7, 0xA2, 0xC7, 0xA4, 0xC7, 0xA6, 0xC7, 0xA8,
+		0xC7, 0xAA, 0xC7, 0xAC, 0xC7, 0xAE, 0xC7, 0xB1,
+		0xC7, 0xB1, 0xC7, 0xB4, 0xC7, 0xB8, 0xC7, 0xBA,
+		0xC7, 0xBC, 0xC7, 0xBE, 0xC8, 0x80, 0xC8, 0x82,
+		0xC8, 0x84, 0xC8, 0x86, 0xC8, 0x88, 0xC8, 0x8A,
+		0xC8, 0x8C, 0xC8, 0x8E, 0xC8, 0x90, 0xC8, 0x92,
+		0xC8, 0x94, 0xC8, 0x96, 0xC8, 0x98, 0xC8, 0x9A,
+		0xC8, 0x9C, 0xC8, 0x9E, 0xC8, 0xA2, 0xC8, 0xA4,
+		0xC8, 0xA6, 0xC8, 0xA8, 0xC8, 0xAA, 0xC8, 0xAC,
+		0xC8, 0xAE, 0xC8, 0xB0, 0xC8, 0xB2, 0xC8, 0xBB,
+		0xC9, 0x81, 0xC9, 0x86, 0xC9, 0x88, 0xC9, 0x8A,
+		0xC9, 0x8C, 0xC9, 0x8E, 0xC6, 0x81, 0xC6, 0x86,
+		0xC6, 0x89, 0xC6, 0x8A, 0xC6, 0x8F, 0xC6, 0x90,
+		0xC6, 0x93, 0xC6, 0x94, 0xC6, 0x97, 0xC6, 0x96,
+		0xE2, 0xB1, 0xA2, 0xC6, 0x9C, 0xC6, 0x9D, 0xC6,
+		0x9F, 0xE2, 0xB1, 0xA4, 0xC6, 0xA6, 0xC6, 0xA9,
+		0xC6, 0xAE, 0xC9, 0x84, 0xC6, 0xB1, 0xC6, 0xB2,
+		0xC9, 0x85, 0xC6, 0xB7, 0xCE, 0x99, 0xCF, 0xBD,
+		0xCF, 0xBE, 0xCF, 0xBF, 0xCE, 0x86, 0xCE, 0x88,
+		0xCE, 0x89, 0xCE, 0x8A, 0xCE, 0x91, 0xCE, 0x92,
+		0xCE, 0x93, 0xCE, 0x94, 0xCE, 0x95, 0xCE, 0x96,
+		0xCE, 0x97, 0xCE, 0x98, 0xCE, 0x99, 0xCE, 0x9A,
+		0xCE, 0x9B, 0xCE, 0x9C, 0xCE, 0x9D, 0xCE, 0x9E,
+		0xCE, 0x9F, 0xCE, 0xA0, 0xCE, 0xA1, 0xCE, 0xA3,
+		0xCE, 0xA3, 0xCE, 0xA4, 0xCE, 0xA5, 0xCE, 0xA6,
+		0xCE, 0xA7, 0xCE, 0xA8, 0xCE, 0xA9, 0xCE, 0xAA,
+		0xCE, 0xAB, 0xCE, 0x8C, 0xCE, 0x8E, 0xCE, 0x8F,
+		0xCE, 0x92, 0xCE, 0x98, 0xCE, 0xA6, 0xCE, 0xA0,
+		0xCF, 0x98, 0xCF, 0x9A, 0xCF, 0x9C, 0xCF, 0x9E,
+		0xCF, 0xA0, 0xCF, 0xA2, 0xCF, 0xA4, 0xCF, 0xA6,
+		0xCF, 0xA8, 0xCF, 0xAA, 0xCF, 0xAC, 0xCF, 0xAE,
+		0xCE, 0x9A, 0xCE, 0xA1, 0xCF, 0xB9, 0xCE, 0x95,
+		0xCF, 0xB7, 0xCF, 0xBA, 0xD0, 0x90, 0xD0, 0x91,
+		0xD0, 0x92, 0xD0, 0x93, 0xD0, 0x94, 0xD0, 0x95,
+		0xD0, 0x96, 0xD0, 0x97, 0xD0, 0x98, 0xD0, 0x99,
+		0xD0, 0x9A, 0xD0, 0x9B, 0xD0, 0x9C, 0xD0, 0x9D,
+		0xD0, 0x9E, 0xD0, 0x9F, 0xD0, 0xA0, 0xD0, 0xA1,
+		0xD0, 0xA2, 0xD0, 0xA3, 0xD0, 0xA4, 0xD0, 0xA5,
+		0xD0, 0xA6, 0xD0, 0xA7, 0xD0, 0xA8, 0xD0, 0xA9,
+		0xD0, 0xAA, 0xD0, 0xAB, 0xD0, 0xAC, 0xD0, 0xAD,
+		0xD0, 0xAE, 0xD0, 0xAF, 0xD0, 0x80, 0xD0, 0x81,
+		0xD0, 0x82, 0xD0, 0x83, 0xD0, 0x84, 0xD0, 0x85,
+		0xD0, 0x86, 0xD0, 0x87, 0xD0, 0x88, 0xD0, 0x89,
+		0xD0, 0x8A, 0xD0, 0x8B, 0xD0, 0x8C, 0xD0, 0x8D,
+		0xD0, 0x8E, 0xD0, 0x8F, 0xD1, 0xA0, 0xD1, 0xA2,
+		0xD1, 0xA4, 0xD1, 0xA6, 0xD1, 0xA8, 0xD1, 0xAA,
+		0xD1, 0xAC, 0xD1, 0xAE, 0xD1, 0xB0, 0xD1, 0xB2,
+		0xD1, 0xB4, 0xD1, 0xB6, 0xD1, 0xB8, 0xD1, 0xBA,
+		0xD1, 0xBC, 0xD1, 0xBE, 0xD2, 0x80, 0xD2, 0x8A,
+		0xD2, 0x8C, 0xD2, 0x8E, 0xD2, 0x90, 0xD2, 0x92,
+		0xD2, 0x94, 0xD2, 0x96, 0xD2, 0x98, 0xD2, 0x9A,
+		0xD2, 0x9C, 0xD2, 0x9E, 0xD2, 0xA0, 0xD2, 0xA2,
+		0xD2, 0xA4, 0xD2, 0xA6, 0xD2, 0xA8, 0xD2, 0xAA,
+		0xD2, 0xAC, 0xD2, 0xAE, 0xD2, 0xB0, 0xD2, 0xB2,
+		0xD2, 0xB4, 0xD2, 0xB6, 0xD2, 0xB8, 0xD2, 0xBA,
+		0xD2, 0xBC, 0xD2, 0xBE, 0xD3, 0x81, 0xD3, 0x83,
+		0xD3, 0x85, 0xD3, 0x87, 0xD3, 0x89, 0xD3, 0x8B,
+		0xD3, 0x8D, 0xD3, 0x80, 0xD3, 0x90, 0xD3, 0x92,
+		0xD3, 0x94, 0xD3, 0x96, 0xD3, 0x98, 0xD3, 0x9A,
+		0xD3, 0x9C, 0xD3, 0x9E, 0xD3, 0xA0, 0xD3, 0xA2,
+		0xD3, 0xA4, 0xD3, 0xA6, 0xD3, 0xA8, 0xD3, 0xAA,
+		0xD3, 0xAC, 0xD3, 0xAE, 0xD3, 0xB0, 0xD3, 0xB2,
+		0xD3, 0xB4, 0xD3, 0xB6, 0xD3, 0xB8, 0xD3, 0xBA,
+		0xD3, 0xBC, 0xD3, 0xBE, 0xD4, 0x80, 0xD4, 0x82,
+		0xD4, 0x84, 0xD4, 0x86, 0xD4, 0x88, 0xD4, 0x8A,
+		0xD4, 0x8C, 0xD4, 0x8E, 0xD4, 0x90, 0xD4, 0x92,
+		0xD4, 0xB1, 0xD4, 0xB2, 0xD4, 0xB3, 0xD4, 0xB4,
+		0xD4, 0xB5, 0xD4, 0xB6, 0xD4, 0xB7, 0xD4, 0xB8,
+		0xD4, 0xB9, 0xD4, 0xBA, 0xD4, 0xBB, 0xD4, 0xBC,
+		0xD4, 0xBD, 0xD4, 0xBE, 0xD4, 0xBF, 0xD5, 0x80,
+		0xD5, 0x81, 0xD5, 0x82, 0xD5, 0x83, 0xD5, 0x84,
+		0xD5, 0x85, 0xD5, 0x86, 0xD5, 0x87, 0xD5, 0x88,
+		0xD5, 0x89, 0xD5, 0x8A, 0xD5, 0x8B, 0xD5, 0x8C,
+		0xD5, 0x8D, 0xD5, 0x8E, 0xD5, 0x8F, 0xD5, 0x90,
+		0xD5, 0x91, 0xD5, 0x92, 0xD5, 0x93, 0xD5, 0x94,
+		0xD5, 0x95, 0xD5, 0x96, 0xE2, 0xB1, 0xA3, 0xE1,
+		0xB8, 0x80, 0xE1, 0xB8, 0x82, 0xE1, 0xB8, 0x84,
+		0xE1, 0xB8, 0x86, 0xE1, 0xB8, 0x88, 0xE1, 0xB8,
+		0x8A, 0xE1, 0xB8, 0x8C, 0xE1, 0xB8, 0x8E, 0xE1,
+		0xB8, 0x90, 0xE1, 0xB8, 0x92, 0xE1, 0xB8, 0x94,
+		0xE1, 0xB8, 0x96, 0xE1, 0xB8, 0x98, 0xE1, 0xB8,
+		0x9A, 0xE1, 0xB8, 0x9C, 0xE1, 0xB8, 0x9E, 0xE1,
+		0xB8, 0xA0, 0xE1, 0xB8, 0xA2, 0xE1, 0xB8, 0xA4,
+		0xE1, 0xB8, 0xA6, 0xE1, 0xB8, 0xA8, 0xE1, 0xB8,
+		0xAA, 0xE1, 0xB8, 0xAC, 0xE1, 0xB8, 0xAE, 0xE1,
+		0xB8, 0xB0, 0xE1, 0xB8, 0xB2, 0xE1, 0xB8, 0xB4,
+		0xE1, 0xB8, 0xB6, 0xE1, 0xB8, 0xB8, 0xE1, 0xB8,
+		0xBA, 0xE1, 0xB8, 0xBC, 0xE1, 0xB8, 0xBE, 0xE1,
+		0xB9, 0x80, 0xE1, 0xB9, 0x82, 0xE1, 0xB9, 0x84,
+		0xE1, 0xB9, 0x86, 0xE1, 0xB9, 0x88, 0xE1, 0xB9,
+		0x8A, 0xE1, 0xB9, 0x8C, 0xE1, 0xB9, 0x8E, 0xE1,
+		0xB9, 0x90, 0xE1, 0xB9, 0x92, 0xE1, 0xB9, 0x94,
+		0xE1, 0xB9, 0x96, 0xE1, 0xB9, 0x98, 0xE1, 0xB9,
+		0x9A, 0xE1, 0xB9, 0x9C, 0xE1, 0xB9, 0x9E, 0xE1,
+		0xB9, 0xA0, 0xE1, 0xB9, 0xA2, 0xE1, 0xB9, 0xA4,
+		0xE1, 0xB9, 0xA6, 0xE1, 0xB9, 0xA8, 0xE1, 0xB9,
+		0xAA, 0xE1, 0xB9, 0xAC, 0xE1, 0xB9, 0xAE, 0xE1,
+		0xB9, 0xB0, 0xE1, 0xB9, 0xB2, 0xE1, 0xB9, 0xB4,
+		0xE1, 0xB9, 0xB6, 0xE1, 0xB9, 0xB8, 0xE1, 0xB9,
+		0xBA, 0xE1, 0xB9, 0xBC, 0xE1, 0xB9, 0xBE, 0xE1,
+		0xBA, 0x80, 0xE1, 0xBA, 0x82, 0xE1, 0xBA, 0x84,
+		0xE1, 0xBA, 0x86, 0xE1, 0xBA, 0x88, 0xE1, 0xBA,
+		0x8A, 0xE1, 0xBA, 0x8C, 0xE1, 0xBA, 0x8E, 0xE1,
+		0xBA, 0x90, 0xE1, 0xBA, 0x92, 0xE1, 0xBA, 0x94,
+		0xE1, 0xB9, 0xA0, 0xE1, 0xBA, 0xA0, 0xE1, 0xBA,
+		0xA2, 0xE1, 0xBA, 0xA4, 0xE1, 0xBA, 0xA6, 0xE1,
+		0xBA, 0xA8, 0xE1, 0xBA, 0xAA, 0xE1, 0xBA, 0xAC,
+		0xE1, 0xBA, 0xAE, 0xE1, 0xBA, 0xB0, 0xE1, 0xBA,
+		0xB2, 0xE1, 0xBA, 0xB4, 0xE1, 0xBA, 0xB6, 0xE1,
+		0xBA, 0xB8, 0xE1, 0xBA, 0xBA, 0xE1, 0xBA, 0xBC,
+		0xE1, 0xBA, 0xBE, 0xE1, 0xBB, 0x80, 0xE1, 0xBB,
+		0x82, 0xE1, 0xBB, 0x84, 0xE1, 0xBB, 0x86, 0xE1,
+		0xBB, 0x88, 0xE1, 0xBB, 0x8A, 0xE1, 0xBB, 0x8C,
+		0xE1, 0xBB, 0x8E, 0xE1, 0xBB, 0x90, 0xE1, 0xBB,
+		0x92, 0xE1, 0xBB, 0x94, 0xE1, 0xBB, 0x96, 0xE1,
+		0xBB, 0x98, 0xE1, 0xBB, 0x9A, 0xE1, 0xBB, 0x9C,
+		0xE1, 0xBB, 0x9E, 0xE1, 0xBB, 0xA0, 0xE1, 0xBB,
+		0xA2, 0xE1, 0xBB, 0xA4, 0xE1, 0xBB, 0xA6, 0xE1,
+		0xBB, 0xA8, 0xE1, 0xBB, 0xAA, 0xE1, 0xBB, 0xAC,
+		0xE1, 0xBB, 0xAE, 0xE1, 0xBB, 0xB0, 0xE1, 0xBB,
+		0xB2, 0xE1, 0xBB, 0xB4, 0xE1, 0xBB, 0xB6, 0xE1,
+		0xBB, 0xB8, 0xE1, 0xBC, 0x88, 0xE1, 0xBC, 0x89,
+		0xE1, 0xBC, 0x8A, 0xE1, 0xBC, 0x8B, 0xE1, 0xBC,
+		0x8C, 0xE1, 0xBC, 0x8D, 0xE1, 0xBC, 0x8E, 0xE1,
+		0xBC, 0x8F, 0xE1, 0xBC, 0x98, 0xE1, 0xBC, 0x99,
+		0xE1, 0xBC, 0x9A, 0xE1, 0xBC, 0x9B, 0xE1, 0xBC,
+		0x9C, 0xE1, 0xBC, 0x9D, 0xE1, 0xBC, 0xA8, 0xE1,
+		0xBC, 0xA9, 0xE1, 0xBC, 0xAA, 0xE1, 0xBC, 0xAB,
+		0xE1, 0xBC, 0xAC, 0xE1, 0xBC, 0xAD, 0xE1, 0xBC,
+		0xAE, 0xE1, 0xBC, 0xAF, 0xE1, 0xBC, 0xB8, 0xE1,
+		0xBC, 0xB9, 0xE1, 0xBC, 0xBA, 0xE1, 0xBC, 0xBB,
+		0xE1, 0xBC, 0xBC, 0xE1, 0xBC, 0xBD, 0xE1, 0xBC,
+		0xBE, 0xE1, 0xBC, 0xBF, 0xE1, 0xBD, 0x88, 0xE1,
+		0xBD, 0x89, 0xE1, 0xBD, 0x8A, 0xE1, 0xBD, 0x8B,
+		0xE1, 0xBD, 0x8C, 0xE1, 0xBD, 0x8D, 0xE1, 0xBD,
+		0x99, 0xE1, 0xBD, 0x9B, 0xE1, 0xBD, 0x9D, 0xE1,
+		0xBD, 0x9F, 0xE1, 0xBD, 0xA8, 0xE1, 0xBD, 0xA9,
+		0xE1, 0xBD, 0xAA, 0xE1, 0xBD, 0xAB, 0xE1, 0xBD,
+		0xAC, 0xE1, 0xBD, 0xAD, 0xE1, 0xBD, 0xAE, 0xE1,
+		0xBD, 0xAF, 0xE1, 0xBE, 0xBA, 0xE1, 0xBE, 0xBB,
+		0xE1, 0xBF, 0x88, 0xE1, 0xBF, 0x89, 0xE1, 0xBF,
+		0x8A, 0xE1, 0xBF, 0x8B, 0xE1, 0xBF, 0x9A, 0xE1,
+		0xBF, 0x9B, 0xE1, 0xBF, 0xB8, 0xE1, 0xBF, 0xB9,
+		0xE1, 0xBF, 0xAA, 0xE1, 0xBF, 0xAB, 0xE1, 0xBF,
+		0xBA, 0xE1, 0xBF, 0xBB, 0xE1, 0xBE, 0x88, 0xE1,
+		0xBE, 0x89, 0xE1, 0xBE, 0x8A, 0xE1, 0xBE, 0x8B,
+		0xE1, 0xBE, 0x8C, 0xE1, 0xBE, 0x8D, 0xE1, 0xBE,
+		0x8E, 0xE1, 0xBE, 0x8F, 0xE1, 0xBE, 0x98, 0xE1,
+		0xBE, 0x99, 0xE1, 0xBE, 0x9A, 0xE1, 0xBE, 0x9B,
+		0xE1, 0xBE, 0x9C, 0xE1, 0xBE, 0x9D, 0xE1, 0xBE,
+		0x9E, 0xE1, 0xBE, 0x9F, 0xE1, 0xBE, 0xA8, 0xE1,
+		0xBE, 0xA9, 0xE1, 0xBE, 0xAA, 0xE1, 0xBE, 0xAB,
+		0xE1, 0xBE, 0xAC, 0xE1, 0xBE, 0xAD, 0xE1, 0xBE,
+		0xAE, 0xE1, 0xBE, 0xAF, 0xE1, 0xBE, 0xB8, 0xE1,
+		0xBE, 0xB9, 0xE1, 0xBE, 0xBC, 0xCE, 0x99, 0xE1,
+		0xBF, 0x8C, 0xE1, 0xBF, 0x98, 0xE1, 0xBF, 0x99,
+		0xE1, 0xBF, 0xA8, 0xE1, 0xBF, 0xA9, 0xE1, 0xBF,
+		0xAC, 0xE1, 0xBF, 0xBC, 0xE2, 0x84, 0xB2, 0xE2,
+		0x85, 0xA0, 0xE2, 0x85, 0xA1, 0xE2, 0x85, 0xA2,
+		0xE2, 0x85, 0xA3, 0xE2, 0x85, 0xA4, 0xE2, 0x85,
+		0xA5, 0xE2, 0x85, 0xA6, 0xE2, 0x85, 0xA7, 0xE2,
+		0x85, 0xA8, 0xE2, 0x85, 0xA9, 0xE2, 0x85, 0xAA,
+		0xE2, 0x85, 0xAB, 0xE2, 0x85, 0xAC, 0xE2, 0x85,
+		0xAD, 0xE2, 0x85, 0xAE, 0xE2, 0x85, 0xAF, 0xE2,
+		0x86, 0x83, 0xE2, 0x92, 0xB6, 0xE2, 0x92, 0xB7,
+		0xE2, 0x92, 0xB8, 0xE2, 0x92, 0xB9, 0xE2, 0x92,
+		0xBA, 0xE2, 0x92, 0xBB, 0xE2, 0x92, 0xBC, 0xE2,
+		0x92, 0xBD, 0xE2, 0x92, 0xBE, 0xE2, 0x92, 0xBF,
+		0xE2, 0x93, 0x80, 0xE2, 0x93, 0x81, 0xE2, 0x93,
+		0x82, 0xE2, 0x93, 0x83, 0xE2, 0x93, 0x84, 0xE2,
+		0x93, 0x85, 0xE2, 0x93, 0x86, 0xE2, 0x93, 0x87,
+		0xE2, 0x93, 0x88, 0xE2, 0x93, 0x89, 0xE2, 0x93,
+		0x8A, 0xE2, 0x93, 0x8B, 0xE2, 0x93, 0x8C, 0xE2,
+		0x93, 0x8D, 0xE2, 0x93, 0x8E, 0xE2, 0x93, 0x8F,
+		0xE2, 0xB0, 0x80, 0xE2, 0xB0, 0x81, 0xE2, 0xB0,
+		0x82, 0xE2, 0xB0, 0x83, 0xE2, 0xB0, 0x84, 0xE2,
+		0xB0, 0x85, 0xE2, 0xB0, 0x86, 0xE2, 0xB0, 0x87,
+		0xE2, 0xB0, 0x88, 0xE2, 0xB0, 0x89, 0xE2, 0xB0,
+		0x8A, 0xE2, 0xB0, 0x8B, 0xE2, 0xB0, 0x8C, 0xE2,
+		0xB0, 0x8D, 0xE2, 0xB0, 0x8E, 0xE2, 0xB0, 0x8F,
+		0xE2, 0xB0, 0x90, 0xE2, 0xB0, 0x91, 0xE2, 0xB0,
+		0x92, 0xE2, 0xB0, 0x93, 0xE2, 0xB0, 0x94, 0xE2,
+		0xB0, 0x95, 0xE2, 0xB0, 0x96, 0xE2, 0xB0, 0x97,
+		0xE2, 0xB0, 0x98, 0xE2, 0xB0, 0x99, 0xE2, 0xB0,
+		0x9A, 0xE2, 0xB0, 0x9B, 0xE2, 0xB0, 0x9C, 0xE2,
+		0xB0, 0x9D, 0xE2, 0xB0, 0x9E, 0xE2, 0xB0, 0x9F,
+		0xE2, 0xB0, 0xA0, 0xE2, 0xB0, 0xA1, 0xE2, 0xB0,
+		0xA2, 0xE2, 0xB0, 0xA3, 0xE2, 0xB0, 0xA4, 0xE2,
+		0xB0, 0xA5, 0xE2, 0xB0, 0xA6, 0xE2, 0xB0, 0xA7,
+		0xE2, 0xB0, 0xA8, 0xE2, 0xB0, 0xA9, 0xE2, 0xB0,
+		0xAA, 0xE2, 0xB0, 0xAB, 0xE2, 0xB0, 0xAC, 0xE2,
+		0xB0, 0xAD, 0xE2, 0xB0, 0xAE, 0xE2, 0xB1, 0xA0,
+		0xC8, 0xBA, 0xC8, 0xBE, 0xE2, 0xB1, 0xA7, 0xE2,
+		0xB1, 0xA9, 0xE2, 0xB1, 0xAB, 0xE2, 0xB1, 0xB5,
+		0xE2, 0xB2, 0x80, 0xE2, 0xB2, 0x82, 0xE2, 0xB2,
+		0x84, 0xE2, 0xB2, 0x86, 0xE2, 0xB2, 0x88, 0xE2,
+		0xB2, 0x8A, 0xE2, 0xB2, 0x8C, 0xE2, 0xB2, 0x8E,
+		0xE2, 0xB2, 0x90, 0xE2, 0xB2, 0x92, 0xE2, 0xB2,
+		0x94, 0xE2, 0xB2, 0x96, 0xE2, 0xB2, 0x98, 0xE2,
+		0xB2, 0x9A, 0xE2, 0xB2, 0x9C, 0xE2, 0xB2, 0x9E,
+		0xE2, 0xB2, 0xA0, 0xE2, 0xB2, 0xA2, 0xE2, 0xB2,
+		0xA4, 0xE2, 0xB2, 0xA6, 0xE2, 0xB2, 0xA8, 0xE2,
+		0xB2, 0xAA, 0xE2, 0xB2, 0xAC, 0xE2, 0xB2, 0xAE,
+		0xE2, 0xB2, 0xB0, 0xE2, 0xB2, 0xB2, 0xE2, 0xB2,
+		0xB4, 0xE2, 0xB2, 0xB6, 0xE2, 0xB2, 0xB8, 0xE2,
+		0xB2, 0xBA, 0xE2, 0xB2, 0xBC, 0xE2, 0xB2, 0xBE,
+		0xE2, 0xB3, 0x80, 0xE2, 0xB3, 0x82, 0xE2, 0xB3,
+		0x84, 0xE2, 0xB3, 0x86, 0xE2, 0xB3, 0x88, 0xE2,
+		0xB3, 0x8A, 0xE2, 0xB3, 0x8C, 0xE2, 0xB3, 0x8E,
+		0xE2, 0xB3, 0x90, 0xE2, 0xB3, 0x92, 0xE2, 0xB3,
+		0x94, 0xE2, 0xB3, 0x96, 0xE2, 0xB3, 0x98, 0xE2,
+		0xB3, 0x9A, 0xE2, 0xB3, 0x9C, 0xE2, 0xB3, 0x9E,
+		0xE2, 0xB3, 0xA0, 0xE2, 0xB3, 0xA2, 0xE1, 0x82,
+		0xA0, 0xE1, 0x82, 0xA1, 0xE1, 0x82, 0xA2, 0xE1,
+		0x82, 0xA3, 0xE1, 0x82, 0xA4, 0xE1, 0x82, 0xA5,
+		0xE1, 0x82, 0xA6, 0xE1, 0x82, 0xA7, 0xE1, 0x82,
+		0xA8, 0xE1, 0x82, 0xA9, 0xE1, 0x82, 0xAA, 0xE1,
+		0x82, 0xAB, 0xE1, 0x82, 0xAC, 0xE1, 0x82, 0xAD,
+		0xE1, 0x82, 0xAE, 0xE1, 0x82, 0xAF, 0xE1, 0x82,
+		0xB0, 0xE1, 0x82, 0xB1, 0xE1, 0x82, 0xB2, 0xE1,
+		0x82, 0xB3, 0xE1, 0x82, 0xB4, 0xE1, 0x82, 0xB5,
+		0xE1, 0x82, 0xB6, 0xE1, 0x82, 0xB7, 0xE1, 0x82,
+		0xB8, 0xE1, 0x82, 0xB9, 0xE1, 0x82, 0xBA, 0xE1,
+		0x82, 0xBB, 0xE1, 0x82, 0xBC, 0xE1, 0x82, 0xBD,
+		0xE1, 0x82, 0xBE, 0xE1, 0x82, 0xBF, 0xE1, 0x83,
+		0x80, 0xE1, 0x83, 0x81, 0xE1, 0x83, 0x82, 0xE1,
+		0x83, 0x83, 0xE1, 0x83, 0x84, 0xE1, 0x83, 0x85,
+		0xEF, 0xBC, 0xA1, 0xEF, 0xBC, 0xA2, 0xEF, 0xBC,
+		0xA3, 0xEF, 0xBC, 0xA4, 0xEF, 0xBC, 0xA5, 0xEF,
+		0xBC, 0xA6, 0xEF, 0xBC, 0xA7, 0xEF, 0xBC, 0xA8,
+		0xEF, 0xBC, 0xA9, 0xEF, 0xBC, 0xAA, 0xEF, 0xBC,
+		0xAB, 0xEF, 0xBC, 0xAC, 0xEF, 0xBC, 0xAD, 0xEF,
+		0xBC, 0xAE, 0xEF, 0xBC, 0xAF, 0xEF, 0xBC, 0xB0,
+		0xEF, 0xBC, 0xB1, 0xEF, 0xBC, 0xB2, 0xEF, 0xBC,
+		0xB3, 0xEF, 0xBC, 0xB4, 0xEF, 0xBC, 0xB5, 0xEF,
+		0xBC, 0xB6, 0xEF, 0xBC, 0xB7, 0xEF, 0xBC, 0xB8,
+		0xEF, 0xBC, 0xB9, 0xEF, 0xBC, 0xBA, 0xF0, 0x90,
+		0x90, 0x80, 0xF0, 0x90, 0x90, 0x81, 0xF0, 0x90,
+		0x90, 0x82, 0xF0, 0x90, 0x90, 0x83, 0xF0, 0x90,
+		0x90, 0x84, 0xF0, 0x90, 0x90, 0x85, 0xF0, 0x90,
+		0x90, 0x86, 0xF0, 0x90, 0x90, 0x87, 0xF0, 0x90,
+		0x90, 0x88, 0xF0, 0x90, 0x90, 0x89, 0xF0, 0x90,
+		0x90, 0x8A, 0xF0, 0x90, 0x90, 0x8B, 0xF0, 0x90,
+		0x90, 0x8C, 0xF0, 0x90, 0x90, 0x8D, 0xF0, 0x90,
+		0x90, 0x8E, 0xF0, 0x90, 0x90, 0x8F, 0xF0, 0x90,
+		0x90, 0x90, 0xF0, 0x90, 0x90, 0x91, 0xF0, 0x90,
+		0x90, 0x92, 0xF0, 0x90, 0x90, 0x93, 0xF0, 0x90,
+		0x90, 0x94, 0xF0, 0x90, 0x90, 0x95, 0xF0, 0x90,
+		0x90, 0x96, 0xF0, 0x90, 0x90, 0x97, 0xF0, 0x90,
+		0x90, 0x98, 0xF0, 0x90, 0x90, 0x99, 0xF0, 0x90,
+		0x90, 0x9A, 0xF0, 0x90, 0x90, 0x9B, 0xF0, 0x90,
+		0x90, 0x9C, 0xF0, 0x90, 0x90, 0x9D, 0xF0, 0x90,
+		0x90, 0x9E, 0xF0, 0x90, 0x90, 0x9F, 0xF0, 0x90,
+		0x90, 0xA0, 0xF0, 0x90, 0x90, 0xA1, 0xF0, 0x90,
+		0x90, 0xA2, 0xF0, 0x90, 0x90, 0xA3, 0xF0, 0x90,
+		0x90, 0xA4, 0xF0, 0x90, 0x90, 0xA5, 0xF0, 0x90,
+		0x90, 0xA6, 0xF0, 0x90, 0x90, 0xA7,
+	},
+};
+
+#undef	N_
+#undef	FIL_
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_U8_TEXTPREP_DATA_H */
diff --git a/include/sys/uberblock.h b/include/sys/uberblock.h
new file mode 100644
index 0000000000000..044e438387c0a
--- /dev/null
+++ b/include/sys/uberblock.h
@@ -0,0 +1,50 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*
+ * Copyright (c) 2014 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_UBERBLOCK_H
+#define	_SYS_UBERBLOCK_H
+
+#include <sys/spa.h>
+#include <sys/vdev.h>
+#include <sys/zio.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct uberblock uberblock_t;
+
+extern int uberblock_verify(uberblock_t *);
+extern boolean_t uberblock_update(uberblock_t *ub, vdev_t *rvd, uint64_t txg,
+    uint64_t mmp_delay);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_UBERBLOCK_H */
diff --git a/include/sys/uberblock_impl.h b/include/sys/uberblock_impl.h
new file mode 100644
index 0000000000000..91699e65131aa
--- /dev/null
+++ b/include/sys/uberblock_impl.h
@@ -0,0 +1,145 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2017 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_UBERBLOCK_IMPL_H
+#define	_SYS_UBERBLOCK_IMPL_H
+
+#include <sys/uberblock.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * The uberblock version is incremented whenever an incompatible on-disk
+ * format change is made to the SPA, DMU, or ZAP.
+ *
+ * Note: the first two fields should never be moved.  When a storage pool
+ * is opened, the uberblock must be read off the disk before the version
+ * can be checked.  If the ub_version field is moved, we may not detect
+ * version mismatch.  If the ub_magic field is moved, applications that
+ * expect the magic number in the first word won't work.
+ */
+#define	UBERBLOCK_MAGIC		0x00bab10c		/* oo-ba-bloc!	*/
+#define	UBERBLOCK_SHIFT		10			/* up to 1K	*/
+#define	MMP_MAGIC		0xa11cea11		/* all-see-all	*/
+
+#define	MMP_INTERVAL_VALID_BIT	0x01
+#define	MMP_SEQ_VALID_BIT	0x02
+#define	MMP_FAIL_INT_VALID_BIT	0x04
+
+#define	MMP_VALID(ubp)		(ubp->ub_magic == UBERBLOCK_MAGIC && \
+				    ubp->ub_mmp_magic == MMP_MAGIC)
+#define	MMP_INTERVAL_VALID(ubp)	(MMP_VALID(ubp) && (ubp->ub_mmp_config & \
+				    MMP_INTERVAL_VALID_BIT))
+#define	MMP_SEQ_VALID(ubp)	(MMP_VALID(ubp) && (ubp->ub_mmp_config & \
+				    MMP_SEQ_VALID_BIT))
+#define	MMP_FAIL_INT_VALID(ubp)	(MMP_VALID(ubp) && (ubp->ub_mmp_config & \
+				    MMP_FAIL_INT_VALID_BIT))
+
+#define	MMP_INTERVAL(ubp)	((ubp->ub_mmp_config & 0x00000000FFFFFF00) \
+				    >> 8)
+#define	MMP_SEQ(ubp)		((ubp->ub_mmp_config & 0x0000FFFF00000000) \
+				    >> 32)
+#define	MMP_FAIL_INT(ubp)	((ubp->ub_mmp_config & 0xFFFF000000000000) \
+				    >> 48)
+
+#define	MMP_INTERVAL_SET(write) \
+	    (((uint64_t)(write & 0xFFFFFF) << 8) | MMP_INTERVAL_VALID_BIT)
+
+#define	MMP_SEQ_SET(seq) \
+	    (((uint64_t)(seq & 0xFFFF) << 32) | MMP_SEQ_VALID_BIT)
+
+#define	MMP_FAIL_INT_SET(fail) \
+	    (((uint64_t)(fail & 0xFFFF) << 48) | MMP_FAIL_INT_VALID_BIT)
+
+struct uberblock {
+	uint64_t	ub_magic;	/* UBERBLOCK_MAGIC		*/
+	uint64_t	ub_version;	/* SPA_VERSION			*/
+	uint64_t	ub_txg;		/* txg of last sync		*/
+	uint64_t	ub_guid_sum;	/* sum of all vdev guids	*/
+	uint64_t	ub_timestamp;	/* UTC time of last sync	*/
+	blkptr_t	ub_rootbp;	/* MOS objset_phys_t		*/
+
+	/* highest SPA_VERSION supported by software that wrote this txg */
+	uint64_t	ub_software_version;
+
+	/* Maybe missing in uberblocks we read, but always written */
+	uint64_t	ub_mmp_magic;	/* MMP_MAGIC			*/
+	/*
+	 * If ub_mmp_delay == 0 and ub_mmp_magic is valid, MMP is off.
+	 * Otherwise, nanosec since last MMP write.
+	 */
+	uint64_t	ub_mmp_delay;
+
+	/*
+	 * The ub_mmp_config contains the multihost write interval, multihost
+	 * fail intervals, sequence number for sub-second granularity, and
+	 * valid bit mask.  This layout is as follows:
+	 *
+	 *   64      56      48      40      32      24      16      8       0
+	 *   +-------+-------+-------+-------+-------+-------+-------+-------+
+	 * 0 | Fail Intervals|      Seq      |   Write Interval (ms) | VALID |
+	 *   +-------+-------+-------+-------+-------+-------+-------+-------+
+	 *
+	 * This allows a write_interval of (2^24/1000)s, over 4.5 hours
+	 *
+	 * VALID Bits:
+	 * - 0x01 - Write Interval (ms)
+	 * - 0x02 - Sequence number exists
+	 * - 0x04 - Fail Intervals
+	 * - 0xf8 - Reserved
+	 */
+	uint64_t	ub_mmp_config;
+
+	/*
+	 * ub_checkpoint_txg indicates two things about the current uberblock:
+	 *
+	 * 1] If it is not zero then this uberblock is a checkpoint. If it is
+	 *    zero, then this uberblock is not a checkpoint.
+	 *
+	 * 2] On checkpointed uberblocks, the value of ub_checkpoint_txg is
+	 *    the ub_txg that the uberblock had at the time we moved it to
+	 *    the MOS config.
+	 *
+	 * The field is set when we checkpoint the uberblock and continues to
+	 * hold that value even after we've rewound (unlike the ub_txg that
+	 * is reset to a higher value).
+	 *
+	 * Besides checks used to determine whether we are reopening the
+	 * pool from a checkpointed uberblock [see spa_ld_select_uberblock()],
+	 * the value of the field is used to determine which ZIL blocks have
+	 * been allocated according to the ms_sm when we are rewinding to a
+	 * checkpoint. Specifically, if blk_birth > ub_checkpoint_txg, then
+	 * the ZIL block is not allocated [see uses of spa_min_claim_txg()].
+	 */
+	uint64_t	ub_checkpoint_txg;
+};
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_UBERBLOCK_IMPL_H */
diff --git a/include/sys/uio_impl.h b/include/sys/uio_impl.h
new file mode 100644
index 0000000000000..cfef0b95dbb95
--- /dev/null
+++ b/include/sys/uio_impl.h
@@ -0,0 +1,49 @@
+/*
+ * 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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
+/*	  All Rights Reserved	*/
+
+/*
+ * University Copyright- Copyright (c) 1982, 1986, 1988
+ * The Regents of the University of California
+ * All Rights Reserved
+ *
+ * University Acknowledgment- Portions of this document are derived from
+ * software developed by the University of California, Berkeley, and its
+ * contributors.
+ */
+
+#ifndef _SYS_UIO_IMPL_H
+#define	_SYS_UIO_IMPL_H
+
+#include <sys/uio.h>
+
+extern int uiomove(void *, size_t, enum uio_rw, uio_t *);
+extern int uio_prefaultpages(ssize_t, uio_t *);
+extern int uiocopy(void *, size_t, enum uio_rw, uio_t *, size_t *);
+extern void uioskip(uio_t *, size_t);
+
+#endif	/* _SYS_UIO_IMPL_H */
diff --git a/include/sys/unique.h b/include/sys/unique.h
new file mode 100644
index 0000000000000..d4ba32e5c642a
--- /dev/null
+++ b/include/sys/unique.h
@@ -0,0 +1,57 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_UNIQUE_H
+#define	_SYS_UNIQUE_H
+
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/* The number of significant bits in each unique value. */
+#define	UNIQUE_BITS	56
+
+void unique_init(void);
+void unique_fini(void);
+
+/*
+ * Return a new unique value (which will not be uniquified against until
+ * it is unique_insert()-ed).
+ */
+uint64_t unique_create(void);
+
+/* Return a unique value, which equals the one passed in if possible. */
+uint64_t unique_insert(uint64_t value);
+
+/* Indicate that this value no longer needs to be uniquified against. */
+void unique_remove(uint64_t value);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_UNIQUE_H */
diff --git a/include/sys/uuid.h b/include/sys/uuid.h
new file mode 100644
index 0000000000000..eab4622a6d9a4
--- /dev/null
+++ b/include/sys/uuid.h
@@ -0,0 +1,94 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_UUID_H
+#define	_SYS_UUID_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * The copyright in this file is taken from the original Leach
+ * & Salz UUID specification, from which this implementation
+ * is derived.
+ */
+
+/*
+ * Copyright (c) 1990- 1993, 1996 Open Software Foundation, Inc.
+ * Copyright (c) 1989 by Hewlett-Packard Company, Palo Alto, Ca. &
+ * Digital Equipment Corporation, Maynard, Mass.  Copyright (c) 1998
+ * Microsoft.  To anyone who acknowledges that this file is provided
+ * "AS IS" without any express or implied warranty: permission to use,
+ * copy, modify, and distribute this file for any purpose is hereby
+ * granted without fee, provided that the above copyright notices and
+ * this notice appears in all source code copies, and that none of the
+ * names of Open Software Foundation, Inc., Hewlett-Packard Company,
+ * or Digital Equipment Corporation be used in advertising or
+ * publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Neither Open Software
+ * Foundation, Inc., Hewlett-Packard Company, Microsoft, nor Digital
+ * Equipment Corporation makes any representations about the
+ * suitability of this software for any purpose.
+ */
+
+#include <sys/types.h>
+#include <sys/byteorder.h>
+
+typedef struct {
+	uint8_t		nodeID[6];
+} uuid_node_t;
+
+/*
+ * The uuid type used throughout when referencing uuids themselves
+ */
+struct uuid {
+	uint32_t	time_low;
+	uint16_t	time_mid;
+	uint16_t	time_hi_and_version;
+	uint8_t		clock_seq_hi_and_reserved;
+	uint8_t		clock_seq_low;
+	uint8_t		node_addr[6];
+};
+
+#define	UUID_PRINTABLE_STRING_LENGTH 37
+
+/*
+ * Convert a uuid to/from little-endian format
+ */
+#define	UUID_LE_CONVERT(dest, src)					\
+{									\
+	(dest) = (src);							\
+	(dest).time_low = LE_32((dest).time_low);			\
+	(dest).time_mid = LE_16((dest).time_mid);			\
+	(dest).time_hi_and_version = LE_16((dest).time_hi_and_version);	\
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_UUID_H */
diff --git a/include/sys/vdev.h b/include/sys/vdev.h
new file mode 100644
index 0000000000000..797065fdd0a53
--- /dev/null
+++ b/include/sys/vdev.h
@@ -0,0 +1,201 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
+ * Copyright (c) 2017, Intel Corporation.
+ * Copyright (c) 2019, Datto Inc. All rights reserved.
+ */
+
+#ifndef _SYS_VDEV_H
+#define	_SYS_VDEV_H
+
+#include <sys/spa.h>
+#include <sys/zio.h>
+#include <sys/dmu.h>
+#include <sys/space_map.h>
+#include <sys/fs/zfs.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef enum vdev_dtl_type {
+	DTL_MISSING,	/* 0% replication: no copies of the data */
+	DTL_PARTIAL,	/* less than 100% replication: some copies missing */
+	DTL_SCRUB,	/* unable to fully repair during scrub/resilver */
+	DTL_OUTAGE,	/* temporarily missing (used to attempt detach) */
+	DTL_TYPES
+} vdev_dtl_type_t;
+
+extern int zfs_nocacheflush;
+
+extern void vdev_dbgmsg(vdev_t *vd, const char *fmt, ...);
+extern void vdev_dbgmsg_print_tree(vdev_t *, int);
+extern int vdev_open(vdev_t *);
+extern void vdev_open_children(vdev_t *);
+extern int vdev_validate(vdev_t *);
+extern int vdev_copy_path_strict(vdev_t *, vdev_t *);
+extern void vdev_copy_path_relaxed(vdev_t *, vdev_t *);
+extern void vdev_close(vdev_t *);
+extern int vdev_create(vdev_t *, uint64_t txg, boolean_t isreplace);
+extern void vdev_reopen(vdev_t *);
+extern int vdev_validate_aux(vdev_t *vd);
+extern zio_t *vdev_probe(vdev_t *vd, zio_t *pio);
+extern boolean_t vdev_is_concrete(vdev_t *vd);
+extern boolean_t vdev_is_bootable(vdev_t *vd);
+extern vdev_t *vdev_lookup_top(spa_t *spa, uint64_t vdev);
+extern vdev_t *vdev_lookup_by_guid(vdev_t *vd, uint64_t guid);
+extern int vdev_count_leaves(spa_t *spa);
+extern void vdev_dtl_dirty(vdev_t *vd, vdev_dtl_type_t d,
+    uint64_t txg, uint64_t size);
+extern boolean_t vdev_dtl_contains(vdev_t *vd, vdev_dtl_type_t d,
+    uint64_t txg, uint64_t size);
+extern boolean_t vdev_dtl_empty(vdev_t *vd, vdev_dtl_type_t d);
+extern boolean_t vdev_dtl_need_resilver(vdev_t *vd, uint64_t off, size_t size);
+extern void vdev_dtl_reassess(vdev_t *vd, uint64_t txg, uint64_t scrub_txg,
+    boolean_t scrub_done, boolean_t rebuild_done);
+extern boolean_t vdev_dtl_required(vdev_t *vd);
+extern boolean_t vdev_resilver_needed(vdev_t *vd,
+    uint64_t *minp, uint64_t *maxp);
+extern void vdev_destroy_unlink_zap(vdev_t *vd, uint64_t zapobj,
+    dmu_tx_t *tx);
+extern uint64_t vdev_create_link_zap(vdev_t *vd, dmu_tx_t *tx);
+extern void vdev_construct_zaps(vdev_t *vd, dmu_tx_t *tx);
+extern void vdev_destroy_spacemaps(vdev_t *vd, dmu_tx_t *tx);
+extern void vdev_indirect_mark_obsolete(vdev_t *vd, uint64_t offset,
+    uint64_t size);
+extern void spa_vdev_indirect_mark_obsolete(spa_t *spa, uint64_t vdev,
+    uint64_t offset, uint64_t size, dmu_tx_t *tx);
+extern boolean_t vdev_replace_in_progress(vdev_t *vdev);
+
+extern void vdev_hold(vdev_t *);
+extern void vdev_rele(vdev_t *);
+
+extern int vdev_metaslab_init(vdev_t *vd, uint64_t txg);
+extern void vdev_metaslab_fini(vdev_t *vd);
+extern void vdev_metaslab_set_size(vdev_t *);
+extern void vdev_ashift_optimize(vdev_t *);
+extern void vdev_expand(vdev_t *vd, uint64_t txg);
+extern void vdev_split(vdev_t *vd);
+extern void vdev_deadman(vdev_t *vd, char *tag);
+extern void vdev_xlate(vdev_t *vd, const range_seg64_t *logical_rs,
+    range_seg64_t *physical_rs);
+
+extern void vdev_get_stats_ex(vdev_t *vd, vdev_stat_t *vs, vdev_stat_ex_t *vsx);
+extern void vdev_get_stats(vdev_t *vd, vdev_stat_t *vs);
+extern void vdev_clear_stats(vdev_t *vd);
+extern void vdev_stat_update(zio_t *zio, uint64_t psize);
+extern void vdev_scan_stat_init(vdev_t *vd);
+extern void vdev_propagate_state(vdev_t *vd);
+extern void vdev_set_state(vdev_t *vd, boolean_t isopen, vdev_state_t state,
+    vdev_aux_t aux);
+extern boolean_t vdev_children_are_offline(vdev_t *vd);
+
+extern void vdev_space_update(vdev_t *vd,
+    int64_t alloc_delta, int64_t defer_delta, int64_t space_delta);
+
+extern int64_t vdev_deflated_space(vdev_t *vd, int64_t space);
+
+extern uint64_t vdev_psize_to_asize(vdev_t *vd, uint64_t psize);
+
+extern int vdev_fault(spa_t *spa, uint64_t guid, vdev_aux_t aux);
+extern int vdev_degrade(spa_t *spa, uint64_t guid, vdev_aux_t aux);
+extern int vdev_online(spa_t *spa, uint64_t guid, uint64_t flags,
+    vdev_state_t *);
+extern int vdev_offline(spa_t *spa, uint64_t guid, uint64_t flags);
+extern void vdev_clear(spa_t *spa, vdev_t *vd);
+
+extern boolean_t vdev_is_dead(vdev_t *vd);
+extern boolean_t vdev_readable(vdev_t *vd);
+extern boolean_t vdev_writeable(vdev_t *vd);
+extern boolean_t vdev_allocatable(vdev_t *vd);
+extern boolean_t vdev_accessible(vdev_t *vd, zio_t *zio);
+extern boolean_t vdev_is_spacemap_addressable(vdev_t *vd);
+
+extern void vdev_cache_init(vdev_t *vd);
+extern void vdev_cache_fini(vdev_t *vd);
+extern boolean_t vdev_cache_read(zio_t *zio);
+extern void vdev_cache_write(zio_t *zio);
+extern void vdev_cache_purge(vdev_t *vd);
+
+extern void vdev_queue_init(vdev_t *vd);
+extern void vdev_queue_fini(vdev_t *vd);
+extern zio_t *vdev_queue_io(zio_t *zio);
+extern void vdev_queue_io_done(zio_t *zio);
+extern void vdev_queue_change_io_priority(zio_t *zio, zio_priority_t priority);
+
+extern int vdev_queue_length(vdev_t *vd);
+extern uint64_t vdev_queue_last_offset(vdev_t *vd);
+
+extern void vdev_config_dirty(vdev_t *vd);
+extern void vdev_config_clean(vdev_t *vd);
+extern int vdev_config_sync(vdev_t **svd, int svdcount, uint64_t txg);
+
+extern void vdev_state_dirty(vdev_t *vd);
+extern void vdev_state_clean(vdev_t *vd);
+
+extern void vdev_defer_resilver(vdev_t *vd);
+extern boolean_t vdev_clear_resilver_deferred(vdev_t *vd, dmu_tx_t *tx);
+
+typedef enum vdev_config_flag {
+	VDEV_CONFIG_SPARE = 1 << 0,
+	VDEV_CONFIG_L2CACHE = 1 << 1,
+	VDEV_CONFIG_REMOVING = 1 << 2,
+	VDEV_CONFIG_MOS = 1 << 3,
+	VDEV_CONFIG_MISSING = 1 << 4
+} vdev_config_flag_t;
+
+extern void vdev_top_config_generate(spa_t *spa, nvlist_t *config);
+extern nvlist_t *vdev_config_generate(spa_t *spa, vdev_t *vd,
+    boolean_t getstats, vdev_config_flag_t flags);
+
+/*
+ * Label routines
+ */
+struct uberblock;
+extern uint64_t vdev_label_offset(uint64_t psize, int l, uint64_t offset);
+extern int vdev_label_number(uint64_t psise, uint64_t offset);
+extern nvlist_t *vdev_label_read_config(vdev_t *vd, uint64_t txg);
+extern void vdev_uberblock_load(vdev_t *, struct uberblock *, nvlist_t **);
+extern void vdev_config_generate_stats(vdev_t *vd, nvlist_t *nv);
+extern void vdev_label_write(zio_t *zio, vdev_t *vd, int l, abd_t *buf, uint64_t
+    offset, uint64_t size, zio_done_func_t *done, void *priv, int flags);
+extern int vdev_label_read_bootenv(vdev_t *, nvlist_t *);
+extern int vdev_label_write_bootenv(vdev_t *, char *);
+
+typedef enum {
+	VDEV_LABEL_CREATE,	/* create/add a new device */
+	VDEV_LABEL_REPLACE,	/* replace an existing device */
+	VDEV_LABEL_SPARE,	/* add a new hot spare */
+	VDEV_LABEL_REMOVE,	/* remove an existing device */
+	VDEV_LABEL_L2CACHE,	/* add an L2ARC cache device */
+	VDEV_LABEL_SPLIT	/* generating new label for split-off dev */
+} vdev_labeltype_t;
+
+extern int vdev_label_init(vdev_t *vd, uint64_t txg, vdev_labeltype_t reason);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VDEV_H */
diff --git a/include/sys/vdev_disk.h b/include/sys/vdev_disk.h
new file mode 100644
index 0000000000000..a7e19fbf0c4b5
--- /dev/null
+++ b/include/sys/vdev_disk.h
@@ -0,0 +1,46 @@
+/*
+ * 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) 2008-2010 Lawrence Livermore National Security, LLC.
+ * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
+ * Written by Brian Behlendorf <behlendorf1@llnl.gov>.
+ * LLNL-CODE-403049.
+ * Copyright (c) 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_VDEV_DISK_H
+#define	_SYS_VDEV_DISK_H
+
+/*
+ * Don't start the slice at the default block of 34; many storage
+ * devices will use a stripe width of 128k, other vendors prefer a 1m
+ * alignment.  It is best to play it safe and ensure a 1m alignment
+ * given 512B blocks.  When the block size is larger by a power of 2
+ * we will still be 1m aligned.  Some devices are sensitive to the
+ * partition ending alignment as well.
+ */
+#define	NEW_START_BLOCK		2048
+#define	PARTITION_END_ALIGNMENT	2048
+
+#ifdef _KERNEL
+#include <sys/vdev.h>
+#endif /* _KERNEL */
+#endif /* _SYS_VDEV_DISK_H */
diff --git a/include/sys/vdev_file.h b/include/sys/vdev_file.h
new file mode 100644
index 0000000000000..1514a44fcabb9
--- /dev/null
+++ b/include/sys/vdev_file.h
@@ -0,0 +1,47 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_VDEV_FILE_H
+#define	_SYS_VDEV_FILE_H
+
+#include <sys/vdev.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct vdev_file {
+	zfs_file_t	*vf_file;
+} vdev_file_t;
+
+extern void vdev_file_init(void);
+extern void vdev_file_fini(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VDEV_FILE_H */
diff --git a/include/sys/vdev_impl.h b/include/sys/vdev_impl.h
new file mode 100644
index 0000000000000..90d6077460139
--- /dev/null
+++ b/include/sys/vdev_impl.h
@@ -0,0 +1,620 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
+ * Copyright (c) 2017, Intel Corporation.
+ */
+
+#ifndef _SYS_VDEV_IMPL_H
+#define	_SYS_VDEV_IMPL_H
+
+#include <sys/avl.h>
+#include <sys/bpobj.h>
+#include <sys/dmu.h>
+#include <sys/metaslab.h>
+#include <sys/nvpair.h>
+#include <sys/space_map.h>
+#include <sys/vdev.h>
+#include <sys/dkio.h>
+#include <sys/uberblock_impl.h>
+#include <sys/vdev_indirect_mapping.h>
+#include <sys/vdev_indirect_births.h>
+#include <sys/vdev_rebuild.h>
+#include <sys/vdev_removal.h>
+#include <sys/zfs_ratelimit.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Virtual device descriptors.
+ *
+ * All storage pool operations go through the virtual device framework,
+ * which provides data replication and I/O scheduling.
+ */
+
+/*
+ * Forward declarations that lots of things need.
+ */
+typedef struct vdev_queue vdev_queue_t;
+typedef struct vdev_cache vdev_cache_t;
+typedef struct vdev_cache_entry vdev_cache_entry_t;
+struct abd;
+
+extern int zfs_vdev_queue_depth_pct;
+extern int zfs_vdev_def_queue_depth;
+extern uint32_t zfs_vdev_async_write_max_active;
+
+/*
+ * Virtual device operations
+ */
+typedef int	vdev_open_func_t(vdev_t *vd, uint64_t *size, uint64_t *max_size,
+    uint64_t *ashift, uint64_t *pshift);
+typedef void	vdev_close_func_t(vdev_t *vd);
+typedef uint64_t vdev_asize_func_t(vdev_t *vd, uint64_t psize);
+typedef void	vdev_io_start_func_t(zio_t *zio);
+typedef void	vdev_io_done_func_t(zio_t *zio);
+typedef void	vdev_state_change_func_t(vdev_t *vd, int, int);
+typedef boolean_t vdev_need_resilver_func_t(vdev_t *vd, uint64_t, size_t);
+typedef void	vdev_hold_func_t(vdev_t *vd);
+typedef void	vdev_rele_func_t(vdev_t *vd);
+
+typedef void	vdev_remap_cb_t(uint64_t inner_offset, vdev_t *vd,
+    uint64_t offset, uint64_t size, void *arg);
+typedef void	vdev_remap_func_t(vdev_t *vd, uint64_t offset, uint64_t size,
+    vdev_remap_cb_t callback, void *arg);
+/*
+ * Given a target vdev, translates the logical range "in" to the physical
+ * range "res"
+ */
+typedef void vdev_xlation_func_t(vdev_t *cvd, const range_seg64_t *in,
+    range_seg64_t *res);
+
+typedef const struct vdev_ops {
+	vdev_open_func_t		*vdev_op_open;
+	vdev_close_func_t		*vdev_op_close;
+	vdev_asize_func_t		*vdev_op_asize;
+	vdev_io_start_func_t		*vdev_op_io_start;
+	vdev_io_done_func_t		*vdev_op_io_done;
+	vdev_state_change_func_t	*vdev_op_state_change;
+	vdev_need_resilver_func_t	*vdev_op_need_resilver;
+	vdev_hold_func_t		*vdev_op_hold;
+	vdev_rele_func_t		*vdev_op_rele;
+	vdev_remap_func_t		*vdev_op_remap;
+	/*
+	 * For translating ranges from non-leaf vdevs (e.g. raidz) to leaves.
+	 * Used when initializing vdevs. Isn't used by leaf ops.
+	 */
+	vdev_xlation_func_t		*vdev_op_xlate;
+	char				vdev_op_type[16];
+	boolean_t			vdev_op_leaf;
+} vdev_ops_t;
+
+/*
+ * Virtual device properties
+ */
+struct vdev_cache_entry {
+	struct abd	*ve_abd;
+	uint64_t	ve_offset;
+	clock_t		ve_lastused;
+	avl_node_t	ve_offset_node;
+	avl_node_t	ve_lastused_node;
+	uint32_t	ve_hits;
+	uint16_t	ve_missed_update;
+	zio_t		*ve_fill_io;
+};
+
+struct vdev_cache {
+	avl_tree_t	vc_offset_tree;
+	avl_tree_t	vc_lastused_tree;
+	kmutex_t	vc_lock;
+};
+
+typedef struct vdev_queue_class {
+	uint32_t	vqc_active;
+
+	/*
+	 * Sorted by offset or timestamp, depending on if the queue is
+	 * LBA-ordered vs FIFO.
+	 */
+	avl_tree_t	vqc_queued_tree;
+} vdev_queue_class_t;
+
+struct vdev_queue {
+	vdev_t		*vq_vdev;
+	vdev_queue_class_t vq_class[ZIO_PRIORITY_NUM_QUEUEABLE];
+	avl_tree_t	vq_active_tree;
+	avl_tree_t	vq_read_offset_tree;
+	avl_tree_t	vq_write_offset_tree;
+	avl_tree_t	vq_trim_offset_tree;
+	uint64_t	vq_last_offset;
+	hrtime_t	vq_io_complete_ts; /* time last i/o completed */
+	hrtime_t	vq_io_delta_ts;
+	zio_t		vq_io_search; /* used as local for stack reduction */
+	kmutex_t	vq_lock;
+};
+
+typedef enum vdev_alloc_bias {
+	VDEV_BIAS_NONE,
+	VDEV_BIAS_LOG,		/* dedicated to ZIL data (SLOG) */
+	VDEV_BIAS_SPECIAL,	/* dedicated to ddt, metadata, and small blks */
+	VDEV_BIAS_DEDUP		/* dedicated to dedup metadata */
+} vdev_alloc_bias_t;
+
+
+/*
+ * On-disk indirect vdev state.
+ *
+ * An indirect vdev is described exclusively in the MOS config of a pool.
+ * The config for an indirect vdev includes several fields, which are
+ * accessed in memory by a vdev_indirect_config_t.
+ */
+typedef struct vdev_indirect_config {
+	/*
+	 * Object (in MOS) which contains the indirect mapping. This object
+	 * contains an array of vdev_indirect_mapping_entry_phys_t ordered by
+	 * vimep_src. The bonus buffer for this object is a
+	 * vdev_indirect_mapping_phys_t. This object is allocated when a vdev
+	 * removal is initiated.
+	 *
+	 * Note that this object can be empty if none of the data on the vdev
+	 * has been copied yet.
+	 */
+	uint64_t	vic_mapping_object;
+
+	/*
+	 * Object (in MOS) which contains the birth times for the mapping
+	 * entries. This object contains an array of
+	 * vdev_indirect_birth_entry_phys_t sorted by vibe_offset. The bonus
+	 * buffer for this object is a vdev_indirect_birth_phys_t. This object
+	 * is allocated when a vdev removal is initiated.
+	 *
+	 * Note that this object can be empty if none of the vdev has yet been
+	 * copied.
+	 */
+	uint64_t	vic_births_object;
+
+	/*
+	 * This is the vdev ID which was removed previous to this vdev, or
+	 * UINT64_MAX if there are no previously removed vdevs.
+	 */
+	uint64_t	vic_prev_indirect_vdev;
+} vdev_indirect_config_t;
+
+/*
+ * Virtual device descriptor
+ */
+struct vdev {
+	/*
+	 * Common to all vdev types.
+	 */
+	uint64_t	vdev_id;	/* child number in vdev parent	*/
+	uint64_t	vdev_guid;	/* unique ID for this vdev	*/
+	uint64_t	vdev_guid_sum;	/* self guid + all child guids	*/
+	uint64_t	vdev_orig_guid;	/* orig. guid prior to remove	*/
+	uint64_t	vdev_asize;	/* allocatable device capacity	*/
+	uint64_t	vdev_min_asize;	/* min acceptable asize		*/
+	uint64_t	vdev_max_asize;	/* max acceptable asize		*/
+	uint64_t	vdev_ashift;	/* block alignment shift	*/
+
+	/*
+	 * Logical block alignment shift
+	 *
+	 * The smallest sized/aligned I/O supported by the device.
+	 */
+	uint64_t	vdev_logical_ashift;
+	/*
+	 * Physical block alignment shift
+	 *
+	 * The device supports logical I/Os with vdev_logical_ashift
+	 * size/alignment, but optimum performance will be achieved by
+	 * aligning/sizing requests to vdev_physical_ashift.  Smaller
+	 * requests may be inflated or incur device level read-modify-write
+	 * operations.
+	 *
+	 * May be 0 to indicate no preference (i.e. use vdev_logical_ashift).
+	 */
+	uint64_t	vdev_physical_ashift;
+	uint64_t	vdev_state;	/* see VDEV_STATE_* #defines	*/
+	uint64_t	vdev_prevstate;	/* used when reopening a vdev	*/
+	vdev_ops_t	*vdev_ops;	/* vdev operations		*/
+	spa_t		*vdev_spa;	/* spa for this vdev		*/
+	void		*vdev_tsd;	/* type-specific data		*/
+	vdev_t		*vdev_top;	/* top-level vdev		*/
+	vdev_t		*vdev_parent;	/* parent vdev			*/
+	vdev_t		**vdev_child;	/* array of children		*/
+	uint64_t	vdev_children;	/* number of children		*/
+	vdev_stat_t	vdev_stat;	/* virtual device statistics	*/
+	vdev_stat_ex_t	vdev_stat_ex;	/* extended statistics		*/
+	boolean_t	vdev_expanding;	/* expand the vdev?		*/
+	boolean_t	vdev_reopening;	/* reopen in progress?		*/
+	boolean_t	vdev_nonrot;	/* true if solid state		*/
+	int		vdev_open_error; /* error on last open		*/
+	kthread_t	*vdev_open_thread; /* thread opening children	*/
+	uint64_t	vdev_crtxg;	/* txg when top-level was added */
+
+	/*
+	 * Top-level vdev state.
+	 */
+	uint64_t	vdev_ms_array;	/* metaslab array object	*/
+	uint64_t	vdev_ms_shift;	/* metaslab size shift		*/
+	uint64_t	vdev_ms_count;	/* number of metaslabs		*/
+	metaslab_group_t *vdev_mg;	/* metaslab group		*/
+	metaslab_t	**vdev_ms;	/* metaslab array		*/
+	uint64_t	vdev_pending_fastwrite; /* allocated fastwrites */
+	txg_list_t	vdev_ms_list;	/* per-txg dirty metaslab lists	*/
+	txg_list_t	vdev_dtl_list;	/* per-txg dirty DTL lists	*/
+	txg_node_t	vdev_txg_node;	/* per-txg dirty vdev linkage	*/
+	boolean_t	vdev_remove_wanted; /* async remove wanted?	*/
+	boolean_t	vdev_probe_wanted; /* async probe wanted?	*/
+	list_node_t	vdev_config_dirty_node; /* config dirty list	*/
+	list_node_t	vdev_state_dirty_node; /* state dirty list	*/
+	uint64_t	vdev_deflate_ratio; /* deflation ratio (x512)	*/
+	uint64_t	vdev_islog;	/* is an intent log device	*/
+	uint64_t	vdev_removing;	/* device is being removed?	*/
+	boolean_t	vdev_ishole;	/* is a hole in the namespace	*/
+	uint64_t	vdev_top_zap;
+	vdev_alloc_bias_t vdev_alloc_bias; /* metaslab allocation bias	*/
+
+	/* pool checkpoint related */
+	space_map_t	*vdev_checkpoint_sm;	/* contains reserved blocks */
+
+	/* Initialize related */
+	boolean_t	vdev_initialize_exit_wanted;
+	vdev_initializing_state_t	vdev_initialize_state;
+	list_node_t	vdev_initialize_node;
+	kthread_t	*vdev_initialize_thread;
+	/* Protects vdev_initialize_thread and vdev_initialize_state. */
+	kmutex_t	vdev_initialize_lock;
+	kcondvar_t	vdev_initialize_cv;
+	uint64_t	vdev_initialize_offset[TXG_SIZE];
+	uint64_t	vdev_initialize_last_offset;
+	range_tree_t	*vdev_initialize_tree;	/* valid while initializing */
+	uint64_t	vdev_initialize_bytes_est;
+	uint64_t	vdev_initialize_bytes_done;
+	uint64_t	vdev_initialize_action_time;	/* start and end time */
+
+	/* TRIM related */
+	boolean_t	vdev_trim_exit_wanted;
+	boolean_t	vdev_autotrim_exit_wanted;
+	vdev_trim_state_t	vdev_trim_state;
+	list_node_t	vdev_trim_node;
+	kmutex_t	vdev_autotrim_lock;
+	kcondvar_t	vdev_autotrim_cv;
+	kthread_t	*vdev_autotrim_thread;
+	/* Protects vdev_trim_thread and vdev_trim_state. */
+	kmutex_t	vdev_trim_lock;
+	kcondvar_t	vdev_trim_cv;
+	kthread_t	*vdev_trim_thread;
+	uint64_t	vdev_trim_offset[TXG_SIZE];
+	uint64_t	vdev_trim_last_offset;
+	uint64_t	vdev_trim_bytes_est;
+	uint64_t	vdev_trim_bytes_done;
+	uint64_t	vdev_trim_rate;		/* requested rate (bytes/sec) */
+	uint64_t	vdev_trim_partial;	/* requested partial TRIM */
+	uint64_t	vdev_trim_secure;	/* requested secure TRIM */
+	uint64_t	vdev_trim_action_time;	/* start and end time */
+
+	/* Rebuild related */
+	boolean_t	vdev_rebuilding;
+	boolean_t	vdev_rebuild_exit_wanted;
+	boolean_t	vdev_rebuild_cancel_wanted;
+	boolean_t	vdev_rebuild_reset_wanted;
+	kmutex_t	vdev_rebuild_lock;
+	kcondvar_t	vdev_rebuild_cv;
+	kthread_t	*vdev_rebuild_thread;
+	vdev_rebuild_t	vdev_rebuild_config;
+
+	/* For limiting outstanding I/Os (initialize, TRIM, rebuild) */
+	kmutex_t	vdev_initialize_io_lock;
+	kcondvar_t	vdev_initialize_io_cv;
+	uint64_t	vdev_initialize_inflight;
+	kmutex_t	vdev_trim_io_lock;
+	kcondvar_t	vdev_trim_io_cv;
+	uint64_t	vdev_trim_inflight[3];
+	kmutex_t	vdev_rebuild_io_lock;
+	kcondvar_t	vdev_rebuild_io_cv;
+	uint64_t	vdev_rebuild_inflight;
+
+	/*
+	 * Values stored in the config for an indirect or removing vdev.
+	 */
+	vdev_indirect_config_t	vdev_indirect_config;
+
+	/*
+	 * The vdev_indirect_rwlock protects the vdev_indirect_mapping
+	 * pointer from changing on indirect vdevs (when it is condensed).
+	 * Note that removing (not yet indirect) vdevs have different
+	 * access patterns (the mapping is not accessed from open context,
+	 * e.g. from zio_read) and locking strategy (e.g. svr_lock).
+	 */
+	krwlock_t vdev_indirect_rwlock;
+	vdev_indirect_mapping_t *vdev_indirect_mapping;
+	vdev_indirect_births_t *vdev_indirect_births;
+
+	/*
+	 * In memory data structures used to manage the obsolete sm, for
+	 * indirect or removing vdevs.
+	 *
+	 * The vdev_obsolete_segments is the in-core record of the segments
+	 * that are no longer referenced anywhere in the pool (due to
+	 * being freed or remapped and not referenced by any snapshots).
+	 * During a sync, segments are added to vdev_obsolete_segments
+	 * via vdev_indirect_mark_obsolete(); at the end of each sync
+	 * pass, this is appended to vdev_obsolete_sm via
+	 * vdev_indirect_sync_obsolete().  The vdev_obsolete_lock
+	 * protects against concurrent modifications of vdev_obsolete_segments
+	 * from multiple zio threads.
+	 */
+	kmutex_t	vdev_obsolete_lock;
+	range_tree_t	*vdev_obsolete_segments;
+	space_map_t	*vdev_obsolete_sm;
+
+	/*
+	 * Protects the vdev_scan_io_queue field itself as well as the
+	 * structure's contents (when present).
+	 */
+	kmutex_t			vdev_scan_io_queue_lock;
+	struct dsl_scan_io_queue	*vdev_scan_io_queue;
+
+	/*
+	 * Leaf vdev state.
+	 */
+	range_tree_t	*vdev_dtl[DTL_TYPES]; /* dirty time logs	*/
+	space_map_t	*vdev_dtl_sm;	/* dirty time log space map	*/
+	txg_node_t	vdev_dtl_node;	/* per-txg dirty DTL linkage	*/
+	uint64_t	vdev_dtl_object; /* DTL object			*/
+	uint64_t	vdev_psize;	/* physical device capacity	*/
+	uint64_t	vdev_wholedisk;	/* true if this is a whole disk */
+	uint64_t	vdev_offline;	/* persistent offline state	*/
+	uint64_t	vdev_faulted;	/* persistent faulted state	*/
+	uint64_t	vdev_degraded;	/* persistent degraded state	*/
+	uint64_t	vdev_removed;	/* persistent removed state	*/
+	uint64_t	vdev_resilver_txg; /* persistent resilvering state */
+	uint64_t	vdev_rebuild_txg; /* persistent rebuilding state */
+	uint64_t	vdev_nparity;	/* number of parity devices for raidz */
+	char		*vdev_path;	/* vdev path (if any)		*/
+	char		*vdev_devid;	/* vdev devid (if any)		*/
+	char		*vdev_physpath;	/* vdev device path (if any)	*/
+	char		*vdev_enc_sysfs_path;	/* enclosure sysfs path */
+	char		*vdev_fru;	/* physical FRU location	*/
+	uint64_t	vdev_not_present; /* not present during import	*/
+	uint64_t	vdev_unspare;	/* unspare when resilvering done */
+	boolean_t	vdev_nowritecache; /* true if flushwritecache failed */
+	boolean_t	vdev_has_trim;	/* TRIM is supported		*/
+	boolean_t	vdev_has_securetrim; /* secure TRIM is supported */
+	boolean_t	vdev_checkremove; /* temporary online test	*/
+	boolean_t	vdev_forcefault; /* force online fault		*/
+	boolean_t	vdev_splitting;	/* split or repair in progress  */
+	boolean_t	vdev_delayed_close; /* delayed device close?	*/
+	boolean_t	vdev_tmpoffline; /* device taken offline temporarily? */
+	boolean_t	vdev_detached;	/* device detached?		*/
+	boolean_t	vdev_cant_read;	/* vdev is failing all reads	*/
+	boolean_t	vdev_cant_write; /* vdev is failing all writes	*/
+	boolean_t	vdev_isspare;	/* was a hot spare		*/
+	boolean_t	vdev_isl2cache;	/* was a l2cache device		*/
+	boolean_t	vdev_copy_uberblocks;  /* post expand copy uberblocks */
+	boolean_t	vdev_resilver_deferred;  /* resilver deferred */
+	vdev_queue_t	vdev_queue;	/* I/O deadline schedule queue	*/
+	vdev_cache_t	vdev_cache;	/* physical block cache		*/
+	spa_aux_vdev_t	*vdev_aux;	/* for l2cache and spares vdevs	*/
+	zio_t		*vdev_probe_zio; /* root of current probe	*/
+	vdev_aux_t	vdev_label_aux;	/* on-disk aux state		*/
+	uint64_t	vdev_leaf_zap;
+	hrtime_t	vdev_mmp_pending; /* 0 if write finished	*/
+	uint64_t	vdev_mmp_kstat_id;	/* to find kstat entry */
+	uint64_t	vdev_expansion_time;	/* vdev's last expansion time */
+	list_node_t	vdev_leaf_node;		/* leaf vdev list */
+
+	/*
+	 * For DTrace to work in userland (libzpool) context, these fields must
+	 * remain at the end of the structure.  DTrace will use the kernel's
+	 * CTF definition for 'struct vdev', and since the size of a kmutex_t is
+	 * larger in userland, the offsets for the rest of the fields would be
+	 * incorrect.
+	 */
+	kmutex_t	vdev_dtl_lock;	/* vdev_dtl_{map,resilver}	*/
+	kmutex_t	vdev_stat_lock;	/* vdev_stat			*/
+	kmutex_t	vdev_probe_lock; /* protects vdev_probe_zio	*/
+
+	/*
+	 * We rate limit ZIO delay and ZIO checksum events, since they
+	 * can flood ZED with tons of events when a drive is acting up.
+	 */
+	zfs_ratelimit_t vdev_delay_rl;
+	zfs_ratelimit_t vdev_checksum_rl;
+};
+
+#define	VDEV_RAIDZ_MAXPARITY	3
+
+#define	VDEV_PAD_SIZE		(8 << 10)
+/* 2 padding areas (vl_pad1 and vl_be) to skip */
+#define	VDEV_SKIP_SIZE		VDEV_PAD_SIZE * 2
+#define	VDEV_PHYS_SIZE		(112 << 10)
+#define	VDEV_UBERBLOCK_RING	(128 << 10)
+
+/*
+ * MMP blocks occupy the last MMP_BLOCKS_PER_LABEL slots in the uberblock
+ * ring when MMP is enabled.
+ */
+#define	MMP_BLOCKS_PER_LABEL	1
+
+/* The largest uberblock we support is 8k. */
+#define	MAX_UBERBLOCK_SHIFT (13)
+#define	VDEV_UBERBLOCK_SHIFT(vd)	\
+	MIN(MAX((vd)->vdev_top->vdev_ashift, UBERBLOCK_SHIFT), \
+	    MAX_UBERBLOCK_SHIFT)
+#define	VDEV_UBERBLOCK_COUNT(vd)	\
+	(VDEV_UBERBLOCK_RING >> VDEV_UBERBLOCK_SHIFT(vd))
+#define	VDEV_UBERBLOCK_OFFSET(vd, n)	\
+	offsetof(vdev_label_t, vl_uberblock[(n) << VDEV_UBERBLOCK_SHIFT(vd)])
+#define	VDEV_UBERBLOCK_SIZE(vd)		(1ULL << VDEV_UBERBLOCK_SHIFT(vd))
+
+typedef struct vdev_phys {
+	char		vp_nvlist[VDEV_PHYS_SIZE - sizeof (zio_eck_t)];
+	zio_eck_t	vp_zbt;
+} vdev_phys_t;
+
+typedef enum vbe_vers {
+	/* The bootenv file is stored as ascii text in the envblock */
+	VB_RAW = 0,
+
+	/*
+	 * The bootenv file is converted to an nvlist and then packed into the
+	 * envblock.
+	 */
+	VB_NVLIST = 1
+} vbe_vers_t;
+
+typedef struct vdev_boot_envblock {
+	uint64_t	vbe_version;
+	char		vbe_bootenv[VDEV_PAD_SIZE - sizeof (uint64_t) -
+			sizeof (zio_eck_t)];
+	zio_eck_t	vbe_zbt;
+} vdev_boot_envblock_t;
+
+CTASSERT_GLOBAL(sizeof (vdev_boot_envblock_t) == VDEV_PAD_SIZE);
+
+typedef struct vdev_label {
+	char		vl_pad1[VDEV_PAD_SIZE];			/*  8K */
+	vdev_boot_envblock_t	vl_be;				/*  8K */
+	vdev_phys_t	vl_vdev_phys;				/* 112K	*/
+	char		vl_uberblock[VDEV_UBERBLOCK_RING];	/* 128K	*/
+} vdev_label_t;						/* 256K total */
+
+/*
+ * vdev_dirty() flags
+ */
+#define	VDD_METASLAB	0x01
+#define	VDD_DTL		0x02
+
+/* Offset of embedded boot loader region on each label */
+#define	VDEV_BOOT_OFFSET	(2 * sizeof (vdev_label_t))
+/*
+ * Size of embedded boot loader region on each label.
+ * The total size of the first two labels plus the boot area is 4MB.
+ */
+#define	VDEV_BOOT_SIZE		(7ULL << 19)			/* 3.5M */
+
+/*
+ * Size of label regions at the start and end of each leaf device.
+ */
+#define	VDEV_LABEL_START_SIZE	(2 * sizeof (vdev_label_t) + VDEV_BOOT_SIZE)
+#define	VDEV_LABEL_END_SIZE	(2 * sizeof (vdev_label_t))
+#define	VDEV_LABELS		4
+#define	VDEV_BEST_LABEL		VDEV_LABELS
+
+#define	VDEV_ALLOC_LOAD		0
+#define	VDEV_ALLOC_ADD		1
+#define	VDEV_ALLOC_SPARE	2
+#define	VDEV_ALLOC_L2CACHE	3
+#define	VDEV_ALLOC_ROOTPOOL	4
+#define	VDEV_ALLOC_SPLIT	5
+#define	VDEV_ALLOC_ATTACH	6
+
+/*
+ * Allocate or free a vdev
+ */
+extern vdev_t *vdev_alloc_common(spa_t *spa, uint_t id, uint64_t guid,
+    vdev_ops_t *ops);
+extern int vdev_alloc(spa_t *spa, vdev_t **vdp, nvlist_t *config,
+    vdev_t *parent, uint_t id, int alloctype);
+extern void vdev_free(vdev_t *vd);
+
+/*
+ * Add or remove children and parents
+ */
+extern void vdev_add_child(vdev_t *pvd, vdev_t *cvd);
+extern void vdev_remove_child(vdev_t *pvd, vdev_t *cvd);
+extern void vdev_compact_children(vdev_t *pvd);
+extern vdev_t *vdev_add_parent(vdev_t *cvd, vdev_ops_t *ops);
+extern void vdev_remove_parent(vdev_t *cvd);
+
+/*
+ * vdev sync load and sync
+ */
+extern boolean_t vdev_log_state_valid(vdev_t *vd);
+extern int vdev_load(vdev_t *vd);
+extern int vdev_dtl_load(vdev_t *vd);
+extern void vdev_sync(vdev_t *vd, uint64_t txg);
+extern void vdev_sync_done(vdev_t *vd, uint64_t txg);
+extern void vdev_dirty(vdev_t *vd, int flags, void *arg, uint64_t txg);
+extern void vdev_dirty_leaves(vdev_t *vd, int flags, uint64_t txg);
+
+/*
+ * Available vdev types.
+ */
+extern vdev_ops_t vdev_root_ops;
+extern vdev_ops_t vdev_mirror_ops;
+extern vdev_ops_t vdev_replacing_ops;
+extern vdev_ops_t vdev_raidz_ops;
+extern vdev_ops_t vdev_disk_ops;
+extern vdev_ops_t vdev_file_ops;
+extern vdev_ops_t vdev_missing_ops;
+extern vdev_ops_t vdev_hole_ops;
+extern vdev_ops_t vdev_spare_ops;
+extern vdev_ops_t vdev_indirect_ops;
+
+/*
+ * Common size functions
+ */
+extern void vdev_default_xlate(vdev_t *vd, const range_seg64_t *in,
+    range_seg64_t *out);
+extern uint64_t vdev_default_asize(vdev_t *vd, uint64_t psize);
+extern uint64_t vdev_get_min_asize(vdev_t *vd);
+extern void vdev_set_min_asize(vdev_t *vd);
+
+/*
+ * Global variables
+ */
+extern int zfs_vdev_standard_sm_blksz;
+/* zdb uses this tunable, so it must be declared here to make lint happy. */
+extern int zfs_vdev_cache_size;
+
+/*
+ * Functions from vdev_indirect.c
+ */
+extern void vdev_indirect_sync_obsolete(vdev_t *vd, dmu_tx_t *tx);
+extern boolean_t vdev_indirect_should_condense(vdev_t *vd);
+extern void spa_condense_indirect_start_sync(vdev_t *vd, dmu_tx_t *tx);
+extern int vdev_obsolete_sm_object(vdev_t *vd, uint64_t *sm_obj);
+extern int vdev_obsolete_counts_are_precise(vdev_t *vd, boolean_t *are_precise);
+
+/*
+ * Other miscellaneous functions
+ */
+int vdev_checkpoint_sm_object(vdev_t *vd, uint64_t *sm_obj);
+
+/*
+ * Vdev ashift optimization tunables
+ */
+extern uint64_t zfs_vdev_min_auto_ashift;
+extern uint64_t zfs_vdev_max_auto_ashift;
+int param_set_min_auto_ashift(ZFS_MODULE_PARAM_ARGS);
+int param_set_max_auto_ashift(ZFS_MODULE_PARAM_ARGS);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VDEV_IMPL_H */
diff --git a/include/sys/vdev_indirect_births.h b/include/sys/vdev_indirect_births.h
new file mode 100644
index 0000000000000..987b14485d2b1
--- /dev/null
+++ b/include/sys/vdev_indirect_births.h
@@ -0,0 +1,80 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2015 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_VDEV_INDIRECT_BIRTHS_H
+#define	_SYS_VDEV_INDIRECT_BIRTHS_H
+
+#include <sys/dmu.h>
+#include <sys/spa.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct vdev_indirect_birth_entry_phys {
+	uint64_t vibe_offset;
+	uint64_t vibe_phys_birth_txg;
+} vdev_indirect_birth_entry_phys_t;
+
+typedef struct vdev_indirect_birth_phys {
+	uint64_t	vib_count; /* count of v_i_b_entry_phys_t's */
+} vdev_indirect_birth_phys_t;
+
+typedef struct vdev_indirect_births {
+	uint64_t	vib_object;
+
+	/*
+	 * Each entry indicates that everything up to but not including
+	 * vibe_offset was copied in vibe_phys_birth_txg. Entries are sorted
+	 * by increasing phys_birth, and also by increasing offset. See
+	 * vdev_indirect_births_physbirth for usage.
+	 */
+	vdev_indirect_birth_entry_phys_t *vib_entries;
+
+	objset_t	*vib_objset;
+
+	dmu_buf_t	*vib_dbuf;
+	vdev_indirect_birth_phys_t	*vib_phys;
+} vdev_indirect_births_t;
+
+extern vdev_indirect_births_t *vdev_indirect_births_open(objset_t *os,
+    uint64_t object);
+extern void vdev_indirect_births_close(vdev_indirect_births_t *vib);
+extern boolean_t vdev_indirect_births_is_open(vdev_indirect_births_t *vib);
+extern uint64_t vdev_indirect_births_alloc(objset_t *os, dmu_tx_t *tx);
+extern void vdev_indirect_births_free(objset_t *os, uint64_t object,
+    dmu_tx_t *tx);
+
+extern uint64_t vdev_indirect_births_count(vdev_indirect_births_t *vib);
+extern uint64_t vdev_indirect_births_object(vdev_indirect_births_t *vib);
+
+extern void vdev_indirect_births_add_entry(vdev_indirect_births_t *vib,
+    uint64_t offset, uint64_t txg, dmu_tx_t *tx);
+
+extern uint64_t vdev_indirect_births_physbirth(vdev_indirect_births_t *vib,
+    uint64_t offset, uint64_t asize);
+
+extern uint64_t vdev_indirect_births_last_entry_txg(
+    vdev_indirect_births_t *vib);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VDEV_INDIRECT_BIRTHS_H */
diff --git a/include/sys/vdev_indirect_mapping.h b/include/sys/vdev_indirect_mapping.h
new file mode 100644
index 0000000000000..7e42c10195044
--- /dev/null
+++ b/include/sys/vdev_indirect_mapping.h
@@ -0,0 +1,141 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2015 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_VDEV_INDIRECT_MAPPING_H
+#define	_SYS_VDEV_INDIRECT_MAPPING_H
+
+#include <sys/dmu.h>
+#include <sys/list.h>
+#include <sys/spa.h>
+#include <sys/space_map.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct vdev_indirect_mapping_entry_phys {
+	/*
+	 * Decode with DVA_MAPPING_* macros.
+	 * Contains:
+	 *   the source offset (low 63 bits)
+	 *   the one-bit "mark", used for garbage collection (by zdb)
+	 */
+	uint64_t vimep_src;
+
+	/*
+	 * Note: the DVA's asize is 24 bits, and can thus store ranges
+	 * up to 8GB.
+	 */
+	dva_t	vimep_dst;
+} vdev_indirect_mapping_entry_phys_t;
+
+#define	DVA_MAPPING_GET_SRC_OFFSET(vimep)	\
+	BF64_GET_SB((vimep)->vimep_src, 0, 63, SPA_MINBLOCKSHIFT, 0)
+#define	DVA_MAPPING_SET_SRC_OFFSET(vimep, x)	\
+	BF64_SET_SB((vimep)->vimep_src, 0, 63, SPA_MINBLOCKSHIFT, 0, x)
+
+typedef struct vdev_indirect_mapping_entry {
+	vdev_indirect_mapping_entry_phys_t	vime_mapping;
+	uint32_t				vime_obsolete_count;
+	list_node_t				vime_node;
+} vdev_indirect_mapping_entry_t;
+
+/*
+ * This is stored in the bonus buffer of the mapping object, see comment of
+ * vdev_indirect_config for more details.
+ */
+typedef struct vdev_indirect_mapping_phys {
+	uint64_t	vimp_max_offset;
+	uint64_t	vimp_bytes_mapped;
+	uint64_t	vimp_num_entries; /* number of v_i_m_entry_phys_t's */
+
+	/*
+	 * For each entry in the mapping object, this object contains an
+	 * entry representing the number of bytes of that mapping entry
+	 * that were no longer in use by the pool at the time this indirect
+	 * vdev was last condensed.
+	 */
+	uint64_t	vimp_counts_object;
+} vdev_indirect_mapping_phys_t;
+
+#define	VDEV_INDIRECT_MAPPING_SIZE_V0	(3 * sizeof (uint64_t))
+
+typedef struct vdev_indirect_mapping {
+	uint64_t	vim_object;
+	boolean_t	vim_havecounts;
+
+	/*
+	 * An ordered array of all mapping entries, sorted by source offset.
+	 * Note that vim_entries is needed during a removal (and contains
+	 * mappings that have been synced to disk so far) to handle frees
+	 * from the removing device.
+	 */
+	vdev_indirect_mapping_entry_phys_t *vim_entries;
+
+	objset_t	*vim_objset;
+
+	dmu_buf_t	*vim_dbuf;
+	vdev_indirect_mapping_phys_t	*vim_phys;
+} vdev_indirect_mapping_t;
+
+extern vdev_indirect_mapping_t *vdev_indirect_mapping_open(objset_t *os,
+    uint64_t object);
+extern void vdev_indirect_mapping_close(vdev_indirect_mapping_t *vim);
+extern uint64_t vdev_indirect_mapping_alloc(objset_t *os, dmu_tx_t *tx);
+extern void vdev_indirect_mapping_free(objset_t *os, uint64_t obj,
+    dmu_tx_t *tx);
+
+extern uint64_t vdev_indirect_mapping_num_entries(vdev_indirect_mapping_t *vim);
+extern uint64_t vdev_indirect_mapping_max_offset(vdev_indirect_mapping_t *vim);
+extern uint64_t vdev_indirect_mapping_object(vdev_indirect_mapping_t *vim);
+extern uint64_t vdev_indirect_mapping_bytes_mapped(
+    vdev_indirect_mapping_t *vim);
+extern uint64_t vdev_indirect_mapping_size(vdev_indirect_mapping_t *vim);
+
+/*
+ * Writes the given list of vdev_indirect_mapping_entry_t to the mapping
+ * then updates internal state.
+ */
+extern void vdev_indirect_mapping_add_entries(vdev_indirect_mapping_t *vim,
+    list_t *vime_list, dmu_tx_t *tx);
+
+extern vdev_indirect_mapping_entry_phys_t *
+    vdev_indirect_mapping_entry_for_offset(vdev_indirect_mapping_t *vim,
+    uint64_t offset);
+
+extern vdev_indirect_mapping_entry_phys_t *
+    vdev_indirect_mapping_entry_for_offset_or_next(vdev_indirect_mapping_t *vim,
+    uint64_t offset);
+
+extern uint32_t *vdev_indirect_mapping_load_obsolete_counts(
+    vdev_indirect_mapping_t *vim);
+extern void vdev_indirect_mapping_load_obsolete_spacemap(
+    vdev_indirect_mapping_t *vim,
+    uint32_t *counts, space_map_t *obsolete_space_sm);
+extern void vdev_indirect_mapping_increment_obsolete_count(
+    vdev_indirect_mapping_t *vim,
+    uint64_t offset, uint64_t asize, uint32_t *counts);
+extern void vdev_indirect_mapping_free_obsolete_counts(
+    vdev_indirect_mapping_t *vim, uint32_t *counts);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VDEV_INDIRECT_MAPPING_H */
diff --git a/include/sys/vdev_initialize.h b/include/sys/vdev_initialize.h
new file mode 100644
index 0000000000000..81d39ebebcb26
--- /dev/null
+++ b/include/sys/vdev_initialize.h
@@ -0,0 +1,47 @@
+/*
+ * 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 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_VDEV_INITIALIZE_H
+#define	_SYS_VDEV_INITIALIZE_H
+
+#include <sys/spa.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern void vdev_initialize(vdev_t *vd);
+extern void vdev_initialize_stop(vdev_t *vd,
+    vdev_initializing_state_t tgt_state, list_t *vd_list);
+extern void vdev_initialize_stop_all(vdev_t *vd,
+    vdev_initializing_state_t tgt_state);
+extern void vdev_initialize_stop_wait(spa_t *spa, list_t *vd_list);
+extern void vdev_initialize_restart(vdev_t *vd);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VDEV_INITIALIZE_H */
diff --git a/include/sys/vdev_raidz.h b/include/sys/vdev_raidz.h
new file mode 100644
index 0000000000000..0ce2b5ea1d67b
--- /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/types.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct zio;
+struct raidz_map;
+#if !defined(_KERNEL)
+struct kernel_param {};
+#endif
+
+/*
+ * vdev_raidz interface
+ */
+struct raidz_map *vdev_raidz_map_alloc(struct zio *, uint64_t, uint64_t,
+    uint64_t);
+void vdev_raidz_map_free(struct raidz_map *);
+void vdev_raidz_generate_parity(struct raidz_map *);
+int vdev_raidz_reconstruct(struct raidz_map *, const int *, int);
+
+/*
+ * vdev_raidz_math interface
+ */
+void vdev_raidz_math_init(void);
+void vdev_raidz_math_fini(void);
+const struct raidz_impl_ops *vdev_raidz_math_get_ops(void);
+int vdev_raidz_math_generate(struct raidz_map *);
+int vdev_raidz_math_reconstruct(struct raidz_map *, const int *, const int *,
+    const int);
+int vdev_raidz_impl_set(const char *);
+
+#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 0000000000000..8492daedb6f81
--- /dev/null
+++ b/include/sys/vdev_raidz_impl.h
@@ -0,0 +1,375 @@
+/*
+ * 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
+
+#include <sys/types.h>
+#include <sys/debug.h>
+#include <sys/kstat.h>
+#include <sys/abd.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#define	CODE_P		(0U)
+#define	CODE_Q		(1U)
+#define	CODE_R		(2U)
+
+#define	PARITY_P	(1U)
+#define	PARITY_PQ	(2U)
+#define	PARITY_PQR	(3U)
+
+#define	TARGET_X	(0U)
+#define	TARGET_Y	(1U)
+#define	TARGET_Z	(2U)
+
+/*
+ * Parity generation methods indexes
+ */
+enum raidz_math_gen_op {
+	RAIDZ_GEN_P = 0,
+	RAIDZ_GEN_PQ,
+	RAIDZ_GEN_PQR,
+	RAIDZ_GEN_NUM = 3
+};
+/*
+ * Data reconstruction methods indexes
+ */
+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
+};
+
+extern const char *raidz_gen_name[RAIDZ_GEN_NUM];
+extern const char *raidz_rec_name[RAIDZ_REC_NUM];
+
+/*
+ * Methods used to define raidz implementation
+ *
+ * @raidz_gen_f	Parity generation function
+ *     @par1	pointer to raidz_map
+ * @raidz_rec_f	Data reconstruction function
+ *     @par1	pointer to raidz_map
+ *     @par2	array of reconstruction targets
+ * @will_work_f Function returns TRUE if impl. is supported on the system
+ * @init_impl_f Function is called once on init
+ * @fini_impl_f Function is called once on fini
+ */
+typedef void		(*raidz_gen_f)(void *);
+typedef int		(*raidz_rec_f)(void *, const int *);
+typedef boolean_t	(*will_work_f)(void);
+typedef void		(*init_impl_f)(void);
+typedef void		(*fini_impl_f)(void);
+
+#define	RAIDZ_IMPL_NAME_MAX	(20)
+
+typedef struct raidz_impl_ops {
+	init_impl_f init;
+	fini_impl_f fini;
+	raidz_gen_f gen[RAIDZ_GEN_NUM];	/* Parity generate functions */
+	raidz_rec_f rec[RAIDZ_REC_NUM];	/* Data reconstruction functions */
+	will_work_f is_supported;	/* Support check function */
+	char name[RAIDZ_IMPL_NAME_MAX];	/* Name of the implementation */
+} raidz_impl_ops_t;
+
+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 */
+	abd_t *rc_abd;			/* 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 */
+	abd_t *rm_abd_copy;		/* 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 */
+	const raidz_impl_ops_t *rm_ops;	/* RAIDZ math operations */
+	raidz_col_t rm_col[1];		/* Flexible array of I/O columns */
+} raidz_map_t;
+
+#define	RAIDZ_ORIGINAL_IMPL	(INT_MAX)
+
+extern const raidz_impl_ops_t vdev_raidz_scalar_impl;
+extern boolean_t raidz_will_scalar_work(void);
+
+#if defined(__x86_64) && defined(HAVE_SSE2)	/* only x86_64 for now */
+extern const raidz_impl_ops_t vdev_raidz_sse2_impl;
+#endif
+#if defined(__x86_64) && defined(HAVE_SSSE3)	/* only x86_64 for now */
+extern const raidz_impl_ops_t vdev_raidz_ssse3_impl;
+#endif
+#if defined(__x86_64) && defined(HAVE_AVX2)	/* only x86_64 for now */
+extern const raidz_impl_ops_t vdev_raidz_avx2_impl;
+#endif
+#if defined(__x86_64) && defined(HAVE_AVX512F)	/* only x86_64 for now */
+extern const raidz_impl_ops_t vdev_raidz_avx512f_impl;
+#endif
+#if defined(__x86_64) && defined(HAVE_AVX512BW)	/* only x86_64 for now */
+extern const raidz_impl_ops_t vdev_raidz_avx512bw_impl;
+#endif
+#if defined(__aarch64__)
+extern const raidz_impl_ops_t vdev_raidz_aarch64_neon_impl;
+extern const raidz_impl_ops_t vdev_raidz_aarch64_neonx2_impl;
+#endif
+#if defined(__powerpc__)
+extern const raidz_impl_ops_t vdev_raidz_powerpc_altivec_impl;
+#endif
+
+/*
+ * Commonly used raidz_map helpers
+ *
+ * raidz_parity		Returns parity of the RAIDZ block
+ * raidz_ncols		Returns number of columns the block spans
+ * raidz_nbigcols	Returns number of big columns
+ * raidz_col_p		Returns pointer to a column
+ * raidz_col_size	Returns size of a column
+ * raidz_big_size	Returns size of big columns
+ * raidz_short_size	Returns size of short columns
+ */
+#define	raidz_parity(rm)	((rm)->rm_firstdatacol)
+#define	raidz_ncols(rm)		((rm)->rm_cols)
+#define	raidz_nbigcols(rm)	((rm)->rm_bigcols)
+#define	raidz_col_p(rm, c)	((rm)->rm_col + (c))
+#define	raidz_col_size(rm, c)	((rm)->rm_col[c].rc_size)
+#define	raidz_big_size(rm)	(raidz_col_size(rm, CODE_P))
+#define	raidz_short_size(rm)	(raidz_col_size(rm, raidz_ncols(rm)-1))
+
+/*
+ * Macro defines an RAIDZ parity generation method
+ *
+ * @code	parity the function produce
+ * @impl	name of the implementation
+ */
+#define	_RAIDZ_GEN_WRAP(code, impl)					\
+static void								\
+impl ## _gen_ ## code(void *rmp)					\
+{									\
+	raidz_map_t *rm = (raidz_map_t *)rmp;				\
+	raidz_generate_## code ## _impl(rm);				\
+}
+
+/*
+ * Macro defines an RAIDZ data reconstruction method
+ *
+ * @code	parity the function produce
+ * @impl	name of the implementation
+ */
+#define	_RAIDZ_REC_WRAP(code, impl)					\
+static int								\
+impl ## _rec_ ## code(void *rmp, const int *tgtidx)			\
+{									\
+	raidz_map_t *rm = (raidz_map_t *)rmp;				\
+	return (raidz_reconstruct_## code ## _impl(rm, tgtidx));	\
+}
+
+/*
+ * Define all gen methods for an implementation
+ *
+ * @impl	name of the implementation
+ */
+#define	DEFINE_GEN_METHODS(impl)					\
+	_RAIDZ_GEN_WRAP(p, impl);					\
+	_RAIDZ_GEN_WRAP(pq, impl);					\
+	_RAIDZ_GEN_WRAP(pqr, impl)
+
+/*
+ * Define all rec functions for an implementation
+ *
+ * @impl	name of the implementation
+ */
+#define	DEFINE_REC_METHODS(impl)					\
+	_RAIDZ_REC_WRAP(p, impl);					\
+	_RAIDZ_REC_WRAP(q, impl);					\
+	_RAIDZ_REC_WRAP(r, impl);					\
+	_RAIDZ_REC_WRAP(pq, impl);					\
+	_RAIDZ_REC_WRAP(pr, impl);					\
+	_RAIDZ_REC_WRAP(qr, impl);					\
+	_RAIDZ_REC_WRAP(pqr, impl)
+
+#define	RAIDZ_GEN_METHODS(impl)						\
+{									\
+	[RAIDZ_GEN_P] = & impl ## _gen_p,				\
+	[RAIDZ_GEN_PQ] = & impl ## _gen_pq,				\
+	[RAIDZ_GEN_PQR] = & impl ## _gen_pqr				\
+}
+
+#define	RAIDZ_REC_METHODS(impl)						\
+{									\
+	[RAIDZ_REC_P] = & impl ## _rec_p,				\
+	[RAIDZ_REC_Q] = & impl ## _rec_q,				\
+	[RAIDZ_REC_R] = & impl ## _rec_r,				\
+	[RAIDZ_REC_PQ] = & impl ## _rec_pq,				\
+	[RAIDZ_REC_PR] = & impl ## _rec_pr,				\
+	[RAIDZ_REC_QR] = & impl ## _rec_qr,				\
+	[RAIDZ_REC_PQR] = & impl ## _rec_pqr				\
+}
+
+
+typedef struct raidz_impl_kstat {
+	uint64_t gen[RAIDZ_GEN_NUM];	/* gen method speed B/s */
+	uint64_t rec[RAIDZ_REC_NUM];	/* rec method speed B/s */
+} raidz_impl_kstat_t;
+
+/*
+ * Enumerate various multiplication constants
+ * used in reconstruction methods
+ */
+typedef enum raidz_mul_info {
+	/* Reconstruct Q */
+	MUL_Q_X		= 0,
+	/* Reconstruct R */
+	MUL_R_X		= 0,
+	/* Reconstruct PQ */
+	MUL_PQ_X	= 0,
+	MUL_PQ_Y	= 1,
+	/* Reconstruct PR */
+	MUL_PR_X	= 0,
+	MUL_PR_Y	= 1,
+	/* Reconstruct QR */
+	MUL_QR_XQ	= 0,
+	MUL_QR_X	= 1,
+	MUL_QR_YQ	= 2,
+	MUL_QR_Y	= 3,
+	/* Reconstruct PQR */
+	MUL_PQR_XP	= 0,
+	MUL_PQR_XQ	= 1,
+	MUL_PQR_XR	= 2,
+	MUL_PQR_YU	= 3,
+	MUL_PQR_YP	= 4,
+	MUL_PQR_YQ	= 5,
+
+	MUL_CNT		= 6
+} raidz_mul_info_t;
+
+/*
+ * Powers of 2 in the Galois field.
+ */
+extern const uint8_t vdev_raidz_pow2[256] __attribute__((aligned(256)));
+/* Logs of 2 in the Galois field defined above. */
+extern const uint8_t vdev_raidz_log2[256] __attribute__((aligned(256)));
+
+/*
+ * Multiply a given number by 2 raised to the given power.
+ */
+static inline uint8_t
+vdev_raidz_exp2(const uint8_t a, const unsigned exp)
+{
+	if (a == 0)
+		return (0);
+
+	return (vdev_raidz_pow2[(exp + (unsigned)vdev_raidz_log2[a]) % 255]);
+}
+
+/*
+ * Galois Field operations.
+ *
+ * gf_exp2	- computes 2 raised to the given power
+ * gf_exp2	- computes 4 raised to the given power
+ * gf_mul	- multiplication
+ * gf_div	- division
+ * gf_inv	- multiplicative inverse
+ */
+typedef unsigned gf_t;
+typedef unsigned gf_log_t;
+
+static inline gf_t
+gf_mul(const gf_t a, const gf_t b)
+{
+	gf_log_t logsum;
+
+	if (a == 0 || b == 0)
+		return (0);
+
+	logsum = (gf_log_t)vdev_raidz_log2[a] + (gf_log_t)vdev_raidz_log2[b];
+
+	return ((gf_t)vdev_raidz_pow2[logsum % 255]);
+}
+
+static inline gf_t
+gf_div(const gf_t  a, const gf_t b)
+{
+	gf_log_t logsum;
+
+	ASSERT3U(b, >, 0);
+	if (a == 0)
+		return (0);
+
+	logsum = (gf_log_t)255 + (gf_log_t)vdev_raidz_log2[a] -
+	    (gf_log_t)vdev_raidz_log2[b];
+
+	return ((gf_t)vdev_raidz_pow2[logsum % 255]);
+}
+
+static inline gf_t
+gf_inv(const gf_t a)
+{
+	gf_log_t logsum;
+
+	ASSERT3U(a, >, 0);
+
+	logsum = (gf_log_t)255 - (gf_log_t)vdev_raidz_log2[a];
+
+	return ((gf_t)vdev_raidz_pow2[logsum]);
+}
+
+static inline gf_t
+gf_exp2(gf_log_t exp)
+{
+	return (vdev_raidz_pow2[exp % 255]);
+}
+
+static inline gf_t
+gf_exp4(gf_log_t exp)
+{
+	ASSERT3U(exp, <=, 255);
+	return ((gf_t)vdev_raidz_pow2[(2 * exp) % 255]);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* _VDEV_RAIDZ_H */
diff --git a/include/sys/vdev_rebuild.h b/include/sys/vdev_rebuild.h
new file mode 100644
index 0000000000000..3d4b8cc468363
--- /dev/null
+++ b/include/sys/vdev_rebuild.h
@@ -0,0 +1,97 @@
+/*
+ * 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) 2018, Intel Corporation.
+ * Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
+ */
+
+#ifndef	_SYS_VDEV_REBUILD_H
+#define	_SYS_VDEV_REBUILD_H
+
+#include <sys/spa.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Number of entries in the physical vdev_rebuild_phys structure.  This
+ * state is stored per top-level as VDEV_ZAP_TOP_VDEV_REBUILD_PHYS.
+ */
+#define	REBUILD_PHYS_ENTRIES	12
+
+/*
+ * On-disk rebuild configuration and state.  When adding new fields they
+ * must be added to the end of the structure.
+ */
+typedef struct vdev_rebuild_phys {
+	uint64_t	vrp_rebuild_state;	/* vdev_rebuild_state_t */
+	uint64_t	vrp_last_offset;	/* last rebuilt offset */
+	uint64_t	vrp_min_txg;		/* minimum missing txg */
+	uint64_t	vrp_max_txg;		/* maximum missing txg */
+	uint64_t	vrp_start_time;		/* start time */
+	uint64_t	vrp_end_time;		/* end time */
+	uint64_t	vrp_scan_time_ms;	/* total run time in ms */
+	uint64_t	vrp_bytes_scanned;	/* alloc bytes scanned */
+	uint64_t	vrp_bytes_issued;	/* read bytes rebuilt */
+	uint64_t	vrp_bytes_rebuilt;	/* rebuilt bytes */
+	uint64_t	vrp_bytes_est;		/* total bytes to scan */
+	uint64_t	vrp_errors;		/* errors during rebuild */
+} vdev_rebuild_phys_t;
+
+/*
+ * The vdev_rebuild_t describes the current state and how a top-level vdev
+ * should be rebuilt.  The core elements are the top-vdev, the metaslab being
+ * rebuilt, range tree containing the allocted extents and the on-disk state.
+ */
+typedef struct vdev_rebuild {
+	vdev_t		*vr_top_vdev;		/* top-level vdev to rebuild */
+	metaslab_t	*vr_scan_msp;		/* scanning disabled metaslab */
+	range_tree_t	*vr_scan_tree;		/* scan ranges (in metaslab) */
+
+	/* In-core state and progress */
+	uint64_t	vr_scan_offset[TXG_SIZE];
+	uint64_t	vr_prev_scan_time_ms;	/* any previous scan time */
+
+	/* Per-rebuild pass statistics for calculating bandwidth */
+	uint64_t	vr_pass_start_time;
+	uint64_t	vr_pass_bytes_scanned;
+	uint64_t	vr_pass_bytes_issued;
+
+	/* On-disk state updated by vdev_rebuild_zap_update_sync() */
+	vdev_rebuild_phys_t vr_rebuild_phys;
+} vdev_rebuild_t;
+
+boolean_t vdev_rebuild_active(vdev_t *);
+
+int vdev_rebuild_load(vdev_t *);
+void vdev_rebuild(vdev_t *);
+void vdev_rebuild_stop_wait(vdev_t *);
+void vdev_rebuild_stop_all(spa_t *);
+void vdev_rebuild_restart(spa_t *);
+void vdev_rebuild_clear_sync(void *, dmu_tx_t *);
+int vdev_rebuild_get_stats(vdev_t *, vdev_rebuild_stat_t *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_VDEV_REBUILD_H */
diff --git a/include/sys/vdev_removal.h b/include/sys/vdev_removal.h
new file mode 100644
index 0000000000000..e3bab0658d621
--- /dev/null
+++ b/include/sys/vdev_removal.h
@@ -0,0 +1,96 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2014, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_VDEV_REMOVAL_H
+#define	_SYS_VDEV_REMOVAL_H
+
+#include <sys/spa.h>
+#include <sys/bpobj.h>
+#include <sys/vdev_indirect_mapping.h>
+#include <sys/vdev_indirect_births.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct spa_vdev_removal {
+	uint64_t	svr_vdev_id;
+	uint64_t	svr_max_offset_to_sync[TXG_SIZE];
+	/* Thread performing a vdev removal. */
+	kthread_t	*svr_thread;
+	/* Segments left to copy from the current metaslab. */
+	range_tree_t	*svr_allocd_segs;
+	kmutex_t	svr_lock;
+	kcondvar_t	svr_cv;
+	boolean_t	svr_thread_exit;
+
+	/*
+	 * New mappings to write out each txg.
+	 */
+	list_t		svr_new_segments[TXG_SIZE];
+
+	/*
+	 * Ranges that were freed while a mapping was in flight.  This is
+	 * a subset of the ranges covered by vdev_im_new_segments.
+	 */
+	range_tree_t	*svr_frees[TXG_SIZE];
+
+	/*
+	 * Number of bytes which we have finished our work for
+	 * in each txg.  This could be data copied (which will be part of
+	 * the mappings in vdev_im_new_segments), or data freed before
+	 * we got around to copying it.
+	 */
+	uint64_t	svr_bytes_done[TXG_SIZE];
+
+	/* List of leaf zap objects to be unlinked */
+	nvlist_t	*svr_zaplist;
+} spa_vdev_removal_t;
+
+typedef struct spa_condensing_indirect {
+	/*
+	 * New mappings to write out each txg.
+	 */
+	list_t		sci_new_mapping_entries[TXG_SIZE];
+
+	vdev_indirect_mapping_t *sci_new_mapping;
+} spa_condensing_indirect_t;
+
+extern int spa_remove_init(spa_t *);
+extern void spa_restart_removal(spa_t *);
+extern int spa_condense_init(spa_t *);
+extern void spa_condense_fini(spa_t *);
+extern void spa_start_indirect_condensing_thread(spa_t *);
+extern void spa_vdev_condense_suspend(spa_t *);
+extern int spa_vdev_remove(spa_t *, uint64_t, boolean_t);
+extern void free_from_removing_vdev(vdev_t *, uint64_t, uint64_t);
+extern int spa_removal_get_stats(spa_t *, pool_removal_stat_t *);
+extern void svr_sync(spa_t *, dmu_tx_t *);
+extern void spa_vdev_remove_suspend(spa_t *);
+extern int spa_vdev_remove_cancel(spa_t *);
+extern void spa_vdev_removal_destroy(spa_vdev_removal_t *);
+extern uint64_t spa_remove_max_segment(spa_t *);
+
+extern int vdev_removal_max_span;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VDEV_REMOVAL_H */
diff --git a/include/sys/vdev_trim.h b/include/sys/vdev_trim.h
new file mode 100644
index 0000000000000..16f4be2a41f88
--- /dev/null
+++ b/include/sys/vdev_trim.h
@@ -0,0 +1,54 @@
+/*
+ * 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) 2019 Lawrence Livermore National Security, LLC.
+ */
+
+#ifndef _SYS_VDEV_TRIM_H
+#define	_SYS_VDEV_TRIM_H
+
+#include <sys/spa.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern unsigned int zfs_trim_metaslab_skip;
+
+extern void vdev_trim(vdev_t *vd, uint64_t rate, boolean_t partial,
+    boolean_t secure);
+extern void vdev_trim_stop(vdev_t *vd, vdev_trim_state_t tgt, list_t *vd_list);
+extern void vdev_trim_stop_all(vdev_t *vd, vdev_trim_state_t tgt_state);
+extern void vdev_trim_stop_wait(spa_t *spa, list_t *vd_list);
+extern void vdev_trim_restart(vdev_t *vd);
+extern void vdev_autotrim(spa_t *spa);
+extern void vdev_autotrim_stop_all(spa_t *spa);
+extern void vdev_autotrim_stop_wait(vdev_t *vd);
+extern void vdev_autotrim_restart(spa_t *spa);
+extern int vdev_trim_simple(vdev_t *vd, uint64_t start, uint64_t size);
+extern void vdev_trim_l2arc(spa_t *spa);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VDEV_TRIM_H */
diff --git a/include/sys/xvattr.h b/include/sys/xvattr.h
new file mode 100644
index 0000000000000..0463bdfbc9d8c
--- /dev/null
+++ b/include/sys/xvattr.h
@@ -0,0 +1,338 @@
+/*
+ * 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) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
+ */
+
+/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
+/*	  All Rights Reserved  	*/
+
+/*
+ * University Copyright- Copyright (c) 1982, 1986, 1988
+ * The Regents of the University of California
+ * All Rights Reserved
+ *
+ * University Acknowledgment- Portions of this document are derived from
+ * software developed by the University of California, Berkeley, and its
+ * contributors.
+ */
+
+#ifndef _SYS_XVATTR_H
+#define	_SYS_XVATTR_H
+
+#include <sys/vnode.h>
+#include <sys/strings.h>
+
+#define	AV_SCANSTAMP_SZ	32		/* length of anti-virus scanstamp */
+
+/*
+ * Structure of all optional attributes.
+ */
+typedef struct xoptattr {
+	inode_timespec_t xoa_createtime;	/* Create time of file */
+	uint8_t		xoa_archive;
+	uint8_t		xoa_system;
+	uint8_t		xoa_readonly;
+	uint8_t		xoa_hidden;
+	uint8_t		xoa_nounlink;
+	uint8_t		xoa_immutable;
+	uint8_t		xoa_appendonly;
+	uint8_t		xoa_nodump;
+	uint8_t		xoa_opaque;
+	uint8_t		xoa_av_quarantined;
+	uint8_t		xoa_av_modified;
+	uint8_t		xoa_av_scanstamp[AV_SCANSTAMP_SZ];
+	uint8_t		xoa_reparse;
+	uint64_t	xoa_generation;
+	uint8_t		xoa_offline;
+	uint8_t		xoa_sparse;
+	uint8_t		xoa_projinherit;
+	uint64_t	xoa_projid;
+} xoptattr_t;
+
+/*
+ * The xvattr structure is really a variable length structure that
+ * is made up of:
+ * - The classic vattr_t (xva_vattr)
+ * - a 32 bit quantity (xva_mapsize) that specifies the size of the
+ *   attribute bitmaps in 32 bit words.
+ * - A pointer to the returned attribute bitmap (needed because the
+ *   previous element, the requested attribute bitmap) is variable length.
+ * - The requested attribute bitmap, which is an array of 32 bit words.
+ *   Callers use the XVA_SET_REQ() macro to set the bits corresponding to
+ *   the attributes that are being requested.
+ * - The returned attribute bitmap, which is an array of 32 bit words.
+ *   File systems that support optional attributes use the XVA_SET_RTN()
+ *   macro to set the bits corresponding to the attributes that are being
+ *   returned.
+ * - The xoptattr_t structure which contains the attribute values
+ *
+ * xva_mapsize determines how many words in the attribute bitmaps.
+ * Immediately following the attribute bitmaps is the xoptattr_t.
+ * xva_getxoptattr() is used to get the pointer to the xoptattr_t
+ * section.
+ */
+
+#define	XVA_MAPSIZE	3		/* Size of attr bitmaps */
+#define	XVA_MAGIC	0x78766174	/* Magic # for verification */
+
+/*
+ * The xvattr structure is an extensible structure which permits optional
+ * attributes to be requested/returned.  File systems may or may not support
+ * optional attributes.  They do so at their own discretion but if they do
+ * support optional attributes, they must register the VFSFT_XVATTR feature
+ * so that the optional attributes can be set/retrieved.
+ *
+ * The fields of the xvattr structure are:
+ *
+ * xva_vattr - The first element of an xvattr is a legacy vattr structure
+ * which includes the common attributes.  If AT_XVATTR is set in the va_mask
+ * then the entire structure is treated as an xvattr.  If AT_XVATTR is not
+ * set, then only the xva_vattr structure can be used.
+ *
+ * xva_magic - 0x78766174 (hex for "xvat"). Magic number for verification.
+ *
+ * xva_mapsize - Size of requested and returned attribute bitmaps.
+ *
+ * xva_rtnattrmapp - Pointer to xva_rtnattrmap[].  We need this since the
+ * size of the array before it, xva_reqattrmap[], could change which means
+ * the location of xva_rtnattrmap[] could change.  This will allow unbundled
+ * file systems to find the location of xva_rtnattrmap[] when the sizes change.
+ *
+ * xva_reqattrmap[] - Array of requested attributes.  Attributes are
+ * represented by a specific bit in a specific element of the attribute
+ * map array.  Callers set the bits corresponding to the attributes
+ * that the caller wants to get/set.
+ *
+ * xva_rtnattrmap[] - Array of attributes that the file system was able to
+ * process.  Not all file systems support all optional attributes.  This map
+ * informs the caller which attributes the underlying file system was able
+ * to set/get.  (Same structure as the requested attributes array in terms
+ * of each attribute  corresponding to specific bits and array elements.)
+ *
+ * xva_xoptattrs - Structure containing values of optional attributes.
+ * These values are only valid if the corresponding bits in xva_reqattrmap
+ * are set and the underlying file system supports those attributes.
+ */
+typedef struct xvattr {
+	vattr_t		xva_vattr;	/* Embedded vattr structure */
+	uint32_t	xva_magic;	/* Magic Number */
+	uint32_t	xva_mapsize;	/* Size of attr bitmap (32-bit words) */
+	uint32_t	*xva_rtnattrmapp;	/* Ptr to xva_rtnattrmap[] */
+	uint32_t	xva_reqattrmap[XVA_MAPSIZE];	/* Requested attrs */
+	uint32_t	xva_rtnattrmap[XVA_MAPSIZE];	/* Returned attrs */
+	xoptattr_t	xva_xoptattrs;	/* Optional attributes */
+} xvattr_t;
+
+/*
+ * Attribute bits used in the extensible attribute's (xva's) attribute
+ * bitmaps.  Note that the bitmaps are made up of a variable length number
+ * of 32-bit words.  The convention is to use XAT{n}_{attrname} where "n"
+ * is the element in the bitmap (starting at 1).  This convention is for
+ * the convenience of the maintainer to keep track of which element each
+ * attribute belongs to.
+ *
+ * NOTE THAT CONSUMERS MUST *NOT* USE THE XATn_* DEFINES DIRECTLY.  CONSUMERS
+ * MUST USE THE XAT_* DEFINES.
+ */
+#define	XAT0_INDEX	0LL		/* Index into bitmap for XAT0 attrs */
+#define	XAT0_CREATETIME	0x00000001	/* Create time of file */
+#define	XAT0_ARCHIVE	0x00000002	/* Archive */
+#define	XAT0_SYSTEM	0x00000004	/* System */
+#define	XAT0_READONLY	0x00000008	/* Readonly */
+#define	XAT0_HIDDEN	0x00000010	/* Hidden */
+#define	XAT0_NOUNLINK	0x00000020	/* Nounlink */
+#define	XAT0_IMMUTABLE	0x00000040	/* immutable */
+#define	XAT0_APPENDONLY	0x00000080	/* appendonly */
+#define	XAT0_NODUMP	0x00000100	/* nodump */
+#define	XAT0_OPAQUE	0x00000200	/* opaque */
+#define	XAT0_AV_QUARANTINED	0x00000400	/* anti-virus quarantine */
+#define	XAT0_AV_MODIFIED	0x00000800	/* anti-virus modified */
+#define	XAT0_AV_SCANSTAMP	0x00001000	/* anti-virus scanstamp */
+#define	XAT0_REPARSE	0x00002000	/* FS reparse point */
+#define	XAT0_GEN	0x00004000	/* object generation number */
+#define	XAT0_OFFLINE	0x00008000	/* offline */
+#define	XAT0_SPARSE	0x00010000	/* sparse */
+#define	XAT0_PROJINHERIT	0x00020000	/* Create with parent projid */
+#define	XAT0_PROJID	0x00040000	/* Project ID */
+
+#define	XAT0_ALL_ATTRS	(XAT0_CREATETIME|XAT0_ARCHIVE|XAT0_SYSTEM| \
+    XAT0_READONLY|XAT0_HIDDEN|XAT0_NOUNLINK|XAT0_IMMUTABLE|XAT0_APPENDONLY| \
+    XAT0_NODUMP|XAT0_OPAQUE|XAT0_AV_QUARANTINED|  XAT0_AV_MODIFIED| \
+    XAT0_AV_SCANSTAMP|XAT0_REPARSE|XATO_GEN|XAT0_OFFLINE|XAT0_SPARSE| \
+    XAT0_PROJINHERIT | XAT0_PROJID)
+
+/* Support for XAT_* optional attributes */
+#define	XVA_MASK		0xffffffff	/* Used to mask off 32 bits */
+#define	XVA_SHFT		32		/* Used to shift index */
+
+/*
+ * Used to pry out the index and attribute bits from the XAT_* attributes
+ * defined below.  Note that we're masking things down to 32 bits then
+ * casting to uint32_t.
+ */
+#define	XVA_INDEX(attr)		((uint32_t)(((attr) >> XVA_SHFT) & XVA_MASK))
+#define	XVA_ATTRBIT(attr)	((uint32_t)((attr) & XVA_MASK))
+
+/*
+ * The following defines present a "flat namespace" so that consumers don't
+ * need to keep track of which element belongs to which bitmap entry.
+ *
+ * NOTE THAT THESE MUST NEVER BE OR-ed TOGETHER
+ */
+#define	XAT_CREATETIME		((XAT0_INDEX << XVA_SHFT) | XAT0_CREATETIME)
+#define	XAT_ARCHIVE		((XAT0_INDEX << XVA_SHFT) | XAT0_ARCHIVE)
+#define	XAT_SYSTEM		((XAT0_INDEX << XVA_SHFT) | XAT0_SYSTEM)
+#define	XAT_READONLY		((XAT0_INDEX << XVA_SHFT) | XAT0_READONLY)
+#define	XAT_HIDDEN		((XAT0_INDEX << XVA_SHFT) | XAT0_HIDDEN)
+#define	XAT_NOUNLINK		((XAT0_INDEX << XVA_SHFT) | XAT0_NOUNLINK)
+#define	XAT_IMMUTABLE		((XAT0_INDEX << XVA_SHFT) | XAT0_IMMUTABLE)
+#define	XAT_APPENDONLY		((XAT0_INDEX << XVA_SHFT) | XAT0_APPENDONLY)
+#define	XAT_NODUMP		((XAT0_INDEX << XVA_SHFT) | XAT0_NODUMP)
+#define	XAT_OPAQUE		((XAT0_INDEX << XVA_SHFT) | XAT0_OPAQUE)
+#define	XAT_AV_QUARANTINED	((XAT0_INDEX << XVA_SHFT) | XAT0_AV_QUARANTINED)
+#define	XAT_AV_MODIFIED		((XAT0_INDEX << XVA_SHFT) | XAT0_AV_MODIFIED)
+#define	XAT_AV_SCANSTAMP	((XAT0_INDEX << XVA_SHFT) | XAT0_AV_SCANSTAMP)
+#define	XAT_REPARSE		((XAT0_INDEX << XVA_SHFT) | XAT0_REPARSE)
+#define	XAT_GEN			((XAT0_INDEX << XVA_SHFT) | XAT0_GEN)
+#define	XAT_OFFLINE		((XAT0_INDEX << XVA_SHFT) | XAT0_OFFLINE)
+#define	XAT_SPARSE		((XAT0_INDEX << XVA_SHFT) | XAT0_SPARSE)
+#define	XAT_PROJINHERIT		((XAT0_INDEX << XVA_SHFT) | XAT0_PROJINHERIT)
+#define	XAT_PROJID		((XAT0_INDEX << XVA_SHFT) | XAT0_PROJID)
+
+/*
+ * The returned attribute map array (xva_rtnattrmap[]) is located past the
+ * requested attribute map array (xva_reqattrmap[]).  Its location changes
+ * when the array sizes change.  We use a separate pointer in a known location
+ * (xva_rtnattrmapp) to hold the location of xva_rtnattrmap[].  This is
+ * set in xva_init()
+ */
+#define	XVA_RTNATTRMAP(xvap)	((xvap)->xva_rtnattrmapp)
+
+/*
+ * XVA_SET_REQ() sets an attribute bit in the proper element in the bitmap
+ * of requested attributes (xva_reqattrmap[]).
+ */
+#define	XVA_SET_REQ(xvap, attr)					\
+	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);		\
+	ASSERT((xvap)->xva_magic == XVA_MAGIC);			\
+	(xvap)->xva_reqattrmap[XVA_INDEX(attr)] |= XVA_ATTRBIT(attr)
+/*
+ * XVA_CLR_REQ() clears an attribute bit in the proper element in the bitmap
+ * of requested attributes (xva_reqattrmap[]).
+ */
+#define	XVA_CLR_REQ(xvap, attr)					\
+	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);		\
+	ASSERT((xvap)->xva_magic == XVA_MAGIC);			\
+	(xvap)->xva_reqattrmap[XVA_INDEX(attr)] &= ~XVA_ATTRBIT(attr)
+
+/*
+ * XVA_SET_RTN() sets an attribute bit in the proper element in the bitmap
+ * of returned attributes (xva_rtnattrmap[]).
+ */
+#define	XVA_SET_RTN(xvap, attr)					\
+	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);		\
+	ASSERT((xvap)->xva_magic == XVA_MAGIC);			\
+	(XVA_RTNATTRMAP(xvap))[XVA_INDEX(attr)] |= XVA_ATTRBIT(attr)
+
+/*
+ * XVA_ISSET_REQ() checks the requested attribute bitmap (xva_reqattrmap[])
+ * to see of the corresponding attribute bit is set.  If so, returns non-zero.
+ */
+#define	XVA_ISSET_REQ(xvap, attr)					\
+	((((xvap)->xva_vattr.va_mask & AT_XVATTR) &&			\
+		((xvap)->xva_magic == XVA_MAGIC) &&			\
+		((xvap)->xva_mapsize > XVA_INDEX(attr))) ?		\
+	((xvap)->xva_reqattrmap[XVA_INDEX(attr)] & XVA_ATTRBIT(attr)) :	0)
+
+/*
+ * XVA_ISSET_RTN() checks the returned attribute bitmap (xva_rtnattrmap[])
+ * to see of the corresponding attribute bit is set.  If so, returns non-zero.
+ */
+#define	XVA_ISSET_RTN(xvap, attr)					\
+	((((xvap)->xva_vattr.va_mask & AT_XVATTR) &&			\
+		((xvap)->xva_magic == XVA_MAGIC) &&			\
+		((xvap)->xva_mapsize > XVA_INDEX(attr))) ?		\
+	((XVA_RTNATTRMAP(xvap))[XVA_INDEX(attr)] & XVA_ATTRBIT(attr)) : 0)
+
+/*
+ * Zero out the structure, set the size of the requested/returned bitmaps,
+ * set AT_XVATTR in the embedded vattr_t's va_mask, and set up the pointer
+ * to the returned attributes array.
+ */
+static inline void
+xva_init(xvattr_t *xvap)
+{
+	bzero(xvap, sizeof (xvattr_t));
+	xvap->xva_mapsize = XVA_MAPSIZE;
+	xvap->xva_magic = XVA_MAGIC;
+	xvap->xva_vattr.va_mask = ATTR_XVATTR;
+	xvap->xva_rtnattrmapp = &(xvap->xva_rtnattrmap)[0];
+}
+
+/*
+ * If AT_XVATTR is set, returns a pointer to the embedded xoptattr_t
+ * structure.  Otherwise, returns NULL.
+ */
+static inline xoptattr_t *
+xva_getxoptattr(xvattr_t *xvap)
+{
+	xoptattr_t *xoap = NULL;
+	if (xvap->xva_vattr.va_mask & AT_XVATTR)
+			xoap = &xvap->xva_xoptattrs;
+	return (xoap);
+}
+
+#define	MODEMASK	07777		/* mode bits plus permission bits */
+#define	PERMMASK	00777		/* permission bits */
+
+/*
+ * VOP_ACCESS flags
+ */
+#define	V_ACE_MASK	0x1	/* mask represents  NFSv4 ACE permissions */
+#define	V_APPEND	0x2	/* want to do append only check */
+
+/*
+ * Structure used on VOP_GETSECATTR and VOP_SETSECATTR operations
+ */
+
+typedef struct vsecattr {
+	uint_t		vsa_mask;	/* See below */
+	int		vsa_aclcnt;	/* ACL entry count */
+	void		*vsa_aclentp;	/* pointer to ACL entries */
+	int		vsa_dfaclcnt;	/* default ACL entry count */
+	void		*vsa_dfaclentp;	/* pointer to default ACL entries */
+	size_t		vsa_aclentsz;	/* ACE size in bytes of vsa_aclentp */
+	uint_t		vsa_aclflags;	/* ACE ACL flags */
+} vsecattr_t;
+
+/* vsa_mask values */
+#define	VSA_ACL			0x0001
+#define	VSA_ACLCNT		0x0002
+#define	VSA_DFACL		0x0004
+#define	VSA_DFACLCNT		0x0008
+#define	VSA_ACE			0x0010
+#define	VSA_ACECNT		0x0020
+#define	VSA_ACE_ALLTYPES	0x0040
+#define	VSA_ACE_ACLFLAGS	0x0080	/* get/set ACE ACL flags */
+
+#endif /* _SYS_XVATTR_H */
diff --git a/include/sys/zap.h b/include/sys/zap.h
new file mode 100644
index 0000000000000..b19b4643879c9
--- /dev/null
+++ b/include/sys/zap.h
@@ -0,0 +1,510 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright 2017 Nexenta Systems, Inc.
+ */
+
+#ifndef	_SYS_ZAP_H
+#define	_SYS_ZAP_H
+
+/*
+ * ZAP - ZFS Attribute Processor
+ *
+ * The ZAP is a module which sits on top of the DMU (Data Management
+ * Unit) and implements a higher-level storage primitive using DMU
+ * objects.  Its primary consumer is the ZPL (ZFS Posix Layer).
+ *
+ * A "zapobj" is a DMU object which the ZAP uses to stores attributes.
+ * Users should use only zap routines to access a zapobj - they should
+ * not access the DMU object directly using DMU routines.
+ *
+ * The attributes stored in a zapobj are name-value pairs.  The name is
+ * a zero-terminated string of up to ZAP_MAXNAMELEN bytes (including
+ * terminating NULL).  The value is an array of integers, which may be
+ * 1, 2, 4, or 8 bytes long.  The total space used by the array (number
+ * of integers * integer length) can be up to ZAP_MAXVALUELEN bytes.
+ * Note that an 8-byte integer value can be used to store the location
+ * (object number) of another dmu object (which may be itself a zapobj).
+ * Note that you can use a zero-length attribute to store a single bit
+ * of information - the attribute is present or not.
+ *
+ * The ZAP routines are thread-safe.  However, you must observe the
+ * DMU's restriction that a transaction may not be operated on
+ * concurrently.
+ *
+ * Any of the routines that return an int may return an I/O error (EIO
+ * or ECHECKSUM).
+ *
+ *
+ * Implementation / Performance Notes:
+ *
+ * The ZAP is intended to operate most efficiently on attributes with
+ * short (49 bytes or less) names and single 8-byte values, for which
+ * the microzap will be used.  The ZAP should be efficient enough so
+ * that the user does not need to cache these attributes.
+ *
+ * The ZAP's locking scheme makes its routines thread-safe.  Operations
+ * on different zapobjs will be processed concurrently.  Operations on
+ * the same zapobj which only read data will be processed concurrently.
+ * Operations on the same zapobj which modify data will be processed
+ * concurrently when there are many attributes in the zapobj (because
+ * the ZAP uses per-block locking - more than 128 * (number of cpus)
+ * small attributes will suffice).
+ */
+
+/*
+ * We're using zero-terminated byte strings (ie. ASCII or UTF-8 C
+ * strings) for the names of attributes, rather than a byte string
+ * bounded by an explicit length.  If some day we want to support names
+ * in character sets which have embedded zeros (eg. UTF-16, UTF-32),
+ * we'll have to add routines for using length-bounded strings.
+ */
+
+#include <sys/dmu.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Specifies matching criteria for ZAP lookups.
+ * MT_NORMALIZE		Use ZAP normalization flags, which can include both
+ *			unicode normalization and case-insensitivity.
+ * MT_MATCH_CASE	Do case-sensitive lookups even if MT_NORMALIZE is
+ *			specified and ZAP normalization flags include
+ *			U8_TEXTPREP_TOUPPER.
+ */
+typedef enum matchtype {
+	MT_NORMALIZE = 1 << 0,
+	MT_MATCH_CASE = 1 << 1,
+} matchtype_t;
+
+typedef enum zap_flags {
+	/* Use 64-bit hash value (serialized cursors will always use 64-bits) */
+	ZAP_FLAG_HASH64 = 1 << 0,
+	/* Key is binary, not string (zap_add_uint64() can be used) */
+	ZAP_FLAG_UINT64_KEY = 1 << 1,
+	/*
+	 * First word of key (which must be an array of uint64) is
+	 * already randomly distributed.
+	 */
+	ZAP_FLAG_PRE_HASHED_KEY = 1 << 2,
+} zap_flags_t;
+
+/*
+ * Create a new zapobj with no attributes and return its object number.
+ */
+uint64_t zap_create(objset_t *ds, dmu_object_type_t ot,
+    dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx);
+uint64_t zap_create_dnsize(objset_t *ds, dmu_object_type_t ot,
+    dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx);
+uint64_t zap_create_norm(objset_t *ds, int normflags, dmu_object_type_t ot,
+    dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx);
+uint64_t zap_create_norm_dnsize(objset_t *ds, int normflags,
+    dmu_object_type_t ot, dmu_object_type_t bonustype, int bonuslen,
+    int dnodesize, dmu_tx_t *tx);
+uint64_t zap_create_flags(objset_t *os, int normflags, zap_flags_t flags,
+    dmu_object_type_t ot, int leaf_blockshift, int indirect_blockshift,
+    dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx);
+uint64_t zap_create_flags_dnsize(objset_t *os, int normflags,
+    zap_flags_t flags, dmu_object_type_t ot, int leaf_blockshift,
+    int indirect_blockshift, dmu_object_type_t bonustype, int bonuslen,
+    int dnodesize, dmu_tx_t *tx);
+uint64_t zap_create_hold(objset_t *os, int normflags, zap_flags_t flags,
+    dmu_object_type_t ot, int leaf_blockshift, int indirect_blockshift,
+    dmu_object_type_t bonustype, int bonuslen, int dnodesize,
+    dnode_t **allocated_dnode, void *tag, dmu_tx_t *tx);
+
+uint64_t zap_create_link(objset_t *os, dmu_object_type_t ot,
+    uint64_t parent_obj, const char *name, dmu_tx_t *tx);
+uint64_t zap_create_link_dnsize(objset_t *os, dmu_object_type_t ot,
+    uint64_t parent_obj, const char *name, int dnodesize, dmu_tx_t *tx);
+
+/*
+ * Initialize an already-allocated object.
+ */
+void mzap_create_impl(dnode_t *dn, int normflags, zap_flags_t flags,
+    dmu_tx_t *tx);
+
+/*
+ * Create a new zapobj with no attributes from the given (unallocated)
+ * object number.
+ */
+int zap_create_claim(objset_t *ds, uint64_t obj, dmu_object_type_t ot,
+    dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx);
+int zap_create_claim_dnsize(objset_t *ds, uint64_t obj, dmu_object_type_t ot,
+    dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx);
+int zap_create_claim_norm(objset_t *ds, uint64_t obj,
+    int normflags, dmu_object_type_t ot,
+    dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx);
+int zap_create_claim_norm_dnsize(objset_t *ds, uint64_t obj,
+    int normflags, dmu_object_type_t ot,
+    dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx);
+
+/*
+ * The zapobj passed in must be a valid ZAP object for all of the
+ * following routines.
+ */
+
+/*
+ * Destroy this zapobj and all its attributes.
+ *
+ * Frees the object number using dmu_object_free.
+ */
+int zap_destroy(objset_t *ds, uint64_t zapobj, dmu_tx_t *tx);
+
+/*
+ * Manipulate attributes.
+ *
+ * 'integer_size' is in bytes, and must be 1, 2, 4, or 8.
+ */
+
+/*
+ * Retrieve the contents of the attribute with the given name.
+ *
+ * If the requested attribute does not exist, the call will fail and
+ * return ENOENT.
+ *
+ * If 'integer_size' is smaller than the attribute's integer size, the
+ * call will fail and return EINVAL.
+ *
+ * If 'integer_size' is equal to or larger than the attribute's integer
+ * size, the call will succeed and return 0.
+ *
+ * When converting to a larger integer size, the integers will be treated as
+ * unsigned (ie. no sign-extension will be performed).
+ *
+ * 'num_integers' is the length (in integers) of 'buf'.
+ *
+ * If the attribute is longer than the buffer, as many integers as will
+ * fit will be transferred to 'buf'.  If the entire attribute was not
+ * transferred, the call will return EOVERFLOW.
+ */
+int zap_lookup(objset_t *ds, uint64_t zapobj, const char *name,
+    uint64_t integer_size, uint64_t num_integers, void *buf);
+
+/*
+ * If rn_len is nonzero, realname will be set to the name of the found
+ * entry (which may be different from the requested name if matchtype is
+ * not MT_EXACT).
+ *
+ * If normalization_conflictp is not NULL, it will be set if there is
+ * another name with the same case/unicode normalized form.
+ */
+int zap_lookup_norm(objset_t *ds, uint64_t zapobj, const char *name,
+    uint64_t integer_size, uint64_t num_integers, void *buf,
+    matchtype_t mt, char *realname, int rn_len,
+    boolean_t *normalization_conflictp);
+int zap_lookup_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key,
+    int key_numints, uint64_t integer_size, uint64_t num_integers, void *buf);
+int zap_contains(objset_t *ds, uint64_t zapobj, const char *name);
+int zap_prefetch(objset_t *os, uint64_t zapobj, const char *name);
+int zap_prefetch_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key,
+    int key_numints);
+
+int zap_lookup_by_dnode(dnode_t *dn, const char *name,
+    uint64_t integer_size, uint64_t num_integers, void *buf);
+int zap_lookup_norm_by_dnode(dnode_t *dn, const char *name,
+    uint64_t integer_size, uint64_t num_integers, void *buf,
+    matchtype_t mt, char *realname, int rn_len,
+    boolean_t *ncp);
+
+int zap_count_write_by_dnode(dnode_t *dn, const char *name,
+    int add, zfs_refcount_t *towrite, zfs_refcount_t *tooverwrite);
+
+/*
+ * Create an attribute with the given name and value.
+ *
+ * If an attribute with the given name already exists, the call will
+ * fail and return EEXIST.
+ */
+int zap_add(objset_t *ds, uint64_t zapobj, const char *key,
+    int integer_size, uint64_t num_integers,
+    const void *val, dmu_tx_t *tx);
+int zap_add_by_dnode(dnode_t *dn, const char *key,
+    int integer_size, uint64_t num_integers,
+    const void *val, dmu_tx_t *tx);
+int zap_add_uint64(objset_t *ds, uint64_t zapobj, const uint64_t *key,
+    int key_numints, int integer_size, uint64_t num_integers,
+    const void *val, dmu_tx_t *tx);
+
+/*
+ * Set the attribute with the given name to the given value.  If an
+ * attribute with the given name does not exist, it will be created.  If
+ * an attribute with the given name already exists, the previous value
+ * will be overwritten.  The integer_size may be different from the
+ * existing attribute's integer size, in which case the attribute's
+ * integer size will be updated to the new value.
+ */
+int zap_update(objset_t *ds, uint64_t zapobj, const char *name,
+    int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx);
+int zap_update_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key,
+    int key_numints,
+    int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx);
+
+/*
+ * Get the length (in integers) and the integer size of the specified
+ * attribute.
+ *
+ * If the requested attribute does not exist, the call will fail and
+ * return ENOENT.
+ */
+int zap_length(objset_t *ds, uint64_t zapobj, const char *name,
+    uint64_t *integer_size, uint64_t *num_integers);
+int zap_length_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key,
+    int key_numints, uint64_t *integer_size, uint64_t *num_integers);
+
+/*
+ * Remove the specified attribute.
+ *
+ * If the specified attribute does not exist, the call will fail and
+ * return ENOENT.
+ */
+int zap_remove(objset_t *ds, uint64_t zapobj, const char *name, dmu_tx_t *tx);
+int zap_remove_norm(objset_t *ds, uint64_t zapobj, const char *name,
+    matchtype_t mt, dmu_tx_t *tx);
+int zap_remove_by_dnode(dnode_t *dn, const char *name, dmu_tx_t *tx);
+int zap_remove_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key,
+    int key_numints, dmu_tx_t *tx);
+
+/*
+ * Returns (in *count) the number of attributes in the specified zap
+ * object.
+ */
+int zap_count(objset_t *ds, uint64_t zapobj, uint64_t *count);
+
+/*
+ * Returns (in name) the name of the entry whose (value & mask)
+ * (za_first_integer) is value, or ENOENT if not found.  The string
+ * pointed to by name must be at least 256 bytes long.  If mask==0, the
+ * match must be exact (ie, same as mask=-1ULL).
+ */
+int zap_value_search(objset_t *os, uint64_t zapobj,
+    uint64_t value, uint64_t mask, char *name);
+
+/*
+ * Transfer all the entries from fromobj into intoobj.  Only works on
+ * int_size=8 num_integers=1 values.  Fails if there are any duplicated
+ * entries.
+ */
+int zap_join(objset_t *os, uint64_t fromobj, uint64_t intoobj, dmu_tx_t *tx);
+
+/* Same as zap_join, but set the values to 'value'. */
+int zap_join_key(objset_t *os, uint64_t fromobj, uint64_t intoobj,
+    uint64_t value, dmu_tx_t *tx);
+
+/* Same as zap_join, but add together any duplicated entries. */
+int zap_join_increment(objset_t *os, uint64_t fromobj, uint64_t intoobj,
+    dmu_tx_t *tx);
+
+/*
+ * Manipulate entries where the name + value are the "same" (the name is
+ * a stringified version of the value).
+ */
+int zap_add_int(objset_t *os, uint64_t obj, uint64_t value, dmu_tx_t *tx);
+int zap_remove_int(objset_t *os, uint64_t obj, uint64_t value, dmu_tx_t *tx);
+int zap_lookup_int(objset_t *os, uint64_t obj, uint64_t value);
+int zap_increment_int(objset_t *os, uint64_t obj, uint64_t key, int64_t delta,
+    dmu_tx_t *tx);
+
+/* Here the key is an int and the value is a different int. */
+int zap_add_int_key(objset_t *os, uint64_t obj,
+    uint64_t key, uint64_t value, dmu_tx_t *tx);
+int zap_update_int_key(objset_t *os, uint64_t obj,
+    uint64_t key, uint64_t value, dmu_tx_t *tx);
+int zap_lookup_int_key(objset_t *os, uint64_t obj,
+    uint64_t key, uint64_t *valuep);
+
+int zap_increment(objset_t *os, uint64_t obj, const char *name, int64_t delta,
+    dmu_tx_t *tx);
+
+struct zap;
+struct zap_leaf;
+typedef struct zap_cursor {
+	/* This structure is opaque! */
+	objset_t *zc_objset;
+	struct zap *zc_zap;
+	struct zap_leaf *zc_leaf;
+	uint64_t zc_zapobj;
+	uint64_t zc_serialized;
+	uint64_t zc_hash;
+	uint32_t zc_cd;
+	boolean_t zc_prefetch;
+} zap_cursor_t;
+
+typedef struct {
+	int za_integer_length;
+	/*
+	 * za_normalization_conflict will be set if there are additional
+	 * entries with this normalized form (eg, "foo" and "Foo").
+	 */
+	boolean_t za_normalization_conflict;
+	uint64_t za_num_integers;
+	uint64_t za_first_integer;	/* no sign extension for <8byte ints */
+	char za_name[ZAP_MAXNAMELEN];
+} zap_attribute_t;
+
+/*
+ * The interface for listing all the attributes of a zapobj can be
+ * thought of as cursor moving down a list of the attributes one by
+ * one.  The cookie returned by the zap_cursor_serialize routine is
+ * persistent across system calls (and across reboot, even).
+ */
+
+/*
+ * Initialize a zap cursor, pointing to the "first" attribute of the
+ * zapobj.  You must _fini the cursor when you are done with it.
+ */
+void zap_cursor_init(zap_cursor_t *zc, objset_t *os, uint64_t zapobj);
+void zap_cursor_init_noprefetch(zap_cursor_t *zc, objset_t *os,
+    uint64_t zapobj);
+void zap_cursor_fini(zap_cursor_t *zc);
+
+/*
+ * Get the attribute currently pointed to by the cursor.  Returns
+ * ENOENT if at the end of the attributes.
+ */
+int zap_cursor_retrieve(zap_cursor_t *zc, zap_attribute_t *za);
+
+/*
+ * Advance the cursor to the next attribute.
+ */
+void zap_cursor_advance(zap_cursor_t *zc);
+
+/*
+ * Get a persistent cookie pointing to the current position of the zap
+ * cursor.  The low 4 bits in the cookie are always zero, and thus can
+ * be used as to differentiate a serialized cookie from a different type
+ * of value.  The cookie will be less than 2^32 as long as there are
+ * fewer than 2^22 (4.2 million) entries in the zap object.
+ */
+uint64_t zap_cursor_serialize(zap_cursor_t *zc);
+
+/*
+ * Initialize a zap cursor pointing to the position recorded by
+ * zap_cursor_serialize (in the "serialized" argument).  You can also
+ * use a "serialized" argument of 0 to start at the beginning of the
+ * zapobj (ie.  zap_cursor_init_serialized(..., 0) is equivalent to
+ * zap_cursor_init(...).)
+ */
+void zap_cursor_init_serialized(zap_cursor_t *zc, objset_t *ds,
+    uint64_t zapobj, uint64_t serialized);
+
+
+#define	ZAP_HISTOGRAM_SIZE 10
+
+typedef struct zap_stats {
+	/*
+	 * Size of the pointer table (in number of entries).
+	 * This is always a power of 2, or zero if it's a microzap.
+	 * In general, it should be considerably greater than zs_num_leafs.
+	 */
+	uint64_t zs_ptrtbl_len;
+
+	uint64_t zs_blocksize;		/* size of zap blocks */
+
+	/*
+	 * The number of blocks used.  Note that some blocks may be
+	 * wasted because old ptrtbl's and large name/value blocks are
+	 * not reused.  (Although their space is reclaimed, we don't
+	 * reuse those offsets in the object.)
+	 */
+	uint64_t zs_num_blocks;
+
+	/*
+	 * Pointer table values from zap_ptrtbl in the zap_phys_t
+	 */
+	uint64_t zs_ptrtbl_nextblk;	  /* next (larger) copy start block */
+	uint64_t zs_ptrtbl_blks_copied;   /* number source blocks copied */
+	uint64_t zs_ptrtbl_zt_blk;	  /* starting block number */
+	uint64_t zs_ptrtbl_zt_numblks;    /* number of blocks */
+	uint64_t zs_ptrtbl_zt_shift;	  /* bits to index it */
+
+	/*
+	 * Values of the other members of the zap_phys_t
+	 */
+	uint64_t zs_block_type;		/* ZBT_HEADER */
+	uint64_t zs_magic;		/* ZAP_MAGIC */
+	uint64_t zs_num_leafs;		/* The number of leaf blocks */
+	uint64_t zs_num_entries;	/* The number of zap entries */
+	uint64_t zs_salt;		/* salt to stir into hash function */
+
+	/*
+	 * Histograms.  For all histograms, the last index
+	 * (ZAP_HISTOGRAM_SIZE-1) includes any values which are greater
+	 * than what can be represented.  For example
+	 * zs_leafs_with_n5_entries[ZAP_HISTOGRAM_SIZE-1] is the number
+	 * of leafs with more than 45 entries.
+	 */
+
+	/*
+	 * zs_leafs_with_n_pointers[n] is the number of leafs with
+	 * 2^n pointers to it.
+	 */
+	uint64_t zs_leafs_with_2n_pointers[ZAP_HISTOGRAM_SIZE];
+
+	/*
+	 * zs_leafs_with_n_entries[n] is the number of leafs with
+	 * [n*5, (n+1)*5) entries.  In the current implementation, there
+	 * can be at most 55 entries in any block, but there may be
+	 * fewer if the name or value is large, or the block is not
+	 * completely full.
+	 */
+	uint64_t zs_blocks_with_n5_entries[ZAP_HISTOGRAM_SIZE];
+
+	/*
+	 * zs_leafs_n_tenths_full[n] is the number of leafs whose
+	 * fullness is in the range [n/10, (n+1)/10).
+	 */
+	uint64_t zs_blocks_n_tenths_full[ZAP_HISTOGRAM_SIZE];
+
+	/*
+	 * zs_entries_using_n_chunks[n] is the number of entries which
+	 * consume n 24-byte chunks.  (Note, large names/values only use
+	 * one chunk, but contribute to zs_num_blocks_large.)
+	 */
+	uint64_t zs_entries_using_n_chunks[ZAP_HISTOGRAM_SIZE];
+
+	/*
+	 * zs_buckets_with_n_entries[n] is the number of buckets (each
+	 * leaf has 64 buckets) with n entries.
+	 * zs_buckets_with_n_entries[1] should be very close to
+	 * zs_num_entries.
+	 */
+	uint64_t zs_buckets_with_n_entries[ZAP_HISTOGRAM_SIZE];
+} zap_stats_t;
+
+/*
+ * Get statistics about a ZAP object.  Note: you need to be aware of the
+ * internal implementation of the ZAP to correctly interpret some of the
+ * statistics.  This interface shouldn't be relied on unless you really
+ * know what you're doing.
+ */
+int zap_get_stats(objset_t *ds, uint64_t zapobj, zap_stats_t *zs);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZAP_H */
diff --git a/include/sys/zap_impl.h b/include/sys/zap_impl.h
new file mode 100644
index 0000000000000..250dde3ce235a
--- /dev/null
+++ b/include/sys/zap_impl.h
@@ -0,0 +1,240 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ * Copyright (c) 2013, 2016 by Delphix. All rights reserved.
+ * Copyright 2017 Nexenta Systems, Inc.
+ */
+
+#ifndef	_SYS_ZAP_IMPL_H
+#define	_SYS_ZAP_IMPL_H
+
+#include <sys/zap.h>
+#include <sys/zfs_context.h>
+#include <sys/avl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern int fzap_default_block_shift;
+
+#define	ZAP_MAGIC 0x2F52AB2ABULL
+
+#define	FZAP_BLOCK_SHIFT(zap)	((zap)->zap_f.zap_block_shift)
+
+#define	MZAP_ENT_LEN		64
+#define	MZAP_NAME_LEN		(MZAP_ENT_LEN - 8 - 4 - 2)
+#define	MZAP_MAX_BLKSZ		SPA_OLD_MAXBLOCKSIZE
+
+#define	ZAP_NEED_CD		(-1U)
+
+typedef struct mzap_ent_phys {
+	uint64_t mze_value;
+	uint32_t mze_cd;
+	uint16_t mze_pad;	/* in case we want to chain them someday */
+	char mze_name[MZAP_NAME_LEN];
+} mzap_ent_phys_t;
+
+typedef struct mzap_phys {
+	uint64_t mz_block_type;	/* ZBT_MICRO */
+	uint64_t mz_salt;
+	uint64_t mz_normflags;
+	uint64_t mz_pad[5];
+	mzap_ent_phys_t mz_chunk[1];
+	/* actually variable size depending on block size */
+} mzap_phys_t;
+
+typedef struct mzap_ent {
+	avl_node_t mze_node;
+	int mze_chunkid;
+	uint64_t mze_hash;
+	uint32_t mze_cd; /* copy from mze_phys->mze_cd */
+} mzap_ent_t;
+
+#define	MZE_PHYS(zap, mze) \
+	(&zap_m_phys(zap)->mz_chunk[(mze)->mze_chunkid])
+
+/*
+ * The (fat) zap is stored in one object. It is an array of
+ * 1<<FZAP_BLOCK_SHIFT byte blocks. The layout looks like one of:
+ *
+ * ptrtbl fits in first block:
+ * 	[zap_phys_t zap_ptrtbl_shift < 6] [zap_leaf_t] ...
+ *
+ * ptrtbl too big for first block:
+ * 	[zap_phys_t zap_ptrtbl_shift >= 6] [zap_leaf_t] [ptrtbl] ...
+ *
+ */
+
+struct dmu_buf;
+struct zap_leaf;
+
+#define	ZBT_LEAF		((1ULL << 63) + 0)
+#define	ZBT_HEADER		((1ULL << 63) + 1)
+#define	ZBT_MICRO		((1ULL << 63) + 3)
+/* any other values are ptrtbl blocks */
+
+/*
+ * the embedded pointer table takes up half a block:
+ * block size / entry size (2^3) / 2
+ */
+#define	ZAP_EMBEDDED_PTRTBL_SHIFT(zap) (FZAP_BLOCK_SHIFT(zap) - 3 - 1)
+
+/*
+ * The embedded pointer table starts half-way through the block.  Since
+ * the pointer table itself is half the block, it starts at (64-bit)
+ * word number (1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)).
+ */
+#define	ZAP_EMBEDDED_PTRTBL_ENT(zap, idx) \
+	((uint64_t *)zap_f_phys(zap)) \
+	[(idx) + (1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap))]
+
+/*
+ * TAKE NOTE:
+ * If zap_phys_t is modified, zap_byteswap() must be modified.
+ */
+typedef struct zap_phys {
+	uint64_t zap_block_type;	/* ZBT_HEADER */
+	uint64_t zap_magic;		/* ZAP_MAGIC */
+
+	struct zap_table_phys {
+		uint64_t zt_blk;	/* starting block number */
+		uint64_t zt_numblks;	/* number of blocks */
+		uint64_t zt_shift;	/* bits to index it */
+		uint64_t zt_nextblk;	/* next (larger) copy start block */
+		uint64_t zt_blks_copied; /* number source blocks copied */
+	} zap_ptrtbl;
+
+	uint64_t zap_freeblk;		/* the next free block */
+	uint64_t zap_num_leafs;		/* number of leafs */
+	uint64_t zap_num_entries;	/* number of entries */
+	uint64_t zap_salt;		/* salt to stir into hash function */
+	uint64_t zap_normflags;		/* flags for u8_textprep_str() */
+	uint64_t zap_flags;		/* zap_flags_t */
+	/*
+	 * This structure is followed by padding, and then the embedded
+	 * pointer table.  The embedded pointer table takes up second
+	 * half of the block.  It is accessed using the
+	 * ZAP_EMBEDDED_PTRTBL_ENT() macro.
+	 */
+} zap_phys_t;
+
+typedef struct zap_table_phys zap_table_phys_t;
+
+typedef struct zap {
+	dmu_buf_user_t zap_dbu;
+	objset_t *zap_objset;
+	uint64_t zap_object;
+	struct dmu_buf *zap_dbuf;
+	krwlock_t zap_rwlock;
+	boolean_t zap_ismicro;
+	int zap_normflags;
+	uint64_t zap_salt;
+	union {
+		struct {
+			/*
+			 * zap_num_entries_mtx protects
+			 * zap_num_entries
+			 */
+			kmutex_t zap_num_entries_mtx;
+			int zap_block_shift;
+		} zap_fat;
+		struct {
+			int16_t zap_num_entries;
+			int16_t zap_num_chunks;
+			int16_t zap_alloc_next;
+			avl_tree_t zap_avl;
+		} zap_micro;
+	} zap_u;
+} zap_t;
+
+static inline zap_phys_t *
+zap_f_phys(zap_t *zap)
+{
+	return (zap->zap_dbuf->db_data);
+}
+
+static inline mzap_phys_t *
+zap_m_phys(zap_t *zap)
+{
+	return (zap->zap_dbuf->db_data);
+}
+
+typedef struct zap_name {
+	zap_t *zn_zap;
+	int zn_key_intlen;
+	const void *zn_key_orig;
+	int zn_key_orig_numints;
+	const void *zn_key_norm;
+	int zn_key_norm_numints;
+	uint64_t zn_hash;
+	matchtype_t zn_matchtype;
+	int zn_normflags;
+	char zn_normbuf[ZAP_MAXNAMELEN];
+} zap_name_t;
+
+#define	zap_f	zap_u.zap_fat
+#define	zap_m	zap_u.zap_micro
+
+boolean_t zap_match(zap_name_t *zn, const char *matchname);
+int zap_lockdir(objset_t *os, uint64_t obj, dmu_tx_t *tx,
+    krw_t lti, boolean_t fatreader, boolean_t adding, void *tag, zap_t **zapp);
+void zap_unlockdir(zap_t *zap, void *tag);
+void zap_evict_sync(void *dbu);
+zap_name_t *zap_name_alloc(zap_t *zap, const char *key, matchtype_t mt);
+void zap_name_free(zap_name_t *zn);
+int zap_hashbits(zap_t *zap);
+uint32_t zap_maxcd(zap_t *zap);
+uint64_t zap_getflags(zap_t *zap);
+
+#define	ZAP_HASH_IDX(hash, n) (((n) == 0) ? 0 : ((hash) >> (64 - (n))))
+
+void fzap_byteswap(void *buf, size_t size);
+int fzap_count(zap_t *zap, uint64_t *count);
+int fzap_lookup(zap_name_t *zn,
+    uint64_t integer_size, uint64_t num_integers, void *buf,
+    char *realname, int rn_len, boolean_t *normalization_conflictp);
+void fzap_prefetch(zap_name_t *zn);
+int fzap_add(zap_name_t *zn, uint64_t integer_size, uint64_t num_integers,
+    const void *val, void *tag, dmu_tx_t *tx);
+int fzap_update(zap_name_t *zn,
+    int integer_size, uint64_t num_integers, const void *val,
+    void *tag, dmu_tx_t *tx);
+int fzap_length(zap_name_t *zn,
+    uint64_t *integer_size, uint64_t *num_integers);
+int fzap_remove(zap_name_t *zn, dmu_tx_t *tx);
+int fzap_cursor_retrieve(zap_t *zap, zap_cursor_t *zc, zap_attribute_t *za);
+void fzap_get_stats(zap_t *zap, zap_stats_t *zs);
+void zap_put_leaf(struct zap_leaf *l);
+
+int fzap_add_cd(zap_name_t *zn,
+    uint64_t integer_size, uint64_t num_integers,
+    const void *val, uint32_t cd, void *tag, dmu_tx_t *tx);
+void fzap_upgrade(zap_t *zap, dmu_tx_t *tx, zap_flags_t flags);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_ZAP_IMPL_H */
diff --git a/include/sys/zap_leaf.h b/include/sys/zap_leaf.h
new file mode 100644
index 0000000000000..a3da1036a5eeb
--- /dev/null
+++ b/include/sys/zap_leaf.h
@@ -0,0 +1,255 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
+ */
+
+#ifndef	_SYS_ZAP_LEAF_H
+#define	_SYS_ZAP_LEAF_H
+
+#include <sys/zap.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct zap;
+struct zap_name;
+struct zap_stats;
+
+#define	ZAP_LEAF_MAGIC 0x2AB1EAF
+
+/* chunk size = 24 bytes */
+#define	ZAP_LEAF_CHUNKSIZE 24
+
+/*
+ * The amount of space available for chunks is:
+ * block size (1<<l->l_bs) - hash entry size (2) * number of hash
+ * entries - header space (2*chunksize)
+ */
+#define	ZAP_LEAF_NUMCHUNKS_BS(bs) \
+	(((1<<(bs)) - 2*ZAP_LEAF_HASH_NUMENTRIES_BS(bs)) / \
+	ZAP_LEAF_CHUNKSIZE - 2)
+
+#define	ZAP_LEAF_NUMCHUNKS(l) (ZAP_LEAF_NUMCHUNKS_BS(((l)->l_bs)))
+
+#define	ZAP_LEAF_NUMCHUNKS_DEF \
+	(ZAP_LEAF_NUMCHUNKS_BS(fzap_default_block_shift))
+
+/*
+ * The amount of space within the chunk available for the array is:
+ * chunk size - space for type (1) - space for next pointer (2)
+ */
+#define	ZAP_LEAF_ARRAY_BYTES (ZAP_LEAF_CHUNKSIZE - 3)
+
+#define	ZAP_LEAF_ARRAY_NCHUNKS(bytes) \
+	(((bytes)+ZAP_LEAF_ARRAY_BYTES-1)/ZAP_LEAF_ARRAY_BYTES)
+
+/*
+ * Low water mark:  when there are only this many chunks free, start
+ * growing the ptrtbl.  Ideally, this should be larger than a
+ * "reasonably-sized" entry.  20 chunks is more than enough for the
+ * largest directory entry (MAXNAMELEN (256) byte name, 8-byte value),
+ * while still being only around 3% for 16k blocks.
+ */
+#define	ZAP_LEAF_LOW_WATER (20)
+
+/*
+ * The leaf hash table has block size / 2^5 (32) number of entries,
+ * which should be more than enough for the maximum number of entries,
+ * which is less than block size / CHUNKSIZE (24) / minimum number of
+ * chunks per entry (3).
+ */
+#define	ZAP_LEAF_HASH_SHIFT_BS(bs) ((bs) - 5)
+#define	ZAP_LEAF_HASH_NUMENTRIES_BS(bs) (1 << ZAP_LEAF_HASH_SHIFT_BS(bs))
+#define	ZAP_LEAF_HASH_SHIFT(l) (ZAP_LEAF_HASH_SHIFT_BS(((l)->l_bs)))
+#define	ZAP_LEAF_HASH_NUMENTRIES(l) (ZAP_LEAF_HASH_NUMENTRIES_BS(((l)->l_bs)))
+
+/*
+ * The chunks start immediately after the hash table.  The end of the
+ * hash table is at l_hash + HASH_NUMENTRIES, which we simply cast to a
+ * chunk_t.
+ */
+#define	ZAP_LEAF_CHUNK(l, idx) \
+	((zap_leaf_chunk_t *) \
+	(zap_leaf_phys(l)->l_hash + ZAP_LEAF_HASH_NUMENTRIES(l)))[idx]
+#define	ZAP_LEAF_ENTRY(l, idx) (&ZAP_LEAF_CHUNK(l, idx).l_entry)
+
+typedef enum zap_chunk_type {
+	ZAP_CHUNK_FREE = 253,
+	ZAP_CHUNK_ENTRY = 252,
+	ZAP_CHUNK_ARRAY = 251,
+	ZAP_CHUNK_TYPE_MAX = 250
+} zap_chunk_type_t;
+
+#define	ZLF_ENTRIES_CDSORTED (1<<0)
+
+/*
+ * TAKE NOTE:
+ * If zap_leaf_phys_t is modified, zap_leaf_byteswap() must be modified.
+ */
+typedef struct zap_leaf_phys {
+	struct zap_leaf_header {
+		/* Public to ZAP */
+		uint64_t lh_block_type;		/* ZBT_LEAF */
+		uint64_t lh_pad1;
+		uint64_t lh_prefix;		/* hash prefix of this leaf */
+		uint32_t lh_magic;		/* ZAP_LEAF_MAGIC */
+		uint16_t lh_nfree;		/* number free chunks */
+		uint16_t lh_nentries;		/* number of entries */
+		uint16_t lh_prefix_len;		/* num bits used to id this */
+
+		/* Private to zap_leaf */
+		uint16_t lh_freelist;		/* chunk head of free list */
+		uint8_t lh_flags;		/* ZLF_* flags */
+		uint8_t lh_pad2[11];
+	} l_hdr; /* 2 24-byte chunks */
+
+	/*
+	 * The header is followed by a hash table with
+	 * ZAP_LEAF_HASH_NUMENTRIES(zap) entries.  The hash table is
+	 * followed by an array of ZAP_LEAF_NUMCHUNKS(zap)
+	 * zap_leaf_chunk structures.  These structures are accessed
+	 * with the ZAP_LEAF_CHUNK() macro.
+	 */
+
+	uint16_t l_hash[1];
+} zap_leaf_phys_t;
+
+typedef union zap_leaf_chunk {
+	struct zap_leaf_entry {
+		uint8_t le_type; 		/* always ZAP_CHUNK_ENTRY */
+		uint8_t le_value_intlen;	/* size of value's ints */
+		uint16_t le_next;		/* next entry in hash chain */
+		uint16_t le_name_chunk;		/* first chunk of the name */
+		uint16_t le_name_numints;	/* ints in name (incl null) */
+		uint16_t le_value_chunk;	/* first chunk of the value */
+		uint16_t le_value_numints;	/* value length in ints */
+		uint32_t le_cd;			/* collision differentiator */
+		uint64_t le_hash;		/* hash value of the name */
+	} l_entry;
+	struct zap_leaf_array {
+		uint8_t la_type;		/* always ZAP_CHUNK_ARRAY */
+		uint8_t la_array[ZAP_LEAF_ARRAY_BYTES];
+		uint16_t la_next;		/* next blk or CHAIN_END */
+	} l_array;
+	struct zap_leaf_free {
+		uint8_t lf_type;		/* always ZAP_CHUNK_FREE */
+		uint8_t lf_pad[ZAP_LEAF_ARRAY_BYTES];
+		uint16_t lf_next;	/* next in free list, or CHAIN_END */
+	} l_free;
+} zap_leaf_chunk_t;
+
+typedef struct zap_leaf {
+	dmu_buf_user_t l_dbu;
+	krwlock_t l_rwlock;
+	uint64_t l_blkid;		/* 1<<ZAP_BLOCK_SHIFT byte block off */
+	int l_bs;			/* block size shift */
+	dmu_buf_t *l_dbuf;
+} zap_leaf_t;
+
+static inline zap_leaf_phys_t *
+zap_leaf_phys(zap_leaf_t *l)
+{
+	return (l->l_dbuf->db_data);
+}
+
+typedef struct zap_entry_handle {
+	/* Set by zap_leaf and public to ZAP */
+	uint64_t zeh_num_integers;
+	uint64_t zeh_hash;
+	uint32_t zeh_cd;
+	uint8_t zeh_integer_size;
+
+	/* Private to zap_leaf */
+	uint16_t zeh_fakechunk;
+	uint16_t *zeh_chunkp;
+	zap_leaf_t *zeh_leaf;
+} zap_entry_handle_t;
+
+/*
+ * Return a handle to the named entry, or ENOENT if not found.  The hash
+ * value must equal zap_hash(name).
+ */
+extern int zap_leaf_lookup(zap_leaf_t *l,
+    struct zap_name *zn, zap_entry_handle_t *zeh);
+
+/*
+ * Return a handle to the entry with this hash+cd, or the entry with the
+ * next closest hash+cd.
+ */
+extern int zap_leaf_lookup_closest(zap_leaf_t *l,
+    uint64_t hash, uint32_t cd, zap_entry_handle_t *zeh);
+
+/*
+ * Read the first num_integers in the attribute.  Integer size
+ * conversion will be done without sign extension.  Return EINVAL if
+ * integer_size is too small.  Return EOVERFLOW if there are more than
+ * num_integers in the attribute.
+ */
+extern int zap_entry_read(const zap_entry_handle_t *zeh,
+    uint8_t integer_size, uint64_t num_integers, void *buf);
+
+extern int zap_entry_read_name(struct zap *zap, const zap_entry_handle_t *zeh,
+    uint16_t buflen, char *buf);
+
+/*
+ * Replace the value of an existing entry.
+ *
+ * May fail if it runs out of space (ENOSPC).
+ */
+extern int zap_entry_update(zap_entry_handle_t *zeh,
+    uint8_t integer_size, uint64_t num_integers, const void *buf);
+
+/*
+ * Remove an entry.
+ */
+extern void zap_entry_remove(zap_entry_handle_t *zeh);
+
+/*
+ * Create an entry. An equal entry must not exist, and this entry must
+ * belong in this leaf (according to its hash value).  Fills in the
+ * entry handle on success.  Returns 0 on success or ENOSPC on failure.
+ */
+extern int zap_entry_create(zap_leaf_t *l, struct zap_name *zn, uint32_t cd,
+    uint8_t integer_size, uint64_t num_integers, const void *buf,
+    zap_entry_handle_t *zeh);
+
+/* Determine whether there is another entry with the same normalized form. */
+extern boolean_t zap_entry_normalization_conflict(zap_entry_handle_t *zeh,
+    struct zap_name *zn, const char *name, struct zap *zap);
+
+/*
+ * Other stuff.
+ */
+
+extern void zap_leaf_init(zap_leaf_t *l, boolean_t sort);
+extern void zap_leaf_byteswap(zap_leaf_phys_t *buf, int len);
+extern void zap_leaf_split(zap_leaf_t *l, zap_leaf_t *nl, boolean_t sort);
+extern void zap_leaf_stats(struct zap *zap, zap_leaf_t *l,
+    struct zap_stats *zs);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_ZAP_LEAF_H */
diff --git a/include/sys/zcp.h b/include/sys/zcp.h
new file mode 100644
index 0000000000000..d7b1dfaa2ea5b
--- /dev/null
+++ b/include/sys/zcp.h
@@ -0,0 +1,194 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2016, 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_ZCP_H
+#define	_SYS_ZCP_H
+
+#include <sys/dmu_tx.h>
+#include <sys/dsl_pool.h>
+
+#include <sys/lua/lua.h>
+#include <sys/lua/lualib.h>
+#include <sys/lua/lauxlib.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	ZCP_RUN_INFO_KEY "runinfo"
+
+extern unsigned long zfs_lua_max_instrlimit;
+extern unsigned long zfs_lua_max_memlimit;
+
+int zcp_argerror(lua_State *, int, const char *, ...);
+
+int zcp_eval(const char *, const char *, boolean_t, uint64_t, uint64_t,
+    nvpair_t *, nvlist_t *);
+
+int zcp_load_list_lib(lua_State *);
+
+int zcp_load_synctask_lib(lua_State *, boolean_t);
+
+typedef void (zcp_cleanup_t)(void *);
+typedef struct zcp_cleanup_handler {
+	zcp_cleanup_t *zch_cleanup_func;
+	void *zch_cleanup_arg;
+	list_node_t zch_node;
+} zcp_cleanup_handler_t;
+
+typedef struct zcp_alloc_arg {
+	boolean_t	aa_must_succeed;
+	int64_t		aa_alloc_remaining;
+	int64_t		aa_alloc_limit;
+} zcp_alloc_arg_t;
+
+typedef struct zcp_run_info {
+	dsl_pool_t	*zri_pool;
+
+	/*
+	 * An estimate of the total amount of space consumed by all
+	 * synctasks we have successfully performed so far in this
+	 * channel program. Used to generate ENOSPC errors for syncfuncs.
+	 */
+	int		zri_space_used;
+
+	/*
+	 * The credentials of the thread which originally invoked the channel
+	 * program. Since channel programs are always invoked from the synctask
+	 * thread they should always do permissions checks against this cred
+	 * rather than the 'current' thread's.
+	 */
+	cred_t		*zri_cred;
+	proc_t		*zri_proc;
+
+	/*
+	 * The tx in which this channel program is running.
+	 */
+	dmu_tx_t	*zri_tx;
+
+	/*
+	 * The maximum number of Lua instructions the channel program is allowed
+	 * to execute. If it takes longer than this it will time out. A value
+	 * of 0 indicates no instruction limit.
+	 */
+	uint64_t	zri_maxinstrs;
+
+	/*
+	 * The number of Lua instructions the channel program has executed.
+	 */
+	uint64_t	zri_curinstrs;
+
+	/*
+	 * Boolean indicating whether or not the channel program exited
+	 * because it timed out.
+	 */
+	boolean_t	zri_timed_out;
+
+	/*
+	 * Channel program was canceled by user
+	 */
+	boolean_t	zri_canceled;
+
+	/*
+	 * Boolean indicating whether or not we are running in syncing
+	 * context.
+	 */
+	boolean_t	zri_sync;
+
+	/*
+	 * List of currently registered cleanup handlers, which will be
+	 * triggered in the event of a fatal error.
+	 */
+	list_t		zri_cleanup_handlers;
+
+	/*
+	 * The Lua state context of our channel program.
+	 */
+	lua_State	*zri_state;
+
+	/*
+	 * Lua memory allocator arguments.
+	 */
+	zcp_alloc_arg_t	*zri_allocargs;
+
+	/*
+	 * Contains output values from zcp script or error string.
+	 */
+	nvlist_t	*zri_outnvl;
+
+	/*
+	 * The keys of this nvlist are datasets which may be zvols and may need
+	 * to have device minor nodes created.  This information is passed from
+	 * syncing context (where the zvol is created) to open context (where we
+	 * create the minor nodes).
+	 */
+	nvlist_t	*zri_new_zvols;
+
+	/*
+	 * The errno number returned to caller of zcp_eval().
+	 */
+	int		zri_result;
+} zcp_run_info_t;
+
+zcp_run_info_t *zcp_run_info(lua_State *);
+zcp_cleanup_handler_t *zcp_register_cleanup(lua_State *, zcp_cleanup_t, void *);
+void zcp_deregister_cleanup(lua_State *, zcp_cleanup_handler_t *);
+void zcp_cleanup(lua_State *);
+
+/*
+ * Argument parsing routines for channel program callback functions.
+ */
+typedef struct zcp_arg {
+	/*
+	 * The name of this argument. For keyword arguments this is the name
+	 * functions will use to set the argument. For positional arguments
+	 * the name has no programmatic meaning, but will appear in error
+	 * messages and help output.
+	 */
+	const char *za_name;
+
+	/*
+	 * The Lua type this argument should have (e.g. LUA_TSTRING,
+	 * LUA_TBOOLEAN) see the lua_type() function documentation for a
+	 * complete list. Calling a function with an argument that does
+	 * not match the expected type will result in the program terminating.
+	 */
+	const int za_lua_type;
+} zcp_arg_t;
+
+void zcp_parse_args(lua_State *, const char *, const zcp_arg_t *,
+    const zcp_arg_t *);
+int zcp_nvlist_to_lua(lua_State *, nvlist_t *, char *, int);
+int zcp_dataset_hold_error(lua_State *, dsl_pool_t *, const char *, int);
+struct dsl_dataset *zcp_dataset_hold(lua_State *, dsl_pool_t *,
+    const char *, void *);
+
+typedef int (zcp_lib_func_t)(lua_State *);
+typedef struct zcp_lib_info {
+	const char *name;
+	zcp_lib_func_t *func;
+	const zcp_arg_t pargs[4];
+	const zcp_arg_t kwargs[2];
+} zcp_lib_info_t;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZCP_H */
diff --git a/include/sys/zcp_global.h b/include/sys/zcp_global.h
new file mode 100644
index 0000000000000..0af5708dd3cb9
--- /dev/null
+++ b/include/sys/zcp_global.h
@@ -0,0 +1,35 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2016 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_ZCP_GLOBALS_H
+#define	_SYS_ZCP_GLOBALS_H
+
+#include <sys/lua/lua.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+void zcp_load_globals(lua_State *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZCP_GLOBALS_H */
diff --git a/include/sys/zcp_iter.h b/include/sys/zcp_iter.h
new file mode 100644
index 0000000000000..1d92d0c6d10c0
--- /dev/null
+++ b/include/sys/zcp_iter.h
@@ -0,0 +1,41 @@
+/*
+ * 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 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_ZCP_LIST_H
+#define	_SYS_ZCP_LIST_H
+
+#include <sys/lua/lua.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+void zcp_load_list_funcs(lua_State *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZCP_LIST_H */
diff --git a/include/sys/zcp_prop.h b/include/sys/zcp_prop.h
new file mode 100644
index 0000000000000..97b17619565c5
--- /dev/null
+++ b/include/sys/zcp_prop.h
@@ -0,0 +1,34 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2016 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_ZCP_PROP_H
+#define	_SYS_ZCP_PROP_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+int zcp_load_get_lib(lua_State *state);
+boolean_t prop_valid_for_ds(dsl_dataset_t *ds, zfs_prop_t zfs_prop);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_ZCP_PROP_H */
diff --git a/include/sys/zcp_set.h b/include/sys/zcp_set.h
new file mode 100644
index 0000000000000..b7428d6fc09ed
--- /dev/null
+++ b/include/sys/zcp_set.h
@@ -0,0 +1,44 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2019 Joyent, Inc.
+ */
+
+#ifndef _SYS_ZCP_SET_H
+#define	_SYS_ZCP_SET_H
+
+#include <sys/dmu_tx.h>
+#include <sys/dsl_pool.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct zcp_set_prop_arg {
+	lua_State	*state;
+	const char	*dsname;
+	const char	*prop;
+	const char	*val;
+} zcp_set_prop_arg_t;
+
+int zcp_set_prop_check(void *arg, dmu_tx_t *tx);
+void zcp_set_prop_sync(void *arg, dmu_tx_t *tx);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* _SYS_ZCP_SET_H */
diff --git a/include/sys/zfeature.h b/include/sys/zfeature.h
new file mode 100644
index 0000000000000..5abde149a615f
--- /dev/null
+++ b/include/sys/zfeature.h
@@ -0,0 +1,73 @@
+/*
+ * 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) 2013 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_ZFEATURE_H
+#define	_SYS_ZFEATURE_H
+
+#include <sys/nvpair.h>
+#include <sys/txg.h>
+#include "zfeature_common.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	VALID_FEATURE_FID(fid)	((fid) >= 0 && (fid) < SPA_FEATURES)
+#define	VALID_FEATURE_OR_NONE(fid)	((fid) == SPA_FEATURE_NONE ||	\
+    VALID_FEATURE_FID(fid))
+
+struct spa;
+struct dmu_tx;
+struct objset;
+
+extern void spa_feature_create_zap_objects(struct spa *, struct dmu_tx *);
+extern void spa_feature_enable(struct spa *, spa_feature_t,
+    struct dmu_tx *);
+extern void spa_feature_incr(struct spa *, spa_feature_t, struct dmu_tx *);
+extern void spa_feature_decr(struct spa *, spa_feature_t, struct dmu_tx *);
+extern boolean_t spa_feature_is_enabled(struct spa *, spa_feature_t);
+extern boolean_t spa_feature_is_active(struct spa *, spa_feature_t);
+extern boolean_t spa_feature_enabled_txg(spa_t *spa, spa_feature_t fid,
+    uint64_t *txg);
+extern uint64_t spa_feature_refcount(spa_t *, spa_feature_t, uint64_t);
+extern boolean_t spa_features_check(spa_t *, boolean_t, nvlist_t *, nvlist_t *);
+
+/*
+ * These functions are only exported for zhack and zdb; normal callers should
+ * use the above interfaces.
+ */
+extern int feature_get_refcount(struct spa *, zfeature_info_t *, uint64_t *);
+extern int feature_get_refcount_from_disk(spa_t *spa, zfeature_info_t *feature,
+    uint64_t *res);
+extern void feature_enable_sync(struct spa *, zfeature_info_t *,
+    struct dmu_tx *);
+extern void feature_sync(struct spa *, zfeature_info_t *, uint64_t,
+    struct dmu_tx *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_ZFEATURE_H */
diff --git a/include/sys/zfs_acl.h b/include/sys/zfs_acl.h
new file mode 100644
index 0000000000000..010686a9121b5
--- /dev/null
+++ b/include/sys/zfs_acl.h
@@ -0,0 +1,248 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ */
+
+#ifndef	_SYS_FS_ZFS_ACL_H
+#define	_SYS_FS_ZFS_ACL_H
+
+#ifdef _KERNEL
+#include <sys/isa_defs.h>
+#include <sys/types32.h>
+#include <sys/xvattr.h>
+#endif
+#include <sys/acl.h>
+#include <sys/dmu.h>
+#include <sys/zfs_fuid.h>
+#include <sys/sa.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct znode_phys;
+
+#define	ACE_SLOT_CNT	6
+#define	ZFS_ACL_VERSION_INITIAL 0ULL
+#define	ZFS_ACL_VERSION_FUID	1ULL
+#define	ZFS_ACL_VERSION		ZFS_ACL_VERSION_FUID
+
+/*
+ * ZFS ACLs (Access Control Lists) are stored in various forms.
+ *
+ * Files created with ACL version ZFS_ACL_VERSION_INITIAL
+ * will all be created with fixed length ACEs of type
+ * zfs_oldace_t.
+ *
+ * Files with ACL version ZFS_ACL_VERSION_FUID will be created
+ * with various sized ACEs.  The abstraction entries will utilize
+ * zfs_ace_hdr_t, normal user/group entries will use zfs_ace_t
+ * and some specialized CIFS ACEs will use zfs_object_ace_t.
+ */
+
+/*
+ * All ACEs have a common hdr.  For
+ * owner@, group@, and everyone@ this is all
+ * that's needed.
+ */
+typedef struct zfs_ace_hdr {
+	uint16_t z_type;
+	uint16_t z_flags;
+	uint32_t z_access_mask;
+} zfs_ace_hdr_t;
+
+typedef zfs_ace_hdr_t zfs_ace_abstract_t;
+
+/*
+ * Standard ACE
+ */
+typedef struct zfs_ace {
+	zfs_ace_hdr_t	z_hdr;
+	uint64_t	z_fuid;
+} zfs_ace_t;
+
+/*
+ * The following type only applies to ACE_ACCESS_ALLOWED|DENIED_OBJECT_ACE_TYPE
+ * and will only be set/retrieved in a CIFS context.
+ */
+
+typedef struct zfs_object_ace {
+	zfs_ace_t	z_ace;
+	uint8_t		z_object_type[16]; /* object type */
+	uint8_t		z_inherit_type[16]; /* inherited object type */
+} zfs_object_ace_t;
+
+typedef struct zfs_oldace {
+	uint32_t	z_fuid;		/* "who" */
+	uint32_t	z_access_mask;  /* access mask */
+	uint16_t	z_flags;	/* flags, i.e inheritance */
+	uint16_t	z_type;		/* type of entry allow/deny */
+} zfs_oldace_t;
+
+typedef struct zfs_acl_phys_v0 {
+	uint64_t	z_acl_extern_obj;	/* ext acl pieces */
+	uint32_t	z_acl_count;		/* Number of ACEs */
+	uint16_t	z_acl_version;		/* acl version */
+	uint16_t	z_acl_pad;		/* pad */
+	zfs_oldace_t	z_ace_data[ACE_SLOT_CNT]; /* 6 standard ACEs */
+} zfs_acl_phys_v0_t;
+
+#define	ZFS_ACE_SPACE	(sizeof (zfs_oldace_t) * ACE_SLOT_CNT)
+
+/*
+ * Size of ACL count is always 2 bytes.
+ * Necessary to for dealing with both V0 ACL and V1 ACL layout
+ */
+#define	ZFS_ACL_COUNT_SIZE	(sizeof (uint16_t))
+
+typedef struct zfs_acl_phys {
+	uint64_t	z_acl_extern_obj;	  /* ext acl pieces */
+	uint32_t	z_acl_size;		  /* Number of bytes in ACL */
+	uint16_t	z_acl_version;		  /* acl version */
+	uint16_t	z_acl_count;		  /* ace count */
+	uint8_t	z_ace_data[ZFS_ACE_SPACE]; /* space for embedded ACEs */
+} zfs_acl_phys_t;
+
+typedef struct acl_ops {
+	uint32_t	(*ace_mask_get) (void *acep); /* get  access mask */
+	void 		(*ace_mask_set) (void *acep,
+			    uint32_t mask); /* set access mask */
+	uint16_t	(*ace_flags_get) (void *acep);	/* get flags */
+	void		(*ace_flags_set) (void *acep,
+			    uint16_t flags); /* set flags */
+	uint16_t	(*ace_type_get)(void *acep); /* get type */
+	void		(*ace_type_set)(void *acep,
+			    uint16_t type); /* set type */
+	uint64_t	(*ace_who_get)(void *acep); /* get who/fuid */
+	void		(*ace_who_set)(void *acep,
+			    uint64_t who); /* set who/fuid */
+	size_t		(*ace_size)(void *acep); /* how big is this ace */
+	size_t		(*ace_abstract_size)(void); /* sizeof abstract entry */
+	int		(*ace_mask_off)(void); /* off of access mask in ace */
+	/* ptr to data if any */
+	int		(*ace_data)(void *acep, void **datap);
+} acl_ops_t;
+
+/*
+ * A zfs_acl_t structure is composed of a list of zfs_acl_node_t's.
+ * Each node will have one or more ACEs associated with it.  You will
+ * only have multiple nodes during a chmod operation.   Normally only
+ * one node is required.
+ */
+typedef struct zfs_acl_node {
+	list_node_t	z_next;		/* Next chunk of ACEs */
+	void		*z_acldata;	/* pointer into actual ACE(s) */
+	void		*z_allocdata;	/* pointer to kmem allocated memory */
+	size_t		z_allocsize;	/* Size of blob in bytes */
+	size_t		z_size;		/* length of ACL data */
+	uint64_t	z_ace_count;	/* number of ACEs in this acl node */
+	int		z_ace_idx;	/* ace iterator positioned on */
+} zfs_acl_node_t;
+
+typedef struct zfs_acl {
+	uint64_t	z_acl_count;	/* Number of ACEs */
+	size_t		z_acl_bytes;	/* Number of bytes in ACL */
+	uint_t		z_version;	/* version of ACL */
+	void		*z_next_ace;	/* pointer to next ACE */
+	uint64_t	z_hints;	/* ACL hints (ZFS_INHERIT_ACE ...) */
+	zfs_acl_node_t	*z_curr_node;	/* current node iterator is handling */
+	list_t		z_acl;		/* chunks of ACE data */
+	acl_ops_t	*z_ops;		/* ACL operations */
+} zfs_acl_t;
+
+typedef struct acl_locator_cb {
+	zfs_acl_t *cb_aclp;
+	zfs_acl_node_t *cb_acl_node;
+} zfs_acl_locator_cb_t;
+
+#define	ACL_DATA_ALLOCED	0x1
+#define	ZFS_ACL_SIZE(aclcnt)	(sizeof (ace_t) * (aclcnt))
+
+struct zfs_fuid_info;
+
+typedef struct zfs_acl_ids {
+	uint64_t		z_fuid;		/* file owner fuid */
+	uint64_t		z_fgid;		/* file group owner fuid */
+	uint64_t		z_mode;		/* mode to set on create */
+	zfs_acl_t		*z_aclp;	/* ACL to create with file */
+	struct zfs_fuid_info 	*z_fuidp;	/* for tracking fuids for log */
+} zfs_acl_ids_t;
+
+/*
+ * Property values for acl_mode and acl_inherit.
+ *
+ * acl_mode can take discard, noallow, groupmask and passthrough.
+ * whereas acl_inherit has secure instead of groupmask.
+ */
+
+#define	ZFS_ACL_DISCARD		0
+#define	ZFS_ACL_NOALLOW		1
+#define	ZFS_ACL_GROUPMASK	2
+#define	ZFS_ACL_PASSTHROUGH	3
+#define	ZFS_ACL_RESTRICTED	4
+#define	ZFS_ACL_PASSTHROUGH_X	5
+
+struct znode;
+struct zfsvfs;
+
+#ifdef _KERNEL
+int zfs_acl_ids_create(struct znode *, int, vattr_t *,
+    cred_t *, vsecattr_t *, zfs_acl_ids_t *);
+void zfs_acl_ids_free(zfs_acl_ids_t *);
+boolean_t zfs_acl_ids_overquota(struct zfsvfs *, zfs_acl_ids_t *, uint64_t);
+int zfs_getacl(struct znode *, vsecattr_t *, boolean_t, cred_t *);
+int zfs_setacl(struct znode *, vsecattr_t *, boolean_t, cred_t *);
+void zfs_acl_rele(void *);
+void zfs_oldace_byteswap(ace_t *, int);
+void zfs_ace_byteswap(void *, size_t, boolean_t);
+extern boolean_t zfs_has_access(struct znode *zp, cred_t *cr);
+extern int zfs_zaccess(struct znode *, int, int, boolean_t, cred_t *);
+int zfs_fastaccesschk_execute(struct znode *, cred_t *);
+extern int zfs_zaccess_rwx(struct znode *, mode_t, int, cred_t *);
+extern int zfs_zaccess_unix(struct znode *, mode_t, cred_t *);
+extern int zfs_acl_access(struct znode *, int, cred_t *);
+int zfs_acl_chmod_setattr(struct znode *, zfs_acl_t **, uint64_t);
+int zfs_zaccess_delete(struct znode *, struct znode *, cred_t *);
+int zfs_zaccess_rename(struct znode *, struct znode *,
+    struct znode *, struct znode *, cred_t *cr);
+void zfs_acl_free(zfs_acl_t *);
+int zfs_vsec_2_aclp(struct zfsvfs *, umode_t, vsecattr_t *, cred_t *,
+    struct zfs_fuid_info **, zfs_acl_t **);
+int zfs_aclset_common(struct znode *, zfs_acl_t *, cred_t *, dmu_tx_t *);
+uint64_t zfs_external_acl(struct znode *);
+int zfs_znode_acl_version(struct znode *);
+int zfs_acl_size(struct znode *, int *);
+zfs_acl_t *zfs_acl_alloc(int);
+zfs_acl_node_t *zfs_acl_node_alloc(size_t);
+void zfs_acl_xform(struct znode *, zfs_acl_t *, cred_t *);
+void zfs_acl_data_locator(void **, uint32_t *, uint32_t, boolean_t, void *);
+uint64_t zfs_mode_compute(uint64_t, zfs_acl_t *,
+    uint64_t *, uint64_t, uint64_t);
+int zfs_acl_node_read(struct znode *, boolean_t, zfs_acl_t **, boolean_t);
+int zfs_acl_chown_setattr(struct znode *);
+
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+#endif	/* _SYS_FS_ZFS_ACL_H */
diff --git a/include/sys/zfs_context.h b/include/sys/zfs_context.h
new file mode 100644
index 0000000000000..16df302c8f314
--- /dev/null
+++ b/include/sys/zfs_context.h
@@ -0,0 +1,763 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2012, Joyent, Inc. All rights reserved.
+ */
+
+#ifndef _SYS_ZFS_CONTEXT_H
+#define	_SYS_ZFS_CONTEXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __KERNEL__
+#include <sys/note.h>
+#include <sys/types.h>
+#include <sys/atomic.h>
+#include <sys/sysmacros.h>
+#include <sys/vmsystm.h>
+#include <sys/condvar.h>
+#include <sys/cmn_err.h>
+#include <sys/kmem.h>
+#include <sys/kmem_cache.h>
+#include <sys/vmem.h>
+#include <sys/taskq.h>
+#include <sys/param.h>
+#include <sys/disp.h>
+#include <sys/debug.h>
+#include <sys/random.h>
+#include <sys/strings.h>
+#include <sys/byteorder.h>
+#include <sys/list.h>
+#include <sys/time.h>
+#include <sys/zone.h>
+#include <sys/kstat.h>
+#include <sys/zfs_debug.h>
+#include <sys/sysevent.h>
+#include <sys/sysevent/eventdefs.h>
+#include <sys/zfs_delay.h>
+#include <sys/sunddi.h>
+#include <sys/ctype.h>
+#include <sys/disp.h>
+#include <sys/trace.h>
+#include <sys/procfs_list.h>
+#include <sys/mod.h>
+#include <sys/zfs_context_os.h>
+#else /* _KERNEL */
+
+#define	_SYS_MUTEX_H
+#define	_SYS_RWLOCK_H
+#define	_SYS_CONDVAR_H
+#define	_SYS_VNODE_H
+#define	_SYS_VFS_H
+#define	_SYS_SUNDDI_H
+#define	_SYS_CALLB_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <strings.h>
+#include <pthread.h>
+#include <setjmp.h>
+#include <assert.h>
+#include <umem.h>
+#include <limits.h>
+#include <atomic.h>
+#include <dirent.h>
+#include <time.h>
+#include <ctype.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/note.h>
+#include <sys/types.h>
+#include <sys/cred.h>
+#include <sys/sysmacros.h>
+#include <sys/resource.h>
+#include <sys/byteorder.h>
+#include <sys/list.h>
+#include <sys/mod.h>
+#include <sys/uio.h>
+#include <sys/zfs_debug.h>
+#include <sys/kstat.h>
+#include <sys/u8_textprep.h>
+#include <sys/sysevent.h>
+#include <sys/sysevent/eventdefs.h>
+#include <sys/sunddi.h>
+#include <sys/debug.h>
+#include <sys/utsname.h>
+#include <sys/trace_zfs.h>
+
+#include <sys/zfs_context_os.h>
+
+/*
+ * Stack
+ */
+
+#define	noinline	__attribute__((noinline))
+#define	likely(x)	__builtin_expect((x), 1)
+#define	unlikely(x)	__builtin_expect((x), 0)
+
+/*
+ * Debugging
+ */
+
+/*
+ * Note that we are not using the debugging levels.
+ */
+
+#define	CE_CONT		0	/* continuation		*/
+#define	CE_NOTE		1	/* notice		*/
+#define	CE_WARN		2	/* warning		*/
+#define	CE_PANIC	3	/* panic		*/
+#define	CE_IGNORE	4	/* print nothing	*/
+
+/*
+ * ZFS debugging
+ */
+
+extern void dprintf_setup(int *argc, char **argv);
+
+extern void cmn_err(int, const char *, ...);
+extern void vcmn_err(int, const char *, va_list);
+extern void panic(const char *, ...)  __NORETURN;
+extern void vpanic(const char *, va_list)  __NORETURN;
+
+#define	fm_panic	panic
+
+extern int aok;
+
+/*
+ * DTrace SDT probes have different signatures in userland than they do in
+ * the kernel.  If they're being used in kernel code, re-define them out of
+ * existence for their counterparts in libzpool.
+ *
+ * Here's an example of how to use the set-error probes in userland:
+ * zfs$target:::set-error /arg0 == EBUSY/ {stack();}
+ *
+ * Here's an example of how to use DTRACE_PROBE probes in userland:
+ * If there is a probe declared as follows:
+ * DTRACE_PROBE2(zfs__probe_name, uint64_t, blkid, dnode_t *, dn);
+ * Then you can use it as follows:
+ * zfs$target:::probe2 /copyinstr(arg0) == "zfs__probe_name"/
+ *     {printf("%u %p\n", arg1, arg2);}
+ */
+
+#ifdef DTRACE_PROBE
+#undef	DTRACE_PROBE
+#endif	/* DTRACE_PROBE */
+#define	DTRACE_PROBE(a)
+
+#ifdef DTRACE_PROBE1
+#undef	DTRACE_PROBE1
+#endif	/* DTRACE_PROBE1 */
+#define	DTRACE_PROBE1(a, b, c)
+
+#ifdef DTRACE_PROBE2
+#undef	DTRACE_PROBE2
+#endif	/* DTRACE_PROBE2 */
+#define	DTRACE_PROBE2(a, b, c, d, e)
+
+#ifdef DTRACE_PROBE3
+#undef	DTRACE_PROBE3
+#endif	/* DTRACE_PROBE3 */
+#define	DTRACE_PROBE3(a, b, c, d, e, f, g)
+
+#ifdef DTRACE_PROBE4
+#undef	DTRACE_PROBE4
+#endif	/* DTRACE_PROBE4 */
+#define	DTRACE_PROBE4(a, b, c, d, e, f, g, h, i)
+
+/*
+ * Tunables.
+ */
+typedef struct zfs_kernel_param {
+	const char *name;	/* unused stub */
+} zfs_kernel_param_t;
+
+#define	ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc)
+#define	ZFS_MODULE_PARAM_ARGS void
+#define	ZFS_MODULE_PARAM_CALL(scope_prefix, name_prefix, name, setfunc, \
+	getfunc, perm, desc)
+
+/*
+ * Threads.
+ */
+typedef pthread_t	kthread_t;
+
+#define	TS_RUN		0x00000002
+#define	TS_JOINABLE	0x00000004
+
+#define	curthread	((void *)(uintptr_t)pthread_self())
+#define	kpreempt(x)	yield()
+#define	getcomm()	"unknown"
+
+#define	thread_create_named(name, stk, stksize, func, arg, len, \
+    pp, state, pri)	\
+	zk_thread_create(func, arg, stksize, state)
+#define	thread_create(stk, stksize, func, arg, len, pp, state, pri)	\
+	zk_thread_create(func, arg, stksize, state)
+#define	thread_exit()	pthread_exit(NULL)
+#define	thread_join(t)	pthread_join((pthread_t)(t), NULL)
+
+#define	newproc(f, a, cid, pri, ctp, pid)	(ENOSYS)
+
+/* in libzpool, p0 exists only to have its address taken */
+typedef struct proc {
+	uintptr_t	this_is_never_used_dont_dereference_it;
+} proc_t;
+
+extern struct proc p0;
+#define	curproc		(&p0)
+
+#define	PS_NONE		-1
+
+extern kthread_t *zk_thread_create(void (*func)(void *), void *arg,
+    size_t stksize, int state);
+
+#define	issig(why)	(FALSE)
+#define	ISSIG(thr, why)	(FALSE)
+
+#define	kpreempt_disable()	((void)0)
+#define	kpreempt_enable()	((void)0)
+#define	cond_resched()		sched_yield()
+
+/*
+ * Mutexes
+ */
+typedef struct kmutex {
+	pthread_mutex_t		m_lock;
+	pthread_t		m_owner;
+} kmutex_t;
+
+#define	MUTEX_DEFAULT		0
+#define	MUTEX_NOLOCKDEP		MUTEX_DEFAULT
+#define	MUTEX_HELD(mp)		pthread_equal((mp)->m_owner, pthread_self())
+#define	MUTEX_NOT_HELD(mp)	!MUTEX_HELD(mp)
+
+extern void mutex_init(kmutex_t *mp, char *name, int type, void *cookie);
+extern void mutex_destroy(kmutex_t *mp);
+extern void mutex_enter(kmutex_t *mp);
+extern void mutex_exit(kmutex_t *mp);
+extern int mutex_tryenter(kmutex_t *mp);
+
+#define	NESTED_SINGLE 1
+#define	mutex_enter_nested(mp, class) mutex_enter(mp)
+/*
+ * RW locks
+ */
+typedef struct krwlock {
+	pthread_rwlock_t	rw_lock;
+	pthread_t		rw_owner;
+	uint_t			rw_readers;
+} krwlock_t;
+
+typedef int krw_t;
+
+#define	RW_READER		0
+#define	RW_WRITER		1
+#define	RW_DEFAULT		RW_READER
+#define	RW_NOLOCKDEP		RW_READER
+
+#define	RW_READ_HELD(rw)	((rw)->rw_readers > 0)
+#define	RW_WRITE_HELD(rw)	pthread_equal((rw)->rw_owner, pthread_self())
+#define	RW_LOCK_HELD(rw)	(RW_READ_HELD(rw) || RW_WRITE_HELD(rw))
+
+extern void rw_init(krwlock_t *rwlp, char *name, int type, void *arg);
+extern void rw_destroy(krwlock_t *rwlp);
+extern void rw_enter(krwlock_t *rwlp, krw_t rw);
+extern int rw_tryenter(krwlock_t *rwlp, krw_t rw);
+extern int rw_tryupgrade(krwlock_t *rwlp);
+extern void rw_exit(krwlock_t *rwlp);
+#define	rw_downgrade(rwlp) do { } while (0)
+
+/*
+ * Credentials
+ */
+extern uid_t crgetuid(cred_t *cr);
+extern uid_t crgetruid(cred_t *cr);
+extern gid_t crgetgid(cred_t *cr);
+extern int crgetngroups(cred_t *cr);
+extern gid_t *crgetgroups(cred_t *cr);
+
+/*
+ * Condition variables
+ */
+typedef pthread_cond_t		kcondvar_t;
+
+#define	CV_DEFAULT		0
+#define	CALLOUT_FLAG_ABSOLUTE	0x2
+
+extern void cv_init(kcondvar_t *cv, char *name, int type, void *arg);
+extern void cv_destroy(kcondvar_t *cv);
+extern void cv_wait(kcondvar_t *cv, kmutex_t *mp);
+extern int cv_wait_sig(kcondvar_t *cv, kmutex_t *mp);
+extern int cv_timedwait(kcondvar_t *cv, kmutex_t *mp, clock_t abstime);
+extern int cv_timedwait_hires(kcondvar_t *cvp, kmutex_t *mp, hrtime_t tim,
+    hrtime_t res, int flag);
+extern void cv_signal(kcondvar_t *cv);
+extern void cv_broadcast(kcondvar_t *cv);
+
+#define	cv_timedwait_io(cv, mp, at)		cv_timedwait(cv, mp, at)
+#define	cv_timedwait_sig(cv, mp, at)		cv_timedwait(cv, mp, at)
+#define	cv_wait_io(cv, mp)			cv_wait(cv, mp)
+#define	cv_wait_io_sig(cv, mp)			cv_wait_sig(cv, mp)
+#define	cv_timedwait_sig_hires(cv, mp, t, r, f) \
+	cv_timedwait_hires(cv, mp, t, r, f)
+
+/*
+ * Thread-specific data
+ */
+#define	tsd_get(k) pthread_getspecific(k)
+#define	tsd_set(k, v) pthread_setspecific(k, v)
+#define	tsd_create(kp, d) pthread_key_create((pthread_key_t *)kp, d)
+#define	tsd_destroy(kp) /* nothing */
+#ifdef __FreeBSD__
+typedef off_t loff_t;
+#endif
+
+/*
+ * kstat creation, installation and deletion
+ */
+extern kstat_t *kstat_create(const char *, int,
+    const char *, const char *, uchar_t, ulong_t, uchar_t);
+extern void kstat_install(kstat_t *);
+extern void kstat_delete(kstat_t *);
+extern void kstat_waitq_enter(kstat_io_t *);
+extern void kstat_waitq_exit(kstat_io_t *);
+extern void kstat_runq_enter(kstat_io_t *);
+extern void kstat_runq_exit(kstat_io_t *);
+extern void kstat_waitq_to_runq(kstat_io_t *);
+extern void kstat_runq_back_to_waitq(kstat_io_t *);
+extern void kstat_set_raw_ops(kstat_t *ksp,
+    int (*headers)(char *buf, size_t size),
+    int (*data)(char *buf, size_t size, void *data),
+    void *(*addr)(kstat_t *ksp, loff_t index));
+
+/*
+ * procfs list manipulation
+ */
+
+typedef struct procfs_list {
+	void		*pl_private;
+	kmutex_t	pl_lock;
+	list_t		pl_list;
+	uint64_t	pl_next_id;
+	size_t		pl_node_offset;
+} procfs_list_t;
+
+#ifndef __cplusplus
+struct seq_file { };
+void seq_printf(struct seq_file *m, const char *fmt, ...);
+
+typedef struct procfs_list_node {
+	list_node_t	pln_link;
+	uint64_t	pln_id;
+} procfs_list_node_t;
+
+void procfs_list_install(const char *module,
+    const char *name,
+    mode_t mode,
+    procfs_list_t *procfs_list,
+    int (*show)(struct seq_file *f, void *p),
+    int (*show_header)(struct seq_file *f),
+    int (*clear)(procfs_list_t *procfs_list),
+    size_t procfs_list_node_off);
+void procfs_list_uninstall(procfs_list_t *procfs_list);
+void procfs_list_destroy(procfs_list_t *procfs_list);
+void procfs_list_add(procfs_list_t *procfs_list, void *p);
+#endif
+
+/*
+ * Kernel memory
+ */
+#define	KM_SLEEP		UMEM_NOFAIL
+#define	KM_PUSHPAGE		KM_SLEEP
+#define	KM_NOSLEEP		UMEM_DEFAULT
+#define	KM_NORMALPRI		0	/* not needed with UMEM_DEFAULT */
+#define	KMC_NODEBUG		UMC_NODEBUG
+#define	KMC_KVMEM		0x0
+#define	kmem_alloc(_s, _f)	umem_alloc(_s, _f)
+#define	kmem_zalloc(_s, _f)	umem_zalloc(_s, _f)
+#define	kmem_free(_b, _s)	umem_free(_b, _s)
+#define	vmem_alloc(_s, _f)	kmem_alloc(_s, _f)
+#define	vmem_zalloc(_s, _f)	kmem_zalloc(_s, _f)
+#define	vmem_free(_b, _s)	kmem_free(_b, _s)
+#define	kmem_cache_create(_a, _b, _c, _d, _e, _f, _g, _h, _i) \
+	umem_cache_create(_a, _b, _c, _d, _e, _f, _g, _h, _i)
+#define	kmem_cache_destroy(_c)	umem_cache_destroy(_c)
+#define	kmem_cache_alloc(_c, _f) umem_cache_alloc(_c, _f)
+#define	kmem_cache_free(_c, _b)	umem_cache_free(_c, _b)
+#define	kmem_debugging()	0
+#define	kmem_cache_reap_now(_c)	umem_cache_reap_now(_c);
+#define	kmem_cache_set_move(_c, _cb)	/* nothing */
+#define	POINTER_INVALIDATE(_pp)		/* nothing */
+#define	POINTER_IS_VALID(_p)	0
+
+typedef umem_cache_t kmem_cache_t;
+
+typedef enum kmem_cbrc {
+	KMEM_CBRC_YES,
+	KMEM_CBRC_NO,
+	KMEM_CBRC_LATER,
+	KMEM_CBRC_DONT_NEED,
+	KMEM_CBRC_DONT_KNOW
+} kmem_cbrc_t;
+
+/*
+ * Task queues
+ */
+
+#define	TASKQ_NAMELEN	31
+
+typedef uintptr_t taskqid_t;
+typedef void (task_func_t)(void *);
+
+typedef struct taskq_ent {
+	struct taskq_ent	*tqent_next;
+	struct taskq_ent	*tqent_prev;
+	task_func_t		*tqent_func;
+	void			*tqent_arg;
+	uintptr_t		tqent_flags;
+} taskq_ent_t;
+
+typedef struct taskq {
+	char		tq_name[TASKQ_NAMELEN + 1];
+	kmutex_t	tq_lock;
+	krwlock_t	tq_threadlock;
+	kcondvar_t	tq_dispatch_cv;
+	kcondvar_t	tq_wait_cv;
+	kthread_t	**tq_threadlist;
+	int		tq_flags;
+	int		tq_active;
+	int		tq_nthreads;
+	int		tq_nalloc;
+	int		tq_minalloc;
+	int		tq_maxalloc;
+	kcondvar_t	tq_maxalloc_cv;
+	int		tq_maxalloc_wait;
+	taskq_ent_t	*tq_freelist;
+	taskq_ent_t	tq_task;
+} taskq_t;
+
+#define	TQENT_FLAG_PREALLOC	0x1	/* taskq_dispatch_ent used */
+
+#define	TASKQ_PREPOPULATE	0x0001
+#define	TASKQ_CPR_SAFE		0x0002	/* Use CPR safe protocol */
+#define	TASKQ_DYNAMIC		0x0004	/* Use dynamic thread scheduling */
+#define	TASKQ_THREADS_CPU_PCT	0x0008	/* Scale # threads by # cpus */
+#define	TASKQ_DC_BATCH		0x0010	/* Mark threads as batch */
+
+#define	TQ_SLEEP	KM_SLEEP	/* Can block for memory */
+#define	TQ_NOSLEEP	KM_NOSLEEP	/* cannot block for memory; may fail */
+#define	TQ_NOQUEUE	0x02		/* Do not enqueue if can't dispatch */
+#define	TQ_FRONT	0x08		/* Queue in front */
+
+#define	TASKQID_INVALID		((taskqid_t)0)
+
+extern taskq_t *system_taskq;
+extern taskq_t *system_delay_taskq;
+
+extern taskq_t	*taskq_create(const char *, int, pri_t, int, int, uint_t);
+#define	taskq_create_proc(a, b, c, d, e, p, f) \
+	    (taskq_create(a, b, c, d, e, f))
+#define	taskq_create_sysdc(a, b, d, e, p, dc, f) \
+	    (taskq_create(a, b, maxclsyspri, d, e, f))
+extern taskqid_t taskq_dispatch(taskq_t *, task_func_t, void *, uint_t);
+extern taskqid_t taskq_dispatch_delay(taskq_t *, task_func_t, void *, uint_t,
+    clock_t);
+extern void	taskq_dispatch_ent(taskq_t *, task_func_t, void *, uint_t,
+    taskq_ent_t *);
+extern int	taskq_empty_ent(taskq_ent_t *);
+extern void	taskq_init_ent(taskq_ent_t *);
+extern void	taskq_destroy(taskq_t *);
+extern void	taskq_wait(taskq_t *);
+extern void	taskq_wait_id(taskq_t *, taskqid_t);
+extern void	taskq_wait_outstanding(taskq_t *, taskqid_t);
+extern int	taskq_member(taskq_t *, kthread_t *);
+extern taskq_t	*taskq_of_curthread(void);
+extern int	taskq_cancel_id(taskq_t *, taskqid_t);
+extern void	system_taskq_init(void);
+extern void	system_taskq_fini(void);
+
+#define	XVA_MAPSIZE	3
+#define	XVA_MAGIC	0x78766174
+
+extern char *vn_dumpdir;
+#define	AV_SCANSTAMP_SZ	32		/* length of anti-virus scanstamp */
+
+typedef struct xoptattr {
+	inode_timespec_t xoa_createtime;	/* Create time of file */
+	uint8_t		xoa_archive;
+	uint8_t		xoa_system;
+	uint8_t		xoa_readonly;
+	uint8_t		xoa_hidden;
+	uint8_t		xoa_nounlink;
+	uint8_t		xoa_immutable;
+	uint8_t		xoa_appendonly;
+	uint8_t		xoa_nodump;
+	uint8_t		xoa_settable;
+	uint8_t		xoa_opaque;
+	uint8_t		xoa_av_quarantined;
+	uint8_t		xoa_av_modified;
+	uint8_t		xoa_av_scanstamp[AV_SCANSTAMP_SZ];
+	uint8_t		xoa_reparse;
+	uint8_t		xoa_offline;
+	uint8_t		xoa_sparse;
+} xoptattr_t;
+
+typedef struct vattr {
+	uint_t		va_mask;	/* bit-mask of attributes */
+	u_offset_t	va_size;	/* file size in bytes */
+} vattr_t;
+
+
+typedef struct xvattr {
+	vattr_t		xva_vattr;	/* Embedded vattr structure */
+	uint32_t	xva_magic;	/* Magic Number */
+	uint32_t	xva_mapsize;	/* Size of attr bitmap (32-bit words) */
+	uint32_t	*xva_rtnattrmapp;	/* Ptr to xva_rtnattrmap[] */
+	uint32_t	xva_reqattrmap[XVA_MAPSIZE];	/* Requested attrs */
+	uint32_t	xva_rtnattrmap[XVA_MAPSIZE];	/* Returned attrs */
+	xoptattr_t	xva_xoptattrs;	/* Optional attributes */
+} xvattr_t;
+
+typedef struct vsecattr {
+	uint_t		vsa_mask;	/* See below */
+	int		vsa_aclcnt;	/* ACL entry count */
+	void		*vsa_aclentp;	/* pointer to ACL entries */
+	int		vsa_dfaclcnt;	/* default ACL entry count */
+	void		*vsa_dfaclentp;	/* pointer to default ACL entries */
+	size_t		vsa_aclentsz;	/* ACE size in bytes of vsa_aclentp */
+} vsecattr_t;
+
+#define	AT_MODE		0x00002
+#define	AT_UID		0x00004
+#define	AT_GID		0x00008
+#define	AT_FSID		0x00010
+#define	AT_NODEID	0x00020
+#define	AT_NLINK	0x00040
+#define	AT_SIZE		0x00080
+#define	AT_ATIME	0x00100
+#define	AT_MTIME	0x00200
+#define	AT_CTIME	0x00400
+#define	AT_RDEV		0x00800
+#define	AT_BLKSIZE	0x01000
+#define	AT_NBLOCKS	0x02000
+#define	AT_SEQ		0x08000
+#define	AT_XVATTR	0x10000
+
+#define	CRCREAT		0
+
+#define	F_FREESP	11
+#define	FIGNORECASE	0x80000 /* request case-insensitive lookups */
+
+/*
+ * Random stuff
+ */
+#define	ddi_get_lbolt()		(gethrtime() >> 23)
+#define	ddi_get_lbolt64()	(gethrtime() >> 23)
+#define	hz	119	/* frequency when using gethrtime() >> 23 for lbolt */
+
+#define	ddi_time_before(a, b)		(a < b)
+#define	ddi_time_after(a, b)		ddi_time_before(b, a)
+#define	ddi_time_before_eq(a, b)	(!ddi_time_after(a, b))
+#define	ddi_time_after_eq(a, b)		ddi_time_before_eq(b, a)
+
+#define	ddi_time_before64(a, b)		(a < b)
+#define	ddi_time_after64(a, b)		ddi_time_before64(b, a)
+#define	ddi_time_before_eq64(a, b)	(!ddi_time_after64(a, b))
+#define	ddi_time_after_eq64(a, b)	ddi_time_before_eq64(b, a)
+
+extern void delay(clock_t ticks);
+
+#define	SEC_TO_TICK(sec)	((sec) * hz)
+#define	MSEC_TO_TICK(msec)	((msec) / (MILLISEC / hz))
+#define	USEC_TO_TICK(usec)	((usec) / (MICROSEC / hz))
+#define	NSEC_TO_TICK(usec)	((usec) / (NANOSEC / hz))
+
+#define	max_ncpus	64
+#define	boot_ncpus	(sysconf(_SC_NPROCESSORS_ONLN))
+
+/*
+ * Process priorities as defined by setpriority(2) and getpriority(2).
+ */
+#define	minclsyspri	19
+#define	maxclsyspri	-20
+#define	defclsyspri	0
+
+#define	CPU_SEQID	((uintptr_t)pthread_self() & (max_ncpus - 1))
+
+#define	kcred		NULL
+#define	CRED()		NULL
+
+#define	ptob(x)		((x) * PAGESIZE)
+
+#define	NN_DIVISOR_1000	(1U << 0)
+#define	NN_NUMBUF_SZ	(6)
+
+extern uint64_t physmem;
+extern char *random_path;
+extern char *urandom_path;
+
+extern int highbit64(uint64_t i);
+extern int lowbit64(uint64_t i);
+extern int random_get_bytes(uint8_t *ptr, size_t len);
+extern int random_get_pseudo_bytes(uint8_t *ptr, size_t len);
+
+extern void kernel_init(int mode);
+extern void kernel_fini(void);
+extern void random_init(void);
+extern void random_fini(void);
+
+struct spa;
+extern void show_pool_stats(struct spa *);
+extern int set_global_var(char *arg);
+
+typedef struct callb_cpr {
+	kmutex_t	*cc_lockp;
+} callb_cpr_t;
+
+#define	CALLB_CPR_INIT(cp, lockp, func, name)	{		\
+	(cp)->cc_lockp = lockp;					\
+}
+
+#define	CALLB_CPR_SAFE_BEGIN(cp) {				\
+	ASSERT(MUTEX_HELD((cp)->cc_lockp));			\
+}
+
+#define	CALLB_CPR_SAFE_END(cp, lockp) {				\
+	ASSERT(MUTEX_HELD((cp)->cc_lockp));			\
+}
+
+#define	CALLB_CPR_EXIT(cp) {					\
+	ASSERT(MUTEX_HELD((cp)->cc_lockp));			\
+	mutex_exit((cp)->cc_lockp);				\
+}
+
+#define	zone_dataset_visible(x, y)	(1)
+#define	INGLOBALZONE(z)			(1)
+extern uint32_t zone_get_hostid(void *zonep);
+
+extern char *kmem_vasprintf(const char *fmt, va_list adx);
+extern char *kmem_asprintf(const char *fmt, ...);
+#define	kmem_strfree(str) kmem_free((str), strlen(str) + 1)
+#define	kmem_strdup(s)  strdup(s)
+
+/*
+ * Hostname information
+ */
+extern char hw_serial[];	/* for userland-emulated hostid access */
+extern int ddi_strtoul(const char *str, char **nptr, int base,
+    unsigned long *result);
+
+extern int ddi_strtoull(const char *str, char **nptr, int base,
+    u_longlong_t *result);
+
+typedef struct utsname	utsname_t;
+extern utsname_t *utsname(void);
+
+/* ZFS Boot Related stuff. */
+
+struct _buf {
+	intptr_t	_fd;
+};
+
+struct bootstat {
+	uint64_t st_size;
+};
+
+typedef struct ace_object {
+	uid_t		a_who;
+	uint32_t	a_access_mask;
+	uint16_t	a_flags;
+	uint16_t	a_type;
+	uint8_t		a_obj_type[16];
+	uint8_t		a_inherit_obj_type[16];
+} ace_object_t;
+
+
+#define	ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE	0x05
+#define	ACE_ACCESS_DENIED_OBJECT_ACE_TYPE	0x06
+#define	ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE	0x07
+#define	ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE	0x08
+
+extern int zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr);
+extern int zfs_secpolicy_rename_perms(const char *from, const char *to,
+    cred_t *cr);
+extern int zfs_secpolicy_destroy_perms(const char *name, cred_t *cr);
+extern int secpolicy_zfs(const cred_t *cr);
+extern int secpolicy_zfs_proc(const cred_t *cr, proc_t *proc);
+extern zoneid_t getzoneid(void);
+
+/* SID stuff */
+typedef struct ksiddomain {
+	uint_t	kd_ref;
+	uint_t	kd_len;
+	char	*kd_name;
+} ksiddomain_t;
+
+ksiddomain_t *ksid_lookupdomain(const char *);
+void ksiddomain_rele(ksiddomain_t *);
+
+#define	DDI_SLEEP	KM_SLEEP
+#define	ddi_log_sysevent(_a, _b, _c, _d, _e, _f, _g) \
+	sysevent_post_event(_c, _d, _b, "libzpool", _e, _f)
+
+#define	zfs_sleep_until(wakeup)						\
+	do {								\
+		hrtime_t delta = wakeup - gethrtime();			\
+		struct timespec ts;					\
+		ts.tv_sec = delta / NANOSEC;				\
+		ts.tv_nsec = delta % NANOSEC;				\
+		(void) nanosleep(&ts, NULL);				\
+	} while (0)
+
+typedef int fstrans_cookie_t;
+
+extern fstrans_cookie_t spl_fstrans_mark(void);
+extern void spl_fstrans_unmark(fstrans_cookie_t);
+extern int __spl_pf_fstrans_check(void);
+extern int kmem_cache_reap_active(void);
+
+#define	____cacheline_aligned
+
+/*
+ * Kernel modules
+ */
+#define	__init
+#define	__exit
+
+#endif /* _KERNEL */
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif	/* _SYS_ZFS_CONTEXT_H */
diff --git a/include/sys/zfs_debug.h b/include/sys/zfs_debug.h
new file mode 100644
index 0000000000000..89587876f9470
--- /dev/null
+++ b/include/sys/zfs_debug.h
@@ -0,0 +1,111 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2019 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_ZFS_DEBUG_H
+#define	_SYS_ZFS_DEBUG_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifndef TRUE
+#define	TRUE 1
+#endif
+
+#ifndef FALSE
+#define	FALSE 0
+#endif
+
+extern int zfs_flags;
+extern int zfs_recover;
+extern int zfs_free_leak_on_eio;
+extern int zfs_dbgmsg_enable;
+
+#define	ZFS_DEBUG_DPRINTF		(1 << 0)
+#define	ZFS_DEBUG_DBUF_VERIFY		(1 << 1)
+#define	ZFS_DEBUG_DNODE_VERIFY		(1 << 2)
+#define	ZFS_DEBUG_SNAPNAMES		(1 << 3)
+#define	ZFS_DEBUG_MODIFY		(1 << 4)
+/* 1<<5 was previously used, try not to reuse */
+#define	ZFS_DEBUG_ZIO_FREE		(1 << 6)
+#define	ZFS_DEBUG_HISTOGRAM_VERIFY	(1 << 7)
+#define	ZFS_DEBUG_METASLAB_VERIFY	(1 << 8)
+#define	ZFS_DEBUG_SET_ERROR		(1 << 9)
+#define	ZFS_DEBUG_INDIRECT_REMAP	(1 << 10)
+#define	ZFS_DEBUG_TRIM			(1 << 11)
+#define	ZFS_DEBUG_LOG_SPACEMAP		(1 << 12)
+
+extern void __set_error(const char *file, const char *func, int line, int err);
+extern void __zfs_dbgmsg(char *buf);
+extern void __dprintf(boolean_t dprint, const char *file, const char *func,
+    int line, const char *fmt, ...);
+
+/*
+ * Some general principles for using zfs_dbgmsg():
+ * 1. We don't want to pollute the log with typically-irrelevant messages,
+ *    so don't print too many messages in the "normal" code path - O(1)
+ *    per txg.
+ * 2. We want to know for sure what happened, so make the message specific
+ *    (e.g. *which* thing am I operating on).
+ * 3. Do print a message when something unusual or unexpected happens
+ *    (e.g. error cases).
+ * 4. Print a message when making user-initiated on-disk changes.
+ *
+ * Note that besides principle 1, another reason that we don't want to
+ * use zfs_dbgmsg in high-frequency routines is the potential impact
+ * that it can have on performance.
+ */
+#define	zfs_dbgmsg(...) \
+	if (zfs_dbgmsg_enable) \
+		__dprintf(B_FALSE, __FILE__, __func__, __LINE__, __VA_ARGS__)
+
+#ifdef ZFS_DEBUG
+/*
+ * To enable this:
+ *
+ * $ echo 1 >/sys/module/zfs/parameters/zfs_flags
+ */
+#define	dprintf(...) \
+	if (zfs_flags & ZFS_DEBUG_DPRINTF) \
+		__dprintf(B_TRUE, __FILE__, __func__, __LINE__, __VA_ARGS__)
+#else
+#define	dprintf(...) ((void)0)
+#endif /* ZFS_DEBUG */
+
+extern void zfs_panic_recover(const char *fmt, ...);
+
+extern void zfs_dbgmsg_init(void);
+extern void zfs_dbgmsg_fini(void);
+
+#ifndef _KERNEL
+extern int dprintf_find_string(const char *string);
+extern void zfs_dbgmsg_print(const char *tag);
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZFS_DEBUG_H */
diff --git a/include/sys/zfs_delay.h b/include/sys/zfs_delay.h
new file mode 100644
index 0000000000000..40e617dba9615
--- /dev/null
+++ b/include/sys/zfs_delay.h
@@ -0,0 +1,41 @@
+/*
+ * 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
+ */
+
+#ifndef	_SYS_FS_ZFS_DELAY_H
+#define	_SYS_FS_ZFS_DELAY_H
+
+#include <sys/timer.h>
+
+/*
+ * Generic wrapper to sleep until a given time.
+ */
+#define	zfs_sleep_until(wakeup)						\
+	do {								\
+		hrtime_t delta = wakeup - gethrtime();			\
+									\
+		if (delta > 0) {					\
+			unsigned long delta_us;				\
+			delta_us = delta / (NANOSEC / MICROSEC);	\
+			usleep_range(delta_us, delta_us + 100);		\
+		}							\
+	} while (0)
+
+#endif	/* _SYS_FS_ZFS_DELAY_H */
diff --git a/include/sys/zfs_file.h b/include/sys/zfs_file.h
new file mode 100644
index 0000000000000..d117933a6e4c6
--- /dev/null
+++ b/include/sys/zfs_file.h
@@ -0,0 +1,62 @@
+/*
+ * 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
+ */
+
+#ifndef	_SYS_ZFS_FILE_H
+#define	_SYS_ZFS_FILE_H
+
+#ifndef _KERNEL
+typedef struct zfs_file {
+	int f_fd;
+	int f_dump_fd;
+} zfs_file_t;
+#elif defined(__linux__) || defined(__FreeBSD__)
+typedef struct file zfs_file_t;
+#else
+#error "unknown OS"
+#endif
+
+typedef struct zfs_file_attr {
+	uint64_t	zfa_size;	/* file size */
+	mode_t		zfa_mode;	/* file type */
+} zfs_file_attr_t;
+
+int zfs_file_open(const char *path, int flags, int mode, zfs_file_t **fp);
+void zfs_file_close(zfs_file_t *fp);
+
+int zfs_file_write(zfs_file_t *fp, const void *buf, size_t len, ssize_t *resid);
+int zfs_file_pwrite(zfs_file_t *fp, const void *buf, size_t len, loff_t off,
+    ssize_t *resid);
+int zfs_file_read(zfs_file_t *fp, void *buf, size_t len, ssize_t *resid);
+int zfs_file_pread(zfs_file_t *fp, void *buf, size_t len, loff_t off,
+    ssize_t *resid);
+
+int zfs_file_seek(zfs_file_t *fp, loff_t *offp, int whence);
+int zfs_file_getattr(zfs_file_t *fp, zfs_file_attr_t *zfattr);
+int zfs_file_fsync(zfs_file_t *fp, int flags);
+int zfs_file_fallocate(zfs_file_t *fp, int mode, loff_t offset, loff_t len);
+loff_t zfs_file_off(zfs_file_t *fp);
+int zfs_file_unlink(const char *);
+
+int zfs_file_get(int fd, zfs_file_t **fp);
+void zfs_file_put(int fd);
+void *zfs_file_private(zfs_file_t *fp);
+
+#endif /* _SYS_ZFS_FILE_H */
diff --git a/include/sys/zfs_fuid.h b/include/sys/zfs_fuid.h
new file mode 100644
index 0000000000000..b5b37db294683
--- /dev/null
+++ b/include/sys/zfs_fuid.h
@@ -0,0 +1,132 @@
+/*
+ * 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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_FS_ZFS_FUID_H
+#define	_SYS_FS_ZFS_FUID_H
+
+#ifdef _KERNEL
+#include <sys/sid.h>
+#include <sys/dmu.h>
+#include <sys/zfs_vfsops.h>
+#endif
+#include <sys/avl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	ZFS_OWNER,
+	ZFS_GROUP,
+	ZFS_ACE_USER,
+	ZFS_ACE_GROUP
+} zfs_fuid_type_t;
+
+/*
+ * Estimate space needed for one more fuid table entry.
+ * for now assume its current size + 1K
+ */
+#define	FUID_SIZE_ESTIMATE(z) ((z)->z_fuid_size + (SPA_MINBLOCKSIZE << 1))
+
+#define	FUID_INDEX(x)	((x) >> 32)
+#define	FUID_RID(x)	((x) & 0xffffffff)
+#define	FUID_ENCODE(idx, rid) (((uint64_t)(idx) << 32) | (rid))
+/*
+ * FUIDs cause problems for the intent log
+ * we need to replay the creation of the FUID,
+ * but we can't count on the idmapper to be around
+ * and during replay the FUID index may be different than
+ * before.  Also, if an ACL has 100 ACEs and 12 different
+ * domains we don't want to log 100 domain strings, but rather
+ * just the unique 12.
+ */
+
+/*
+ * The FUIDs in the log will index into
+ * domain string table and the bottom half will be the rid.
+ * Used for mapping ephemeral uid/gid during ACL setting to FUIDs
+ */
+typedef struct zfs_fuid {
+	list_node_t 	z_next;
+	uint64_t 	z_id;		/* uid/gid being converted to fuid */
+	uint64_t	z_domidx;	/* index in AVL domain table */
+	uint64_t	z_logfuid;	/* index for domain in log */
+} zfs_fuid_t;
+
+/* list of unique domains */
+typedef struct zfs_fuid_domain {
+	list_node_t	z_next;
+	uint64_t	z_domidx;	/* AVL tree idx */
+	const char	*z_domain;	/* domain string */
+} zfs_fuid_domain_t;
+
+/*
+ * FUID information necessary for logging create, setattr, and setacl.
+ */
+typedef struct zfs_fuid_info {
+	list_t	z_fuids;
+	list_t	z_domains;
+	uint64_t z_fuid_owner;
+	uint64_t z_fuid_group;
+	char **z_domain_table;  /* Used during replay */
+	uint32_t z_fuid_cnt;	/* How many fuids in z_fuids */
+	uint32_t z_domain_cnt;	/* How many domains */
+	size_t	z_domain_str_sz; /* len of domain strings z_domain list */
+} zfs_fuid_info_t;
+
+#ifdef _KERNEL
+struct znode;
+extern uid_t zfs_fuid_map_id(zfsvfs_t *, uint64_t, cred_t *, zfs_fuid_type_t);
+extern void zfs_fuid_node_add(zfs_fuid_info_t **, const char *, uint32_t,
+    uint64_t, uint64_t, zfs_fuid_type_t);
+extern void zfs_fuid_destroy(zfsvfs_t *);
+extern uint64_t zfs_fuid_create_cred(zfsvfs_t *, zfs_fuid_type_t,
+    cred_t *, zfs_fuid_info_t **);
+extern uint64_t zfs_fuid_create(zfsvfs_t *, uint64_t, cred_t *, zfs_fuid_type_t,
+    zfs_fuid_info_t **);
+extern void zfs_fuid_map_ids(struct znode *zp, cred_t *cr,
+    uid_t *uid, uid_t *gid);
+extern zfs_fuid_info_t *zfs_fuid_info_alloc(void);
+extern void zfs_fuid_info_free(zfs_fuid_info_t *);
+extern boolean_t zfs_groupmember(zfsvfs_t *, uint64_t, cred_t *);
+void zfs_fuid_sync(zfsvfs_t *, dmu_tx_t *);
+extern int zfs_fuid_find_by_domain(zfsvfs_t *, const char *domain,
+    char **retdomain, boolean_t addok);
+extern const char *zfs_fuid_find_by_idx(zfsvfs_t *zfsvfs, uint32_t idx);
+extern void zfs_fuid_txhold(zfsvfs_t *zfsvfs, dmu_tx_t *tx);
+extern int zfs_id_to_fuidstr(zfsvfs_t *zfsvfs, const char *domain, uid_t rid,
+    char *buf, size_t len, boolean_t addok);
+#endif
+
+char *zfs_fuid_idx_domain(avl_tree_t *, uint32_t);
+void zfs_fuid_avl_tree_create(avl_tree_t *, avl_tree_t *);
+uint64_t zfs_fuid_table_load(objset_t *, uint64_t, avl_tree_t *, avl_tree_t *);
+void zfs_fuid_table_destroy(avl_tree_t *, avl_tree_t *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_FS_ZFS_FUID_H */
diff --git a/include/sys/zfs_ioctl.h b/include/sys/zfs_ioctl.h
new file mode 100644
index 0000000000000..136075a1fc18c
--- /dev/null
+++ b/include/sys/zfs_ioctl.h
@@ -0,0 +1,581 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 by Delphix. All rights reserved.
+ * Copyright 2016 RackTop Systems.
+ * Copyright (c) 2017, Intel Corporation.
+ */
+
+#ifndef	_SYS_ZFS_IOCTL_H
+#define	_SYS_ZFS_IOCTL_H
+
+#include <sys/cred.h>
+#include <sys/dmu.h>
+#include <sys/zio.h>
+#include <sys/dsl_deleg.h>
+#include <sys/spa.h>
+#include <sys/zfs_stat.h>
+
+#ifdef _KERNEL
+#include <sys/nvpair.h>
+#endif	/* _KERNEL */
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * The structures in this file are passed between userland and the
+ * kernel.  Userland may be running a 32-bit process, while the kernel
+ * is 64-bit.  Therefore, these structures need to compile the same in
+ * 32-bit and 64-bit.  This means not using type "long", and adding
+ * explicit padding so that the 32-bit structure will not be packed more
+ * tightly than the 64-bit structure (which requires 64-bit alignment).
+ */
+
+/*
+ * Property values for snapdir
+ */
+#define	ZFS_SNAPDIR_HIDDEN		0
+#define	ZFS_SNAPDIR_VISIBLE		1
+
+/*
+ * Property values for snapdev
+ */
+#define	ZFS_SNAPDEV_HIDDEN		0
+#define	ZFS_SNAPDEV_VISIBLE		1
+/*
+ * Property values for acltype
+ */
+#define	ZFS_ACLTYPE_OFF			0
+#define	ZFS_ACLTYPE_POSIXACL		1
+
+/*
+ * Field manipulation macros for the drr_versioninfo field of the
+ * send stream header.
+ */
+
+/*
+ * Header types for zfs send streams.
+ */
+typedef enum drr_headertype {
+	DMU_SUBSTREAM = 0x1,
+	DMU_COMPOUNDSTREAM = 0x2
+} drr_headertype_t;
+
+#define	DMU_GET_STREAM_HDRTYPE(vi)	BF64_GET((vi), 0, 2)
+#define	DMU_SET_STREAM_HDRTYPE(vi, x)	BF64_SET((vi), 0, 2, x)
+
+#define	DMU_GET_FEATUREFLAGS(vi)	BF64_GET((vi), 2, 30)
+#define	DMU_SET_FEATUREFLAGS(vi, x)	BF64_SET((vi), 2, 30, x)
+
+/*
+ * Feature flags for zfs send streams (flags in drr_versioninfo)
+ */
+
+#define	DMU_BACKUP_FEATURE_DEDUP		(1 << 0)
+#define	DMU_BACKUP_FEATURE_DEDUPPROPS		(1 << 1)
+#define	DMU_BACKUP_FEATURE_SA_SPILL		(1 << 2)
+/* flags #3 - #15 are reserved for incompatible closed-source implementations */
+#define	DMU_BACKUP_FEATURE_EMBED_DATA		(1 << 16)
+#define	DMU_BACKUP_FEATURE_LZ4			(1 << 17)
+/* flag #18 is reserved for a Delphix feature */
+#define	DMU_BACKUP_FEATURE_LARGE_BLOCKS		(1 << 19)
+#define	DMU_BACKUP_FEATURE_RESUMING		(1 << 20)
+#define	DMU_BACKUP_FEATURE_REDACTED		(1 << 21)
+#define	DMU_BACKUP_FEATURE_COMPRESSED		(1 << 22)
+#define	DMU_BACKUP_FEATURE_LARGE_DNODE		(1 << 23)
+#define	DMU_BACKUP_FEATURE_RAW			(1 << 24)
+#define	DMU_BACKUP_FEATURE_ZSTD			(1 << 25)
+#define	DMU_BACKUP_FEATURE_HOLDS		(1 << 26)
+/*
+ * The SWITCH_TO_LARGE_BLOCKS feature indicates that we can receive
+ * incremental LARGE_BLOCKS streams (those with WRITE records of >128KB) even
+ * if the previous send did not use LARGE_BLOCKS, and thus its large blocks
+ * were split into multiple 128KB WRITE records.  (See
+ * flush_write_batch_impl() and receive_object()).  Older software that does
+ * not support this flag may encounter a bug when switching to large blocks,
+ * which causes files to incorrectly be zeroed.
+ *
+ * This flag is currently not set on any send streams.  In the future, we
+ * intend for incremental send streams of snapshots that have large blocks to
+ * use LARGE_BLOCKS by default, and these streams will also have the
+ * SWITCH_TO_LARGE_BLOCKS feature set. This ensures that streams from the
+ * default use of "zfs send" won't encounter the bug mentioned above.
+ */
+#define	DMU_BACKUP_FEATURE_SWITCH_TO_LARGE_BLOCKS (1 << 27)
+
+/*
+ * Mask of all supported backup features
+ */
+#define	DMU_BACKUP_FEATURE_MASK	(DMU_BACKUP_FEATURE_SA_SPILL | \
+    DMU_BACKUP_FEATURE_EMBED_DATA | DMU_BACKUP_FEATURE_LZ4 | \
+    DMU_BACKUP_FEATURE_RESUMING | DMU_BACKUP_FEATURE_LARGE_BLOCKS | \
+    DMU_BACKUP_FEATURE_COMPRESSED | DMU_BACKUP_FEATURE_LARGE_DNODE | \
+    DMU_BACKUP_FEATURE_RAW | DMU_BACKUP_FEATURE_HOLDS | \
+    DMU_BACKUP_FEATURE_REDACTED | DMU_BACKUP_FEATURE_SWITCH_TO_LARGE_BLOCKS | \
+    DMU_BACKUP_FEATURE_ZSTD)
+
+/* Are all features in the given flag word currently supported? */
+#define	DMU_STREAM_SUPPORTED(x)	(!((x) & ~DMU_BACKUP_FEATURE_MASK))
+
+typedef enum dmu_send_resume_token_version {
+	ZFS_SEND_RESUME_TOKEN_VERSION = 1
+} dmu_send_resume_token_version_t;
+
+/*
+ * The drr_versioninfo field of the dmu_replay_record has the
+ * following layout:
+ *
+ *	64	56	48	40	32	24	16	8	0
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ *	|		reserved	|        feature-flags	    |C|S|
+ *	+-------+-------+-------+-------+-------+-------+-------+-------+
+ *
+ * The low order two bits indicate the header type: SUBSTREAM (0x1)
+ * or COMPOUNDSTREAM (0x2).  Using two bits for this is historical:
+ * this field used to be a version number, where the two version types
+ * were 1 and 2.  Using two bits for this allows earlier versions of
+ * the code to be able to recognize send streams that don't use any
+ * of the features indicated by feature flags.
+ */
+
+#define	DMU_BACKUP_MAGIC 0x2F5bacbacULL
+
+/*
+ * Send stream flags.  Bits 24-31 are reserved for vendor-specific
+ * implementations and should not be used.
+ */
+#define	DRR_FLAG_CLONE		(1<<0)
+#define	DRR_FLAG_CI_DATA	(1<<1)
+/*
+ * This send stream, if it is a full send, includes the FREE and FREEOBJECT
+ * records that are created by the sending process.  This means that the send
+ * stream can be received as a clone, even though it is not an incremental.
+ * This is not implemented as a feature flag, because the receiving side does
+ * not need to have implemented it to receive this stream; it is fully backwards
+ * compatible.  We need a flag, though, because full send streams without it
+ * cannot necessarily be received as a clone correctly.
+ */
+#define	DRR_FLAG_FREERECORDS	(1<<2)
+/*
+ * When DRR_FLAG_SPILL_BLOCK is set it indicates the DRR_OBJECT_SPILL
+ * and DRR_SPILL_UNMODIFIED flags are meaningful in the send stream.
+ *
+ * When DRR_FLAG_SPILL_BLOCK is set, DRR_OBJECT records will have
+ * DRR_OBJECT_SPILL set if and only if they should have a spill block
+ * (either an existing one, or a new one in the send stream).  When clear
+ * the object does not have a spill block and any existing spill block
+ * should be freed.
+ *
+ * Similarly, when DRR_FLAG_SPILL_BLOCK is set, DRR_SPILL records will
+ * have DRR_SPILL_UNMODIFIED set if and only if they were included for
+ * backward compatibility purposes, and can be safely ignored by new versions
+ * of zfs receive.  Previous versions of ZFS which do not understand the
+ * DRR_FLAG_SPILL_BLOCK will process this record and recreate any missing
+ * spill blocks.
+ */
+#define	DRR_FLAG_SPILL_BLOCK	(1<<3)
+
+/*
+ * flags in the drr_flags field in the DRR_WRITE, DRR_SPILL, DRR_OBJECT,
+ * DRR_WRITE_BYREF, and DRR_OBJECT_RANGE blocks
+ */
+#define	DRR_CHECKSUM_DEDUP	(1<<0) /* not used for SPILL records */
+#define	DRR_RAW_BYTESWAP	(1<<1)
+#define	DRR_OBJECT_SPILL	(1<<2) /* OBJECT record has a spill block */
+#define	DRR_SPILL_UNMODIFIED	(1<<2) /* SPILL record for unmodified block */
+
+#define	DRR_IS_DEDUP_CAPABLE(flags)	((flags) & DRR_CHECKSUM_DEDUP)
+#define	DRR_IS_RAW_BYTESWAPPED(flags)	((flags) & DRR_RAW_BYTESWAP)
+#define	DRR_OBJECT_HAS_SPILL(flags)	((flags) & DRR_OBJECT_SPILL)
+#define	DRR_SPILL_IS_UNMODIFIED(flags)	((flags) & DRR_SPILL_UNMODIFIED)
+
+/* deal with compressed drr_write replay records */
+#define	DRR_WRITE_COMPRESSED(drrw)	((drrw)->drr_compressiontype != 0)
+#define	DRR_WRITE_PAYLOAD_SIZE(drrw) \
+	(DRR_WRITE_COMPRESSED(drrw) ? (drrw)->drr_compressed_size : \
+	(drrw)->drr_logical_size)
+#define	DRR_SPILL_PAYLOAD_SIZE(drrs) \
+	((drrs)->drr_compressed_size ? \
+	(drrs)->drr_compressed_size : (drrs)->drr_length)
+#define	DRR_OBJECT_PAYLOAD_SIZE(drro) \
+	((drro)->drr_raw_bonuslen != 0 ? \
+	(drro)->drr_raw_bonuslen : P2ROUNDUP((drro)->drr_bonuslen, 8))
+
+/*
+ * zfs ioctl command structure
+ */
+
+/* Header is used in C++ so can't forward declare untagged struct */
+struct drr_begin {
+	uint64_t drr_magic;
+	uint64_t drr_versioninfo; /* was drr_version */
+	uint64_t drr_creation_time;
+	dmu_objset_type_t drr_type;
+	uint32_t drr_flags;
+	uint64_t drr_toguid;
+	uint64_t drr_fromguid;
+	char drr_toname[MAXNAMELEN];
+};
+
+typedef struct dmu_replay_record {
+	enum {
+		DRR_BEGIN, DRR_OBJECT, DRR_FREEOBJECTS,
+		DRR_WRITE, DRR_FREE, DRR_END, DRR_WRITE_BYREF,
+		DRR_SPILL, DRR_WRITE_EMBEDDED, DRR_OBJECT_RANGE, DRR_REDACT,
+		DRR_NUMTYPES
+	} drr_type;
+	uint32_t drr_payloadlen;
+	union {
+		struct drr_begin drr_begin;
+		struct drr_end {
+			zio_cksum_t drr_checksum;
+			uint64_t drr_toguid;
+		} drr_end;
+		struct drr_object {
+			uint64_t drr_object;
+			dmu_object_type_t drr_type;
+			dmu_object_type_t drr_bonustype;
+			uint32_t drr_blksz;
+			uint32_t drr_bonuslen;
+			uint8_t drr_checksumtype;
+			uint8_t drr_compress;
+			uint8_t drr_dn_slots;
+			uint8_t drr_flags;
+			uint32_t drr_raw_bonuslen;
+			uint64_t drr_toguid;
+			/* only (possibly) nonzero for raw streams */
+			uint8_t drr_indblkshift;
+			uint8_t drr_nlevels;
+			uint8_t drr_nblkptr;
+			uint8_t drr_pad[5];
+			uint64_t drr_maxblkid;
+			/* bonus content follows */
+		} drr_object;
+		struct drr_freeobjects {
+			uint64_t drr_firstobj;
+			uint64_t drr_numobjs;
+			uint64_t drr_toguid;
+		} drr_freeobjects;
+		struct drr_write {
+			uint64_t drr_object;
+			dmu_object_type_t drr_type;
+			uint32_t drr_pad;
+			uint64_t drr_offset;
+			uint64_t drr_logical_size;
+			uint64_t drr_toguid;
+			uint8_t drr_checksumtype;
+			uint8_t drr_flags;
+			uint8_t drr_compressiontype;
+			uint8_t drr_pad2[5];
+			/* deduplication key */
+			ddt_key_t drr_key;
+			/* only nonzero if drr_compressiontype is not 0 */
+			uint64_t drr_compressed_size;
+			/* only nonzero for raw streams */
+			uint8_t drr_salt[ZIO_DATA_SALT_LEN];
+			uint8_t drr_iv[ZIO_DATA_IV_LEN];
+			uint8_t drr_mac[ZIO_DATA_MAC_LEN];
+			/* content follows */
+		} drr_write;
+		struct drr_free {
+			uint64_t drr_object;
+			uint64_t drr_offset;
+			uint64_t drr_length;
+			uint64_t drr_toguid;
+		} drr_free;
+		struct drr_write_byref {
+			/* where to put the data */
+			uint64_t drr_object;
+			uint64_t drr_offset;
+			uint64_t drr_length;
+			uint64_t drr_toguid;
+			/* where to find the prior copy of the data */
+			uint64_t drr_refguid;
+			uint64_t drr_refobject;
+			uint64_t drr_refoffset;
+			/* properties of the data */
+			uint8_t drr_checksumtype;
+			uint8_t drr_flags;
+			uint8_t drr_pad2[6];
+			ddt_key_t drr_key; /* deduplication key */
+		} drr_write_byref;
+		struct drr_spill {
+			uint64_t drr_object;
+			uint64_t drr_length;
+			uint64_t drr_toguid;
+			uint8_t drr_flags;
+			uint8_t drr_compressiontype;
+			uint8_t drr_pad[6];
+			/* only nonzero for raw streams */
+			uint64_t drr_compressed_size;
+			uint8_t drr_salt[ZIO_DATA_SALT_LEN];
+			uint8_t drr_iv[ZIO_DATA_IV_LEN];
+			uint8_t drr_mac[ZIO_DATA_MAC_LEN];
+			dmu_object_type_t drr_type;
+			/* spill data follows */
+		} drr_spill;
+		struct drr_write_embedded {
+			uint64_t drr_object;
+			uint64_t drr_offset;
+			/* logical length, should equal blocksize */
+			uint64_t drr_length;
+			uint64_t drr_toguid;
+			uint8_t drr_compression;
+			uint8_t drr_etype;
+			uint8_t drr_pad[6];
+			uint32_t drr_lsize; /* uncompressed size of payload */
+			uint32_t drr_psize; /* compr. (real) size of payload */
+			/* (possibly compressed) content follows */
+		} drr_write_embedded;
+		struct drr_object_range {
+			uint64_t drr_firstobj;
+			uint64_t drr_numslots;
+			uint64_t drr_toguid;
+			uint8_t drr_salt[ZIO_DATA_SALT_LEN];
+			uint8_t drr_iv[ZIO_DATA_IV_LEN];
+			uint8_t drr_mac[ZIO_DATA_MAC_LEN];
+			uint8_t drr_flags;
+			uint8_t drr_pad[3];
+		} drr_object_range;
+		struct drr_redact {
+			uint64_t drr_object;
+			uint64_t drr_offset;
+			uint64_t drr_length;
+			uint64_t drr_toguid;
+		} drr_redact;
+
+		/*
+		 * Note: drr_checksum is overlaid with all record types
+		 * except DRR_BEGIN.  Therefore its (non-pad) members
+		 * must not overlap with members from the other structs.
+		 * We accomplish this by putting its members at the very
+		 * end of the struct.
+		 */
+		struct drr_checksum {
+			uint64_t drr_pad[34];
+			/*
+			 * fletcher-4 checksum of everything preceding the
+			 * checksum.
+			 */
+			zio_cksum_t drr_checksum;
+		} drr_checksum;
+	} drr_u;
+} dmu_replay_record_t;
+
+/* diff record range types */
+typedef enum diff_type {
+	DDR_NONE = 0x1,
+	DDR_INUSE = 0x2,
+	DDR_FREE = 0x4
+} diff_type_t;
+
+/*
+ * The diff reports back ranges of free or in-use objects.
+ */
+typedef struct dmu_diff_record {
+	uint64_t ddr_type;
+	uint64_t ddr_first;
+	uint64_t ddr_last;
+} dmu_diff_record_t;
+
+typedef struct zinject_record {
+	uint64_t	zi_objset;
+	uint64_t	zi_object;
+	uint64_t	zi_start;
+	uint64_t	zi_end;
+	uint64_t	zi_guid;
+	uint32_t	zi_level;
+	uint32_t	zi_error;
+	uint64_t	zi_type;
+	uint32_t	zi_freq;
+	uint32_t	zi_failfast;
+	char		zi_func[MAXNAMELEN];
+	uint32_t	zi_iotype;
+	int32_t		zi_duration;
+	uint64_t	zi_timer;
+	uint64_t	zi_nlanes;
+	uint32_t	zi_cmd;
+	uint32_t	zi_dvas;
+} zinject_record_t;
+
+#define	ZINJECT_NULL		0x1
+#define	ZINJECT_FLUSH_ARC	0x2
+#define	ZINJECT_UNLOAD_SPA	0x4
+#define	ZINJECT_CALC_RANGE	0x8
+
+#define	ZEVENT_NONE		0x0
+#define	ZEVENT_NONBLOCK		0x1
+#define	ZEVENT_SIZE		1024
+
+#define	ZEVENT_SEEK_START	0
+#define	ZEVENT_SEEK_END		UINT64_MAX
+
+/* scaled frequency ranges */
+#define	ZI_PERCENTAGE_MIN	4294UL
+#define	ZI_PERCENTAGE_MAX	UINT32_MAX
+
+#define	ZI_NO_DVA		(-1)
+
+typedef enum zinject_type {
+	ZINJECT_UNINITIALIZED,
+	ZINJECT_DATA_FAULT,
+	ZINJECT_DEVICE_FAULT,
+	ZINJECT_LABEL_FAULT,
+	ZINJECT_IGNORED_WRITES,
+	ZINJECT_PANIC,
+	ZINJECT_DELAY_IO,
+	ZINJECT_DECRYPT_FAULT,
+} zinject_type_t;
+
+typedef struct zfs_share {
+	uint64_t	z_exportdata;
+	uint64_t	z_sharedata;
+	uint64_t	z_sharetype;	/* 0 = share, 1 = unshare */
+	uint64_t	z_sharemax;  /* max length of share string */
+} zfs_share_t;
+
+/*
+ * ZFS file systems may behave the usual, POSIX-compliant way, where
+ * name lookups are case-sensitive.  They may also be set up so that
+ * all the name lookups are case-insensitive, or so that only some
+ * lookups, the ones that set an FIGNORECASE flag, are case-insensitive.
+ */
+typedef enum zfs_case {
+	ZFS_CASE_SENSITIVE,
+	ZFS_CASE_INSENSITIVE,
+	ZFS_CASE_MIXED
+} zfs_case_t;
+
+/*
+ * Note: this struct must have the same layout in 32-bit and 64-bit, so
+ * that 32-bit processes (like /sbin/zfs) can pass it to the 64-bit
+ * kernel.  Therefore, we add padding to it so that no "hidden" padding
+ * is automatically added on 64-bit (but not on 32-bit).
+ */
+typedef struct zfs_cmd {
+	char		zc_name[MAXPATHLEN];	/* name of pool or dataset */
+	uint64_t	zc_nvlist_src;		/* really (char *) */
+	uint64_t	zc_nvlist_src_size;
+	uint64_t	zc_nvlist_dst;		/* really (char *) */
+	uint64_t	zc_nvlist_dst_size;
+	boolean_t	zc_nvlist_dst_filled;	/* put an nvlist in dst? */
+	int		zc_pad2;
+
+	/*
+	 * The following members are for legacy ioctls which haven't been
+	 * converted to the new method.
+	 */
+	uint64_t	zc_history;		/* really (char *) */
+	char		zc_value[MAXPATHLEN * 2];
+	char		zc_string[MAXNAMELEN];
+	uint64_t	zc_guid;
+	uint64_t	zc_nvlist_conf;		/* really (char *) */
+	uint64_t	zc_nvlist_conf_size;
+	uint64_t	zc_cookie;
+	uint64_t	zc_objset_type;
+	uint64_t	zc_perm_action;
+	uint64_t	zc_history_len;
+	uint64_t	zc_history_offset;
+	uint64_t	zc_obj;
+	uint64_t	zc_iflags;		/* internal to zfs(7fs) */
+	zfs_share_t	zc_share;
+	dmu_objset_stats_t zc_objset_stats;
+	struct drr_begin zc_begin_record;
+	zinject_record_t zc_inject_record;
+	uint32_t	zc_defer_destroy;
+	uint32_t	zc_flags;
+	uint64_t	zc_action_handle;
+	int		zc_cleanup_fd;
+	uint8_t		zc_simple;
+	uint8_t		zc_pad[3];		/* alignment */
+	uint64_t	zc_sendobj;
+	uint64_t	zc_fromobj;
+	uint64_t	zc_createtxg;
+	zfs_stat_t	zc_stat;
+	uint64_t	zc_zoneid;
+} zfs_cmd_t;
+
+typedef struct zfs_useracct {
+	char zu_domain[256];
+	uid_t zu_rid;
+	uint32_t zu_pad;
+	uint64_t zu_space;
+} zfs_useracct_t;
+
+#define	ZFSDEV_MAX_MINOR	(1 << 16)
+#define	ZFS_MIN_MINOR	(ZFSDEV_MAX_MINOR + 1)
+
+#define	ZPOOL_EXPORT_AFTER_SPLIT 0x1
+
+#ifdef _KERNEL
+struct objset;
+struct zfsvfs;
+
+typedef struct zfs_creat {
+	nvlist_t	*zct_zplprops;
+	nvlist_t	*zct_props;
+} zfs_creat_t;
+
+extern int zfs_secpolicy_snapshot_perms(const char *, cred_t *);
+extern int zfs_secpolicy_rename_perms(const char *, const char *, cred_t *);
+extern int zfs_secpolicy_destroy_perms(const char *, cred_t *);
+extern void zfs_unmount_snap(const char *);
+extern void zfs_destroy_unmount_origin(const char *);
+extern int getzfsvfs_impl(struct objset *, struct zfsvfs **);
+extern int getzfsvfs(const char *, struct zfsvfs **);
+
+enum zfsdev_state_type {
+	ZST_ONEXIT,
+	ZST_ZEVENT,
+	ZST_ALL,
+};
+
+/*
+ * The zfsdev_state_t structure is managed as a singly-linked list
+ * from which items are never deleted.  This allows for lock-free
+ * reading of the list so long as assignments to the zs_next and
+ * reads from zs_minor are performed atomically.  Empty items are
+ * indicated by storing -1 into zs_minor.
+ */
+typedef struct zfsdev_state {
+	struct zfsdev_state	*zs_next;	/* next zfsdev_state_t link */
+	minor_t			zs_minor;	/* made up minor number */
+	void			*zs_onexit;	/* onexit data */
+	void			*zs_zevent;	/* zevent data */
+} zfsdev_state_t;
+
+extern void *zfsdev_get_state(minor_t minor, enum zfsdev_state_type which);
+extern int zfsdev_getminor(int fd, minor_t *minorp);
+extern minor_t zfsdev_minor_alloc(void);
+
+extern uint_t zfs_fsyncer_key;
+extern uint_t zfs_allow_log_key;
+
+#endif	/* _KERNEL */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZFS_IOCTL_H */
diff --git a/include/sys/zfs_ioctl_impl.h b/include/sys/zfs_ioctl_impl.h
new file mode 100644
index 0000000000000..787475cf396c2
--- /dev/null
+++ b/include/sys/zfs_ioctl_impl.h
@@ -0,0 +1,97 @@
+/*
+ * 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
+ */
+
+
+#ifndef _ZFS_IOCTL_IMPL_H_
+#define	_ZFS_IOCTL_IMPL_H_
+
+extern kmutex_t zfsdev_state_lock;
+extern zfsdev_state_t *zfsdev_state_list;
+extern unsigned long zfs_max_nvlist_src_size;
+
+typedef int zfs_ioc_legacy_func_t(zfs_cmd_t *);
+typedef int zfs_ioc_func_t(const char *, nvlist_t *, nvlist_t *);
+typedef int zfs_secpolicy_func_t(zfs_cmd_t *, nvlist_t *, cred_t *);
+
+typedef enum {
+	POOL_CHECK_NONE		= 1 << 0,
+	POOL_CHECK_SUSPENDED	= 1 << 1,
+	POOL_CHECK_READONLY	= 1 << 2,
+} zfs_ioc_poolcheck_t;
+
+typedef enum {
+	NO_NAME,
+	POOL_NAME,
+	DATASET_NAME,
+	ENTITY_NAME
+} zfs_ioc_namecheck_t;
+
+/*
+ * IOC Keys are used to document and validate user->kernel interface inputs.
+ * See zfs_keys_recv_new for an example declaration. Any key name that is not
+ * listed will be rejected as input.
+ *
+ * The keyname 'optional' is always allowed, and must be an nvlist if present.
+ * Arguments which older kernels can safely ignore can be placed under the
+ * "optional" key.
+ *
+ * When adding new keys to an existing ioc for new functionality, consider:
+ *	- adding an entry into zfs_sysfs.c zfs_features[] list
+ *	- updating the libzfs_input_check.c test utility
+ *
+ * Note: in the ZK_WILDCARDLIST case, the name serves as documentation
+ * for the expected name (bookmark, snapshot, property, etc) but there
+ * is no validation in the preflight zfs_check_input_nvpairs() check.
+ */
+typedef enum {
+	ZK_OPTIONAL = 1 << 0,		/* pair is optional */
+	ZK_WILDCARDLIST = 1 << 1,	/* one or more unspecified key names */
+} ioc_key_flag_t;
+
+typedef struct zfs_ioc_key {
+	const char	*zkey_name;
+	data_type_t	zkey_type;
+	ioc_key_flag_t	zkey_flags;
+} zfs_ioc_key_t;
+
+int zfs_secpolicy_config(zfs_cmd_t *, nvlist_t *, cred_t *);
+
+void zfs_ioctl_register_dataset_nolog(zfs_ioc_t, zfs_ioc_legacy_func_t *,
+    zfs_secpolicy_func_t *, zfs_ioc_poolcheck_t);
+
+void zfs_ioctl_register(const char *, zfs_ioc_t, zfs_ioc_func_t *,
+    zfs_secpolicy_func_t *, zfs_ioc_namecheck_t, zfs_ioc_poolcheck_t,
+    boolean_t, boolean_t, const zfs_ioc_key_t *, size_t);
+
+uint64_t zfs_max_nvlist_src_size_os(void);
+void zfs_ioctl_init_os(void);
+
+boolean_t zfs_vfs_held(zfsvfs_t *);
+int zfs_vfs_ref(zfsvfs_t **);
+void zfs_vfs_rele(zfsvfs_t *);
+
+long zfsdev_ioctl_common(uint_t, zfs_cmd_t *, int);
+int zfsdev_attach(void);
+void zfsdev_detach(void);
+int zfs_kmod_init(void);
+void zfs_kmod_fini(void);
+
+#endif
diff --git a/include/sys/zfs_onexit.h b/include/sys/zfs_onexit.h
new file mode 100644
index 0000000000000..0fab23ff849b5
--- /dev/null
+++ b/include/sys/zfs_onexit.h
@@ -0,0 +1,63 @@
+/*
+ * 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) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_ZFS_ONEXIT_H
+#define	_SYS_ZFS_ONEXIT_H
+
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifdef _KERNEL
+
+typedef struct zfs_onexit {
+	kmutex_t	zo_lock;
+	list_t		zo_actions;
+} zfs_onexit_t;
+
+typedef struct zfs_onexit_action_node {
+	list_node_t	za_link;
+	void		(*za_func)(void *);
+	void		*za_data;
+} zfs_onexit_action_node_t;
+
+extern void zfs_onexit_init(zfs_onexit_t **zo);
+extern void zfs_onexit_destroy(zfs_onexit_t *zo);
+
+#endif
+
+extern int zfs_onexit_fd_hold(int fd, minor_t *minorp);
+extern void zfs_onexit_fd_rele(int fd);
+extern int zfs_onexit_add_cb(minor_t minor, void (*func)(void *), void *data,
+    uint64_t *action_handle);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZFS_ONEXIT_H */
diff --git a/include/sys/zfs_project.h b/include/sys/zfs_project.h
new file mode 100644
index 0000000000000..81a238905225d
--- /dev/null
+++ b/include/sys/zfs_project.h
@@ -0,0 +1,83 @@
+/*
+ * 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) 2017, Intel Corporation. All rights reserved.
+ */
+
+#ifndef	_SYS_ZFS_PROJECT_H
+#define	_SYS_ZFS_PROJECT_H
+
+#ifndef _KERNEL
+#ifndef _SYS_MOUNT_H
+/* XXX: some hack to avoid include sys/mount.h */
+#define	_SYS_MOUNT_H
+#endif
+#endif
+
+#include <sys/vfs.h>
+
+#ifdef FS_PROJINHERIT_FL
+#define	ZFS_PROJINHERIT_FL	FS_PROJINHERIT_FL
+#else
+#define	ZFS_PROJINHERIT_FL	0x20000000
+#endif
+
+#ifdef FS_IOC_FSGETXATTR
+typedef struct fsxattr zfsxattr_t;
+
+#define	ZFS_IOC_FSGETXATTR	FS_IOC_FSGETXATTR
+#define	ZFS_IOC_FSSETXATTR	FS_IOC_FSSETXATTR
+#else
+struct zfsxattr {
+	uint32_t	fsx_xflags;	/* xflags field value (get/set) */
+	uint32_t	fsx_extsize;	/* extsize field value (get/set) */
+	uint32_t	fsx_nextents;	/* nextents field value (get)   */
+	uint32_t	fsx_projid;	/* project identifier (get/set) */
+	uint32_t	fsx_cowextsize;
+	unsigned char	fsx_pad[8];
+};
+typedef struct zfsxattr zfsxattr_t;
+
+#define	ZFS_IOC_FSGETXATTR	_IOR('X', 31, zfsxattr_t)
+#define	ZFS_IOC_FSSETXATTR	_IOW('X', 32, zfsxattr_t)
+#endif
+
+#define	ZFS_DEFAULT_PROJID	(0ULL)
+/*
+ * It is NOT ondisk project ID value. Just means either the object has
+ * no project ID or the operation does not touch project ID attribute.
+ */
+#define	ZFS_INVALID_PROJID	(-1ULL)
+
+static inline boolean_t
+zpl_is_valid_projid(uint32_t projid)
+{
+	/*
+	 * zfsxattr::fsx_projid is 32-bits, when convert to uint64_t,
+	 * the higher 32-bits will be set as zero, so cannot directly
+	 * compare with ZFS_INVALID_PROJID (-1ULL)
+	 */
+	if ((uint32_t)ZFS_INVALID_PROJID == projid)
+		return (B_FALSE);
+	return (B_TRUE);
+}
+
+#endif	/* _SYS_ZFS_PROJECT_H */
diff --git a/include/sys/zfs_quota.h b/include/sys/zfs_quota.h
new file mode 100644
index 0000000000000..b215b8dd00131
--- /dev/null
+++ b/include/sys/zfs_quota.h
@@ -0,0 +1,45 @@
+/*
+ * 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
+ */
+
+#ifndef _SYS_ZFS_QUOTA_H
+#define	_SYS_ZFS_QUOTA_H
+
+#include <sys/dmu.h>
+#include <sys/fs/zfs.h>
+
+struct zfsvfs;
+struct zfs_file_info_t;
+
+extern int zpl_get_file_info(dmu_object_type_t,
+    const void *, struct zfs_file_info *);
+
+extern int zfs_userspace_one(struct zfsvfs *, zfs_userquota_prop_t,
+    const char *, uint64_t, uint64_t *);
+extern int zfs_userspace_many(struct zfsvfs *, zfs_userquota_prop_t,
+    uint64_t *, void *, uint64_t *);
+extern int zfs_set_userquota(struct zfsvfs *, zfs_userquota_prop_t,
+    const char *, uint64_t, uint64_t);
+
+extern boolean_t zfs_id_overobjquota(struct zfsvfs *, uint64_t, uint64_t);
+extern boolean_t zfs_id_overblockquota(struct zfsvfs *, uint64_t, uint64_t);
+extern boolean_t zfs_id_overquota(struct zfsvfs *, uint64_t, uint64_t);
+
+#endif
diff --git a/include/sys/zfs_ratelimit.h b/include/sys/zfs_ratelimit.h
new file mode 100644
index 0000000000000..012825fadb223
--- /dev/null
+++ b/include/sys/zfs_ratelimit.h
@@ -0,0 +1,44 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2016, Lawrence Livermore National Security, LLC.
+ */
+
+#ifndef _SYS_ZFS_RATELIMIT_H
+#define	_SYS_ZFS_RATELIMIT_H
+
+#include <sys/zfs_context.h>
+
+typedef struct {
+	hrtime_t start;
+	unsigned int count;
+
+	/*
+	 * Pointer to number of events per interval.  We do this to
+	 * allow the burst to be a (changeable) module parameter.
+	 */
+	unsigned int *burst;
+
+	unsigned int interval;	/* Interval length in seconds */
+	kmutex_t lock;
+} zfs_ratelimit_t;
+
+int zfs_ratelimit(zfs_ratelimit_t *rl);
+void zfs_ratelimit_init(zfs_ratelimit_t *rl, unsigned int *burst,
+    unsigned int interval);
+void zfs_ratelimit_fini(zfs_ratelimit_t *rl);
+
+#endif	/* _SYS_ZFS_RATELIMIT_H */
diff --git a/include/sys/zfs_refcount.h b/include/sys/zfs_refcount.h
new file mode 100644
index 0000000000000..fc0cbea1cf7c7
--- /dev/null
+++ b/include/sys/zfs_refcount.h
@@ -0,0 +1,126 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2015 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_ZFS_REFCOUNT_H
+#define	_SYS_ZFS_REFCOUNT_H
+
+#include <sys/inttypes.h>
+#include <sys/list.h>
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * If the reference is held only by the calling function and not any
+ * particular object, use FTAG (which is a string) for the holder_tag.
+ * Otherwise, use the object that holds the reference.
+ */
+#define	FTAG ((char *)(uintptr_t)__func__)
+
+#ifdef	ZFS_DEBUG
+typedef struct reference {
+	list_node_t ref_link;
+	const void *ref_holder;
+	uint64_t ref_number;
+	uint8_t *ref_removed;
+} reference_t;
+
+typedef struct refcount {
+	kmutex_t rc_mtx;
+	boolean_t rc_tracked;
+	list_t rc_list;
+	list_t rc_removed;
+	uint64_t rc_count;
+	uint64_t rc_removed_count;
+} zfs_refcount_t;
+
+/*
+ * Note: zfs_refcount_t must be initialized with
+ * refcount_create[_untracked]()
+ */
+
+void zfs_refcount_create(zfs_refcount_t *);
+void zfs_refcount_create_untracked(zfs_refcount_t *);
+void zfs_refcount_create_tracked(zfs_refcount_t *);
+void zfs_refcount_destroy(zfs_refcount_t *);
+void zfs_refcount_destroy_many(zfs_refcount_t *, uint64_t);
+int zfs_refcount_is_zero(zfs_refcount_t *);
+int64_t zfs_refcount_count(zfs_refcount_t *);
+int64_t zfs_refcount_add(zfs_refcount_t *, const void *);
+int64_t zfs_refcount_remove(zfs_refcount_t *, const void *);
+int64_t zfs_refcount_add_many(zfs_refcount_t *, uint64_t, const void *);
+int64_t zfs_refcount_remove_many(zfs_refcount_t *, uint64_t, const void *);
+void zfs_refcount_transfer(zfs_refcount_t *, zfs_refcount_t *);
+void zfs_refcount_transfer_ownership(zfs_refcount_t *, const void *,
+    const void *);
+void zfs_refcount_transfer_ownership_many(zfs_refcount_t *, uint64_t,
+    const void *, const void *);
+boolean_t zfs_refcount_held(zfs_refcount_t *, const void *);
+boolean_t zfs_refcount_not_held(zfs_refcount_t *, const void *);
+
+void zfs_refcount_init(void);
+void zfs_refcount_fini(void);
+
+#else	/* ZFS_DEBUG */
+
+typedef struct refcount {
+	uint64_t rc_count;
+} zfs_refcount_t;
+
+#define	zfs_refcount_create(rc) ((rc)->rc_count = 0)
+#define	zfs_refcount_create_untracked(rc) ((rc)->rc_count = 0)
+#define	zfs_refcount_create_tracked(rc) ((rc)->rc_count = 0)
+#define	zfs_refcount_destroy(rc) ((rc)->rc_count = 0)
+#define	zfs_refcount_destroy_many(rc, number) ((rc)->rc_count = 0)
+#define	zfs_refcount_is_zero(rc) ((rc)->rc_count == 0)
+#define	zfs_refcount_count(rc) ((rc)->rc_count)
+#define	zfs_refcount_add(rc, holder) atomic_inc_64_nv(&(rc)->rc_count)
+#define	zfs_refcount_remove(rc, holder) atomic_dec_64_nv(&(rc)->rc_count)
+#define	zfs_refcount_add_many(rc, number, holder) \
+	atomic_add_64_nv(&(rc)->rc_count, number)
+#define	zfs_refcount_remove_many(rc, number, holder) \
+	atomic_add_64_nv(&(rc)->rc_count, -number)
+#define	zfs_refcount_transfer(dst, src) { \
+	uint64_t __tmp = (src)->rc_count; \
+	atomic_add_64(&(src)->rc_count, -__tmp); \
+	atomic_add_64(&(dst)->rc_count, __tmp); \
+}
+#define	zfs_refcount_transfer_ownership(rc, ch, nh)		((void)0)
+#define	zfs_refcount_transfer_ownership_many(rc, nr, ch, nh)	((void)0)
+#define	zfs_refcount_held(rc, holder)			((rc)->rc_count > 0)
+#define	zfs_refcount_not_held(rc, holder)		(B_TRUE)
+
+#define	zfs_refcount_init()
+#define	zfs_refcount_fini()
+
+#endif	/* ZFS_DEBUG */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_REFCOUNT_H */
diff --git a/include/sys/zfs_rlock.h b/include/sys/zfs_rlock.h
new file mode 100644
index 0000000000000..2302abb37337b
--- /dev/null
+++ b/include/sys/zfs_rlock.h
@@ -0,0 +1,83 @@
+/*
+ * 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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*
+ * Copyright (c) 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_FS_ZFS_RLOCK_H
+#define	_SYS_FS_ZFS_RLOCK_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <sys/avl.h>
+
+typedef enum {
+	RL_READER,
+	RL_WRITER,
+	RL_APPEND
+} zfs_rangelock_type_t;
+
+struct zfs_locked_range;
+
+typedef void (zfs_rangelock_cb_t)(struct zfs_locked_range *, void *);
+
+typedef struct zfs_rangelock {
+	avl_tree_t rl_tree; /* contains locked_range_t */
+	kmutex_t rl_lock;
+	zfs_rangelock_cb_t *rl_cb;
+	void *rl_arg;
+} zfs_rangelock_t;
+
+typedef struct zfs_locked_range {
+	zfs_rangelock_t *lr_rangelock; /* rangelock that this lock applies to */
+	avl_node_t lr_node;	/* avl node link */
+	uint64_t lr_offset;	/* file range offset */
+	uint64_t lr_length;	/* file range length */
+	uint_t lr_count;	/* range reference count in tree */
+	zfs_rangelock_type_t lr_type; /* range type */
+	kcondvar_t lr_write_cv;	/* cv for waiting writers */
+	kcondvar_t lr_read_cv;	/* cv for waiting readers */
+	uint8_t lr_proxy;	/* acting for original range */
+	uint8_t lr_write_wanted; /* writer wants to lock this range */
+	uint8_t lr_read_wanted;	/* reader wants to lock this range */
+} zfs_locked_range_t;
+
+void zfs_rangelock_init(zfs_rangelock_t *, zfs_rangelock_cb_t *, void *);
+void zfs_rangelock_fini(zfs_rangelock_t *);
+
+zfs_locked_range_t *zfs_rangelock_enter(zfs_rangelock_t *,
+    uint64_t, uint64_t, zfs_rangelock_type_t);
+zfs_locked_range_t *zfs_rangelock_tryenter(zfs_rangelock_t *,
+    uint64_t, uint64_t, zfs_rangelock_type_t);
+void zfs_rangelock_exit(zfs_locked_range_t *);
+void zfs_rangelock_reduce(zfs_locked_range_t *, uint64_t, uint64_t);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_FS_ZFS_RLOCK_H */
diff --git a/include/sys/zfs_sa.h b/include/sys/zfs_sa.h
new file mode 100644
index 0000000000000..4e6d28638ef68
--- /dev/null
+++ b/include/sys/zfs_sa.h
@@ -0,0 +1,153 @@
+/*
+ * 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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_ZFS_SA_H
+#define	_SYS_ZFS_SA_H
+
+#ifdef _KERNEL
+#include <sys/types32.h>
+#include <sys/list.h>
+#include <sys/dmu.h>
+#include <sys/zfs_acl.h>
+#include <sys/zfs_znode.h>
+#include <sys/sa.h>
+#include <sys/zil.h>
+
+
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * This is the list of known attributes
+ * to the ZPL.  The values of the actual
+ * attributes are not defined by the order
+ * the enums.  It is controlled by the attribute
+ * registration mechanism.  Two different file system
+ * could have different numeric values for the same
+ * attributes.  this list is only used for dereferencing
+ * into the table that will hold the actual numeric value.
+ */
+typedef enum zpl_attr {
+	ZPL_ATIME,
+	ZPL_MTIME,
+	ZPL_CTIME,
+	ZPL_CRTIME,
+	ZPL_GEN,
+	ZPL_MODE,
+	ZPL_SIZE,
+	ZPL_PARENT,
+	ZPL_LINKS,
+	ZPL_XATTR,
+	ZPL_RDEV,
+	ZPL_FLAGS,
+	ZPL_UID,
+	ZPL_GID,
+	ZPL_PAD,
+	ZPL_ZNODE_ACL,
+	ZPL_DACL_COUNT,
+	ZPL_SYMLINK,
+	ZPL_SCANSTAMP,
+	ZPL_DACL_ACES,
+	ZPL_DXATTR,
+	ZPL_PROJID,
+	ZPL_END
+} zpl_attr_t;
+
+#define	ZFS_OLD_ZNODE_PHYS_SIZE	0x108
+#define	ZFS_SA_BASE_ATTR_SIZE	(ZFS_OLD_ZNODE_PHYS_SIZE - \
+    sizeof (zfs_acl_phys_t))
+
+#define	SA_MODE_OFFSET		0
+#define	SA_SIZE_OFFSET		8
+#define	SA_GEN_OFFSET		16
+#define	SA_UID_OFFSET		24
+#define	SA_GID_OFFSET		32
+#define	SA_PARENT_OFFSET	40
+#define	SA_FLAGS_OFFSET		48
+#define	SA_PROJID_OFFSET	128
+
+extern sa_attr_reg_t zfs_attr_table[ZPL_END + 1];
+extern sa_attr_reg_t zfs_legacy_attr_table[ZPL_END + 1];
+
+/*
+ * This is a deprecated data structure that only exists for
+ * dealing with file systems create prior to ZPL version 5.
+ */
+typedef struct znode_phys {
+	uint64_t zp_atime[2];		/*  0 - last file access time */
+	uint64_t zp_mtime[2];		/* 16 - last file modification time */
+	uint64_t zp_ctime[2];		/* 32 - last file change time */
+	uint64_t zp_crtime[2];		/* 48 - creation time */
+	uint64_t zp_gen;		/* 64 - generation (txg of creation) */
+	uint64_t zp_mode;		/* 72 - file mode bits */
+	uint64_t zp_size;		/* 80 - size of file */
+	uint64_t zp_parent;		/* 88 - directory parent (`..') */
+	uint64_t zp_links;		/* 96 - number of links to file */
+	uint64_t zp_xattr;		/* 104 - DMU object for xattrs */
+	uint64_t zp_rdev;		/* 112 - dev_t for VBLK & VCHR files */
+	uint64_t zp_flags;		/* 120 - persistent flags */
+	uint64_t zp_uid;		/* 128 - file owner */
+	uint64_t zp_gid;		/* 136 - owning group */
+	uint64_t zp_zap;		/* 144 - extra attributes */
+	uint64_t zp_pad[3];		/* 152 - future */
+	zfs_acl_phys_t zp_acl;		/* 176 - 263 ACL */
+	/*
+	 * Data may pad out any remaining bytes in the znode buffer, eg:
+	 *
+	 * |<---------------------- dnode_phys (512) ------------------------>|
+	 * |<-- dnode (192) --->|<----------- "bonus" buffer (320) ---------->|
+	 *			|<---- znode (264) ---->|<---- data (56) ---->|
+	 *
+	 * At present, we use this space for the following:
+	 *  - symbolic links
+	 *  - 32-byte anti-virus scanstamp (regular files only)
+	 */
+} znode_phys_t;
+
+#ifdef _KERNEL
+
+#define	DXATTR_MAX_ENTRY_SIZE	(32768)
+#define	DXATTR_MAX_SA_SIZE	(SPA_OLD_MAXBLOCKSIZE >> 1)
+
+int zfs_sa_readlink(struct znode *, uio_t *);
+void zfs_sa_symlink(struct znode *, char *link, int len, dmu_tx_t *);
+void zfs_sa_get_scanstamp(struct znode *, xvattr_t *);
+void zfs_sa_set_scanstamp(struct znode *, xvattr_t *, dmu_tx_t *);
+int zfs_sa_get_xattr(struct znode *);
+int zfs_sa_set_xattr(struct znode *);
+void zfs_sa_upgrade(struct sa_handle  *, dmu_tx_t *);
+void zfs_sa_upgrade_txholds(dmu_tx_t *, struct znode *);
+void zfs_sa_init(void);
+void zfs_sa_fini(void);
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZFS_SA_H */
diff --git a/include/sys/zfs_stat.h b/include/sys/zfs_stat.h
new file mode 100644
index 0000000000000..465aefaa20632
--- /dev/null
+++ b/include/sys/zfs_stat.h
@@ -0,0 +1,56 @@
+/*
+ * 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) 2010, Oracle and/or its affiliates. All rights reserved.
+ */
+
+#ifndef	_SYS_FS_ZFS_STAT_H
+#define	_SYS_FS_ZFS_STAT_H
+
+#ifdef _KERNEL
+#include <sys/isa_defs.h>
+#include <sys/types32.h>
+#include <sys/dmu.h>
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * A limited number of zpl level stats are retrievable
+ * with an ioctl.  zfs diff is the current consumer.
+ */
+typedef struct zfs_stat {
+	uint64_t	zs_gen;
+	uint64_t	zs_mode;
+	uint64_t	zs_links;
+	uint64_t	zs_ctime[2];
+} zfs_stat_t;
+
+extern int zfs_obj_to_stats(objset_t *osp, uint64_t obj, zfs_stat_t *sb,
+    char *buf, int len);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_FS_ZFS_STAT_H */
diff --git a/include/sys/zfs_sysfs.h b/include/sys/zfs_sysfs.h
new file mode 100644
index 0000000000000..925d7ad542f7e
--- /dev/null
+++ b/include/sys/zfs_sysfs.h
@@ -0,0 +1,50 @@
+/*
+ * 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) 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_ZFS_SYSFS_H
+#define	_SYS_ZFS_SYSFS_H
+
+#ifdef _KERNEL
+
+void zfs_sysfs_init(void);
+void zfs_sysfs_fini(void);
+
+#else
+
+#define	zfs_sysfs_init()
+#define	zfs_sysfs_fini()
+
+boolean_t zfs_mod_supported(const char *, const char *);
+#endif
+
+#define	ZFS_SYSFS_POOL_PROPERTIES	"properties.pool"
+#define	ZFS_SYSFS_DATASET_PROPERTIES	"properties.dataset"
+#define	ZFS_SYSFS_KERNEL_FEATURES	"features.kernel"
+#define	ZFS_SYSFS_POOL_FEATURES		"features.pool"
+
+#define	ZFS_SYSFS_DIR			"/sys/module/zfs"
+/* Alternate location when ZFS is built as part of the kernel (rare) */
+#define	ZFS_SYSFS_ALT_DIR		"/sys/fs/zfs"
+
+#endif	/* _SYS_ZFS_SYSFS_H */
diff --git a/include/sys/zfs_znode.h b/include/sys/zfs_znode.h
new file mode 100644
index 0000000000000..d7823221eb779
--- /dev/null
+++ b/include/sys/zfs_znode.h
@@ -0,0 +1,295 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright 2016 Nexenta Systems, Inc. All rights reserved.
+ */
+
+#ifndef	_SYS_FS_ZFS_ZNODE_H
+#define	_SYS_FS_ZFS_ZNODE_H
+
+#include <sys/zfs_acl.h>
+#include <sys/zil.h>
+#include <sys/zfs_project.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Additional file level attributes, that are stored
+ * in the upper half of zp_flags
+ */
+#define	ZFS_READONLY		0x0000000100000000ull
+#define	ZFS_HIDDEN		0x0000000200000000ull
+#define	ZFS_SYSTEM		0x0000000400000000ull
+#define	ZFS_ARCHIVE		0x0000000800000000ull
+#define	ZFS_IMMUTABLE		0x0000001000000000ull
+#define	ZFS_NOUNLINK		0x0000002000000000ull
+#define	ZFS_APPENDONLY		0x0000004000000000ull
+#define	ZFS_NODUMP		0x0000008000000000ull
+#define	ZFS_OPAQUE		0x0000010000000000ull
+#define	ZFS_AV_QUARANTINED	0x0000020000000000ull
+#define	ZFS_AV_MODIFIED		0x0000040000000000ull
+#define	ZFS_REPARSE		0x0000080000000000ull
+#define	ZFS_OFFLINE		0x0000100000000000ull
+#define	ZFS_SPARSE		0x0000200000000000ull
+
+/*
+ * PROJINHERIT attribute is used to indicate that the child object under the
+ * directory which has the PROJINHERIT attribute needs to inherit its parent
+ * project ID that is used by project quota.
+ */
+#define	ZFS_PROJINHERIT		0x0000400000000000ull
+
+/*
+ * PROJID attr is used internally to indicate that the object has project ID.
+ */
+#define	ZFS_PROJID		0x0000800000000000ull
+
+#define	ZFS_ATTR_SET(zp, attr, value, pflags, tx) \
+{ \
+	if (value) \
+		pflags |= attr; \
+	else \
+		pflags &= ~attr; \
+	VERIFY(0 == sa_update(zp->z_sa_hdl, SA_ZPL_FLAGS(ZTOZSB(zp)), \
+	    &pflags, sizeof (pflags), tx)); \
+}
+
+/*
+ * Define special zfs pflags
+ */
+#define	ZFS_XATTR		0x1		/* is an extended attribute */
+#define	ZFS_INHERIT_ACE		0x2		/* ace has inheritable ACEs */
+#define	ZFS_ACL_TRIVIAL		0x4		/* files ACL is trivial */
+#define	ZFS_ACL_OBJ_ACE		0x8		/* ACL has CMPLX Object ACE */
+#define	ZFS_ACL_PROTECTED	0x10		/* ACL protected */
+#define	ZFS_ACL_DEFAULTED	0x20		/* ACL should be defaulted */
+#define	ZFS_ACL_AUTO_INHERIT	0x40		/* ACL should be inherited */
+#define	ZFS_BONUS_SCANSTAMP	0x80		/* Scanstamp in bonus area */
+#define	ZFS_NO_EXECS_DENIED	0x100		/* exec was given to everyone */
+
+#define	SA_ZPL_ATIME(z)		z->z_attr_table[ZPL_ATIME]
+#define	SA_ZPL_MTIME(z)		z->z_attr_table[ZPL_MTIME]
+#define	SA_ZPL_CTIME(z)		z->z_attr_table[ZPL_CTIME]
+#define	SA_ZPL_CRTIME(z)	z->z_attr_table[ZPL_CRTIME]
+#define	SA_ZPL_GEN(z)		z->z_attr_table[ZPL_GEN]
+#define	SA_ZPL_DACL_ACES(z)	z->z_attr_table[ZPL_DACL_ACES]
+#define	SA_ZPL_XATTR(z)		z->z_attr_table[ZPL_XATTR]
+#define	SA_ZPL_SYMLINK(z)	z->z_attr_table[ZPL_SYMLINK]
+#define	SA_ZPL_RDEV(z)		z->z_attr_table[ZPL_RDEV]
+#define	SA_ZPL_SCANSTAMP(z)	z->z_attr_table[ZPL_SCANSTAMP]
+#define	SA_ZPL_UID(z)		z->z_attr_table[ZPL_UID]
+#define	SA_ZPL_GID(z)		z->z_attr_table[ZPL_GID]
+#define	SA_ZPL_PARENT(z)	z->z_attr_table[ZPL_PARENT]
+#define	SA_ZPL_LINKS(z)		z->z_attr_table[ZPL_LINKS]
+#define	SA_ZPL_MODE(z)		z->z_attr_table[ZPL_MODE]
+#define	SA_ZPL_DACL_COUNT(z)	z->z_attr_table[ZPL_DACL_COUNT]
+#define	SA_ZPL_FLAGS(z)		z->z_attr_table[ZPL_FLAGS]
+#define	SA_ZPL_SIZE(z)		z->z_attr_table[ZPL_SIZE]
+#define	SA_ZPL_ZNODE_ACL(z)	z->z_attr_table[ZPL_ZNODE_ACL]
+#define	SA_ZPL_DXATTR(z)	z->z_attr_table[ZPL_DXATTR]
+#define	SA_ZPL_PAD(z)		z->z_attr_table[ZPL_PAD]
+#define	SA_ZPL_PROJID(z)	z->z_attr_table[ZPL_PROJID]
+
+/*
+ * Is ID ephemeral?
+ */
+#define	IS_EPHEMERAL(x)		(x > MAXUID)
+
+/*
+ * Should we use FUIDs?
+ */
+#define	USE_FUIDS(version, os)	(version >= ZPL_VERSION_FUID && \
+    spa_version(dmu_objset_spa(os)) >= SPA_VERSION_FUID)
+#define	USE_SA(version, os) (version >= ZPL_VERSION_SA && \
+    spa_version(dmu_objset_spa(os)) >= SPA_VERSION_SA)
+
+#define	MASTER_NODE_OBJ	1
+
+/*
+ * Special attributes for master node.
+ * "userquota@", "groupquota@" and "projectquota@" are also valid (from
+ * zfs_userquota_prop_prefixes[]).
+ */
+#define	ZFS_FSID		"FSID"
+#define	ZFS_UNLINKED_SET	"DELETE_QUEUE"
+#define	ZFS_ROOT_OBJ		"ROOT"
+#define	ZPL_VERSION_STR		"VERSION"
+#define	ZFS_FUID_TABLES		"FUID"
+#define	ZFS_SHARES_DIR		"SHARES"
+#define	ZFS_SA_ATTRS		"SA_ATTRS"
+
+/*
+ * Convert mode bits (zp_mode) to BSD-style DT_* values for storing in
+ * the directory entries.  On Linux systems this value is already
+ * defined correctly as part of the /usr/include/dirent.h header file.
+ */
+#ifndef IFTODT
+#define	IFTODT(mode) (((mode) & S_IFMT) >> 12)
+#endif
+
+/*
+ * The directory entry has the type (currently unused on Solaris) in the
+ * top 4 bits, and the object number in the low 48 bits.  The "middle"
+ * 12 bits are unused.
+ */
+#define	ZFS_DIRENT_TYPE(de) BF64_GET(de, 60, 4)
+#define	ZFS_DIRENT_OBJ(de) BF64_GET(de, 0, 48)
+
+extern int zfs_obj_to_path(objset_t *osp, uint64_t obj, char *buf, int len);
+
+#ifdef _KERNEL
+#include <sys/zfs_znode_impl.h>
+
+/*
+ * Directory entry locks control access to directory entries.
+ * They are used to protect creates, deletes, and renames.
+ * Each directory znode has a mutex and a list of locked names.
+ */
+typedef struct zfs_dirlock {
+	char		*dl_name;	/* directory entry being locked */
+	uint32_t	dl_sharecnt;	/* 0 if exclusive, > 0 if shared */
+	uint8_t		dl_namelock;	/* 1 if z_name_lock is NOT held */
+	uint16_t	dl_namesize;	/* set if dl_name was allocated */
+	kcondvar_t	dl_cv;		/* wait for entry to be unlocked */
+	struct znode	*dl_dzp;	/* directory znode */
+	struct zfs_dirlock *dl_next;	/* next in z_dirlocks list */
+} zfs_dirlock_t;
+
+typedef struct znode {
+	uint64_t	z_id;		/* object ID for this znode */
+	kmutex_t	z_lock;		/* znode modification lock */
+	krwlock_t	z_parent_lock;	/* parent lock for directories */
+	krwlock_t	z_name_lock;	/* "master" lock for dirent locks */
+	zfs_dirlock_t	*z_dirlocks;	/* directory entry lock list */
+	zfs_rangelock_t	z_rangelock;	/* file range locks */
+	boolean_t	z_unlinked;	/* file has been unlinked */
+	boolean_t	z_atime_dirty;	/* atime needs to be synced */
+	boolean_t	z_zn_prefetch;	/* Prefetch znodes? */
+	boolean_t	z_moved;	/* Has this znode been moved? */
+	boolean_t	z_is_sa;	/* are we native sa? */
+	boolean_t	z_is_mapped;	/* are we mmap'ed */
+	boolean_t	z_is_ctldir;	/* are we .zfs entry */
+	boolean_t	z_is_stale;	/* are we stale due to rollback? */
+	boolean_t	z_suspended;	/* extra ref from a suspend? */
+	uint_t		z_blksz;	/* block size in bytes */
+	uint_t		z_seq;		/* modification sequence number */
+	uint64_t	z_mapcnt;	/* number of pages mapped to file */
+	uint64_t	z_dnodesize;	/* dnode size */
+	uint64_t	z_size;		/* file size (cached) */
+	uint64_t	z_pflags;	/* pflags (cached) */
+	uint32_t	z_sync_cnt;	/* synchronous open count */
+	mode_t		z_mode;		/* mode (cached) */
+	kmutex_t	z_acl_lock;	/* acl data lock */
+	zfs_acl_t	*z_acl_cached;	/* cached acl */
+	krwlock_t	z_xattr_lock;	/* xattr data lock */
+	nvlist_t	*z_xattr_cached; /* cached xattrs */
+	uint64_t	z_xattr_parent;	/* parent obj for this xattr */
+	uint64_t	z_projid;	/* project ID */
+	list_node_t	z_link_node;	/* all znodes in fs link */
+	sa_handle_t	*z_sa_hdl;	/* handle to sa data */
+
+	/*
+	 * Platform specific field, defined by each platform and only
+	 * accessible from platform specific code.
+	 */
+	ZNODE_OS_FIELDS;
+} znode_t;
+
+typedef struct znode_hold {
+	uint64_t	zh_obj;		/* object id */
+	kmutex_t	zh_lock;	/* lock serializing object access */
+	avl_node_t	zh_node;	/* avl tree linkage */
+	zfs_refcount_t	zh_refcount;	/* active consumer reference count */
+} znode_hold_t;
+
+static inline uint64_t
+zfs_inherit_projid(znode_t *dzp)
+{
+	return ((dzp->z_pflags & ZFS_PROJINHERIT) ? dzp->z_projid :
+	    ZFS_DEFAULT_PROJID);
+}
+
+/*
+ * Timestamp defines
+ */
+#define	ACCESSED		(ATTR_ATIME)
+#define	STATE_CHANGED		(ATTR_CTIME)
+#define	CONTENT_MODIFIED	(ATTR_MTIME | ATTR_CTIME)
+
+extern int	zfs_init_fs(zfsvfs_t *, znode_t **);
+extern void	zfs_set_dataprop(objset_t *);
+extern void	zfs_create_fs(objset_t *os, cred_t *cr, nvlist_t *,
+    dmu_tx_t *tx);
+extern void	zfs_tstamp_update_setup(znode_t *, uint_t, uint64_t [2],
+    uint64_t [2]);
+extern void	zfs_grow_blocksize(znode_t *, uint64_t, dmu_tx_t *);
+extern int	zfs_freesp(znode_t *, uint64_t, uint64_t, int, boolean_t);
+extern void	zfs_znode_init(void);
+extern void	zfs_znode_fini(void);
+extern int	zfs_znode_hold_compare(const void *, const void *);
+extern int	zfs_zget(zfsvfs_t *, uint64_t, znode_t **);
+extern int	zfs_rezget(znode_t *);
+extern void	zfs_zinactive(znode_t *);
+extern void	zfs_znode_delete(znode_t *, dmu_tx_t *);
+extern void	zfs_remove_op_tables(void);
+extern int	zfs_create_op_tables(void);
+extern dev_t	zfs_cmpldev(uint64_t);
+extern int	zfs_get_zplprop(objset_t *os, zfs_prop_t prop, uint64_t *value);
+extern int	zfs_get_stats(objset_t *os, nvlist_t *nv);
+extern boolean_t zfs_get_vfs_flag_unmounted(objset_t *os);
+extern void	zfs_znode_dmu_fini(znode_t *);
+
+extern void zfs_log_create(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
+    znode_t *dzp, znode_t *zp, char *name, vsecattr_t *, zfs_fuid_info_t *,
+    vattr_t *vap);
+extern int zfs_log_create_txtype(zil_create_t, vsecattr_t *vsecp,
+    vattr_t *vap);
+extern void zfs_log_remove(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
+    znode_t *dzp, char *name, uint64_t foid, boolean_t unlinked);
+#define	ZFS_NO_OBJECT	0	/* no object id */
+extern void zfs_log_link(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
+    znode_t *dzp, znode_t *zp, char *name);
+extern void zfs_log_symlink(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
+    znode_t *dzp, znode_t *zp, char *name, char *link);
+extern void zfs_log_rename(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
+    znode_t *sdzp, char *sname, znode_t *tdzp, char *dname, znode_t *szp);
+extern void zfs_log_write(zilog_t *zilog, dmu_tx_t *tx, int txtype,
+    znode_t *zp, offset_t off, ssize_t len, int ioflag,
+    zil_callback_t callback, void *callback_data);
+extern void zfs_log_truncate(zilog_t *zilog, dmu_tx_t *tx, int txtype,
+    znode_t *zp, uint64_t off, uint64_t len);
+extern void zfs_log_setattr(zilog_t *zilog, dmu_tx_t *tx, int txtype,
+    znode_t *zp, vattr_t *vap, uint_t mask_applied, zfs_fuid_info_t *fuidp);
+extern void zfs_log_acl(zilog_t *zilog, dmu_tx_t *tx, znode_t *zp,
+    vsecattr_t *vsecp, zfs_fuid_info_t *fuidp);
+extern void zfs_xvattr_set(znode_t *zp, xvattr_t *xvap, dmu_tx_t *tx);
+extern void zfs_upgrade(zfsvfs_t *zfsvfs, dmu_tx_t *tx);
+
+#endif
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_FS_ZFS_ZNODE_H */
diff --git a/include/sys/zil.h b/include/sys/zil.h
new file mode 100644
index 0000000000000..7e61a13301c0c
--- /dev/null
+++ b/include/sys/zil.h
@@ -0,0 +1,529 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ */
+
+/* Portions Copyright 2010 Robert Milkowski */
+
+#ifndef	_SYS_ZIL_H
+#define	_SYS_ZIL_H
+
+#include <sys/types.h>
+#include <sys/spa.h>
+#include <sys/zio.h>
+#include <sys/dmu.h>
+#include <sys/zio_crypt.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct dsl_pool;
+struct dsl_dataset;
+struct lwb;
+
+/*
+ * Intent log format:
+ *
+ * Each objset has its own intent log.  The log header (zil_header_t)
+ * for objset N's intent log is kept in the Nth object of the SPA's
+ * intent_log objset.  The log header points to a chain of log blocks,
+ * each of which contains log records (i.e., transactions) followed by
+ * a log block trailer (zil_trailer_t).  The format of a log record
+ * depends on the record (or transaction) type, but all records begin
+ * with a common structure that defines the type, length, and txg.
+ */
+
+/*
+ * Intent log header - this on disk structure holds fields to manage
+ * the log.  All fields are 64 bit to easily handle cross architectures.
+ */
+typedef struct zil_header {
+	uint64_t zh_claim_txg;	/* txg in which log blocks were claimed */
+	uint64_t zh_replay_seq;	/* highest replayed sequence number */
+	blkptr_t zh_log;	/* log chain */
+	uint64_t zh_claim_blk_seq; /* highest claimed block sequence number */
+	uint64_t zh_flags;	/* header flags */
+	uint64_t zh_claim_lr_seq; /* highest claimed lr sequence number */
+	uint64_t zh_pad[3];
+} zil_header_t;
+
+/*
+ * zh_flags bit settings
+ */
+#define	ZIL_REPLAY_NEEDED	0x1	/* replay needed - internal only */
+#define	ZIL_CLAIM_LR_SEQ_VALID	0x2	/* zh_claim_lr_seq field is valid */
+
+/*
+ * Log block chaining.
+ *
+ * Log blocks are chained together. Originally they were chained at the
+ * end of the block. For performance reasons the chain was moved to the
+ * beginning of the block which allows writes for only the data being used.
+ * The older position is supported for backwards compatibility.
+ *
+ * The zio_eck_t contains a zec_cksum which for the intent log is
+ * the sequence number of this log block. A seq of 0 is invalid.
+ * The zec_cksum is checked by the SPA against the sequence
+ * number passed in the blk_cksum field of the blkptr_t
+ */
+typedef struct zil_chain {
+	uint64_t zc_pad;
+	blkptr_t zc_next_blk;	/* next block in chain */
+	uint64_t zc_nused;	/* bytes in log block used */
+	zio_eck_t zc_eck;	/* block trailer */
+} zil_chain_t;
+
+#define	ZIL_MIN_BLKSZ	4096ULL
+
+/*
+ * ziltest is by and large an ugly hack, but very useful in
+ * checking replay without tedious work.
+ * When running ziltest we want to keep all itx's and so maintain
+ * a single list in the zl_itxg[] that uses a high txg: ZILTEST_TXG
+ * We subtract TXG_CONCURRENT_STATES to allow for common code.
+ */
+#define	ZILTEST_TXG (UINT64_MAX - TXG_CONCURRENT_STATES)
+
+/*
+ * The words of a log block checksum.
+ */
+#define	ZIL_ZC_GUID_0	0
+#define	ZIL_ZC_GUID_1	1
+#define	ZIL_ZC_OBJSET	2
+#define	ZIL_ZC_SEQ	3
+
+typedef enum zil_create {
+	Z_FILE,
+	Z_DIR,
+	Z_XATTRDIR,
+} zil_create_t;
+
+/*
+ * size of xvattr log section.
+ * its composed of lr_attr_t + xvattr bitmap + 2 64 bit timestamps
+ * for create time and a single 64 bit integer for all of the attributes,
+ * and 4 64 bit integers (32 bytes) for the scanstamp.
+ *
+ */
+
+#define	ZIL_XVAT_SIZE(mapsize) \
+	sizeof (lr_attr_t) + (sizeof (uint32_t) * (mapsize - 1)) + \
+	(sizeof (uint64_t) * 7)
+
+/*
+ * Size of ACL in log.  The ACE data is padded out to properly align
+ * on 8 byte boundary.
+ */
+
+#define	ZIL_ACE_LENGTH(x)	(roundup(x, sizeof (uint64_t)))
+
+/*
+ * Intent log transaction types and record structures
+ */
+#define	TX_COMMIT		0	/* Commit marker (no on-disk state) */
+#define	TX_CREATE		1	/* Create file */
+#define	TX_MKDIR		2	/* Make directory */
+#define	TX_MKXATTR		3	/* Make XATTR directory */
+#define	TX_SYMLINK		4	/* Create symbolic link to a file */
+#define	TX_REMOVE		5	/* Remove file */
+#define	TX_RMDIR		6	/* Remove directory */
+#define	TX_LINK			7	/* Create hard link to a file */
+#define	TX_RENAME		8	/* Rename a file */
+#define	TX_WRITE		9	/* File write */
+#define	TX_TRUNCATE		10	/* Truncate a file */
+#define	TX_SETATTR		11	/* Set file attributes */
+#define	TX_ACL_V0		12	/* Set old formatted ACL */
+#define	TX_ACL			13	/* Set ACL */
+#define	TX_CREATE_ACL		14	/* create with ACL */
+#define	TX_CREATE_ATTR		15	/* create + attrs */
+#define	TX_CREATE_ACL_ATTR 	16	/* create with ACL + attrs */
+#define	TX_MKDIR_ACL		17	/* mkdir with ACL */
+#define	TX_MKDIR_ATTR		18	/* mkdir with attr */
+#define	TX_MKDIR_ACL_ATTR	19	/* mkdir with ACL + attrs */
+#define	TX_WRITE2		20	/* dmu_sync EALREADY write */
+#define	TX_MAX_TYPE		21	/* Max transaction type */
+
+/*
+ * The transactions for mkdir, symlink, remove, rmdir, link, and rename
+ * may have the following bit set, indicating the original request
+ * specified case-insensitive handling of names.
+ */
+#define	TX_CI	((uint64_t)0x1 << 63) /* case-insensitive behavior requested */
+
+/*
+ * Transactions for write, truncate, setattr, acl_v0, and acl can be logged
+ * out of order.  For convenience in the code, all such records must have
+ * lr_foid at the same offset.
+ */
+#define	TX_OOO(txtype)			\
+	((txtype) == TX_WRITE ||	\
+	(txtype) == TX_TRUNCATE ||	\
+	(txtype) == TX_SETATTR ||	\
+	(txtype) == TX_ACL_V0 ||	\
+	(txtype) == TX_ACL ||		\
+	(txtype) == TX_WRITE2)
+
+/*
+ * The number of dnode slots consumed by the object is stored in the 8
+ * unused upper bits of the object ID. We subtract 1 from the value
+ * stored on disk for compatibility with implementations that don't
+ * support large dnodes. The slot count for a single-slot dnode will
+ * contain 0 for those bits to preserve the log record format for
+ * "small" dnodes.
+ */
+#define	LR_FOID_GET_SLOTS(oid) (BF64_GET((oid), 56, 8) + 1)
+#define	LR_FOID_SET_SLOTS(oid, x) BF64_SET((oid), 56, 8, (x) - 1)
+#define	LR_FOID_GET_OBJ(oid) BF64_GET((oid), 0, DN_MAX_OBJECT_SHIFT)
+#define	LR_FOID_SET_OBJ(oid, x) BF64_SET((oid), 0, DN_MAX_OBJECT_SHIFT, (x))
+
+/*
+ * Format of log records.
+ * The fields are carefully defined to allow them to be aligned
+ * and sized the same on sparc & intel architectures.
+ * Each log record has a common structure at the beginning.
+ *
+ * The log record on disk (lrc_seq) holds the sequence number of all log
+ * records which is used to ensure we don't replay the same record.
+ */
+typedef struct {			/* common log record header */
+	uint64_t	lrc_txtype;	/* intent log transaction type */
+	uint64_t	lrc_reclen;	/* transaction record length */
+	uint64_t	lrc_txg;	/* dmu transaction group number */
+	uint64_t	lrc_seq;	/* see comment above */
+} lr_t;
+
+/*
+ * Common start of all out-of-order record types (TX_OOO() above).
+ */
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_foid;	/* object id */
+} lr_ooo_t;
+
+/*
+ * Handle option extended vattr attributes.
+ *
+ * Whenever new attributes are added the version number
+ * will need to be updated as will code in
+ * zfs_log.c and zfs_replay.c
+ */
+typedef struct {
+	uint32_t	lr_attr_masksize; /* number of elements in array */
+	uint32_t	lr_attr_bitmap; /* First entry of array */
+	/* remainder of array and any additional fields */
+} lr_attr_t;
+
+/*
+ * log record for creates without optional ACL.
+ * This log record does support optional xvattr_t attributes.
+ */
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_doid;	/* object id of directory */
+	uint64_t	lr_foid;	/* object id of created file object */
+	uint64_t	lr_mode;	/* mode of object */
+	uint64_t	lr_uid;		/* uid of object */
+	uint64_t	lr_gid;		/* gid of object */
+	uint64_t	lr_gen;		/* generation (txg of creation) */
+	uint64_t	lr_crtime[2];	/* creation time */
+	uint64_t	lr_rdev;	/* rdev of object to create */
+	/* name of object to create follows this */
+	/* for symlinks, link content follows name */
+	/* for creates with xvattr data, the name follows the xvattr info */
+} lr_create_t;
+
+/*
+ * FUID ACL record will be an array of ACEs from the original ACL.
+ * If this array includes ephemeral IDs, the record will also include
+ * an array of log-specific FUIDs to replace the ephemeral IDs.
+ * Only one copy of each unique domain will be present, so the log-specific
+ * FUIDs will use an index into a compressed domain table.  On replay this
+ * information will be used to construct real FUIDs (and bypass idmap,
+ * since it may not be available).
+ */
+
+/*
+ * Log record for creates with optional ACL
+ * This log record is also used for recording any FUID
+ * information needed for replaying the create.  If the
+ * file doesn't have any actual ACEs then the lr_aclcnt
+ * would be zero.
+ *
+ * After lr_acl_flags, there are a lr_acl_bytes number of variable sized ace's.
+ * If create is also setting xvattr's, then acl data follows xvattr.
+ * If ACE FUIDs are needed then they will follow the xvattr_t.  Following
+ * the FUIDs will be the domain table information.  The FUIDs for the owner
+ * and group will be in lr_create.  Name follows ACL data.
+ */
+typedef struct {
+	lr_create_t	lr_create;	/* common create portion */
+	uint64_t	lr_aclcnt;	/* number of ACEs in ACL */
+	uint64_t	lr_domcnt;	/* number of unique domains */
+	uint64_t	lr_fuidcnt;	/* number of real fuids */
+	uint64_t	lr_acl_bytes;	/* number of bytes in ACL */
+	uint64_t	lr_acl_flags;	/* ACL flags */
+} lr_acl_create_t;
+
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_doid;	/* obj id of directory */
+	/* name of object to remove follows this */
+} lr_remove_t;
+
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_doid;	/* obj id of directory */
+	uint64_t	lr_link_obj;	/* obj id of link */
+	/* name of object to link follows this */
+} lr_link_t;
+
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_sdoid;	/* obj id of source directory */
+	uint64_t	lr_tdoid;	/* obj id of target directory */
+	/* 2 strings: names of source and destination follow this */
+} lr_rename_t;
+
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_foid;	/* file object to write */
+	uint64_t	lr_offset;	/* offset to write to */
+	uint64_t	lr_length;	/* user data length to write */
+	uint64_t	lr_blkoff;	/* no longer used */
+	blkptr_t	lr_blkptr;	/* spa block pointer for replay */
+	/* write data will follow for small writes */
+} lr_write_t;
+
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_foid;	/* object id of file to truncate */
+	uint64_t	lr_offset;	/* offset to truncate from */
+	uint64_t	lr_length;	/* length to truncate */
+} lr_truncate_t;
+
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_foid;	/* file object to change attributes */
+	uint64_t	lr_mask;	/* mask of attributes to set */
+	uint64_t	lr_mode;	/* mode to set */
+	uint64_t	lr_uid;		/* uid to set */
+	uint64_t	lr_gid;		/* gid to set */
+	uint64_t	lr_size;	/* size to set */
+	uint64_t	lr_atime[2];	/* access time */
+	uint64_t	lr_mtime[2];	/* modification time */
+	/* optional attribute lr_attr_t may be here */
+} lr_setattr_t;
+
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_foid;	/* obj id of file */
+	uint64_t	lr_aclcnt;	/* number of acl entries */
+	/* lr_aclcnt number of ace_t entries follow this */
+} lr_acl_v0_t;
+
+typedef struct {
+	lr_t		lr_common;	/* common portion of log record */
+	uint64_t	lr_foid;	/* obj id of file */
+	uint64_t	lr_aclcnt;	/* number of ACEs in ACL */
+	uint64_t	lr_domcnt;	/* number of unique domains */
+	uint64_t	lr_fuidcnt;	/* number of real fuids */
+	uint64_t	lr_acl_bytes;	/* number of bytes in ACL */
+	uint64_t	lr_acl_flags;	/* ACL flags */
+	/* lr_acl_bytes number of variable sized ace's follows */
+} lr_acl_t;
+
+/*
+ * ZIL structure definitions, interface function prototype and globals.
+ */
+
+/*
+ * Writes are handled in three different ways:
+ *
+ * WR_INDIRECT:
+ *    In this mode, if we need to commit the write later, then the block
+ *    is immediately written into the file system (using dmu_sync),
+ *    and a pointer to the block is put into the log record.
+ *    When the txg commits the block is linked in.
+ *    This saves additionally writing the data into the log record.
+ *    There are a few requirements for this to occur:
+ *	- write is greater than zfs/zvol_immediate_write_sz
+ *	- not using slogs (as slogs are assumed to always be faster
+ *	  than writing into the main pool)
+ *	- the write occupies only one block
+ * WR_COPIED:
+ *    If we know we'll immediately be committing the
+ *    transaction (O_SYNC or O_DSYNC), then we allocate a larger
+ *    log record here for the data and copy the data in.
+ * WR_NEED_COPY:
+ *    Otherwise we don't allocate a buffer, and *if* we need to
+ *    flush the write later then a buffer is allocated and
+ *    we retrieve the data using the dmu.
+ */
+typedef enum {
+	WR_INDIRECT,	/* indirect - a large write (dmu_sync() data */
+			/* and put blkptr in log, rather than actual data) */
+	WR_COPIED,	/* immediate - data is copied into lr_write_t */
+	WR_NEED_COPY,	/* immediate - data needs to be copied if pushed */
+	WR_NUM_STATES	/* number of states */
+} itx_wr_state_t;
+
+typedef void (*zil_callback_t)(void *data);
+
+typedef struct itx {
+	list_node_t	itx_node;	/* linkage on zl_itx_list */
+	void		*itx_private;	/* type-specific opaque data */
+	itx_wr_state_t	itx_wr_state;	/* write state */
+	uint8_t		itx_sync;	/* synchronous transaction */
+	zil_callback_t	itx_callback;   /* Called when the itx is persistent */
+	void		*itx_callback_data; /* User data for the callback */
+	size_t		itx_size;	/* allocated itx structure size */
+	uint64_t	itx_oid;	/* object id */
+	lr_t		itx_lr;		/* common part of log record */
+	/* followed by type-specific part of lr_xx_t and its immediate data */
+} itx_t;
+
+/*
+ * Used for zil kstat.
+ */
+typedef struct zil_stats {
+	/*
+	 * Number of times a ZIL commit (e.g. fsync) has been requested.
+	 */
+	kstat_named_t zil_commit_count;
+
+	/*
+	 * Number of times the ZIL has been flushed to stable storage.
+	 * This is less than zil_commit_count when commits are "merged"
+	 * (see the documentation above zil_commit()).
+	 */
+	kstat_named_t zil_commit_writer_count;
+
+	/*
+	 * Number of transactions (reads, writes, renames, etc.)
+	 * that have been committed.
+	 */
+	kstat_named_t zil_itx_count;
+
+	/*
+	 * See the documentation for itx_wr_state_t above.
+	 * Note that "bytes" accumulates the length of the transactions
+	 * (i.e. data), not the actual log record sizes.
+	 */
+	kstat_named_t zil_itx_indirect_count;
+	kstat_named_t zil_itx_indirect_bytes;
+	kstat_named_t zil_itx_copied_count;
+	kstat_named_t zil_itx_copied_bytes;
+	kstat_named_t zil_itx_needcopy_count;
+	kstat_named_t zil_itx_needcopy_bytes;
+
+	/*
+	 * Transactions which have been allocated to the "normal"
+	 * (i.e. not slog) storage pool. Note that "bytes" accumulate
+	 * the actual log record sizes - which do not include the actual
+	 * data in case of indirect writes.
+	 */
+	kstat_named_t zil_itx_metaslab_normal_count;
+	kstat_named_t zil_itx_metaslab_normal_bytes;
+
+	/*
+	 * Transactions which have been allocated to the "slog" storage pool.
+	 * If there are no separate log devices, this is the same as the
+	 * "normal" pool.
+	 */
+	kstat_named_t zil_itx_metaslab_slog_count;
+	kstat_named_t zil_itx_metaslab_slog_bytes;
+} zil_stats_t;
+
+extern zil_stats_t zil_stats;
+
+#define	ZIL_STAT_INCR(stat, val) \
+    atomic_add_64(&zil_stats.stat.value.ui64, (val));
+#define	ZIL_STAT_BUMP(stat) \
+    ZIL_STAT_INCR(stat, 1);
+
+typedef int zil_parse_blk_func_t(zilog_t *zilog, blkptr_t *bp, void *arg,
+    uint64_t txg);
+typedef int zil_parse_lr_func_t(zilog_t *zilog, lr_t *lr, void *arg,
+    uint64_t txg);
+typedef int zil_replay_func_t(void *arg1, void *arg2, boolean_t byteswap);
+typedef int zil_get_data_t(void *arg, lr_write_t *lr, char *dbuf,
+    struct lwb *lwb, zio_t *zio);
+
+extern int zil_parse(zilog_t *zilog, zil_parse_blk_func_t *parse_blk_func,
+    zil_parse_lr_func_t *parse_lr_func, void *arg, uint64_t txg,
+    boolean_t decrypt);
+
+extern void	zil_init(void);
+extern void	zil_fini(void);
+
+extern zilog_t	*zil_alloc(objset_t *os, zil_header_t *zh_phys);
+extern void	zil_free(zilog_t *zilog);
+
+extern zilog_t	*zil_open(objset_t *os, zil_get_data_t *get_data);
+extern void	zil_close(zilog_t *zilog);
+
+extern void	zil_replay(objset_t *os, void *arg,
+    zil_replay_func_t *replay_func[TX_MAX_TYPE]);
+extern boolean_t zil_replaying(zilog_t *zilog, dmu_tx_t *tx);
+extern void	zil_destroy(zilog_t *zilog, boolean_t keep_first);
+extern void	zil_destroy_sync(zilog_t *zilog, dmu_tx_t *tx);
+
+extern itx_t	*zil_itx_create(uint64_t txtype, size_t lrsize);
+extern void	zil_itx_destroy(itx_t *itx);
+extern void	zil_itx_assign(zilog_t *zilog, itx_t *itx, dmu_tx_t *tx);
+
+extern void	zil_async_to_sync(zilog_t *zilog, uint64_t oid);
+extern void	zil_commit(zilog_t *zilog, uint64_t oid);
+extern void	zil_commit_impl(zilog_t *zilog, uint64_t oid);
+extern void	zil_remove_async(zilog_t *zilog, uint64_t oid);
+
+extern int	zil_reset(const char *osname, void *txarg);
+extern int	zil_claim(struct dsl_pool *dp,
+    struct dsl_dataset *ds, void *txarg);
+extern int 	zil_check_log_chain(struct dsl_pool *dp,
+    struct dsl_dataset *ds, void *tx);
+extern void	zil_sync(zilog_t *zilog, dmu_tx_t *tx);
+extern void	zil_clean(zilog_t *zilog, uint64_t synced_txg);
+
+extern int	zil_suspend(const char *osname, void **cookiep);
+extern void	zil_resume(void *cookie);
+
+extern void	zil_lwb_add_block(struct lwb *lwb, const blkptr_t *bp);
+extern void	zil_lwb_add_txg(struct lwb *lwb, uint64_t txg);
+extern int	zil_bp_tree_add(zilog_t *zilog, const blkptr_t *bp);
+
+extern void	zil_set_sync(zilog_t *zilog, uint64_t syncval);
+
+extern void	zil_set_logbias(zilog_t *zilog, uint64_t slogval);
+
+extern uint64_t	zil_max_copied_data(zilog_t *zilog);
+extern uint64_t	zil_max_log_data(zilog_t *zilog);
+
+extern int zil_replay_disable;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZIL_H */
diff --git a/include/sys/zil_impl.h b/include/sys/zil_impl.h
new file mode 100644
index 0000000000000..d2f4018653a6b
--- /dev/null
+++ b/include/sys/zil_impl.h
@@ -0,0 +1,230 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ */
+
+/* Portions Copyright 2010 Robert Milkowski */
+
+#ifndef	_SYS_ZIL_IMPL_H
+#define	_SYS_ZIL_IMPL_H
+
+#include <sys/zil.h>
+#include <sys/dmu_objset.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Possible states for a given lwb structure.
+ *
+ * An lwb will start out in the "closed" state, and then transition to
+ * the "opened" state via a call to zil_lwb_write_open(). When
+ * transitioning from "closed" to "opened" the zilog's "zl_issuer_lock"
+ * must be held.
+ *
+ * After the lwb is "opened", it can transition into the "issued" state
+ * via zil_lwb_write_issue(). Again, the zilog's "zl_issuer_lock" must
+ * be held when making this transition.
+ *
+ * After the lwb's write zio completes, it transitions into the "write
+ * done" state via zil_lwb_write_done(); and then into the "flush done"
+ * state via zil_lwb_flush_vdevs_done(). When transitioning from
+ * "issued" to "write done", and then from "write done" to "flush done",
+ * the zilog's "zl_lock" must be held, *not* the "zl_issuer_lock".
+ *
+ * The zilog's "zl_issuer_lock" can become heavily contended in certain
+ * workloads, so we specifically avoid acquiring that lock when
+ * transitioning an lwb from "issued" to "done". This allows us to avoid
+ * having to acquire the "zl_issuer_lock" for each lwb ZIO completion,
+ * which would have added more lock contention on an already heavily
+ * contended lock.
+ *
+ * Additionally, correctness when reading an lwb's state is often
+ * achieved by exploiting the fact that these state transitions occur in
+ * this specific order; i.e. "closed" to "opened" to "issued" to "done".
+ *
+ * Thus, if an lwb is in the "closed" or "opened" state, holding the
+ * "zl_issuer_lock" will prevent a concurrent thread from transitioning
+ * that lwb to the "issued" state. Likewise, if an lwb is already in the
+ * "issued" state, holding the "zl_lock" will prevent a concurrent
+ * thread from transitioning that lwb to the "write done" state.
+ */
+typedef enum {
+    LWB_STATE_CLOSED,
+    LWB_STATE_OPENED,
+    LWB_STATE_ISSUED,
+    LWB_STATE_WRITE_DONE,
+    LWB_STATE_FLUSH_DONE,
+    LWB_NUM_STATES
+} lwb_state_t;
+
+/*
+ * Log write block (lwb)
+ *
+ * Prior to an lwb being issued to disk via zil_lwb_write_issue(), it
+ * will be protected by the zilog's "zl_issuer_lock". Basically, prior
+ * to it being issued, it will only be accessed by the thread that's
+ * holding the "zl_issuer_lock". After the lwb is issued, the zilog's
+ * "zl_lock" is used to protect the lwb against concurrent access.
+ */
+typedef struct lwb {
+	zilog_t		*lwb_zilog;	/* back pointer to log struct */
+	blkptr_t	lwb_blk;	/* on disk address of this log blk */
+	boolean_t	lwb_fastwrite;	/* is blk marked for fastwrite? */
+	boolean_t	lwb_slog;	/* lwb_blk is on SLOG device */
+	int		lwb_nused;	/* # used bytes in buffer */
+	int		lwb_sz;		/* size of block and buffer */
+	lwb_state_t	lwb_state;	/* the state of this lwb */
+	char		*lwb_buf;	/* log write buffer */
+	zio_t		*lwb_write_zio;	/* zio for the lwb buffer */
+	zio_t		*lwb_root_zio;	/* root zio for lwb write and flushes */
+	dmu_tx_t	*lwb_tx;	/* tx for log block allocation */
+	uint64_t	lwb_max_txg;	/* highest txg in this lwb */
+	list_node_t	lwb_node;	/* zilog->zl_lwb_list linkage */
+	list_t		lwb_itxs;	/* list of itx's */
+	list_t		lwb_waiters;	/* list of zil_commit_waiter's */
+	avl_tree_t	lwb_vdev_tree;	/* vdevs to flush after lwb write */
+	kmutex_t	lwb_vdev_lock;	/* protects lwb_vdev_tree */
+	hrtime_t	lwb_issued_timestamp; /* when was the lwb issued? */
+} lwb_t;
+
+/*
+ * ZIL commit waiter.
+ *
+ * This structure is allocated each time zil_commit() is called, and is
+ * used by zil_commit() to communicate with other parts of the ZIL, such
+ * that zil_commit() can know when it safe for it return. For more
+ * details, see the comment above zil_commit().
+ *
+ * The "zcw_lock" field is used to protect the commit waiter against
+ * concurrent access. This lock is often acquired while already holding
+ * the zilog's "zl_issuer_lock" or "zl_lock"; see the functions
+ * zil_process_commit_list() and zil_lwb_flush_vdevs_done() as examples
+ * of this. Thus, one must be careful not to acquire the
+ * "zl_issuer_lock" or "zl_lock" when already holding the "zcw_lock";
+ * e.g. see the zil_commit_waiter_timeout() function.
+ */
+typedef struct zil_commit_waiter {
+	kcondvar_t	zcw_cv;		/* signalled when "done" */
+	kmutex_t	zcw_lock;	/* protects fields of this struct */
+	list_node_t	zcw_node;	/* linkage in lwb_t:lwb_waiter list */
+	lwb_t		*zcw_lwb;	/* back pointer to lwb when linked */
+	boolean_t	zcw_done;	/* B_TRUE when "done", else B_FALSE */
+	int		zcw_zio_error;	/* contains the zio io_error value */
+} zil_commit_waiter_t;
+
+/*
+ * Intent log transaction lists
+ */
+typedef struct itxs {
+	list_t		i_sync_list;	/* list of synchronous itxs */
+	avl_tree_t	i_async_tree;	/* tree of foids for async itxs */
+} itxs_t;
+
+typedef struct itxg {
+	kmutex_t	itxg_lock;	/* lock for this structure */
+	uint64_t	itxg_txg;	/* txg for this chain */
+	itxs_t		*itxg_itxs;	/* sync and async itxs */
+} itxg_t;
+
+/* for async nodes we build up an AVL tree of lists of async itxs per file */
+typedef struct itx_async_node {
+	uint64_t	ia_foid;	/* file object id */
+	list_t		ia_list;	/* list of async itxs for this foid */
+	avl_node_t	ia_node;	/* AVL tree linkage */
+} itx_async_node_t;
+
+/*
+ * Vdev flushing: during a zil_commit(), we build up an AVL tree of the vdevs
+ * we've touched so we know which ones need a write cache flush at the end.
+ */
+typedef struct zil_vdev_node {
+	uint64_t	zv_vdev;	/* vdev to be flushed */
+	avl_node_t	zv_node;	/* AVL tree linkage */
+} zil_vdev_node_t;
+
+#define	ZIL_PREV_BLKS 16
+
+/*
+ * Stable storage intent log management structure.  One per dataset.
+ */
+struct zilog {
+	kmutex_t	zl_lock;	/* protects most zilog_t fields */
+	struct dsl_pool	*zl_dmu_pool;	/* DSL pool */
+	spa_t		*zl_spa;	/* handle for read/write log */
+	const zil_header_t *zl_header;	/* log header buffer */
+	objset_t	*zl_os;		/* object set we're logging */
+	zil_get_data_t	*zl_get_data;	/* callback to get object content */
+	lwb_t		*zl_last_lwb_opened; /* most recent lwb opened */
+	hrtime_t	zl_last_lwb_latency; /* zio latency of last lwb done */
+	uint64_t	zl_lr_seq;	/* on-disk log record sequence number */
+	uint64_t	zl_commit_lr_seq; /* last committed on-disk lr seq */
+	uint64_t	zl_destroy_txg;	/* txg of last zil_destroy() */
+	uint64_t	zl_replayed_seq[TXG_SIZE]; /* last replayed rec seq */
+	uint64_t	zl_replaying_seq; /* current replay seq number */
+	uint32_t	zl_suspend;	/* log suspend count */
+	kcondvar_t	zl_cv_suspend;	/* log suspend completion */
+	uint8_t		zl_suspending;	/* log is currently suspending */
+	uint8_t		zl_keep_first;	/* keep first log block in destroy */
+	uint8_t		zl_replay;	/* replaying records while set */
+	uint8_t		zl_stop_sync;	/* for debugging */
+	kmutex_t	zl_issuer_lock;	/* single writer, per ZIL, at a time */
+	uint8_t		zl_logbias;	/* latency or throughput */
+	uint8_t		zl_sync;	/* synchronous or asynchronous */
+	int		zl_parse_error;	/* last zil_parse() error */
+	uint64_t	zl_parse_blk_seq; /* highest blk seq on last parse */
+	uint64_t	zl_parse_lr_seq; /* highest lr seq on last parse */
+	uint64_t	zl_parse_blk_count; /* number of blocks parsed */
+	uint64_t	zl_parse_lr_count; /* number of log records parsed */
+	itxg_t		zl_itxg[TXG_SIZE]; /* intent log txg chains */
+	list_t		zl_itx_commit_list; /* itx list to be committed */
+	uint64_t	zl_cur_used;	/* current commit log size used */
+	list_t		zl_lwb_list;	/* in-flight log write list */
+	avl_tree_t	zl_bp_tree;	/* track bps during log parse */
+	clock_t		zl_replay_time;	/* lbolt of when replay started */
+	uint64_t	zl_replay_blks;	/* number of log blocks replayed */
+	zil_header_t	zl_old_header;	/* debugging aid */
+	uint_t		zl_prev_blks[ZIL_PREV_BLKS]; /* size - sector rounded */
+	uint_t		zl_prev_rotor;	/* rotor for zl_prev[] */
+	txg_node_t	zl_dirty_link;	/* protected by dp_dirty_zilogs list */
+	uint64_t	zl_dirty_max_txg; /* highest txg used to dirty zilog */
+	/*
+	 * Max block size for this ZIL.  Note that this can not be changed
+	 * while the ZIL is in use because consumers (ZPL/zvol) need to take
+	 * this into account when deciding between WR_COPIED and WR_NEED_COPY
+	 * (see zil_max_copied_data()).
+	 */
+	uint64_t	zl_max_block_size;
+};
+
+typedef struct zil_bp_node {
+	dva_t		zn_dva;
+	avl_node_t	zn_node;
+} zil_bp_node_t;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZIL_IMPL_H */
diff --git a/include/sys/zio.h b/include/sys/zio.h
new file mode 100644
index 0000000000000..f3b5a120793fc
--- /dev/null
+++ b/include/sys/zio.h
@@ -0,0 +1,710 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
+ * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
+ * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
+ * Copyright (c) 2013, Joyent, Inc. All rights reserved.
+ * Copyright 2016 Toomas Soome <tsoome@me.com>
+ * Copyright (c) 2019, Allan Jude
+ * Copyright (c) 2019, Klara Inc.
+ * Copyright (c) 2019-2020, Michael Niewöhner
+ */
+
+#ifndef _ZIO_H
+#define	_ZIO_H
+
+#include <sys/zio_priority.h>
+#include <sys/zfs_context.h>
+#include <sys/spa.h>
+#include <sys/txg.h>
+#include <sys/avl.h>
+#include <sys/fs/zfs.h>
+#include <sys/zio_impl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Embedded checksum
+ */
+#define	ZEC_MAGIC	0x210da7ab10c7a11ULL
+
+typedef struct zio_eck {
+	uint64_t	zec_magic;	/* for validation, endianness	*/
+	zio_cksum_t	zec_cksum;	/* 256-bit checksum		*/
+} zio_eck_t;
+
+/*
+ * Gang block headers are self-checksumming and contain an array
+ * of block pointers.
+ */
+#define	SPA_GANGBLOCKSIZE	SPA_MINBLOCKSIZE
+#define	SPA_GBH_NBLKPTRS	((SPA_GANGBLOCKSIZE - \
+	sizeof (zio_eck_t)) / sizeof (blkptr_t))
+#define	SPA_GBH_FILLER		((SPA_GANGBLOCKSIZE - \
+	sizeof (zio_eck_t) - \
+	(SPA_GBH_NBLKPTRS * sizeof (blkptr_t))) /\
+	sizeof (uint64_t))
+
+typedef struct zio_gbh {
+	blkptr_t		zg_blkptr[SPA_GBH_NBLKPTRS];
+	uint64_t		zg_filler[SPA_GBH_FILLER];
+	zio_eck_t		zg_tail;
+} zio_gbh_phys_t;
+
+enum zio_checksum {
+	ZIO_CHECKSUM_INHERIT = 0,
+	ZIO_CHECKSUM_ON,
+	ZIO_CHECKSUM_OFF,
+	ZIO_CHECKSUM_LABEL,
+	ZIO_CHECKSUM_GANG_HEADER,
+	ZIO_CHECKSUM_ZILOG,
+	ZIO_CHECKSUM_FLETCHER_2,
+	ZIO_CHECKSUM_FLETCHER_4,
+	ZIO_CHECKSUM_SHA256,
+	ZIO_CHECKSUM_ZILOG2,
+	ZIO_CHECKSUM_NOPARITY,
+	ZIO_CHECKSUM_SHA512,
+	ZIO_CHECKSUM_SKEIN,
+#if !defined(__FreeBSD__)
+	ZIO_CHECKSUM_EDONR,
+#endif
+	ZIO_CHECKSUM_FUNCTIONS
+};
+
+/*
+ * The number of "legacy" compression functions which can be set on individual
+ * objects.
+ */
+#define	ZIO_CHECKSUM_LEGACY_FUNCTIONS ZIO_CHECKSUM_ZILOG2
+
+#define	ZIO_CHECKSUM_ON_VALUE	ZIO_CHECKSUM_FLETCHER_4
+#define	ZIO_CHECKSUM_DEFAULT	ZIO_CHECKSUM_ON
+
+#define	ZIO_CHECKSUM_MASK	0xffULL
+#define	ZIO_CHECKSUM_VERIFY	(1 << 8)
+
+#define	ZIO_DEDUPCHECKSUM	ZIO_CHECKSUM_SHA256
+
+/* supported encryption algorithms */
+enum zio_encrypt {
+	ZIO_CRYPT_INHERIT = 0,
+	ZIO_CRYPT_ON,
+	ZIO_CRYPT_OFF,
+	ZIO_CRYPT_AES_128_CCM,
+	ZIO_CRYPT_AES_192_CCM,
+	ZIO_CRYPT_AES_256_CCM,
+	ZIO_CRYPT_AES_128_GCM,
+	ZIO_CRYPT_AES_192_GCM,
+	ZIO_CRYPT_AES_256_GCM,
+	ZIO_CRYPT_FUNCTIONS
+};
+
+#define	ZIO_CRYPT_ON_VALUE	ZIO_CRYPT_AES_256_GCM
+#define	ZIO_CRYPT_DEFAULT	ZIO_CRYPT_OFF
+
+/* macros defining encryption lengths */
+#define	ZIO_OBJSET_MAC_LEN		32
+#define	ZIO_DATA_IV_LEN			12
+#define	ZIO_DATA_SALT_LEN		8
+#define	ZIO_DATA_MAC_LEN		16
+
+/*
+ * The number of "legacy" compression functions which can be set on individual
+ * objects.
+ */
+#define	ZIO_COMPRESS_LEGACY_FUNCTIONS ZIO_COMPRESS_LZ4
+
+/*
+ * The meaning of "compress = on" selected by the compression features enabled
+ * on a given pool.
+ */
+#define	ZIO_COMPRESS_LEGACY_ON_VALUE	ZIO_COMPRESS_LZJB
+#define	ZIO_COMPRESS_LZ4_ON_VALUE	ZIO_COMPRESS_LZ4
+
+#define	ZIO_COMPRESS_DEFAULT		ZIO_COMPRESS_OFF
+
+#define	BOOTFS_COMPRESS_VALID(compress)			\
+	((compress) == ZIO_COMPRESS_LZJB ||		\
+	(compress) == ZIO_COMPRESS_LZ4 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_1 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_2 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_3 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_4 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_5 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_6 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_7 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_8 ||		\
+	(compress) == ZIO_COMPRESS_GZIP_9 ||		\
+	(compress) == ZIO_COMPRESS_ZLE ||		\
+	(compress) == ZIO_COMPRESS_ZSTD ||		\
+	(compress) == ZIO_COMPRESS_ON ||		\
+	(compress) == ZIO_COMPRESS_OFF)
+
+
+#define	ZIO_COMPRESS_ALGO(x)	(x & SPA_COMPRESSMASK)
+#define	ZIO_COMPRESS_LEVEL(x)	((x & ~SPA_COMPRESSMASK) >> SPA_COMPRESSBITS)
+#define	ZIO_COMPRESS_RAW(type, level)	(type | ((level) << SPA_COMPRESSBITS))
+
+#define	ZIO_COMPLEVEL_ZSTD(level)	\
+	ZIO_COMPRESS_RAW(ZIO_COMPRESS_ZSTD, level)
+
+#define	ZIO_FAILURE_MODE_WAIT		0
+#define	ZIO_FAILURE_MODE_CONTINUE	1
+#define	ZIO_FAILURE_MODE_PANIC		2
+
+typedef enum zio_suspend_reason {
+	ZIO_SUSPEND_NONE = 0,
+	ZIO_SUSPEND_IOERR,
+	ZIO_SUSPEND_MMP,
+} zio_suspend_reason_t;
+
+enum zio_flag {
+	/*
+	 * Flags inherited by gang, ddt, and vdev children,
+	 * and that must be equal for two zios to aggregate
+	 */
+	ZIO_FLAG_DONT_AGGREGATE	= 1 << 0,
+	ZIO_FLAG_IO_REPAIR	= 1 << 1,
+	ZIO_FLAG_SELF_HEAL	= 1 << 2,
+	ZIO_FLAG_RESILVER	= 1 << 3,
+	ZIO_FLAG_SCRUB		= 1 << 4,
+	ZIO_FLAG_SCAN_THREAD	= 1 << 5,
+	ZIO_FLAG_PHYSICAL	= 1 << 6,
+
+#define	ZIO_FLAG_AGG_INHERIT	(ZIO_FLAG_CANFAIL - 1)
+
+	/*
+	 * Flags inherited by ddt, gang, and vdev children.
+	 */
+	ZIO_FLAG_CANFAIL	= 1 << 7,	/* must be first for INHERIT */
+	ZIO_FLAG_SPECULATIVE	= 1 << 8,
+	ZIO_FLAG_CONFIG_WRITER	= 1 << 9,
+	ZIO_FLAG_DONT_RETRY	= 1 << 10,
+	ZIO_FLAG_DONT_CACHE	= 1 << 11,
+	ZIO_FLAG_NODATA		= 1 << 12,
+	ZIO_FLAG_INDUCE_DAMAGE	= 1 << 13,
+	ZIO_FLAG_IO_ALLOCATING  = 1 << 14,
+
+#define	ZIO_FLAG_DDT_INHERIT	(ZIO_FLAG_IO_RETRY - 1)
+#define	ZIO_FLAG_GANG_INHERIT	(ZIO_FLAG_IO_RETRY - 1)
+
+	/*
+	 * Flags inherited by vdev children.
+	 */
+	ZIO_FLAG_IO_RETRY	= 1 << 15,	/* must be first for INHERIT */
+	ZIO_FLAG_PROBE		= 1 << 16,
+	ZIO_FLAG_TRYHARD	= 1 << 17,
+	ZIO_FLAG_OPTIONAL	= 1 << 18,
+
+#define	ZIO_FLAG_VDEV_INHERIT	(ZIO_FLAG_DONT_QUEUE - 1)
+
+	/*
+	 * Flags not inherited by any children.
+	 */
+	ZIO_FLAG_DONT_QUEUE	= 1 << 19,	/* must be first for INHERIT */
+	ZIO_FLAG_DONT_PROPAGATE	= 1 << 20,
+	ZIO_FLAG_IO_BYPASS	= 1 << 21,
+	ZIO_FLAG_IO_REWRITE	= 1 << 22,
+	ZIO_FLAG_RAW_COMPRESS	= 1 << 23,
+	ZIO_FLAG_RAW_ENCRYPT	= 1 << 24,
+	ZIO_FLAG_GANG_CHILD	= 1 << 25,
+	ZIO_FLAG_DDT_CHILD	= 1 << 26,
+	ZIO_FLAG_GODFATHER	= 1 << 27,
+	ZIO_FLAG_NOPWRITE	= 1 << 28,
+	ZIO_FLAG_REEXECUTED	= 1 << 29,
+	ZIO_FLAG_DELEGATED	= 1 << 30,
+	ZIO_FLAG_FASTWRITE	= 1 << 31,
+};
+
+#define	ZIO_FLAG_MUSTSUCCEED		0
+#define	ZIO_FLAG_RAW	(ZIO_FLAG_RAW_COMPRESS | ZIO_FLAG_RAW_ENCRYPT)
+
+#define	ZIO_DDT_CHILD_FLAGS(zio)				\
+	(((zio)->io_flags & ZIO_FLAG_DDT_INHERIT) |		\
+	ZIO_FLAG_DDT_CHILD | ZIO_FLAG_CANFAIL)
+
+#define	ZIO_GANG_CHILD_FLAGS(zio)				\
+	(((zio)->io_flags & ZIO_FLAG_GANG_INHERIT) |		\
+	ZIO_FLAG_GANG_CHILD | ZIO_FLAG_CANFAIL)
+
+#define	ZIO_VDEV_CHILD_FLAGS(zio)				\
+	(((zio)->io_flags & ZIO_FLAG_VDEV_INHERIT) |		\
+	ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_CANFAIL)
+
+#define	ZIO_CHILD_BIT(x)		(1 << (x))
+#define	ZIO_CHILD_BIT_IS_SET(val, x)	((val) & (1 << (x)))
+
+enum zio_child {
+	ZIO_CHILD_VDEV = 0,
+	ZIO_CHILD_GANG,
+	ZIO_CHILD_DDT,
+	ZIO_CHILD_LOGICAL,
+	ZIO_CHILD_TYPES
+};
+
+#define	ZIO_CHILD_VDEV_BIT		ZIO_CHILD_BIT(ZIO_CHILD_VDEV)
+#define	ZIO_CHILD_GANG_BIT		ZIO_CHILD_BIT(ZIO_CHILD_GANG)
+#define	ZIO_CHILD_DDT_BIT		ZIO_CHILD_BIT(ZIO_CHILD_DDT)
+#define	ZIO_CHILD_LOGICAL_BIT		ZIO_CHILD_BIT(ZIO_CHILD_LOGICAL)
+#define	ZIO_CHILD_ALL_BITS					\
+	(ZIO_CHILD_VDEV_BIT | ZIO_CHILD_GANG_BIT |		\
+	ZIO_CHILD_DDT_BIT | ZIO_CHILD_LOGICAL_BIT)
+
+enum zio_wait_type {
+	ZIO_WAIT_READY = 0,
+	ZIO_WAIT_DONE,
+	ZIO_WAIT_TYPES
+};
+
+typedef void zio_done_func_t(zio_t *zio);
+
+extern int zio_exclude_metadata;
+extern int zio_dva_throttle_enabled;
+extern const char *zio_type_name[ZIO_TYPES];
+
+/*
+ * A bookmark is a four-tuple <objset, object, level, blkid> that uniquely
+ * identifies any block in the pool.  By convention, the meta-objset (MOS)
+ * is objset 0, and the meta-dnode is object 0.  This covers all blocks
+ * except root blocks and ZIL blocks, which are defined as follows:
+ *
+ * Root blocks (objset_phys_t) are object 0, level -1:  <objset, 0, -1, 0>.
+ * ZIL blocks are bookmarked <objset, 0, -2, blkid == ZIL sequence number>.
+ * dmu_sync()ed ZIL data blocks are bookmarked <objset, object, -2, blkid>.
+ * dnode visit bookmarks are <objset, object id of dnode, -3, 0>.
+ *
+ * Note: this structure is called a bookmark because its original purpose
+ * was to remember where to resume a pool-wide traverse.
+ *
+ * Note: this structure is passed between userland and the kernel, and is
+ * stored on disk (by virtue of being incorporated into other on-disk
+ * structures, e.g. dsl_scan_phys_t).
+ */
+struct zbookmark_phys {
+	uint64_t	zb_objset;
+	uint64_t	zb_object;
+	int64_t		zb_level;
+	uint64_t	zb_blkid;
+};
+
+#define	SET_BOOKMARK(zb, objset, object, level, blkid)  \
+{                                                       \
+	(zb)->zb_objset = objset;                       \
+	(zb)->zb_object = object;                       \
+	(zb)->zb_level = level;                         \
+	(zb)->zb_blkid = blkid;                         \
+}
+
+#define	ZB_DESTROYED_OBJSET	(-1ULL)
+
+#define	ZB_ROOT_OBJECT		(0ULL)
+#define	ZB_ROOT_LEVEL		(-1LL)
+#define	ZB_ROOT_BLKID		(0ULL)
+
+#define	ZB_ZIL_OBJECT		(0ULL)
+#define	ZB_ZIL_LEVEL		(-2LL)
+
+#define	ZB_DNODE_LEVEL		(-3LL)
+#define	ZB_DNODE_BLKID		(0ULL)
+
+#define	ZB_IS_ZERO(zb)						\
+	((zb)->zb_objset == 0 && (zb)->zb_object == 0 &&	\
+	(zb)->zb_level == 0 && (zb)->zb_blkid == 0)
+#define	ZB_IS_ROOT(zb)				\
+	((zb)->zb_object == ZB_ROOT_OBJECT &&	\
+	(zb)->zb_level == ZB_ROOT_LEVEL &&	\
+	(zb)->zb_blkid == ZB_ROOT_BLKID)
+
+typedef struct zio_prop {
+	enum zio_checksum	zp_checksum;
+	enum zio_compress	zp_compress;
+	uint8_t			zp_complevel;
+	dmu_object_type_t	zp_type;
+	uint8_t			zp_level;
+	uint8_t			zp_copies;
+	boolean_t		zp_dedup;
+	boolean_t		zp_dedup_verify;
+	boolean_t		zp_nopwrite;
+	boolean_t		zp_encrypt;
+	boolean_t		zp_byteorder;
+	uint8_t			zp_salt[ZIO_DATA_SALT_LEN];
+	uint8_t			zp_iv[ZIO_DATA_IV_LEN];
+	uint8_t			zp_mac[ZIO_DATA_MAC_LEN];
+	uint32_t		zp_zpl_smallblk;
+} zio_prop_t;
+
+typedef struct zio_cksum_report zio_cksum_report_t;
+
+typedef void zio_cksum_finish_f(zio_cksum_report_t *rep,
+    const abd_t *good_data);
+typedef void zio_cksum_free_f(void *cbdata, size_t size);
+
+struct zio_bad_cksum;				/* defined in zio_checksum.h */
+struct dnode_phys;
+struct abd;
+
+struct zio_cksum_report {
+	struct zio_cksum_report *zcr_next;
+	nvlist_t		*zcr_ereport;
+	nvlist_t		*zcr_detector;
+	void			*zcr_cbdata;
+	size_t			zcr_cbinfo;	/* passed to zcr_free() */
+	uint64_t		zcr_align;
+	uint64_t		zcr_length;
+	zio_cksum_finish_f	*zcr_finish;
+	zio_cksum_free_f	*zcr_free;
+
+	/* internal use only */
+	struct zio_bad_cksum	*zcr_ckinfo;	/* information from failure */
+};
+
+typedef void zio_vsd_cksum_report_f(zio_t *zio, zio_cksum_report_t *zcr,
+    void *arg);
+
+zio_vsd_cksum_report_f	zio_vsd_default_cksum_report;
+
+typedef struct zio_vsd_ops {
+	zio_done_func_t		*vsd_free;
+	zio_vsd_cksum_report_f	*vsd_cksum_report;
+} zio_vsd_ops_t;
+
+typedef struct zio_gang_node {
+	zio_gbh_phys_t		*gn_gbh;
+	struct zio_gang_node	*gn_child[SPA_GBH_NBLKPTRS];
+} zio_gang_node_t;
+
+typedef zio_t *zio_gang_issue_func_t(zio_t *zio, blkptr_t *bp,
+    zio_gang_node_t *gn, struct abd *data, uint64_t offset);
+
+typedef void zio_transform_func_t(zio_t *zio, struct abd *data, uint64_t size);
+
+typedef struct zio_transform {
+	struct abd		*zt_orig_abd;
+	uint64_t		zt_orig_size;
+	uint64_t		zt_bufsize;
+	zio_transform_func_t	*zt_transform;
+	struct zio_transform	*zt_next;
+} zio_transform_t;
+
+typedef zio_t *zio_pipe_stage_t(zio_t *zio);
+
+/*
+ * The io_reexecute flags are distinct from io_flags because the child must
+ * be able to propagate them to the parent.  The normal io_flags are local
+ * to the zio, not protected by any lock, and not modifiable by children;
+ * the reexecute flags are protected by io_lock, modifiable by children,
+ * and always propagated -- even when ZIO_FLAG_DONT_PROPAGATE is set.
+ */
+#define	ZIO_REEXECUTE_NOW	0x01
+#define	ZIO_REEXECUTE_SUSPEND	0x02
+
+/*
+ * The io_trim flags are used to specify the type of TRIM to perform.  They
+ * only apply to ZIO_TYPE_TRIM zios are distinct from io_flags.
+ */
+enum trim_flag {
+	ZIO_TRIM_SECURE		= 1 << 0,
+};
+
+typedef struct zio_alloc_list {
+	list_t  zal_list;
+	uint64_t zal_size;
+} zio_alloc_list_t;
+
+typedef struct zio_link {
+	zio_t		*zl_parent;
+	zio_t		*zl_child;
+	list_node_t	zl_parent_node;
+	list_node_t	zl_child_node;
+} zio_link_t;
+
+struct zio {
+	/* Core information about this I/O */
+	zbookmark_phys_t	io_bookmark;
+	zio_prop_t	io_prop;
+	zio_type_t	io_type;
+	enum zio_child	io_child_type;
+	enum trim_flag	io_trim_flags;
+	int		io_cmd;
+	zio_priority_t	io_priority;
+	uint8_t		io_reexecute;
+	uint8_t		io_state[ZIO_WAIT_TYPES];
+	uint64_t	io_txg;
+	spa_t		*io_spa;
+	blkptr_t	*io_bp;
+	blkptr_t	*io_bp_override;
+	blkptr_t	io_bp_copy;
+	list_t		io_parent_list;
+	list_t		io_child_list;
+	zio_t		*io_logical;
+	zio_transform_t *io_transform_stack;
+
+	/* Callback info */
+	zio_done_func_t	*io_ready;
+	zio_done_func_t	*io_children_ready;
+	zio_done_func_t	*io_physdone;
+	zio_done_func_t	*io_done;
+	void		*io_private;
+	int64_t		io_prev_space_delta;	/* DMU private */
+	blkptr_t	io_bp_orig;
+	/* io_lsize != io_orig_size iff this is a raw write */
+	uint64_t	io_lsize;
+
+	/* Data represented by this I/O */
+	struct abd	*io_abd;
+	struct abd	*io_orig_abd;
+	uint64_t	io_size;
+	uint64_t	io_orig_size;
+
+	/* Stuff for the vdev stack */
+	vdev_t		*io_vd;
+	void		*io_vsd;
+	const zio_vsd_ops_t *io_vsd_ops;
+	metaslab_class_t *io_metaslab_class;	/* dva throttle class */
+
+	uint64_t	io_offset;
+	hrtime_t	io_timestamp;	/* submitted at */
+	hrtime_t	io_queued_timestamp;
+	hrtime_t	io_target_timestamp;
+	hrtime_t	io_delta;	/* vdev queue service delta */
+	hrtime_t	io_delay;	/* Device access time (disk or */
+					/* file). */
+	avl_node_t	io_queue_node;
+	avl_node_t	io_offset_node;
+	avl_node_t	io_alloc_node;
+	zio_alloc_list_t 	io_alloc_list;
+
+	/* Internal pipeline state */
+	enum zio_flag	io_flags;
+	enum zio_stage	io_stage;
+	enum zio_stage	io_pipeline;
+	enum zio_flag	io_orig_flags;
+	enum zio_stage	io_orig_stage;
+	enum zio_stage	io_orig_pipeline;
+	enum zio_stage	io_pipeline_trace;
+	int		io_error;
+	int		io_child_error[ZIO_CHILD_TYPES];
+	uint64_t	io_children[ZIO_CHILD_TYPES][ZIO_WAIT_TYPES];
+	uint64_t	io_child_count;
+	uint64_t	io_phys_children;
+	uint64_t	io_parent_count;
+	uint64_t	*io_stall;
+	zio_t		*io_gang_leader;
+	zio_gang_node_t	*io_gang_tree;
+	void		*io_executor;
+	void		*io_waiter;
+	void		*io_bio;
+	kmutex_t	io_lock;
+	kcondvar_t	io_cv;
+	int		io_allocator;
+
+	/* FMA state */
+	zio_cksum_report_t *io_cksum_report;
+	uint64_t	io_ena;
+
+	/* Taskq dispatching state */
+	taskq_ent_t	io_tqent;
+};
+
+enum blk_verify_flag {
+	BLK_VERIFY_ONLY,
+	BLK_VERIFY_LOG,
+	BLK_VERIFY_HALT
+};
+
+extern int zio_bookmark_compare(const void *, const void *);
+
+extern zio_t *zio_null(zio_t *pio, spa_t *spa, vdev_t *vd,
+    zio_done_func_t *done, void *priv, enum zio_flag flags);
+
+extern zio_t *zio_root(spa_t *spa,
+    zio_done_func_t *done, void *priv, enum zio_flag flags);
+
+extern zio_t *zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp,
+    struct abd *data, uint64_t lsize, zio_done_func_t *done, void *priv,
+    zio_priority_t priority, enum zio_flag flags, const zbookmark_phys_t *zb);
+
+extern zio_t *zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
+    struct abd *data, uint64_t size, uint64_t psize, const zio_prop_t *zp,
+    zio_done_func_t *ready, zio_done_func_t *children_ready,
+    zio_done_func_t *physdone, zio_done_func_t *done,
+    void *priv, zio_priority_t priority, enum zio_flag flags,
+    const zbookmark_phys_t *zb);
+
+extern zio_t *zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
+    struct abd *data, uint64_t size, zio_done_func_t *done, void *priv,
+    zio_priority_t priority, enum zio_flag flags, zbookmark_phys_t *zb);
+
+extern void zio_write_override(zio_t *zio, blkptr_t *bp, int copies,
+    boolean_t nopwrite);
+
+extern void zio_free(spa_t *spa, uint64_t txg, const blkptr_t *bp);
+
+extern zio_t *zio_claim(zio_t *pio, spa_t *spa, uint64_t txg,
+    const blkptr_t *bp,
+    zio_done_func_t *done, void *priv, enum zio_flag flags);
+
+extern zio_t *zio_ioctl(zio_t *pio, spa_t *spa, vdev_t *vd, int cmd,
+    zio_done_func_t *done, void *priv, enum zio_flag flags);
+
+extern zio_t *zio_trim(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size,
+    zio_done_func_t *done, void *priv, zio_priority_t priority,
+    enum zio_flag flags, enum trim_flag trim_flags);
+
+extern zio_t *zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset,
+    uint64_t size, struct abd *data, int checksum,
+    zio_done_func_t *done, void *priv, zio_priority_t priority,
+    enum zio_flag flags, boolean_t labels);
+
+extern zio_t *zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset,
+    uint64_t size, struct abd *data, int checksum,
+    zio_done_func_t *done, void *priv, zio_priority_t priority,
+    enum zio_flag flags, boolean_t labels);
+
+extern zio_t *zio_free_sync(zio_t *pio, spa_t *spa, uint64_t txg,
+    const blkptr_t *bp, enum zio_flag flags);
+
+extern int zio_alloc_zil(spa_t *spa, objset_t *os, uint64_t txg,
+    blkptr_t *new_bp, uint64_t size, boolean_t *slog);
+extern void zio_flush(zio_t *zio, vdev_t *vd);
+extern void zio_shrink(zio_t *zio, uint64_t size);
+
+extern int zio_wait(zio_t *zio);
+extern void zio_nowait(zio_t *zio);
+extern void zio_execute(zio_t *zio);
+extern void zio_interrupt(zio_t *zio);
+extern void zio_delay_init(zio_t *zio);
+extern void zio_delay_interrupt(zio_t *zio);
+extern void zio_deadman(zio_t *zio, char *tag);
+
+extern zio_t *zio_walk_parents(zio_t *cio, zio_link_t **);
+extern zio_t *zio_walk_children(zio_t *pio, zio_link_t **);
+extern zio_t *zio_unique_parent(zio_t *cio);
+extern void zio_add_child(zio_t *pio, zio_t *cio);
+
+extern void *zio_buf_alloc(size_t size);
+extern void zio_buf_free(void *buf, size_t size);
+extern void *zio_data_buf_alloc(size_t size);
+extern void zio_data_buf_free(void *buf, size_t size);
+
+extern void zio_push_transform(zio_t *zio, struct abd *abd, uint64_t size,
+    uint64_t bufsize, zio_transform_func_t *transform);
+extern void zio_pop_transforms(zio_t *zio);
+
+extern void zio_resubmit_stage_async(void *);
+
+extern zio_t *zio_vdev_child_io(zio_t *zio, blkptr_t *bp, vdev_t *vd,
+    uint64_t offset, struct abd *data, uint64_t size, int type,
+    zio_priority_t priority, enum zio_flag flags,
+    zio_done_func_t *done, void *priv);
+
+extern zio_t *zio_vdev_delegated_io(vdev_t *vd, uint64_t offset,
+    struct abd *data, uint64_t size, zio_type_t type, zio_priority_t priority,
+    enum zio_flag flags, zio_done_func_t *done, void *priv);
+
+extern void zio_vdev_io_bypass(zio_t *zio);
+extern void zio_vdev_io_reissue(zio_t *zio);
+extern void zio_vdev_io_redone(zio_t *zio);
+
+extern void zio_change_priority(zio_t *pio, zio_priority_t priority);
+
+extern void zio_checksum_verified(zio_t *zio);
+extern int zio_worst_error(int e1, int e2);
+
+extern enum zio_checksum zio_checksum_select(enum zio_checksum child,
+    enum zio_checksum parent);
+extern enum zio_checksum zio_checksum_dedup_select(spa_t *spa,
+    enum zio_checksum child, enum zio_checksum parent);
+extern enum zio_compress zio_compress_select(spa_t *spa,
+    enum zio_compress child, enum zio_compress parent);
+extern uint8_t zio_complevel_select(spa_t *spa, enum zio_compress compress,
+    uint8_t child, uint8_t parent);
+
+extern void zio_suspend(spa_t *spa, zio_t *zio, zio_suspend_reason_t);
+extern int zio_resume(spa_t *spa);
+extern void zio_resume_wait(spa_t *spa);
+
+extern boolean_t zfs_blkptr_verify(spa_t *spa, const blkptr_t *bp,
+    boolean_t config_held, enum blk_verify_flag blk_verify);
+
+/*
+ * Initial setup and teardown.
+ */
+extern void zio_init(void);
+extern void zio_fini(void);
+
+/*
+ * Fault injection
+ */
+struct zinject_record;
+extern uint32_t zio_injection_enabled;
+extern int zio_inject_fault(char *name, int flags, int *id,
+    struct zinject_record *record);
+extern int zio_inject_list_next(int *id, char *name, size_t buflen,
+    struct zinject_record *record);
+extern int zio_clear_fault(int id);
+extern void zio_handle_panic_injection(spa_t *spa, char *tag, uint64_t type);
+extern int zio_handle_decrypt_injection(spa_t *spa, const zbookmark_phys_t *zb,
+    uint64_t type, int error);
+extern int zio_handle_fault_injection(zio_t *zio, int error);
+extern int zio_handle_device_injection(vdev_t *vd, zio_t *zio, int error);
+extern int zio_handle_device_injections(vdev_t *vd, zio_t *zio, int err1,
+    int err2);
+extern int zio_handle_label_injection(zio_t *zio, int error);
+extern void zio_handle_ignored_writes(zio_t *zio);
+extern hrtime_t zio_handle_io_delay(zio_t *zio);
+
+/*
+ * Checksum ereport functions
+ */
+extern void zfs_ereport_start_checksum(spa_t *spa, vdev_t *vd,
+    const zbookmark_phys_t *zb, struct zio *zio, uint64_t offset,
+    uint64_t length, void *arg, struct zio_bad_cksum *info);
+extern void zfs_ereport_finish_checksum(zio_cksum_report_t *report,
+    const abd_t *good_data, const abd_t *bad_data, boolean_t drop_if_identical);
+
+extern void zfs_ereport_free_checksum(zio_cksum_report_t *report);
+
+/* If we have the good data in hand, this function can be used */
+extern int zfs_ereport_post_checksum(spa_t *spa, vdev_t *vd,
+    const zbookmark_phys_t *zb, struct zio *zio, uint64_t offset,
+    uint64_t length, const abd_t *good_data, const abd_t *bad_data,
+    struct zio_bad_cksum *info);
+
+/* Called from spa_sync(), but primarily an injection handler */
+extern void spa_handle_ignored_writes(spa_t *spa);
+
+/* zbookmark_phys functions */
+boolean_t zbookmark_subtree_completed(const struct dnode_phys *dnp,
+    const zbookmark_phys_t *subtree_root, const zbookmark_phys_t *last_block);
+int zbookmark_compare(uint16_t dbss1, uint8_t ibs1, uint16_t dbss2,
+    uint8_t ibs2, const zbookmark_phys_t *zb1, const zbookmark_phys_t *zb2);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _ZIO_H */
diff --git a/include/sys/zio_checksum.h b/include/sys/zio_checksum.h
new file mode 100644
index 0000000000000..45abd3bd313b6
--- /dev/null
+++ b/include/sys/zio_checksum.h
@@ -0,0 +1,144 @@
+/*
+ * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2016 by Delphix. All rights reserved.
+ * Copyright Saso Kiselkov 2013, All rights reserved.
+ */
+
+#ifndef _SYS_ZIO_CHECKSUM_H
+#define	_SYS_ZIO_CHECKSUM_H
+
+#include <sys/zio.h>
+#include <zfeature_common.h>
+#include <zfs_fletcher.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct abd;
+
+/*
+ * Signature for checksum functions.
+ */
+typedef void zio_checksum_t(struct abd *abd, uint64_t size,
+    const void *ctx_template, zio_cksum_t *zcp);
+typedef void *zio_checksum_tmpl_init_t(const zio_cksum_salt_t *salt);
+typedef void zio_checksum_tmpl_free_t(void *ctx_template);
+
+typedef enum zio_checksum_flags {
+	/* Strong enough for metadata? */
+	ZCHECKSUM_FLAG_METADATA = (1 << 1),
+	/* ZIO embedded checksum */
+	ZCHECKSUM_FLAG_EMBEDDED = (1 << 2),
+	/* Strong enough for dedup (without verification)? */
+	ZCHECKSUM_FLAG_DEDUP = (1 << 3),
+	/* Uses salt value */
+	ZCHECKSUM_FLAG_SALTED = (1 << 4),
+	/* Strong enough for nopwrite? */
+	ZCHECKSUM_FLAG_NOPWRITE = (1 << 5)
+} zio_checksum_flags_t;
+
+typedef enum {
+	ZIO_CHECKSUM_NATIVE,
+	ZIO_CHECKSUM_BYTESWAP
+} zio_byteorder_t;
+
+typedef struct zio_abd_checksum_data {
+	zio_byteorder_t		acd_byteorder;
+	fletcher_4_ctx_t	*acd_ctx;
+	zio_cksum_t 		*acd_zcp;
+	void 			*acd_private;
+} zio_abd_checksum_data_t;
+
+typedef void zio_abd_checksum_init_t(zio_abd_checksum_data_t *);
+typedef void zio_abd_checksum_fini_t(zio_abd_checksum_data_t *);
+typedef int zio_abd_checksum_iter_t(void *, size_t, void *);
+
+typedef const struct zio_abd_checksum_func {
+	zio_abd_checksum_init_t *acf_init;
+	zio_abd_checksum_fini_t *acf_fini;
+	zio_abd_checksum_iter_t *acf_iter;
+} zio_abd_checksum_func_t;
+
+/*
+ * Information about each checksum function.
+ */
+typedef const struct zio_checksum_info {
+	/* checksum function for each byteorder */
+	zio_checksum_t			*ci_func[2];
+	zio_checksum_tmpl_init_t	*ci_tmpl_init;
+	zio_checksum_tmpl_free_t	*ci_tmpl_free;
+	zio_checksum_flags_t		ci_flags;
+	char				*ci_name;	/* descriptive name */
+} zio_checksum_info_t;
+
+typedef struct zio_bad_cksum {
+	zio_cksum_t		zbc_expected;
+	zio_cksum_t		zbc_actual;
+	const char		*zbc_checksum_name;
+	uint8_t			zbc_byteswapped;
+	uint8_t			zbc_injected;
+	uint8_t			zbc_has_cksum;	/* expected/actual valid */
+} zio_bad_cksum_t;
+
+extern zio_checksum_info_t zio_checksum_table[ZIO_CHECKSUM_FUNCTIONS];
+
+/*
+ * Checksum routines.
+ */
+extern zio_checksum_t abd_checksum_SHA256;
+extern zio_checksum_t abd_checksum_SHA512_native;
+extern zio_checksum_t abd_checksum_SHA512_byteswap;
+
+/* Skein */
+extern zio_checksum_t abd_checksum_skein_native;
+extern zio_checksum_t abd_checksum_skein_byteswap;
+extern zio_checksum_tmpl_init_t abd_checksum_skein_tmpl_init;
+extern zio_checksum_tmpl_free_t abd_checksum_skein_tmpl_free;
+
+/* Edon-R */
+extern zio_checksum_t abd_checksum_edonr_native;
+extern zio_checksum_t abd_checksum_edonr_byteswap;
+extern zio_checksum_tmpl_init_t abd_checksum_edonr_tmpl_init;
+extern zio_checksum_tmpl_free_t abd_checksum_edonr_tmpl_free;
+
+extern zio_abd_checksum_func_t fletcher_4_abd_ops;
+extern zio_checksum_t abd_fletcher_4_native;
+extern zio_checksum_t abd_fletcher_4_byteswap;
+
+extern int zio_checksum_equal(spa_t *, blkptr_t *, enum zio_checksum,
+    void *, uint64_t, uint64_t, zio_bad_cksum_t *);
+extern void zio_checksum_compute(zio_t *, enum zio_checksum,
+    struct abd *, uint64_t);
+extern int zio_checksum_error_impl(spa_t *, const blkptr_t *, enum zio_checksum,
+    struct abd *, uint64_t, uint64_t, zio_bad_cksum_t *);
+extern int zio_checksum_error(zio_t *zio, zio_bad_cksum_t *out);
+extern enum zio_checksum spa_dedup_checksum(spa_t *spa);
+extern void zio_checksum_templates_free(spa_t *spa);
+extern spa_feature_t zio_checksum_to_feature(enum zio_checksum cksum);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZIO_CHECKSUM_H */
diff --git a/include/sys/zio_compress.h b/include/sys/zio_compress.h
new file mode 100644
index 0000000000000..4a22ad2a27428
--- /dev/null
+++ b/include/sys/zio_compress.h
@@ -0,0 +1,198 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright (c) 2019, Allan Jude
+ * Copyright (c) 2019, Klara Inc.
+ * Use is subject to license terms.
+ * Copyright (c) 2015, 2016 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_ZIO_COMPRESS_H
+#define	_SYS_ZIO_COMPRESS_H
+
+#include <sys/abd.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+enum zio_compress {
+	ZIO_COMPRESS_INHERIT = 0,
+	ZIO_COMPRESS_ON,
+	ZIO_COMPRESS_OFF,
+	ZIO_COMPRESS_LZJB,
+	ZIO_COMPRESS_EMPTY,
+	ZIO_COMPRESS_GZIP_1,
+	ZIO_COMPRESS_GZIP_2,
+	ZIO_COMPRESS_GZIP_3,
+	ZIO_COMPRESS_GZIP_4,
+	ZIO_COMPRESS_GZIP_5,
+	ZIO_COMPRESS_GZIP_6,
+	ZIO_COMPRESS_GZIP_7,
+	ZIO_COMPRESS_GZIP_8,
+	ZIO_COMPRESS_GZIP_9,
+	ZIO_COMPRESS_ZLE,
+	ZIO_COMPRESS_LZ4,
+	ZIO_COMPRESS_ZSTD,
+	ZIO_COMPRESS_FUNCTIONS
+};
+
+/* Compression algorithms that have levels */
+#define	ZIO_COMPRESS_HASLEVEL(compress)	((compress == ZIO_COMPRESS_ZSTD || \
+					(compress >= ZIO_COMPRESS_GZIP_1 && \
+					compress <= ZIO_COMPRESS_GZIP_9)))
+
+#define	ZIO_COMPLEVEL_INHERIT	0
+#define	ZIO_COMPLEVEL_DEFAULT	255
+
+enum zio_zstd_levels {
+	ZIO_ZSTD_LEVEL_INHERIT = 0,
+	ZIO_ZSTD_LEVEL_1,
+#define	ZIO_ZSTD_LEVEL_MIN	ZIO_ZSTD_LEVEL_1
+	ZIO_ZSTD_LEVEL_2,
+	ZIO_ZSTD_LEVEL_3,
+#define	ZIO_ZSTD_LEVEL_DEFAULT	ZIO_ZSTD_LEVEL_3
+	ZIO_ZSTD_LEVEL_4,
+	ZIO_ZSTD_LEVEL_5,
+	ZIO_ZSTD_LEVEL_6,
+	ZIO_ZSTD_LEVEL_7,
+	ZIO_ZSTD_LEVEL_8,
+	ZIO_ZSTD_LEVEL_9,
+	ZIO_ZSTD_LEVEL_10,
+	ZIO_ZSTD_LEVEL_11,
+	ZIO_ZSTD_LEVEL_12,
+	ZIO_ZSTD_LEVEL_13,
+	ZIO_ZSTD_LEVEL_14,
+	ZIO_ZSTD_LEVEL_15,
+	ZIO_ZSTD_LEVEL_16,
+	ZIO_ZSTD_LEVEL_17,
+	ZIO_ZSTD_LEVEL_18,
+	ZIO_ZSTD_LEVEL_19,
+#define	ZIO_ZSTD_LEVEL_MAX	ZIO_ZSTD_LEVEL_19
+	ZIO_ZSTD_LEVEL_RESERVE = 101, /* Leave room for new positive levels */
+	ZIO_ZSTD_LEVEL_FAST, /* Fast levels are negative */
+	ZIO_ZSTD_LEVEL_FAST_1,
+#define	ZIO_ZSTD_LEVEL_FAST_DEFAULT	ZIO_ZSTD_LEVEL_FAST_1
+	ZIO_ZSTD_LEVEL_FAST_2,
+	ZIO_ZSTD_LEVEL_FAST_3,
+	ZIO_ZSTD_LEVEL_FAST_4,
+	ZIO_ZSTD_LEVEL_FAST_5,
+	ZIO_ZSTD_LEVEL_FAST_6,
+	ZIO_ZSTD_LEVEL_FAST_7,
+	ZIO_ZSTD_LEVEL_FAST_8,
+	ZIO_ZSTD_LEVEL_FAST_9,
+	ZIO_ZSTD_LEVEL_FAST_10,
+	ZIO_ZSTD_LEVEL_FAST_20,
+	ZIO_ZSTD_LEVEL_FAST_30,
+	ZIO_ZSTD_LEVEL_FAST_40,
+	ZIO_ZSTD_LEVEL_FAST_50,
+	ZIO_ZSTD_LEVEL_FAST_60,
+	ZIO_ZSTD_LEVEL_FAST_70,
+	ZIO_ZSTD_LEVEL_FAST_80,
+	ZIO_ZSTD_LEVEL_FAST_90,
+	ZIO_ZSTD_LEVEL_FAST_100,
+	ZIO_ZSTD_LEVEL_FAST_500,
+	ZIO_ZSTD_LEVEL_FAST_1000,
+#define	ZIO_ZSTD_LEVEL_FAST_MAX	ZIO_ZSTD_LEVEL_FAST_1000
+	ZIO_ZSTD_LEVEL_AUTO = 251, /* Reserved for future use */
+	ZIO_ZSTD_LEVEL_LEVELS
+};
+
+/* Forward Declaration to avoid visibility problems */
+struct zio_prop;
+
+/* Common signature for all zio compress functions. */
+typedef size_t zio_compress_func_t(void *src, void *dst,
+    size_t s_len, size_t d_len, int);
+/* Common signature for all zio decompress functions. */
+typedef int zio_decompress_func_t(void *src, void *dst,
+    size_t s_len, size_t d_len, int);
+/* Common signature for all zio decompress and get level functions. */
+typedef int zio_decompresslevel_func_t(void *src, void *dst,
+    size_t s_len, size_t d_len, uint8_t *level);
+/* Common signature for all zio get-compression-level functions. */
+typedef int zio_getlevel_func_t(void *src, size_t s_len, uint8_t *level);
+
+
+/*
+ * Common signature for all zio decompress functions using an ABD as input.
+ * This is helpful if you have both compressed ARC and scatter ABDs enabled,
+ * but is not a requirement for all compression algorithms.
+ */
+typedef int zio_decompress_abd_func_t(abd_t *src, void *dst,
+    size_t s_len, size_t d_len, int);
+/*
+ * Information about each compression function.
+ */
+typedef const struct zio_compress_info {
+	char				*ci_name;
+	int				ci_level;
+	zio_compress_func_t		*ci_compress;
+	zio_decompress_func_t		*ci_decompress;
+	zio_decompresslevel_func_t	*ci_decompress_level;
+} zio_compress_info_t;
+
+extern zio_compress_info_t zio_compress_table[ZIO_COMPRESS_FUNCTIONS];
+
+/*
+ * lz4 compression init & free
+ */
+extern void lz4_init(void);
+extern void lz4_fini(void);
+
+/*
+ * Compression routines.
+ */
+extern size_t lzjb_compress(void *src, void *dst, size_t s_len, size_t d_len,
+    int level);
+extern int lzjb_decompress(void *src, void *dst, size_t s_len, size_t d_len,
+    int level);
+extern size_t gzip_compress(void *src, void *dst, size_t s_len, size_t d_len,
+    int level);
+extern int gzip_decompress(void *src, void *dst, size_t s_len, size_t d_len,
+    int level);
+extern size_t zle_compress(void *src, void *dst, size_t s_len, size_t d_len,
+    int level);
+extern int zle_decompress(void *src, void *dst, size_t s_len, size_t d_len,
+    int level);
+extern size_t lz4_compress_zfs(void *src, void *dst, size_t s_len, size_t d_len,
+    int level);
+extern int lz4_decompress_zfs(void *src, void *dst, size_t s_len, size_t d_len,
+    int level);
+
+/*
+ * Compress and decompress data if necessary.
+ */
+extern size_t zio_compress_data(enum zio_compress c, abd_t *src, void *dst,
+    size_t s_len, uint8_t level);
+extern int zio_decompress_data(enum zio_compress c, abd_t *src, void *dst,
+    size_t s_len, size_t d_len, uint8_t *level);
+extern int zio_decompress_data_buf(enum zio_compress c, void *src, void *dst,
+    size_t s_len, size_t d_len, uint8_t *level);
+extern int zio_compress_to_feature(enum zio_compress comp);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ZIO_COMPRESS_H */
diff --git a/include/sys/zio_crypt.h b/include/sys/zio_crypt.h
new file mode 100644
index 0000000000000..d7a63d69582dc
--- /dev/null
+++ b/include/sys/zio_crypt.h
@@ -0,0 +1,160 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2017, Datto, Inc. All rights reserved.
+ */
+
+#ifndef	_SYS_ZIO_CRYPT_H
+#define	_SYS_ZIO_CRYPT_H
+
+#include <sys/dmu.h>
+#include <sys/zfs_refcount.h>
+#if defined(__FreeBSD__) && defined(_KERNEL)
+#include <sys/freebsd_crypto.h>
+#else
+#include <sys/crypto/api.h>
+#endif /* __FreeBSD__ */
+#include <sys/nvpair.h>
+#include <sys/avl.h>
+#include <sys/zio.h>
+
+/* forward declarations */
+struct zbookmark_phys;
+
+#define	WRAPPING_KEY_LEN	32
+#define	WRAPPING_IV_LEN		ZIO_DATA_IV_LEN
+#define	WRAPPING_MAC_LEN	ZIO_DATA_MAC_LEN
+#define	MASTER_KEY_MAX_LEN	32
+#define	SHA512_HMAC_KEYLEN	64
+
+#define	ZIO_CRYPT_KEY_CURRENT_VERSION	1ULL
+
+typedef enum zio_crypt_type {
+	ZC_TYPE_NONE = 0,
+	ZC_TYPE_CCM,
+	ZC_TYPE_GCM
+} zio_crypt_type_t;
+
+/* table of supported crypto algorithms, modes and keylengths. */
+typedef struct zio_crypt_info {
+	/* mechanism name, needed by ICP */
+#if defined(__FreeBSD__) && defined(_KERNEL)
+	/*
+	 * I've deliberately used a different name here, to catch
+	 * ICP-using code.
+	 */
+	const char	*ci_algname;
+#else
+	crypto_mech_name_t ci_mechname;
+#endif
+	/* cipher mode type (GCM, CCM) */
+	zio_crypt_type_t ci_crypt_type;
+
+	/* length of the encryption key */
+	size_t ci_keylen;
+
+	/* human-readable name of the encryption algorithm */
+	char *ci_name;
+} zio_crypt_info_t;
+
+extern zio_crypt_info_t zio_crypt_table[ZIO_CRYPT_FUNCTIONS];
+
+/* in memory representation of an unwrapped key that is loaded into memory */
+typedef struct zio_crypt_key {
+	/* encryption algorithm */
+	uint64_t zk_crypt;
+
+	/* on-disk format version */
+	uint64_t zk_version;
+
+	/* GUID for uniquely identifying this key. Not encrypted on disk. */
+	uint64_t zk_guid;
+
+	/* buffer for master key */
+	uint8_t zk_master_keydata[MASTER_KEY_MAX_LEN];
+
+	/* buffer for hmac key */
+	uint8_t zk_hmac_keydata[SHA512_HMAC_KEYLEN];
+
+	/* buffer for current encryption key derived from master key */
+	uint8_t zk_current_keydata[MASTER_KEY_MAX_LEN];
+
+	/* current 64 bit salt for deriving an encryption key */
+	uint8_t zk_salt[ZIO_DATA_SALT_LEN];
+
+	/* count of how many times the current salt has been used */
+	uint64_t zk_salt_count;
+
+	/* illumos crypto api current encryption key */
+	crypto_key_t zk_current_key;
+
+#if defined(__FreeBSD__) && defined(_KERNEL)
+	/* Session for current encryption key.  Must always be set */
+	freebsd_crypt_session_t	zk_session;
+#else
+	/* template of current encryption key for illumos crypto api */
+	crypto_ctx_template_t zk_current_tmpl;
+#endif
+
+	/* illumos crypto api current hmac key */
+	crypto_key_t zk_hmac_key;
+
+	/* template of hmac key for illumos crypto api */
+	crypto_ctx_template_t zk_hmac_tmpl;
+
+	/* lock for changing the salt and dependent values */
+	krwlock_t zk_salt_lock;
+} zio_crypt_key_t;
+
+void zio_crypt_key_destroy(zio_crypt_key_t *key);
+int zio_crypt_key_init(uint64_t crypt, zio_crypt_key_t *key);
+int zio_crypt_key_get_salt(zio_crypt_key_t *key, uint8_t *salt_out);
+
+int zio_crypt_key_wrap(crypto_key_t *cwkey, zio_crypt_key_t *key, uint8_t *iv,
+    uint8_t *mac, uint8_t *keydata_out, uint8_t *hmac_keydata_out);
+int zio_crypt_key_unwrap(crypto_key_t *cwkey, uint64_t crypt, uint64_t version,
+    uint64_t guid, uint8_t *keydata, uint8_t *hmac_keydata, uint8_t *iv,
+    uint8_t *mac, zio_crypt_key_t *key);
+int zio_crypt_generate_iv(uint8_t *ivbuf);
+int zio_crypt_generate_iv_salt_dedup(zio_crypt_key_t *key, uint8_t *data,
+    uint_t datalen, uint8_t *ivbuf, uint8_t *salt);
+
+void zio_crypt_encode_params_bp(blkptr_t *bp, uint8_t *salt, uint8_t *iv);
+void zio_crypt_decode_params_bp(const blkptr_t *bp, uint8_t *salt, uint8_t *iv);
+void zio_crypt_encode_mac_bp(blkptr_t *bp, uint8_t *mac);
+void zio_crypt_decode_mac_bp(const blkptr_t *bp, uint8_t *mac);
+void zio_crypt_encode_mac_zil(void *data, uint8_t *mac);
+void zio_crypt_decode_mac_zil(const void *data, uint8_t *mac);
+void zio_crypt_copy_dnode_bonus(abd_t *src_abd, uint8_t *dst, uint_t datalen);
+
+int zio_crypt_do_indirect_mac_checksum(boolean_t generate, void *buf,
+    uint_t datalen, boolean_t byteswap, uint8_t *cksum);
+int zio_crypt_do_indirect_mac_checksum_abd(boolean_t generate, abd_t *abd,
+    uint_t datalen, boolean_t byteswap, uint8_t *cksum);
+int zio_crypt_do_hmac(zio_crypt_key_t *key, uint8_t *data, uint_t datalen,
+    uint8_t *digestbuf, uint_t digestlen);
+int zio_crypt_do_objset_hmacs(zio_crypt_key_t *key, void *data, uint_t datalen,
+    boolean_t byteswap, uint8_t *portable_mac, uint8_t *local_mac);
+int zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key,
+    dmu_object_type_t ot, boolean_t byteswap, uint8_t *salt, uint8_t *iv,
+    uint8_t *mac, uint_t datalen, uint8_t *plainbuf, uint8_t *cipherbuf,
+    boolean_t *no_crypt);
+int zio_do_crypt_abd(boolean_t encrypt, zio_crypt_key_t *key,
+    dmu_object_type_t ot, boolean_t byteswap, uint8_t *salt, uint8_t *iv,
+    uint8_t *mac, uint_t datalen, abd_t *pabd, abd_t *cabd,
+    boolean_t *no_crypt);
+
+#endif
diff --git a/include/sys/zio_impl.h b/include/sys/zio_impl.h
new file mode 100644
index 0000000000000..4c998571653a4
--- /dev/null
+++ b/include/sys/zio_impl.h
@@ -0,0 +1,270 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright (c) 2012, 2015 by Delphix. All rights reserved.
+ */
+
+#ifndef _ZIO_IMPL_H
+#define	_ZIO_IMPL_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * XXX -- Describe ZFS I/O pipeline here. Fill in as needed.
+ *
+ * The ZFS I/O pipeline is comprised of various stages which are defined
+ * in the zio_stage enum below. The individual stages are used to construct
+ * these basic I/O operations: Read, Write, Free, Claim, and Ioctl.
+ *
+ * I/O operations: (XXX - provide detail for each of the operations)
+ *
+ * Read:
+ * Write:
+ * Free:
+ * Claim:
+ * Ioctl:
+ *
+ * Although the most common pipeline are used by the basic I/O operations
+ * above, there are some helper pipelines (one could consider them
+ * sub-pipelines) which are used internally by the ZIO module and are
+ * explained below:
+ *
+ * Interlock Pipeline:
+ * The interlock pipeline is the most basic pipeline and is used by all
+ * of the I/O operations. The interlock pipeline does not perform any I/O
+ * and is used to coordinate the dependencies between I/Os that are being
+ * issued (i.e. the parent/child relationship).
+ *
+ * Vdev child Pipeline:
+ * The vdev child pipeline is responsible for performing the physical I/O.
+ * It is in this pipeline where the I/O are queued and possibly cached.
+ *
+ * In addition to performing I/O, the pipeline is also responsible for
+ * data transformations. The transformations performed are based on the
+ * specific properties that user may have selected and modify the
+ * behavior of the pipeline. Examples of supported transformations are
+ * compression, dedup, and nop writes. Transformations will either modify
+ * the data or the pipeline. This list below further describes each of
+ * the supported transformations:
+ *
+ * Compression:
+ * ZFS supports five different flavors of compression -- gzip, lzjb, lz4, zle,
+ * and zstd. Compression occurs as part of the write pipeline and is
+ * performed in the ZIO_STAGE_WRITE_BP_INIT stage.
+ *
+ * Dedup:
+ * Dedup reads are handled by the ZIO_STAGE_DDT_READ_START and
+ * ZIO_STAGE_DDT_READ_DONE stages. These stages are added to an existing
+ * read pipeline if the dedup bit is set on the block pointer.
+ * Writing a dedup block is performed by the ZIO_STAGE_DDT_WRITE stage
+ * and added to a write pipeline if a user has enabled dedup on that
+ * particular dataset.
+ *
+ * NOP Write:
+ * The NOP write feature is performed by the ZIO_STAGE_NOP_WRITE stage
+ * and is added to an existing write pipeline if a cryptographically
+ * secure checksum (i.e. SHA256) is enabled and compression is turned on.
+ * The NOP write stage will compare the checksums of the current data
+ * on-disk (level-0 blocks only) and the data that is currently being written.
+ * If the checksum values are identical then the pipeline is converted to
+ * an interlock pipeline skipping block allocation and bypassing the
+ * physical I/O.  The nop write feature can handle writes in either
+ * syncing or open context (i.e. zil writes) and as a result is mutually
+ * exclusive with dedup.
+ *
+ * Encryption:
+ * Encryption and authentication is handled by the ZIO_STAGE_ENCRYPT stage.
+ * This stage determines how the encryption metadata is stored in the bp.
+ * Decryption and MAC verification is performed during zio_decrypt() as a
+ * transform callback. Encryption is mutually exclusive with nopwrite, because
+ * blocks with the same plaintext will be encrypted with different salts and
+ * IV's (if dedup is off), and therefore have different ciphertexts. For dedup
+ * blocks we deterministically generate the IV and salt by performing an HMAC
+ * of the plaintext, which is computationally expensive, but allows us to keep
+ * support for encrypted dedup. See the block comment in zio_crypt.c for
+ * details.
+ */
+
+/*
+ * zio pipeline stage definitions
+ */
+enum zio_stage {
+	ZIO_STAGE_OPEN			= 1 << 0,	/* RWFCI */
+
+	ZIO_STAGE_READ_BP_INIT		= 1 << 1,	/* R---- */
+	ZIO_STAGE_WRITE_BP_INIT		= 1 << 2,	/* -W--- */
+	ZIO_STAGE_FREE_BP_INIT		= 1 << 3,	/* --F-- */
+	ZIO_STAGE_ISSUE_ASYNC		= 1 << 4,	/* RWF-- */
+	ZIO_STAGE_WRITE_COMPRESS	= 1 << 5,	/* -W--- */
+
+	ZIO_STAGE_ENCRYPT		= 1 << 6,	/* -W--- */
+	ZIO_STAGE_CHECKSUM_GENERATE	= 1 << 7,	/* -W--- */
+
+	ZIO_STAGE_NOP_WRITE		= 1 << 8,	/* -W--- */
+
+	ZIO_STAGE_DDT_READ_START	= 1 << 9,	/* R---- */
+	ZIO_STAGE_DDT_READ_DONE		= 1 << 10,	/* R---- */
+	ZIO_STAGE_DDT_WRITE		= 1 << 11,	/* -W--- */
+	ZIO_STAGE_DDT_FREE		= 1 << 12,	/* --F-- */
+
+	ZIO_STAGE_GANG_ASSEMBLE		= 1 << 13,	/* RWFC- */
+	ZIO_STAGE_GANG_ISSUE		= 1 << 14,	/* RWFC- */
+
+	ZIO_STAGE_DVA_THROTTLE		= 1 << 15,	/* -W--- */
+	ZIO_STAGE_DVA_ALLOCATE		= 1 << 16,	/* -W--- */
+	ZIO_STAGE_DVA_FREE		= 1 << 17,	/* --F-- */
+	ZIO_STAGE_DVA_CLAIM		= 1 << 18,	/* ---C- */
+
+	ZIO_STAGE_READY			= 1 << 19,	/* RWFCI */
+
+	ZIO_STAGE_VDEV_IO_START		= 1 << 20,	/* RW--I */
+	ZIO_STAGE_VDEV_IO_DONE		= 1 << 21,	/* RW--I */
+	ZIO_STAGE_VDEV_IO_ASSESS	= 1 << 22,	/* RW--I */
+
+	ZIO_STAGE_CHECKSUM_VERIFY	= 1 << 23,	/* R---- */
+
+	ZIO_STAGE_DONE			= 1 << 24	/* RWFCI */
+};
+
+#define	ZIO_INTERLOCK_STAGES			\
+	(ZIO_STAGE_READY |			\
+	ZIO_STAGE_DONE)
+
+#define	ZIO_INTERLOCK_PIPELINE			\
+	ZIO_INTERLOCK_STAGES
+
+#define	ZIO_VDEV_IO_STAGES			\
+	(ZIO_STAGE_VDEV_IO_START |		\
+	ZIO_STAGE_VDEV_IO_DONE |		\
+	ZIO_STAGE_VDEV_IO_ASSESS)
+
+#define	ZIO_VDEV_CHILD_PIPELINE			\
+	(ZIO_VDEV_IO_STAGES |			\
+	ZIO_STAGE_DONE)
+
+#define	ZIO_READ_COMMON_STAGES			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_VDEV_IO_STAGES |			\
+	ZIO_STAGE_CHECKSUM_VERIFY)
+
+#define	ZIO_READ_PHYS_PIPELINE			\
+	ZIO_READ_COMMON_STAGES
+
+#define	ZIO_READ_PIPELINE			\
+	(ZIO_READ_COMMON_STAGES |		\
+	ZIO_STAGE_READ_BP_INIT)
+
+#define	ZIO_DDT_CHILD_READ_PIPELINE		\
+	ZIO_READ_COMMON_STAGES
+
+#define	ZIO_DDT_READ_PIPELINE			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_STAGE_READ_BP_INIT |		\
+	ZIO_STAGE_DDT_READ_START |		\
+	ZIO_STAGE_DDT_READ_DONE)
+
+#define	ZIO_WRITE_COMMON_STAGES			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_VDEV_IO_STAGES |			\
+	ZIO_STAGE_ISSUE_ASYNC |			\
+	ZIO_STAGE_CHECKSUM_GENERATE)
+
+#define	ZIO_WRITE_PHYS_PIPELINE			\
+	ZIO_WRITE_COMMON_STAGES
+
+#define	ZIO_REWRITE_PIPELINE			\
+	(ZIO_WRITE_COMMON_STAGES |		\
+	ZIO_STAGE_WRITE_COMPRESS |		\
+	ZIO_STAGE_ENCRYPT |			\
+	ZIO_STAGE_WRITE_BP_INIT)
+
+#define	ZIO_WRITE_PIPELINE			\
+	(ZIO_WRITE_COMMON_STAGES |		\
+	ZIO_STAGE_WRITE_BP_INIT |		\
+	ZIO_STAGE_WRITE_COMPRESS |		\
+	ZIO_STAGE_ENCRYPT |			\
+	ZIO_STAGE_DVA_THROTTLE |		\
+	ZIO_STAGE_DVA_ALLOCATE)
+
+#define	ZIO_DDT_CHILD_WRITE_PIPELINE		\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_VDEV_IO_STAGES |			\
+	ZIO_STAGE_DVA_THROTTLE |		\
+	ZIO_STAGE_DVA_ALLOCATE)
+
+#define	ZIO_DDT_WRITE_PIPELINE			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_STAGE_WRITE_BP_INIT |		\
+	ZIO_STAGE_ISSUE_ASYNC |			\
+	ZIO_STAGE_WRITE_COMPRESS |		\
+	ZIO_STAGE_ENCRYPT |			\
+	ZIO_STAGE_CHECKSUM_GENERATE |		\
+	ZIO_STAGE_DDT_WRITE)
+
+#define	ZIO_GANG_STAGES				\
+	(ZIO_STAGE_GANG_ASSEMBLE |		\
+	ZIO_STAGE_GANG_ISSUE)
+
+#define	ZIO_FREE_PIPELINE			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_STAGE_FREE_BP_INIT |		\
+	ZIO_STAGE_DVA_FREE)
+
+#define	ZIO_DDT_FREE_PIPELINE			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_STAGE_FREE_BP_INIT |		\
+	ZIO_STAGE_ISSUE_ASYNC |			\
+	ZIO_STAGE_DDT_FREE)
+
+#define	ZIO_CLAIM_PIPELINE			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_STAGE_DVA_CLAIM)
+
+#define	ZIO_IOCTL_PIPELINE			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_STAGE_VDEV_IO_START |		\
+	ZIO_STAGE_VDEV_IO_ASSESS)
+
+#define	ZIO_TRIM_PIPELINE			\
+	(ZIO_INTERLOCK_STAGES |			\
+	ZIO_STAGE_ISSUE_ASYNC |			\
+	ZIO_VDEV_IO_STAGES)
+
+#define	ZIO_BLOCKING_STAGES			\
+	(ZIO_STAGE_DVA_ALLOCATE |		\
+	ZIO_STAGE_DVA_CLAIM |			\
+	ZIO_STAGE_VDEV_IO_START)
+
+extern void zio_inject_init(void);
+extern void zio_inject_fini(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _ZIO_IMPL_H */
diff --git a/include/sys/zio_priority.h b/include/sys/zio_priority.h
new file mode 100644
index 0000000000000..2d8e7fc36bae6
--- /dev/null
+++ b/include/sys/zio_priority.h
@@ -0,0 +1,43 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (c) 2014, 2016 by Delphix. All rights reserved.
+ */
+#ifndef	_ZIO_PRIORITY_H
+#define	_ZIO_PRIORITY_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef enum zio_priority {
+	ZIO_PRIORITY_SYNC_READ,
+	ZIO_PRIORITY_SYNC_WRITE,	/* ZIL */
+	ZIO_PRIORITY_ASYNC_READ,	/* prefetch */
+	ZIO_PRIORITY_ASYNC_WRITE,	/* spa_sync() */
+	ZIO_PRIORITY_SCRUB,		/* asynchronous scrub/resilver reads */
+	ZIO_PRIORITY_REMOVAL,		/* reads/writes for vdev removal */
+	ZIO_PRIORITY_INITIALIZING,	/* initializing I/O */
+	ZIO_PRIORITY_TRIM,		/* trim I/O (discard) */
+	ZIO_PRIORITY_REBUILD,		/* reads/writes for vdev rebuild */
+	ZIO_PRIORITY_NUM_QUEUEABLE,
+	ZIO_PRIORITY_NOW,		/* non-queued i/os (e.g. free) */
+} zio_priority_t;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _ZIO_PRIORITY_H */
diff --git a/include/sys/zrlock.h b/include/sys/zrlock.h
new file mode 100644
index 0000000000000..b6eba1a18ff45
--- /dev/null
+++ b/include/sys/zrlock.h
@@ -0,0 +1,63 @@
+/*
+ * 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) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015 by Delphix. All rights reserved.
+ */
+
+#ifndef	_SYS_ZRLOCK_H
+#define	_SYS_ZRLOCK_H
+
+#include <sys/zfs_context.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct zrlock {
+	kmutex_t zr_mtx;
+	volatile int32_t zr_refcount;
+	kcondvar_t zr_cv;
+	uint16_t zr_pad;
+#ifdef	ZFS_DEBUG
+	kthread_t *zr_owner;
+	const char *zr_caller;
+#endif
+} zrlock_t;
+
+extern void zrl_init(zrlock_t *);
+extern void zrl_destroy(zrlock_t *);
+#define	zrl_add(_z)	zrl_add_impl((_z), __func__)
+extern void zrl_add_impl(zrlock_t *, const char *);
+extern void zrl_remove(zrlock_t *);
+extern int zrl_tryenter(zrlock_t *);
+extern void zrl_exit(zrlock_t *);
+extern int zrl_is_zero(zrlock_t *);
+extern int zrl_is_locked(zrlock_t *);
+#ifdef	ZFS_DEBUG
+extern kthread_t *zrl_owner(zrlock_t *);
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_ZRLOCK_H */
diff --git a/include/sys/zstd/Makefile.am b/include/sys/zstd/Makefile.am
new file mode 100644
index 0000000000000..16666fe633551
--- /dev/null
+++ b/include/sys/zstd/Makefile.am
@@ -0,0 +1,18 @@
+COMMON_H = \
+	$(top_srcdir)/include/sys/zstd/zstd.h
+
+KERNEL_H =
+
+USER_H =
+
+EXTRA_DIST = $(COMMON_H) $(KERNEL_H) $(USER_H)
+
+if CONFIG_USER
+libzfsdir = $(includedir)/libzfs/sys/zstd
+libzfs_HEADERS = $(COMMON_H) $(USER_H)
+endif
+
+if CONFIG_KERNEL
+kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys/zstd
+kernel_HEADERS = $(COMMON_H) $(KERNEL_H)
+endif
diff --git a/include/sys/zstd/zstd.h b/include/sys/zstd/zstd.h
new file mode 100644
index 0000000000000..f965df31988c9
--- /dev/null
+++ b/include/sys/zstd/zstd.h
@@ -0,0 +1,98 @@
+/*
+ * BSD 3-Clause New License (https://spdx.org/licenses/BSD-3-Clause.html)
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Copyright (c) 2016-2018, Klara Inc.
+ * Copyright (c) 2016-2018, Allan Jude
+ * Copyright (c) 2018-2020, Sebastian Gottschall
+ * Copyright (c) 2019-2020, Michael Niewöhner
+ * Copyright (c) 2020, The FreeBSD Foundation [1]
+ *
+ * [1] Portions of this software were developed by Allan Jude
+ *     under sponsorship from the FreeBSD Foundation.
+ */
+
+#ifndef	_ZFS_ZSTD_H
+#define	_ZFS_ZSTD_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * ZSTD block header
+ * NOTE: all fields in this header are in big endian order.
+ */
+typedef struct zfs_zstd_header {
+	/* Compressed size of data */
+	uint32_t c_len;
+
+	/*
+	 * Version and compression level
+	 * We use a union to be able to big endian encode a single 32 bit
+	 * unsigned integer, but still access the individual bitmasked
+	 * components easily.
+	 */
+	union {
+		uint32_t raw_version_level;
+		struct {
+			uint32_t version : 24;
+			uint8_t level;
+		};
+	};
+
+	char data[];
+} zfs_zstdhdr_t;
+
+/*
+ * kstat helper macros
+ */
+#define	ZSTDSTAT(stat)		(zstd_stats.stat.value.ui64)
+#define	ZSTDSTAT_INCR(stat, val) \
+	atomic_add_64(&zstd_stats.stat.value.ui64, (val))
+#define	ZSTDSTAT_BUMP(stat)	ZSTDSTAT_INCR(stat, 1)
+
+/* (de)init for user space / kernel emulation */
+int zstd_init(void);
+void zstd_fini(void);
+
+size_t zfs_zstd_compress(void *s_start, void *d_start, size_t s_len,
+    size_t d_len, int level);
+int zfs_zstd_get_level(void *s_start, size_t s_len, uint8_t *level);
+int zfs_zstd_decompress_level(void *s_start, void *d_start, size_t s_len,
+    size_t d_len, uint8_t *level);
+int zfs_zstd_decompress(void *s_start, void *d_start, size_t s_len,
+    size_t d_len, int n);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _ZFS_ZSTD_H */
diff --git a/include/sys/zthr.h b/include/sys/zthr.h
new file mode 100644
index 0000000000000..ae8c57e9eea28
--- /dev/null
+++ b/include/sys/zthr.h
@@ -0,0 +1,42 @@
+/*
+ * CDDL HEADER START
+ *
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source. A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2017, 2018 by Delphix. All rights reserved.
+ */
+
+#ifndef _SYS_ZTHR_H
+#define	_SYS_ZTHR_H
+
+typedef struct zthr zthr_t;
+typedef void (zthr_func_t)(void *, zthr_t *);
+typedef boolean_t (zthr_checkfunc_t)(void *, zthr_t *);
+
+extern zthr_t *zthr_create(const char *zthr_name,
+    zthr_checkfunc_t checkfunc, zthr_func_t *func, void *arg);
+extern zthr_t *zthr_create_timer(const char *zthr_name,
+    zthr_checkfunc_t *checkfunc, zthr_func_t *func, void *arg,
+	hrtime_t nano_wait);
+extern void zthr_destroy(zthr_t *t);
+
+extern void zthr_wakeup(zthr_t *t);
+extern void zthr_cancel(zthr_t *t);
+extern void zthr_resume(zthr_t *t);
+extern void zthr_wait_cycle_done(zthr_t *t);
+
+extern boolean_t zthr_iscancelled(zthr_t *t);
+extern boolean_t zthr_has_waiters(zthr_t *t);
+
+#endif /* _SYS_ZTHR_H */
diff --git a/include/sys/zvol.h b/include/sys/zvol.h
new file mode 100644
index 0000000000000..8efb7f5e60411
--- /dev/null
+++ b/include/sys/zvol.h
@@ -0,0 +1,65 @@
+/*
+ * 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) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016 Actifio, Inc. All rights reserved.
+ */
+
+#ifndef	_SYS_ZVOL_H
+#define	_SYS_ZVOL_H
+
+#include <sys/zfs_context.h>
+
+#define	ZVOL_OBJ		1ULL
+#define	ZVOL_ZAP_OBJ		2ULL
+
+#define	SPEC_MAXOFFSET_T	((1LL << ((NBBY * sizeof (daddr32_t)) + \
+				DEV_BSHIFT - 1)) - 1)
+
+extern void zvol_create_minor(const char *);
+extern void zvol_create_minors_recursive(const char *);
+extern void zvol_remove_minors(spa_t *, const char *, boolean_t);
+extern void zvol_rename_minors(spa_t *, const char *, const char *, boolean_t);
+
+#ifdef _KERNEL
+struct zvol_state;
+typedef struct zvol_state zvol_state_handle_t;
+
+extern int zvol_check_volsize(uint64_t, uint64_t);
+extern int zvol_check_volblocksize(const char *, uint64_t);
+extern int zvol_get_stats(objset_t *, nvlist_t *);
+extern boolean_t zvol_is_zvol(const char *);
+extern void zvol_create_cb(objset_t *, void *, cred_t *, dmu_tx_t *);
+extern int zvol_set_volsize(const char *, uint64_t);
+extern int zvol_set_volblocksize(const char *, uint64_t);
+extern int zvol_set_snapdev(const char *, zprop_source_t, uint64_t);
+extern int zvol_set_volmode(const char *, zprop_source_t, uint64_t);
+extern zvol_state_handle_t *zvol_suspend(const char *);
+extern int zvol_resume(zvol_state_handle_t *);
+extern void *zvol_tag(zvol_state_handle_t *);
+
+extern int zvol_init(void);
+extern void zvol_fini(void);
+extern int zvol_busy(void);
+
+#endif /* _KERNEL */
+#endif /* _SYS_ZVOL_H */
diff --git a/include/sys/zvol_impl.h b/include/sys/zvol_impl.h
new file mode 100644
index 0000000000000..36199c311d072
--- /dev/null
+++ b/include/sys/zvol_impl.h
@@ -0,0 +1,108 @@
+/*
+ * 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
+ */
+
+#ifndef	_SYS_ZVOL_IMPL_H
+#define	_SYS_ZVOL_IMPL_H
+
+#include <sys/zfs_context.h>
+
+#define	ZVOL_RDONLY	0x1
+/*
+ * Whether the zvol has been written to (as opposed to ZVOL_RDONLY, which
+ * specifies whether or not the zvol _can_ be written to)
+ */
+#define	ZVOL_WRITTEN_TO	0x2
+
+#define	ZVOL_DUMPIFIED	0x4
+
+#define	ZVOL_EXCL	0x8
+
+/*
+ * The in-core state of each volume.
+ */
+typedef struct zvol_state {
+	char			zv_name[MAXNAMELEN];	/* name */
+	uint64_t		zv_volsize;		/* advertised space */
+	uint64_t		zv_volblocksize;	/* volume block size */
+	objset_t		*zv_objset;	/* objset handle */
+	uint32_t		zv_flags;	/* ZVOL_* flags */
+	uint32_t		zv_open_count;	/* open counts */
+	uint32_t		zv_changed;	/* disk changed */
+	zilog_t			*zv_zilog;	/* ZIL handle */
+	zfs_rangelock_t		zv_rangelock;	/* for range locking */
+	dnode_t			*zv_dn;		/* dnode hold */
+	dataset_kstats_t	zv_kstat;	/* zvol kstats */
+	list_node_t		zv_next;	/* next zvol_state_t linkage */
+	uint64_t		zv_hash;	/* name hash */
+	struct hlist_node	zv_hlink;	/* hash link */
+	kmutex_t		zv_state_lock;	/* protects zvol_state_t */
+	atomic_t		zv_suspend_ref;	/* refcount for suspend */
+	krwlock_t		zv_suspend_lock;	/* suspend lock */
+	struct zvol_state_os	*zv_zso;	/* private platform state */
+} zvol_state_t;
+
+
+extern list_t zvol_state_list;
+extern krwlock_t zvol_state_lock;
+#define	ZVOL_HT_SIZE	1024
+extern struct hlist_head *zvol_htable;
+#define	ZVOL_HT_HEAD(hash)	(&zvol_htable[(hash) & (ZVOL_HT_SIZE-1)])
+extern zil_replay_func_t *zvol_replay_vector[TX_MAX_TYPE];
+
+extern unsigned int zvol_volmode;
+extern unsigned int zvol_inhibit_dev;
+
+/*
+ * platform independent functions exported to platform code
+ */
+zvol_state_t *zvol_find_by_name_hash(const char *name,
+    uint64_t hash, int mode);
+int zvol_first_open(zvol_state_t *zv, boolean_t readonly);
+uint64_t zvol_name_hash(const char *name);
+void zvol_remove_minors_impl(const char *name);
+void zvol_last_close(zvol_state_t *zv);
+void zvol_insert(zvol_state_t *zv);
+void zvol_log_truncate(zvol_state_t *zv, dmu_tx_t *tx, uint64_t off,
+    uint64_t len, boolean_t sync);
+void zvol_log_write(zvol_state_t *zv, dmu_tx_t *tx, uint64_t offset,
+    uint64_t size, int sync);
+int zvol_get_data(void *arg, lr_write_t *lr, char *buf, struct lwb *lwb,
+    zio_t *zio);
+int zvol_init_impl(void);
+void zvol_fini_impl(void);
+
+/*
+ * platform dependent functions exported to platform independent code
+ */
+typedef struct zvol_platform_ops {
+	void (*zv_free)(zvol_state_t *);
+	void (*zv_rename_minor)(zvol_state_t *, const char *);
+	int (*zv_create_minor)(const char *);
+	int (*zv_update_volsize)(zvol_state_t *, uint64_t);
+	boolean_t (*zv_is_zvol)(const char *);
+	void (*zv_clear_private)(zvol_state_t *);
+	void (*zv_set_disk_ro)(zvol_state_t *, int flags);
+	void (*zv_set_capacity)(zvol_state_t *, uint64_t capacity);
+} zvol_platform_ops_t;
+
+void zvol_register_ops(const zvol_platform_ops_t *ops);
+
+#endif