Imported Upstream version 0.9.8 upstream/0.9.8
authorSven Hoexter <sven@timegate.de>
Sun, 12 Aug 2012 17:16:47 +0000 (19:16 +0200)
committerSven Hoexter <sven@timegate.de>
Sun, 12 Aug 2012 17:16:47 +0000 (19:16 +0200)
33 files changed:
ChangeLog
SConstruct
dump/main.c
fsck/main.c
label/main.c
libexfat/byteorder.h
libexfat/cluster.c
libexfat/exfat.h
libexfat/exfatfs.h
libexfat/io.c
libexfat/log.c
libexfat/lookup.c
libexfat/mount.c
libexfat/node.c
libexfat/time.c
libexfat/utf.c
libexfat/utils.c
libexfat/version.h
mkfs/cbm.c
mkfs/cbm.h
mkfs/fat.c
mkfs/fat.h
mkfs/main.c
mkfs/mkexfat.c [new file with mode: 0644]
mkfs/mkexfat.h
mkfs/rootdir.c
mkfs/rootdir.h
mkfs/uct.c
mkfs/uct.h
mkfs/uctc.c [new file with mode: 0644]
mkfs/uctc.h
mkfs/vbr.c
mkfs/vbr.h

index d492c39..e42a095 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+0.9.8 (2012-08-09)
+
+* The mkfs utility can now create huge file systems (up to several exabytes).
+* Fixed handling of characters beyond Basic Multilingual Plane.
+* Echo messages to syslog only if stderr is not connected to a terminal.
+
 0.9.7 (2012-03-08)
 
 * Out-of-the-box FreeBSD support (via ublio library).
index 14bd10e..3206c54 100644 (file)
@@ -2,7 +2,7 @@
 #      SConstruct (10.09.09)
 #      SConscript for all components.
 #
-#      Copyright (C) 2009, 2010  Andrew Nayenko
+#      Copyright (C) 2010-2012  Andrew Nayenko
 #
 #      This program is free software: you can redistribute it and/or modify
 #      it under the terms of the GNU General Public License as published by
@@ -36,16 +36,23 @@ if 'CCFLAGS' in os.environ:
 # Set default CCFLAGS for known compilers
 if not conf.env['CCFLAGS']:
        if conf.env['CC'] == 'gcc':
-               conf.env.Replace(CCFLAGS = '-Wall -O2 -ggdb')
+               conf.env.Replace(CCFLAGS = '-Wall -O2 -ggdb -std=c99')
        elif conf.env['CC'] == 'clang':
-               conf.env.Replace(CCFLAGS = '-Wall -O2 -g')
-conf.env.Append(CPPDEFINES = {'FUSE_USE_VERSION': 26})
+               conf.env.Replace(CCFLAGS = '-Wall -O2 -g -std=c99')
+if 'CPPFLAGS' in os.environ:
+       conf.env.Replace(CPPFLAGS = os.environ['CPPFLAGS'])
 conf.env.Append(CPPDEFINES = {'_FILE_OFFSET_BITS' : 64})
 conf.env.Append(CPPPATH = ['libexfat'])
 if 'LDFLAGS' in os.environ:
        conf.env.Append(LINKFLAGS = os.environ['LDFLAGS'])
 conf.env.Append(LIBPATH = ['libexfat'])
 
+# GNU/Linux requires _BSD_SOURCE define for vsyslog(), _XOPEN_SOURCE >= 500 for
+# pread(), pwrite(), snprintf(), strdup(), etc. Everything needed is enabled by
+# _GNU_SOURCE.
+if platform.system() == 'Linux':
+       conf.env.Append(CPPDEFINES = '_GNU_SOURCE');
+
 # __DARWIN_64_BIT_INO_T=0 define is needed because since Snow Leopard inode
 # numbers are 64-bit by default, but libfuse operates 32-bit ones. This define
 # forces 32-bit inode declaration in system headers, but it's also possible to
index cd424d9..1536f81 100644 (file)
@@ -2,7 +2,7 @@
        main.c (08.11.10)
        Prints detailed information about exFAT volume.
 
-       Copyright (C) 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -162,7 +162,7 @@ int main(int argc, char* argv[])
                        used_sectors = 1;
                else if (strcmp(*pp, "-v") == 0)
                {
-                       puts("Copyright (C) 2010  Andrew Nayenko");
+                       puts("Copyright (C) 2011, 2012  Andrew Nayenko");
                        return 0;
                }
                else if (spec == NULL)
