Index: boot/Makefile.common
===================================================================
--- boot/Makefile.common	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ boot/Makefile.common	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -165,4 +165,5 @@
 	$(USPACE_PATH)/app/locinfo/locinfo \
 	$(USPACE_PATH)/app/mkfat/mkfat \
+	$(USPACE_PATH)/app/mkexfat/mkexfat \
 	$(USPACE_PATH)/app/mkmfs/mkmfs \
 	$(USPACE_PATH)/app/lsusb/lsusb \
Index: uspace/Makefile
===================================================================
--- uspace/Makefile	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ uspace/Makefile	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -48,4 +48,5 @@
 	app/lsusb \
 	app/mkfat \
+	app/mkexfat \
 	app/mkmfs \
 	app/redir \
Index: uspace/app/mkexfat/Makefile
===================================================================
--- uspace/app/mkexfat/Makefile	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
+++ uspace/app/mkexfat/Makefile	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -0,0 +1,37 @@
+#
+# Copyright (c) 2012 Maurizio Lombardi
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - 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.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+#
+
+USPACE_PREFIX = ../..
+LIBS = $(LIBBLOCK_PREFIX)/libblock.a
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX)
+BINARY = mkexfat
+
+SOURCES = \
+	mkexfat.c
+
+include $(USPACE_PREFIX)/Makefile.common
Index: uspace/app/mkexfat/exfat.h
===================================================================
--- uspace/app/mkexfat/exfat.h	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
+++ uspace/app/mkexfat/exfat.h	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2011 Oleg Romanenko
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup fs
+ * @{
+ */
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <bool.h>
+
+#define EXFAT_FILENAME_LEN	255
+#define EXFAT_NAME_PART_LEN	15
+
+#define EXFAT_TYPE_UNUSED	0x00
+#define EXFAT_TYPE_USED		0x80
+#define EXFAT_TYPE_VOLLABEL	0x83
+#define EXFAT_TYPE_BITMAP	0x81
+#define EXFAT_TYPE_UCTABLE	0x82
+#define EXFAT_TYPE_GUID		0xA0
+#define EXFAT_TYPE_FILE		0x85
+#define EXFAT_TYPE_STREAM	0xC0
+#define EXFAT_TYPE_NAME		0xC1
+
+#define EXFAT_ATTR_RDONLY	0x01
+#define EXFAT_ATTR_HIDDEN	0x02
+#define EXFAT_ATTR_SYSTEM	0x04
+#define EXFAT_ATTR_SUBDIR	0x10
+#define EXFAT_ATTR_ARCHIVE	0x20
+
+
+/* All dentry structs should have 31 byte size */
+typedef struct {
+	uint8_t 	size;
+	uint16_t 	label[11];
+	uint8_t 	_reserved[8];
+} __attribute__ ((packed)) exfat_vollabel_dentry_t;
+
+typedef struct {
+	uint8_t 	flags;
+	uint8_t 	_reserved[18];
+	uint32_t 	firstc;
+	uint64_t 	size;
+} __attribute__ ((packed)) exfat_bitmap_dentry_t;
+
+typedef struct {
+	uint8_t 	_reserved1[3];
+	uint32_t 	checksum;
+	uint8_t 	_reserved2[12];
+	uint32_t 	firstc;
+	uint64_t 	size;
+} __attribute__ ((packed)) exfat_uctable_dentry_t;
+
+typedef struct {
+	uint8_t 	count; /* Always zero */ 
+	uint16_t 	checksum;
+	uint16_t 	flags;
+	uint8_t 	guid[16];
+	uint8_t 	_reserved[10];
+} __attribute__ ((packed)) exfat_guid_dentry_t;
+
+typedef struct {
+	uint8_t 	count;
+	uint16_t 	checksum;
+	uint16_t 	attr;
+	uint8_t 	_reserved1[2];
+	uint32_t 	ctime;
+	uint32_t 	mtime;
+	uint32_t 	atime;
+	uint8_t 	ctime_fine;
+	uint8_t 	mtime_fine;
+	uint8_t 	ctime_tz;
+	uint8_t 	mtime_tz;
+	uint8_t 	atime_tz;
+	uint8_t 	_reserved2[7];
+} __attribute__ ((packed)) exfat_file_dentry_t;
+
+typedef struct {
+	uint8_t 	flags;
+	uint8_t 	_reserved1[1];
+	uint8_t 	name_size;
+	uint16_t 	hash;
+	uint8_t 	_reserved2[2];
+	uint64_t 	valid_data_size;
+	uint8_t 	_reserved3[4];
+	uint32_t 	firstc;
+	uint64_t 	data_size;
+} __attribute__ ((packed)) exfat_stream_dentry_t;
+
+typedef struct {
+	uint8_t 	flags;
+	uint16_t 	name[EXFAT_NAME_PART_LEN];
+} __attribute__ ((packed)) exfat_name_dentry_t;
+
+
+typedef struct {
+	uint8_t type;
+	union {
+		exfat_vollabel_dentry_t	vollabel;
+		exfat_bitmap_dentry_t 	bitmap;
+		exfat_uctable_dentry_t 	uctable;
+		exfat_guid_dentry_t 	guid;
+		exfat_file_dentry_t 	file;
+		exfat_stream_dentry_t 	stream;
+		exfat_name_dentry_t 	name;
+	};
+} __attribute__ ((packed)) exfat_dentry_t;
+
+
+typedef enum {
+	EXFAT_DENTRY_SKIP,
+	EXFAT_DENTRY_LAST,
+	EXFAT_DENTRY_FREE,
+	EXFAT_DENTRY_VOLLABEL,
+	EXFAT_DENTRY_BITMAP,
+	EXFAT_DENTRY_UCTABLE,
+	EXFAT_DENTRY_GUID,
+	EXFAT_DENTRY_FILE,
+	EXFAT_DENTRY_STREAM,
+	EXFAT_DENTRY_NAME
+} exfat_dentry_clsf_t;
+
+
+typedef struct exfat_bs {
+	uint8_t jump[3];            /* 0x00 jmp and nop instructions */
+	uint8_t oem_name[8];        /* 0x03 "EXFAT   " */
+	uint8_t	__reserved[53];     /* 0x0B always 0 */
+	uint64_t volume_start;      /* 0x40 partition first sector */
+	uint64_t volume_count;      /* 0x48 partition sectors count */
+	uint32_t fat_sector_start;  /* 0x50 FAT first sector */
+	uint32_t fat_sector_count;  /* 0x54 FAT sectors count */
+	uint32_t data_start_sector; /* 0x58 Data region first cluster sector */
+	uint32_t data_clusters;     /* 0x5C total clusters count */
+	uint32_t rootdir_cluster;   /* 0x60 first cluster of the root dir */
+	uint32_t volume_serial;     /* 0x64 volume serial number */
+	struct {                    /* 0x68 FS version */
+		uint8_t minor;
+		uint8_t major;
+	} __attribute__ ((packed)) version;
+	uint16_t volume_flags;     /* 0x6A volume state flags */
+	uint8_t bytes_per_sector;  /* 0x6C sector size as (1 << n) */
+	uint8_t sec_per_cluster;   /* 0x6D sectors per cluster as (1 << n) */
+	uint8_t fat_count;         /* 0x6E always 1 */
+	uint8_t drive_no;          /* 0x6F always 0x80 */
+	uint8_t allocated_percent; /* 0x70 percentage of allocated space */
+	uint8_t _reserved2[7];     /* 0x71 reserved */
+	uint8_t bootcode[390];     /* Boot code */
+	uint16_t signature;        /* the value of 0xAA55 */
+} __attribute__((__packed__)) exfat_bs_t;
+
+/**
+ * @}
+ */
Index: uspace/app/mkexfat/mkexfat.c
===================================================================
--- uspace/app/mkexfat/mkexfat.c	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
+++ uspace/app/mkexfat/mkexfat.c	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -0,0 +1,891 @@
+/*
+ * Copyright (c) 2012 Maurizio Lombardi
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup fs
+ * @{
+ */
+
+/**
+ * @file	mkexfat.c
+ * @brief	Tool for creating new exFAT file systems.
+ *
+ */
+
+#include <stdio.h>
+#include <libblock.h>
+#include <assert.h>
+#include <errno.h>
+#include <malloc.h>
+#include <byteorder.h>
+#include <align.h>
+#include <sys/types.h>
+#include <sys/typefmt.h>
+#include <bool.h>
+#include <str.h>
+#include <getopt.h>
+#include "exfat.h"
+#include "upcase.h"
+
+#define NAME    "mkexfat"
+
+/** First sector of the FAT */
+#define FAT_SECTOR_START 128
+
+/** First sector of the Main Extended Boot Region */
+#define EBS_SECTOR_START 1
+
+/** First sector of the Main Extended Boot Region Backup */
+#define EBS_BACKUP_SECTOR_START 13
+
+/** First sector of the Main Boot Sector */
+#define MBS_SECTOR 0
+
+/** First sector of the Main Boot Sector Backup */
+#define MBS_BACKUP_SECTOR 12
+
+/** VBR Checksum sector */
+#define VBR_CHECKSUM_SECTOR 11
+
+/** VBR Backup Checksum sector */
+#define VBR_BACKUP_CHECKSUM_SECTOR 23
+
+/** Size of the Main Extended Boot Region */
+#define EBS_SIZE 8
+
+/** Divide and round up. */
+#define div_round_up(a, b) (((a) + (b) - 1) / (b))
+
+/** The default size of each cluster is 4096 byte */
+#define DEFAULT_CLUSTER_SIZE 4096
+
+/** Index of the first free cluster on the device */
+#define FIRST_FREE_CLUSTER   2
+
+#define min(x, y) ((x) < (y) ? (x) : (y))
+
+typedef struct exfat_cfg {
+	aoff64_t volume_start;
+	aoff64_t volume_count;
+	unsigned long fat_sector_count;
+	unsigned long data_start_sector;
+	unsigned long rootdir_cluster;
+	unsigned long upcase_table_cluster;
+	unsigned long bitmap_cluster;
+	unsigned long total_clusters;
+	unsigned long allocated_clusters;
+	size_t   bitmap_size;
+	size_t   sector_size;
+	size_t   cluster_size;
+} exfat_cfg_t;
+
+
+static unsigned log2(unsigned n);
+
+static uint32_t
+vbr_checksum_start(void const *octets, size_t nbytes);
+
+static void
+vbr_checksum_update(void const *octets, size_t nbytes, uint32_t *checksum);
+
+static int
+ebs_write(service_id_t service_id, exfat_cfg_t *cfg,
+    int base, uint32_t *chksum);
+
+static int
+bitmap_write(service_id_t service_id, exfat_cfg_t *cfg);
+
+static uint32_t
+upcase_table_checksum(void const *data, size_t nbytes);
+
+static struct option const long_options[] = {
+	{"help", no_argument, 0, 'h'},
+	{"cluster-size", required_argument, 0, 'c'},
+	{"fs-size", required_argument, 0, 's'},
+};
+
+static void usage(void)
+{
+	printf("Usage: mkexfat [options] <device>\n"
+	    "-c, --cluster-size ## Specify the cluster size (Kb)\n"
+	    "-s, --fs-size ##      Specify the filesystem size (byte)\n");
+}
+
+/** Initialize the exFAT params structure.
+ *
+ * @param cfg Pointer to the exFAT params structure to initialize.
+ */
+static void
+cfg_params_initialize(exfat_cfg_t *cfg)
+{
+	unsigned long fat_bytes;
+	aoff64_t const volume_bytes = (cfg->volume_count - FAT_SECTOR_START) *
+	    cfg->sector_size;
+	aoff64_t n_req_clusters;
+
+	if (cfg->cluster_size != 0) {
+		/* The user already choose the cluster size he wants */
+		n_req_clusters = volume_bytes / cfg->cluster_size;
+		goto skip_cluster_size_set;
+	}
+
+	n_req_clusters = volume_bytes / DEFAULT_CLUSTER_SIZE;
+	cfg->cluster_size = DEFAULT_CLUSTER_SIZE;
+
+	/* Compute the required cluster size to index
+	 * the entire storage device and to keep the FAT
+	 * size less or equal to 64 Mb.
+	 */
+	while (n_req_clusters > 16000000ULL &&
+	    (cfg->cluster_size < 32 * 1024 * 1024)) {
+
+		cfg->cluster_size <<= 1;
+		n_req_clusters = div_round_up(volume_bytes, cfg->cluster_size);
+	}
+
+skip_cluster_size_set:
+
+	/* The first two clusters are reserved */
+	cfg->total_clusters = n_req_clusters + 2;
+
+	/* Compute the FAT size in sectors */
+	fat_bytes = (cfg->total_clusters + 1) * 4;
+	cfg->fat_sector_count = div_round_up(fat_bytes, cfg->sector_size);
+
+	/* Compute the number of the first data sector */
+	cfg->data_start_sector = ROUND_UP(FAT_SECTOR_START +
+	    cfg->fat_sector_count, cfg->cluster_size / cfg->sector_size);
+
+	/* Compute the bitmap size */
+	cfg->bitmap_size = div_round_up(n_req_clusters, 8);
+
+	/* Compute the number of clusters reserved to the bitmap */
+	cfg->allocated_clusters = div_round_up(cfg->bitmap_size,
+	    cfg->cluster_size);
+
+	/* This account for the root directory */
+	cfg->allocated_clusters++;
+
+	/* Compute the number of clusters reserved to the upcase table */
+	cfg->allocated_clusters += div_round_up(sizeof(upcase_table),
+	    cfg->cluster_size);
+
+	/* Will be set later */
+	cfg->rootdir_cluster = 0;
+
+	/* Bitmap always starts at the first free cluster */
+	cfg->bitmap_cluster = FIRST_FREE_CLUSTER;
+
+	/* The first sector of the partition is zero */
+	cfg->volume_start = 0;
+}
+
+/** Prints the exFAT structure values
+ *
+ * @param cfg Pointer to the exfat_cfg_t structure.
+ */
+static void
+cfg_print_info(exfat_cfg_t *cfg)
+{
+	printf(NAME ": Sector size:           %lu\n",
+	    (unsigned long) cfg->sector_size);
+	printf(NAME ": Cluster size:          %lu\n",
+	    (unsigned long) cfg->cluster_size);
+	printf(NAME ": FAT size in sectors:   %lu\n", cfg->fat_sector_count);
+	printf(NAME ": Data start sector:     %lu\n", cfg->data_start_sector);
+	printf(NAME ": Total num of clusters: %lu\n", cfg->total_clusters);
+	printf(NAME ": Bitmap size:           %lu\n", (unsigned long)
+	    div_round_up(cfg->bitmap_size, cfg->cluster_size));
+	printf(NAME ": Upcase table size:     %lu\n", (unsigned long)
+	    div_round_up(sizeof(upcase_table), cfg->cluster_size));
+}
+
+/** Initialize the Main Boot Sector fields.
+ *
+ * @param mbs Pointer to the Main Boot Sector structure.
+ * @param cfg Pointer to the exFAT configuration structure.
+ * @return    Initial checksum value.
+ */
+static uint32_t
+vbr_initialize(exfat_bs_t *mbs, exfat_cfg_t *cfg)
+{
+	/* Fill the structure with zeroes */
+	memset(mbs, 0, sizeof(exfat_bs_t));
+
+	/* Init Jump Boot section */
+	mbs->jump[0] = 0xEB;
+	mbs->jump[1] = 0x76;
+	mbs->jump[2] = 0x90;
+
+	/* Set the filesystem name */
+	memcpy(mbs->oem_name, "EXFAT   ", sizeof(mbs->oem_name));
+
+	mbs->volume_start = host2uint64_t_le(cfg->volume_start);
+	mbs->volume_count = host2uint64_t_le(cfg->volume_count);
+	mbs->fat_sector_start = host2uint32_t_le(FAT_SECTOR_START);
+	mbs->fat_sector_count = host2uint32_t_le(cfg->fat_sector_count);
+	mbs->data_start_sector = host2uint32_t_le(cfg->data_start_sector);
+
+	mbs->data_clusters = host2uint32_t_le(cfg->total_clusters - 
+	    div_round_up(cfg->data_start_sector * cfg->sector_size,
+	    cfg->cluster_size));
+
+	mbs->rootdir_cluster = host2uint32_t_le(cfg->rootdir_cluster);
+	mbs->volume_serial = host2uint32_t_le(0xe1028172);
+	mbs->version.major = 1;
+	mbs->version.minor = 0;
+	mbs->volume_flags = host2uint16_t_le(0);
+	mbs->bytes_per_sector = log2(cfg->sector_size);
+	mbs->sec_per_cluster = log2(cfg->cluster_size / cfg->sector_size);
+
+	/* Maximum cluster size is 32 Mb */
+	assert((mbs->bytes_per_sector + mbs->sec_per_cluster) <= 25);
+
+	mbs->fat_count = 1;
+	mbs->drive_no = 0x80;
+	mbs->allocated_percent = 0;
+	mbs->signature = host2uint16_t_le(0xAA55);
+
+	return vbr_checksum_start(mbs, sizeof(exfat_bs_t));
+}
+
+static int
+bootsec_write(service_id_t service_id, exfat_cfg_t *cfg)
+{
+	exfat_bs_t mbs;
+	uint32_t vbr_checksum;
+	uint32_t *chksum_sector;
+	int rc;
+	unsigned idx;
+
+	chksum_sector = calloc(cfg->sector_size, sizeof(uint8_t));
+	if (!chksum_sector)
+		return ENOMEM;
+
+	vbr_checksum = vbr_initialize(&mbs, cfg);
+
+	/* Write the Main Boot Sector to disk */
+	rc = block_write_direct(service_id, MBS_SECTOR, 1, &mbs);
+	if (rc != EOK)
+		goto exit;
+
+	/* Write the Main extended boot sectors to disk */
+	rc = ebs_write(service_id, cfg, EBS_SECTOR_START, &vbr_checksum);
+	if (rc != EOK)
+		goto exit;
+
+	/* Write the Main Boot Sector backup to disk */
+	rc = block_write_direct(service_id, MBS_BACKUP_SECTOR, 1, &mbs);
+	if (rc != EOK)
+		goto exit;
+
+	/* Initialize the checksum sectors */
+	for (idx = 0; idx < cfg->sector_size / sizeof(uint32_t); ++idx)
+		chksum_sector[idx] = host2uint32_t_le(vbr_checksum);
+
+	/* Write the main checksum sector to disk */
+	rc = block_write_direct(service_id,
+	    VBR_CHECKSUM_SECTOR, 1, chksum_sector);
+	if (rc != EOK)
+		goto exit;
+
+	/* Write the backup checksum sector to disk */
+	rc = block_write_direct(service_id,
+	    VBR_BACKUP_CHECKSUM_SECTOR, 1, chksum_sector);
+	if (rc != EOK)
+		goto exit;
+
+	/* Write the Main extended boot sectors backup to disk */ 
+	rc = ebs_write(service_id, cfg,
+	    EBS_BACKUP_SECTOR_START, &vbr_checksum);
+
+exit:
+	free(chksum_sector);
+	return rc;
+}
+
+/** Write the Main Extended Boot Sector to disk
+ *
+ * @param service_id  The service id.
+ * @param cfg  Pointer to the exFAT configuration structure.
+ * @param base Base sector of the EBS.
+ * @return  EOK on success or a negative error code.
+ */
+static int
+ebs_write(service_id_t service_id, exfat_cfg_t *cfg, int base,
+    uint32_t *chksum)
+{
+	uint32_t *ebs = calloc(cfg->sector_size, sizeof(uint8_t));
+	int i, rc;
+
+	if (!ebs)
+		return ENOMEM;
+
+	ebs[cfg->sector_size / 4 - 1] = host2uint32_t_le(0xAA550000);
+
+	for (i = 0; i < EBS_SIZE; ++i) {
+		vbr_checksum_update(ebs, cfg->sector_size, chksum);
+
+		rc = block_write_direct(service_id,
+		    i + base, 1, ebs);
+
+		if (rc != EOK)
+			goto exit;
+	}
+
+	/* The OEM record is not yet used
+	 * by the official exFAT implementation, we'll fill
+	 * it with zeroes.
+	 */
+
+	memset(ebs, 0, cfg->sector_size);
+	vbr_checksum_update(ebs, cfg->sector_size, chksum);
+
+	rc = block_write_direct(service_id, i++ + base, 1, ebs);
+	if (rc != EOK)
+		goto exit;
+
+	/* The next sector is reserved, fill it with zeroes too */
+	vbr_checksum_update(ebs, cfg->sector_size, chksum);
+
+	rc = block_write_direct(service_id, i++ + base, 1, ebs);
+	if (rc != EOK)
+		goto exit;
+
+exit:
+	free(ebs);
+	return rc;
+}
+
+/** Initialize the FAT table.
+ *
+ * @param service_id  The service id.
+ * @param cfg Pointer to the exfat_cfg structure.
+ * @return EOK on success or a negative error code.
+ */
+static int
+fat_initialize(service_id_t service_id, exfat_cfg_t *cfg)
+{
+	unsigned long i;
+	uint32_t *pfat;
+	int rc;
+
+	pfat = calloc(cfg->sector_size, 1);
+	if (!pfat)
+		return ENOMEM;
+
+	pfat[0] = host2uint32_t_le(0xFFFFFFF8);
+	pfat[1] = host2uint32_t_le(0xFFFFFFFF);
+
+	rc = block_write_direct(service_id, FAT_SECTOR_START, 1, pfat);
+	if (rc != EOK)
+		goto error;
+
+	pfat[0] = pfat[1] = 0;
+
+	for (i = 1; i < cfg->fat_sector_count; ++i) {
+		rc = block_write_direct(service_id,
+		    FAT_SECTOR_START + i, 1, pfat);
+		if (rc != EOK)
+			goto error;
+	}
+
+error:
+	free(pfat);
+	return rc;
+}
+
+/** Allocate a given number of clusters and create a cluster chain.
+ *
+ * @param service_id  The service id.
+ * @param cfg  Pointer to the exfat configuration structure.
+ * @param cur_cls  Cluster index from where to start the allocation.
+ * @param ncls  Number of clusters to allocate.
+ * @return EOK on success or a negative error code.
+ */
+static int
+fat_allocate_clusters(service_id_t service_id, exfat_cfg_t *cfg,
+    uint32_t cur_cls, unsigned long ncls)
+{
+	int rc;
+	unsigned const fat_entries = cfg->sector_size / sizeof(uint32_t);
+	aoff64_t fat_sec = cur_cls / fat_entries + FAT_SECTOR_START;
+	uint32_t *fat;
+
+	cur_cls %= fat_entries;
+
+	fat = malloc(cfg->sector_size);
+	if (!fat)
+		return ENOMEM;
+
+loop:
+	rc = block_read_direct(service_id, fat_sec, 1, fat);
+	if (rc != EOK)
+		goto exit;
+
+	assert(fat[cur_cls] == 0);
+	assert(ncls > 0);
+
+	for (; cur_cls < fat_entries && ncls > 1; ++cur_cls, --ncls)
+		fat[cur_cls] = host2uint32_t_le(cur_cls + 1);
+
+	if (cur_cls == fat_entries) {
+		/* This sector is full, there are no more free entries,
+		 * read the next sector and restart the search.
+		 */
+		rc = block_write_direct(service_id, fat_sec++, 1, fat);
+		if (rc != EOK)
+			goto exit;
+		cur_cls = 0;
+		goto loop;
+	} else if (ncls == 1) {
+		/* This is the last cluster of this chain, mark it
+		 * with EOF.
+		 */
+		fat[cur_cls] = host2uint32_t_le(0xFFFFFFFF);
+	}
+
+	rc = block_write_direct(service_id, fat_sec, 1, fat);
+
+exit:
+	free(fat);
+	return rc;
+}
+
+/** Initialize the allocation bitmap.
+ *
+ * @param service_id   The service id.
+ * @param cfg  Pointer to the exfat configuration structure.
+ * @return  EOK on success or a negative error code.
+ */
+static int
+bitmap_write(service_id_t service_id, exfat_cfg_t *cfg)
+{
+	unsigned long i, sec;
+	unsigned long allocated_cls;
+	int rc = EOK;
+	bool need_reset = true;
+
+	/* Bitmap size in sectors */
+	size_t const bss = div_round_up(cfg->bitmap_size, cfg->sector_size);
+
+	uint8_t *bitmap = malloc(cfg->sector_size);
+	if (!bitmap)
+		return ENOMEM;
+
+	allocated_cls = cfg->allocated_clusters;
+
+	for (sec = 0; sec < bss; ++sec) {
+		if (need_reset) {
+			need_reset = false;
+			memset(bitmap, 0, cfg->sector_size);
+		}
+		if (allocated_cls > 0) {
+			for (i = 0; i < allocated_cls; ++i) {
+				unsigned byte_idx = i / 8;
+				unsigned bit_idx = i % 8;
+
+				if (byte_idx == cfg->sector_size)
+					break;
+				bitmap[byte_idx] |= 1 << bit_idx;
+			}
+
+			allocated_cls -= i;
+			need_reset = true;
+		}
+
+		rc = block_write_direct(service_id,
+		    cfg->data_start_sector + sec, 1, bitmap);
+		if (rc != EOK)
+			goto exit;
+	}
+
+exit:
+	free(bitmap);
+	return rc;
+}
+
+/** Write the upcase table to disk. */
+static int
+upcase_table_write(service_id_t service_id, exfat_cfg_t *cfg)
+{
+	int rc = EOK;
+	aoff64_t start_sec, nsecs, i;
+	uint8_t *table_ptr;
+	uint8_t *buf;
+	size_t table_size = sizeof(upcase_table);
+
+	buf = malloc(cfg->sector_size);
+	if (!buf)
+		return ENOENT;
+
+	/* Compute the start sector of the upcase table */
+	start_sec = cfg->data_start_sector;
+	start_sec += ((cfg->upcase_table_cluster - 2) * cfg->cluster_size) /
+	    cfg->sector_size;
+
+	/* Compute the number of sectors needed to store the table on disk */
+	nsecs = div_round_up(sizeof(upcase_table), cfg->sector_size);
+	table_ptr = (uint8_t *) upcase_table;
+
+	for (i = 0; i < nsecs; ++i,
+	    table_ptr += min(table_size, cfg->sector_size),
+	    table_size -= cfg->sector_size) {
+
+		if (table_size < cfg->sector_size) {
+			/* Reset the content of the unused part
+			 * of the last sector.
+			 */
+			memset(buf, 0, cfg->sector_size);
+		}
+		memcpy(buf, table_ptr, min(table_size, cfg->sector_size));
+
+		rc = block_write_direct(service_id,
+		    start_sec + i, 1, buf);
+		if (rc != EOK)
+			goto exit;
+	}
+
+exit:
+	free(buf);
+	return rc;
+}
+
+/** Initialize and write the root directory entries to disk.
+ *
+ * @param service_id   The service id.
+ * @param cfg   Pointer to the exFAT configuration structure.
+ * @return   EOK on success or a negative error code.
+ */
+static int
+root_dentries_write(service_id_t service_id, exfat_cfg_t *cfg)
+{
+	exfat_dentry_t *d;
+	aoff64_t rootdir_sec;
+	int rc;
+	uint8_t *data;
+
+	data = calloc(cfg->sector_size, 1);
+	if (!data)
+		return ENOMEM;
+
+	d = (exfat_dentry_t *) data;
+
+	/* Initialize the volume label dentry */
+	d->type = EXFAT_TYPE_VOLLABEL;
+	str_to_utf16(d->vollabel.label, 8, "HELENOS ");
+	d->vollabel.size = 8;
+
+	d++;
+
+	/* Initialize the allocation bitmap dentry */
+	d->type = EXFAT_TYPE_BITMAP;
+	d->bitmap.flags = 0; /* First FAT */
+	d->bitmap.firstc = host2uint32_t_le(cfg->bitmap_cluster);
+	d->bitmap.size = host2uint64_t_le(cfg->bitmap_size);
+
+	d++;
+
+	/* Initialize the upcase table dentry */
+	d->type = EXFAT_TYPE_UCTABLE;
+	d->uctable.checksum = host2uint32_t_le(upcase_table_checksum(
+	    upcase_table, sizeof(upcase_table)));
+	d->uctable.firstc = host2uint32_t_le(cfg->upcase_table_cluster);
+	d->uctable.size = host2uint64_t_le(sizeof(upcase_table));
+
+	/* Compute the number of the sector where the rootdir resides */
+
+	rootdir_sec = cfg->data_start_sector;
+	rootdir_sec += ((cfg->rootdir_cluster - 2) * cfg->cluster_size) /
+	    cfg->sector_size;
+
+	rc = block_write_direct(service_id, rootdir_sec, 1, data);
+
+	free(data);
+	return rc;
+}
+
+/** Given a number (n), returns the result of log2(n).
+ *
+ * It works only if n is a power of two.
+ */
+static unsigned
+log2(unsigned n)
+{
+	unsigned r;
+
+	for (r = 0;n >> r != 1; ++r);
+
+	return r;
+}
+
+/** Initialize the VBR checksum calculation */
+static uint32_t
+vbr_checksum_start(void const *data, size_t nbytes)
+{
+	uint32_t checksum = 0;
+	size_t index;
+	uint8_t const *octets = (uint8_t *) data;
+
+	for (index = 0; index < nbytes; ++index) {
+		if (index == 106 || index == 107 || index == 112) {
+			/* Skip volume_flags and allocated_percent fields */
+			continue;
+		}
+
+		checksum = ((checksum << 31) | (checksum >> 1)) +
+		    octets[index];
+	}
+
+	return checksum;
+}
+
+/** Update the VBR checksum */
+static void
+vbr_checksum_update(void const *data, size_t nbytes, uint32_t *checksum)
+{
+	size_t index;
+	uint8_t const *octets = (uint8_t *) data;
+
+	for (index = 0; index < nbytes; ++index) {
+		*checksum = ((*checksum << 31) | (*checksum >> 1)) +
+		    octets[index];
+	}
+}
+
+/** Compute the checksum of the upcase table.
+ *
+ * @param data   Pointer to the upcase table.
+ * @param nbytes size of the upcase table in bytes.
+ * @return   Checksum value.
+ */
+static uint32_t
+upcase_table_checksum(void const *data, size_t nbytes)
+{
+	size_t index;
+	uint32_t chksum = 0;
+	uint8_t const *octets = (uint8_t *) data;
+
+	for (index = 0; index < nbytes; ++index)
+		chksum = ((chksum << 31) | (chksum >> 1)) + octets[index];
+
+	return chksum;
+}
+
+/** Check if a given number is a power of two.
+ *
+ * @param n   The number to check.
+ * @return    true if n is a power of two, false otherwise.
+ */
+static bool
+is_power_of_two(unsigned long n)
+{
+	if (n == 0)
+		return false;
+
+	return (n & (n - 1)) == 0;
+}
+
+int main (int argc, char **argv)
+{
+	exfat_cfg_t cfg;
+	uint32_t next_cls;
+	char *dev_path;
+	service_id_t service_id;
+	int rc, c, opt_ind;
+	aoff64_t user_fs_size = 0;
+
+	if (argc < 2) {
+		printf(NAME ": Error, argument missing\n");
+		usage();
+		return 1;
+	}
+
+	cfg.cluster_size = 0;
+
+	for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
+		c = getopt_long(argc, argv, "hs:c:",
+		    long_options, &opt_ind);
+		switch (c) {
+		case 'h':
+			usage();
+			return 0;
+		case 's':
+			user_fs_size = (aoff64_t) strtol(optarg, NULL, 10);
+			if (user_fs_size < 1024 * 1024) {
+				printf(NAME ": Error, fs size can't be less"
+				    " than 1 Mb.\n");
+				return 1;
+			}
+			break;
+
+		case 'c':
+			cfg.cluster_size = strtol(optarg, NULL, 10) * 1024;
+			if (cfg.cluster_size < 4096) {
+				printf(NAME ": Error, cluster size can't"
+				    " be less than 4096 byte.\n");
+				return 1;
+			} else if (cfg.cluster_size > 32 * 1024 * 1024) {
+				printf(NAME ": Error, cluster size can't"
+				    " be greater than 32 Mb");
+				return 1;
+			}
+
+			if (!is_power_of_two(cfg.cluster_size)) {
+				printf(NAME ": Error, the size of the cluster"
+				    " must be a power of two.\n");
+				return 1;
+			}
+			break;
+		}
+	}
+
+	argv += optind;
+	dev_path = *argv;
+
+	printf(NAME ": Device = %s\n", dev_path);
+
+	rc = loc_service_get_id(dev_path, &service_id, 0);
+	if (rc != EOK) {
+		printf(NAME ": Error resolving device `%s'.\n", dev_path);
+		return 2;
+	}
+
+	rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+	if (rc != EOK) {
+		printf(NAME ": Error initializing libblock.\n");
+		return 2;
+	}
+
+	rc = block_get_bsize(service_id, &cfg.sector_size);
+	if (rc != EOK) {
+		printf(NAME ": Error determining device block size.\n");
+		return 2;
+	}
+
+	if (cfg.sector_size > 4096) {
+		printf(NAME ": Error, sector size can't be greater" \
+		    " than 4096 bytes.\n");
+		return 2;
+	}
+
+	rc = block_get_nblocks(service_id, &cfg.volume_count);
+	if (rc != EOK) {
+		printf(NAME ": Warning, failed to obtain" \
+		    " device block size.\n");
+		return 1;
+	} else {
+		printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
+		    cfg.volume_count);
+	}
+
+	if (user_fs_size != 0) {
+		if (user_fs_size > cfg.volume_count * cfg.sector_size) {
+			printf(NAME ": Error, the device is not big enough"
+			    " to create the filesystem a filesystem of"
+			    " the specified size.\n");
+			return 1;
+		}
+
+		cfg.volume_count = user_fs_size / cfg.sector_size;
+	}
+
+	cfg_params_initialize(&cfg);
+	cfg_print_info(&cfg);
+
+	/* Initialize the FAT table */
+	rc = fat_initialize(service_id, &cfg);
+	if (rc != EOK) {
+		printf(NAME ": Error, failed to write the FAT to disk\n");
+		return 2;
+	}
+
+	/* Allocate clusters for the bitmap */
+	rc = fat_allocate_clusters(service_id, &cfg, cfg.bitmap_cluster,
+	    div_round_up(cfg.bitmap_size, cfg.cluster_size));
+	if (rc != EOK) {
+		printf(NAME ": Error, failed to allocate" \
+		    " clusters for bitmap.\n");
+		return 2;
+	}
+
+	next_cls = cfg.bitmap_cluster +
+	    div_round_up(cfg.bitmap_size, cfg.cluster_size);
+	cfg.upcase_table_cluster = next_cls;
+
+	/* Allocate clusters for the upcase table */
+	rc = fat_allocate_clusters(service_id, &cfg, next_cls,
+	    div_round_up(sizeof(upcase_table), cfg.cluster_size));
+	if (rc != EOK) {
+		printf(NAME ":Error, failed to allocate clusters" \
+		    " for the upcase table.\n");
+		return 2;
+	}
+
+	next_cls += div_round_up(sizeof(upcase_table), cfg.cluster_size);
+	cfg.rootdir_cluster = next_cls;
+
+	/* Allocate a cluster for the root directory entry */
+	rc = fat_allocate_clusters(service_id, &cfg, next_cls, 1);
+	if (rc != EOK) {
+		printf(NAME ": Error, failed to allocate cluster" \
+		    " for the root dentry.\n");
+		return 2;
+	}
+
+	/* Write the allocation bitmap to disk */
+	rc = bitmap_write(service_id, &cfg);
+	if (rc != EOK) {
+		printf(NAME ": Error, failed to write the allocation" \
+		    " bitmap to disk.\n");
+		return 2;
+	}
+
+	/* Write the upcase table to disk */
+	rc = upcase_table_write(service_id, &cfg);
+	if (rc != EOK) {
+		printf(NAME ": Error, failed to write the" \
+		    " upcase table to disk.\n");
+		return 2;
+	}
+
+	rc = root_dentries_write(service_id, &cfg);
+	if (rc != EOK) {
+		printf(NAME ": Error, failed to write the root directory" \
+		    " entries to disk.\n");
+		return 2;
+	}
+
+	rc = bootsec_write(service_id, &cfg);
+	if (rc != EOK) {
+		printf(NAME ": Error, failed to write the VBR to disk\n");
+		return 2;
+	}
+
+	return 0;
+}
+
Index: uspace/app/mkexfat/upcase.h
===================================================================
--- uspace/app/mkexfat/upcase.h	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
+++ uspace/app/mkexfat/upcase.h	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -0,0 +1,2927 @@
+#ifndef _UPCASE_H_
+#define _UPCASE_H_
+
+/** Up-case unicode table */
+static uint8_t const upcase_table[] = {
+    0x00, 0x00,
+    0x01, 0x00,
+    0x02, 0x00,
+    0x03, 0x00,
+    0x04, 0x00,
+    0x05, 0x00,
+    0x06, 0x00,
+    0x07, 0x00,
+    0x08, 0x00,
+    0x09, 0x00,
+    0x0a, 0x00,
+    0x0b, 0x00,
+    0x0c, 0x00,
+    0x0d, 0x00,
+    0x0e, 0x00,
+    0x0f, 0x00,
+    0x10, 0x00,
+    0x11, 0x00,
+    0x12, 0x00,
+    0x13, 0x00,
+    0x14, 0x00,
+    0x15, 0x00,
+    0x16, 0x00,
+    0x17, 0x00,
+    0x18, 0x00,
+    0x19, 0x00,
+    0x1a, 0x00,
+    0x1b, 0x00,
+    0x1c, 0x00,
+    0x1d, 0x00,
+    0x1e, 0x00,
+    0x1f, 0x00,
+    0x20, 0x00,
+    0x21, 0x00,
+    0x22, 0x00,
+    0x23, 0x00,
+    0x24, 0x00,
+    0x25, 0x00,
+    0x26, 0x00,
+    0x27, 0x00,
+    0x28, 0x00,
+    0x29, 0x00,
+    0x2a, 0x00,
+    0x2b, 0x00,
+    0x2c, 0x00,
+    0x2d, 0x00,
+    0x2e, 0x00,
+    0x2f, 0x00,
+    0x30, 0x00,
+    0x31, 0x00,
+    0x32, 0x00,
+    0x33, 0x00,
+    0x34, 0x00,
+    0x35, 0x00,
+    0x36, 0x00,
+    0x37, 0x00,
+    0x38, 0x00,
+    0x39, 0x00,
+    0x3a, 0x00,
+    0x3b, 0x00,
+    0x3c, 0x00,
+    0x3d, 0x00,
+    0x3e, 0x00,
+    0x3f, 0x00,
+    0x40, 0x00,
+    0x41, 0x00,
+    0x42, 0x00,
+    0x43, 0x00,
+    0x44, 0x00,
+    0x45, 0x00,
+    0x46, 0x00,
+    0x47, 0x00,
+    0x48, 0x00,
+    0x49, 0x00,
+    0x4a, 0x00,
+    0x4b, 0x00,
+    0x4c, 0x00,
+    0x4d, 0x00,
+    0x4e, 0x00,
+    0x4f, 0x00,
+    0x50, 0x00,
+    0x51, 0x00,
+    0x52, 0x00,
+    0x53, 0x00,
+    0x54, 0x00,
+    0x55, 0x00,
+    0x56, 0x00,
+    0x57, 0x00,
+    0x58, 0x00,
+    0x59, 0x00,
+    0x5a, 0x00,
+    0x5b, 0x00,
+    0x5c, 0x00,
+    0x5d, 0x00,
+    0x5e, 0x00,
+    0x5f, 0x00,
+    0x60, 0x00,
+    0x41, 0x00,
+    0x42, 0x00,
+    0x43, 0x00,
+    0x44, 0x00,
+    0x45, 0x00,
+    0x46, 0x00,
+    0x47, 0x00,
+    0x48, 0x00,
+    0x49, 0x00,
+    0x4a, 0x00,
+    0x4b, 0x00,
+    0x4c, 0x00,
+    0x4d, 0x00,
+    0x4e, 0x00,
+    0x4f, 0x00,
+    0x50, 0x00,
+    0x51, 0x00,
+    0x52, 0x00,
+    0x53, 0x00,
+    0x54, 0x00,
+    0x55, 0x00,
+    0x56, 0x00,
+    0x57, 0x00,
+    0x58, 0x00,
+    0x59, 0x00,
+    0x5a, 0x00,
+    0x7b, 0x00,
+    0x7c, 0x00,
+    0x7d, 0x00,
+    0x7e, 0x00,
+    0x7f, 0x00,
+    0x80, 0x00,
+    0x81, 0x00,
+    0x82, 0x00,
+    0x83, 0x00,
+    0x84, 0x00,
+    0x85, 0x00,
+    0x86, 0x00,
+    0x87, 0x00,
+    0x88, 0x00,
+    0x89, 0x00,
+    0x8a, 0x00,
+    0x8b, 0x00,
+    0x8c, 0x00,
+    0x8d, 0x00,
+    0x8e, 0x00,
+    0x8f, 0x00,
+    0x90, 0x00,
+    0x91, 0x00,
+    0x92, 0x00,
+    0x93, 0x00,
+    0x94, 0x00,
+    0x95, 0x00,
+    0x96, 0x00,
+    0x97, 0x00,
+    0x98, 0x00,
+    0x99, 0x00,
+    0x9a, 0x00,
+    0x9b, 0x00,
+    0x9c, 0x00,
+    0x9d, 0x00,
+    0x9e, 0x00,
+    0x9f, 0x00,
+    0xa0, 0x00,
+    0xa1, 0x00,
+    0xa2, 0x00,
+    0xa3, 0x00,
+    0xa4, 0x00,
+    0xa5, 0x00,
+    0xa6, 0x00,
+    0xa7, 0x00,
+    0xa8, 0x00,
+    0xa9, 0x00,
+    0xaa, 0x00,
+    0xab, 0x00,
+    0xac, 0x00,
+    0xad, 0x00,
+    0xae, 0x00,
+    0xaf, 0x00,
+    0xb0, 0x00,
+    0xb1, 0x00,
+    0xb2, 0x00,
+    0xb3, 0x00,
+    0xb4, 0x00,
+    0xb5, 0x00,
+    0xb6, 0x00,
+    0xb7, 0x00,
+    0xb8, 0x00,
+    0xb9, 0x00,
+    0xba, 0x00,
+    0xbb, 0x00,
+    0xbc, 0x00,
+    0xbd, 0x00,
+    0xbe, 0x00,
+    0xbf, 0x00,
+    0xc0, 0x00,
+    0xc1, 0x00,
+    0xc2, 0x00,
+    0xc3, 0x00,
+    0xc4, 0x00,
+    0xc5, 0x00,
+    0xc6, 0x00,
+    0xc7, 0x00,
+    0xc8, 0x00,
+    0xc9, 0x00,
+    0xca, 0x00,
+    0xcb, 0x00,
+    0xcc, 0x00,
+    0xcd, 0x00,
+    0xce, 0x00,
+    0xcf, 0x00,
+    0xd0, 0x00,
+    0xd1, 0x00,
+    0xd2, 0x00,
+    0xd3, 0x00,
+    0xd4, 0x00,
+    0xd5, 0x00,
+    0xd6, 0x00,
+    0xd7, 0x00,
+    0xd8, 0x00,
+    0xd9, 0x00,
+    0xda, 0x00,
+    0xdb, 0x00,
+    0xdc, 0x00,
+    0xdd, 0x00,
+    0xde, 0x00,
+    0xdf, 0x00,
+    0xc0, 0x00,
+    0xc1, 0x00,
+    0xc2, 0x00,
+    0xc3, 0x00,
+    0xc4, 0x00,
+    0xc5, 0x00,
+    0xc6, 0x00,
+    0xc7, 0x00,
+    0xc8, 0x00,
+    0xc9, 0x00,
+    0xca, 0x00,
+    0xcb, 0x00,
+    0xcc, 0x00,
+    0xcd, 0x00,
+    0xce, 0x00,
+    0xcf, 0x00,
+    0xd0, 0x00,
+    0xd1, 0x00,
+    0xd2, 0x00,
+    0xd3, 0x00,
+    0xd4, 0x00,
+    0xd5, 0x00,
+    0xd6, 0x00,
+    0xf7, 0x00,
+    0xd8, 0x00,
+    0xd9, 0x00,
+    0xda, 0x00,
+    0xdb, 0x00,
+    0xdc, 0x00,
+    0xdd, 0x00,
+    0xde, 0x00,
+    0x78, 0x01,
+    0x00, 0x01,
+    0x00, 0x01,
+    0x02, 0x01,
+    0x02, 0x01,
+    0x04, 0x01,
+    0x04, 0x01,
+    0x06, 0x01,
+    0x06, 0x01,
+    0x08, 0x01,
+    0x08, 0x01,
+    0x0a, 0x01,
+    0x0a, 0x01,
+    0x0c, 0x01,
+    0x0c, 0x01,
+    0x0e, 0x01,
+    0x0e, 0x01,
+    0x10, 0x01,
+    0x10, 0x01,
+    0x12, 0x01,
+    0x12, 0x01,
+    0x14, 0x01,
+    0x14, 0x01,
+    0x16, 0x01,
+    0x16, 0x01,
+    0x18, 0x01,
+    0x18, 0x01,
+    0x1a, 0x01,
+    0x1a, 0x01,
+    0x1c, 0x01,
+    0x1c, 0x01,
+    0x1e, 0x01,
+    0x1e, 0x01,
+    0x20, 0x01,
+    0x20, 0x01,
+    0x22, 0x01,
+    0x22, 0x01,
+    0x24, 0x01,
+    0x24, 0x01,
+    0x26, 0x01,
+    0x26, 0x01,
+    0x28, 0x01,
+    0x28, 0x01,
+    0x2a, 0x01,
+    0x2a, 0x01,
+    0x2c, 0x01,
+    0x2c, 0x01,
+    0x2e, 0x01,
+    0x2e, 0x01,
+    0x30, 0x01,
+    0x31, 0x01,
+    0x32, 0x01,
+    0x32, 0x01,
+    0x34, 0x01,
+    0x34, 0x01,
+    0x36, 0x01,
+    0x36, 0x01,
+    0x38, 0x01,
+    0x39, 0x01,
+    0x39, 0x01,
+    0x3b, 0x01,
+    0x3b, 0x01,
+    0x3d, 0x01,
+    0x3d, 0x01,
+    0x3f, 0x01,
+    0x3f, 0x01,
+    0x41, 0x01,
+    0x41, 0x01,
+    0x43, 0x01,
+    0x43, 0x01,
+    0x45, 0x01,
+    0x45, 0x01,
+    0x47, 0x01,
+    0x47, 0x01,
+    0x49, 0x01,
+    0x4a, 0x01,
+    0x4a, 0x01,
+    0x4c, 0x01,
+    0x4c, 0x01,
+    0x4e, 0x01,
+    0x4e, 0x01,
+    0x50, 0x01,
+    0x50, 0x01,
+    0x52, 0x01,
+    0x52, 0x01,
+    0x54, 0x01,
+    0x54, 0x01,
+    0x56, 0x01,
+    0x56, 0x01,
+    0x58, 0x01,
+    0x58, 0x01,
+    0x5a, 0x01,
+    0x5a, 0x01,
+    0x5c, 0x01,
+    0x5c, 0x01,
+    0x5e, 0x01,
+    0x5e, 0x01,
+    0x60, 0x01,
+    0x60, 0x01,
+    0x62, 0x01,
+    0x62, 0x01,
+    0x64, 0x01,
+    0x64, 0x01,
+    0x66, 0x01,
+    0x66, 0x01,
+    0x68, 0x01,
+    0x68, 0x01,
+    0x6a, 0x01,
+    0x6a, 0x01,
+    0x6c, 0x01,
+    0x6c, 0x01,
+    0x6e, 0x01,
+    0x6e, 0x01,
+    0x70, 0x01,
+    0x70, 0x01,
+    0x72, 0x01,
+    0x72, 0x01,
+    0x74, 0x01,
+    0x74, 0x01,
+    0x76, 0x01,
+    0x76, 0x01,
+    0x78, 0x01,
+    0x79, 0x01,
+    0x79, 0x01,
+    0x7b, 0x01,
+    0x7b, 0x01,
+    0x7d, 0x01,
+    0x7d, 0x01,
+    0x7f, 0x01,
+    0x43, 0x02,
+    0x81, 0x01,
+    0x82, 0x01,
+    0x82, 0x01,
+    0x84, 0x01,
+    0x84, 0x01,
+    0x86, 0x01,
+    0x87, 0x01,
+    0x87, 0x01,
+    0x89, 0x01,
+    0x8a, 0x01,
+    0x8b, 0x01,
+    0x8b, 0x01,
+    0x8d, 0x01,
+    0x8e, 0x01,
+    0x8f, 0x01,
+    0x90, 0x01,
+    0x91, 0x01,
+    0x91, 0x01,
+    0x93, 0x01,
+    0x94, 0x01,
+    0xf6, 0x01,
+    0x96, 0x01,
+    0x97, 0x01,
+    0x98, 0x01,
+    0x98, 0x01,
+    0x3d, 0x02,
+    0x9b, 0x01,
+    0x9c, 0x01,
+    0x9d, 0x01,
+    0x20, 0x02,
+    0x9f, 0x01,
+    0xa0, 0x01,
+    0xa0, 0x01,
+    0xa2, 0x01,
+    0xa2, 0x01,
+    0xa4, 0x01,
+    0xa4, 0x01,
+    0xa6, 0x01,
+    0xa7, 0x01,
+    0xa7, 0x01,
+    0xa9, 0x01,
+    0xaa, 0x01,
+    0xab, 0x01,
+    0xac, 0x01,
+    0xac, 0x01,
+    0xae, 0x01,
+    0xaf, 0x01,
+    0xaf, 0x01,
+    0xb1, 0x01,
+    0xb2, 0x01,
+    0xb3, 0x01,
+    0xb3, 0x01,
+    0xb5, 0x01,
+    0xb5, 0x01,
+    0xb7, 0x01,
+    0xb8, 0x01,
+    0xb8, 0x01,
+    0xba, 0x01,
+    0xbb, 0x01,
+    0xbc, 0x01,
+    0xbc, 0x01,
+    0xbe, 0x01,
+    0xf7, 0x01,
+    0xc0, 0x01,
+    0xc1, 0x01,
+    0xc2, 0x01,
+    0xc3, 0x01,
+    0xc4, 0x01,
+    0xc5, 0x01,
+    0xc4, 0x01,
+    0xc7, 0x01,
+    0xc8, 0x01,
+    0xc7, 0x01,
+    0xca, 0x01,
+    0xcb, 0x01,
+    0xca, 0x01,
+    0xcd, 0x01,
+    0xcd, 0x01,
+    0xcf, 0x01,
+    0xcf, 0x01,
+    0xd1, 0x01,
+    0xd1, 0x01,
+    0xd3, 0x01,
+    0xd3, 0x01,
+    0xd5, 0x01,
+    0xd5, 0x01,
+    0xd7, 0x01,
+    0xd7, 0x01,
+    0xd9, 0x01,
+    0xd9, 0x01,
+    0xdb, 0x01,
+    0xdb, 0x01,
+    0x8e, 0x01,
+    0xde, 0x01,
+    0xde, 0x01,
+    0xe0, 0x01,
+    0xe0, 0x01,
+    0xe2, 0x01,
+    0xe2, 0x01,
+    0xe4, 0x01,
+    0xe4, 0x01,
+    0xe6, 0x01,
+    0xe6, 0x01,
+    0xe8, 0x01,
+    0xe8, 0x01,
+    0xea, 0x01,
+    0xea, 0x01,
+    0xec, 0x01,
+    0xec, 0x01,
+    0xee, 0x01,
+    0xee, 0x01,
+    0xf0, 0x01,
+    0xf1, 0x01,
+    0xf2, 0x01,
+    0xf1, 0x01,
+    0xf4, 0x01,
+    0xf4, 0x01,
+    0xf6, 0x01,
+    0xf7, 0x01,
+    0xf8, 0x01,
+    0xf8, 0x01,
+    0xfa, 0x01,
+    0xfa, 0x01,
+    0xfc, 0x01,
+    0xfc, 0x01,
+    0xfe, 0x01,
+    0xfe, 0x01,
+    0x00, 0x02,
+    0x00, 0x02,
+    0x02, 0x02,
+    0x02, 0x02,
+    0x04, 0x02,
+    0x04, 0x02,
+    0x06, 0x02,
+    0x06, 0x02,
+    0x08, 0x02,
+    0x08, 0x02,
+    0x0a, 0x02,
+    0x0a, 0x02,
+    0x0c, 0x02,
+    0x0c, 0x02,
+    0x0e, 0x02,
+    0x0e, 0x02,
+    0x10, 0x02,
+    0x10, 0x02,
+    0x12, 0x02,
+    0x12, 0x02,
+    0x14, 0x02,
+    0x14, 0x02,
+    0x16, 0x02,
+    0x16, 0x02,
+    0x18, 0x02,
+    0x18, 0x02,
+    0x1a, 0x02,
+    0x1a, 0x02,
+    0x1c, 0x02,
+    0x1c, 0x02,
+    0x1e, 0x02,
+    0x1e, 0x02,
+    0x20, 0x02,
+    0x21, 0x02,
+    0x22, 0x02,
+    0x22, 0x02,
+    0x24, 0x02,
+    0x24, 0x02,
+    0x26, 0x02,
+    0x26, 0x02,
+    0x28, 0x02,
+    0x28, 0x02,
+    0x2a, 0x02,
+    0x2a, 0x02,
+    0x2c, 0x02,
+    0x2c, 0x02,
+    0x2e, 0x02,
+    0x2e, 0x02,
+    0x30, 0x02,
+    0x30, 0x02,
+    0x32, 0x02,
+    0x32, 0x02,
+    0x34, 0x02,
+    0x35, 0x02,
+    0x36, 0x02,
+    0x37, 0x02,
+    0x38, 0x02,
+    0x39, 0x02,
+    0x65, 0x2c,
+    0x3b, 0x02,
+    0x3b, 0x02,
+    0x3d, 0x02,
+    0x66, 0x2c,
+    0x3f, 0x02,
+    0x40, 0x02,
+    0x41, 0x02,
+    0x41, 0x02,
+    0x43, 0x02,
+    0x44, 0x02,
+    0x45, 0x02,
+    0x46, 0x02,
+    0x46, 0x02,
+    0x48, 0x02,
+    0x48, 0x02,
+    0x4a, 0x02,
+    0x4a, 0x02,
+    0x4c, 0x02,
+    0x4c, 0x02,
+    0x4e, 0x02,
+    0x4e, 0x02,
+    0x50, 0x02,
+    0x51, 0x02,
+    0x52, 0x02,
+    0x81, 0x01,
+    0x86, 0x01,
+    0x55, 0x02,
+    0x89, 0x01,
+    0x8a, 0x01,
+    0x58, 0x02,
+    0x8f, 0x01,
+    0x5a, 0x02,
+    0x90, 0x01,
+    0x5c, 0x02,
+    0x5d, 0x02,
+    0x5e, 0x02,
+    0x5f, 0x02,
+    0x93, 0x01,
+    0x61, 0x02,
+    0x62, 0x02,
+    0x94, 0x01,
+    0x64, 0x02,
+    0x65, 0x02,
+    0x66, 0x02,
+    0x67, 0x02,
+    0x97, 0x01,
+    0x96, 0x01,
+    0x6a, 0x02,
+    0x62, 0x2c,
+    0x6c, 0x02,
+    0x6d, 0x02,
+    0x6e, 0x02,
+    0x9c, 0x01,
+    0x70, 0x02,
+    0x71, 0x02,
+    0x9d, 0x01,
+    0x73, 0x02,
+    0x74, 0x02,
+    0x9f, 0x01,
+    0x76, 0x02,
+    0x77, 0x02,
+    0x78, 0x02,
+    0x79, 0x02,
+    0x7a, 0x02,
+    0x7b, 0x02,
+    0x7c, 0x02,
+    0x64, 0x2c,
+    0x7e, 0x02,
+    0x7f, 0x02,
+    0xa6, 0x01,
+    0x81, 0x02,
+    0x82, 0x02,
+    0xa9, 0x01,
+    0x84, 0x02,
+    0x85, 0x02,
+    0x86, 0x02,
+    0x87, 0x02,
+    0xae, 0x01,
+    0x44, 0x02,
+    0xb1, 0x01,
+    0xb2, 0x01,
+    0x45, 0x02,
+    0x8d, 0x02,
+    0x8e, 0x02,
+    0x8f, 0x02,
+    0x90, 0x02,
+    0x91, 0x02,
+    0xb7, 0x01,
+    0x93, 0x02,
+    0x94, 0x02,
+    0x95, 0x02,
+    0x96, 0x02,
+    0x97, 0x02,
+    0x98, 0x02,
+    0x99, 0x02,
+    0x9a, 0x02,
+    0x9b, 0x02,
+    0x9c, 0x02,
+    0x9d, 0x02,
+    0x9e, 0x02,
+    0x9f, 0x02,
+    0xa0, 0x02,
+    0xa1, 0x02,
+    0xa2, 0x02,
+    0xa3, 0x02,
+    0xa4, 0x02,
+    0xa5, 0x02,
+    0xa6, 0x02,
+    0xa7, 0x02,
+    0xa8, 0x02,
+    0xa9, 0x02,
+    0xaa, 0x02,
+    0xab, 0x02,
+    0xac, 0x02,
+    0xad, 0x02,
+    0xae, 0x02,
+    0xaf, 0x02,
+    0xb0, 0x02,
+    0xb1, 0x02,
+    0xb2, 0x02,
+    0xb3, 0x02,
+    0xb4, 0x02,
+    0xb5, 0x02,
+    0xb6, 0x02,
+    0xb7, 0x02,
+    0xb8, 0x02,
+    0xb9, 0x02,
+    0xba, 0x02,
+    0xbb, 0x02,
+    0xbc, 0x02,
+    0xbd, 0x02,
+    0xbe, 0x02,
+    0xbf, 0x02,
+    0xc0, 0x02,
+    0xc1, 0x02,
+    0xc2, 0x02,
+    0xc3, 0x02,
+    0xc4, 0x02,
+    0xc5, 0x02,
+    0xc6, 0x02,
+    0xc7, 0x02,
+    0xc8, 0x02,
+    0xc9, 0x02,
+    0xca, 0x02,
+    0xcb, 0x02,
+    0xcc, 0x02,
+    0xcd, 0x02,
+    0xce, 0x02,
+    0xcf, 0x02,
+    0xd0, 0x02,
+    0xd1, 0x02,
+    0xd2, 0x02,
+    0xd3, 0x02,
+    0xd4, 0x02,
+    0xd5, 0x02,
+    0xd6, 0x02,
+    0xd7, 0x02,
+    0xd8, 0x02,
+    0xd9, 0x02,
+    0xda, 0x02,
+    0xdb, 0x02,
+    0xdc, 0x02,
+    0xdd, 0x02,
+    0xde, 0x02,
+    0xdf, 0x02,
+    0xe0, 0x02,
+    0xe1, 0x02,
+    0xe2, 0x02,
+    0xe3, 0x02,
+    0xe4, 0x02,
+    0xe5, 0x02,
+    0xe6, 0x02,
+    0xe7, 0x02,
+    0xe8, 0x02,
+    0xe9, 0x02,
+    0xea, 0x02,
+    0xeb, 0x02,
+    0xec, 0x02,
+    0xed, 0x02,
+    0xee, 0x02,
+    0xef, 0x02,
+    0xf0, 0x02,
+    0xf1, 0x02,
+    0xf2, 0x02,
+    0xf3, 0x02,
+    0xf4, 0x02,
+    0xf5, 0x02,
+    0xf6, 0x02,
+    0xf7, 0x02,
+    0xf8, 0x02,
+    0xf9, 0x02,
+    0xfa, 0x02,
+    0xfb, 0x02,
+    0xfc, 0x02,
+    0xfd, 0x02,
+    0xfe, 0x02,
+    0xff, 0x02,
+    0x00, 0x03,
+    0x01, 0x03,
+    0x02, 0x03,
+    0x03, 0x03,
+    0x04, 0x03,
+    0x05, 0x03,
+    0x06, 0x03,
+    0x07, 0x03,
+    0x08, 0x03,
+    0x09, 0x03,
+    0x0a, 0x03,
+    0x0b, 0x03,
+    0x0c, 0x03,
+    0x0d, 0x03,
+    0x0e, 0x03,
+    0x0f, 0x03,
+    0x10, 0x03,
+    0x11, 0x03,
+    0x12, 0x03,
+    0x13, 0x03,
+    0x14, 0x03,
+    0x15, 0x03,
+    0x16, 0x03,
+    0x17, 0x03,
+    0x18, 0x03,
+    0x19, 0x03,
+    0x1a, 0x03,
+    0x1b, 0x03,
+    0x1c, 0x03,
+    0x1d, 0x03,
+    0x1e, 0x03,
+    0x1f, 0x03,
+    0x20, 0x03,
+    0x21, 0x03,
+    0x22, 0x03,
+    0x23, 0x03,
+    0x24, 0x03,
+    0x25, 0x03,
+    0x26, 0x03,
+    0x27, 0x03,
+    0x28, 0x03,
+    0x29, 0x03,
+    0x2a, 0x03,
+    0x2b, 0x03,
+    0x2c, 0x03,
+    0x2d, 0x03,
+    0x2e, 0x03,
+    0x2f, 0x03,
+    0x30, 0x03,
+    0x31, 0x03,
+    0x32, 0x03,
+    0x33, 0x03,
+    0x34, 0x03,
+    0x35, 0x03,
+    0x36, 0x03,
+    0x37, 0x03,
+    0x38, 0x03,
+    0x39, 0x03,
+    0x3a, 0x03,
+    0x3b, 0x03,
+    0x3c, 0x03,
+    0x3d, 0x03,
+    0x3e, 0x03,
+    0x3f, 0x03,
+    0x40, 0x03,
+    0x41, 0x03,
+    0x42, 0x03,
+    0x43, 0x03,
+    0x44, 0x03,
+    0x45, 0x03,
+    0x46, 0x03,
+    0x47, 0x03,
+    0x48, 0x03,
+    0x49, 0x03,
+    0x4a, 0x03,
+    0x4b, 0x03,
+    0x4c, 0x03,
+    0x4d, 0x03,
+    0x4e, 0x03,
+    0x4f, 0x03,
+    0x50, 0x03,
+    0x51, 0x03,
+    0x52, 0x03,
+    0x53, 0x03,
+    0x54, 0x03,
+    0x55, 0x03,
+    0x56, 0x03,
+    0x57, 0x03,
+    0x58, 0x03,
+    0x59, 0x03,
+    0x5a, 0x03,
+    0x5b, 0x03,
+    0x5c, 0x03,
+    0x5d, 0x03,
+    0x5e, 0x03,
+    0x5f, 0x03,
+    0x60, 0x03,
+    0x61, 0x03,
+    0x62, 0x03,
+    0x63, 0x03,
+    0x64, 0x03,
+    0x65, 0x03,
+    0x66, 0x03,
+    0x67, 0x03,
+    0x68, 0x03,
+    0x69, 0x03,
+    0x6a, 0x03,
+    0x6b, 0x03,
+    0x6c, 0x03,
+    0x6d, 0x03,
+    0x6e, 0x03,
+    0x6f, 0x03,
+    0x70, 0x03,
+    0x71, 0x03,
+    0x72, 0x03,
+    0x73, 0x03,
+    0x74, 0x03,
+    0x75, 0x03,
+    0x76, 0x03,
+    0x77, 0x03,
+    0x78, 0x03,
+    0x79, 0x03,
+    0x7a, 0x03,
+    0xfd, 0x03,
+    0xfe, 0x03,
+    0xff, 0x03,
+    0x7e, 0x03,
+    0x7f, 0x03,
+    0x80, 0x03,
+    0x81, 0x03,
+    0x82, 0x03,
+    0x83, 0x03,
+    0x84, 0x03,
+    0x85, 0x03,
+    0x86, 0x03,
+    0x87, 0x03,
+    0x88, 0x03,
+    0x89, 0x03,
+    0x8a, 0x03,
+    0x8b, 0x03,
+    0x8c, 0x03,
+    0x8d, 0x03,
+    0x8e, 0x03,
+    0x8f, 0x03,
+    0x90, 0x03,
+    0x91, 0x03,
+    0x92, 0x03,
+    0x93, 0x03,
+    0x94, 0x03,
+    0x95, 0x03,
+    0x96, 0x03,
+    0x97, 0x03,
+    0x98, 0x03,
+    0x99, 0x03,
+    0x9a, 0x03,
+    0x9b, 0x03,
+    0x9c, 0x03,
+    0x9d, 0x03,
+    0x9e, 0x03,
+    0x9f, 0x03,
+    0xa0, 0x03,
+    0xa1, 0x03,
+    0xa2, 0x03,
+    0xa3, 0x03,
+    0xa4, 0x03,
+    0xa5, 0x03,
+    0xa6, 0x03,
+    0xa7, 0x03,
+    0xa8, 0x03,
+    0xa9, 0x03,
+    0xaa, 0x03,
+    0xab, 0x03,
+    0x86, 0x03,
+    0x88, 0x03,
+    0x89, 0x03,
+    0x8a, 0x03,
+    0xb0, 0x03,
+    0x91, 0x03,
+    0x92, 0x03,
+    0x93, 0x03,
+    0x94, 0x03,
+    0x95, 0x03,
+    0x96, 0x03,
+    0x97, 0x03,
+    0x98, 0x03,
+    0x99, 0x03,
+    0x9a, 0x03,
+    0x9b, 0x03,
+    0x9c, 0x03,
+    0x9d, 0x03,
+    0x9e, 0x03,
+    0x9f, 0x03,
+    0xa0, 0x03,
+    0xa1, 0x03,
+    0xa3, 0x03,
+    0xa3, 0x03,
+    0xa4, 0x03,
+    0xa5, 0x03,
+    0xa6, 0x03,
+    0xa7, 0x03,
+    0xa8, 0x03,
+    0xa9, 0x03,
+    0xaa, 0x03,
+    0xab, 0x03,
+    0x8c, 0x03,
+    0x8e, 0x03,
+    0x8f, 0x03,
+    0xcf, 0x03,
+    0xd0, 0x03,
+    0xd1, 0x03,
+    0xd2, 0x03,
+    0xd3, 0x03,
+    0xd4, 0x03,
+    0xd5, 0x03,
+    0xd6, 0x03,
+    0xd7, 0x03,
+    0xd8, 0x03,
+    0xd8, 0x03,
+    0xda, 0x03,
+    0xda, 0x03,
+    0xdc, 0x03,
+    0xdc, 0x03,
+    0xde, 0x03,
+    0xde, 0x03,
+    0xe0, 0x03,
+    0xe0, 0x03,
+    0xe2, 0x03,
+    0xe2, 0x03,
+    0xe4, 0x03,
+    0xe4, 0x03,
+    0xe6, 0x03,
+    0xe6, 0x03,
+    0xe8, 0x03,
+    0xe8, 0x03,
+    0xea, 0x03,
+    0xea, 0x03,
+    0xec, 0x03,
+    0xec, 0x03,
+    0xee, 0x03,
+    0xee, 0x03,
+    0xf0, 0x03,
+    0xf1, 0x03,
+    0xf9, 0x03,
+    0xf3, 0x03,
+    0xf4, 0x03,
+    0xf5, 0x03,
+    0xf6, 0x03,
+    0xf7, 0x03,
+    0xf7, 0x03,
+    0xf9, 0x03,
+    0xfa, 0x03,
+    0xfa, 0x03,
+    0xfc, 0x03,
+    0xfd, 0x03,
+    0xfe, 0x03,
+    0xff, 0x03,
+    0x00, 0x04,
+    0x01, 0x04,
+    0x02, 0x04,
+    0x03, 0x04,
+    0x04, 0x04,
+    0x05, 0x04,
+    0x06, 0x04,
+    0x07, 0x04,
+    0x08, 0x04,
+    0x09, 0x04,
+    0x0a, 0x04,
+    0x0b, 0x04,
+    0x0c, 0x04,
+    0x0d, 0x04,
+    0x0e, 0x04,
+    0x0f, 0x04,
+    0x10, 0x04,
+    0x11, 0x04,
+    0x12, 0x04,
+    0x13, 0x04,
+    0x14, 0x04,
+    0x15, 0x04,
+    0x16, 0x04,
+    0x17, 0x04,
+    0x18, 0x04,
+    0x19, 0x04,
+    0x1a, 0x04,
+    0x1b, 0x04,
+    0x1c, 0x04,
+    0x1d, 0x04,
+    0x1e, 0x04,
+    0x1f, 0x04,
+    0x20, 0x04,
+    0x21, 0x04,
+    0x22, 0x04,
+    0x23, 0x04,
+    0x24, 0x04,
+    0x25, 0x04,
+    0x26, 0x04,
+    0x27, 0x04,
+    0x28, 0x04,
+    0x29, 0x04,
+    0x2a, 0x04,
+    0x2b, 0x04,
+    0x2c, 0x04,
+    0x2d, 0x04,
+    0x2e, 0x04,
+    0x2f, 0x04,
+    0x10, 0x04,
+    0x11, 0x04,
+    0x12, 0x04,
+    0x13, 0x04,
+    0x14, 0x04,
+    0x15, 0x04,
+    0x16, 0x04,
+    0x17, 0x04,
+    0x18, 0x04,
+    0x19, 0x04,
+    0x1a, 0x04,
+    0x1b, 0x04,
+    0x1c, 0x04,
+    0x1d, 0x04,
+    0x1e, 0x04,
+    0x1f, 0x04,
+    0x20, 0x04,
+    0x21, 0x04,
+    0x22, 0x04,
+    0x23, 0x04,
+    0x24, 0x04,
+    0x25, 0x04,
+    0x26, 0x04,
+    0x27, 0x04,
+    0x28, 0x04,
+    0x29, 0x04,
+    0x2a, 0x04,
+    0x2b, 0x04,
+    0x2c, 0x04,
+    0x2d, 0x04,
+    0x2e, 0x04,
+    0x2f, 0x04,
+    0x00, 0x04,
+    0x01, 0x04,
+    0x02, 0x04,
+    0x03, 0x04,
+    0x04, 0x04,
+    0x05, 0x04,
+    0x06, 0x04,
+    0x07, 0x04,
+    0x08, 0x04,
+    0x09, 0x04,
+    0x0a, 0x04,
+    0x0b, 0x04,
+    0x0c, 0x04,
+    0x0d, 0x04,
+    0x0e, 0x04,
+    0x0f, 0x04,
+    0x60, 0x04,
+    0x60, 0x04,
+    0x62, 0x04,
+    0x62, 0x04,
+    0x64, 0x04,
+    0x64, 0x04,
+    0x66, 0x04,
+    0x66, 0x04,
+    0x68, 0x04,
+    0x68, 0x04,
+    0x6a, 0x04,
+    0x6a, 0x04,
+    0x6c, 0x04,
+    0x6c, 0x04,
+    0x6e, 0x04,
+    0x6e, 0x04,
+    0x70, 0x04,
+    0x70, 0x04,
+    0x72, 0x04,
+    0x72, 0x04,
+    0x74, 0x04,
+    0x74, 0x04,
+    0x76, 0x04,
+    0x76, 0x04,
+    0x78, 0x04,
+    0x78, 0x04,
+    0x7a, 0x04,
+    0x7a, 0x04,
+    0x7c, 0x04,
+    0x7c, 0x04,
+    0x7e, 0x04,
+    0x7e, 0x04,
+    0x80, 0x04,
+    0x80, 0x04,
+    0x82, 0x04,
+    0x83, 0x04,
+    0x84, 0x04,
+    0x85, 0x04,
+    0x86, 0x04,
+    0x87, 0x04,
+    0x88, 0x04,
+    0x89, 0x04,
+    0x8a, 0x04,
+    0x8a, 0x04,
+    0x8c, 0x04,
+    0x8c, 0x04,
+    0x8e, 0x04,
+    0x8e, 0x04,
+    0x90, 0x04,
+    0x90, 0x04,
+    0x92, 0x04,
+    0x92, 0x04,
+    0x94, 0x04,
+    0x94, 0x04,
+    0x96, 0x04,
+    0x96, 0x04,
+    0x98, 0x04,
+    0x98, 0x04,
+    0x9a, 0x04,
+    0x9a, 0x04,
+    0x9c, 0x04,
+    0x9c, 0x04,
+    0x9e, 0x04,
+    0x9e, 0x04,
+    0xa0, 0x04,
+    0xa0, 0x04,
+    0xa2, 0x04,
+    0xa2, 0x04,
+    0xa4, 0x04,
+    0xa4, 0x04,
+    0xa6, 0x04,
+    0xa6, 0x04,
+    0xa8, 0x04,
+    0xa8, 0x04,
+    0xaa, 0x04,
+    0xaa, 0x04,
+    0xac, 0x04,
+    0xac, 0x04,
+    0xae, 0x04,
+    0xae, 0x04,
+    0xb0, 0x04,
+    0xb0, 0x04,
+    0xb2, 0x04,
+    0xb2, 0x04,
+    0xb4, 0x04,
+    0xb4, 0x04,
+    0xb6, 0x04,
+    0xb6, 0x04,
+    0xb8, 0x04,
+    0xb8, 0x04,
+    0xba, 0x04,
+    0xba, 0x04,
+    0xbc, 0x04,
+    0xbc, 0x04,
+    0xbe, 0x04,
+    0xbe, 0x04,
+    0xc0, 0x04,
+    0xc1, 0x04,
+    0xc1, 0x04,
+    0xc3, 0x04,
+    0xc3, 0x04,
+    0xc5, 0x04,
+    0xc5, 0x04,
+    0xc7, 0x04,
+    0xc7, 0x04,
+    0xc9, 0x04,
+    0xc9, 0x04,
+    0xcb, 0x04,
+    0xcb, 0x04,
+    0xcd, 0x04,
+    0xcd, 0x04,
+    0xc0, 0x04,
+    0xd0, 0x04,
+    0xd0, 0x04,
+    0xd2, 0x04,
+    0xd2, 0x04,
+    0xd4, 0x04,
+    0xd4, 0x04,
+    0xd6, 0x04,
+    0xd6, 0x04,
+    0xd8, 0x04,
+    0xd8, 0x04,
+    0xda, 0x04,
+    0xda, 0x04,
+    0xdc, 0x04,
+    0xdc, 0x04,
+    0xde, 0x04,
+    0xde, 0x04,
+    0xe0, 0x04,
+    0xe0, 0x04,
+    0xe2, 0x04,
+    0xe2, 0x04,
+    0xe4, 0x04,
+    0xe4, 0x04,
+    0xe6, 0x04,
+    0xe6, 0x04,
+    0xe8, 0x04,
+    0xe8, 0x04,
+    0xea, 0x04,
+    0xea, 0x04,
+    0xec, 0x04,
+    0xec, 0x04,
+    0xee, 0x04,
+    0xee, 0x04,
+    0xf0, 0x04,
+    0xf0, 0x04,
+    0xf2, 0x04,
+    0xf2, 0x04,
+    0xf4, 0x04,
+    0xf4, 0x04,
+    0xf6, 0x04,
+    0xf6, 0x04,
+    0xf8, 0x04,
+    0xf8, 0x04,
+    0xfa, 0x04,
+    0xfa, 0x04,
+    0xfc, 0x04,
+    0xfc, 0x04,
+    0xfe, 0x04,
+    0xfe, 0x04,
+    0x00, 0x05,
+    0x00, 0x05,
+    0x02, 0x05,
+    0x02, 0x05,
+    0x04, 0x05,
+    0x04, 0x05,
+    0x06, 0x05,
+    0x06, 0x05,
+    0x08, 0x05,
+    0x08, 0x05,
+    0x0a, 0x05,
+    0x0a, 0x05,
+    0x0c, 0x05,
+    0x0c, 0x05,
+    0x0e, 0x05,
+    0x0e, 0x05,
+    0x10, 0x05,
+    0x10, 0x05,
+    0x12, 0x05,
+    0x12, 0x05,
+    0x14, 0x05,
+    0x15, 0x05,
+    0x16, 0x05,
+    0x17, 0x05,
+    0x18, 0x05,
+    0x19, 0x05,
+    0x1a, 0x05,
+    0x1b, 0x05,
+    0x1c, 0x05,
+    0x1d, 0x05,
+    0x1e, 0x05,
+    0x1f, 0x05,
+    0x20, 0x05,
+    0x21, 0x05,
+    0x22, 0x05,
+    0x23, 0x05,
+    0x24, 0x05,
+    0x25, 0x05,
+    0x26, 0x05,
+    0x27, 0x05,
+    0x28, 0x05,
+    0x29, 0x05,
+    0x2a, 0x05,
+    0x2b, 0x05,
+    0x2c, 0x05,
+    0x2d, 0x05,
+    0x2e, 0x05,
+    0x2f, 0x05,
+    0x30, 0x05,
+    0x31, 0x05,
+    0x32, 0x05,
+    0x33, 0x05,
+    0x34, 0x05,
+    0x35, 0x05,
+    0x36, 0x05,
+    0x37, 0x05,
+    0x38, 0x05,
+    0x39, 0x05,
+    0x3a, 0x05,
+    0x3b, 0x05,
+    0x3c, 0x05,
+    0x3d, 0x05,
+    0x3e, 0x05,
+    0x3f, 0x05,
+    0x40, 0x05,
+    0x41, 0x05,
+    0x42, 0x05,
+    0x43, 0x05,
+    0x44, 0x05,
+    0x45, 0x05,
+    0x46, 0x05,
+    0x47, 0x05,
+    0x48, 0x05,
+    0x49, 0x05,
+    0x4a, 0x05,
+    0x4b, 0x05,
+    0x4c, 0x05,
+    0x4d, 0x05,
+    0x4e, 0x05,
+    0x4f, 0x05,
+    0x50, 0x05,
+    0x51, 0x05,
+    0x52, 0x05,
+    0x53, 0x05,
+    0x54, 0x05,
+    0x55, 0x05,
+    0x56, 0x05,
+    0x57, 0x05,
+    0x58, 0x05,
+    0x59, 0x05,
+    0x5a, 0x05,
+    0x5b, 0x05,
+    0x5c, 0x05,
+    0x5d, 0x05,
+    0x5e, 0x05,
+    0x5f, 0x05,
+    0x60, 0x05,
+    0x31, 0x05,
+    0x32, 0x05,
+    0x33, 0x05,
+    0x34, 0x05,
+    0x35, 0x05,
+    0x36, 0x05,
+    0x37, 0x05,
+    0x38, 0x05,
+    0x39, 0x05,
+    0x3a, 0x05,
+    0x3b, 0x05,
+    0x3c, 0x05,
+    0x3d, 0x05,
+    0x3e, 0x05,
+    0x3f, 0x05,
+    0x40, 0x05,
+    0x41, 0x05,
+    0x42, 0x05,
+    0x43, 0x05,
+    0x44, 0x05,
+    0x45, 0x05,
+    0x46, 0x05,
+    0x47, 0x05,
+    0x48, 0x05,
+    0x49, 0x05,
+    0x4a, 0x05,
+    0x4b, 0x05,
+    0x4c, 0x05,
+    0x4d, 0x05,
+    0x4e, 0x05,
+    0x4f, 0x05,
+    0x50, 0x05,
+    0x51, 0x05,
+    0x52, 0x05,
+    0x53, 0x05,
+    0x54, 0x05,
+    0x55, 0x05,
+    0x56, 0x05,
+    0xff, 0xff,
+    0xf6, 0x17,
+    0x63, 0x2c,
+    0x7e, 0x1d,
+    0x7f, 0x1d,
+    0x80, 0x1d,
+    0x81, 0x1d,
+    0x82, 0x1d,
+    0x83, 0x1d,
+    0x84, 0x1d,
+    0x85, 0x1d,
+    0x86, 0x1d,
+    0x87, 0x1d,
+    0x88, 0x1d,
+    0x89, 0x1d,
+    0x8a, 0x1d,
+    0x8b, 0x1d,
+    0x8c, 0x1d,
+    0x8d, 0x1d,
+    0x8e, 0x1d,
+    0x8f, 0x1d,
+    0x90, 0x1d,
+    0x91, 0x1d,
+    0x92, 0x1d,
+    0x93, 0x1d,
+    0x94, 0x1d,
+    0x95, 0x1d,
+    0x96, 0x1d,
+    0x97, 0x1d,
+    0x98, 0x1d,
+    0x99, 0x1d,
+    0x9a, 0x1d,
+    0x9b, 0x1d,
+    0x9c, 0x1d,
+    0x9d, 0x1d,
+    0x9e, 0x1d,
+    0x9f, 0x1d,
+    0xa0, 0x1d,
+    0xa1, 0x1d,
+    0xa2, 0x1d,
+    0xa3, 0x1d,
+    0xa4, 0x1d,
+    0xa5, 0x1d,
+    0xa6, 0x1d,
+    0xa7, 0x1d,
+    0xa8, 0x1d,
+    0xa9, 0x1d,
+    0xaa, 0x1d,
+    0xab, 0x1d,
+    0xac, 0x1d,
+    0xad, 0x1d,
+    0xae, 0x1d,
+    0xaf, 0x1d,
+    0xb0, 0x1d,
+    0xb1, 0x1d,
+    0xb2, 0x1d,
+    0xb3, 0x1d,
+    0xb4, 0x1d,
+    0xb5, 0x1d,
+    0xb6, 0x1d,
+    0xb7, 0x1d,
+    0xb8, 0x1d,
+    0xb9, 0x1d,
+    0xba, 0x1d,
+    0xbb, 0x1d,
+    0xbc, 0x1d,
+    0xbd, 0x1d,
+    0xbe, 0x1d,
+    0xbf, 0x1d,
+    0xc0, 0x1d,
+    0xc1, 0x1d,
+    0xc2, 0x1d,
+    0xc3, 0x1d,
+    0xc4, 0x1d,
+    0xc5, 0x1d,
+    0xc6, 0x1d,
+    0xc7, 0x1d,
+    0xc8, 0x1d,
+    0xc9, 0x1d,
+    0xca, 0x1d,
+    0xcb, 0x1d,
+    0xcc, 0x1d,
+    0xcd, 0x1d,
+    0xce, 0x1d,
+    0xcf, 0x1d,
+    0xd0, 0x1d,
+    0xd1, 0x1d,
+    0xd2, 0x1d,
+    0xd3, 0x1d,
+    0xd4, 0x1d,
+    0xd5, 0x1d,
+    0xd6, 0x1d,
+    0xd7, 0x1d,
+    0xd8, 0x1d,
+    0xd9, 0x1d,
+    0xda, 0x1d,
+    0xdb, 0x1d,
+    0xdc, 0x1d,
+    0xdd, 0x1d,
+    0xde, 0x1d,
+    0xdf, 0x1d,
+    0xe0, 0x1d,
+    0xe1, 0x1d,
+    0xe2, 0x1d,
+    0xe3, 0x1d,
+    0xe4, 0x1d,
+    0xe5, 0x1d,
+    0xe6, 0x1d,
+    0xe7, 0x1d,
+    0xe8, 0x1d,
+    0xe9, 0x1d,
+    0xea, 0x1d,
+    0xeb, 0x1d,
+    0xec, 0x1d,
+    0xed, 0x1d,
+    0xee, 0x1d,
+    0xef, 0x1d,
+    0xf0, 0x1d,
+    0xf1, 0x1d,
+    0xf2, 0x1d,
+    0xf3, 0x1d,
+    0xf4, 0x1d,
+    0xf5, 0x1d,
+    0xf6, 0x1d,
+    0xf7, 0x1d,
+    0xf8, 0x1d,
+    0xf9, 0x1d,
+    0xfa, 0x1d,
+    0xfb, 0x1d,
+    0xfc, 0x1d,
+    0xfd, 0x1d,
+    0xfe, 0x1d,
+    0xff, 0x1d,
+    0x00, 0x1e,
+    0x00, 0x1e,
+    0x02, 0x1e,
+    0x02, 0x1e,
+    0x04, 0x1e,
+    0x04, 0x1e,
+    0x06, 0x1e,
+    0x06, 0x1e,
+    0x08, 0x1e,
+    0x08, 0x1e,
+    0x0a, 0x1e,
+    0x0a, 0x1e,
+    0x0c, 0x1e,
+    0x0c, 0x1e,
+    0x0e, 0x1e,
+    0x0e, 0x1e,
+    0x10, 0x1e,
+    0x10, 0x1e,
+    0x12, 0x1e,
+    0x12, 0x1e,
+    0x14, 0x1e,
+    0x14, 0x1e,
+    0x16, 0x1e,
+    0x16, 0x1e,
+    0x18, 0x1e,
+    0x18, 0x1e,
+    0x1a, 0x1e,
+    0x1a, 0x1e,
+    0x1c, 0x1e,
+    0x1c, 0x1e,
+    0x1e, 0x1e,
+    0x1e, 0x1e,
+    0x20, 0x1e,
+    0x20, 0x1e,
+    0x22, 0x1e,
+    0x22, 0x1e,
+    0x24, 0x1e,
+    0x24, 0x1e,
+    0x26, 0x1e,
+    0x26, 0x1e,
+    0x28, 0x1e,
+    0x28, 0x1e,
+    0x2a, 0x1e,
+    0x2a, 0x1e,
+    0x2c, 0x1e,
+    0x2c, 0x1e,
+    0x2e, 0x1e,
+    0x2e, 0x1e,
+    0x30, 0x1e,
+    0x30, 0x1e,
+    0x32, 0x1e,
+    0x32, 0x1e,
+    0x34, 0x1e,
+    0x34, 0x1e,
+    0x36, 0x1e,
+    0x36, 0x1e,
+    0x38, 0x1e,
+    0x38, 0x1e,
+    0x3a, 0x1e,
+    0x3a, 0x1e,
+    0x3c, 0x1e,
+    0x3c, 0x1e,
+    0x3e, 0x1e,
+    0x3e, 0x1e,
+    0x40, 0x1e,
+    0x40, 0x1e,
+    0x42, 0x1e,
+    0x42, 0x1e,
+    0x44, 0x1e,
+    0x44, 0x1e,
+    0x46, 0x1e,
+    0x46, 0x1e,
+    0x48, 0x1e,
+    0x48, 0x1e,
+    0x4a, 0x1e,
+    0x4a, 0x1e,
+    0x4c, 0x1e,
+    0x4c, 0x1e,
+    0x4e, 0x1e,
+    0x4e, 0x1e,
+    0x50, 0x1e,
+    0x50, 0x1e,
+    0x52, 0x1e,
+    0x52, 0x1e,
+    0x54, 0x1e,
+    0x54, 0x1e,
+    0x56, 0x1e,
+    0x56, 0x1e,
+    0x58, 0x1e,
+    0x58, 0x1e,
+    0x5a, 0x1e,
+    0x5a, 0x1e,
+    0x5c, 0x1e,
+    0x5c, 0x1e,
+    0x5e, 0x1e,
+    0x5e, 0x1e,
+    0x60, 0x1e,
+    0x60, 0x1e,
+    0x62, 0x1e,
+    0x62, 0x1e,
+    0x64, 0x1e,
+    0x64, 0x1e,
+    0x66, 0x1e,
+    0x66, 0x1e,
+    0x68, 0x1e,
+    0x68, 0x1e,
+    0x6a, 0x1e,
+    0x6a, 0x1e,
+    0x6c, 0x1e,
+    0x6c, 0x1e,
+    0x6e, 0x1e,
+    0x6e, 0x1e,
+    0x70, 0x1e,
+    0x70, 0x1e,
+    0x72, 0x1e,
+    0x72, 0x1e,
+    0x74, 0x1e,
+    0x74, 0x1e,
+    0x76, 0x1e,
+    0x76, 0x1e,
+    0x78, 0x1e,
+    0x78, 0x1e,
+    0x7a, 0x1e,
+    0x7a, 0x1e,
+    0x7c, 0x1e,
+    0x7c, 0x1e,
+    0x7e, 0x1e,
+    0x7e, 0x1e,
+    0x80, 0x1e,
+    0x80, 0x1e,
+    0x82, 0x1e,
+    0x82, 0x1e,
+    0x84, 0x1e,
+    0x84, 0x1e,
+    0x86, 0x1e,
+    0x86, 0x1e,
+    0x88, 0x1e,
+    0x88, 0x1e,
+    0x8a, 0x1e,
+    0x8a, 0x1e,
+    0x8c, 0x1e,
+    0x8c, 0x1e,
+    0x8e, 0x1e,
+    0x8e, 0x1e,
+    0x90, 0x1e,
+    0x90, 0x1e,
+    0x92, 0x1e,
+    0x92, 0x1e,
+    0x94, 0x1e,
+    0x94, 0x1e,
+    0x96, 0x1e,
+    0x97, 0x1e,
+    0x98, 0x1e,
+    0x99, 0x1e,
+    0x9a, 0x1e,
+    0x9b, 0x1e,
+    0x9c, 0x1e,
+    0x9d, 0x1e,
+    0x9e, 0x1e,
+    0x9f, 0x1e,
+    0xa0, 0x1e,
+    0xa0, 0x1e,
+    0xa2, 0x1e,
+    0xa2, 0x1e,
+    0xa4, 0x1e,
+    0xa4, 0x1e,
+    0xa6, 0x1e,
+    0xa6, 0x1e,
+    0xa8, 0x1e,
+    0xa8, 0x1e,
+    0xaa, 0x1e,
+    0xaa, 0x1e,
+    0xac, 0x1e,
+    0xac, 0x1e,
+    0xae, 0x1e,
+    0xae, 0x1e,
+    0xb0, 0x1e,
+    0xb0, 0x1e,
+    0xb2, 0x1e,
+    0xb2, 0x1e,
+    0xb4, 0x1e,
+    0xb4, 0x1e,
+    0xb6, 0x1e,
+    0xb6, 0x1e,
+    0xb8, 0x1e,
+    0xb8, 0x1e,
+    0xba, 0x1e,
+    0xba, 0x1e,
+    0xbc, 0x1e,
+    0xbc, 0x1e,
+    0xbe, 0x1e,
+    0xbe, 0x1e,
+    0xc0, 0x1e,
+    0xc0, 0x1e,
+    0xc2, 0x1e,
+    0xc2, 0x1e,
+    0xc4, 0x1e,
+    0xc4, 0x1e,
+    0xc6, 0x1e,
+    0xc6, 0x1e,
+    0xc8, 0x1e,
+    0xc8, 0x1e,
+    0xca, 0x1e,
+    0xca, 0x1e,
+    0xcc, 0x1e,
+    0xcc, 0x1e,
+    0xce, 0x1e,
+    0xce, 0x1e,
+    0xd0, 0x1e,
+    0xd0, 0x1e,
+    0xd2, 0x1e,
+    0xd2, 0x1e,
+    0xd4, 0x1e,
+    0xd4, 0x1e,
+    0xd6, 0x1e,
+    0xd6, 0x1e,
+    0xd8, 0x1e,
+    0xd8, 0x1e,
+    0xda, 0x1e,
+    0xda, 0x1e,
+    0xdc, 0x1e,
+    0xdc, 0x1e,
+    0xde, 0x1e,
+    0xde, 0x1e,
+    0xe0, 0x1e,
+    0xe0, 0x1e,
+    0xe2, 0x1e,
+    0xe2, 0x1e,
+    0xe4, 0x1e,
+    0xe4, 0x1e,
+    0xe6, 0x1e,
+    0xe6, 0x1e,
+    0xe8, 0x1e,
+    0xe8, 0x1e,
+    0xea, 0x1e,
+    0xea, 0x1e,
+    0xec, 0x1e,
+    0xec, 0x1e,
+    0xee, 0x1e,
+    0xee, 0x1e,
+    0xf0, 0x1e,
+    0xf0, 0x1e,
+    0xf2, 0x1e,
+    0xf2, 0x1e,
+    0xf4, 0x1e,
+    0xf4, 0x1e,
+    0xf6, 0x1e,
+    0xf6, 0x1e,
+    0xf8, 0x1e,
+    0xf8, 0x1e,
+    0xfa, 0x1e,
+    0xfb, 0x1e,
+    0xfc, 0x1e,
+    0xfd, 0x1e,
+    0xfe, 0x1e,
+    0xff, 0x1e,
+    0x08, 0x1f,
+    0x09, 0x1f,
+    0x0a, 0x1f,
+    0x0b, 0x1f,
+    0x0c, 0x1f,
+    0x0d, 0x1f,
+    0x0e, 0x1f,
+    0x0f, 0x1f,
+    0x08, 0x1f,
+    0x09, 0x1f,
+    0x0a, 0x1f,
+    0x0b, 0x1f,
+    0x0c, 0x1f,
+    0x0d, 0x1f,
+    0x0e, 0x1f,
+    0x0f, 0x1f,
+    0x18, 0x1f,
+    0x19, 0x1f,
+    0x1a, 0x1f,
+    0x1b, 0x1f,
+    0x1c, 0x1f,
+    0x1d, 0x1f,
+    0x16, 0x1f,
+    0x17, 0x1f,
+    0x18, 0x1f,
+    0x19, 0x1f,
+    0x1a, 0x1f,
+    0x1b, 0x1f,
+    0x1c, 0x1f,
+    0x1d, 0x1f,
+    0x1e, 0x1f,
+    0x1f, 0x1f,
+    0x28, 0x1f,
+    0x29, 0x1f,
+    0x2a, 0x1f,
+    0x2b, 0x1f,
+    0x2c, 0x1f,
+    0x2d, 0x1f,
+    0x2e, 0x1f,
+    0x2f, 0x1f,
+    0x28, 0x1f,
+    0x29, 0x1f,
+    0x2a, 0x1f,
+    0x2b, 0x1f,
+    0x2c, 0x1f,
+    0x2d, 0x1f,
+    0x2e, 0x1f,
+    0x2f, 0x1f,
+    0x38, 0x1f,
+    0x39, 0x1f,
+    0x3a, 0x1f,
+    0x3b, 0x1f,
+    0x3c, 0x1f,
+    0x3d, 0x1f,
+    0x3e, 0x1f,
+    0x3f, 0x1f,
+    0x38, 0x1f,
+    0x39, 0x1f,
+    0x3a, 0x1f,
+    0x3b, 0x1f,
+    0x3c, 0x1f,
+    0x3d, 0x1f,
+    0x3e, 0x1f,
+    0x3f, 0x1f,
+    0x48, 0x1f,
+    0x49, 0x1f,
+    0x4a, 0x1f,
+    0x4b, 0x1f,
+    0x4c, 0x1f,
+    0x4d, 0x1f,
+    0x46, 0x1f,
+    0x47, 0x1f,
+    0x48, 0x1f,
+    0x49, 0x1f,
+    0x4a, 0x1f,
+    0x4b, 0x1f,
+    0x4c, 0x1f,
+    0x4d, 0x1f,
+    0x4e, 0x1f,
+    0x4f, 0x1f,
+    0x50, 0x1f,
+    0x59, 0x1f,
+    0x52, 0x1f,
+    0x5b, 0x1f,
+    0x54, 0x1f,
+    0x5d, 0x1f,
+    0x56, 0x1f,
+    0x5f, 0x1f,
+    0x58, 0x1f,
+    0x59, 0x1f,
+    0x5a, 0x1f,
+    0x5b, 0x1f,
+    0x5c, 0x1f,
+    0x5d, 0x1f,
+    0x5e, 0x1f,
+    0x5f, 0x1f,
+    0x68, 0x1f,
+    0x69, 0x1f,
+    0x6a, 0x1f,
+    0x6b, 0x1f,
+    0x6c, 0x1f,
+    0x6d, 0x1f,
+    0x6e, 0x1f,
+    0x6f, 0x1f,
+    0x68, 0x1f,
+    0x69, 0x1f,
+    0x6a, 0x1f,
+    0x6b, 0x1f,
+    0x6c, 0x1f,
+    0x6d, 0x1f,
+    0x6e, 0x1f,
+    0x6f, 0x1f,
+    0xba, 0x1f,
+    0xbb, 0x1f,
+    0xc8, 0x1f,
+    0xc9, 0x1f,
+    0xca, 0x1f,
+    0xcb, 0x1f,
+    0xda, 0x1f,
+    0xdb, 0x1f,
+    0xf8, 0x1f,
+    0xf9, 0x1f,
+    0xea, 0x1f,
+    0xeb, 0x1f,
+    0xfa, 0x1f,
+    0xfb, 0x1f,
+    0x7e, 0x1f,
+    0x7f, 0x1f,
+    0x88, 0x1f,
+    0x89, 0x1f,
+    0x8a, 0x1f,
+    0x8b, 0x1f,
+    0x8c, 0x1f,
+    0x8d, 0x1f,
+    0x8e, 0x1f,
+    0x8f, 0x1f,
+    0x88, 0x1f,
+    0x89, 0x1f,
+    0x8a, 0x1f,
+    0x8b, 0x1f,
+    0x8c, 0x1f,
+    0x8d, 0x1f,
+    0x8e, 0x1f,
+    0x8f, 0x1f,
+    0x98, 0x1f,
+    0x99, 0x1f,
+    0x9a, 0x1f,
+    0x9b, 0x1f,
+    0x9c, 0x1f,
+    0x9d, 0x1f,
+    0x9e, 0x1f,
+    0x9f, 0x1f,
+    0x98, 0x1f,
+    0x99, 0x1f,
+    0x9a, 0x1f,
+    0x9b, 0x1f,
+    0x9c, 0x1f,
+    0x9d, 0x1f,
+    0x9e, 0x1f,
+    0x9f, 0x1f,
+    0xa8, 0x1f,
+    0xa9, 0x1f,
+    0xaa, 0x1f,
+    0xab, 0x1f,
+    0xac, 0x1f,
+    0xad, 0x1f,
+    0xae, 0x1f,
+    0xaf, 0x1f,
+    0xa8, 0x1f,
+    0xa9, 0x1f,
+    0xaa, 0x1f,
+    0xab, 0x1f,
+    0xac, 0x1f,
+    0xad, 0x1f,
+    0xae, 0x1f,
+    0xaf, 0x1f,
+    0xb8, 0x1f,
+    0xb9, 0x1f,
+    0xb2, 0x1f,
+    0xbc, 0x1f,
+    0xb4, 0x1f,
+    0xb5, 0x1f,
+    0xb6, 0x1f,
+    0xb7, 0x1f,
+    0xb8, 0x1f,
+    0xb9, 0x1f,
+    0xba, 0x1f,
+    0xbb, 0x1f,
+    0xbc, 0x1f,
+    0xbd, 0x1f,
+    0xbe, 0x1f,
+    0xbf, 0x1f,
+    0xc0, 0x1f,
+    0xc1, 0x1f,
+    0xc2, 0x1f,
+    0xc3, 0x1f,
+    0xc4, 0x1f,
+    0xc5, 0x1f,
+    0xc6, 0x1f,
+    0xc7, 0x1f,
+    0xc8, 0x1f,
+    0xc9, 0x1f,
+    0xca, 0x1f,
+    0xcb, 0x1f,
+    0xc3, 0x1f,
+    0xcd, 0x1f,
+    0xce, 0x1f,
+    0xcf, 0x1f,
+    0xd8, 0x1f,
+    0xd9, 0x1f,
+    0xd2, 0x1f,
+    0xd3, 0x1f,
+    0xd4, 0x1f,
+    0xd5, 0x1f,
+    0xd6, 0x1f,
+    0xd7, 0x1f,
+    0xd8, 0x1f,
+    0xd9, 0x1f,
+    0xda, 0x1f,
+    0xdb, 0x1f,
+    0xdc, 0x1f,
+    0xdd, 0x1f,
+    0xde, 0x1f,
+    0xdf, 0x1f,
+    0xe8, 0x1f,
+    0xe9, 0x1f,
+    0xe2, 0x1f,
+    0xe3, 0x1f,
+    0xe4, 0x1f,
+    0xec, 0x1f,
+    0xe6, 0x1f,
+    0xe7, 0x1f,
+    0xe8, 0x1f,
+    0xe9, 0x1f,
+    0xea, 0x1f,
+    0xeb, 0x1f,
+    0xec, 0x1f,
+    0xed, 0x1f,
+    0xee, 0x1f,
+    0xef, 0x1f,
+    0xf0, 0x1f,
+    0xf1, 0x1f,
+    0xf2, 0x1f,
+    0xf3, 0x1f,
+    0xf4, 0x1f,
+    0xf5, 0x1f,
+    0xf6, 0x1f,
+    0xf7, 0x1f,
+    0xf8, 0x1f,
+    0xf9, 0x1f,
+    0xfa, 0x1f,
+    0xfb, 0x1f,
+    0xf3, 0x1f,
+    0xfd, 0x1f,
+    0xfe, 0x1f,
+    0xff, 0x1f,
+    0x00, 0x20,
+    0x01, 0x20,
+    0x02, 0x20,
+    0x03, 0x20,
+    0x04, 0x20,
+    0x05, 0x20,
+    0x06, 0x20,
+    0x07, 0x20,
+    0x08, 0x20,
+    0x09, 0x20,
+    0x0a, 0x20,
+    0x0b, 0x20,
+    0x0c, 0x20,
+    0x0d, 0x20,
+    0x0e, 0x20,
+    0x0f, 0x20,
+    0x10, 0x20,
+    0x11, 0x20,
+    0x12, 0x20,
+    0x13, 0x20,
+    0x14, 0x20,
+    0x15, 0x20,
+    0x16, 0x20,
+    0x17, 0x20,
+    0x18, 0x20,
+    0x19, 0x20,
+    0x1a, 0x20,
+    0x1b, 0x20,
+    0x1c, 0x20,
+    0x1d, 0x20,
+    0x1e, 0x20,
+    0x1f, 0x20,
+    0x20, 0x20,
+    0x21, 0x20,
+    0x22, 0x20,
+    0x23, 0x20,
+    0x24, 0x20,
+    0x25, 0x20,
+    0x26, 0x20,
+    0x27, 0x20,
+    0x28, 0x20,
+    0x29, 0x20,
+    0x2a, 0x20,
+    0x2b, 0x20,
+    0x2c, 0x20,
+    0x2d, 0x20,
+    0x2e, 0x20,
+    0x2f, 0x20,
+    0x30, 0x20,
+    0x31, 0x20,
+    0x32, 0x20,
+    0x33, 0x20,
+    0x34, 0x20,
+    0x35, 0x20,
+    0x36, 0x20,
+    0x37, 0x20,
+    0x38, 0x20,
+    0x39, 0x20,
+    0x3a, 0x20,
+    0x3b, 0x20,
+    0x3c, 0x20,
+    0x3d, 0x20,
+    0x3e, 0x20,
+    0x3f, 0x20,
+    0x40, 0x20,
+    0x41, 0x20,
+    0x42, 0x20,
+    0x43, 0x20,
+    0x44, 0x20,
+    0x45, 0x20,
+    0x46, 0x20,
+    0x47, 0x20,
+    0x48, 0x20,
+    0x49, 0x20,
+    0x4a, 0x20,
+    0x4b, 0x20,
+    0x4c, 0x20,
+    0x4d, 0x20,
+    0x4e, 0x20,
+    0x4f, 0x20,
+    0x50, 0x20,
+    0x51, 0x20,
+    0x52, 0x20,
+    0x53, 0x20,
+    0x54, 0x20,
+    0x55, 0x20,
+    0x56, 0x20,
+    0x57, 0x20,
+    0x58, 0x20,
+    0x59, 0x20,
+    0x5a, 0x20,
+    0x5b, 0x20,
+    0x5c, 0x20,
+    0x5d, 0x20,
+    0x5e, 0x20,
+    0x5f, 0x20,
+    0x60, 0x20,
+    0x61, 0x20,
+    0x62, 0x20,
+    0x63, 0x20,
+    0x64, 0x20,
+    0x65, 0x20,
+    0x66, 0x20,
+    0x67, 0x20,
+    0x68, 0x20,
+    0x69, 0x20,
+    0x6a, 0x20,
+    0x6b, 0x20,
+    0x6c, 0x20,
+    0x6d, 0x20,
+    0x6e, 0x20,
+    0x6f, 0x20,
+    0x70, 0x20,
+    0x71, 0x20,
+    0x72, 0x20,
+    0x73, 0x20,
+    0x74, 0x20,
+    0x75, 0x20,
+    0x76, 0x20,
+    0x77, 0x20,
+    0x78, 0x20,
+    0x79, 0x20,
+    0x7a, 0x20,
+    0x7b, 0x20,
+    0x7c, 0x20,
+    0x7d, 0x20,
+    0x7e, 0x20,
+    0x7f, 0x20,
+    0x80, 0x20,
+    0x81, 0x20,
+    0x82, 0x20,
+    0x83, 0x20,
+    0x84, 0x20,
+    0x85, 0x20,
+    0x86, 0x20,
+    0x87, 0x20,
+    0x88, 0x20,
+    0x89, 0x20,
+    0x8a, 0x20,
+    0x8b, 0x20,
+    0x8c, 0x20,
+    0x8d, 0x20,
+    0x8e, 0x20,
+    0x8f, 0x20,
+    0x90, 0x20,
+    0x91, 0x20,
+    0x92, 0x20,
+    0x93, 0x20,
+    0x94, 0x20,
+    0x95, 0x20,
+    0x96, 0x20,
+    0x97, 0x20,
+    0x98, 0x20,
+    0x99, 0x20,
+    0x9a, 0x20,
+    0x9b, 0x20,
+    0x9c, 0x20,
+    0x9d, 0x20,
+    0x9e, 0x20,
+    0x9f, 0x20,
+    0xa0, 0x20,
+    0xa1, 0x20,
+    0xa2, 0x20,
+    0xa3, 0x20,
+    0xa4, 0x20,
+    0xa5, 0x20,
+    0xa6, 0x20,
+    0xa7, 0x20,
+    0xa8, 0x20,
+    0xa9, 0x20,
+    0xaa, 0x20,
+    0xab, 0x20,
+    0xac, 0x20,
+    0xad, 0x20,
+    0xae, 0x20,
+    0xaf, 0x20,
+    0xb0, 0x20,
+    0xb1, 0x20,
+    0xb2, 0x20,
+    0xb3, 0x20,
+    0xb4, 0x20,
+    0xb5, 0x20,
+    0xb6, 0x20,
+    0xb7, 0x20,
+    0xb8, 0x20,
+    0xb9, 0x20,
+    0xba, 0x20,
+    0xbb, 0x20,
+    0xbc, 0x20,
+    0xbd, 0x20,
+    0xbe, 0x20,
+    0xbf, 0x20,
+    0xc0, 0x20,
+    0xc1, 0x20,
+    0xc2, 0x20,
+    0xc3, 0x20,
+    0xc4, 0x20,
+    0xc5, 0x20,
+    0xc6, 0x20,
+    0xc7, 0x20,
+    0xc8, 0x20,
+    0xc9, 0x20,
+    0xca, 0x20,
+    0xcb, 0x20,
+    0xcc, 0x20,
+    0xcd, 0x20,
+    0xce, 0x20,
+    0xcf, 0x20,
+    0xd0, 0x20,
+    0xd1, 0x20,
+    0xd2, 0x20,
+    0xd3, 0x20,
+    0xd4, 0x20,
+    0xd5, 0x20,
+    0xd6, 0x20,
+    0xd7, 0x20,
+    0xd8, 0x20,
+    0xd9, 0x20,
+    0xda, 0x20,
+    0xdb, 0x20,
+    0xdc, 0x20,
+    0xdd, 0x20,
+    0xde, 0x20,
+    0xdf, 0x20,
+    0xe0, 0x20,
+    0xe1, 0x20,
+    0xe2, 0x20,
+    0xe3, 0x20,
+    0xe4, 0x20,
+    0xe5, 0x20,
+    0xe6, 0x20,
+    0xe7, 0x20,
+    0xe8, 0x20,
+    0xe9, 0x20,
+    0xea, 0x20,
+    0xeb, 0x20,
+    0xec, 0x20,
+    0xed, 0x20,
+    0xee, 0x20,
+    0xef, 0x20,
+    0xf0, 0x20,
+    0xf1, 0x20,
+    0xf2, 0x20,
+    0xf3, 0x20,
+    0xf4, 0x20,
+    0xf5, 0x20,
+    0xf6, 0x20,
+    0xf7, 0x20,
+    0xf8, 0x20,
+    0xf9, 0x20,
+    0xfa, 0x20,
+    0xfb, 0x20,
+    0xfc, 0x20,
+    0xfd, 0x20,
+    0xfe, 0x20,
+    0xff, 0x20,
+    0x00, 0x21,
+    0x01, 0x21,
+    0x02, 0x21,
+    0x03, 0x21,
+    0x04, 0x21,
+    0x05, 0x21,
+    0x06, 0x21,
+    0x07, 0x21,
+    0x08, 0x21,
+    0x09, 0x21,
+    0x0a, 0x21,
+    0x0b, 0x21,
+    0x0c, 0x21,
+    0x0d, 0x21,
+    0x0e, 0x21,
+    0x0f, 0x21,
+    0x10, 0x21,
+    0x11, 0x21,
+    0x12, 0x21,
+    0x13, 0x21,
+    0x14, 0x21,
+    0x15, 0x21,
+    0x16, 0x21,
+    0x17, 0x21,
+    0x18, 0x21,
+    0x19, 0x21,
+    0x1a, 0x21,
+    0x1b, 0x21,
+    0x1c, 0x21,
+    0x1d, 0x21,
+    0x1e, 0x21,
+    0x1f, 0x21,
+    0x20, 0x21,
+    0x21, 0x21,
+    0x22, 0x21,
+    0x23, 0x21,
+    0x24, 0x21,
+    0x25, 0x21,
+    0x26, 0x21,
+    0x27, 0x21,
+    0x28, 0x21,
+    0x29, 0x21,
+    0x2a, 0x21,
+    0x2b, 0x21,
+    0x2c, 0x21,
+    0x2d, 0x21,
+    0x2e, 0x21,
+    0x2f, 0x21,
+    0x30, 0x21,
+    0x31, 0x21,
+    0x32, 0x21,
+    0x33, 0x21,
+    0x34, 0x21,
+    0x35, 0x21,
+    0x36, 0x21,
+    0x37, 0x21,
+    0x38, 0x21,
+    0x39, 0x21,
+    0x3a, 0x21,
+    0x3b, 0x21,
+    0x3c, 0x21,
+    0x3d, 0x21,
+    0x3e, 0x21,
+    0x3f, 0x21,
+    0x40, 0x21,
+    0x41, 0x21,
+    0x42, 0x21,
+    0x43, 0x21,
+    0x44, 0x21,
+    0x45, 0x21,
+    0x46, 0x21,
+    0x47, 0x21,
+    0x48, 0x21,
+    0x49, 0x21,
+    0x4a, 0x21,
+    0x4b, 0x21,
+    0x4c, 0x21,
+    0x4d, 0x21,
+    0x32, 0x21,
+    0x4f, 0x21,
+    0x50, 0x21,
+    0x51, 0x21,
+    0x52, 0x21,
+    0x53, 0x21,
+    0x54, 0x21,
+    0x55, 0x21,
+    0x56, 0x21,
+    0x57, 0x21,
+    0x58, 0x21,
+    0x59, 0x21,
+    0x5a, 0x21,
+    0x5b, 0x21,
+    0x5c, 0x21,
+    0x5d, 0x21,
+    0x5e, 0x21,
+    0x5f, 0x21,
+    0x60, 0x21,
+    0x61, 0x21,
+    0x62, 0x21,
+    0x63, 0x21,
+    0x64, 0x21,
+    0x65, 0x21,
+    0x66, 0x21,
+    0x67, 0x21,
+    0x68, 0x21,
+    0x69, 0x21,
+    0x6a, 0x21,
+    0x6b, 0x21,
+    0x6c, 0x21,
+    0x6d, 0x21,
+    0x6e, 0x21,
+    0x6f, 0x21,
+    0x60, 0x21,
+    0x61, 0x21,
+    0x62, 0x21,
+    0x63, 0x21,
+    0x64, 0x21,
+    0x65, 0x21,
+    0x66, 0x21,
+    0x67, 0x21,
+    0x68, 0x21,
+    0x69, 0x21,
+    0x6a, 0x21,
+    0x6b, 0x21,
+    0x6c, 0x21,
+    0x6d, 0x21,
+    0x6e, 0x21,
+    0x6f, 0x21,
+    0x80, 0x21,
+    0x81, 0x21,
+    0x82, 0x21,
+    0x83, 0x21,
+    0x83, 0x21,
+    0xff, 0xff,
+    0x4b, 0x03,
+    0xb6, 0x24,
+    0xb7, 0x24,
+    0xb8, 0x24,
+    0xb9, 0x24,
+    0xba, 0x24,
+    0xbb, 0x24,
+    0xbc, 0x24,
+    0xbd, 0x24,
+    0xbe, 0x24,
+    0xbf, 0x24,
+    0xc0, 0x24,
+    0xc1, 0x24,
+    0xc2, 0x24,
+    0xc3, 0x24,
+    0xc4, 0x24,
+    0xc5, 0x24,
+    0xc6, 0x24,
+    0xc7, 0x24,
+    0xc8, 0x24,
+    0xc9, 0x24,
+    0xca, 0x24,
+    0xcb, 0x24,
+    0xcc, 0x24,
+    0xcd, 0x24,
+    0xce, 0x24,
+    0xcf, 0x24,
+    0xff, 0xff,
+    0x46, 0x07,
+    0x00, 0x2c,
+    0x01, 0x2c,
+    0x02, 0x2c,
+    0x03, 0x2c,
+    0x04, 0x2c,
+    0x05, 0x2c,
+    0x06, 0x2c,
+    0x07, 0x2c,
+    0x08, 0x2c,
+    0x09, 0x2c,
+    0x0a, 0x2c,
+    0x0b, 0x2c,
+    0x0c, 0x2c,
+    0x0d, 0x2c,
+    0x0e, 0x2c,
+    0x0f, 0x2c,
+    0x10, 0x2c,
+    0x11, 0x2c,
+    0x12, 0x2c,
+    0x13, 0x2c,
+    0x14, 0x2c,
+    0x15, 0x2c,
+    0x16, 0x2c,
+    0x17, 0x2c,
+    0x18, 0x2c,
+    0x19, 0x2c,
+    0x1a, 0x2c,
+    0x1b, 0x2c,
+    0x1c, 0x2c,
+    0x1d, 0x2c,
+    0x1e, 0x2c,
+    0x1f, 0x2c,
+    0x20, 0x2c,
+    0x21, 0x2c,
+    0x22, 0x2c,
+    0x23, 0x2c,
+    0x24, 0x2c,
+    0x25, 0x2c,
+    0x26, 0x2c,
+    0x27, 0x2c,
+    0x28, 0x2c,
+    0x29, 0x2c,
+    0x2a, 0x2c,
+    0x2b, 0x2c,
+    0x2c, 0x2c,
+    0x2d, 0x2c,
+    0x2e, 0x2c,
+    0x5f, 0x2c,
+    0x60, 0x2c,
+    0x60, 0x2c,
+    0x62, 0x2c,
+    0x63, 0x2c,
+    0x64, 0x2c,
+    0x65, 0x2c,
+    0x66, 0x2c,
+    0x67, 0x2c,
+    0x67, 0x2c,
+    0x69, 0x2c,
+    0x69, 0x2c,
+    0x6b, 0x2c,
+    0x6b, 0x2c,
+    0x6d, 0x2c,
+    0x6e, 0x2c,
+    0x6f, 0x2c,
+    0x70, 0x2c,
+    0x71, 0x2c,
+    0x72, 0x2c,
+    0x73, 0x2c,
+    0x74, 0x2c,
+    0x75, 0x2c,
+    0x75, 0x2c,
+    0x77, 0x2c,
+    0x78, 0x2c,
+    0x79, 0x2c,
+    0x7a, 0x2c,
+    0x7b, 0x2c,
+    0x7c, 0x2c,
+    0x7d, 0x2c,
+    0x7e, 0x2c,
+    0x7f, 0x2c,
+    0x80, 0x2c,
+    0x80, 0x2c,
+    0x82, 0x2c,
+    0x82, 0x2c,
+    0x84, 0x2c,
+    0x84, 0x2c,
+    0x86, 0x2c,
+    0x86, 0x2c,
+    0x88, 0x2c,
+    0x88, 0x2c,
+    0x8a, 0x2c,
+    0x8a, 0x2c,
+    0x8c, 0x2c,
+    0x8c, 0x2c,
+    0x8e, 0x2c,
+    0x8e, 0x2c,
+    0x90, 0x2c,
+    0x90, 0x2c,
+    0x92, 0x2c,
+    0x92, 0x2c,
+    0x94, 0x2c,
+    0x94, 0x2c,
+    0x96, 0x2c,
+    0x96, 0x2c,
+    0x98, 0x2c,
+    0x98, 0x2c,
+    0x9a, 0x2c,
+    0x9a, 0x2c,
+    0x9c, 0x2c,
+    0x9c, 0x2c,
+    0x9e, 0x2c,
+    0x9e, 0x2c,
+    0xa0, 0x2c,
+    0xa0, 0x2c,
+    0xa2, 0x2c,
+    0xa2, 0x2c,
+    0xa4, 0x2c,
+    0xa4, 0x2c,
+    0xa6, 0x2c,
+    0xa6, 0x2c,
+    0xa8, 0x2c,
+    0xa8, 0x2c,
+    0xaa, 0x2c,
+    0xaa, 0x2c,
+    0xac, 0x2c,
+    0xac, 0x2c,
+    0xae, 0x2c,
+    0xae, 0x2c,
+    0xb0, 0x2c,
+    0xb0, 0x2c,
+    0xb2, 0x2c,
+    0xb2, 0x2c,
+    0xb4, 0x2c,
+    0xb4, 0x2c,
+    0xb6, 0x2c,
+    0xb6, 0x2c,
+    0xb8, 0x2c,
+    0xb8, 0x2c,
+    0xba, 0x2c,
+    0xba, 0x2c,
+    0xbc, 0x2c,
+    0xbc, 0x2c,
+    0xbe, 0x2c,
+    0xbe, 0x2c,
+    0xc0, 0x2c,
+    0xc0, 0x2c,
+    0xc2, 0x2c,
+    0xc2, 0x2c,
+    0xc4, 0x2c,
+    0xc4, 0x2c,
+    0xc6, 0x2c,
+    0xc6, 0x2c,
+    0xc8, 0x2c,
+    0xc8, 0x2c,
+    0xca, 0x2c,
+    0xca, 0x2c,
+    0xcc, 0x2c,
+    0xcc, 0x2c,
+    0xce, 0x2c,
+    0xce, 0x2c,
+    0xd0, 0x2c,
+    0xd0, 0x2c,
+    0xd2, 0x2c,
+    0xd2, 0x2c,
+    0xd4, 0x2c,
+    0xd4, 0x2c,
+    0xd6, 0x2c,
+    0xd6, 0x2c,
+    0xd8, 0x2c,
+    0xd8, 0x2c,
+    0xda, 0x2c,
+    0xda, 0x2c,
+    0xdc, 0x2c,
+    0xdc, 0x2c,
+    0xde, 0x2c,
+    0xde, 0x2c,
+    0xe0, 0x2c,
+    0xe0, 0x2c,
+    0xe2, 0x2c,
+    0xe2, 0x2c,
+    0xe4, 0x2c,
+    0xe5, 0x2c,
+    0xe6, 0x2c,
+    0xe7, 0x2c,
+    0xe8, 0x2c,
+    0xe9, 0x2c,
+    0xea, 0x2c,
+    0xeb, 0x2c,
+    0xec, 0x2c,
+    0xed, 0x2c,
+    0xee, 0x2c,
+    0xef, 0x2c,
+    0xf0, 0x2c,
+    0xf1, 0x2c,
+    0xf2, 0x2c,
+    0xf3, 0x2c,
+    0xf4, 0x2c,
+    0xf5, 0x2c,
+    0xf6, 0x2c,
+    0xf7, 0x2c,
+    0xf8, 0x2c,
+    0xf9, 0x2c,
+    0xfa, 0x2c,
+    0xfb, 0x2c,
+    0xfc, 0x2c,
+    0xfd, 0x2c,
+    0xfe, 0x2c,
+    0xff, 0x2c,
+    0xa0, 0x10,
+    0xa1, 0x10,
+    0xa2, 0x10,
+    0xa3, 0x10,
+    0xa4, 0x10,
+    0xa5, 0x10,
+    0xa6, 0x10,
+    0xa7, 0x10,
+    0xa8, 0x10,
+    0xa9, 0x10,
+    0xaa, 0x10,
+    0xab, 0x10,
+    0xac, 0x10,
+    0xad, 0x10,
+    0xae, 0x10,
+    0xaf, 0x10,
+    0xb0, 0x10,
+    0xb1, 0x10,
+    0xb2, 0x10,
+    0xb3, 0x10,
+    0xb4, 0x10,
+    0xb5, 0x10,
+    0xb6, 0x10,
+    0xb7, 0x10,
+    0xb8, 0x10,
+    0xb9, 0x10,
+    0xba, 0x10,
+    0xbb, 0x10,
+    0xbc, 0x10,
+    0xbd, 0x10,
+    0xbe, 0x10,
+    0xbf, 0x10,
+    0xc0, 0x10,
+    0xc1, 0x10,
+    0xc2, 0x10,
+    0xc3, 0x10,
+    0xc4, 0x10,
+    0xc5, 0x10,
+    0xff, 0xff,
+    0x1b, 0xd2,
+    0x21, 0xff,
+    0x22, 0xff,
+    0x23, 0xff,
+    0x24, 0xff,
+    0x25, 0xff,
+    0x26, 0xff,
+    0x27, 0xff,
+    0x28, 0xff,
+    0x29, 0xff,
+    0x2a, 0xff,
+    0x2b, 0xff,
+    0x2c, 0xff,
+    0x2d, 0xff,
+    0x2e, 0xff,
+    0x2f, 0xff,
+    0x30, 0xff,
+    0x31, 0xff,
+    0x32, 0xff,
+    0x33, 0xff,
+    0x34, 0xff,
+    0x35, 0xff,
+    0x36, 0xff,
+    0x37, 0xff,
+    0x38, 0xff,
+    0x39, 0xff,
+    0x3a, 0xff,
+    0x5b, 0xff,
+    0x5c, 0xff,
+    0x5d, 0xff,
+    0x5e, 0xff,
+    0x5f, 0xff,
+    0x60, 0xff,
+    0x61, 0xff,
+    0x62, 0xff,
+    0x63, 0xff,
+    0x64, 0xff,
+    0x65, 0xff,
+    0x66, 0xff,
+    0x67, 0xff,
+    0x68, 0xff,
+    0x69, 0xff,
+    0x6a, 0xff,
+    0x6b, 0xff,
+    0x6c, 0xff,
+    0x6d, 0xff,
+    0x6e, 0xff,
+    0x6f, 0xff,
+    0x70, 0xff,
+    0x71, 0xff,
+    0x72, 0xff,
+    0x73, 0xff,
+    0x74, 0xff,
+    0x75, 0xff,
+    0x76, 0xff,
+    0x77, 0xff,
+    0x78, 0xff,
+    0x79, 0xff,
+    0x7a, 0xff,
+    0x7b, 0xff,
+    0x7c, 0xff,
+    0x7d, 0xff,
+    0x7e, 0xff,
+    0x7f, 0xff,
+    0x80, 0xff,
+    0x81, 0xff,
+    0x82, 0xff,
+    0x83, 0xff,
+    0x84, 0xff,
+    0x85, 0xff,
+    0x86, 0xff,
+    0x87, 0xff,
+    0x88, 0xff,
+    0x89, 0xff,
+    0x8a, 0xff,
+    0x8b, 0xff,
+    0x8c, 0xff,
+    0x8d, 0xff,
+    0x8e, 0xff,
+    0x8f, 0xff,
+    0x90, 0xff,
+    0x91, 0xff,
+    0x92, 0xff,
+    0x93, 0xff,
+    0x94, 0xff,
+    0x95, 0xff,
+    0x96, 0xff,
+    0x97, 0xff,
+    0x98, 0xff,
+    0x99, 0xff,
+    0x9a, 0xff,
+    0x9b, 0xff,
+    0x9c, 0xff,
+    0x9d, 0xff,
+    0x9e, 0xff,
+    0x9f, 0xff,
+    0xa0, 0xff,
+    0xa1, 0xff,
+    0xa2, 0xff,
+    0xa3, 0xff,
+    0xa4, 0xff,
+    0xa5, 0xff,
+    0xa6, 0xff,
+    0xa7, 0xff,
+    0xa8, 0xff,
+    0xa9, 0xff,
+    0xaa, 0xff,
+    0xab, 0xff,
+    0xac, 0xff,
+    0xad, 0xff,
+    0xae, 0xff,
+    0xaf, 0xff,
+    0xb0, 0xff,
+    0xb1, 0xff,
+    0xb2, 0xff,
+    0xb3, 0xff,
+    0xb4, 0xff,
+    0xb5, 0xff,
+    0xb6, 0xff,
+    0xb7, 0xff,
+    0xb8, 0xff,
+    0xb9, 0xff,
+    0xba, 0xff,
+    0xbb, 0xff,
+    0xbc, 0xff,
+    0xbd, 0xff,
+    0xbe, 0xff,
+    0xbf, 0xff,
+    0xc0, 0xff,
+    0xc1, 0xff,
+    0xc2, 0xff,
+    0xc3, 0xff,
+    0xc4, 0xff,
+    0xc5, 0xff,
+    0xc6, 0xff,
+    0xc7, 0xff,
+    0xc8, 0xff,
+    0xc9, 0xff,
+    0xca, 0xff,
+    0xcb, 0xff,
+    0xcc, 0xff,
+    0xcd, 0xff,
+    0xce, 0xff,
+    0xcf, 0xff,
+    0xd0, 0xff,
+    0xd1, 0xff,
+    0xd2, 0xff,
+    0xd3, 0xff,
+    0xd4, 0xff,
+    0xd5, 0xff,
+    0xd6, 0xff,
+    0xd7, 0xff,
+    0xd8, 0xff,
+    0xd9, 0xff,
+    0xda, 0xff,
+    0xdb, 0xff,
+    0xdc, 0xff,
+    0xdd, 0xff,
+    0xde, 0xff,
+    0xdf, 0xff,
+    0xe0, 0xff,
+    0xe1, 0xff,
+    0xe2, 0xff,
+    0xe3, 0xff,
+    0xe4, 0xff,
+    0xe5, 0xff,
+    0xe6, 0xff,
+    0xe7, 0xff,
+    0xe8, 0xff,
+    0xe9, 0xff,
+    0xea, 0xff,
+    0xeb, 0xff,
+    0xec, 0xff,
+    0xed, 0xff,
+    0xee, 0xff,
+    0xef, 0xff,
+    0xf0, 0xff,
+    0xf1, 0xff,
+    0xf2, 0xff,
+    0xf3, 0xff,
+    0xf4, 0xff,
+    0xf5, 0xff,
+    0xf6, 0xff,
+    0xf7, 0xff,
+    0xf8, 0xff,
+    0xf9, 0xff,
+    0xfa, 0xff,
+    0xfb, 0xff,
+    0xfc, 0xff,
+    0xfd, 0xff,
+    0xfe, 0xff,
+    0xff, 0xff
+};
+
+#endif
+
Index: uspace/srv/fs/exfat/exfat_bitmap.c
===================================================================
--- uspace/srv/fs/exfat/exfat_bitmap.c	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ uspace/srv/fs/exfat/exfat_bitmap.c	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -48,5 +48,5 @@
 
 
-int bitmap_is_free(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_is_free(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t clst)
 {
@@ -89,5 +89,5 @@
 }
 
-int bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t clst)
 {
@@ -124,5 +124,5 @@
 }
 
