From 70a4b10edcf53a90140e6dd80ccaa045f3647ad7 Mon Sep 17 00:00:00 2001 From: Sven Hoexter Date: Sun, 12 Aug 2012 19:16:47 +0200 Subject: [PATCH 1/1] Imported Upstream version 0.9.8 --- ChangeLog | 6 + SConstruct | 15 +- dump/main.c | 4 +- fsck/main.c | 4 +- label/main.c | 6 +- libexfat/byteorder.h | 2 +- libexfat/cluster.c | 2 +- libexfat/exfat.h | 6 +- libexfat/exfatfs.h | 3 +- libexfat/io.c | 5 +- libexfat/log.c | 12 +- libexfat/lookup.c | 2 +- libexfat/mount.c | 2 +- libexfat/node.c | 2 +- libexfat/time.c | 2 +- libexfat/utf.c | 4 +- libexfat/utils.c | 8 +- libexfat/version.h | 4 +- mkfs/cbm.c | 47 +-- mkfs/cbm.h | 8 +- mkfs/fat.c | 48 +-- mkfs/fat.h | 8 +- mkfs/main.c | 375 +++++++-------------- mkfs/mkexfat.c | 160 +++++++++ mkfs/mkexfat.h | 34 +- mkfs/rootdir.c | 75 ++++- mkfs/rootdir.h | 8 +- mkfs/uct.c | 40 ++- mkfs/uct.h | 8 +- mkfs/uctc.c | 755 +++++++++++++++++++++++++++++++++++++++++++ mkfs/uctc.h | 740 +----------------------------------------- mkfs/vbr.c | 120 +++++-- mkfs/vbr.h | 8 +- 33 files changed, 1360 insertions(+), 1163 deletions(-) create mode 100644 mkfs/mkexfat.c create mode 100644 mkfs/uctc.c diff --git a/ChangeLog b/ChangeLog index d492c39..e42a095 100644 --- 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). diff --git a/SConstruct b/SConstruct index 14bd10e..3206c54 100644 --- a/SConstruct +++ b/SConstruct @@ -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 diff --git a/dump/main.c b/dump/main.c index cd424d9..1536f81 100644 --- a/dump/main.c +++ b/dump/main.c @@ -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) diff --git a/fsck/main.c b/fsck/main.c index 7ad5b26..26ef2b2 100644 --- a/fsck/main.c +++ b/fsck/main.c @@ -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) diff --git a/label/main.c b/label/main.c index b4ee541..b3a3d30 100644 --- a/label/main.c +++ b/label/main.c @@ -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; } diff --git a/libexfat/byteorder.h b/libexfat/byteorder.h index 6b38646..abcf811 100644 --- a/libexfat/byteorder.h +++ b/libexfat/byteorder.h @@ -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 diff --git a/libexfat/cluster.c b/libexfat/cluster.c index 1257c7a..0418932 100644 --- a/libexfat/cluster.c +++ b/libexfat/cluster.c @@ -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 diff --git a/libexfat/exfat.h b/libexfat/exfat.h index bca0d24..392c95d 100644 --- a/libexfat/exfat.h +++ b/libexfat/exfat.h @@ -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 @@ -38,10 +38,12 @@ #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))) diff --git a/libexfat/exfatfs.h b/libexfat/exfatfs.h index 61e39a1..5a8e39f 100644 --- a/libexfat/exfatfs.h +++ b/libexfat/exfatfs.h @@ -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 */ diff --git a/libexfat/io.c b/libexfat/io.c index c9c1e2b..f0beddc 100644 --- a/libexfat/io.c +++ b/libexfat/io.c @@ -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 . */ -#define _XOPEN_SOURCE 500 /* for pread() and pwrite() in Linux */ #include "exfat.h" #include #include @@ -32,7 +31,7 @@ #include #endif -#if _FILE_OFFSET_BITS != 64 +#if !defined(_FILE_OFFSET_BITS) || (_FILE_OFFSET_BITS != 64) #error You should define _FILE_OFFSET_BITS=64 #endif diff --git a/libexfat/log.c b/libexfat/log.c index 7a2b35d..8b589b4 100644 --- a/libexfat/log.c +++ b/libexfat/log.c @@ -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 #include +#include 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); } diff --git a/libexfat/lookup.c b/libexfat/lookup.c index 619dcea..d650976 100644 --- a/libexfat/lookup.c +++ b/libexfat/lookup.c @@ -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 diff --git a/libexfat/mount.c b/libexfat/mount.c index 521b539..a62466b 100644 --- a/libexfat/mount.c +++ b/libexfat/mount.c @@ -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 diff --git a/libexfat/node.c b/libexfat/node.c index 2ae724d..4cbb3e2 100644 --- a/libexfat/node.c +++ b/libexfat/node.c @@ -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 diff --git a/libexfat/time.c b/libexfat/time.c index 2e22a99..890930e 100644 --- a/libexfat/time.c +++ b/libexfat/time.c @@ -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 diff --git a/libexfat/utf.c b/libexfat/utf.c index 3f0dc19..983c793 100644 --- a/libexfat/utf.c +++ b/libexfat/utf.c @@ -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; diff --git a/libexfat/utils.c b/libexfat/utils.c index c165cf9..7c47f4d 100644 --- a/libexfat/utils.c +++ b/libexfat/utils.c @@ -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; diff --git a/libexfat/version.h b/libexfat/version.h index aa636f8..f35cb4f 100644 --- a/libexfat/version.h +++ b/libexfat/version.h @@ -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 */ diff --git a/mkfs/cbm.c b/mkfs/cbm.c index 1a79a6b..1651160 100644 --- a/mkfs/cbm.c +++ b/mkfs/cbm.c @@ -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 @@ -18,36 +18,39 @@ along with this program. If not, see . */ -#include #include -#include -#include -#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, +}; diff --git a/mkfs/cbm.h b/mkfs/cbm.h index b6007e0..176504c 100644 --- a/mkfs/cbm.h +++ b/mkfs/cbm.h @@ -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 */ diff --git a/mkfs/fat.c b/mkfs/fat.c index 21d74d4..bdd9941 100644 --- a/mkfs/fat.c +++ b/mkfs/fat.c @@ -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 @@ -19,21 +19,19 @@ */ #include -#include -#include -#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, +}; diff --git a/mkfs/fat.h b/mkfs/fat.h index 01b5c20..8d7b86c 100644 --- a/mkfs/fat.h +++ b/mkfs/fat.h @@ -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 */ diff --git a/mkfs/main.c b/mkfs/main.c index 885dd71..4d44fa1 100644 --- a/mkfs/main.c +++ b/mkfs/main.c @@ -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 @@ -25,242 +25,127 @@ #include #include #include -#include #include +#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 index 0000000..aaf2c42 --- /dev/null +++ b/mkfs/mkexfat.c @@ -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 . +*/ + +#include +#include +#include +#include +#include +#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"); +} diff --git a/mkfs/mkexfat.h b/mkfs/mkexfat.h index dbaeb8d..a11dff3 100644 --- a/mkfs/mkexfat.h +++ b/mkfs/mkexfat.h @@ -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 @@ -23,15 +23,25 @@ #include -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 */ diff --git a/mkfs/rootdir.c b/mkfs/rootdir.c index 547ca3b..3a4bd40 100644 --- a/mkfs/rootdir.c +++ b/mkfs/rootdir.c @@ -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 @@ -18,28 +18,83 @@ along with this program. If not, see . */ -#include -#include -#include "mkexfat.h" +#include +#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, +}; diff --git a/mkfs/rootdir.h b/mkfs/rootdir.h index f3df708..64e5332 100644 --- a/mkfs/rootdir.h +++ b/mkfs/rootdir.h @@ -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 */ diff --git a/mkfs/uct.c b/mkfs/uct.c index 886bd32..1b6e1a1 100644 --- a/mkfs/uct.c +++ b/mkfs/uct.c @@ -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 @@ -18,37 +18,33 @@ along with this program. If not, see . */ -#include -#include -#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, +}; diff --git a/mkfs/uct.h b/mkfs/uct.h index b35a612..4b4f024 100644 --- a/mkfs/uct.h +++ b/mkfs/uct.h @@ -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 index 0000000..5739811 --- /dev/null +++ b/mkfs/uctc.c @@ -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 . +*/ + +#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 +}; diff --git a/mkfs/uctc.h b/mkfs/uctc.h index 460759a..67d2bba 100644 --- a/mkfs/uctc.h +++ b/mkfs/uctc.h @@ -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 @@ -21,738 +21,8 @@ #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 + +extern uint8_t upcase_table[5836]; #endif /* ifndef MKFS_UCTC_H_INCLUDED */ diff --git a/mkfs/vbr.c b/mkfs/vbr.c index 4580565..68f481c 100644 --- a/mkfs/vbr.c +++ b/mkfs/vbr.c @@ -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 @@ -18,71 +18,129 @@ along with this program. If not, see . */ -#include #include -#include -#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, +}; diff --git a/mkfs/vbr.h b/mkfs/vbr.h index d4cd56d..c3a6362 100644 --- a/mkfs/vbr.h +++ b/mkfs/vbr.h @@ -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 */ -- 2.39.2