index 7ad5b26..26ef2b2 100644 (file)
@@ -2,7 +2,7 @@
        main.c (02.09.09)
        exFAT file system checker.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -133,7 +133,7 @@ int main(int argc, char* argv[])
        {
                if (strcmp(*pp, "-v") == 0)
                {
-                       puts("Copyright (C) 2009  Andrew Nayenko");
+                       puts("Copyright (C) 2011, 2012  Andrew Nayenko");
                        return 0;
                }
                else if (spec == NULL)
index b4ee541..b3a3d30 100644 (file)
@@ -1,8 +1,8 @@
 /*
-       label.c (20.01.11)
+       main.c (20.01.11)
        Prints or changes exFAT volume label.
 
-       Copyright (C) 2011  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -33,7 +33,7 @@ int main(int argc, char* argv[])
                {
                        printf("exfatlabel %u.%u.%u\n", EXFAT_VERSION_MAJOR,
                                        EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH);
-                       puts("Copyright (C) 2011  Andrew Nayenko");
+                       puts("Copyright (C) 2011, 2012  Andrew Nayenko");
                        return 0;
                }
 
index 6b38646..abcf811 100644 (file)
@@ -2,7 +2,7 @@
        byteorder.h (12.01.10)
        Endianness stuff. exFAT uses little-endian byte order.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
index 1257c7a..0418932 100644 (file)
@@ -2,7 +2,7 @@
        cluster.c (03.09.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
index bca0d24..392c95d 100644 (file)
@@ -3,7 +3,7 @@
        Definitions of structures and constants used in exFAT file system
        implementation.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
 #define IS_CONTIGUOUS(node) (((node).flags & EXFAT_ATTRIB_CONTIGUOUS) != 0)
 #define SECTOR_SIZE(sb) (1 << (sb).sector_bits)
 #define CLUSTER_SIZE(sb) (SECTOR_SIZE(sb) << (sb).spc_bits)
-#define CLUSTER_INVALID(c) ((c) == EXFAT_CLUSTER_BAD || (c) == EXFAT_CLUSTER_END)
+#define CLUSTER_INVALID(c) ((c) > EXFAT_LAST_DATA_CLUSTER)
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
 #define DIV_ROUND_UP(x, d) (((x) + (d) - 1) / (d))
+#define ROUND_UP(x, d) (DIV_ROUND_UP(x, d) * (d))
 
 #define BMAP_GET(bitmap, index) \
        (((uint8_t*) bitmap)[(index) / 8] & (1u << ((index) % 8)))
index 61e39a1..5a8e39f 100644 (file)
@@ -2,7 +2,7 @@
        exfatfs.h (29.08.09)
        Definitions of structures and constants used in exFAT file system.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -26,6 +26,7 @@
 typedef uint32_t cluster_t;            /* cluster number */
 
 #define EXFAT_FIRST_DATA_CLUSTER 2
+#define EXFAT_LAST_DATA_CLUSTER 0xfffffff6
 
 #define EXFAT_CLUSTER_FREE         0 /* free cluster */
 #define EXFAT_CLUSTER_BAD 0xfffffff7 /* cluster contains bad sector */
index c9c1e2b..f0beddc 100644 (file)
@@ -2,7 +2,7 @@
        io.c (02.09.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -18,7 +18,6 @@
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#define _XOPEN_SOURCE 500 /* for pread() and pwrite() in Linux */
 #include "exfat.h"
 #include <inttypes.h>
 #include <sys/types.h>
@@ -32,7 +31,7 @@
 #include <ublio.h>
 #endif
 
-#if _FILE_OFFSET_BITS != 64
+#if !defined(_FILE_OFFSET_BITS) || (_FILE_OFFSET_BITS != 64)
        #error You should define _FILE_OFFSET_BITS=64
 #endif
 
index 7a2b35d..8b589b4 100644 (file)
@@ -2,7 +2,7 @@
        log.c (02.09.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -21,6 +21,7 @@
 #include "exfat.h"
 #include <stdarg.h>
 #include <syslog.h>
+#include <unistd.h>
 
 int exfat_errors;
 
@@ -40,7 +41,8 @@ void exfat_bug(const char* format, ...)
        va_end(ap);
        fputs(".\n", stderr);
 
-       vsyslog(LOG_CRIT, format, aq);
+       if (!isatty(STDERR_FILENO))
+               vsyslog(LOG_CRIT, format, aq);
        va_end(aq);
 
        abort();
@@ -63,7 +65,8 @@ void exfat_error(const char* format, ...)
        va_end(ap);
        fputs(".\n", stderr);
 
-       vsyslog(LOG_ERR, format, aq);
+       if (!isatty(STDERR_FILENO))
+               vsyslog(LOG_ERR, format, aq);
        va_end(aq);
 }
 
@@ -84,7 +87,8 @@ void exfat_warn(const char* format, ...)
        va_end(ap);
        fputs(".\n", stderr);
 
-       vsyslog(LOG_WARNING, format, aq);
+       if (!isatty(STDERR_FILENO))
+               vsyslog(LOG_WARNING, format, aq);
        va_end(aq);
 }
 
index 619dcea..d650976 100644 (file)
@@ -2,7 +2,7 @@
        lookup.c (02.09.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
index 521b539..a62466b 100644 (file)
@@ -2,7 +2,7 @@
        mount.c (22.10.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
index 2ae724d..4cbb3e2 100644 (file)
@@ -2,7 +2,7 @@
        node.c (09.10.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
index 2e22a99..890930e 100644 (file)
@@ -2,7 +2,7 @@
        time.c (03.02.12)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
index 3f0dc19..983c793 100644 (file)
@@ -2,7 +2,7 @@
        utf.c (13.09.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -89,6 +89,7 @@ static const le16_t* utf16_to_wchar(const le16_t* input, wchar_t* wc,
                        return NULL;
                *wc = ((wchar_t) (le16_to_cpu(input[0]) & 0x3ff) << 10);
                *wc |= (le16_to_cpu(input[1]) & 0x3ff);
+               *wc += 0x10000;
                return input + 2;
        }
        else
@@ -186,6 +187,7 @@ static le16_t* wchar_to_utf16(le16_t* output, wchar_t wc, size_t outsize)
        }
        if (outsize < 2)
                return NULL;
+       wc -= 0x10000;
        output[0] = cpu_to_le16(0xd800 | ((wc >> 10) & 0x3ff));
        output[1] = cpu_to_le16(0xdc00 | (wc & 0x3ff));
        return output + 2;
index c165cf9..7c47f4d 100644 (file)
@@ -2,7 +2,7 @@
        utils.c (04.09.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -133,11 +133,13 @@ le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name)
 void exfat_humanize_bytes(uint64_t value, struct exfat_human_bytes* hb)
 {
        size_t i;
-       const char* units[] = {"bytes", "KB", "MB", "GB", "TB", "PB"};
+       /* 16 EB (minus 1 byte) is the largest size that can be represented by
+          uint64_t */
+       const char* units[] = {"bytes", "KB", "MB", "GB", "TB", "PB", "EB"};
        uint64_t divisor = 1;
        uint64_t temp = 0;
 
-       for (i = 0; i < sizeof(units) / sizeof(units[0]) - 1; i++, divisor *= 1024)
+       for (i = 0; ; i++, divisor *= 1024)
        {
                temp = (value + divisor / 2) / divisor;
 
index aa636f8..f35cb4f 100644 (file)
@@ -2,7 +2,7 @@
        version.h (12.06.10)
        Version constants.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2010-2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -23,6 +23,6 @@
 
 #define EXFAT_VERSION_MAJOR 0
 #define EXFAT_VERSION_MINOR 9
-#define EXFAT_VERSION_PATCH 7
+#define EXFAT_VERSION_PATCH 8
 
 #endif /* ifndef VERSION_H_INCLUDED */
index 1a79a6b..1651160 100644 (file)
@@ -2,7 +2,7 @@
        cbm.c (09.11.10)
        Clusters Bitmap creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <unistd.h>
 #include <limits.h>
-#include <inttypes.h>
-#include <errno.h>
-#include "mkexfat.h"
+#include "cbm.h"
+#include "fat.h"
 #include "uct.h"
 #include "rootdir.h"
 
-off_t cbm_alignment(void)
+static off_t cbm_alignment(void)
 {
-       return CLUSTER_SIZE(sb);
+       return get_cluster_size();
 }
 
-off_t cbm_size(void)
+static off_t cbm_size(void)
 {
-       return DIV_ROUND_UP(le32_to_cpu(sb.cluster_count), CHAR_BIT);
+       return DIV_ROUND_UP(
+                       (get_volume_size() - get_position(&cbm)) / get_cluster_size(),
+                       CHAR_BIT);
 }
 
-int cbm_write(struct exfat_dev* dev, off_t base)
+static int cbm_write(struct exfat_dev* dev)
 {
        uint32_t allocated_clusters =
-                       DIV_ROUND_UP(cbm_size(), CLUSTER_SIZE(sb)) +
-                       DIV_ROUND_UP(uct_size(), CLUSTER_SIZE(sb)) +
-                       DIV_ROUND_UP(rootdir_size(), CLUSTER_SIZE(sb));
+                       DIV_ROUND_UP(cbm.get_size(), get_cluster_size()) +
+                       DIV_ROUND_UP(uct.get_size(), get_cluster_size()) +
+                       DIV_ROUND_UP(rootdir.get_size(), get_cluster_size());
        size_t bitmap_size = DIV_ROUND_UP(allocated_clusters, CHAR_BIT);
        uint8_t* bitmap = malloc(bitmap_size);
        size_t i;
 
        if (bitmap == NULL)
-               return errno;
+       {
+               exfat_error("failed to allocate bitmap of %zu bytes", bitmap_size);
+               return 1;
+       }
 
        for (i = 0; i < bitmap_size * CHAR_BIT; i++)
                if (i < allocated_clusters)
@@ -55,11 +58,17 @@ int cbm_write(struct exfat_dev* dev, off_t base)
                else
                        BMAP_CLR(bitmap, i);
        if (exfat_write(dev, bitmap, bitmap_size) < 0)
-               return errno;
+       {
+               exfat_error("failed to write bitmap of %zu bytes", bitmap_size);
+               return 1;
+       }
        free(bitmap);
-
-       sb.cluster_sector_start = cpu_to_le32(base / SECTOR_SIZE(sb));
-       bitmap_entry.start_cluster = cpu_to_le32(OFFSET_TO_CLUSTER(base));
-       bitmap_entry.size = cpu_to_le64(cbm_size());
        return 0;
 }
+
+const struct fs_object cbm =
+{
+       .get_alignment = cbm_alignment,
+       .get_size = cbm_size,
+       .write = cbm_write,
+};
index b6007e0..176504c 100644 (file)
@@ -2,7 +2,7 @@
        cbm.h (09.11.10)
        Clusters Bitmap creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -21,8 +21,8 @@
 #ifndef MKFS_CBM_H_INCLUDED
 #define MKFS_CBM_H_INCLUDED
 
-off_t cbm_alignment(void);
-off_t cbm_size(void);
-int cbm_write(struct exfat_dev* dev, off_t base);
+#include "mkexfat.h"
+
+extern const struct fs_object cbm;
 
 #endif /* ifndef MKFS_CBM_H_INCLUDED */
index 21d74d4..bdd9941 100644 (file)
@@ -2,7 +2,7 @@
        fat.c (09.11.10)
        File Allocation Table creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
 */
 
 #include <unistd.h>
-#include <inttypes.h>
-#include <errno.h>
-#include "mkexfat.h"
+#include "fat.h"
 #include "cbm.h"
 #include "uct.h"
 #include "rootdir.h"
 
-off_t fat_alignment(void)
+static off_t fat_alignment(void)
 {
-       return (off_t) le32_to_cpu(sb.fat_sector_start) * SECTOR_SIZE(sb);
+       return (off_t) 128 * get_sector_size();
 }
 
-off_t fat_size(void)
+static off_t fat_size(void)
 {
-       return (off_t) le32_to_cpu(sb.fat_sector_count) * SECTOR_SIZE(sb);
+       return get_volume_size() / get_cluster_size() * sizeof(cluster_t);
 }
 
 static cluster_t fat_write_entry(struct exfat_dev* dev, cluster_t cluster,
@@ -41,14 +39,17 @@ static cluster_t fat_write_entry(struct exfat_dev* dev, cluster_t cluster,
 {
        le32_t fat_entry = cpu_to_le32(value);
        if (exfat_write(dev, &fat_entry, sizeof(fat_entry)) < 0)
+       {
+               exfat_error("failed to write FAT entry 0x%x", value);
                return 0;
+       }
        return cluster + 1;
 }
 
 static cluster_t fat_write_entries(struct exfat_dev* dev, cluster_t cluster,
                uint64_t length)
 {
-       cluster_t end = cluster + DIV_ROUND_UP(length, CLUSTER_SIZE(sb));
+       cluster_t end = cluster + DIV_ROUND_UP(length, get_cluster_size());
 
        while (cluster < end - 1)
        {
@@ -59,24 +60,27 @@ static cluster_t fat_write_entries(struct exfat_dev* dev, cluster_t cluster,
        return fat_write_entry(dev, cluster, EXFAT_CLUSTER_END);
 }
 
-int fat_write(struct exfat_dev* dev, off_t base)
+static int fat_write(struct exfat_dev* dev)
 {
        cluster_t c = 0;
 
-       if (base != le32_to_cpu(sb.fat_sector_start) * SECTOR_SIZE(sb))
-               exfat_bug("unexpected FAT location: %"PRIu64" (expected %u)",
-                               base, le32_to_cpu(sb.fat_sector_start) * SECTOR_SIZE(sb));
-
        if (!(c = fat_write_entry(dev, c, 0xfffffff8))) /* media type */
-               return errno;
+               return 1;
        if (!(c = fat_write_entry(dev, c, 0xffffffff))) /* some weird constant */
-               return errno;
-       if (!(c = fat_write_entries(dev, c, cbm_size())))
-               return errno;
-       if (!(c = fat_write_entries(dev, c, uct_size())))
-               return errno;
-       if (!(c = fat_write_entries(dev, c, rootdir_size())))
-               return errno;
+               return 1;
+       if (!(c = fat_write_entries(dev, c, cbm.get_size())))
+               return 1;
+       if (!(c = fat_write_entries(dev, c, uct.get_size())))
+               return 1;
+       if (!(c = fat_write_entries(dev, c, rootdir.get_size())))
+               return 1;
 
        return 0;
 }
+
+const struct fs_object fat =
+{
+       .get_alignment = fat_alignment,
+       .get_size = fat_size,
+       .write = fat_write,
+};
index 01b5c20..8d7b86c 100644 (file)
@@ -2,7 +2,7 @@
        fat.h (09.11.10)
        File Allocation Table creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -21,8 +21,8 @@
 #ifndef MKFS_FAT_H_INCLUDED
 #define MKFS_FAT_H_INCLUDED
 
-off_t fat_alignment(void);
-off_t fat_size(void);
-int fat_write(struct exfat_dev* dev, off_t base);
+#include "mkexfat.h"
+
+extern const struct fs_object fat;
 
 #endif /* ifndef MKFS_FAT_H_INCLUDED */
index 885dd71..4d44fa1 100644 (file)
@@ -2,7 +2,7 @@
        main.c (15.08.10)
        Creates exFAT file system.
 
-       Copyright (C) 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
 #include <stdio.h>
 #include <string.h>
 #include <limits.h>
-#include <errno.h>
 #include <exfat.h>
+#include "mkexfat.h"
 #include "vbr.h"
 #include "fat.h"
 #include "cbm.h"
 #include "uct.h"
 #include "rootdir.h"
 
-#define ROUND_UP(x, d) (DIV_ROUND_UP(x, d) * (d))
-
-struct exfat_super_block sb;
-struct exfat_entry_label label_entry = {EXFAT_ENTRY_LABEL ^ EXFAT_ENTRY_VALID};
-struct exfat_entry_bitmap bitmap_entry = {EXFAT_ENTRY_BITMAP};
-struct exfat_entry_upcase upcase_entry = {EXFAT_ENTRY_UPCASE};
-
-struct exfat_structure
+const struct fs_object* objects[] =
 {
-       const char* name;
-       int order;
-       off_t (*get_alignment)(void);
-       off_t (*get_size)(void);
-       int (*write_data)(struct exfat_dev*, off_t);
+       &vbr,
+       &vbr,
+       &fat,
+       /* clusters heap */
+       &cbm,
+       &uct,
+       &rootdir,
+       NULL,
 };
 
-static int init_sb(off_t volume_size, int sector_bits, int spc_bits,
-               uint32_t volume_serial, int first_sector)
+static struct
 {
-       uint32_t clusters_max = (volume_size >> sector_bits >> spc_bits);
-       uint32_t fat_sectors = DIV_ROUND_UP(clusters_max * 4, 1 << sector_bits);
-       uint32_t allocated_clusters;
-
-       memset(&sb, 0, sizeof(struct exfat_super_block));
-       sb.jump[0] = 0xeb;
-       sb.jump[1] = 0x76;
-       sb.jump[2] = 0x90;
-       memcpy(sb.oem_name, "EXFAT   ", sizeof(sb.oem_name));
-       sb.sector_start = cpu_to_le64(first_sector);
-       sb.sector_count = cpu_to_le64(volume_size >> sector_bits);
-       sb.fat_sector_start = cpu_to_le32(128); /* FIXME */
-       sb.fat_sector_count = cpu_to_le32(ROUND_UP(
-                       le32_to_cpu(sb.fat_sector_start) + fat_sectors, 1 << spc_bits) -
-                       le32_to_cpu(sb.fat_sector_start));
-       /* cluster_sector_start will be set later */
-       sb.cluster_count = cpu_to_le32(clusters_max -
-                       ((le32_to_cpu(sb.fat_sector_start) +
-                         le32_to_cpu(sb.fat_sector_count)) >> spc_bits));
-       /* rootdir_cluster will be set later */
-       sb.volume_serial = cpu_to_le32(volume_serial);
-       sb.version.major = 1;
-       sb.version.minor = 0;
-       sb.volume_state = cpu_to_le16(0);
-       sb.sector_bits = sector_bits;
-       sb.spc_bits = spc_bits;
-       sb.fat_count = 1;
-       sb.drive_no = 0x80;
-       sb.allocated_percent = 0;
-       sb.boot_signature = cpu_to_le16(0xaa55);
-
-       allocated_clusters =
-                       DIV_ROUND_UP(cbm_size(), CLUSTER_SIZE(sb)) +
-                       DIV_ROUND_UP(uct_size(), CLUSTER_SIZE(sb)) +
-                       DIV_ROUND_UP(rootdir_size(), CLUSTER_SIZE(sb));
-       if (clusters_max < ((le32_to_cpu(sb.fat_sector_start) +
-                       le32_to_cpu(sb.fat_sector_count)) >> spc_bits) +
-                       allocated_clusters)
-       {
-               exfat_error("too small volume (%"PRIu64" bytes)", volume_size);
-               return 1;
-       }
-       exfat_print_info(&sb, le32_to_cpu(sb.cluster_count) -
-                       allocated_clusters);
-       return 0;
+       int sector_bits;
+       int spc_bits;
+       off_t volume_size;
+       le16_t volume_label[EXFAT_ENAME_MAX + 1];
+       uint32_t volume_serial;
+       uint64_t first_sector;
 }
+param;
 
-static int erase_device(struct exfat_dev* dev)
+int get_sector_bits(void)
 {
-       off_t erase_size;
-       off_t erase_blocks;
-       long block_size;
-       void* block;
-       off_t i;
-
-       block_size = sysconf(_SC_PAGESIZE);
-       if (block_size < 1)
-               block_size = 0x1000;
-
-       erase_size = ((uint64_t)
-                       le32_to_cpu(sb.fat_sector_start) +
-                       le32_to_cpu(sb.fat_sector_count)) * SECTOR_SIZE(sb);
-       erase_size = ROUND_UP(erase_size, cbm_alignment());
-       erase_size += cbm_size();
-       erase_size = ROUND_UP(erase_size, uct_alignment());
-       erase_size += uct_size();
-       erase_size = ROUND_UP(erase_size, rootdir_alignment());
-       erase_size += rootdir_size();
-
-       erase_blocks = DIV_ROUND_UP(erase_size, block_size);
-
-       if (exfat_seek(dev, 0, SEEK_SET) == (off_t) -1)
-       {
-               exfat_error("seek failed");
-               return 1;
-       }
+       return param.sector_bits;
+}
 
-       block = malloc(block_size);
-       if (block == NULL)
-       {
-               exfat_error("failed to allocate erase block");
-               return 1;
-       }
-       memset(block, 0, block_size);
+int get_spc_bits(void)
+{
+       return param.spc_bits;
+}
 
-       for (i = 0; i < erase_blocks; i++)
-       {
-               if (exfat_write(dev, block, block_size) < 0)
-               {
-                       free(block);
-                       exfat_error("failed to erase block %"PRIu64, i);
-                       return 1;
-               }
-               if (i * 100 / erase_blocks != (i + 1) * 100 / erase_blocks)
-               {
-                       printf("\b\b\b%2"PRIu64"%%", (i + 1) * 100 / erase_blocks);
-                       fflush(stdout);
-               }
-       }
-       free(block);
-       return 0;
+off_t get_volume_size(void)
+{
+       return param.volume_size;
 }
 
-/*
- * exFAT layout:
- * - Volume Boot Record (VBR)
- *   - Main Boot Sector (MBR)
- *   - Main Extended Boot Sectors (MEBS)
- *   - OEM Parameters
- *   - Reserved sector
- *   - Checksum sector
- * - Volume Boot Record copy
- * - File Allocation Table (FAT)
- * - Clusters heap
- *   - Clusters bitmap
- *   - Upper case table
- *   - Root directory
- */
-#define FS_OBJECT(order, name) \
-       {#name, order, name##_alignment, name##_size, name##_write}
-static struct exfat_structure structures[] =
+const le16_t* get_volume_label(void)
 {
-       FS_OBJECT(3, vbr),
-       FS_OBJECT(3, vbr),
-       FS_OBJECT(2, fat),
-       FS_OBJECT(1, cbm),
-       FS_OBJECT(1, uct),
-       FS_OBJECT(1, rootdir)
-};
-#undef FS_OBJECT
+       return param.volume_label;
+}
 
-static off_t write_structure(struct exfat_dev* dev,
-               struct exfat_structure* structure, off_t current)
+uint32_t get_volume_serial(void)
 {
-       off_t alignment = structure->get_alignment();
-       off_t base = ROUND_UP(current, alignment);
+       return param.volume_serial;
+}
 
-       if (exfat_seek(dev, base, SEEK_SET) == (off_t) -1)
-       {
-               exfat_error("seek to %"PRIu64" failed", base);
-               return -1;
-       }
-       if (structure->order > 0)
-       {
-               int rc = structure->write_data(dev, base);
-               if (rc != 0)
-               {
-                       exfat_error("%s creation failed: %s", structure->name,
-                                       strerror(rc));
-                       return -1;
-               }
-               structure->order--;
-       }
-       return base + structure->get_size();
+uint64_t get_first_sector(void)
+{
+       return param.first_sector;
 }
 
-static int write_structures(struct exfat_dev* dev)
+int get_sector_size(void)
 {
-       off_t current;
-       size_t i;
-       int remainder;
+       return 1 << get_sector_bits();
+}
 
-       do
-       {
-               current = 0;
-               remainder = 0;
-               for (i = 0; i < sizeof(structures) / sizeof(structures[0]); i++)
-               {
-                       current = write_structure(dev, &structures[i], current);
-                       if (current == (off_t) -1)
-                               return 1;
-                       remainder += structures[i].order;
-               }
-       }
-       while (remainder > 0);
-       return 0;
+int get_cluster_size(void)
+{
+       return get_sector_size() << get_spc_bits();
 }
 
-static int get_spc_bits(int user_defined, off_t volume_size)
+static off_t setup_volume_size(struct exfat_dev* dev)
 {
+       off_t size = exfat_seek(dev, 0, SEEK_END);
+       if (size == (off_t) -1)
+               exfat_error("failed to get volume size");
+       return size;
+}
+
+static int setup_spc_bits(int sector_bits, int user_defined, off_t volume_size)
+{
+       int i;
+
        if (user_defined != -1)
+       {
+               off_t cluster_size = 1 << sector_bits << user_defined;
+               if (volume_size / cluster_size > EXFAT_LAST_DATA_CLUSTER)
+               {
+                       struct exfat_human_bytes chb, vhb;
+
+                       exfat_humanize_bytes(cluster_size, &chb);
+                       exfat_humanize_bytes(volume_size, &vhb);
+                       exfat_error("cluster size %"PRIu64" %s is too small for "
+                                       "%"PRIu64" %s volume, try -s %d",
+                                       chb.value, chb.unit,
+                                       vhb.value, vhb.unit,
+                                       1 << setup_spc_bits(sector_bits, -1, volume_size));
+                       return -1;
+               }
                return user_defined;
+       }
 
        if (volume_size < 256ull * 1024 * 1024)
-               return 3;       /* 4 KB */
-       else if (volume_size < 32ull * 1024 * 1024 * 1024)
-               return 6;       /* 32 KB */
-       else
-               return 8;       /* 128 KB */
+               return MAX(0, 12 - sector_bits);        /* 4 KB */
+       if (volume_size < 32ull * 1024 * 1024 * 1024)
+               return MAX(0, 15 - sector_bits);        /* 32 KB */
+
+       for (i = 17; ; i++)                                             /* 128 KB or more */
+               if (DIV_ROUND_UP(volume_size, 1 << i) <= EXFAT_LAST_DATA_CLUSTER)
+                       return MAX(0, i - sector_bits);
 }
 
-static int set_volume_label(const char* volume_label)
+static int setup_volume_label(le16_t label[EXFAT_ENAME_MAX + 1], const char* s)
 {
-       le16_t tmp[EXFAT_ENAME_MAX + 1];
-
-       if (volume_label == NULL)
+       memset(label, 0, (EXFAT_ENAME_MAX + 1) * sizeof(le16_t));
+       if (s == NULL)
                return 0;
-
-       memset(tmp, 0, sizeof(tmp));
-       if (utf8_to_utf16(tmp, volume_label, EXFAT_ENAME_MAX,
-                               strlen(volume_label)) != 0)
-               return 1;
-       memcpy(label_entry.name, tmp, EXFAT_ENAME_MAX * sizeof(le16_t));
-       label_entry.length = utf16_length(tmp);
-       label_entry.type |= EXFAT_ENTRY_VALID;
-       return 0;
+       return utf8_to_utf16(label, s, EXFAT_ENAME_MAX, strlen(s));
 }
 
-static uint32_t get_volume_serial(uint32_t user_defined)
+static uint32_t setup_volume_serial(uint32_t user_defined)
 {
        struct timeval now;
 
@@ -268,76 +153,36 @@ static uint32_t get_volume_serial(uint32_t user_defined)
                return user_defined;
 
        if (gettimeofday(&now, NULL) != 0)
+       {
+               exfat_error("failed to form volume id");
                return 0;
+       }
        return (now.tv_sec << 20) | now.tv_usec;
 }
 
-static int mkfs(const char* spec, int sector_bits, int spc_bits,
-               const char* volume_label, uint32_t volume_serial, int first_sector)
+static int setup(struct exfat_dev* dev, int sector_bits, int spc_bits,
+               const char* volume_label, uint32_t volume_serial,
+               uint64_t first_sector)
 {
-       struct exfat_dev* dev;
-       off_t volume_size;
+       param.sector_bits = sector_bits;
+       param.first_sector = first_sector;
 
-       dev = exfat_open(spec, 0);
-       if (dev == NULL)
-               return 1;
-
-       volume_size = exfat_seek(dev, 0, SEEK_END);
-       if (volume_size == (off_t) -1)
-       {
-               exfat_close(dev);
-               exfat_error("seek failed");
+       param.volume_size = setup_volume_size(dev);
+       if (param.volume_size == (off_t) -1)
                return 1;
-       }
-       spc_bits = get_spc_bits(spc_bits, volume_size);
 
-       if (set_volume_label(volume_label) != 0)
-       {
-               exfat_close(dev);
+       param.spc_bits = setup_spc_bits(sector_bits, spc_bits, param.volume_size);
+       if (param.spc_bits == -1)
                return 1;
-       }
 
-       volume_serial = get_volume_serial(volume_serial);
-       if (volume_serial == 0)
-       {
-               exfat_close(dev);
-               exfat_error("failed to get current time to form volume id");
+       if (setup_volume_label(param.volume_label, volume_label) != 0)
                return 1;
-       }
 
-       if (init_sb(volume_size, sector_bits, spc_bits, volume_serial,
-                               first_sector) != 0)
-       {
-               exfat_close(dev);
+       param.volume_serial = setup_volume_serial(volume_serial);
+       if (param.volume_serial == 0)
                return 1;
-       }
 
-       printf("Creating... %2u%%", 0);
-       fflush(stdout);
-       if (erase_device(dev) != 0)
-       {
-               exfat_close(dev);
-               return 1;
-       }
-       if (write_structures(dev) != 0)
-       {
-               exfat_close(dev);
-               return 1;
-       }
-       puts("\b\b\b\bdone.");
-
-       printf("Flushing... ");
-       fflush(stdout);
-       if (exfat_fsync(dev) != 0)
-       {
-               exfat_close(dev);
-               return 1;
-       }
-       puts("done.");
-       if (exfat_close(dev) != 0)
-               return 1;
-       printf("File system created successfully.\n");
-       return 0;
+       return mkfs(dev, param.volume_size);
 }
 
 static int logarithm2(int n)
@@ -365,7 +210,8 @@ int main(int argc, char* argv[])
        int spc_bits = -1;
        const char* volume_label = NULL;
        uint32_t volume_serial = 0;
-       int first_sector = 0;
+       uint64_t first_sector = 0;
+       struct exfat_dev* dev;
 
        printf("mkexfatfs %u.%u.%u\n",
                        EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH);
@@ -390,7 +236,6 @@ int main(int argc, char* argv[])
                        if (*pp == NULL)
                                usage(argv[0]);
                        volume_label = *pp;
-                       /* TODO check length */
                }
                else if (strcmp(*pp, "-i") == 0)
                {
@@ -404,11 +249,11 @@ int main(int argc, char* argv[])
                        pp++;
                        if (*pp == NULL)
                                usage(argv[0]);
-                       first_sector = atoi(*pp);
+                       first_sector = strtoll(*pp, NULL, 10);
                }
                else if (strcmp(*pp, "-v") == 0)
                {
-                       puts("Copyright (C) 2010  Andrew Nayenko");
+                       puts("Copyright (C) 2011, 2012  Andrew Nayenko");
                        return 0;
                }
                else if (spec == NULL)
@@ -419,5 +264,17 @@ int main(int argc, char* argv[])
        if (spec == NULL)
                usage(argv[0]);
 
-       return mkfs(spec, 9, spc_bits, volume_label, volume_serial, first_sector);
+       dev = exfat_open(spec, 0);
+       if (dev == NULL)
+               return 1;
+       if (setup(dev, 9, spc_bits, volume_label, volume_serial,
+                               first_sector) != 0)
+       {
+               exfat_close(dev);
+               return 1;
+       }
+       if (exfat_close(dev) != 0)
+               return 1;
+       printf("File system created successfully.\n");
+       return 0;
 }
diff --git a/mkfs/mkexfat.c b/mkfs/mkexfat.c
new file mode 100644 (file)
index 0000000..aaf2c42
--- /dev/null
@@ -0,0 +1,160 @@
+/*
+       mkexfat.c (22.04.12)
+       FS creation engine.
+
+       Copyright (C) 2011, 2012  Andrew Nayenko
+
+       This program is free software: you can redistribute it and/or modify
+       it under the terms of the GNU General Public License as published by
+       the Free Software Foundation, either version 3 of the License, or
+       (at your option) any later version.
+
+       This program is distributed in the hope that it will be useful,
+       but WITHOUT ANY WARRANTY; without even the implied warranty of
+       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+       GNU General Public License for more details.
+
+       You should have received a copy of the GNU General Public License
+       along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include "mkexfat.h"
+
+static int check_size(off_t volume_size)
+{
+       const struct fs_object** pp;
+       off_t position = 0;
+
+       for (pp = objects; *pp; pp++)
+       {
+               position = ROUND_UP(position, (*pp)->get_alignment());
+               position += (*pp)->get_size();
+       }
+
+       if (position > volume_size)
+       {
+               struct exfat_human_bytes vhb;
+
+               exfat_humanize_bytes(volume_size, &vhb);
+               exfat_error("too small device (%"PRIu64" %s)", vhb.value, vhb.unit);
+               return 1;
+       }
+
+       return 0;
+
+}
+
+static int erase_object(struct exfat_dev* dev, const void* block,
+               size_t block_size, off_t start, off_t size)
+{
+       const off_t block_count = DIV_ROUND_UP(size, block_size);
+       off_t i;
+
+       if (exfat_seek(dev, start, SEEK_SET) == (off_t) -1)
+       {
+               exfat_error("seek to 0x%"PRIx64" failed", start);
+               return 1;
+       }
+       for (i = 0; i < size; i += block_size)
+       {
+               if (exfat_write(dev, block, MIN(size - i, block_size)) < 0)
+               {
+                       exfat_error("failed to erase block %"PRIu64"/%"PRIu64
+                                       " at 0x%"PRIx64, i + 1, block_count, start);
+                       return 1;
+               }
+       }
+       return 0;
+}
+
+static int erase(struct exfat_dev* dev)
+{
+       const struct fs_object** pp;
+       off_t position = 0;
+       const size_t block_size = 1024 * 1024;
+       void* block = malloc(block_size);
+
+       if (block == NULL)
+       {
+               exfat_error("failed to allocate erase block of %zu bytes", block_size);
+               return 1;
+       }
+       memset(block, 0, block_size);
+
+       for (pp = objects; *pp; pp++)
+       {
+               position = ROUND_UP(position, (*pp)->get_alignment());
+               if (erase_object(dev, block, block_size, position,
+                               (*pp)->get_size()) != 0)
+               {
+                       free(block);
+                       return 1;
+               }
+               position += (*pp)->get_size();
+       }
+
+       free(block);
+       return 0;
+}
+
+static int create(struct exfat_dev* dev)
+{
+       const struct fs_object** pp;
+       off_t position = 0;
+
+       for (pp = objects; *pp; pp++)
+       {
+               position = ROUND_UP(position, (*pp)->get_alignment());
+               if (exfat_seek(dev, position, SEEK_SET) == (off_t) -1)
+               {
+                       exfat_error("seek to 0x%"PRIx64" failed", position);
+                       return 1;
+               }
+               if ((*pp)->write(dev) != 0)
+                       return 1;
+               position += (*pp)->get_size();
+       }
+       return 0;
+}
+
+int mkfs(struct exfat_dev* dev, off_t volume_size)
+{
+       if (check_size(volume_size) != 0)
+               return 1;
+
+       fputs("Creating... ", stdout);
+       fflush(stdout);
+       if (erase(dev) != 0)
+               return 1;
+       if (create(dev) != 0)
+               return 1;
+       puts("done.");
+
+       fputs("Flushing... ", stdout);
+       fflush(stdout);
+       if (exfat_fsync(dev) != 0)
+               return 1;
+       puts("done.");
+
+       return 0;
+}
+
+off_t get_position(const struct fs_object* object)
+{
+       const struct fs_object** pp;
+       off_t position = 0;
+
+       for (pp = objects; *pp; pp++)
+       {
+               position = ROUND_UP(position, (*pp)->get_alignment());
+               if (*pp == object)
+                       return position;
+               position += (*pp)->get_size();
+       }
+       exfat_bug("unknown object");
+}
index dbaeb8d..a11dff3 100644 (file)
@@ -1,8 +1,8 @@
 /*
        mkexfat.h (09.11.10)
-       Common declarations.
+       FS creation engine.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
 
 #include <exfat.h>
 
-extern struct exfat_super_block sb;
-extern struct exfat_entry_label label_entry;
-extern struct exfat_entry_bitmap bitmap_entry;
-extern struct exfat_entry_upcase upcase_entry;
-
-#define OFFSET_TO_SECTOR(off) ((off) >> (sb).sector_bits)
-#define SECTOR_TO_CLUSTER(sector) \
-       ((((sector) - le32_to_cpu((sb).cluster_sector_start)) >> (sb).spc_bits) + \
-               EXFAT_FIRST_DATA_CLUSTER)
-#define OFFSET_TO_CLUSTER(off) SECTOR_TO_CLUSTER(OFFSET_TO_SECTOR(off))
+struct fs_object
+{
+       off_t (*get_alignment)(void);
+       off_t (*get_size)(void);
+       int (*write)(struct exfat_dev* dev);
+};
+
+extern const struct fs_object* objects[];
+
+int get_sector_bits(void);
+int get_spc_bits(void);
+off_t get_volume_size(void);
+const le16_t* get_volume_label(void);
+uint32_t get_volume_serial(void);
+uint64_t get_first_sector(void);
+int get_sector_size(void);
+int get_cluster_size(void);
+
+int mkfs(struct exfat_dev* dev, off_t volume_size);
+off_t get_position(const struct fs_object* object);
 
 #endif /* ifndef MKFS_MKEXFAT_H_INCLUDED */
index 547ca3b..3a4bd40 100644 (file)
@@ -2,7 +2,7 @@
        rootdir.c (09.11.10)
        Root directory creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <unistd.h>
-#include <errno.h>
-#include "mkexfat.h"
+#include <string.h>
+#include "rootdir.h"
+#include "uct.h"
+#include "cbm.h"
+#include "uctc.h"
 
-off_t rootdir_alignment(void)
+static off_t rootdir_alignment(void)
 {
-       return CLUSTER_SIZE(sb);
+       return get_cluster_size();
 }
 
-off_t rootdir_size(void)
+static off_t rootdir_size(void)
 {
-       return CLUSTER_SIZE(sb);
+       return get_cluster_size();
 }
 
-int rootdir_write(struct exfat_dev* dev, off_t base)
+static void init_label_entry(struct exfat_entry_label* label_entry)
 {
+       memset(label_entry, 0, sizeof(struct exfat_entry_label));
+       label_entry->type = EXFAT_ENTRY_LABEL ^ EXFAT_ENTRY_VALID;
+
+       if (utf16_length(get_volume_label()) == 0)
+               return;
+
+       memcpy(label_entry->name, get_volume_label(),
+                       EXFAT_ENAME_MAX * sizeof(le16_t));
+       label_entry->length = utf16_length(get_volume_label());
+       label_entry->type |= EXFAT_ENTRY_VALID;
+}
+
+static void init_bitmap_entry(struct exfat_entry_bitmap* bitmap_entry)
+{
+       memset(bitmap_entry, 0, sizeof(struct exfat_entry_bitmap));
+       bitmap_entry->type = EXFAT_ENTRY_BITMAP;
+       bitmap_entry->start_cluster = cpu_to_le32(EXFAT_FIRST_DATA_CLUSTER);
+       bitmap_entry->size = cpu_to_le64(cbm.get_size());
+}
+
+static void init_upcase_entry(struct exfat_entry_upcase* upcase_entry)
+{
+       size_t i;
+       uint32_t sum = 0;
+
+       for (i = 0; i < sizeof(upcase_table); i++)
+               sum = ((sum << 31) | (sum >> 1)) + upcase_table[i];
+
+       memset(upcase_entry, 0, sizeof(struct exfat_entry_upcase));
+       upcase_entry->type = EXFAT_ENTRY_UPCASE;
+       upcase_entry->checksum = cpu_to_le32(sum);
+       upcase_entry->start_cluster = cpu_to_le32(
+                       (get_position(&uct) - get_position(&cbm)) / get_cluster_size() +
+                       EXFAT_FIRST_DATA_CLUSTER);
+       upcase_entry->size = cpu_to_le64(sizeof(upcase_table));
+}
+
+static int rootdir_write(struct exfat_dev* dev)
+{
+       struct exfat_entry_label label_entry;
+       struct exfat_entry_bitmap bitmap_entry;
+       struct exfat_entry_upcase upcase_entry;
+
+       init_label_entry(&label_entry);
+       init_bitmap_entry(&bitmap_entry);
+       init_upcase_entry(&upcase_entry);
+
        if (exfat_write(dev, &label_entry, sizeof(struct exfat_entry)) < 0)
                return 1;
        if (exfat_write(dev, &bitmap_entry, sizeof(struct exfat_entry)) < 0)
                return 1;
        if (exfat_write(dev, &upcase_entry, sizeof(struct exfat_entry)) < 0)
                return 1;
-       sb.rootdir_cluster = cpu_to_le32(OFFSET_TO_CLUSTER(base));
        return 0;
 }
+
+const struct fs_object rootdir =
+{
+       .get_alignment = rootdir_alignment,
+       .get_size = rootdir_size,
+       .write = rootdir_write,
+};
index f3df708..64e5332 100644 (file)
@@ -2,7 +2,7 @@
        rootdir.h (09.11.10)
        Root directory creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -21,8 +21,8 @@
 #ifndef MKFS_ROOTDIR_H_INCLUDED
 #define MKFS_ROOTDIR_H_INCLUDED
 
-off_t rootdir_alignment(void);
-off_t rootdir_size(void);
-int rootdir_write(struct exfat_dev* dev, off_t base);
+#include "mkexfat.h"
+
+extern const struct fs_object rootdir;
 
 #endif /* ifndef MKFS_ROOTDIR_H_INCLUDED */
index 886bd32..1b6e1a1 100644 (file)
@@ -2,7 +2,7 @@
        uct.c (09.11.10)
        Upper Case Table creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <unistd.h>
-#include <errno.h>
-#include "mkexfat.h"
+#include "uct.h"
 #include "uctc.h"
 
-off_t uct_alignment(void)
+static off_t uct_alignment(void)
 {
-       return CLUSTER_SIZE(sb);
+       return get_cluster_size();
 }
 
-off_t uct_size(void)
+static off_t uct_size(void)
 {
        return sizeof(upcase_table);
 }
 
-static le32_t uct_checksum(void)
-{
-       size_t i;
-       uint32_t sum = 0;
-
-       for (i = 0; i < sizeof(upcase_table); i++)
-               sum = ((sum << 31) | (sum >> 1)) + upcase_table[i];
-       return cpu_to_le32(sum);
-}
-
-int uct_write(struct exfat_dev* dev, off_t base)
+static int uct_write(struct exfat_dev* dev)
 {
        if (exfat_write(dev, upcase_table, sizeof(upcase_table)) < 0)
-               return errno;
-       upcase_entry.checksum = uct_checksum();
-       upcase_entry.start_cluster = cpu_to_le32(OFFSET_TO_CLUSTER(base));
-       upcase_entry.size = cpu_to_le64(sizeof(upcase_table));
+       {
+               exfat_error("failed to write upcase table of %zu bytes",
+                               sizeof(upcase_table));
+               return 1;
+       }
        return 0;
 }
+
+const struct fs_object uct =
+{
+       .get_alignment = uct_alignment,
+       .get_size = uct_size,
+       .write = uct_write,
+};
index b35a612..4b4f024 100644 (file)
@@ -2,7 +2,7 @@
        uct.h (09.11.10)
        Upper Case Table creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -21,8 +21,8 @@
 #ifndef MKFS_UCT_H_INCLUDED
 #define MKFS_UCT_H_INCLUDED
 
-off_t uct_alignment(void);
-off_t uct_size(void);
-int uct_write(struct exfat_dev* dev, off_t base);
+#include "mkexfat.h"
+
+extern const struct fs_object uct;
 
 #endif /* ifndef MKFS_UCT_H_INCLUDED */
diff --git a/mkfs/uctc.c b/mkfs/uctc.c
new file mode 100644 (file)
index 0000000..5739811
--- /dev/null
@@ -0,0 +1,755 @@
+/*
+       uctc.c (30.04.12)
+       Upper Case Table contents.
+
+       Copyright (C) 2011, 2012  Andrew Nayenko
+
+       This program is free software: you can redistribute it and/or modify
+       it under the terms of the GNU General Public License as published by
+       the Free Software Foundation, either version 3 of the License, or
+       (at your option) any later version.
+
+       This program is distributed in the hope that it will be useful,
+       but WITHOUT ANY WARRANTY; without even the implied warranty of
+       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+       GNU General Public License for more details.
+
+       You should have received a copy of the GNU General Public License
+       along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "uctc.h"
+
+uint8_t upcase_table[5836] =
+{
+       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
+};
index 460759a..67d2bba 100644 (file)
@@ -1,8 +1,8 @@
 /*
        uctc.h (30.10.10)
-       Upper Case Table contents.
+       Upper Case Table declaration.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
 #ifndef MKFS_UCTC_H_INCLUDED
 #define MKFS_UCTC_H_INCLUDED
 
-uint8_t 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
-};
+#include <stdint.h>
+
+extern uint8_t upcase_table[5836];
 
 #endif /* ifndef MKFS_UCTC_H_INCLUDED */
index 4580565..68f481c 100644 (file)
@@ -2,7 +2,7 @@
        vbr.c (09.11.10)
        Volume Boot Record creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <unistd.h>
 #include <string.h>
-#include <errno.h>
-#include "mkexfat.h"
+#include "vbr.h"
+#include "fat.h"
+#include "cbm.h"
+#include "uct.h"
+#include "rootdir.h"
 
-off_t vbr_alignment(void)
+static off_t vbr_alignment(void)
 {
-       return 1;
+       return get_sector_size();
 }
 
-off_t vbr_size(void)
+static off_t vbr_size(void)
 {
-       return 12 * SECTOR_SIZE(sb);
+       return 12 * get_sector_size();
 }
 
-int vbr_write(struct exfat_dev* dev, off_t base)
+static void init_sb(struct exfat_super_block* sb)
 {
+       uint32_t clusters_max;
+       uint32_t fat_sectors;
+
+       clusters_max = get_volume_size() / get_cluster_size();
+       fat_sectors = DIV_ROUND_UP((off_t) clusters_max * sizeof(cluster_t),
+                       get_sector_size());
+
+       memset(sb, 0, sizeof(struct exfat_super_block));
+       sb->jump[0] = 0xeb;
+       sb->jump[1] = 0x76;
+       sb->jump[2] = 0x90;
+       memcpy(sb->oem_name, "EXFAT   ", sizeof(sb->oem_name));
+       sb->sector_start = cpu_to_le64(get_first_sector());
+       sb->sector_count = cpu_to_le64(get_volume_size() / get_sector_size());
+       sb->fat_sector_start = cpu_to_le32(
+                       fat.get_alignment() / get_sector_size());
+       sb->fat_sector_count = cpu_to_le32(ROUND_UP(
+                       le32_to_cpu(sb->fat_sector_start) + fat_sectors,
+                               1 << get_spc_bits()) -
+                       le32_to_cpu(sb->fat_sector_start));
+       sb->cluster_sector_start = cpu_to_le32(
+                       get_position(&cbm) / get_sector_size());
+       sb->cluster_count = cpu_to_le32(clusters_max -
+                       ((le32_to_cpu(sb->fat_sector_start) +
+                         le32_to_cpu(sb->fat_sector_count)) >> get_spc_bits()));
+       sb->rootdir_cluster = cpu_to_le32(
+                       (get_position(&rootdir) - get_position(&cbm)) / get_cluster_size()
+                       + EXFAT_FIRST_DATA_CLUSTER);
+       sb->volume_serial = cpu_to_le32(get_volume_serial());
+       sb->version.major = 1;
+       sb->version.minor = 0;
+       sb->volume_state = cpu_to_le16(0);
+       sb->sector_bits = get_sector_bits();
+       sb->spc_bits = get_spc_bits();
+       sb->fat_count = 1;
+       sb->drive_no = 0x80;
+       sb->allocated_percent = 0;
+       sb->boot_signature = cpu_to_le16(0xaa55);
+}
+
+static int vbr_write(struct exfat_dev* dev)
+{
+       struct exfat_super_block sb;
        uint32_t checksum;
-       le32_t* sector = malloc(SECTOR_SIZE(sb));
+       le32_t* sector = malloc(get_sector_size());
        size_t i;
 
        if (sector == NULL)
-               return errno;
+       {
+               exfat_error("failed to allocate sector-sized block of memory");
+               return 1;
+       }
 
+       init_sb(&sb);
        if (exfat_write(dev, &sb, sizeof(struct exfat_super_block)) < 0)
        {
                free(sector);
-               return errno;
+               exfat_error("failed to write super block sector");
+               return 1;
        }
        checksum = exfat_vbr_start_checksum(&sb, sizeof(struct exfat_super_block));
 
-       memset(sector, 0, SECTOR_SIZE(sb));
-       sector[SECTOR_SIZE(sb) / sizeof(sector[0]) - 1] = cpu_to_le32(0xaa550000);
+       memset(sector, 0, get_sector_size());
+       sector[get_sector_size() / sizeof(sector[0]) - 1] =
+                       cpu_to_le32(0xaa550000);
        for (i = 0; i < 8; i++)
        {
-               if (exfat_write(dev, sector, SECTOR_SIZE(sb)) < 0)
+               if (exfat_write(dev, sector, get_sector_size()) < 0)
                {
                        free(sector);
-                       return errno;
+                       exfat_error("failed to write a sector with boot signature");
+                       return 1;
                }
-               checksum = exfat_vbr_add_checksum(sector, SECTOR_SIZE(sb), checksum);
+               checksum = exfat_vbr_add_checksum(sector, get_sector_size(), checksum);
        }
 
-       memset(sector, 0, SECTOR_SIZE(sb));
-       if (exfat_write(dev, sector, SECTOR_SIZE(sb)) < 0)
-       {
-               free(sector);
-               return errno;
-       }
-       checksum = exfat_vbr_add_checksum(sector, SECTOR_SIZE(sb), checksum);
-       if (exfat_write(dev, sector, SECTOR_SIZE(sb)) < 0)
+       memset(sector, 0, get_sector_size());
+       for (i = 0; i < 2; i++)
        {
-               free(sector);
-               return errno;
+               if (exfat_write(dev, sector, get_sector_size()) < 0)
+               {
+                       free(sector);
+                       exfat_error("failed to write an empty sector");
+                       return 1;
+               }
+               checksum = exfat_vbr_add_checksum(sector, get_sector_size(), checksum);
        }
-       checksum = exfat_vbr_add_checksum(sector, SECTOR_SIZE(sb), checksum);
 
-       for (i = 0; i < SECTOR_SIZE(sb) / sizeof(sector[0]); i++)
+       for (i = 0; i < get_sector_size() / sizeof(sector[0]); i++)
                sector[i] = cpu_to_le32(checksum);
-       if (exfat_write(dev, sector, SECTOR_SIZE(sb)) < 0)
+       if (exfat_write(dev, sector, get_sector_size()) < 0)
        {
                free(sector);
-               return errno;
+               exfat_error("failed to write checksum sector");
+               return 1;
        }
 
        free(sector);
        return 0;
 }
+
+const struct fs_object vbr =
+{
+       .get_alignment = vbr_alignment,
+       .get_size = vbr_size,
+       .write = vbr_write,
+};
index d4cd56d..c3a6362 100644 (file)
@@ -2,7 +2,7 @@
        vbr.h (09.11.10)
        Volume Boot Record creation code.
 
-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Copyright (C) 2011, 2012  Andrew Nayenko
 
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
@@ -21,8 +21,8 @@
 #ifndef MKFS_VBR_H_INCLUDED
 #define MKFS_VBR_H_INCLUDED
 
-off_t vbr_alignment(void);
-off_t vbr_size(void);
-int vbr_write(struct exfat_dev* dev, off_t base);
+#include "mkexfat.h"
+
+extern const struct fs_object vbr;
 
 #endif /* ifndef MKFS_VBR_H_INCLUDED */