5 files changed, 1305 insertions, 64 deletions

diff --git a/sbin/newfs_msdos/Makefile b/sbin/newfs_msdos/Makefile
index bd5b3486b6b6..74c4c90cb41b 100644
--- a/sbin/newfs_msdos/Makefile
+++ b/sbin/newfs_msdos/Makefile
@@ -5,6 +5,13 @@ PROG=	newfs_msdos
 MAN=	newfs_msdos.8
 SRCS=	newfs_msdos.c mkfs_msdos.c
 
+LINKS=  ${BINDIR}/newfs_msdos ${BINDIR}/newfs_exfat
+MLINKS=	newfs_msdos.8 newfs_exfat.8
+
+.if ${MK_ICONV} == "yes"
+CFLAGS+=-DWITH_ICONV
+.endif
+
 # XXX - this is verboten
 .if ${MACHINE_CPUARCH} == "arm"
 WARNS?= 3
diff --git a/sbin/newfs_msdos/mkfs_msdos.c b/sbin/newfs_msdos/mkfs_msdos.c
index dcc2bb982efc..70ec3b8f345c 100644
--- a/sbin/newfs_msdos/mkfs_msdos.c
+++ b/sbin/newfs_msdos/mkfs_msdos.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 1998 Robert Nordier
+ * Copyright (c) 2025 Stefan Eßer
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -35,6 +36,7 @@
 #include <sys/disklabel.h>
 #include <sys/mount.h>
 #endif
+#include <sys/endian.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/time.h>
@@ -44,9 +46,14 @@
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
+#ifdef WITH_ICONV
+#include <iconv.h>
+#include <locale.h>
+#endif
 #include <inttypes.h>
 #include <paths.h>
 #include <signal.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -61,11 +68,14 @@
 
 #define	DOSMAGIC  0xaa55	/* DOS magic number */
 #define	MINBPS	  512		/* minimum bytes per sector */
-#define	MAXBPS    4096		/* maximum bytes per sector */
+#define	MAXBPS	  4096		/* maximum bytes per sector */
 #define	MAXSPC	  128		/* maximum sectors per cluster */
+#define	MAXBPC_EX (1<<25)	/* maximum sectors per cluster exFAT */
 #define	MAXNFT	  16		/* maximum number of FATs */
+#define	MAXNFT_EX 2		/* maximum number of FATs exFAT */
 #define	DEFBLK	  4096		/* default block size */
 #define	DEFBLK16  2048		/* default block size FAT16 */
+#define	DEFBLK_EX (128*1024)	/* default block size exFAT */
 #define	DEFRDE	  512		/* default root directory entries */
 #define	RESFTE	  2		/* reserved FAT entries */
 #define	MINCLS12  1U		/* minimum FAT12 clusters */
@@ -78,23 +88,25 @@
 #define	mincls(fat)  ((fat) == 12 ? MINCLS12 :	\
 		      (fat) == 16 ? MINCLS16 :	\
 				    MINCLS32)
-
 #define	maxcls(fat)  ((fat) == 12 ? MAXCLS12 :	\
 		      (fat) == 16 ? MAXCLS16 :	\
 				    MAXCLS32)
 
-#define	mk1(p, x)				\
-    (p) = (u_int8_t)(x)
+#define	BOOTSEC		0	/* boot sector offset */
+#define	EXTBOOTSEC	1	/* extended boot sector offset */
+#define	EXTBOOTSECCNT	8	/* number of extended boot sectors */
+#define	OEMPARMSEC	9	/* OEM parameter sector offset */
+#define	RESERVEDSEC	10	/* reserved sector */
+#define	BOOTCKSUMSEC	11	/* checksum sector */
+#define	BACKUPSECOFS	12	/* backup boot sector region offset */
 
-#define	mk2(p, x)				\
-    (p)[0] = (u_int8_t)(x),			\
-    (p)[1] = (u_int8_t)((x) >> 010)
+#define	EX_DE_ALLOCMAP		0x81	/* cluster allocation bitmap */
+#define	EX_DE_UPCASETABLE	0x82	/* UTF-16 upper case translation */
+#define	EX_DE_LABEL		0x83	/* volume label */
 