-int bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t clst)
 {
@@ -160,5 +160,5 @@
 }
 
-int bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t firstc, exfat_cluster_t count)
 {
@@ -168,8 +168,8 @@
 
 	while (clst < firstc + count ) {
-		rc = bitmap_set_cluster(bs, service_id, clst);
+		rc = exfat_bitmap_set_cluster(bs, service_id, clst);
 		if (rc != EOK) {
 			if (clst - firstc > 0)
-				(void) bitmap_clear_clusters(bs, service_id,
+				(void) exfat_bitmap_clear_clusters(bs, service_id,
 				    firstc, clst - firstc);
 			return rc;
@@ -180,5 +180,5 @@
 }
 
-int bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t firstc, exfat_cluster_t count)
 {
@@ -188,5 +188,5 @@
 
 	while (clst < firstc + count) {
-		rc = bitmap_clear_cluster(bs, service_id, clst);
+		rc = exfat_bitmap_clear_cluster(bs, service_id, clst);
 		if (rc != EOK)
 			return rc;
@@ -196,5 +196,5 @@
 }
 
-int bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t *firstc, exfat_cluster_t count)
 {
@@ -204,8 +204,8 @@
 	while (startc < DATA_CNT(bs) + 2) {
 		endc = startc;
-		while (bitmap_is_free(bs, service_id, endc) == EOK) {
+		while (exfat_bitmap_is_free(bs, service_id, endc) == EOK) {
 			if ((endc - startc) + 1 == count) {
 				*firstc = startc;
-				return bitmap_set_clusters(bs, service_id, startc, count);
+				return exfat_bitmap_set_clusters(bs, service_id, startc, count);
 			} else
 				endc++;
@@ -217,9 +217,9 @@
 
 
-int bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
+int exfat_bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
     exfat_cluster_t count)
 {
 	if (nodep->firstc == 0) {
-		return bitmap_alloc_clusters(bs, nodep->idx->service_id, 
+		return exfat_bitmap_alloc_clusters(bs, nodep->idx->service_id, 
 		    &nodep->firstc, count);
 	} else {
@@ -228,7 +228,7 @@
 
 		clst = lastc + 1;
-		while (bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
+		while (exfat_bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
 			if (clst - lastc == count){
-				return bitmap_set_clusters(bs, nodep->idx->service_id, 
+				return exfat_bitmap_set_clusters(bs, nodep->idx->service_id, 
 				    lastc + 1, count);
 			} else
@@ -240,5 +240,5 @@
 
 
-int bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
+int exfat_bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
     exfat_cluster_t count)
 {
@@ -247,9 +247,9 @@
 	lastc -= count;
 
-	return bitmap_clear_clusters(bs, nodep->idx->service_id, lastc + 1, count);
-}
-
-
-int bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
+	return exfat_bitmap_clear_clusters(bs, nodep->idx->service_id, lastc + 1, count);
+}
+
+
+int exfat_bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
 {
 	int rc;
Index: uspace/srv/fs/exfat/exfat_bitmap.h
===================================================================
--- uspace/srv/fs/exfat/exfat_bitmap.h	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ uspace/srv/fs/exfat/exfat_bitmap.h	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -42,20 +42,20 @@
 struct exfat_bs;
 
-extern int bitmap_alloc_clusters(struct exfat_bs *, service_id_t, 
+extern int exfat_bitmap_alloc_clusters(struct exfat_bs *, service_id_t, 
     exfat_cluster_t *, exfat_cluster_t);
-extern int bitmap_append_clusters(struct exfat_bs *, struct exfat_node *, 
+extern int exfat_bitmap_append_clusters(struct exfat_bs *, struct exfat_node *, 
     exfat_cluster_t);
-extern int bitmap_free_clusters(struct exfat_bs *, struct exfat_node *, 
+extern int exfat_bitmap_free_clusters(struct exfat_bs *, struct exfat_node *, 
     exfat_cluster_t);
-extern int bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *); 
+extern int exfat_bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *); 
 
-extern int bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
-extern int bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
-extern int bitmap_clear_cluster(struct exfat_bs *, service_id_t, 
+extern int exfat_bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
+extern int exfat_bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
+extern int exfat_bitmap_clear_cluster(struct exfat_bs *, service_id_t, 
     exfat_cluster_t);
 
-extern int bitmap_set_clusters(struct exfat_bs *, service_id_t, 
+extern int exfat_bitmap_set_clusters(struct exfat_bs *, service_id_t, 
     exfat_cluster_t, exfat_cluster_t);
-extern int bitmap_clear_clusters(struct exfat_bs *, service_id_t, 
+extern int exfat_bitmap_clear_clusters(struct exfat_bs *, service_id_t, 
     exfat_cluster_t, exfat_cluster_t);
 
Index: uspace/srv/fs/exfat/exfat_dentry.c
===================================================================
--- uspace/srv/fs/exfat/exfat_dentry.c	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ uspace/srv/fs/exfat/exfat_dentry.c	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -130,5 +130,5 @@
 }
 
-size_t utf16_length(const uint16_t *wstr)
+size_t exfat_utf16_length(const uint16_t *wstr)
 {
 	size_t len = 0;
Index: uspace/srv/fs/exfat/exfat_dentry.h
===================================================================
--- uspace/srv/fs/exfat/exfat_dentry.h	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ uspace/srv/fs/exfat/exfat_dentry.h	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -160,5 +160,5 @@
 extern bool exfat_valid_name(const char *);
 
-extern size_t utf16_length(const uint16_t *);
+extern size_t exfat_utf16_length(const uint16_t *);
 
 
Index: uspace/srv/fs/exfat/exfat_directory.c
===================================================================
--- uspace/srv/fs/exfat/exfat_directory.c	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ uspace/srv/fs/exfat/exfat_directory.c	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -371,5 +371,5 @@
 	ds.stream.valid_data_size = 0;
 	ds.stream.data_size = 0;
-	ds.stream.name_size = utf16_length(wname);
+	ds.stream.name_size = exfat_utf16_length(wname);
 	ds.stream.hash = host2uint16_t_le(exfat_name_hash(wname, uctable, 
 	    uctable_chars));
Index: uspace/srv/fs/exfat/exfat_fat.c
===================================================================
--- uspace/srv/fs/exfat/exfat_fat.c	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ uspace/srv/fs/exfat/exfat_fat.c	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -314,5 +314,5 @@
 	    clst++) {
 		/* Need to rewrite because of multiple exfat_bitmap_get calls */
-		if (bitmap_is_free(bs, service_id, clst) == EOK) {
+		if (exfat_bitmap_is_free(bs, service_id, clst) == EOK) {
 			/*
 			 * The cluster is free. Put it into our stack
@@ -325,5 +325,5 @@
 				goto exit_error;
 			found++;
-			rc = bitmap_set_cluster(bs, service_id, clst);
+			rc = exfat_bitmap_set_cluster(bs, service_id, clst);
 			if (rc != EOK)
 				goto exit_error;
@@ -346,5 +346,5 @@
 	/* If something wrong - free the clusters */
 	while (found--) {
-		(void) bitmap_clear_cluster(bs, service_id, lifo[found]);
+		(void) exfat_bitmap_clear_cluster(bs, service_id, lifo[found]);
 		(void) exfat_set_cluster(bs, service_id, lifo[found], 0);
 	}
@@ -378,5 +378,5 @@
 		if (rc != EOK)
 			return rc;
-		rc = bitmap_clear_cluster(bs, service_id, firstc);
+		rc = exfat_bitmap_clear_cluster(bs, service_id, firstc);
 		if (rc != EOK)
 			return rc;
Index: uspace/srv/fs/exfat/exfat_ops.c
===================================================================
--- uspace/srv/fs/exfat/exfat_ops.c	(revision b64fbc9fdd4c146668b26c5ab85a174bea2e1e9e)
+++ uspace/srv/fs/exfat/exfat_ops.c	(revision 3df290792b980ae2873195fbf00acafa0d94b3dc)
@@ -405,5 +405,5 @@
 
 	if (!nodep->fragmented) {
-		rc = bitmap_append_clusters(bs, nodep, clusters);
+		rc = exfat_bitmap_append_clusters(bs, nodep, clusters);
 		if (rc != ENOSPC)
 			return rc;
@@ -411,5 +411,5 @@
 			nodep->fragmented = true;
 			nodep->dirty = true;		/* need to sync node */
-			rc = bitmap_replicate_clusters(bs, nodep);
+			rc = exfat_bitmap_replicate_clusters(bs, nodep);
 			if (rc != EOK)
 				return rc;
@@ -457,5 +457,5 @@
 
 		clsts = prev_clsts - new_clsts;
-		rc = bitmap_free_clusters(bs, nodep, clsts);
+		rc = exfat_bitmap_free_clusters(bs, nodep, clsts);
 		if (rc != EOK)
 			return rc;
@@ -704,5 +704,5 @@
 				nodep->firstc);
 		else
-			rc = bitmap_free_clusters(bs, nodep, 
+			rc = exfat_bitmap_free_clusters(bs, nodep, 
 			    ROUND_UP(nodep->size, BPC(bs)) / BPC(bs));
 	} 
@@ -758,9 +758,5 @@
 
 	fibril_mutex_unlock(&parentp->idx->lock);
-	if (rc != EOK)
-		return rc;
-
 	fibril_mutex_lock(&childp->idx->lock);
-
 
 	childp->idx->pfc = parentp->firstc;
@@ -1463,5 +1459,8 @@
 	}
 
-	(void) exfat_node_put(fn);
+	int rc2 = exfat_node_put(fn);
+	if (rc == EOK && rc2 != EOK)
+		rc = rc2;
+
 	return rc;
 }