-#define	mk4(p, x)				\
-    (p)[0] = (u_int8_t)(x),			\
-    (p)[1] = (u_int8_t)((x) >> 010),		\
-    (p)[2] = (u_int8_t)((x) >> 020),		\
-    (p)[3] = (u_int8_t)((x) >> 030)
+#define	mk1(p, x)	(p) = (u_int8_t)(x)
+#define	mk2(p, x)	le16enc(p, x)
+#define	mk4(p, x)	le32enc(p, x)
 
 struct bs {
     u_int8_t bsJump[3];			/* bootstrap entry point */
@@ -135,6 +147,30 @@ struct bsx {
     u_int8_t exFileSysType[8];		/* file system type */
 } __packed;
 
+struct bsexfat {
+    u_int8_t bsJump[3];			/* bootstrap entry point */
+    u_int8_t bsFileSystemName[8];	/* OEM name and version "EXFAT   " */
+    u_int8_t bsUnused[53];		/* unused DOS parameter area */
+    u_int8_t bsPartitionOffset[8];	/* start of partition on device */
+    u_int8_t bsVolumeLength[8];		/* number of sectors in volume */
+    u_int8_t bsFatOffset[4];		/* phys. sector of start of FAT */
+    u_int8_t bsFatLength[4];		/* number of sectors per FAT */
+    u_int8_t bsClusterHeapOffset[4];	/* phys. sector of cluster #2 */
+    u_int8_t bsClusterCount[4];		/* number of clusters */
+    u_int8_t bsRootClust[4];		/* start cluster for root directory */
+    u_int8_t bsVolSerialNumber[4];	/* volume serial number */
+    u_int8_t bsFSVers[2];		/* ExFat file system revision */
+    u_int8_t bsVolumeFlags[2];		/* volume status, e.g. dirty */
+    u_int8_t bsBytesPerSecShift;	/* log2 of bytes per sector */
+    u_int8_t bsSecPerClustShift;	/* log2 of sectors per cluster */
+    u_int8_t bsFATs;			/* number of FATs */
+    u_int8_t bsDriveSelect;		/* extended INT 13h drive number */
+    u_int8_t bsPercentInUse;		/* percentage of clusters in use */
+    u_int8_t bsReserved[7];		/* reserved for future expansion */
+    u_int8_t bsBootCode[390];		/* pad so structure is 512b */
+    u_int8_t bsBootSectSig[2];		/* DOSMAGIC */
+} __packed;
+
 struct de {
     u_int8_t deName[11];		/* name and extension */
     u_int8_t deAttributes;		/* attributes */
@@ -157,14 +193,57 @@ struct bpb {
     u_int bpbSecPerTrack;		/* sectors per track */
     u_int bpbHeads;			/* drive heads */
     u_int bpbHiddenSecs;		/* hidden sectors */
-    u_int bpbHugeSectors; 		/* big total sectors */
+    u_quad_t bpbHugeSectors; 		/* big total sectors */
     u_int bpbBigFATsecs; 		/* big sectors per FAT */
     u_int bpbRootClust; 		/* root directory start cluster */
     u_int bpbFSInfo; 			/* file system info sector */
     u_int bpbBackup; 			/* backup boot sector */
+    u_int bpbUsedBitmapClust1;		/* used block bitmap cluster 1 */
+    u_int bpbUsedBitmapClust2;		/* used block bitmap cluster 2 */
+    u_int bpbUpcaseTableClust;		/* upcase table cluster */
+    u_int bpbClusterHeapOffset;		/* start of EXFAT data area */
+    u_int bpbBPSshift;			/* bytes per sector shift value */
+    u_int bpbSPCshift;			/* sectors per cluster shift value */
+    u_int bpbClusterCount;		/* number of clusters */
+    u_int bpbUpcaseTableSectors;	/* upcase table sectors */
+    u_int bpbUsedBitmapSectors;		/* used block bitmap sectors */
+};
+
+/*
+ * Structure of an EXFAT allocation bitmap (cluster heap) entry.
+ */
+struct exfatdir_bitmap {
+	uint8_t		type;		/* entry type == 0x81 */
+	uint8_t		flags;		/* secondary flags */
+#define	EX_FLAG_BITMAP2		0x01	/* entry is pointing to 2nd bitmap */
+	uint8_t		reserved[18];
+	uint8_t		firstcluster[4];/* first bitmap cluster */
+	uint8_t		datalength[8];	/* size of bitmap in bytes */
+};
+
+/*
+ * Structure of an EXFAT UTF-16 upper case translation table  entry.
+ */
+struct exfatdir_upcasetable {
+	uint8_t		type;		/* entry type == 0x82 */
+	uint8_t		reserved1[3];
+	uint8_t		chksum[4];	/* checksum of compressed table */
+	uint8_t		reserved2[12];
+	uint8_t		firstcluster[4]; /* first bitmap cluster */
+	uint8_t		datalength[8]; /* size of bitmap in bytes */
+};
+
+/*
+ * Structure of an EXFAT volume label entry.
+ */
+struct exfatdir_label {
+	uint8_t		type;		/* entry type == 0x83 */
+	uint8_t		namelength;	/* number of UTF-16 characters */
+	uint8_t		label[22];	/* up to 11 UTF-16 characters */
+	uint8_t		reserved[8];
 };
 
-#define	BPBGAP 0, 0, 0, 0, 0, 0
+#define	BPBGAP 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 
 static struct {
     const char *name;
@@ -214,6 +293,745 @@ static const u_int8_t bootcode[] = {
     0
 };
 
+/*
+ * Up-case table recommended in section 7.2.5.1 of the exFAT File System
+ * Specification.
+ */
+static u_int compr_upcase_table_cksum = 0xE619D30D;
+
+static uint8_t compr_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
+};
+
 static volatile sig_atomic_t got_siginfo;
 static void infohandler(int);
 
@@ -227,7 +1045,320 @@ static void print_bpb(struct bpb *);
 static int ckgeom(const char *, u_int, const char *);
 static void mklabel(u_int8_t *, const char *);
 static int oklabel(const char *);
+static int exfat_oklabel(const u_int8_t *, int len);
 static void setstr(u_int8_t *, const char *, size_t);
+static void fill_exfat_buffer(u_int8_t *, u_int, const struct bpb *, const struct msdos_options *);
+
+static int
+u8to16char(const u_char **u8strp, u_long *u8lenp, u_char **u16strp, u_long *u16lenp) {
+    u_long more;
+    unsigned temp;
+    u_char c;
+
+    if (*u8lenp == 0)
+	return (0);
+
+    c = (*u8strp)[0];
+
+    if ((c & 0x80) == 0) {
+	temp = c;
+	more = 0;
+    } else if ((c & 0xe0) == 0xc0) {
+	temp = c & 0x1f;
+	more = 1;
+    } else if ((c & 0xf0) == 0xe0) {
+	temp = c & 0x0f;
+	more = 2;
+    } else if ((c & 0xf8) == 0xf0) {
+	temp = c & 0x07;
+	more = 3;
+    } else {
+	return (-1);
+    }
+
+    if (*u8lenp < more + 1)
+	return (-1);
+
+    (*u8strp)++;
+    *u8lenp -= more + 1;
+
+    while (more-- > 0) {
+	temp <<= 6;
+	temp |= (u_char)*(*u8strp)++ & 0x3f;
+    }
+
+    if ((temp & 0xffff0000) == 0) {
+	if (*u16lenp < 2)
+	    return (-1);
+	*(*u16strp)++ = temp;
+	*(*u16strp)++ = temp >> 8;
+	*u16lenp -= 2;
+    } else {
+	if (*u16lenp < 4)
+	    return (-1);
+	temp -= 0x10000;
+	*(*u16strp)++ = (temp >> 10);
+	*(*u16strp)++ = 0xD8 | ((temp >> 18) & 0x03);
+	*(*u16strp)++ = temp;
+	*(*u16strp)++ = 0xDC | ((temp >> 8) & 0x03);
+    }
+    return (0);
+}
+
+static int
+u8to16str(const u_char **u8strp, u_long *u8lenp, u_char **u16strp, u_long *u16lenp)
+{
+    int error = 0;
+#ifdef WITH_ICONV
+    iconv_t u8to16function;
+
+    setlocale(LC_ALL, "");
+    u8to16function = iconv_open("UTF-16LE", "");
+    if ((long)u8to16function != -1L) {
+	error = iconv(u8to16function, __DECONST(char**, u8strp), u8lenp,
+	    (char**)u16strp, u16lenp);
+	iconv_close(u8to16function);
+	return (error);
+    }
+#endif
+    while (*u8lenp > 0 && *u16lenp > 0 && (*u8strp)[0] != 0 && error == 0) {
+	error = u8to16char(u8strp, u8lenp, u16strp, u16lenp);
+    }
+    return (error);
+}
+
+static int
+exfat_cksum(u_char *data, int secno, int len, uint32_t cksum) {
+    int i;
+
+    for (i = 0; i < len; i++) {
+	if (secno == 0 && (i == 106 || i == 107 || i == 112))
+	    continue;
+	cksum = ((cksum & 1) << 31) + (cksum >> 1) + data[i];
+    }
+    return (cksum);
+}
+
+static void
+fill_exfat_bootsec(u_int8_t *buffer, const struct bpb *bpb,
+    const struct msdos_options *op)
+{
+    struct bsexfat *bse;
+    struct timespec now;
+    int volume_id;
+
+    if (op->volume_id_set != 0)
+	volume_id = op->volume_id;
+    else
+	if (clock_gettime(CLOCK_SECOND, &now) == 0)
+	    volume_id = now.tv_sec;
+	else
+	    volume_id = arc4random();
+    bse = (struct bsexfat *)buffer;
+    bse->bsJump[0] = 0xeb;
+    bse->bsJump[1] = offsetof(struct bsexfat, bsBootCode) - 2;
+    bse->bsJump[2] = 0x90;
+    setstr(bse->bsFileSystemName, "EXFAT", sizeof(bse->bsFileSystemName));
+    le64enc(bse->bsPartitionOffset, op->offset);
+    le64enc(bse->bsVolumeLength, bpb->bpbHugeSectors);
+    le32enc(bse->bsFatOffset, bpb->bpbResSectors);
+    le32enc(bse->bsFatLength, bpb->bpbBigFATsecs);
+    le32enc(bse->bsClusterHeapOffset, bpb->bpbClusterHeapOffset);
+    le32enc(bse->bsClusterCount, bpb->bpbClusterCount);
+    le32enc(bse->bsRootClust, bpb->bpbRootClust);
+    le32enc(bse->bsVolSerialNumber, volume_id);
+    le16enc(bse->bsFSVers, 0x0100);
+    le16enc(bse->bsVolumeFlags, 0x0000);
+    bse->bsBytesPerSecShift = bpb->bpbBPSshift;
+    bse->bsSecPerClustShift = bpb->bpbSPCshift;
+    bse->bsFATs = (u_int8_t)bpb->bpbFATs;
+    bse->bsDriveSelect = 0x80;
+    bse->bsPercentInUse = 0;
+    memset(bse->bsBootCode, 0xf4, sizeof(bse->bsBootCode));
+    le16enc(bse->bsBootSectSig, DOSMAGIC);
+}
+
+static void
+fill_exfat_extbootsec(u_int8_t *buffer, int secsize)
+{
+    le16enc(buffer + secsize - 4, 0);
+    le16enc(buffer + secsize - 2, DOSMAGIC);
+}
+
+static void
+fill_exfat_cksumsec(u_int8_t *buffer, const struct bpb *bpb, u_int32_t cksum)
+{
+    u_int secsize, i;
+
+    secsize = bpb->bpbBytesPerSec;
+    for (i = 0; i < secsize; i += 4)
+	le32enc(buffer + i, cksum);
+}
+
+static void
+fill_exfat_upcasetable(u_int8_t *buffer, const struct bpb *bpb, u_int secno)
+{
+    u_int secsize;
+    u_int ofs, n;
+
+    secsize = bpb->bpbBytesPerSec;
+    ofs = secno * secsize;
+    if (ofs < sizeof(compr_upcase_table)) {
+	n = sizeof(compr_upcase_table) - ofs;
+	if (n > secsize)
+	    n = secsize;
+	memcpy(buffer, compr_upcase_table + ofs, n);
+    }
+}
+
+static void
+fill_exfat_usedbitmap(u_int8_t *buffer, const struct bpb *bpb, u_int secno)
+{
+    u_int used_clusters, lastsec;
+    int secsize;
+
+    used_clusters = (bpb->bpbRootClust - RESFTE) + 1;
+    secsize = bpb->bpbBytesPerSec;
+    lastsec = (used_clusters - 1) / (secsize * 8);
+    if (secno <= lastsec) {
+	if (secno < lastsec) {
+	    memset(buffer, 0xff, secsize);
+	} else {
+	    memset(buffer, 0xff, used_clusters / 8);
+	    buffer += used_clusters / 8;
+	    used_clusters %= 8;
+	    if (used_clusters > 0)
+		*buffer = (1 << used_clusters) - 1;
+	}
+    }
+}
+
+static void
+fill_exfat_rootdir(u_int8_t *buffer, const struct bpb *bpb,
+    const u_char* volume_label, u_int secno)
+{
+    struct exfatdir_label *p_l;
+    struct exfatdir_upcasetable *p_u;
+    struct exfatdir_bitmap *p_b;
+    const u_char *u8str;
+    u_long u8len, u16len;
+    u_char *u16labelp;
+
+    u8str = volume_label;
+    if (secno == 0) {
+	p_l = (struct exfatdir_label*)buffer;
+	p_l->type = EX_DE_LABEL;
+	if (u8str && *u8str != 0) {
+	    u8len = strlen(u8str);
+	    u16len = nitems(p_l->label);
+	    u16labelp = (u_char*)p_l->label;
+	    if (u8to16str(&u8str, &u8len, &u16labelp, &u16len) != 0)
+		warn("Bad volume label '%s' truncated at '%s'", volume_label, u8str);
+	    p_l->namelength = (sizeof(p_l->label) - u16len) / 2;
+	    if (!exfat_oklabel(p_l->label, p_l->namelength)) {
+		warnx("Bad volume label '%s' ignored: contains invalid character",
+		    volume_label);
+		p_l->namelength = 0;
+		memset(p_l->label, 0, sizeof(p_l->label));
+	    }
+	}
+	p_b = (struct exfatdir_bitmap*)p_l + 1;
+	p_b->type = EX_DE_ALLOCMAP;
+	p_b->flags = 0;
+	le32enc(p_b->firstcluster, bpb->bpbUsedBitmapClust1);
+	le64enc(p_b->datalength, (u_int64_t)howmany(bpb->bpbClusterCount, 8));
+
+	if (bpb->bpbFATs == 2) {
+	    p_b++;
+	    p_b->type = EX_DE_UPCASETABLE;
+	    p_b->flags = EX_FLAG_BITMAP2;
+	    le32enc(p_b->firstcluster, bpb->bpbUsedBitmapClust2);
+	    le64enc(p_b->datalength, (u_int64_t)howmany(bpb->bpbClusterCount, 8));
+	}
+
+	p_u = (struct exfatdir_upcasetable*)p_b + 1;
+	p_u->type = EX_DE_UPCASETABLE;
+	le32enc(p_u->chksum, compr_upcase_table_cksum);
+	le32enc(p_u->firstcluster, bpb->bpbUpcaseTableClust);
+	le64enc(p_u->datalength, (u_int64_t)sizeof(compr_upcase_table));
+    }
+}
+
+static void
+fill_exfat_buffer(u_int8_t *buffer, u_int secno, const struct bpb *bpb,
+    const struct msdos_options *op)
+{
+    int secsize, fillsize, fatsec;
+    u_int32_t sectype, basesec, segmsize, used_clusters;
+    static u_int32_t cksum;
+
+    secsize = bpb->bpbBytesPerSec;
+    if (secno < 2 * BACKUPSECOFS) {
+	/* Main and backup boot regions. */
+	sectype = secno % BACKUPSECOFS;
+	switch (sectype) {
+	case BOOTSEC:
+	    fill_exfat_bootsec(buffer, bpb, op);
+	    cksum = 0;
+	    break;
+	case OEMPARMSEC:
+	case RESERVEDSEC:
+	    break;
+	case BOOTCKSUMSEC:
+	    /* Final sector in main and backup boot region. */
+	    fill_exfat_cksumsec(buffer, bpb, cksum);
+	    break;
+	default:
+	    assert(EXTBOOTSEC <= sectype && sectype < EXTBOOTSEC + EXTBOOTSECCNT);
+	    fill_exfat_extbootsec(buffer, secsize);
+	    break;
+	}
+	cksum = exfat_cksum(buffer, sectype, secsize, cksum);
+    } else if (secno >= bpb->bpbResSectors &&
+	secno < bpb->bpbResSectors + bpb->bpbFATs * bpb->bpbBigFATsecs) {
+	/* FAT region, up to 2 FAT tables are supported */
+	fatsec = (secno - bpb->bpbResSectors) % bpb->bpbBigFATsecs;
+	used_clusters = bpb->bpbRootClust;
+	fillsize = used_clusters * 4 - fatsec * secsize;
+
+	if (fillsize > 0) {
+	    if (fillsize > secsize)
+		fillsize = secsize;
+	    memset(buffer + 4, 0xff, fillsize);
+	    if (fatsec == 0)
+		le32enc(buffer, 0xfffffff8);
+	}
+    } else {
+	/* Data region. */
+	basesec = bpb->bpbClusterHeapOffset;
+
+	basesec += (bpb->bpbUsedBitmapClust1 - RESFTE) << bpb->bpbSPCshift;
+	segmsize = bpb->bpbUsedBitmapSectors;
+	if (basesec <= secno && secno < basesec + segmsize) {
+	    /* Used block bitmap section. */
+	    fill_exfat_usedbitmap(buffer, bpb, secno - basesec);
+	}
+	if (bpb->bpbFATs == 2) {
+	    /* Optional 2nd used block bitmap section, if number of FATs == 2. */
+	    basesec += (bpb->bpbUsedBitmapClust2 - bpb->bpbUsedBitmapClust1) << bpb->bpbSPCshift;
+	    if (basesec <= secno && secno < basesec + segmsize) {
+		fill_exfat_usedbitmap(buffer, bpb, secno - basesec);
+	    }
+	}
+	basesec += (bpb->bpbUpcaseTableClust - bpb->bpbUsedBitmapClust2) << bpb->bpbSPCshift;
+	segmsize = bpb->bpbUpcaseTableSectors;
+	if (basesec <= secno && secno < basesec + segmsize) {
+	    /* UTF-16 up-case translation table used for file name matching. */
+	    fill_exfat_upcasetable(buffer, bpb, secno - basesec);
+	}
+	basesec += (bpb->bpbRootClust - bpb->bpbUpcaseTableClust) << bpb->bpbSPCshift;
+	segmsize = bpb->bpbUpcaseTableSectors;
+	if (basesec <= secno && secno < basesec + segmsize) {
+	    /* Root directory with entries for up-case table and used block bitmaps. */
+	    fill_exfat_rootdir(buffer, bpb, op->volume_label, secno - basesec);
+	}
+    }
+}
 
 int
 mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
@@ -254,6 +1385,7 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
     int fd, fd1, rv;
     struct msdos_options o = *op;
     ssize_t chunksize;
+    u_int maxnft, maxspc, defblk;
 
     physbuf = NULL;
     rv = -1;
@@ -331,10 +1463,12 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
     if (!(o.floppy || (o.drive_heads && o.sectors_per_track &&
 	o.bytes_per_sector && o.size && o.hidden_sectors_set))) {
 	if (getdiskinfo(fd, fname, dtype, o.hidden_sectors_set, &bpb) == -1)
-		goto done;
+	    goto done;
 	bpb.bpbHugeSectors -= (o.offset / bpb.bpbBytesPerSec);
 	if (bpb.bpbSecPerClust == 0) {	/* set defaults */
-	    if (bpb.bpbHugeSectors <= 6000)	/* about 3MB -> 512 bytes */
+	    if (o.exfat)
+		bpb.bpbSecPerClust = 32;	    /* EXFAT default is 32 * 4k */
+	    else if (bpb.bpbHugeSectors <= 6000)    /* about 3MB -> 512 bytes */
 		bpb.bpbSecPerClust = 1;
 	    else if (bpb.bpbHugeSectors <= (1<<17)) /* 64M -> 4k */
 		bpb.bpbSecPerClust = 8;
@@ -354,11 +1488,13 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	goto done;
     }
 
-    if (o.volume_label && !oklabel(o.volume_label)) {
+    if (!o.exfat && !oklabel(o.volume_label)) {
 	warnx("%s: bad volume label", o.volume_label);
 	goto done;
     }
-    if (!(fat = o.fat_type)) {
+    if (o.exfat) {
+	fat = 32;
+    } else if (!(fat = o.fat_type)) {
 	if (o.floppy)
 	    fat = 12;
 	else if (!o.directory_entries && (o.info_sector || o.backup_sector))
@@ -377,6 +1513,7 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	goto done;
     }
 
+    maxspc = o.exfat ? MAXBPC_EX / bpb.bpbBytesPerSec : MAXSPC;
     if (o.block_size) {
 	if (!powerof2(o.block_size)) {
 	    warnx("block size (%u) is not a power of 2", o.block_size);
@@ -387,9 +1524,9 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 		 o.block_size, bpb.bpbBytesPerSec);
 	    goto done;
 	}
-	if (o.block_size > bpb.bpbBytesPerSec * MAXSPC) {
+	if (o.block_size > bpb.bpbBytesPerSec * maxspc) {
 	    warnx("block size (%u) is too large; maximum is %u",
-		 o.block_size, bpb.bpbBytesPerSec * MAXSPC);
+		 o.block_size, bpb.bpbBytesPerSec * maxspc);
 	    goto done;
 	}
 	bpb.bpbSecPerClust = o.block_size / bpb.bpbBytesPerSec;
@@ -403,11 +1540,12 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	bpb.bpbSecPerClust = o.sectors_per_cluster;
     }
     if (o.reserved_sectors)
-	bpb.bpbResSectors = o.reserved_sectors;
+	    bpb.bpbResSectors = o.reserved_sectors;
+    maxnft = o.exfat ? MAXNFT_EX : MAXNFT;
     if (o.num_FAT) {
-	if (o.num_FAT > MAXNFT) {
+	    if (o.num_FAT > maxnft) {
 	    warnx("number of FATs (%u) is too large; maximum is %u",
-		 o.num_FAT, MAXNFT);
+		 o.num_FAT, maxnft);
 	    goto done;
 	}
 	bpb.bpbFATs = o.num_FAT;
@@ -429,8 +1567,12 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	bpb.bpbBigFATsecs = o.sectors_per_fat;
     if (o.info_sector)
 	bpb.bpbFSInfo = o.info_sector;
-    if (o.backup_sector)
+    if (o.exfat) {
+	bpb.bpbBackup = BACKUPSECOFS;
+	bpb.bpbResSectors = 2 * BACKUPSECOFS;
+    } else if (o.backup_sector) {
 	bpb.bpbBackup = o.backup_sector;
+    }
     bss = 1;
     bname = NULL;
     fd1 = -1;
@@ -453,7 +1595,7 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	bss = sb.st_size / bpb.bpbBytesPerSec;
     }
     if (!bpb.bpbFATs)
-	bpb.bpbFATs = 2;
+	bpb.bpbFATs = o.exfat ? 1 : 2;
     if (!fat) {
 	if (bpb.bpbHugeSectors < (bpb.bpbResSectors ? bpb.bpbResSectors : bss) +
 	    howmany((RESFTE + (bpb.bpbSecPerClust ? MINCLS16 : MAXCLS12 + 1)) *
@@ -479,7 +1621,7 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	    fat = 32;
     }
     x = bss;
-    if (fat == 32) {
+    if (fat == 32 && !o.exfat) {
 	if (!bpb.bpbFSInfo) {
 	    if (x == MAXU16 || x == bpb.bpbBackup) {
 		warnx("no room for info sector");
@@ -533,10 +1675,10 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	    bpb.bpbRootDirEnts = DEFRDE;
 	rds = howmany(bpb.bpbRootDirEnts,
 	    bpb.bpbBytesPerSec / sizeof(struct de));
+	defblk = fat == 16 ? DEFBLK16 : (o.exfat ? DEFBLK_EX : DEFBLK);
 	if (set_spc) {
-	    for (bpb.bpbSecPerClust = howmany(fat == 16 ? DEFBLK16 :
-		    DEFBLK, bpb.bpbBytesPerSec);
-		bpb.bpbSecPerClust < MAXSPC && (bpb.bpbResSectors +
+	    for (bpb.bpbSecPerClust = howmany(defblk, bpb.bpbBytesPerSec);
+		bpb.bpbSecPerClust < maxspc && (bpb.bpbResSectors +
 		    howmany((RESFTE + maxcls(fat)) * (fat / BPN),
 			bpb.bpbBytesPerSec * NPB) * bpb.bpbFATs +
 		    rds +
@@ -590,7 +1732,7 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
     if (bpb.bpbBigFATsecs < x2)
 	warnx("warning: sectors/FAT limits file system to %u clusters",
 	      cls);
-    if (cls < mincls(fat)) {
+    if (!o.exfat && cls < mincls(fat)) {
 	warnx("%u clusters too few clusters for FAT%u, need %u", cls, fat,
 	    mincls(fat));
 	goto done;
@@ -598,18 +1740,37 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
     if (cls > maxcls(fat)) {
 	cls = maxcls(fat);
 	bpb.bpbHugeSectors = x1 + (cls + 1) * bpb.bpbSecPerClust - 1;
-	warnx("warning: FAT type limits file system to %u sectors",
+	warnx("warning: FAT type limits file system to %lu sectors",
 	      bpb.bpbHugeSectors);
     }
     printf("%s: %u sector%s in %u FAT%u cluster%s "
 	   "(%u bytes/cluster)\n", fname, cls * bpb.bpbSecPerClust,
 	   cls * bpb.bpbSecPerClust == 1 ? "" : "s", cls, fat,
 	   cls == 1 ? "" : "s", bpb.bpbBytesPerSec * bpb.bpbSecPerClust);
+    if (o.exfat) {
+	bpb.bpbBPSshift = fls(bpb.bpbBytesPerSec) - 1;
+	bpb.bpbSPCshift = fls(bpb.bpbSecPerClust) - 1;
+	bpb.bpbClusterHeapOffset = howmany(bpb.bpbResSectors + bpb.bpbFATs * bpb.bpbBigFATsecs,
+		bpb.bpbSecPerClust) * bpb.bpbSecPerClust;
+	bpb.bpbClusterCount = (bpb.bpbHugeSectors - bpb.bpbClusterHeapOffset) >> bpb.bpbSPCshift;
+	bpb.bpbUpcaseTableSectors = howmany(sizeof(compr_upcase_table),
+	    bpb.bpbBytesPerSec);
+	bpb.bpbUsedBitmapSectors = howmany(howmany(bpb.bpbClusterCount, 8),
+	    bpb.bpbBytesPerSec);
+        bpb.bpbUsedBitmapClust1 = RESFTE;
+        bpb.bpbUsedBitmapClust2 = bpb.bpbUsedBitmapClust1 +
+	    (bpb.bpbFATs == 2 ? howmany(bpb.bpbUsedBitmapSectors, bpb.bpbSecPerClust) : 0);
+	bpb.bpbUpcaseTableClust = bpb.bpbUsedBitmapClust2 +
+	    howmany(bpb.bpbUsedBitmapSectors, bpb.bpbSecPerClust);
+        bpb.bpbRootClust = bpb.bpbUpcaseTableClust +
+	    howmany(bpb.bpbUpcaseTableSectors, bpb.bpbSecPerClust);
+    } else {
+	if (fat == 32)
+	   bpb.bpbRootClust = RESFTE;
+    }
     if (!bpb.bpbMedia)
 	bpb.bpbMedia = !bpb.bpbHiddenSecs ? 0xf0 : 0xf8;
-    if (fat == 32)
-	bpb.bpbRootClust = RESFTE;
-    if (bpb.bpbHugeSectors <= MAXU16) {
+    if (!o.exfat && bpb.bpbHugeSectors <= MAXU16) {
 	bpb.bpbSectors = bpb.bpbHugeSectors;
 	bpb.bpbHugeSectors = 0;
     }
@@ -628,6 +1789,13 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	    now = tv.tv_sec;
 	    tm = localtime(&now);
 	}
+	if (!o.volume_id_set)
+	    o.volume_id = (((u_int)(1 + tm->tm_mon) << 8 |
+	        (u_int)tm->tm_mday) + ((u_int)tm->tm_sec << 8 |
+		(u_int)(tv.tv_usec / 10))) << 16 |
+		((u_int)(1900 + tm->tm_year) +
+		    ((u_int)tm->tm_hour << 8 |
+	        (u_int)tm->tm_min));
 
 	chunksize = getchunksize();
 	physbuf = malloc(chunksize);
@@ -638,8 +1806,12 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 	physbuf_end = physbuf + chunksize;
 	img = physbuf;
 
-	dir = bpb.bpbResSectors + (bpb.bpbFATsecs ? bpb.bpbFATsecs :
-				   bpb.bpbBigFATsecs) * bpb.bpbFATs;
+	if (o.exfat)
+	    dir = bpb.bpbClusterHeapOffset +
+		((bpb.bpbRootClust - RESFTE) << bpb.bpbSPCshift);
+	else
+	    dir = bpb.bpbResSectors +
+		(bpb.bpbFATsecs ? bpb.bpbFATsecs : bpb.bpbBigFATsecs) * bpb.bpbFATs;
 	memset(&si_sa, 0, sizeof(si_sa));
 	si_sa.sa_handler = infohandler;
 #ifdef SIGINFO
@@ -678,6 +1850,10 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 		}
 	    } else
 		memset(img, 0, bpb.bpbBytesPerSec);
+	    if (o.exfat) {
+		fill_exfat_buffer(img, lsn, &bpb, op);
+		goto secfilled;
+	    }
 	    if (!lsn ||
 		(fat == 32 && bpb.bpbBackup != MAXU16 &&
 		 lsn == bpb.bpbBackup)) {
@@ -708,17 +1884,8 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 		}
 		bsx = (struct bsx *)(img + x1);
 		mk1(bsx->exBootSignature, 0x29);
-		if (o.volume_id_set)
-		    x = o.volume_id;
-		else
-		    x = (((u_int)(1 + tm->tm_mon) << 8 |
-			  (u_int)tm->tm_mday) +
-			 ((u_int)tm->tm_sec << 8 |
-			  (u_int)(tv.tv_usec / 10))) << 16 |
-			((u_int)(1900 + tm->tm_year) +
-			 ((u_int)tm->tm_hour << 8 |
-			  (u_int)tm->tm_min));
-		mk4(bsx->exVolumeID, x);
+		x = o.volume_id;
+		mk4(bsx->exVolumeID, o.volume_id);
 		mklabel(bsx->exVolumeLabel, o.volume_label ? o.volume_label : "NO NAME");
 		snprintf(buf, sizeof(buf), "FAT%u", fat);
 		setstr(bsx->exFileSysType, buf, sizeof(bsx->exFileSysType));
@@ -762,6 +1929,7 @@ mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
 		    (u_int)tm->tm_mday;
 		mk2(de->deMDate, x);
 	    }
+secfilled:
 	    /*
 	     * Issue a write of chunksize once we have collected
 	     * enough sectors.
@@ -1028,7 +2196,7 @@ print_bpb(struct bpb *bpb)
     printf(" SecPerTrack=%u Heads=%u HiddenSecs=%u", bpb->bpbSecPerTrack,
 	   bpb->bpbHeads, bpb->bpbHiddenSecs);
     if (bpb->bpbHugeSectors)
-	printf(" HugeSectors=%u", bpb->bpbHugeSectors);
+	printf(" HugeSectors=%llu", (unsigned long long)bpb->bpbHugeSectors);
     if (!bpb->bpbFATsecs) {
 	printf(" FATsecs=%u RootCluster=%u", bpb->bpbBigFATsecs,
 	       bpb->bpbRootClust);
@@ -1073,6 +2241,21 @@ oklabel(const char *src)
     return i && !c;
 }
 
+static int
+exfat_oklabel(const u_int8_t *src, int len)
+{
+    int i;
+    u_int16_t c;
+
+    for (i = 0; i < len; i++) {
+	c = src[0] + (src[1] << 8);
+	if (c < ' ' || (c <= 0xff && strchr("\"*/:<>?[\\]|", c)))
+	    break;
+	src += 2;
+    }
+    return (i == len);
+}
+
 /*
  * Make a volume label.
  */
diff --git a/sbin/newfs_msdos/mkfs_msdos.h b/sbin/newfs_msdos/mkfs_msdos.h
index 6e5bad0da8f0..0a27f66d7dd5 100644
--- a/sbin/newfs_msdos/mkfs_msdos.h
+++ b/sbin/newfs_msdos/mkfs_msdos.h
@@ -55,7 +55,7 @@ AOPT('m', uint8_t, media_descriptor, 0, "Media descriptor") \
 AOPT('n', uint8_t, num_FAT, 1, "Number of FATs") \
 AOPT('o', uint32_t, hidden_sectors, 0, "Hidden sectors") \
 AOPT('r', uint16_t, reserved_sectors, 1, "Reserved sectors") \
-AOPT('s', uint32_t, size, 1, "File System size") \
+AOPT('s', uint64_t, size, 1, "File System size") \
 AOPT('u', uint16_t, sectors_per_track, 1, "Sectors per track")
 
 struct msdos_options {
@@ -66,6 +66,7 @@ ALLOPTS
 	uint32_t volume_id_set:1;
 	uint32_t media_descriptor_set:1;
 	uint32_t hidden_sectors_set:1;
+	uint32_t exfat:1;
 };
 
 int mkfs_msdos(const char *, const char *, const struct msdos_options *);
diff --git a/sbin/newfs_msdos/newfs_msdos.8 b/sbin/newfs_msdos/newfs_msdos.8
index 03dfbfced51f..6da75696f159 100644
--- a/sbin/newfs_msdos/newfs_msdos.8
+++ b/sbin/newfs_msdos/newfs_msdos.8
@@ -23,12 +23,13 @@
 .\" OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 .\" IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 .\"
-.Dd June 6, 2024
+.Dd August 5, 2025
 .Dt NEWFS_MSDOS 8
 .Os
 .Sh NAME
-.Nm newfs_msdos
-.Nd construct a new MS-DOS (FAT) file system
+.Nm newfs_msdos ,
+.Nm newfs_exfat
+.Nd construct a new FAT or exFAT file system
 .Sh SYNOPSIS
 .Nm
 .Op Fl N
@@ -58,10 +59,28 @@
 .Op Fl u Ar track-size
 .Ar special
 .Op Ar disktype
+.Nm newfs_exfat
+.Op Fl N
+.Op Fl @ Ar offset
+.Op Fl A
+.Op Fl B Ar boot
+.Op Fl C Ar create-size
+.Op Fl I Ar VolumeID
+.Op Fl L Ar label
+.Op Fl S Ar sector-size
+.Op Fl T Ar timestamp
+.Op Fl a Ar FAT-size
+.Op Fl b Ar block-size
+.Op Fl c Ar cluster-size
+.Op Fl n Ar FATs
+.Op Fl s Ar total
+.Ar special
+.Op Ar disktype
 .Sh DESCRIPTION
 The
 .Nm
-utility creates a FAT12, FAT16, or FAT32 file system on device or file named
+utility creates a FAT12, FAT16, FAT32, or exFAT file system on device or file
+named
 .Ar special ,
 using
 .Xr disktab 5
@@ -222,11 +241,13 @@ struct bsxbpb {
 };
 .Ed
 .Sh LIMITATION
-The maximum file size is 4GB, even if the file system itself is bigger.
+The maximum size of a file on a FAT file system is 4GB, even if the file system
+itself is bigger.
+This limitation does not apply to exFAT file systems.
 .Sh EXIT STATUS
 Exit status is 0 on success and 1 on error.
 .Sh EXAMPLES
-Create a file system, using default parameters, on
+Create a FAT file system, using default parameters, on
 .Pa /dev/ada0s1 :
 .Bd -literal -offset indent
 newfs_msdos /dev/ada0s1
@@ -251,6 +272,13 @@ Create a 30MB image file, with the FAT partition starting
 .Bd -literal -offset indent
 newfs_msdos -C 30M -@63s ./somefile
 .Ed
+.Pp
+Create a 300MB exFAT image file with a block size of 65536
+bytes:
+.Bd -literal -offset indent
+newfs_exfat -C 300M -b 65536 /tmp/1.raw
+.Ed
+.Pp
 .Sh SEE ALSO
 .Xr msdosfs 4 ,
 .Xr gpart 8 ,
@@ -260,5 +288,9 @@ The
 .Nm
 utility first appeared in
 .Fx 3.0 .
+Support for the creation of exFAT file systems has been
+introduced in
+.Fx 15.0 .
 .Sh AUTHORS
 .An Robert Nordier Aq Mt rnordier@FreeBSD.org
+.An Stefan Eßer Aq Mt se@FreeBSD.org
diff --git a/sbin/newfs_msdos/newfs_msdos.c b/sbin/newfs_msdos/newfs_msdos.c
index 312a862d9113..08c23c203057 100644
--- a/sbin/newfs_msdos/newfs_msdos.c
+++ b/sbin/newfs_msdos/newfs_msdos.c
@@ -31,6 +31,7 @@
 #include <sys/stat.h>
 #include <err.h>
 #include <errno.h>
+#include <libgen.h>
 #include <paths.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -42,12 +43,15 @@
 #define	argto1(arg, lo, msg)  argtou(arg, lo, 0xff, msg)
 #define	argto2(arg, lo, msg)  argtou(arg, lo, 0xffff, msg)
 #define	argto4(arg, lo, msg)  argtou(arg, lo, 0xffffffff, msg)
+#define	argto8(arg, lo, msg)  argtou(arg, lo, 0xffffffffffffffff, msg)
 #define	argtox(arg, lo, msg)  argtou(arg, lo, UINT_MAX, msg)
 
-static u_int argtou(const char *, u_int, u_int, const char *);
+static u_quad_t argtou(const char *, u_int, u_quad_t, const char *);
 static off_t argtooff(const char *, const char *);
 static void usage(void) __dead2;
 
+static const char *fsopts;
+
 static time_t
 get_tstamp(const char *b)
 {
@@ -66,12 +70,22 @@ get_tstamp(const char *b)
 }
 
 /*
+ * Check whether invoked as newfs_exfat.
+ */
+static int
+check_exfat(char *argv0)
+{
+	return (strstr(basename(argv0), "exfat") != NULL);
+}
+
+/*
  * Construct a FAT12, FAT16, or FAT32 file system.
  */
 int
 main(int argc, char *argv[])
 {
-    static const char opts[] = "@:NAB:C:F:I:L:O:S:a:b:c:e:f:h:i:k:m:n:o:r:s:T:u:";
+    static const char fatopts[] = "@:NAB:C:F:I:L:O:S:T:a:b:c:e:f:h:i:k:m:n:o:r:s:u:";
+    static const char exfatopts[] = "@:NAB:C:I:L:S:T:a:b:c:n:s:";
     struct msdos_options o;
     const char *fname, *dtype;
     char buf[MAXPATHLEN];
@@ -79,7 +93,10 @@ main(int argc, char *argv[])
 
     memset(&o, 0, sizeof(o));
 
-    while ((ch = getopt(argc, argv, opts)) != -1)
+    o.exfat = check_exfat(argv[0]);
+    fsopts = o.exfat ? exfatopts : fatopts;
+
+    while ((ch = getopt(argc, argv, fsopts)) != -1)
 	switch (ch) {
 	case '@':
 	    o.offset = argtooff(optarg, "offset");
@@ -157,7 +174,7 @@ main(int argc, char *argv[])
 	    o.reserved_sectors = argto2(optarg, 1, "reserved sectors");
 	    break;
 	case 's':
-	    o.size = argto4(optarg, 1, "file system size");
+	    o.size = argto8(optarg, 1, "file system size");
 	    break;
 	case 'T':
 	    o.timestamp_set = 1;
@@ -189,14 +206,14 @@ main(int argc, char *argv[])
 /*
  * Convert and check a numeric option argument.
  */
-static u_int
-argtou(const char *arg, u_int lo, u_int hi, const char *msg)
+static u_quad_t
+argtou(const char *arg, u_int lo, u_quad_t hi, const char *msg)
 {
     char *s;
-    u_long x;
+    u_quad_t x;
 
     errno = 0;
-    x = strtoul(arg, &s, 0);
+    x = strtoull(arg, &s, 0);
     if (errno || !*arg || *s || x < lo || x > hi)
 	errx(1, "%s: bad %s", arg, msg);
     return x;
@@ -271,6 +288,7 @@ ALLOPTS
 #undef AOPT
     };
     for (size_t i = 0; i < nitems(opts); i++)
-	fprintf(stderr, "\t-%c %s\n", opts[i].o, opts[i].h);
+	if (strchr(fsopts, opts[i].o) != NULL)
+	    fprintf(stderr, "\t-%c %s\n", opts[i].o, opts[i].h);
     exit(1);
 }