diff --git a/icu4c/source/common/filterednormalizer2.cpp b/icu4c/source/common/filterednormalizer2.cpp
index 28e5f6cbdde..eef199797c1 100644
--- a/icu4c/source/common/filterednormalizer2.cpp
+++ b/icu4c/source/common/filterednormalizer2.cpp
@@ -20,11 +20,13 @@
 
 #if !UCONFIG_NO_NORMALIZATION
 
+#include "unicode/edits.h"
 #include "unicode/normalizer2.h"
 #include "unicode/uniset.h"
 #include "unicode/unistr.h"
 #include "unicode/unorm.h"
 #include "cpputils.h"
+#include "ustr_imp.h"  // U_EDITS_NO_RESET
 
 U_NAMESPACE_BEGIN
 
@@ -85,6 +87,52 @@ FilteredNormalizer2::normalize(const UnicodeString &src,
     return dest;
 }
 
+void
+FilteredNormalizer2::normalizeUTF8(uint32_t options, StringPiece src, ByteSink &sink,
+                                   Edits *edits, UErrorCode &errorCode) const {
+    if (U_FAILURE(errorCode)) {
+        return;
+    }
+    if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
+        edits->reset();
+    }
+    options |= U_EDITS_NO_RESET;  // Do not reset for each span.
+    normalizeUTF8(options, src.data(), src.length(), sink, edits, USET_SPAN_SIMPLE, errorCode);
+}
+
+void
+FilteredNormalizer2::normalizeUTF8(uint32_t options, const char *src, int32_t length,
+                                   ByteSink &sink, Edits *edits,
+                                   USetSpanCondition spanCondition,
+                                   UErrorCode &errorCode) const {
+    while (length > 0) {
+        int32_t spanLength = set.spanUTF8(src, length, spanCondition);
+        if (spanCondition == USET_SPAN_NOT_CONTAINED) {
+            if (spanLength != 0) {
+                if (edits != nullptr) {
+                    edits->addUnchanged(spanLength);
+                }
+                if ((options & U_OMIT_UNCHANGED_TEXT) == 0) {
+                    sink.Append(src, spanLength);
+                }
+            }
+            spanCondition = USET_SPAN_SIMPLE;
+        } else {
+            if (spanLength != 0) {
+                // Not norm2.normalizeSecondAndAppend() because we do not want
+                // to modify the non-filter part of dest.
+                norm2.normalizeUTF8(options, StringPiece(src, spanLength), sink, edits, errorCode);
+                if (U_FAILURE(errorCode)) {
+                    break;
+                }
+            }
+            spanCondition = USET_SPAN_NOT_CONTAINED;
+        }
+        src += spanLength;
+        length -= spanLength;
+    }
+}
+
 UnicodeString &
 FilteredNormalizer2::normalizeSecondAndAppend(UnicodeString &first,
                                               const UnicodeString &second,
diff --git a/icu4c/source/common/loadednormalizer2impl.cpp b/icu4c/source/common/loadednormalizer2impl.cpp
index 0a4bef4adf7..288a7d69536 100644
--- a/icu4c/source/common/loadednormalizer2impl.cpp
+++ b/icu4c/source/common/loadednormalizer2impl.cpp
@@ -62,7 +62,7 @@ LoadedNormalizer2Impl::isAcceptable(void * /*context*/,
         pInfo->dataFormat[1]==0x72 &&
         pInfo->dataFormat[2]==0x6d &&
         pInfo->dataFormat[3]==0x32 &&
-        pInfo->formatVersion[0]==2
+        pInfo->formatVersion[0]==3
     ) {
         // Normalizer2Impl *me=(Normalizer2Impl *)context;
         // uprv_memcpy(me->dataVersion, pInfo->dataVersion, 4);
@@ -84,7 +84,7 @@ LoadedNormalizer2Impl::load(const char *packageName, const char *name, UErrorCod
     const uint8_t *inBytes=(const uint8_t *)udata_getMemory(memory);
     const int32_t *inIndexes=(const int32_t *)inBytes;
     int32_t indexesLength=inIndexes[IX_NORM_TRIE_OFFSET]/4;
-    if(indexesLength<=IX_MIN_YES_NO_MAPPINGS_ONLY) {
+    if(indexesLength<=IX_MIN_LCCC_CP) {
         errorCode=U_INVALID_FORMAT_ERROR;  // Not enough indexes.
         return;
     }
diff --git a/icu4c/source/common/norm2_nfc_data.h b/icu4c/source/common/norm2_nfc_data.h
index 55a20617f7e..a8e33878dfb 100644
--- a/icu4c/source/common/norm2_nfc_data.h
+++ b/icu4c/source/common/norm2_nfc_data.h
@@ -11,14 +11,15 @@
 
 #ifdef INCLUDED_FROM_NORMALIZER2_CPP
 
-static const UVersionInfo norm2_nfc_data_formatVersion={2,0,0,0};
+static const UVersionInfo norm2_nfc_data_formatVersion={3,0,0,0};
 static const UVersionInfo norm2_nfc_data_dataVersion={0xa,0,0,0};
 
 static const int32_t norm2_nfc_data_indexes[Normalizer2Impl::IX_COUNT]={
-0x40,0x4c48,0x889c,0x899c,0x899c,0x899c,0x899c,0x899c,0xc0,0x300,0x56e,0x14e7,0x1e2a,0xfe00,0x941,0
+0x50,0x4cc0,0x8918,0x8a18,0x8a18,0x8a18,0x8a18,0x8a18,0xc0,0x300,0xadc,0x29d0,0x3c56,0xfc00,0x1282,0x3b8c,
+0x3c24,0x3c56,0x300,0
 };
 
-static const uint16_t norm2_nfc_data_trieIndex[9724]={
+static const uint16_t norm2_nfc_data_trieIndex[9776]={
 0x2a8,0x2b0,0x2b8,0x2c0,0x2ce,0x2d6,0x2de,0x2e6,0x2ee,0x2f6,0x2fe,0x306,0x30e,0x316,0x31c,0x324,
 0x32c,0x334,0x2c7,0x2cf,0x339,0x341,0x2c7,0x2cf,0x349,0x351,0x359,0x361,0x369,0x371,0x379,0x381,
 0x389,0x391,0x399,0x3a1,0x3a9,0x3b1,0x3b9,0x3c1,0x2c7,0x2cf,0x2c7,0x2cf,0x3c8,0x3d0,0x3d8,0x3e0,
@@ -105,29 +106,29 @@ static const uint16_t norm2_nfc_data_trieIndex[9724]={
 0x2c7,0x2c7,0x2c7,0x6e5,0x6ed,0x2c7,0x2c7,0x6f5,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
 0x6fc,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x703,0x70b,0x2c7,0x711,0x715,0x2c7,0x2c7,0x58b,0x71d,0x2c7,
 0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x721,0x729,0x72c,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x48b,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,
-0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x959,0x960,0x2c7,0x2c7,
-0x968,0x96f,0x2a8,0x976,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,
+0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,
+0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,
+0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,
+0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,
+0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,
+0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,
+0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,
+0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,
+0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,
+0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,
+0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,
+0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,
+0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,
+0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,
+0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,
+0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,
+0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,
+0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,
+0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,
+0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,
+0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,
+0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x965,0x2c7,0x2c7,
+0x975,0x97c,0x2a8,0x983,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,
 0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,
 0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
 0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
@@ -189,447 +190,450 @@ static const uint16_t norm2_nfc_data_trieIndex[9724]={
 0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
 0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
 0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2a7,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,2,4,6,0,
-0,8,0x28,0x2e,0x38,0x44,0x66,0x68,0x76,0x84,0xa2,0xa4,0xae,0xba,0xc0,0xd2,
-0xf2,0,0xf6,0x106,0x114,0x122,0x148,0x14c,0x158,0x15c,0x16e,0,0,0,0,0,
-0,0x17a,0x19a,0x1a0,0x1aa,0x1b6,0x1d8,0x1da,0x1e8,0x1f8,0x214,0x218,0x222,0x22e,0x234,0x246,
-0x266,0,0x26a,0x27a,0x288,0x298,0x2be,0x2c2,0x2d0,0x2d4,0x2e8,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x2f4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x941,0x944,0x56f,0x947,0x57a,0x57f,0x2fa,0x584,
-0x94a,0x94d,0x589,0x950,0x953,0x956,0x959,0x594,0,0x95c,0x95f,0x962,0x599,0x5a4,0x5ad,0,
-0x2fe,0x965,0x968,0x96b,0x5b2,0x96e,0,0,0x971,0x974,0x5bd,0x977,0x5c8,0x5cd,0x300,0x5d2,
-0x97a,0x97d,0x5d7,0x980,0x983,0x986,0x989,0x5e2,0,0x98c,0x98f,0x992,0x5e7,0x5f2,0x5fb,0,
-0x304,0x995,0x998,0x99b,0x600,0x99e,0,0x9a1,0x9a4,0x9a7,0x60b,0x616,0x9aa,0x9ad,0x9b0,0x9b3,
-0x9b6,0x9b9,0x9bc,0x9bf,0x9c2,0x9c5,0x9c8,0x9cb,0,0,0x621,0x628,0x9ce,0x9d1,0x9d4,0x9d7,
-0x9da,0x9dd,0x9e0,0x9e3,0x9e6,0x9e9,0x9ec,0x9ef,0x9f2,0x9f5,0x9f8,0x9fb,0x9fe,0xa01,0,0,
-0xa04,0xa07,0xa0a,0xa0d,0xa10,0xa13,0xa16,0xa19,0xa1c,0,0,0,0xa1f,0xa22,0xa25,0xa28,
-0,0xa2b,0xa2e,0xa31,0xa34,0xa37,0xa3a,0,0,0,0,0xa3d,0xa40,0xa43,0xa46,0xa49,
-0xa4c,0,0,0,0x62f,0x636,0xa4f,0xa52,0xa55,0xa58,0,0,0xa5b,0xa5e,0xa61,0xa64,
-0xa67,0xa6a,0x63d,0x642,0xa6d,0xa70,0xa73,0xa76,0x647,0x64c,0xa79,0xa7c,0xa7f,0xa82,0,0,
-0x651,0x656,0x65b,0x660,0xa85,0xa88,0xa8b,0xa8e,0xa91,0xa94,0xa97,0xa9a,0xa9d,0xaa0,0xaa3,0xaa6,
-0xaa9,0xaac,0xaaf,0xab2,0xab5,0xab8,0xabb,0x306,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x665,0x672,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0x67f,0x68c,0,0,0,0,0,0,0x308,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0xabe,0xac1,0xac4,
-0xac7,0xaca,0xacd,0xad0,0xad3,0xad7,0xadc,0xae1,0xae6,0xaeb,0xaf0,0xaf5,0xafa,0,0xaff,0xb04,
-0xb09,0xb0e,0xb12,0xb15,0,0,0xb18,0xb1b,0xb1e,0xb21,0x699,0x69e,0xb25,0xb2a,0xb2e,0xb31,
-0xb34,0,0,0,0xb37,0xb3a,0,0,0xb3d,0xb40,0xb44,0xb49,0xb4d,0xb50,0xb53,0xb56,
-0xb59,0xb5c,0xb5f,0xb62,0xb65,0xb68,0xb6b,0xb6e,0xb71,0xb74,0xb77,0xb7a,0xb7d,0xb80,0xb83,0xb86,
-0xb89,0xb8c,0xb8f,0xb92,0xb95,0xb98,0xb9b,0xb9e,0xba1,0xba4,0xba7,0xbaa,0,0,0xbad,0xbb0,
-0,0,0,0,0,0,0x6a3,0x6a8,0x6ad,0x6b2,0xbb4,0xbb9,0xbbe,0xbc3,0x6b7,0x6bc,
-0xbc8,0xbcd,0xbd1,0xbd4,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0x30a,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xfee6,0xfee6,0xfee6,0xfee6,0xfee6,0xffe6,0xfee6,0xfee6,0xfee6,0xfee6,0xfee6,0xfee6,
-0xfee6,0xffe6,0xffe6,0xfee6,0xffe6,0xfee6,0xffe6,0xfee6,0xfee6,0xffe8,0xffdc,0xffdc,0xffdc,0xffdc,0xffe8,0xfed8,
-0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffca,0xffca,0xfedc,0xfedc,0xfedc,0xfedc,0xfeca,0xfeca,0xffdc,0xffdc,0xffdc,
-0xffdc,0xfedc,0xfedc,0xffdc,0xfedc,0xfedc,0xffdc,0xffdc,0xff01,0xff01,0xff01,0xff01,0xfe01,0xffdc,0xffdc,0xffdc,
-0xffdc,0xffe6,0xffe6,0xffe6,0x14e8,0x14eb,0xfee6,0x14ee,0x14f1,0xfef0,0xffe6,0xffdc,0xffdc,0xffdc,0xffe6,0xffe6,
-0xffe6,0xffdc,0xffdc,0,0xffe6,0xffe6,0xffe6,0xffdc,0xffdc,0xffdc,0xffdc,0xffe6,0xffe8,0xffdc,0xffdc,0xffe6,
-0xffe9,0xffea,0xffea,0xffe9,0xffea,0xffea,0xffe9,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0,0,0,0,0x14f4,0,0,0,0,0,0,0,
-0,0,0x14f6,0,0,0,0,0,0,0xbd7,0xbda,0x14f8,0xbdd,0xbe0,0xbe3,0,
-0xbe6,0,0xbe9,0xbec,0xbf0,0x30c,0,0,0,0x31a,0,0x322,0,0x32c,0,0,
-0,0,0,0x33a,0,0x342,0,0,0,0x344,0,0,0,0x350,0xbf4,0xbf7,
-0x6c1,0xbfa,0x6c6,0xbfd,0xc01,0x35a,0,0,0,0x36a,0,0x372,0,0x37e,0,0,
-0,0,0,0x38e,0,0x396,0,0,0,0x39a,0,0,0,0x3aa,0x6cb,0x6d4,
-0xc05,0xc08,0x6dd,0,0,0,0x3b6,0xc0b,0xc0e,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xc11,0xc14,0,0xc17,0,0,0x3ba,0xc1a,0,0,0,0,
-0xc1d,0xc20,0xc23,0,0x3bc,0,0,0x3c0,0,0x3c2,0x3c8,0x3cc,0x3ce,0xc26,0x3d6,0,
-0,0,0x3d8,0,0,0,0,0x3da,0,0,0,0x3e2,0,0,0,0x3e4,
-0,0x3e6,0,0,0x3e8,0,0,0x3ec,0,0x3ee,0x3f4,0x3f8,0x3fa,0xc29,0x402,0,
-0,0,0x404,0,0,0,0,0x406,0,0,0,0x40e,0,0,0,0x410,
-0,0x412,0,0,0xc2c,0xc2f,0,0xc32,0,0,0x414,0xc35,0,0,0,0,
-0xc38,0xc3b,0xc3e,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x416,0x418,0xc41,0xc44,0,0,0,0,
-0,0,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0xc47,0xc4a,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xc4d,0xc50,0xc53,0xc56,0,0,0xc59,0xc5c,0x41a,0x41c,0xc5f,0xc62,
-0xc65,0xc68,0xc6b,0xc6e,0,0,0xc71,0xc74,0xc77,0xc7a,0xc7d,0xc80,0x41e,0x420,0xc83,0xc86,
-0xc89,0xc8c,0xc8f,0xc92,0xc95,0xc98,0xc9b,0xc9e,0xca1,0xca4,0,0,0xca7,0xcaa,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xffdc,0xffe6,0xffe6,0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffe6,0xffde,0xffdc,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffde,0xffe4,0xffe6,
-0xff0a,0xff0b,0xff0c,0xff0d,0xff0e,0xff0f,0xff10,0xff11,0xff12,0xff13,0xff13,0xff14,0xff15,0xff16,0,0xff17,
-0,0xff18,0xff19,0,0xffe6,0xffdc,0,0xff12,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xff1e,0xff1f,0xff20,0,0,0,0,0,
-0,0,0xcad,0xcb0,0xcb3,0xcb6,0xcb9,0x422,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x428,0,0x42a,0xff1b,0xff1c,0xff1d,0xff1e,0xff1f,0xff20,0xff21,0xff22,0xfee6,0xfee6,0xfedc,0xffdc,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffdc,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xff23,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xcbc,0x42c,0xcbf,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x42e,0xcc2,0,0x430,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffdc,0xffe6,0,0,0xffe6,
-0xffe6,0,0xffdc,0xffe6,0xffe6,0xffdc,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xff24,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xffe6,0xffdc,0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffdc,
-0xffdc,0xffdc,0xffe6,0xffdc,0xffdc,0xffe6,0xffdc,0xffe6,0xffe6,0xffe6,0xffdc,0xffe6,0xffdc,0xffe6,0xffdc,0xffe6,
-0xffdc,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffdc,0xffe6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0,0xffe6,0xffe6,0xffe6,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xffdc,0xffdc,0xffdc,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0xffdc,
-0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffe6,0xffdc,0xffdc,0xffdc,0xff1b,0xff1c,0xff1d,0xffe6,
-0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffdc,0xffdc,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,0,0,
-0,0,0,0,0x432,0xcc5,0,0,0,0,0,0,0x434,0xcc8,0,0x436,
-0xccb,0,0,0,0,0,0,0,0xfe07,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xff09,0,0,0,0xffe6,0xffdc,0xffe6,
-0xffe6,0,0,0,0x14fa,0x14fd,0x1500,0x1503,0x1506,0x1509,0x150c,0x150f,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xff07,0,0xfe00,0,0,0,0,0,
-0,0,0,0x438,0,0,0,0xcce,0xcd1,0xff09,0,0,0,0,0,0,
-0,0,0,0xfe00,0,0,0,0,0x1512,0x1515,0,0x1518,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x151b,
-0,0,0x151e,0,0,0,0,0,0xff07,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xff09,0,0,0,0,0,0,
-0,0,0,0,0,0x1521,0x1524,0x1527,0,0,0x152a,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xff07,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xff09,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x43c,
-0xcd4,0,0,0xcd7,0xcda,0xff09,0,0,0,0,0,0,0,0,0xfe00,0xfe00,
-0,0,0,0,0x152d,0x1530,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x442,0,0xcdd,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xfe00,0,
-0,0,0,0,0,0,0x444,0x448,0,0,0xce0,0xce3,0xce6,0xff09,0,0,
-0,0,0,0,0,0,0,0xfe00,0,0,0,0,0,0,0,0,
-0,0,0x44a,0,0xce9,0,0,0,0,0xff09,0,0,0,0,0,0,
-0,0xff54,0xfe5b,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xff07,0,0,0x44c,0xcec,0,0xfe00,0,0,0,0x44e,0xcef,0xcf2,0,0x6e2,0xcf6,
-0,0xff09,0,0,0,0,0,0,0,0xfe00,0xfe00,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xff09,0xff09,0,0xfe00,0,0,0,0,0,
-0,0,0x454,0x458,0,0,0xcfa,0xcfd,0xd00,0xff09,0,0,0,0,0,0,
-0,0,0,0xfe00,0,0,0,0,0,0,0,0,0,0,0xfe09,0,
-0,0,0,0xfe00,0,0,0,0,0,0,0,0,0,0x45a,0xd03,0,
-0x6e7,0xd07,0xd0b,0xfe00,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xff67,0xff67,0xff09,0,
-0,0,0,0,0,0,0,0,0xff6b,0xff6b,0xff6b,0xff6b,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xff76,0xff76,0,0,0,0,0,0,0,0,0,0,
-0xff7a,0xff7a,0xff7a,0xff7a,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xffdc,0xffdc,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0xffdc,0,0xffdc,0,0xffd8,0,0,0,0,0,0,
-0,0,0,0x1533,0,0,0,0,0,0,0,0,0,0x1536,0,0,
-0,0,0x1539,0,0,0,0,0x153c,0,0,0,0,0x153f,0,0,0,
-0,0,0,0,0,0,0,0,0,0x1542,0,0,0,0,0,0,
-0,0xff81,0xff82,0x1546,0xff84,0x154a,0x154d,0,0x1550,0,0xff82,0xff82,0xff82,0xff82,0,0,
-0xff82,0x1554,0xffe6,0xffe6,0xff09,0,0xffe6,0xffe6,0,0,0,0,0,0,0,0,
-0,0,0,0x1557,0,0,0,0,0,0,0,0,0,0x155a,0,0,
-0,0,0x155d,0,0,0,0,0x1560,0,0,0,0,0x1563,0,0,0,
-0,0,0,0,0,0,0,0,0,0x1566,0,0,0,0,0,0,
-0,0,0xffdc,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0x460,0xd0e,0,
-0,0,0,0,0,0,0xfe00,0,0,0,0,0,0,0,0,0xff07,
-0,0xff09,0xff09,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xffdc,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xffe6,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xff09,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xff09,0,
-0,0,0,0,0,0,0,0,0,0xffe6,0,0,0,0,0,0,
-0,0,0,0,0,0xffe4,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xffde,0xffe6,0xffdc,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0xffe6,0xffdc,0,0,0,
-0,0,0,0,0xff09,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0,0,0xffdc,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffe6,
-0xffe6,0xffdc,0,0,0,0,0,0,0,0x462,0xd11,0x464,0xd14,0x466,0xd17,0x468,
-0xd1a,0x46a,0xd1d,0,0,0x46c,0xd20,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xff07,0xfe00,0,0,
-0,0,0x46e,0xd23,0x470,0xd26,0x472,0x474,0xd29,0xd2c,0x476,0xd2f,0xff09,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0xffe6,0xffdc,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0xff09,0xff09,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0xff07,0,0,0,0,0,
-0,0,0,0,0,0,0xff09,0xff09,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xff07,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xffe6,0xffe6,0xffe6,0,0xff01,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffe6,0xffe6,0xffdc,0xffdc,0xffdc,0xffdc,
-0xffe6,0,0xff01,0xff01,0xff01,0xff01,0xff01,0xff01,0xff01,0,0,0,0,0xffdc,0,0,
-0,0,0,0,0xffe6,0,0,0,0xffe6,0xffe6,0,0,0,0,0,0,
-0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffdc,0xffe6,0xffe6,0xffea,0xffd6,0xffdc,
-0xffca,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe8,0xffe4,0xffe4,0xffdc,0,0xffe6,
-0xffe9,0xffdc,0xffe6,0xffdc,0xd32,0xd35,0xd38,0xd3b,0xd3e,0xd41,0xd44,0xd47,0xd4b,0xd50,0xd54,0xd57,
-0xd5a,0xd5d,0xd60,0xd63,0xd66,0xd69,0xd6c,0xd6f,0xd73,0xd78,0xd7d,0xd82,0xd86,0xd89,0xd8c,0xd8f,
-0xd93,0xd98,0xd9c,0xd9f,0xda2,0xda5,0xda8,0xdab,0xdae,0xdb1,0xdb4,0xdb7,0xdba,0xdbd,0xdc0,0xdc3,
-0xdc6,0xdc9,0xdcd,0xdd2,0xdd6,0xdd9,0xddc,0xddf,0xde2,0xde5,0x6ec,0x6f1,0xde9,0xdee,0xdf2,0xdf5,
-0xdf8,0xdfb,0xdfe,0xe01,0xe04,0xe07,0xe0a,0xe0d,0xe10,0xe13,0xe16,0xe19,0xe1c,0xe1f,0xe22,0xe25,
-0xe29,0xe2e,0xe33,0xe38,0xe3d,0xe42,0xe47,0xe4c,0xe50,0xe53,0xe56,0xe59,0xe5c,0xe5f,0x6f6,0x6fb,
-0xe63,0xe68,0xe6c,0xe6f,0xe72,0xe75,0x700,0x705,0xe79,0xe7e,0xe83,0xe88,0xe8d,0xe92,0xe96,0xe99,
-0xe9c,0xe9f,0xea2,0xea5,0xea8,0xeab,0xeae,0xeb1,0xeb4,0xeb7,0xeba,0xebd,0xec1,0xec6,0xecb,0xed0,
-0xed4,0xed7,0xeda,0xedd,0xee0,0xee3,0xee6,0xee9,0xeec,0xeef,0xef2,0xef5,0xef8,0xefb,0xefe,0xf01,
-0xf04,0xf07,0xf0a,0xf0d,0xf10,0xf13,0xf16,0xf19,0xf1c,0xf1f,0xf22,0xf25,0xf28,0xf2b,0,0xf2e,
-0,0,0,0,0x70a,0x711,0xf31,0xf34,0xf38,0xf3d,0xf42,0xf47,0xf4c,0xf51,0xf56,0xf5b,
-0xf60,0xf65,0xf6a,0xf6f,0xf74,0xf79,0xf7e,0xf83,0xf88,0xf8d,0xf92,0xf97,0x718,0x71d,0xf9b,0xf9e,
-0xfa1,0xfa4,0xfa8,0xfad,0xfb2,0xfb7,0xfbc,0xfc1,0xfc6,0xfcb,0xfd0,0xfd5,0xfd9,0xfdc,0xfdf,0xfe2,
-0x722,0x727,0xfe5,0xfe8,0xfec,0xff1,0xff6,0xffb,0x1000,0x1005,0x100a,0x100f,0x1014,0x1019,0x101e,0x1023,
-0x1028,0x102d,0x1032,0x1037,0x103c,0x1041,0x1046,0x104b,0x104f,0x1052,0x1055,0x1058,0x105c,0x1061,0x1066,0x106b,
-0x1070,0x1075,0x107a,0x107f,0x1084,0x1089,0x108d,0x1090,0x1093,0x1096,0x1099,0x109c,0x109f,0x10a2,0,0,
-0,0,0,0,0x72c,0x737,0x743,0x74a,0x751,0x758,0x75f,0x766,0x76c,0x777,0x783,0x78a,
-0x791,0x798,0x79f,0x7a6,0x7ac,0x7b3,0x10a6,0x10ab,0x10b0,0x10b5,0,0,0x7ba,0x7c1,0x10ba,0x10bf,
-0x10c4,0x10c9,0,0,0x7c8,0x7d3,0x7df,0x7e6,0x7ed,0x7f4,0x7fb,0x802,0x808,0x813,0x81f,0x826,
-0x82d,0x834,0x83b,0x842,0x848,0x851,0x10ce,0x10d3,0x10d8,0x10dd,0x10e2,0x10e7,0x85a,0x863,0x10ec,0x10f1,
-0x10f6,0x10fb,0x1100,0x1105,0x86c,0x873,0x110a,0x110f,0x1114,0x1119,0,0,0x87a,0x881,0x111e,0x1123,
-0x1128,0x112d,0,0,0x888,0x891,0x1132,0x1137,0x113c,0x1141,0x1146,0x114b,0,0x89a,0,0x1150,
-0,0x1155,0,0x115a,0x8a3,0x8ae,0x8ba,0x8c1,0x8c8,0x8cf,0x8d6,0x8dd,0x8e3,0x8ee,0x8fa,0x901,
-0x908,0x90f,0x916,0x91d,0x923,0x156a,0x115e,0x156e,0x928,0x1572,0x1161,0x1576,0x1164,0x157a,0x1167,0x157e,
-0x92d,0x1582,0,0,0x116b,0x1170,0x1177,0x117f,0x1187,0x118f,0x1197,0x119f,0x11a5,0x11aa,0x11b1,0x11b9,
-0x11c1,0x11c9,0x11d1,0x11d9,0x11df,0x11e4,0x11eb,0x11f3,0x11fb,0x1203,0x120b,0x1213,0x1219,0x121e,0x1225,0x122d,
-0x1235,0x123d,0x1245,0x124d,0x1253,0x1258,0x125f,0x1267,0x126f,0x1277,0x127f,0x1287,0x128d,0x1292,0x1299,0x12a1,
-0x12a9,0x12b1,0x12b9,0x12c1,0x12c6,0x12c9,0x12cd,0x12d1,0x12d5,0,0x932,0x12da,0x12de,0x12e1,0x12e4,0x1586,
-0x12e7,0,0x1589,0x478,0,0x12ea,0x12ee,0x12f2,0x12f6,0,0x937,0x12fb,0x12ff,0x158c,0x1302,0x1590,
-0x1305,0x1308,0x130b,0x130e,0x1311,0x1314,0x1318,0x1595,0,0,0x131c,0x1320,0x1324,0x1327,0x132a,0x159a,
-0,0x132d,0x1330,0x1333,0x1336,0x1339,0x133d,0x159f,0x1341,0x1344,0x1347,0x134b,0x134f,0x1352,0x1355,0x15a4,
-0x1358,0x135b,0x15a8,0x15ab,0,0,0x135f,0x1363,0x1367,0,0x93c,0x136c,0x1370,0x15ae,0x1373,0x15b2,
-0x1376,0x15b5,0x47e,0,0xfdc1,0xfdc1,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xffe6,0xffe6,0xff01,0xff01,0xffe6,0xffe6,0xffe6,0xffe6,0xff01,0xff01,0xff01,0xffe6,
-0xffe6,0,0,0,0,0xffe6,0,0,0,0xff01,0xff01,0xffe6,0xffdc,0xffe6,0xff01,0xff01,
-0xffdc,0xffdc,0xffdc,0xffdc,0xffe6,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0x15b7,0,0,0,0x15b9,0x15bc,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x484,0,0x486,0,0x488,0,0,0,0,0,0x1379,0x137c,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x137f,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0x1382,0x1385,0x1388,
-0x48a,0,0x48c,0,0x48e,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0x490,0x138b,0,0,0,0x492,0x138e,0,0x494,0x1391,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0x496,0x1394,0x498,0x1397,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x49a,0,0,0,
-0,0x139a,0,0x49c,0x139d,0x49e,0,0x13a0,0x4a0,0x13a3,0,0,0,0x4a2,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x13a6,0x4a4,0x13a9,0,0x4a6,0x4a8,0,0,0,0,0,0,0,0x13ac,0x13af,0x13b2,
-0x13b5,0x13b8,0x4aa,0x4ac,0x13bb,0x13be,0x4ae,0x4b0,0x13c1,0x13c4,0x4b2,0x4b4,0x4b6,0x4b8,0,0,
-0x13c7,0x13ca,0x4ba,0x4bc,0x13cd,0x13d0,0x4be,0x4c0,0x13d3,0x13d6,0,0,0,0,0,0,
-0,0x4c2,0x4c4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0x4c6,0,0,0,0,0,0x4c8,0x4ca,0,0x4cc,0x13d9,0x13dc,0x13df,0x13e2,
-0,0,0x4ce,0x4d0,0x4d2,0x4d4,0,0,0,0,0,0,0,0,0,0,
-0x13e5,0x13e8,0x13eb,0x13ee,0,0,0,0,0,0,0x13f1,0x13f4,0x13f7,0x13fa,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0x15bf,0x15c1,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x15c3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0xffe6,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xff09,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,0,0,0,0,0,0,
-0,0,0xffda,0xffe4,0xffe8,0xffde,0xffe0,0xffe0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x4d6,0,0,0,0,0x4d8,
-0x13fd,0x4da,0x1400,0x4dc,0x1403,0x4de,0x1406,0x4e0,0x1409,0x4e2,0x140c,0x4e4,0x140f,0x4e6,0x1412,0x4e8,
-0x1415,0x4ea,0x1418,0x4ec,0x141b,0x4ee,0x141e,0,0x4f0,0x1421,0x4f2,0x1424,0x4f4,0x1427,0,0,
-0,0,0,0x4f6,0x142a,0x142d,0x4fa,0x1430,0x1433,0x4fe,0x1436,0x1439,0x502,0x143c,0x143f,0x506,
-0x1442,0x1445,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x1448,0,0,0,0,0xfe08,0xfe08,0,
-0,0x50a,0x144b,0,0,0,0,0,0,0,0x50c,0,0,0,0,0x50e,
-0x144e,0x510,0x1451,0x512,0x1454,0x514,0x1457,0x516,0x145a,0x518,0x145d,0x51a,0x1460,0x51c,0x1463,0x51e,
-0x1466,0x520,0x1469,0x522,0x146c,0x524,0x146f,0,0x526,0x1472,0x528,0x1475,0x52a,0x1478,0,0,
-0,0,0,0x52c,0x147b,0x147e,0x530,0x1481,0x1484,0x534,0x1487,0x148a,0x538,0x148d,0x1490,0x53c,
-0x1493,0x1496,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0x540,0x542,0x544,0x546,0,0x1499,0,0,0x149c,0x149f,0x14a2,0x14a5,0,
-0,0x548,0x14a8,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0xffe6,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0xff09,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xff09,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xffdc,
-0xffdc,0xffdc,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xff09,0,0,0,0,0,0,0,0,
-0,0,0,0,0xff09,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xffe6,0,0xffe6,0xffe6,0xffdc,0,0,0xffe6,0xffe6,0,0,0,
-0,0,0xffe6,0xffe6,0,0xffe6,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0xff09,0,0,0,0,0,0,0,0,0,
-0x15c6,0x15c8,0x15ca,0x15cc,0x15ce,0x15d0,0x15d2,0x15d4,0x15d4,0x15d6,0x15d8,0x15da,0x15dc,0x15de,0x15e0,0x15e2,
-0x15e4,0x15e6,0x15e8,0x15ea,0x15ec,0x15ee,0x15f0,0x15f2,0x15f4,0x15f6,0x15f8,0x15fa,0x15fc,0x15fe,0x1600,0x1602,
-0x1604,0x1606,0x1608,0x160a,0x160c,0x160e,0x1610,0x1612,0x1614,0x1616,0x1618,0x161a,0x161c,0x161e,0x1620,0x1622,
-0x1624,0x1626,0x1628,0x162a,0x162c,0x162e,0x1630,0x1632,0x1634,0x1636,0x1638,0x163a,0x163c,0x163e,0x1640,0x1642,
-0x1644,0x1646,0x1648,0x164a,0x164c,0x164e,0x1650,0x1652,0x1654,0x1656,0x1658,0x165a,0x165c,0x165e,0x1660,0x1662,
-0x1664,0x1666,0x1668,0x166a,0x166c,0x166e,0x1670,0x1672,0x1674,0x1676,0x1678,0x167a,0x15ec,0x167c,0x167e,0x1680,
-0x1682,0x1684,0x1686,0x1688,0x168a,0x168c,0x168e,0x1690,0x1692,0x1694,0x1696,0x1698,0x169a,0x169c,0x169e,0x16a0,
-0x16a2,0x16a4,0x16a6,0x16a8,0x16aa,0x16ac,0x16ae,0x16b0,0x16b2,0x16b4,0x16b6,0x16b8,0x16ba,0x16bc,0x16be,0x16c0,
-0x16c2,0x16c4,0x16c6,0x16c8,0x16ca,0x16cc,0x16ce,0x16d0,0x16d2,0x16d4,0x16d6,0x16d8,0x16da,0x16dc,0x16de,0x16e0,
-0x16e2,0x16e4,0x16e6,0x16e8,0x16ea,0x16ec,0x16ee,0x16f0,0x16f2,0x16f4,0x16f6,0x16f8,0x16fa,0x16fc,0x16fe,0x1700,
-0x1702,0x16a0,0x1704,0x1706,0x1708,0x170a,0x170c,0x170e,0x1710,0x1712,0x1680,0x1714,0x1716,0x1718,0x171a,0x171c,
-0x171e,0x1720,0x1722,0x1724,0x1726,0x1728,0x172a,0x172c,0x172e,0x1730,0x1732,0x1734,0x1736,0x1738,0x173a,0x15ec,
-0x173c,0x173e,0x1740,0x1742,0x1744,0x1746,0x1748,0x174a,0x174c,0x174e,0x1750,0x1752,0x1754,0x1756,0x1758,0x175a,
-0x175c,0x175e,0x1760,0x1762,0x1764,0x1766,0x1768,0x176a,0x176c,0x176e,0x1770,0x1684,0x1772,0x1774,0x1776,0x1778,
-0x177a,0x177c,0x177e,0x1780,0x1782,0x1784,0x1786,0x1788,0x178a,0x178c,0x178e,0x1790,0x1792,0x1794,0x1796,0x1798,
-0x179a,0x179c,0x179e,0x17a0,0x17a2,0x17a4,0x17a6,0x17a8,0x17aa,0x17ac,0x17ae,0x17b0,0x17b2,0x17b4,0x17b6,0x17b8,
-0x17ba,0x17bc,0x17be,0x17c0,0x17c2,0x17c4,0x17c6,0x17c8,0x17ca,0x17cc,0x17ce,0x17d0,0x17d2,0x17d4,0,0,
-0x17d6,0,0x17d8,0,0,0x17da,0x17dc,0x17de,0x17e0,0x17e2,0x17e4,0x17e6,0x17e8,0x17ea,0x17ec,0,
-0x17ee,0,0x17f0,0,0,0x17f2,0x17f4,0,0,0,0x17f6,0x17f8,0x17fa,0x17fc,0x17fe,0x1800,
-0x1802,0x1804,0x1806,0x1808,0x180a,0x180c,0x180e,0x1810,0x1812,0x1814,0x1816,0x1818,0x181a,0x181c,0x181e,0x1820,
-0x1822,0x1824,0x1826,0x1828,0x182a,0x182c,0x182e,0x1830,0x1832,0x1834,0x1836,0x1838,0x183a,0x183c,0x183e,0x1840,
-0x1842,0x1844,0x1846,0x1848,0x184a,0x184c,0x184e,0x16ee,0x1850,0x1852,0x1854,0x1856,0x1858,0x185a,0x185a,0x185c,
-0x185e,0x1860,0x1862,0x1864,0x1866,0x1868,0x186a,0x17f2,0x186c,0x186e,0x1870,0x1872,0x1874,0x1877,0,0,
-0x1879,0x187b,0x187d,0x187f,0x1881,0x1883,0x1885,0x1887,0x180e,0x1889,0x188b,0x188d,0x17d6,0x188f,0x1891,0x1893,
-0x1895,0x1897,0x1899,0x189b,0x189d,0x189f,0x18a1,0x18a3,0x18a5,0x1820,0x18a7,0x1822,0x18a9,0x18ab,0x18ad,0x18af,
-0x18b1,0x17d8,0x1616,0x18b3,0x18b5,0x18b7,0x16a2,0x1750,0x18b9,0x18bb,0x1830,0x18bd,0x1832,0x18bf,0x18c1,0x18c3,
-0x17dc,0x18c5,0x18c7,0x18c9,0x18cb,0x18cd,0x17de,0x18cf,0x18d1,0x18d3,0x18d5,0x18d7,0x18d9,0x184e,0x18db,0x18dd,
-0x16ee,0x18df,0x1856,0x18e1,0x18e3,0x18e5,0x18e7,0x18e9,0x1860,0x18eb,0x17f0,0x18ed,0x1862,0x167c,0x18ef,0x1864,
-0x18f1,0x1868,0x18f3,0x18f5,0x18f7,0x18f9,0x18fb,0x186c,0x17e8,0x18fd,0x186e,0x18ff,0x1870,0x1901,0x15d4,0x1903,
-0x1906,0x1909,0x190c,0x190e,0x1910,0x1912,0x1915,0x1918,0x191b,0x191d,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0x191f,0xff1a,0x1922,0,0,0,0,
-0,0,0,0,0,0,0x1925,0x1928,0x192c,0x1931,0x1935,0x1938,0x193b,0x193e,0x1941,0x1944,
-0x1947,0x194a,0x194d,0,0x1950,0x1953,0x1956,0x1959,0x195c,0,0x195f,0,0x1962,0x1965,0,0x1968,
-0x196b,0,0x196e,0x1971,0x1974,0x1977,0x197a,0x197d,0x1980,0x1983,0x1986,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffe6,0xffe6,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xffdc,0,0,0xffdc,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xffdc,0,0xffe6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xffe6,0xff01,0xffdc,0,
-0,0,0,0xff09,0,0,0,0,0,0xffe6,0xffdc,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0x54a,0x14ab,0x54d,0x14b0,0,0,0,0,0,0,0,
-0,0x550,0,0,0,0,0,0x14b5,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0xff09,0xfe07,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xfe00,
-0,0,0,0,0,0,0x14ba,0x14bf,0,0x553,0x556,0xff09,0xff09,0,0,0,
-0,0,0,0,0,0,0,0,0xff09,0,0,0,0,0,0,0,
-0,0,0xff07,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xff09,0xff07,0,0,0,0,0,
-0,0,0,0,0,0xff07,0xff09,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x559,
-0,0,0,0x14c4,0x14c9,0xff09,0,0,0,0,0,0,0,0,0,0xfe00,
-0,0,0,0,0,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0xff09,0,0,0,0xff07,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xfe00,0,0,0,0,0,0,0,0,0x55f,0xfe00,0x14ce,
-0x14d3,0xfe00,0x14d8,0,0,0,0xff09,0xff07,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xfe00,0,0,0,0,0,0,0,0,
-0x568,0x56b,0x14dd,0x14e2,0,0,0,0xff09,0xff07,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0xff09,0xff07,0,0,0,0,
-0,0,0,0,0,0,0,0xff09,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xff09,0,0,0,0,0,0,0,0,0xff07,0,0xff09,0xff09,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xff01,0xff01,0xff01,0xff01,0xff01,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0xff01,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0x1989,0x198e,0x1998,0x19a4,0x19b0,0x19bc,0x19c8,0xffd8,0xffd8,0xff01,
-0xff01,0xff01,0,0,0,0xffe2,0xffd8,0xffd8,0xffd8,0xffd8,0xffd8,0,0,0,0,0,
-0,0,0,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0,0,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffdc,0xffdc,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0x19cf,0x19d4,0x19de,0x19ea,0x19f6,
-0x1a02,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0xffe6,0xffe6,0xffe6,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,
-0xffe6,0xffe6,0,0xffe6,0xffe6,0,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0xffdc,0,0,0,0,0,0,0,0,0,
-0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xffe6,0xff07,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x1a09,0x1a0b,0x1a0d,0x1a0f,
-0x1a12,0x1802,0x1a14,0x1a16,0x1a18,0x1a1a,0x1804,0x1a1c,0x1a1e,0x1a20,0x1806,0x1a23,0x1a25,0x1a27,0x1a29,0x1a2c,
-0x1a2e,0x1a30,0x1a32,0x1a35,0x1a37,0x1a39,0x1a3b,0x187b,0x1a3d,0x1a40,0x1a42,0x1a44,0x1a46,0x1a48,0x1a4a,0x1a4c,
-0x1a4e,0x1885,0x1808,0x180a,0x1887,0x1a50,0x1a52,0x1688,0x1a54,0x180c,0x1a56,0x1a58,0x1a5a,0x1a5c,0x1a5c,0x1a5c,
-0x1a5e,0x1a61,0x1a63,0x1a65,0x1a67,0x1a6a,0x1a6c,0x1a6e,0x1a70,0x1a72,0x1a74,0x1a76,0x1a78,0x1a7a,0x1a7c,0x1a7e,
-0x1a80,0x1a82,0x1a82,0x188b,0x1a84,0x1a86,0x1a88,0x1a8a,0x1810,0x1a8c,0x1a8e,0x1a90,0x17ba,0x1a92,0x1a94,0x1a96,
-0x1a98,0x1a9a,0x1a9c,0x1a9e,0x1aa0,0x1aa2,0x1aa5,0x1aa7,0x1aa9,0x1aab,0x1aad,0x1aaf,0x1ab1,0x1ab4,0x1ab7,0x1ab9,
-0x1abb,0x1abd,0x1abf,0x1ac1,0x1ac3,0x1ac5,0x1ac7,0x1ac7,0x1ac9,0x1acc,0x1ace,0x1680,0x1ad0,0x1ad2,0x1ad5,0x1ad7,
-0x1ad9,0x1adb,0x1add,0x1adf,0x181a,0x1ae1,0x1ae3,0x1ae5,0x1ae8,0x1aea,0x1aed,0x1aef,0x1af1,0x1af3,0x1af5,0x1af7,
-0x1af9,0x1afb,0x1afd,0x1aff,0x1b01,0x1b03,0x1b06,0x1b08,0x1b0a,0x1b0c,0x1614,0x1b0e,0x1b11,0x1b13,0x1b13,0x1b16,
-0x1b18,0x1b18,0x1b1a,0x1b1c,0x1b1f,0x1b22,0x1b24,0x1b26,0x1b28,0x1b2a,0x1b2c,0x1b2e,0x1b30,0x1b32,0x1b34,0x181c,
-0x1b36,0x1b39,0x1b3b,0x1b3d,0x18a3,0x1b3d,0x1b3f,0x1820,0x1b41,0x1b43,0x1b45,0x1b47,0x1822,0x15de,0x1b49,0x1b4b,
-0x1b4d,0x1b4f,0x1b51,0x1b53,0x1b55,0x1b58,0x1b5a,0x1b5c,0x1b5e,0x1b60,0x1b62,0x1b65,0x1b67,0x1b69,0x1b6b,0x1b6d,
-0x1b6f,0x1b71,0x1b73,0x1b75,0x1824,0x1b77,0x1b79,0x1b7c,0x1b7e,0x1b80,0x1b82,0x1828,0x1b84,0x1b86,0x1b88,0x1b8a,
-0x1b8c,0x1b8e,0x1b90,0x1b92,0x1616,0x18b3,0x1b94,0x1b96,0x1b98,0x1b9a,0x1b9d,0x1b9f,0x1ba1,0x1ba3,0x182a,0x1ba5,
-0x1ba8,0x1baa,0x1bac,0x190c,0x1bae,0x1bb0,0x1bb2,0x1bb4,0x1bb6,0x1bb9,0x1bbb,0x1bbd,0x1bbf,0x1bc2,0x1bc4,0x1bc6,
-0x1bc8,0x16a2,0x1bca,0x1bcc,0x1bcf,0x1bd2,0x1bd5,0x1bd7,0x1bda,0x1bdc,0x1bde,0x1be0,0x1be2,0x182c,0x1750,0x1be4,
-0x1be6,0x1be8,0x1bea,0x1bed,0x1bef,0x1bf1,0x1bf3,0x18bb,0x1bf5,0x1bf7,0x1bfa,0x1bfc,0x1bfe,0x1c01,0x1c04,0x1c06,
-0x18bd,0x1c08,0x1c0a,0x1c0c,0x1c0e,0x1c10,0x1c12,0x1c14,0x1c17,0x1c19,0x1c1c,0x1c1e,0x1c21,0x18c1,0x1c23,0x1c25,
-0x1c28,0x1c2a,0x1c2c,0x1c2f,0x1c32,0x1c34,0x1c36,0x1c38,0x1c3a,0x1c3a,0x1c3c,0x1c3e,0x18c5,0x1c40,0x1c42,0x1c44,
-0x1c46,0x1c48,0x1c4b,0x1c4d,0x1686,0x1c50,0x1c53,0x1c55,0x1c58,0x1c5b,0x1c5e,0x1c60,0x18d1,0x1c62,0x1c65,0x1c68,
-0x1c6b,0x1c6e,0x1c70,0x1c70,0x18d3,0x1910,0x1c72,0x1c74,0x1c76,0x1c78,0x1c7b,0x163a,0x18d7,0x1c7d,0x1c7f,0x1842,
-0x1c82,0x1c85,0x17e6,0x1c88,0x1c8a,0x184a,0x1c8c,0x1c8e,0x1c90,0x1c93,0x1c93,0x1c96,0x1c98,0x1c9a,0x1c9d,0x1c9f,
-0x1ca1,0x1ca3,0x1ca6,0x1ca8,0x1caa,0x1cac,0x1cae,0x1cb0,0x1cb3,0x1cb5,0x1cb7,0x1cb9,0x1cbb,0x1cbd,0x1cbf,0x1cc2,
-0x1cc5,0x1cc7,0x1cca,0x1ccc,0x1ccf,0x1cd1,0x1856,0x1cd3,0x1cd6,0x1cd9,0x1cdb,0x1cde,0x1ce0,0x1ce3,0x1ce5,0x1ce7,
-0x1ce9,0x1ceb,0x1ced,0x1cef,0x1cf2,0x1cf5,0x1cf8,0x1b16,0x1cfb,0x1cfd,0x1cff,0x1d01,0x1d03,0x1d05,0x1d07,0x1d09,
-0x1d0b,0x1d0d,0x1d0f,0x1d11,0x16aa,0x1d14,0x1d16,0x1d18,0x1d1a,0x1d1c,0x1d1e,0x185c,0x1d20,0x1d22,0x1d24,0x1d26,
-0x1d28,0x1d2b,0x1d2e,0x1d31,0x1d33,0x1d35,0x1d37,0x1d39,0x1d3c,0x1d3e,0x1d41,0x1d43,0x1d45,0x1d48,0x1d4b,0x1d4d,
-0x1630,0x1d4f,0x1d51,0x1d53,0x1d55,0x1d57,0x1d59,0x18e5,0x1d5b,0x1d5d,0x1d5f,0x1d61,0x1d63,0x1d65,0x1d67,0x1d69,
-0x1d6b,0x1d6d,0x1d70,0x1d72,0x1d74,0x1d76,0x1d78,0x1d7a,0x1d7d,0x1d80,0x1d82,0x1d84,0x18ef,0x18f1,0x1d86,0x1d88,
-0x1d8b,0x1d8d,0x1d8f,0x1d91,0x1d93,0x1d96,0x1d99,0x1d9b,0x1d9d,0x1d9f,0x1da2,0x18f3,0x1da4,0x1da7,0x1daa,0x1dac,
-0x1dae,0x1db0,0x1db3,0x1db5,0x1db7,0x1db9,0x1dbb,0x1dbd,0x1dbf,0x1dc1,0x1dc4,0x1dc6,0x1dc8,0x1dca,0x1dcd,0x1dcf,
-0x1dd1,0x1dd3,0x1dd5,0x1dd8,0x1ddb,0x1ddd,0x1ddf,0x1de1,0x1de4,0x1de6,0x18ff,0x18ff,0x1de9,0x1deb,0x1dee,0x1df0,
-0x1df2,0x1df4,0x1df6,0x1df8,0x1dfa,0x1dfc,0x1901,0x1dff,0x1e01,0x1e03,0x1e05,0x1e07,0x1e09,0x1e0c,0x1e0e,0x1e11,
-0x1e14,0x1e17,0x1e19,0x1e1b,0x1e1d,0x1e1f,0x1e21,0x1e23,0x1e25,0x1e27,0,0,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0xff00,0xff00,0xff00,
-0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,
-0xff00,0xff00,0,0,0,0,0,0,0,0,0,0,0xff00,0xff00,0xff00,0xff00,
-0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,
-0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,
-0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,0x56e,
-0x56e,0x56e,0x56e,0x56e,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1e29,0,0x1e29,0,0x1e29,0x1e29,0x1e29,0x1e29,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x1e29,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0x1e29,0,0,0,0,
-0x1e29,0,0,0,0x1e29,0,0x1e29,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0x1e27,0,0,0,0,0
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,4,8,0xc,1,
+1,0x10,0x50,0x5c,0x70,0x88,0xcc,0xd0,0xec,0x108,0x144,0x148,0x15c,0x174,0x180,0x1a4,
+0x1e4,1,0x1ec,0x20c,0x228,0x244,0x290,0x298,0x2b0,0x2b8,0x2dc,1,1,1,1,1,
+1,0x2f4,0x334,0x340,0x354,0x36c,0x3b0,0x3b4,0x3d0,0x3f0,0x428,0x430,0x444,0x45c,0x468,0x48c,
+0x4cc,1,0x4d4,0x4f4,0x510,0x530,0x57c,0x584,0x5a0,0x5a8,0x5d0,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x5e8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0x1284,0x128a,0xade,0x1290,0xaf4,0xafe,0x5f4,0xb08,
+0x1296,0x129c,0xb12,0x12a2,0x12a8,0x12ae,0x12b4,0xb28,1,0x12ba,0x12c0,0x12c6,0xb32,0xb48,0xb5a,1,
+0x5fc,0x12cc,0x12d2,0x12d8,0xb64,0x12de,1,1,0x12e4,0x12ea,0xb7a,0x12f0,0xb90,0xb9a,0x600,0xba4,
+0x12f6,0x12fc,0xbae,0x1302,0x1308,0x130e,0x1314,0xbc4,1,0x131a,0x1320,0x1326,0xbce,0xbe4,0xbf6,1,
+0x608,0x132c,0x1332,0x1338,0xc00,0x133e,1,0x1344,0x134a,0x1350,0xc16,0xc2c,0x1357,0x135d,0x1362,0x1368,
+0x136e,0x1374,0x137a,0x1380,0x1386,0x138c,0x1392,0x1398,1,1,0xc42,0xc50,0x139e,0x13a4,0x13aa,0x13b0,
+0x13b7,0x13bd,0x13c2,0x13c8,0x13ce,0x13d4,0x13da,0x13e0,0x13e6,0x13ec,0x13f3,0x13f9,0x13fe,0x1404,1,1,
+0x140a,0x1410,0x1416,0x141c,0x1422,0x1428,0x142f,0x1435,0x143a,1,1,1,0x1441,0x1447,0x144d,0x1453,
+1,0x1458,0x145e,0x1465,0x146b,0x1470,0x1476,1,1,1,1,0x147c,0x1482,0x1489,0x148f,0x1494,
+0x149a,1,1,1,0xc5e,0xc6c,0x14a0,0x14a6,0x14ac,0x14b2,1,1,0x14b8,0x14be,0x14c5,0x14cb,
+0x14d0,0x14d6,0xc7a,0xc84,0x14dc,0x14e2,0x14e9,0x14ef,0xc8e,0xc98,0x14f5,0x14fb,0x1500,0x1506,1,1,
+0xca2,0xcac,0xcb6,0xcc0,0x150c,0x1512,0x1518,0x151e,0x1524,0x152a,0x1531,0x1537,0x153c,0x1542,0x1548,0x154e,
+0x1554,0x155a,0x1560,0x1566,0x156c,0x1572,0x1578,0x60c,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xcca,0xce4,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xcfe,0xd18,1,1,1,1,1,1,0x610,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0x157e,0x1584,0x158a,
+0x1590,0x1596,0x159c,0x15a2,0x15a8,0x15b0,0x15ba,0x15c4,0x15ce,0x15d8,0x15e2,0x15ec,0x15f6,1,0x1600,0x160a,
+0x1614,0x161e,0x1627,0x162d,1,1,0x1632,0x1638,0x163e,0x1644,0xd32,0xd3c,0x164d,0x1657,0x165f,0x1665,
+0x166b,1,1,1,0x1670,0x1676,1,1,0x167c,0x1682,0x168a,0x1694,0x169d,0x16a3,0x16a9,0x16af,
+0x16b4,0x16ba,0x16c0,0x16c6,0x16cc,0x16d2,0x16d8,0x16de,0x16e4,0x16ea,0x16f0,0x16f6,0x16fc,0x1702,0x1708,0x170e,
+0x1714,0x171a,0x1720,0x1726,0x172c,0x1732,0x1738,0x173e,0x1744,0x174a,0x1750,0x1756,1,1,0x175c,0x1762,
+1,1,1,1,1,1,0xd46,0xd50,0xd5a,0xd64,0x176a,0x1774,0x177e,0x1788,0xd6e,0xd78,
+0x1792,0x179c,0x17a4,0x17aa,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0x614,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xffcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,
+0xfdcc,0xffcc,0xffcc,0xfdcc,0xffcc,0xfdcc,0xffcc,0xfdcc,0xfdcc,0xffd0,0xffb8,0xffb8,0xffb8,0xffb8,0xffd0,0xfdb0,
+0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xff94,0xff94,0xfdb8,0xfdb8,0xfdb8,0xfdb8,0xfd94,0xfd94,0xffb8,0xffb8,0xffb8,
+0xffb8,0xfdb8,0xfdb8,0xffb8,0xfdb8,0xfdb8,0xffb8,0xffb8,0xfe02,0xfe02,0xfe02,0xfe02,0xfc02,0xffb8,0xffb8,0xffb8,
+0xffb8,0xffcc,0xffcc,0xffcc,0x3c26,0x3c2c,0xfdcc,0x3c32,0x3c38,0xfde0,0xffcc,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,
+0xffcc,0xffb8,0xffb8,1,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffd0,0xffb8,0xffb8,0xffcc,
+0xffd2,0xffd4,0xffd4,0xffd2,0xffd4,0xffd4,0xffd2,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,0x29d1,1,1,1,1,1,1,1,
+1,1,0x29d5,1,1,1,1,1,1,0x17b1,0x17b7,0x29d9,0x17bd,0x17c3,0x17c9,1,
+0x17cf,1,0x17d5,0x17db,0x17e3,0x618,1,1,1,0x634,1,0x644,1,0x658,1,1,
+1,1,1,0x674,1,0x684,1,1,1,0x688,1,1,1,0x6a0,0x17eb,0x17f1,
+0xd82,0x17f7,0xd8c,0x17fd,0x1805,0x6b4,1,1,1,0x6d4,1,0x6e4,1,0x6fc,1,1,
+1,1,1,0x71c,1,0x72c,1,1,1,0x734,1,1,1,0x754,0xd96,0xda8,
+0x180d,0x1813,0xdba,1,1,1,0x76c,0x1819,0x181f,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x1825,0x182b,1,0x1831,1,1,0x774,0x1837,1,1,1,1,
+0x183d,0x1843,0x1849,1,0x778,1,1,0x780,1,0x784,0x790,0x798,0x79c,0x184f,0x7ac,1,
+1,1,0x7b0,1,1,1,1,0x7b4,1,1,1,0x7c4,1,1,1,0x7c8,
+1,0x7cc,1,1,0x7d0,1,1,0x7d8,1,0x7dc,0x7e8,0x7f0,0x7f4,0x1855,0x804,1,
+1,1,0x808,1,1,1,1,0x80c,1,1,1,0x81c,1,1,1,0x820,
+1,0x824,1,1,0x185b,0x1861,1,0x1867,1,1,0x828,0x186d,1,1,1,1,
+0x1873,0x1879,0x187f,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0x82c,0x830,0x1885,0x188b,1,1,1,1,
+1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0x1891,0x1897,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x189d,0x18a3,0x18a9,0x18af,1,1,0x18b5,0x18bb,0x834,0x838,0x18c1,0x18c7,
+0x18cd,0x18d3,0x18d9,0x18df,1,1,0x18e5,0x18eb,0x18f1,0x18f7,0x18fd,0x1903,0x83c,0x840,0x1909,0x190f,
+0x1915,0x191b,0x1921,0x1927,0x192d,0x1933,0x1939,0x193f,0x1945,0x194b,1,1,0x1951,0x1957,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffbc,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffbc,0xffc8,0xffcc,
+0xfe14,0xfe16,0xfe18,0xfe1a,0xfe1c,0xfe1e,0xfe20,0xfe22,0xfe24,0xfe26,0xfe26,0xfe28,0xfe2a,0xfe2c,1,0xfe2e,
+1,0xfe30,0xfe32,1,0xffcc,0xffb8,1,0xfe24,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xfe3c,0xfe3e,0xfe40,1,1,1,1,1,
+1,1,0x195c,0x1962,0x1969,0x196f,0x1975,0x844,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x850,1,0x854,0xfe36,0xfe38,0xfe3a,0xfe3c,0xfe3e,0xfe40,0xfe42,0xfe44,0xfdcc,0xfdcc,0xfdb8,0xffb8,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xfe46,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0x197b,0x858,0x1981,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0x85c,0x1987,1,0x860,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,1,1,0xffcc,
+0xffcc,1,0xffb8,0xffcc,0xffcc,0xffb8,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xfe48,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,
+0xffb8,0xffb8,0xffcc,0xffb8,0xffb8,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffb8,0xffcc,0xffb8,0xffcc,
+0xffb8,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffb8,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,1,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xffb8,0xffb8,0xffb8,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,0xffb8,
+0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xfe36,0xfe38,0xfe3a,0xffcc,
+0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,
+1,1,1,1,0x864,0x198d,1,1,1,1,1,1,0x868,0x1993,1,0x86c,
+0x1999,1,1,1,1,1,1,1,0xfc0e,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,0xffcc,0xffb8,0xffcc,
+0xffcc,1,1,1,0x29dd,0x29e3,0x29e9,0x29ef,0x29f5,0x29fb,0x2a01,0x2a07,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xfe0e,1,0xfc00,1,1,1,1,1,
+1,1,1,0x870,1,1,1,0x199f,0x19a5,0xfe12,1,1,1,1,1,1,
+1,1,1,0xfc00,1,1,1,1,0x2a0d,0x2a13,1,0x2a19,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x2a1f,
+1,1,0x2a25,1,1,1,1,1,0xfe0e,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,
+1,1,1,1,1,0x2a2b,0x2a31,0x2a37,1,1,0x2a3d,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xfe0e,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x878,
+0x19ab,1,1,0x19b1,0x19b7,0xfe12,1,1,1,1,1,1,1,1,0xfc00,0xfc00,
+1,1,1,1,0x2a43,0x2a49,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0x884,1,0x19bd,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfc00,1,
+1,1,1,1,1,1,0x888,0x890,1,1,0x19c3,0x19c9,0x19cf,0xfe12,1,1,
+1,1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,
+1,1,0x894,1,0x19d5,1,1,1,1,0xfe12,1,1,1,1,1,1,
+1,0xfea8,0xfcb6,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xfe0e,1,1,0x898,0x19db,1,0xfc00,1,1,1,0x89c,0x19e1,0x19e7,1,0xdc4,0x19ef,
+1,0xfe12,1,1,1,1,1,1,1,0xfc00,0xfc00,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xfe12,0xfe12,1,0xfc00,1,1,1,1,1,
+1,1,0x8a8,0x8b0,1,1,0x19f7,0x19fd,0x1a03,0xfe12,1,1,1,1,1,1,
+1,1,1,0xfc00,1,1,1,1,1,1,1,1,1,1,0xfc12,1,
+1,1,1,0xfc00,1,1,1,1,1,1,1,1,1,0x8b4,0x1a09,1,
+0xdce,0x1a11,0x1a19,0xfc00,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xfece,0xfece,0xfe12,1,
+1,1,1,1,1,1,1,1,0xfed6,0xfed6,0xfed6,0xfed6,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xfeec,0xfeec,1,1,1,1,1,1,1,1,1,1,
+0xfef4,0xfef4,0xfef4,0xfef4,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xffb8,0xffb8,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xffb8,1,0xffb8,1,0xffb0,1,1,1,1,1,1,
+1,1,1,0x2a4f,1,1,1,1,1,1,1,1,1,0x2a55,1,1,
+1,1,0x2a5b,1,1,1,1,0x2a61,1,1,1,1,0x2a67,1,1,1,
+1,1,1,1,1,1,1,1,1,0x2a6d,1,1,1,1,1,1,
+1,0xff02,0xff04,0x3c40,0xff08,0x3c48,0x2a73,1,0x2a79,1,0xff04,0xff04,0xff04,0xff04,1,1,
+0xff04,0x3c50,0xffcc,0xffcc,0xfe12,1,0xffcc,0xffcc,1,1,1,1,1,1,1,1,
+1,1,1,0x2a7f,1,1,1,1,1,1,1,1,1,0x2a85,1,1,
+1,1,0x2a8b,1,1,1,1,0x2a91,1,1,1,1,0x2a97,1,1,1,
+1,1,1,1,1,1,1,1,1,0x2a9d,1,1,1,1,1,1,
+1,1,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0x8c0,0x1a1f,1,
+1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,0xfe0e,
+1,0xfe12,0xfe12,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,1,
+1,1,1,1,1,1,1,1,1,0xffcc,1,1,1,1,1,1,
+1,1,1,1,1,0xffc8,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0xffbc,0xffcc,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffb8,1,1,1,
+1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,1,1,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,
+0xffcc,0xffb8,1,1,1,1,1,1,1,0x8c4,0x1a25,0x8c8,0x1a2b,0x8cc,0x1a31,0x8d0,
+0x1a37,0x8d4,0x1a3d,1,1,0x8d8,0x1a43,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xfe0e,0xfc00,1,1,
+1,1,0x8dc,0x1a49,0x8e0,0x1a4f,0x8e4,0x8e8,0x1a55,0x1a5b,0x8ec,0x1a61,0xfe12,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0xfe12,0xfe12,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0xfe0e,1,1,1,1,1,
+1,1,1,1,1,1,0xfe12,0xfe12,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe0e,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffcc,1,0xfe02,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,
+0xffcc,1,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,1,1,1,1,0xffb8,1,1,
+1,1,1,1,0xffcc,1,1,1,0xffcc,0xffcc,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffd4,0xffac,0xffb8,
+0xff94,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffd0,0xffc8,0xffc8,0xffb8,1,0xffcc,
+0xffd2,0xffb8,0xffcc,0xffb8,0x1a66,0x1a6c,0x1a72,0x1a78,0x1a7f,0x1a85,0x1a8b,0x1a91,0x1a99,0x1aa3,0x1aaa,0x1ab0,
+0x1ab6,0x1abc,0x1ac2,0x1ac8,0x1acf,0x1ad5,0x1ada,0x1ae0,0x1ae8,0x1af2,0x1afc,0x1b06,0x1b0e,0x1b14,0x1b1a,0x1b20,
+0x1b29,0x1b33,0x1b3b,0x1b41,0x1b46,0x1b4c,0x1b52,0x1b58,0x1b5e,0x1b64,0x1b6a,0x1b70,0x1b77,0x1b7d,0x1b82,0x1b88,
+0x1b8e,0x1b94,0x1b9c,0x1ba6,0x1bae,0x1bb4,0x1bba,0x1bc0,0x1bc6,0x1bcc,0xdd8,0xde2,0x1bd4,0x1bde,0x1be6,0x1bec,
+0x1bf2,0x1bf8,0x1bfe,0x1c04,0x1c0a,0x1c10,0x1c17,0x1c1d,0x1c22,0x1c28,0x1c2e,0x1c34,0x1c3a,0x1c40,0x1c46,0x1c4c,
+0x1c54,0x1c5e,0x1c68,0x1c72,0x1c7c,0x1c86,0x1c90,0x1c9a,0x1ca3,0x1ca9,0x1caf,0x1cb5,0x1cba,0x1cc0,0xdec,0xdf6,
+0x1cc8,0x1cd2,0x1cda,0x1ce0,0x1ce6,0x1cec,0xe00,0xe0a,0x1cf4,0x1cfe,0x1d08,0x1d12,0x1d1c,0x1d26,0x1d2e,0x1d34,
+0x1d3a,0x1d40,0x1d46,0x1d4c,0x1d52,0x1d58,0x1d5e,0x1d64,0x1d6a,0x1d70,0x1d76,0x1d7c,0x1d84,0x1d8e,0x1d98,0x1da2,
+0x1daa,0x1db0,0x1db7,0x1dbd,0x1dc2,0x1dc8,0x1dce,0x1dd4,0x1dda,0x1de0,0x1de6,0x1dec,0x1df3,0x1df9,0x1dff,0x1e05,
+0x1e0b,0x1e11,0x1e16,0x1e1c,0x1e22,0x1e28,0x1e2f,0x1e35,0x1e3b,0x1e41,0x1e46,0x1e4c,0x1e52,0x1e58,1,0x1e5f,
+1,1,1,1,0xe14,0xe22,0x1e64,0x1e6a,0x1e72,0x1e7c,0x1e86,0x1e90,0x1e9a,0x1ea4,0x1eae,0x1eb8,
+0x1ec2,0x1ecc,0x1ed6,0x1ee0,0x1eea,0x1ef4,0x1efe,0x1f08,0x1f12,0x1f1c,0x1f26,0x1f30,0xe30,0xe3a,0x1f38,0x1f3e,
+0x1f44,0x1f4a,0x1f52,0x1f5c,0x1f66,0x1f70,0x1f7a,0x1f84,0x1f8e,0x1f98,0x1fa2,0x1fac,0x1fb4,0x1fba,0x1fc0,0x1fc6,
+0xe44,0xe4e,0x1fcc,0x1fd2,0x1fda,0x1fe4,0x1fee,0x1ff8,0x2002,0x200c,0x2016,0x2020,0x202a,0x2034,0x203e,0x2048,
+0x2052,0x205c,0x2066,0x2070,0x207a,0x2084,0x208e,0x2098,0x20a0,0x20a6,0x20ac,0x20b2,0x20ba,0x20c4,0x20ce,0x20d8,
+0x20e2,0x20ec,0x20f6,0x2100,0x210a,0x2114,0x211c,0x2122,0x2129,0x212f,0x2134,0x213a,0x2140,0x2146,1,1,
+1,1,1,1,0xe58,0xe6e,0xe86,0xe94,0xea2,0xeb0,0xebe,0xecc,0xed8,0xeee,0xf06,0xf14,
+0xf22,0xf30,0xf3e,0xf4c,0xf58,0xf66,0x214f,0x2159,0x2163,0x216d,1,1,0xf74,0xf82,0x2177,0x2181,
+0x218b,0x2195,1,1,0xf90,0xfa6,0xfbe,0xfcc,0xfda,0xfe8,0xff6,0x1004,0x1010,0x1026,0x103e,0x104c,
+0x105a,0x1068,0x1076,0x1084,0x1090,0x10a2,0x219f,0x21a9,0x21b3,0x21bd,0x21c7,0x21d1,0x10b4,0x10c6,0x21db,0x21e5,
+0x21ef,0x21f9,0x2203,0x220d,0x10d8,0x10e6,0x2217,0x2221,0x222b,0x2235,1,1,0x10f4,0x1102,0x223f,0x2249,
+0x2253,0x225d,1,1,0x1110,0x1122,0x2267,0x2271,0x227b,0x2285,0x228f,0x2299,1,0x1134,1,0x22a3,
+1,0x22ad,1,0x22b7,0x1146,0x115c,0x1174,0x1182,0x1190,0x119e,0x11ac,0x11ba,0x11c6,0x11dc,0x11f4,0x1202,
+0x1210,0x121e,0x122c,0x123a,0x1246,0x3b8e,0x22bf,0x3b97,0x1250,0x3b9e,0x22c5,0x3ba7,0x22cb,0x3baf,0x22d1,0x3bb7,
+0x125a,0x3bbe,1,1,0x22d8,0x22e2,0x22f1,0x2301,0x2311,0x2321,0x2331,0x2341,0x234c,0x2356,0x2365,0x2375,
+0x2385,0x2395,0x23a5,0x23b5,0x23c0,0x23ca,0x23d9,0x23e9,0x23f9,0x2409,0x2419,0x2429,0x2434,0x243e,0x244d,0x245d,
+0x246d,0x247d,0x248d,0x249d,0x24a8,0x24b2,0x24c1,0x24d1,0x24e1,0x24f1,0x2501,0x2511,0x251c,0x2526,0x2535,0x2545,
+0x2555,0x2565,0x2575,0x2585,0x258f,0x2595,0x259d,0x25a4,0x25ad,1,0x1264,0x25b7,0x25bf,0x25c5,0x25cb,0x3bc7,
+0x25d0,1,0x2aa2,0x8f0,1,0x25d7,0x25df,0x25e6,0x25ef,1,0x126e,0x25f9,0x2601,0x3bcf,0x2607,0x3bd7,
+0x260c,0x2613,0x2619,0x261f,0x2625,0x262b,0x2633,0x3be1,1,1,0x263b,0x2643,0x264b,0x2651,0x2657,0x3beb,
+1,0x265d,0x2663,0x2669,0x266f,0x2675,0x267d,0x3bf5,0x2685,0x268b,0x2691,0x2699,0x26a1,0x26a7,0x26ad,0x3bff,
+0x26b3,0x26b9,0x3c07,0x2aa7,1,1,0x26c1,0x26c8,0x26d1,1,0x1278,0x26db,0x26e3,0x3c0f,0x26e9,0x3c17,
+0x26ee,0x2aab,0x8fc,1,0xfa09,0xfa09,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xffcc,0xffcc,0xfe02,0xfe02,0xffcc,0xffcc,0xffcc,0xffcc,0xfe02,0xfe02,0xfe02,0xffcc,
+0xffcc,1,1,1,1,0xffcc,1,1,1,0xfe02,0xfe02,0xffcc,0xffb8,0xffcc,0xfe02,0xfe02,
+0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0x2aae,1,1,1,0x2ab2,0x3c1e,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x908,1,0x90c,1,0x910,1,1,1,1,1,0x26f5,0x26fb,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0x2701,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0x2707,0x270d,0x2713,
+0x914,1,0x918,1,0x91c,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0x920,0x2719,1,1,1,0x924,0x271f,1,0x928,0x2725,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0x92c,0x272b,0x930,0x2731,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0x934,1,1,1,
+1,0x2737,1,0x938,0x273d,0x93c,1,0x2743,0x940,0x2749,1,1,1,0x944,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x274f,0x948,0x2755,1,0x94c,0x950,1,1,1,1,1,1,1,0x275b,0x2761,0x2767,
+0x276d,0x2773,0x954,0x958,0x2779,0x277f,0x95c,0x960,0x2785,0x278b,0x964,0x968,0x96c,0x970,1,1,
+0x2791,0x2797,0x974,0x978,0x279d,0x27a3,0x97c,0x980,0x27a9,0x27af,1,1,1,1,1,1,
+1,0x984,0x988,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0x98c,1,1,1,1,1,0x990,0x994,1,0x998,0x27b5,0x27bb,0x27c1,0x27c7,
+1,1,0x99c,0x9a0,0x9a4,0x9a8,1,1,1,1,1,1,1,1,1,1,
+0x27cd,0x27d3,0x27d9,0x27df,1,1,1,1,1,1,0x27e5,0x27eb,0x27f1,0x27f7,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0x2ab7,0x2abb,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x2abf,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xfe12,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,
+1,1,0xffb4,0xffc8,0xffd0,0xffbc,0xffc0,0xffc0,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0x9ac,1,1,1,1,0x9b0,
+0x27fd,0x9b4,0x2803,0x9b8,0x2809,0x9bc,0x280f,0x9c0,0x2815,0x9c4,0x281b,0x9c8,0x2821,0x9cc,0x2827,0x9d0,
+0x282d,0x9d4,0x2833,0x9d8,0x2839,0x9dc,0x283f,1,0x9e0,0x2845,0x9e4,0x284b,0x9e8,0x2851,1,1,
+1,1,1,0x9ec,0x2857,0x285d,0x9f4,0x2863,0x2869,0x9fc,0x286f,0x2875,0xa04,0x287b,0x2881,0xa0c,
+0x2887,0x288d,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0x2893,1,1,1,1,0xfc10,0xfc10,1,
+1,0xa14,0x2899,1,1,1,1,1,1,1,0xa18,1,1,1,1,0xa1c,
+0x289f,0xa20,0x28a5,0xa24,0x28ab,0xa28,0x28b1,0xa2c,0x28b7,0xa30,0x28bd,0xa34,0x28c3,0xa38,0x28c9,0xa3c,
+0x28cf,0xa40,0x28d5,0xa44,0x28db,0xa48,0x28e1,1,0xa4c,0x28e7,0xa50,0x28ed,0xa54,0x28f3,1,1,
+1,1,1,0xa58,0x28f9,0x28ff,0xa60,0x2905,0x290b,0xa68,0x2911,0x2917,0xa70,0x291d,0x2923,0xa78,
+0x2929,0x292f,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0xa80,0xa84,0xa88,0xa8c,1,0x2935,1,1,0x293b,0x2941,0x2947,0x294d,1,
+1,0xa90,0x2953,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0xffcc,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xfe12,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xffb8,
+0xffb8,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,
+1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xffcc,1,0xffcc,0xffcc,0xffb8,1,1,0xffcc,0xffcc,1,1,1,
+1,1,0xffcc,0xffcc,1,0xffcc,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,
+0x2ac5,0x2ac9,0x2acd,0x2ad1,0x2ad5,0x2ad9,0x2add,0x2ae1,0x2ae1,0x2ae5,0x2ae9,0x2aed,0x2af1,0x2af5,0x2af9,0x2afd,
+0x2b01,0x2b05,0x2b09,0x2b0d,0x2b11,0x2b15,0x2b19,0x2b1d,0x2b21,0x2b25,0x2b29,0x2b2d,0x2b31,0x2b35,0x2b39,0x2b3d,
+0x2b41,0x2b45,0x2b49,0x2b4d,0x2b51,0x2b55,0x2b59,0x2b5d,0x2b61,0x2b65,0x2b69,0x2b6d,0x2b71,0x2b75,0x2b79,0x2b7d,
+0x2b81,0x2b85,0x2b89,0x2b8d,0x2b91,0x2b95,0x2b99,0x2b9d,0x2ba1,0x2ba5,0x2ba9,0x2bad,0x2bb1,0x2bb5,0x2bb9,0x2bbd,
+0x2bc1,0x2bc5,0x2bc9,0x2bcd,0x2bd1,0x2bd5,0x2bd9,0x2bdd,0x2be1,0x2be5,0x2be9,0x2bed,0x2bf1,0x2bf5,0x2bf9,0x2bfd,
+0x2c01,0x2c05,0x2c09,0x2c0d,0x2c11,0x2c15,0x2c19,0x2c1d,0x2c21,0x2c25,0x2c29,0x2c2d,0x2b11,0x2c31,0x2c35,0x2c39,
+0x2c3d,0x2c41,0x2c45,0x2c49,0x2c4d,0x2c51,0x2c55,0x2c59,0x2c5d,0x2c61,0x2c65,0x2c69,0x2c6d,0x2c71,0x2c75,0x2c79,
+0x2c7d,0x2c81,0x2c85,0x2c89,0x2c8d,0x2c91,0x2c95,0x2c99,0x2c9d,0x2ca1,0x2ca5,0x2ca9,0x2cad,0x2cb1,0x2cb5,0x2cb9,
+0x2cbd,0x2cc1,0x2cc5,0x2cc9,0x2ccd,0x2cd1,0x2cd5,0x2cd9,0x2cdd,0x2ce1,0x2ce5,0x2ce9,0x2ced,0x2cf1,0x2cf5,0x2cf9,
+0x2cfd,0x2d01,0x2d05,0x2d09,0x2d0d,0x2d11,0x2d15,0x2d19,0x2d1d,0x2d21,0x2d25,0x2d29,0x2d2d,0x2d31,0x2d35,0x2d39,
+0x2d3d,0x2c79,0x2d41,0x2d45,0x2d49,0x2d4d,0x2d51,0x2d55,0x2d59,0x2d5d,0x2c39,0x2d61,0x2d65,0x2d69,0x2d6d,0x2d71,
+0x2d75,0x2d79,0x2d7d,0x2d81,0x2d85,0x2d89,0x2d8d,0x2d91,0x2d95,0x2d99,0x2d9d,0x2da1,0x2da5,0x2da9,0x2dad,0x2b11,
+0x2db1,0x2db5,0x2db9,0x2dbd,0x2dc1,0x2dc5,0x2dc9,0x2dcd,0x2dd1,0x2dd5,0x2dd9,0x2ddd,0x2de1,0x2de5,0x2de9,0x2ded,
+0x2df1,0x2df5,0x2df9,0x2dfd,0x2e01,0x2e05,0x2e09,0x2e0d,0x2e11,0x2e15,0x2e19,0x2c41,0x2e1d,0x2e21,0x2e25,0x2e29,
+0x2e2d,0x2e31,0x2e35,0x2e39,0x2e3d,0x2e41,0x2e45,0x2e49,0x2e4d,0x2e51,0x2e55,0x2e59,0x2e5d,0x2e61,0x2e65,0x2e69,
+0x2e6d,0x2e71,0x2e75,0x2e79,0x2e7d,0x2e81,0x2e85,0x2e89,0x2e8d,0x2e91,0x2e95,0x2e99,0x2e9d,0x2ea1,0x2ea5,0x2ea9,
+0x2ead,0x2eb1,0x2eb5,0x2eb9,0x2ebd,0x2ec1,0x2ec5,0x2ec9,0x2ecd,0x2ed1,0x2ed5,0x2ed9,0x2edd,0x2ee1,1,1,
+0x2ee5,1,0x2ee9,1,1,0x2eed,0x2ef1,0x2ef5,0x2ef9,0x2efd,0x2f01,0x2f05,0x2f09,0x2f0d,0x2f11,1,
+0x2f15,1,0x2f19,1,1,0x2f1d,0x2f21,1,1,1,0x2f25,0x2f29,0x2f2d,0x2f31,0x2f35,0x2f39,
+0x2f3d,0x2f41,0x2f45,0x2f49,0x2f4d,0x2f51,0x2f55,0x2f59,0x2f5d,0x2f61,0x2f65,0x2f69,0x2f6d,0x2f71,0x2f75,0x2f79,
+0x2f7d,0x2f81,0x2f85,0x2f89,0x2f8d,0x2f91,0x2f95,0x2f99,0x2f9d,0x2fa1,0x2fa5,0x2fa9,0x2fad,0x2fb1,0x2fb5,0x2fb9,
+0x2fbd,0x2fc1,0x2fc5,0x2fc9,0x2fcd,0x2fd1,0x2fd5,0x2d15,0x2fd9,0x2fdd,0x2fe1,0x2fe5,0x2fe9,0x2fed,0x2fed,0x2ff1,
+0x2ff5,0x2ff9,0x2ffd,0x3001,0x3005,0x3009,0x300d,0x2f1d,0x3011,0x3015,0x3019,0x301d,0x3021,0x3027,1,1,
+0x302b,0x302f,0x3033,0x3037,0x303b,0x303f,0x3043,0x3047,0x2f55,0x304b,0x304f,0x3053,0x2ee5,0x3057,0x305b,0x305f,
+0x3063,0x3067,0x306b,0x306f,0x3073,0x3077,0x307b,0x307f,0x3083,0x2f79,0x3087,0x2f7d,0x308b,0x308f,0x3093,0x3097,
+0x309b,0x2ee9,0x2b65,0x309f,0x30a3,0x30a7,0x2c7d,0x2dd9,0x30ab,0x30af,0x2f99,0x30b3,0x2f9d,0x30b7,0x30bb,0x30bf,
+0x2ef1,0x30c3,0x30c7,0x30cb,0x30cf,0x30d3,0x2ef5,0x30d7,0x30db,0x30df,0x30e3,0x30e7,0x30eb,0x2fd5,0x30ef,0x30f3,
+0x2d15,0x30f7,0x2fe5,0x30fb,0x30ff,0x3103,0x3107,0x310b,0x2ff9,0x310f,0x2f19,0x3113,0x2ffd,0x2c31,0x3117,0x3001,
+0x311b,0x3009,0x311f,0x3123,0x3127,0x312b,0x312f,0x3011,0x2f09,0x3133,0x3015,0x3137,0x3019,0x313b,0x2ae1,0x313f,
+0x3145,0x314b,0x3151,0x3155,0x3159,0x315d,0x3163,0x3169,0x316f,0x3173,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0x3177,0xfe34,0x317d,1,1,1,1,
+1,1,1,1,1,1,0x3183,0x3189,0x3191,0x319b,0x31a3,0x31a9,0x31af,0x31b5,0x31bb,0x31c1,
+0x31c7,0x31cd,0x31d3,1,0x31d9,0x31df,0x31e5,0x31eb,0x31f1,1,0x31f7,1,0x31fd,0x3203,1,0x3209,
+0x320f,1,0x3215,0x321b,0x3221,0x3227,0x322d,0x3233,0x3239,0x323f,0x3245,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xffb8,1,1,0xffb8,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0xffb8,1,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xfe02,0xffb8,1,
+1,1,1,0xfe12,1,1,1,1,1,0xffcc,0xffb8,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xa94,0x2959,0xa9a,0x2963,1,1,1,1,1,1,1,
+1,0xaa0,1,1,1,1,1,0x296d,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xfe12,0xfc0e,1,1,1,1,1,0xffcc,0xffcc,0xffcc,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfc00,
+1,1,1,1,1,1,0x2977,0x2981,1,0xaa6,0xaac,0xfe12,0xfe12,1,1,1,
+1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,
+1,1,0xfe0e,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xfe12,0xfe0e,1,1,1,1,1,
+1,1,1,1,1,0xfe0e,0xfe12,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xab2,
+1,1,1,0x298b,0x2995,0xfe12,1,1,1,1,1,1,1,1,1,0xfc00,
+1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0xfe12,1,1,1,0xfe0e,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,0xabe,0xfc00,0x299f,
+0x29a9,0xfc00,0x29b3,1,1,1,0xfe12,0xfe0e,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,
+0xad0,0xad6,0x29bd,0x29c7,1,1,1,0xfe12,0xfe0e,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0xfe12,0xfe0e,1,1,1,1,
+1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0xfe12,1,1,1,1,1,1,1,1,0xfe0e,1,0xfe12,0xfe12,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0xfe02,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0x324b,0x3255,0x3269,0x3281,0x3299,0x32b1,0x32c9,0xffb0,0xffb0,0xfe02,
+0xfe02,0xfe02,1,1,1,0xffc4,0xffb0,0xffb0,0xffb0,0xffb0,0xffb0,1,1,1,1,1,
+1,1,1,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,1,1,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffb8,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0x32d7,0x32e1,0x32f5,0x330d,0x3325,
+0x333d,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,1,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xfe0e,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0x334b,0x334f,0x3353,0x3357,
+0x335d,0x2f3d,0x3361,0x3365,0x3369,0x336d,0x2f41,0x3371,0x3375,0x3379,0x2f45,0x337f,0x3383,0x3387,0x338b,0x3391,
+0x3395,0x3399,0x339d,0x33a3,0x33a7,0x33ab,0x33af,0x302f,0x33b3,0x33b9,0x33bd,0x33c1,0x33c5,0x33c9,0x33cd,0x33d1,
+0x33d5,0x3043,0x2f49,0x2f4d,0x3047,0x33d9,0x33dd,0x2c49,0x33e1,0x2f51,0x33e5,0x33e9,0x33ed,0x33f1,0x33f1,0x33f1,
+0x33f5,0x33fb,0x33ff,0x3403,0x3407,0x340d,0x3411,0x3415,0x3419,0x341d,0x3421,0x3425,0x3429,0x342d,0x3431,0x3435,
+0x3439,0x343d,0x343d,0x304f,0x3441,0x3445,0x3449,0x344d,0x2f59,0x3451,0x3455,0x3459,0x2ead,0x345d,0x3461,0x3465,
+0x3469,0x346d,0x3471,0x3475,0x3479,0x347d,0x3483,0x3487,0x348b,0x348f,0x3493,0x3497,0x349b,0x34a1,0x34a7,0x34ab,
+0x34af,0x34b3,0x34b7,0x34bb,0x34bf,0x34c3,0x34c7,0x34c7,0x34cb,0x34d1,0x34d5,0x2c39,0x34d9,0x34dd,0x34e3,0x34e7,
+0x34eb,0x34ef,0x34f3,0x34f7,0x2f6d,0x34fb,0x34ff,0x3503,0x3509,0x350d,0x3513,0x3517,0x351b,0x351f,0x3523,0x3527,
+0x352b,0x352f,0x3533,0x3537,0x353b,0x353f,0x3545,0x3549,0x354d,0x3551,0x2b61,0x3555,0x355b,0x355f,0x355f,0x3565,
+0x3569,0x3569,0x356d,0x3571,0x3577,0x357d,0x3581,0x3585,0x3589,0x358d,0x3591,0x3595,0x3599,0x359d,0x35a1,0x2f71,
+0x35a5,0x35ab,0x35af,0x35b3,0x307f,0x35b3,0x35b7,0x2f79,0x35bb,0x35bf,0x35c3,0x35c7,0x2f7d,0x2af5,0x35cb,0x35cf,
+0x35d3,0x35d7,0x35db,0x35df,0x35e3,0x35e9,0x35ed,0x35f1,0x35f5,0x35f9,0x35fd,0x3603,0x3607,0x360b,0x360f,0x3613,
+0x3617,0x361b,0x361f,0x3623,0x2f81,0x3627,0x362b,0x3631,0x3635,0x3639,0x363d,0x2f89,0x3641,0x3645,0x3649,0x364d,
+0x3651,0x3655,0x3659,0x365d,0x2b65,0x309f,0x3661,0x3665,0x3669,0x366d,0x3673,0x3677,0x367b,0x367f,0x2f8d,0x3683,
+0x3689,0x368d,0x3691,0x3151,0x3695,0x3699,0x369d,0x36a1,0x36a5,0x36ab,0x36af,0x36b3,0x36b7,0x36bd,0x36c1,0x36c5,
+0x36c9,0x2c7d,0x36cd,0x36d1,0x36d7,0x36dd,0x36e3,0x36e7,0x36ed,0x36f1,0x36f5,0x36f9,0x36fd,0x2f91,0x2dd9,0x3701,
+0x3705,0x3709,0x370d,0x3713,0x3717,0x371b,0x371f,0x30af,0x3723,0x3727,0x372d,0x3731,0x3735,0x373b,0x3741,0x3745,
+0x30b3,0x3749,0x374d,0x3751,0x3755,0x3759,0x375d,0x3761,0x3767,0x376b,0x3771,0x3775,0x377b,0x30bb,0x377f,0x3783,
+0x3789,0x378d,0x3791,0x3797,0x379d,0x37a1,0x37a5,0x37a9,0x37ad,0x37ad,0x37b1,0x37b5,0x30c3,0x37b9,0x37bd,0x37c1,
+0x37c5,0x37c9,0x37cf,0x37d3,0x2c45,0x37d9,0x37df,0x37e3,0x37e9,0x37ef,0x37f5,0x37f9,0x30db,0x37fd,0x3803,0x3809,
+0x380f,0x3815,0x3819,0x3819,0x30df,0x3159,0x381d,0x3821,0x3825,0x3829,0x382f,0x2bad,0x30e7,0x3833,0x3837,0x2fbd,
+0x383d,0x3843,0x2f05,0x3849,0x384d,0x2fcd,0x3851,0x3855,0x3859,0x385f,0x385f,0x3865,0x3869,0x386d,0x3873,0x3877,
+0x387b,0x387f,0x3885,0x3889,0x388d,0x3891,0x3895,0x3899,0x389f,0x38a3,0x38a7,0x38ab,0x38af,0x38b3,0x38b7,0x38bd,
+0x38c3,0x38c7,0x38cd,0x38d1,0x38d7,0x38db,0x2fe5,0x38df,0x38e5,0x38eb,0x38ef,0x38f5,0x38f9,0x38ff,0x3903,0x3907,
+0x390b,0x390f,0x3913,0x3917,0x391d,0x3923,0x3929,0x3565,0x392f,0x3933,0x3937,0x393b,0x393f,0x3943,0x3947,0x394b,
+0x394f,0x3953,0x3957,0x395b,0x2c8d,0x3961,0x3965,0x3969,0x396d,0x3971,0x3975,0x2ff1,0x3979,0x397d,0x3981,0x3985,
+0x3989,0x398f,0x3995,0x399b,0x399f,0x39a3,0x39a7,0x39ab,0x39b1,0x39b5,0x39bb,0x39bf,0x39c3,0x39c9,0x39cf,0x39d3,
+0x2b99,0x39d7,0x39db,0x39df,0x39e3,0x39e7,0x39eb,0x3103,0x39ef,0x39f3,0x39f7,0x39fb,0x39ff,0x3a03,0x3a07,0x3a0b,
+0x3a0f,0x3a13,0x3a19,0x3a1d,0x3a21,0x3a25,0x3a29,0x3a2d,0x3a33,0x3a39,0x3a3d,0x3a41,0x3117,0x311b,0x3a45,0x3a49,
+0x3a4f,0x3a53,0x3a57,0x3a5b,0x3a5f,0x3a65,0x3a6b,0x3a6f,0x3a73,0x3a77,0x3a7d,0x311f,0x3a81,0x3a87,0x3a8d,0x3a91,
+0x3a95,0x3a99,0x3a9f,0x3aa3,0x3aa7,0x3aab,0x3aaf,0x3ab3,0x3ab7,0x3abb,0x3ac1,0x3ac5,0x3ac9,0x3acd,0x3ad3,0x3ad7,
+0x3adb,0x3adf,0x3ae3,0x3ae9,0x3aef,0x3af3,0x3af7,0x3afb,0x3b01,0x3b05,0x3137,0x3137,0x3b0b,0x3b0f,0x3b15,0x3b19,
+0x3b1d,0x3b21,0x3b25,0x3b29,0x3b2d,0x3b31,0x313b,0x3b37,0x3b3b,0x3b3f,0x3b43,0x3b47,0x3b4b,0x3b51,0x3b55,0x3b5b,
+0x3b61,0x3b67,0x3b6b,0x3b6f,0x3b73,0x3b77,0x3b7b,0x3b7f,0x3b83,0x3b87,1,1,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe00,0xfe00,0xfe00,
+0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,
+0xfe00,0xfe00,1,1,1,1,1,1,1,1,1,1,0xfe00,0xfe00,0xfe00,0xfe00,
+0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,
+0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xadc,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+0xadc,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x1283,0x1283,0x1283,0x1283,0xadc,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+0x1283,0x1283,0x1283,0x1283,0x3c54,1,0x3c54,1,0x3c54,0x3c54,0x3c54,0x3c54,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x3c54,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x3c54,
+1,1,1,1,0x3c54,1,1,1,0x3c54,1,0x3c54,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0x3b87,1,1,1,1,1
 };
 
-static const uint16_t norm2_nfc_data_extraData[7722]={
+static const uint16_t norm2_nfc_data_extraData[7724]={
 0xffff,0xffff,0x8670,0x44dc,0x8670,0x44c0,0x8670,0x44de,0x600,0x180,0x602,0x182,0x604,0x185,0x606,0x186,
 0x608,0x200,0x60c,0x205,0x60e,0x44d,0x610,0x189,0x612,0x3d44,0x614,0x18b,0x618,0x39a,0x61e,0x400,
 0x622,0x404,0x646,0x3d41,0x64a,0x3c00,0x8650,0x208,0x60e,0x3c04,0x646,0x3c08,0x8662,0x3c0c,0x602,0x20c,
@@ -716,403 +720,403 @@ static const uint16_t norm2_nfc_data_extraData[7722]={
 0x6132,0x61a6,0xe134,0x61a8,0x6132,0x61ac,0xe134,0x61ae,0x6132,0x61b2,0xe134,0x61b4,0x6132,0x61b8,0xe134,0x61ba,
 0xe132,0x61ee,0xe132,0x61f0,0xe132,0x61f2,0xe132,0x61f4,0xe132,0x61fc,0xb489,0x2e82,0x2134,0xb489,0x2e82,0x2138,
 0xb489,0x2e82,0x2156,0xb489,0x49c2,0x225c,0xb489,0x49c2,0x225e,0x3489,0xcf82,0x2696,0xb489,0xd5c2,0x2698,0x348b,
-0x2c02,0x2978,0x348b,0x2e82,0x2976,0xb48b,0x2f42,0x297c,0xb48b,0x6bc2,0x2b74,0xb48b,0x6bc2,0x2b76,0,0xe622,
-0x41,0x302,0x600,0x3d4c,0x602,0x3d48,0x606,0x3d54,0x8612,0x3d50,0xe622,0x41,0x308,0x8608,0x3bc,0xe622,
-0x41,0x30a,0x8602,0x3f4,0xca22,0x43,0x327,0x8602,0x3c10,0xe622,0x45,0x302,0x600,0x3d80,0x602,0x3d7c,
-0x606,0x3d88,0x8612,0x3d84,0xe622,0x49,0x308,0x8602,0x3c5c,0xe622,0x4f,0x302,0x600,0x3da4,0x602,0x3da0,
-0x606,0x3dac,0x8612,0x3da8,0xe622,0x4f,0x303,0x602,0x3c98,0x608,0x458,0x8610,0x3c9c,0xe622,0x4f,0x308,
-0x8608,0x454,0xe622,0x55,0x308,0x600,0x3b6,0x602,0x3ae,0x608,0x3aa,0x8618,0x3b2,0xe622,0x61,0x302,
-0x600,0x3d4e,0x602,0x3d4a,0x606,0x3d56,0x8612,0x3d52,0xe622,0x61,0x308,0x8608,0x3be,0xe622,0x61,0x30a,
-0x8602,0x3f6,0xca22,0x63,0x327,0x8602,0x3c12,0xe622,0x65,0x302,0x600,0x3d82,0x602,0x3d7e,0x606,0x3d8a,
-0x8612,0x3d86,0xe622,0x69,0x308,0x8602,0x3c5e,0xe622,0x6f,0x302,0x600,0x3da6,0x602,0x3da2,0x606,0x3dae,
-0x8612,0x3daa,0xe622,0x6f,0x303,0x602,0x3c9a,0x608,0x45a,0x8610,0x3c9e,0xe622,0x6f,0x308,0x8608,0x456,
-0xe622,0x75,0x308,0x600,0x3b8,0x602,0x3b0,0x608,0x3ac,0x8618,0x3b4,0xe622,0x41,0x306,0x600,0x3d60,
-0x602,0x3d5c,0x606,0x3d68,0x8612,0x3d64,0xe622,0x61,0x306,0x600,0x3d62,0x602,0x3d5e,0x606,0x3d6a,0x8612,
-0x3d66,0xe622,0x45,0x304,0x600,0x3c28,0x8602,0x3c2c,0xe622,0x65,0x304,0x600,0x3c2a,0x8602,0x3c2e,0xe622,
-0x4f,0x304,0x600,0x3ca0,0x8602,0x3ca4,0xe622,0x6f,0x304,0x600,0x3ca2,0x8602,0x3ca6,0xe622,0x53,0x301,
-0x860e,0x3cc8,0xe622,0x73,0x301,0x860e,0x3cca,0xe622,0x53,0x30c,0x860e,0x3ccc,0xe622,0x73,0x30c,0x860e,
-0x3cce,0xe622,0x55,0x303,0x8602,0x3cf0,0xe622,0x75,0x303,0x8602,0x3cf2,0xe622,0x55,0x304,0x8610,0x3cf4,
-0xe622,0x75,0x304,0x8610,0x3cf6,0xd822,0x4f,0x31b,0x600,0x3db8,0x602,0x3db4,0x606,0x3dc0,0x612,0x3dbc,
-0x8646,0x3dc4,0xd822,0x6f,0x31b,0x600,0x3dba,0x602,0x3db6,0x606,0x3dc2,0x612,0x3dbe,0x8646,0x3dc6,0xd822,
-0x55,0x31b,0x600,0x3dd4,0x602,0x3dd0,0x606,0x3ddc,0x612,0x3dd8,0x8646,0x3de0,0xd822,0x75,0x31b,0x600,
-0x3dd6,0x602,0x3dd2,0x606,0x3dde,0x612,0x3dda,0x8646,0x3de2,0xca22,0x4f,0x328,0x8608,0x3d8,0xca22,0x6f,
-0x328,0x8608,0x3da,0xe622,0x41,0x307,0x8608,0x3c0,0xe622,0x61,0x307,0x8608,0x3c2,0xca22,0x45,0x327,
-0x860c,0x3c38,0xca22,0x65,0x327,0x860c,0x3c3a,0xe622,0x4f,0x307,0x8608,0x460,0xe622,0x6f,0x307,0x8608,
-0x462,0xe622,0x3b1,0x301,0x868a,0x3f68,0xe622,0x3b7,0x301,0x868a,0x3f88,0xe622,0x3b9,0x308,0x600,0x3fa4,
-0x602,0x720,0x8684,0x3fae,0xe622,0x3c5,0x308,0x600,0x3fc4,0x602,0x760,0x8684,0x3fce,0xe622,0x3c9,0x301,
-0x868a,0x3fe8,0x22,0xcc6,0xcc2,0x99aa,0x1996,0x22,0xdd9,0xdcf,0x9b94,0x1bba,0xdc22,0x4c,0x323,0x8608,
-0x3c70,0xdc22,0x6c,0x323,0x8608,0x3c72,0xdc22,0x52,0x323,0x8608,0x3cb8,0xdc22,0x72,0x323,0x8608,0x3cba,
-0xdc22,0x53,0x323,0x860e,0x3cd0,0xdc22,0x73,0x323,0x860e,0x3cd2,0xdc22,0x41,0x323,0x604,0x3d58,0x860c,
-0x3d6c,0xdc22,0x61,0x323,0x604,0x3d5a,0x860c,0x3d6e,0xdc22,0x45,0x323,0x8604,0x3d8c,0xdc22,0x65,0x323,
-0x8604,0x3d8e,0xdc22,0x4f,0x323,0x8604,0x3db0,0xdc22,0x6f,0x323,0x8604,0x3db2,0xe622,0x3b1,0x313,0x600,
-0x3e05,0x602,0x3e09,0x684,0x3e0d,0x868a,0x3f00,0xe622,0x3b1,0x314,0x600,0x3e07,0x602,0x3e0b,0x684,0x3e0f,
-0x868a,0x3f02,0x1f00,0xe663,0x3b1,0x313,0x300,0x868a,0x3f04,0x1f01,0xe663,0x3b1,0x314,0x300,0x868a,0x3f06,
-0x1f00,0xe663,0x3b1,0x313,0x301,0x868a,0x3f08,0x1f01,0xe663,0x3b1,0x314,0x301,0x868a,0x3f0a,0x1f00,0xe663,
-0x3b1,0x313,0x342,0x868a,0x3f0c,0x1f01,0xe663,0x3b1,0x314,0x342,0x868a,0x3f0e,0xe622,0x391,0x313,0x600,
-0x3e15,0x602,0x3e19,0x684,0x3e1d,0x868a,0x3f10,0xe622,0x391,0x314,0x600,0x3e17,0x602,0x3e1b,0x684,0x3e1f,
-0x868a,0x3f12,0x1f08,0xe663,0x391,0x313,0x300,0x868a,0x3f14,0x1f09,0xe663,0x391,0x314,0x300,0x868a,0x3f16,
-0x1f08,0xe663,0x391,0x313,0x301,0x868a,0x3f18,0x1f09,0xe663,0x391,0x314,0x301,0x868a,0x3f1a,0x1f08,0xe663,
-0x391,0x313,0x342,0x868a,0x3f1c,0x1f09,0xe663,0x391,0x314,0x342,0x868a,0x3f1e,0xe622,0x3b5,0x313,0x600,
-0x3e24,0x8602,0x3e28,0xe622,0x3b5,0x314,0x600,0x3e26,0x8602,0x3e2a,0xe622,0x395,0x313,0x600,0x3e34,0x8602,
-0x3e38,0xe622,0x395,0x314,0x600,0x3e36,0x8602,0x3e3a,0xe622,0x3b7,0x313,0x600,0x3e45,0x602,0x3e49,0x684,
-0x3e4d,0x868a,0x3f20,0xe622,0x3b7,0x314,0x600,0x3e47,0x602,0x3e4b,0x684,0x3e4f,0x868a,0x3f22,0x1f20,0xe663,
-0x3b7,0x313,0x300,0x868a,0x3f24,0x1f21,0xe663,0x3b7,0x314,0x300,0x868a,0x3f26,0x1f20,0xe663,0x3b7,0x313,
-0x301,0x868a,0x3f28,0x1f21,0xe663,0x3b7,0x314,0x301,0x868a,0x3f2a,0x1f20,0xe663,0x3b7,0x313,0x342,0x868a,
-0x3f2c,0x1f21,0xe663,0x3b7,0x314,0x342,0x868a,0x3f2e,0xe622,0x397,0x313,0x600,0x3e55,0x602,0x3e59,0x684,
-0x3e5d,0x868a,0x3f30,0xe622,0x397,0x314,0x600,0x3e57,0x602,0x3e5b,0x684,0x3e5f,0x868a,0x3f32,0x1f28,0xe663,
-0x397,0x313,0x300,0x868a,0x3f34,0x1f29,0xe663,0x397,0x314,0x300,0x868a,0x3f36,0x1f28,0xe663,0x397,0x313,
-0x301,0x868a,0x3f38,0x1f29,0xe663,0x397,0x314,0x301,0x868a,0x3f3a,0x1f28,0xe663,0x397,0x313,0x342,0x868a,
-0x3f3c,0x1f29,0xe663,0x397,0x314,0x342,0x868a,0x3f3e,0xe622,0x3b9,0x313,0x600,0x3e64,0x602,0x3e68,0x8684,
-0x3e6c,0xe622,0x3b9,0x314,0x600,0x3e66,0x602,0x3e6a,0x8684,0x3e6e,0xe622,0x399,0x313,0x600,0x3e74,0x602,
-0x3e78,0x8684,0x3e7c,0xe622,0x399,0x314,0x600,0x3e76,0x602,0x3e7a,0x8684,0x3e7e,0xe622,0x3bf,0x313,0x600,
-0x3e84,0x8602,0x3e88,0xe622,0x3bf,0x314,0x600,0x3e86,0x8602,0x3e8a,0xe622,0x39f,0x313,0x600,0x3e94,0x8602,
-0x3e98,0xe622,0x39f,0x314,0x600,0x3e96,0x8602,0x3e9a,0xe622,0x3c5,0x313,0x600,0x3ea4,0x602,0x3ea8,0x8684,
-0x3eac,0xe622,0x3c5,0x314,0x600,0x3ea6,0x602,0x3eaa,0x8684,0x3eae,0xe622,0x3a5,0x314,0x600,0x3eb6,0x602,
-0x3eba,0x8684,0x3ebe,0xe622,0x3c9,0x313,0x600,0x3ec5,0x602,0x3ec9,0x684,0x3ecd,0x868a,0x3f40,0xe622,0x3c9,
-0x314,0x600,0x3ec7,0x602,0x3ecb,0x684,0x3ecf,0x868a,0x3f42,0x1f60,0xe663,0x3c9,0x313,0x300,0x868a,0x3f44,
-0x1f61,0xe663,0x3c9,0x314,0x300,0x868a,0x3f46,0x1f60,0xe663,0x3c9,0x313,0x301,0x868a,0x3f48,0x1f61,0xe663,
-0x3c9,0x314,0x301,0x868a,0x3f4a,0x1f60,0xe663,0x3c9,0x313,0x342,0x868a,0x3f4c,0x1f61,0xe663,0x3c9,0x314,
-0x342,0x868a,0x3f4e,0xe622,0x3a9,0x313,0x600,0x3ed5,0x602,0x3ed9,0x684,0x3edd,0x868a,0x3f50,0xe622,0x3a9,
-0x314,0x600,0x3ed7,0x602,0x3edb,0x684,0x3edf,0x868a,0x3f52,0x1f68,0xe663,0x3a9,0x313,0x300,0x868a,0x3f54,
-0x1f69,0xe663,0x3a9,0x314,0x300,0x868a,0x3f56,0x1f68,0xe663,0x3a9,0x313,0x301,0x868a,0x3f58,0x1f69,0xe663,
-0x3a9,0x314,0x301,0x868a,0x3f5a,0x1f68,0xe663,0x3a9,0x313,0x342,0x868a,0x3f5c,0x1f69,0xe663,0x3a9,0x314,
-0x342,0x868a,0x3f5e,0xe622,0x3b1,0x300,0x868a,0x3f64,0xe622,0x3b7,0x300,0x868a,0x3f84,0xe622,0x3c9,0x300,
-0x868a,0x3fe4,0xe622,0x3b1,0x342,0x868a,0x3f6e,0xe622,0x3b7,0x342,0x868a,0x3f8e,0xe622,0x3c9,0x342,0x868a,
-0x3fee,0xe622,0x41,0x300,0xe622,0x41,0x301,0xe622,0x41,0x303,0xe622,0x45,0x300,0xe622,0x45,0x301,
-0xe622,0x45,0x308,0xe622,0x49,0x300,0xe622,0x49,0x301,0xe622,0x49,0x302,0xe622,0x4e,0x303,0xe622,
-0x4f,0x300,0xe622,0x4f,0x301,0xe622,0x55,0x300,0xe622,0x55,0x301,0xe622,0x55,0x302,0xe622,0x59,
-0x301,0xe622,0x61,0x300,0xe622,0x61,0x301,0xe622,0x61,0x303,0xe622,0x65,0x300,0xe622,0x65,0x301,
-0xe622,0x65,0x308,0xe622,0x69,0x300,0xe622,0x69,0x301,0xe622,0x69,0x302,0xe622,0x6e,0x303,0xe622,
-0x6f,0x300,0xe622,0x6f,0x301,0xe622,0x75,0x300,0xe622,0x75,0x301,0xe622,0x75,0x302,0xe622,0x79,
-0x301,0xe622,0x79,0x308,0xe622,0x41,0x304,0xe622,0x61,0x304,0xca02,0x41,0x328,0xca02,0x61,0x328,
-0xe622,0x43,0x301,0xe622,0x63,0x301,0xe622,0x43,0x302,0xe622,0x63,0x302,0xe622,0x43,0x307,0xe622,
-0x63,0x307,0xe622,0x43,0x30c,0xe622,0x63,0x30c,0xe622,0x44,0x30c,0xe622,0x64,0x30c,0xe622,0x45,
-0x306,0xe622,0x65,0x306,0xe622,0x45,0x307,0xe622,0x65,0x307,0xca02,0x45,0x328,0xca02,0x65,0x328,
-0xe622,0x45,0x30c,0xe622,0x65,0x30c,0xe622,0x47,0x302,0xe622,0x67,0x302,0xe622,0x47,0x306,0xe622,
-0x67,0x306,0xe622,0x47,0x307,0xe622,0x67,0x307,0xca02,0x47,0x327,0xca02,0x67,0x327,0xe622,0x48,
-0x302,0xe622,0x68,0x302,0xe622,0x49,0x303,0xe622,0x69,0x303,0xe622,0x49,0x304,0xe622,0x69,0x304,
-0xe622,0x49,0x306,0xe622,0x69,0x306,0xca02,0x49,0x328,0xca02,0x69,0x328,0xe622,0x49,0x307,0xe602,
-0x4a,0x302,0xe602,0x6a,0x302,0xca02,0x4b,0x327,0xca02,0x6b,0x327,0xe622,0x4c,0x301,0xe622,0x6c,
-0x301,0xca02,0x4c,0x327,0xca02,0x6c,0x327,0xe622,0x4c,0x30c,0xe622,0x6c,0x30c,0xe622,0x4e,0x301,
-0xe622,0x6e,0x301,0xca02,0x4e,0x327,0xca02,0x6e,0x327,0xe622,0x4e,0x30c,0xe622,0x6e,0x30c,0xe622,
-0x4f,0x306,0xe622,0x6f,0x306,0xe622,0x4f,0x30b,0xe622,0x6f,0x30b,0xe622,0x52,0x301,0xe622,0x72,
-0x301,0xca02,0x52,0x327,0xca02,0x72,0x327,0xe622,0x52,0x30c,0xe622,0x72,0x30c,0xe622,0x53,0x302,
-0xe622,0x73,0x302,0xca02,0x53,0x327,0xca02,0x73,0x327,0xca02,0x54,0x327,0xca02,0x74,0x327,0xe622,
-0x54,0x30c,0xe622,0x74,0x30c,0xe622,0x55,0x306,0xe622,0x75,0x306,0xe622,0x55,0x30a,0xe622,0x75,
-0x30a,0xe622,0x55,0x30b,0xe622,0x75,0x30b,0xca02,0x55,0x328,0xca02,0x75,0x328,0xe622,0x57,0x302,
-0xe622,0x77,0x302,0xe622,0x59,0x302,0xe622,0x79,0x302,0xe622,0x59,0x308,0xe622,0x5a,0x301,0xe622,
-0x7a,0x301,0xe622,0x5a,0x307,0xe622,0x7a,0x307,0xe622,0x5a,0x30c,0xe622,0x7a,0x30c,0xe622,0x41,
-0x30c,0xe622,0x61,0x30c,0xe622,0x49,0x30c,0xe622,0x69,0x30c,0xe622,0x4f,0x30c,0xe622,0x6f,0x30c,
-0xe622,0x55,0x30c,0xe622,0x75,0x30c,0xdc,0xe663,0x55,0x308,0x304,0xfc,0xe663,0x75,0x308,0x304,
-0xdc,0xe663,0x55,0x308,0x301,0xfc,0xe663,0x75,0x308,0x301,0xdc,0xe663,0x55,0x308,0x30c,0xfc,
-0xe663,0x75,0x308,0x30c,0xdc,0xe663,0x55,0x308,0x300,0xfc,0xe663,0x75,0x308,0x300,0xc4,0xe663,
-0x41,0x308,0x304,0xe4,0xe663,0x61,0x308,0x304,0x226,0xe663,0x41,0x307,0x304,0x227,0xe663,0x61,
-0x307,0x304,0xe602,0xc6,0x304,0xe602,0xe6,0x304,0xe622,0x47,0x30c,0xe622,0x67,0x30c,0xe622,0x4b,
-0x30c,0xe622,0x6b,0x30c,0x1ea,0xe643,0x4f,0x328,0x304,0x1eb,0xe643,0x6f,0x328,0x304,0xe602,0x1b7,
-0x30c,0xe602,0x292,0x30c,0xe602,0x6a,0x30c,0xe622,0x47,0x301,0xe622,0x67,0x301,0xe622,0x4e,0x300,
-0xe622,0x6e,0x300,0xc5,0xe663,0x41,0x30a,0x301,0xe5,0xe663,0x61,0x30a,0x301,0xe602,0xc6,0x301,
-0xe602,0xe6,0x301,0xe602,0xd8,0x301,0xe602,0xf8,0x301,0xe622,0x41,0x30f,0xe622,0x61,0x30f,0xe622,
-0x41,0x311,0xe622,0x61,0x311,0xe622,0x45,0x30f,0xe622,0x65,0x30f,0xe622,0x45,0x311,0xe622,0x65,
-0x311,0xe622,0x49,0x30f,0xe622,0x69,0x30f,0xe622,0x49,0x311,0xe622,0x69,0x311,0xe622,0x4f,0x30f,
-0xe622,0x6f,0x30f,0xe622,0x4f,0x311,0xe622,0x6f,0x311,0xe622,0x52,0x30f,0xe622,0x72,0x30f,0xe622,
-0x52,0x311,0xe622,0x72,0x311,0xe622,0x55,0x30f,0xe622,0x75,0x30f,0xe622,0x55,0x311,0xe622,0x75,
-0x311,0xdc22,0x53,0x326,0xdc22,0x73,0x326,0xdc22,0x54,0x326,0xdc22,0x74,0x326,0xe622,0x48,0x30c,
-0xe622,0x68,0x30c,0xd6,0xe663,0x4f,0x308,0x304,0xf6,0xe663,0x6f,0x308,0x304,0xd5,0xe663,0x4f,
-0x303,0x304,0xf5,0xe663,0x6f,0x303,0x304,0x22e,0xe663,0x4f,0x307,0x304,0x22f,0xe663,0x6f,0x307,
-0x304,0xe622,0x59,0x304,0xe622,0x79,0x304,0xe602,0xa8,0x301,0xe602,0x391,0x301,0xe602,0x395,0x301,
-0xe602,0x397,0x301,0xe602,0x399,0x301,0xe602,0x39f,0x301,0xe602,0x3a5,0x301,0xe602,0x3a9,0x301,0x3ca,
-0xe643,0x3b9,0x308,0x301,0xe602,0x399,0x308,0xe602,0x3a5,0x308,0xe602,0x3b5,0x301,0xe602,0x3b9,0x301,
-0x3cb,0xe643,0x3c5,0x308,0x301,0xe602,0x3bf,0x301,0xe602,0x3c5,0x301,0xe602,0x3d2,0x301,0xe602,0x3d2,
-0x308,0xe602,0x415,0x300,0xe602,0x415,0x308,0xe602,0x413,0x301,0xe602,0x406,0x308,0xe602,0x41a,0x301,
-0xe602,0x418,0x300,0xe602,0x423,0x306,0xe602,0x418,0x306,0xe602,0x438,0x306,0xe602,0x435,0x300,0xe602,
-0x435,0x308,0xe602,0x433,0x301,0xe602,0x456,0x308,0xe602,0x43a,0x301,0xe602,0x438,0x300,0xe602,0x443,
-0x306,0xe602,0x474,0x30f,0xe602,0x475,0x30f,0xe602,0x416,0x306,0xe602,0x436,0x306,0xe602,0x410,0x306,
-0xe602,0x430,0x306,0xe602,0x410,0x308,0xe602,0x430,0x308,0xe602,0x415,0x306,0xe602,0x435,0x306,0xe602,
-0x4d8,0x308,0xe602,0x4d9,0x308,0xe602,0x416,0x308,0xe602,0x436,0x308,0xe602,0x417,0x308,0xe602,0x437,
-0x308,0xe602,0x418,0x304,0xe602,0x438,0x304,0xe602,0x418,0x308,0xe602,0x438,0x308,0xe602,0x41e,0x308,
-0xe602,0x43e,0x308,0xe602,0x4e8,0x308,0xe602,0x4e9,0x308,0xe602,0x42d,0x308,0xe602,0x44d,0x308,0xe602,
-0x423,0x304,0xe602,0x443,0x304,0xe602,0x423,0x308,0xe602,0x443,0x308,0xe602,0x423,0x30b,0xe602,0x443,
-0x30b,0xe602,0x427,0x308,0xe602,0x447,0x308,0xe602,0x42b,0x308,0xe602,0x44b,0x308,0xe622,0x627,0x653,
-0xe622,0x627,0x654,0xe602,0x648,0x654,0xdc02,0x627,0x655,0xe602,0x64a,0x654,0xe602,0x6d5,0x654,0xe602,
-0x6c1,0x654,0xe602,0x6d2,0x654,0x702,0x928,0x93c,0x702,0x930,0x93c,0x702,0x933,0x93c,2,0x9c7,
-0x9be,2,0x9c7,0x9d7,2,0xb47,0xb56,2,0xb47,0xb3e,2,0xb47,0xb57,2,0xb92,0xbd7,
-2,0xbc6,0xbbe,2,0xbc7,0xbbe,2,0xbc6,0xbd7,0x5b02,0xc46,0xc56,2,0xcbf,0xcd5,2,
-0xcc6,0xcd5,2,0xcc6,0xcd6,0xcca,0x43,0xcc6,0xcc2,0xcd5,2,0xd46,0xd3e,2,0xd47,0xd3e,
-2,0xd46,0xd57,0x902,0xdd9,0xdca,0xddc,0x943,0xdd9,0xdcf,0xdca,2,0xdd9,0xddf,2,0x1025,
-0x102e,2,0x1b05,0x1b35,2,0x1b07,0x1b35,2,0x1b09,0x1b35,2,0x1b0b,0x1b35,2,0x1b0d,0x1b35,
-2,0x1b11,0x1b35,2,0x1b3a,0x1b35,2,0x1b3c,0x1b35,2,0x1b3e,0x1b35,2,0x1b3f,0x1b35,2,
-0x1b42,0x1b35,0xdc22,0x41,0x325,0xdc22,0x61,0x325,0xe622,0x42,0x307,0xe622,0x62,0x307,0xdc02,0x42,
-0x323,0xdc02,0x62,0x323,0xdc02,0x42,0x331,0xdc02,0x62,0x331,0xc7,0xe643,0x43,0x327,0x301,0xe7,
-0xe643,0x63,0x327,0x301,0xe622,0x44,0x307,0xe622,0x64,0x307,0xdc22,0x44,0x323,0xdc22,0x64,0x323,
-0xdc22,0x44,0x331,0xdc22,0x64,0x331,0xca02,0x44,0x327,0xca02,0x64,0x327,0xdc22,0x44,0x32d,0xdc22,
-0x64,0x32d,0x112,0xe663,0x45,0x304,0x300,0x113,0xe663,0x65,0x304,0x300,0x112,0xe663,0x45,0x304,
-0x301,0x113,0xe663,0x65,0x304,0x301,0xdc22,0x45,0x32d,0xdc22,0x65,0x32d,0xdc22,0x45,0x330,0xdc22,
-0x65,0x330,0x228,0xe643,0x45,0x327,0x306,0x229,0xe643,0x65,0x327,0x306,0xe602,0x46,0x307,0xe602,
-0x66,0x307,0xe622,0x47,0x304,0xe622,0x67,0x304,0xe622,0x48,0x307,0xe622,0x68,0x307,0xdc22,0x48,
-0x323,0xdc22,0x68,0x323,0xe622,0x48,0x308,0xe622,0x68,0x308,0xca02,0x48,0x327,0xca02,0x68,0x327,
-0xdc22,0x48,0x32e,0xdc22,0x68,0x32e,0xdc22,0x49,0x330,0xdc22,0x69,0x330,0xcf,0xe663,0x49,0x308,
-0x301,0xef,0xe663,0x69,0x308,0x301,0xe622,0x4b,0x301,0xe622,0x6b,0x301,0xdc22,0x4b,0x323,0xdc22,
-0x6b,0x323,0xdc22,0x4b,0x331,0xdc22,0x6b,0x331,0x1e36,0xe663,0x4c,0x323,0x304,0x1e37,0xe663,0x6c,
-0x323,0x304,0xdc22,0x4c,0x331,0xdc22,0x6c,0x331,0xdc22,0x4c,0x32d,0xdc22,0x6c,0x32d,0xe622,0x4d,
-0x301,0xe622,0x6d,0x301,0xe622,0x4d,0x307,0xe622,0x6d,0x307,0xdc02,0x4d,0x323,0xdc02,0x6d,0x323,
-0xe622,0x4e,0x307,0xe622,0x6e,0x307,0xdc22,0x4e,0x323,0xdc22,0x6e,0x323,0xdc22,0x4e,0x331,0xdc22,
-0x6e,0x331,0xdc22,0x4e,0x32d,0xdc22,0x6e,0x32d,0xd5,0xe663,0x4f,0x303,0x301,0xf5,0xe663,0x6f,
-0x303,0x301,0xd5,0xe663,0x4f,0x303,0x308,0xf5,0xe663,0x6f,0x303,0x308,0x14c,0xe663,0x4f,0x304,
-0x300,0x14d,0xe663,0x6f,0x304,0x300,0x14c,0xe663,0x4f,0x304,0x301,0x14d,0xe663,0x6f,0x304,0x301,
-0xe602,0x50,0x301,0xe602,0x70,0x301,0xe602,0x50,0x307,0xe602,0x70,0x307,0xe622,0x52,0x307,0xe622,
-0x72,0x307,0x1e5a,0xe663,0x52,0x323,0x304,0x1e5b,0xe663,0x72,0x323,0x304,0xdc22,0x52,0x331,0xdc22,
-0x72,0x331,0xe622,0x53,0x307,0xe622,0x73,0x307,0x15a,0xe663,0x53,0x301,0x307,0x15b,0xe663,0x73,
-0x301,0x307,0x160,0xe663,0x53,0x30c,0x307,0x161,0xe663,0x73,0x30c,0x307,0x1e62,0xe663,0x53,0x323,
-0x307,0x1e63,0xe663,0x73,0x323,0x307,0xe622,0x54,0x307,0xe622,0x74,0x307,0xdc22,0x54,0x323,0xdc22,
-0x74,0x323,0xdc22,0x54,0x331,0xdc22,0x74,0x331,0xdc22,0x54,0x32d,0xdc22,0x74,0x32d,0xdc22,0x55,
-0x324,0xdc22,0x75,0x324,0xdc22,0x55,0x330,0xdc22,0x75,0x330,0xdc22,0x55,0x32d,0xdc22,0x75,0x32d,
-0x168,0xe663,0x55,0x303,0x301,0x169,0xe663,0x75,0x303,0x301,0x16a,0xe663,0x55,0x304,0x308,0x16b,
-0xe663,0x75,0x304,0x308,0xe622,0x56,0x303,0xe622,0x76,0x303,0xdc02,0x56,0x323,0xdc02,0x76,0x323,
-0xe622,0x57,0x300,0xe622,0x77,0x300,0xe622,0x57,0x301,0xe622,0x77,0x301,0xe622,0x57,0x308,0xe622,
-0x77,0x308,0xe622,0x57,0x307,0xe622,0x77,0x307,0xdc02,0x57,0x323,0xdc02,0x77,0x323,0xe602,0x58,
-0x307,0xe602,0x78,0x307,0xe602,0x58,0x308,0xe602,0x78,0x308,0xe622,0x59,0x307,0xe622,0x79,0x307,
-0xe622,0x5a,0x302,0xe622,0x7a,0x302,0xdc02,0x5a,0x323,0xdc02,0x7a,0x323,0xdc02,0x5a,0x331,0xdc02,
-0x7a,0x331,0xdc22,0x68,0x331,0xe622,0x74,0x308,0xe622,0x77,0x30a,0xe622,0x79,0x30a,0xe602,0x17f,
-0x307,0xe622,0x41,0x309,0xe622,0x61,0x309,0xc2,0xe663,0x41,0x302,0x301,0xe2,0xe663,0x61,0x302,
-0x301,0xc2,0xe663,0x41,0x302,0x300,0xe2,0xe663,0x61,0x302,0x300,0xc2,0xe663,0x41,0x302,0x309,
-0xe2,0xe663,0x61,0x302,0x309,0xc2,0xe663,0x41,0x302,0x303,0xe2,0xe663,0x61,0x302,0x303,0x1ea0,
-0xe663,0x41,0x323,0x302,0x1ea1,0xe663,0x61,0x323,0x302,0x102,0xe663,0x41,0x306,0x301,0x103,0xe663,
-0x61,0x306,0x301,0x102,0xe663,0x41,0x306,0x300,0x103,0xe663,0x61,0x306,0x300,0x102,0xe663,0x41,
-0x306,0x309,0x103,0xe663,0x61,0x306,0x309,0x102,0xe663,0x41,0x306,0x303,0x103,0xe663,0x61,0x306,
-0x303,0x1ea0,0xe663,0x41,0x323,0x306,0x1ea1,0xe663,0x61,0x323,0x306,0xe622,0x45,0x309,0xe622,0x65,
-0x309,0xe622,0x45,0x303,0xe622,0x65,0x303,0xca,0xe663,0x45,0x302,0x301,0xea,0xe663,0x65,0x302,
-0x301,0xca,0xe663,0x45,0x302,0x300,0xea,0xe663,0x65,0x302,0x300,0xca,0xe663,0x45,0x302,0x309,
-0xea,0xe663,0x65,0x302,0x309,0xca,0xe663,0x45,0x302,0x303,0xea,0xe663,0x65,0x302,0x303,0x1eb8,
-0xe663,0x45,0x323,0x302,0x1eb9,0xe663,0x65,0x323,0x302,0xe622,0x49,0x309,0xe622,0x69,0x309,0xdc22,
-0x49,0x323,0xdc22,0x69,0x323,0xe622,0x4f,0x309,0xe622,0x6f,0x309,0xd4,0xe663,0x4f,0x302,0x301,
-0xf4,0xe663,0x6f,0x302,0x301,0xd4,0xe663,0x4f,0x302,0x300,0xf4,0xe663,0x6f,0x302,0x300,0xd4,
-0xe663,0x4f,0x302,0x309,0xf4,0xe663,0x6f,0x302,0x309,0xd4,0xe663,0x4f,0x302,0x303,0xf4,0xe663,
-0x6f,0x302,0x303,0x1ecc,0xe663,0x4f,0x323,0x302,0x1ecd,0xe663,0x6f,0x323,0x302,0x1a0,0xe663,0x4f,
-0x31b,0x301,0x1a1,0xe663,0x6f,0x31b,0x301,0x1a0,0xe663,0x4f,0x31b,0x300,0x1a1,0xe663,0x6f,0x31b,
-0x300,0x1a0,0xe663,0x4f,0x31b,0x309,0x1a1,0xe663,0x6f,0x31b,0x309,0x1a0,0xe663,0x4f,0x31b,0x303,
-0x1a1,0xe663,0x6f,0x31b,0x303,0x1a0,0xdc63,0x4f,0x31b,0x323,0x1a1,0xdc63,0x6f,0x31b,0x323,0xdc22,
-0x55,0x323,0xdc22,0x75,0x323,0xe622,0x55,0x309,0xe622,0x75,0x309,0x1af,0xe663,0x55,0x31b,0x301,
-0x1b0,0xe663,0x75,0x31b,0x301,0x1af,0xe663,0x55,0x31b,0x300,0x1b0,0xe663,0x75,0x31b,0x300,0x1af,
-0xe663,0x55,0x31b,0x309,0x1b0,0xe663,0x75,0x31b,0x309,0x1af,0xe663,0x55,0x31b,0x303,0x1b0,0xe663,
-0x75,0x31b,0x303,0x1af,0xdc63,0x55,0x31b,0x323,0x1b0,0xdc63,0x75,0x31b,0x323,0xe622,0x59,0x300,
-0xe622,0x79,0x300,0xdc02,0x59,0x323,0xdc02,0x79,0x323,0xe622,0x59,0x309,0xe622,0x79,0x309,0xe622,
-0x59,0x303,0xe622,0x79,0x303,0x1f10,0xe643,0x3b5,0x313,0x300,0x1f11,0xe643,0x3b5,0x314,0x300,0x1f10,
-0xe643,0x3b5,0x313,0x301,0x1f11,0xe643,0x3b5,0x314,0x301,0x1f18,0xe643,0x395,0x313,0x300,0x1f19,0xe643,
-0x395,0x314,0x300,0x1f18,0xe643,0x395,0x313,0x301,0x1f19,0xe643,0x395,0x314,0x301,0x1f30,0xe643,0x3b9,
-0x313,0x300,0x1f31,0xe643,0x3b9,0x314,0x300,0x1f30,0xe643,0x3b9,0x313,0x301,0x1f31,0xe643,0x3b9,0x314,
-0x301,0x1f30,0xe643,0x3b9,0x313,0x342,0x1f31,0xe643,0x3b9,0x314,0x342,0x1f38,0xe643,0x399,0x313,0x300,
-0x1f39,0xe643,0x399,0x314,0x300,0x1f38,0xe643,0x399,0x313,0x301,0x1f39,0xe643,0x399,0x314,0x301,0x1f38,
-0xe643,0x399,0x313,0x342,0x1f39,0xe643,0x399,0x314,0x342,0x1f40,0xe643,0x3bf,0x313,0x300,0x1f41,0xe643,
-0x3bf,0x314,0x300,0x1f40,0xe643,0x3bf,0x313,0x301,0x1f41,0xe643,0x3bf,0x314,0x301,0x1f48,0xe643,0x39f,
-0x313,0x300,0x1f49,0xe643,0x39f,0x314,0x300,0x1f48,0xe643,0x39f,0x313,0x301,0x1f49,0xe643,0x39f,0x314,
-0x301,0x1f50,0xe643,0x3c5,0x313,0x300,0x1f51,0xe643,0x3c5,0x314,0x300,0x1f50,0xe643,0x3c5,0x313,0x301,
-0x1f51,0xe643,0x3c5,0x314,0x301,0x1f50,0xe643,0x3c5,0x313,0x342,0x1f51,0xe643,0x3c5,0x314,0x342,0x1f59,
-0xe643,0x3a5,0x314,0x300,0x1f59,0xe643,0x3a5,0x314,0x301,0x1f59,0xe643,0x3a5,0x314,0x342,0xe602,0x3b5,
-0x300,0xe602,0x3b9,0x300,0xe602,0x3bf,0x300,0xe602,0x3c5,0x300,0x1f00,0xf063,0x3b1,0x313,0x345,0x1f01,
-0xf063,0x3b1,0x314,0x345,0x1f02,0x345,2,0xf044,0x3b1,0x313,0x300,0x345,0x1f03,0x345,2,0xf044,
-0x3b1,0x314,0x300,0x345,0x1f04,0x345,2,0xf044,0x3b1,0x313,0x301,0x345,0x1f05,0x345,2,0xf044,
-0x3b1,0x314,0x301,0x345,0x1f06,0x345,2,0xf044,0x3b1,0x313,0x342,0x345,0x1f07,0x345,2,0xf044,
-0x3b1,0x314,0x342,0x345,0x1f08,0xf063,0x391,0x313,0x345,0x1f09,0xf063,0x391,0x314,0x345,0x1f0a,0x345,
-2,0xf044,0x391,0x313,0x300,0x345,0x1f0b,0x345,2,0xf044,0x391,0x314,0x300,0x345,0x1f0c,0x345,
-2,0xf044,0x391,0x313,0x301,0x345,0x1f0d,0x345,2,0xf044,0x391,0x314,0x301,0x345,0x1f0e,0x345,
-2,0xf044,0x391,0x313,0x342,0x345,0x1f0f,0x345,2,0xf044,0x391,0x314,0x342,0x345,0x1f20,0xf063,
-0x3b7,0x313,0x345,0x1f21,0xf063,0x3b7,0x314,0x345,0x1f22,0x345,2,0xf044,0x3b7,0x313,0x300,0x345,
-0x1f23,0x345,2,0xf044,0x3b7,0x314,0x300,0x345,0x1f24,0x345,2,0xf044,0x3b7,0x313,0x301,0x345,
-0x1f25,0x345,2,0xf044,0x3b7,0x314,0x301,0x345,0x1f26,0x345,2,0xf044,0x3b7,0x313,0x342,0x345,
-0x1f27,0x345,2,0xf044,0x3b7,0x314,0x342,0x345,0x1f28,0xf063,0x397,0x313,0x345,0x1f29,0xf063,0x397,
-0x314,0x345,0x1f2a,0x345,2,0xf044,0x397,0x313,0x300,0x345,0x1f2b,0x345,2,0xf044,0x397,0x314,
-0x300,0x345,0x1f2c,0x345,2,0xf044,0x397,0x313,0x301,0x345,0x1f2d,0x345,2,0xf044,0x397,0x314,
-0x301,0x345,0x1f2e,0x345,2,0xf044,0x397,0x313,0x342,0x345,0x1f2f,0x345,2,0xf044,0x397,0x314,
-0x342,0x345,0x1f60,0xf063,0x3c9,0x313,0x345,0x1f61,0xf063,0x3c9,0x314,0x345,0x1f62,0x345,2,0xf044,
-0x3c9,0x313,0x300,0x345,0x1f63,0x345,2,0xf044,0x3c9,0x314,0x300,0x345,0x1f64,0x345,2,0xf044,
-0x3c9,0x313,0x301,0x345,0x1f65,0x345,2,0xf044,0x3c9,0x314,0x301,0x345,0x1f66,0x345,2,0xf044,
-0x3c9,0x313,0x342,0x345,0x1f67,0x345,2,0xf044,0x3c9,0x314,0x342,0x345,0x1f68,0xf063,0x3a9,0x313,
-0x345,0x1f69,0xf063,0x3a9,0x314,0x345,0x1f6a,0x345,2,0xf044,0x3a9,0x313,0x300,0x345,0x1f6b,0x345,
-2,0xf044,0x3a9,0x314,0x300,0x345,0x1f6c,0x345,2,0xf044,0x3a9,0x313,0x301,0x345,0x1f6d,0x345,
-2,0xf044,0x3a9,0x314,0x301,0x345,0x1f6e,0x345,2,0xf044,0x3a9,0x313,0x342,0x345,0x1f6f,0x345,
-2,0xf044,0x3a9,0x314,0x342,0x345,0xe602,0x3b1,0x306,0xe602,0x3b1,0x304,0x1f70,0xf043,0x3b1,0x300,
-0x345,0xf022,0x3b1,0x345,0x3ac,0xf043,0x3b1,0x301,0x345,0x1fb6,0xf043,0x3b1,0x342,0x345,0xe602,0x391,
-0x306,0xe602,0x391,0x304,0xe602,0x391,0x300,0xf022,0x391,0x345,0xe602,0xa8,0x342,0x1f74,0xf043,0x3b7,
-0x300,0x345,0xf022,0x3b7,0x345,0x3ae,0xf043,0x3b7,0x301,0x345,0x1fc6,0xf043,0x3b7,0x342,0x345,0xe602,
-0x395,0x300,0xe602,0x397,0x300,0xf022,0x397,0x345,0xe602,0x1fbf,0x300,0xe602,0x1fbf,0x301,0xe602,0x1fbf,
-0x342,0xe602,0x3b9,0x306,0xe602,0x3b9,0x304,0x3ca,0xe643,0x3b9,0x308,0x300,0xe602,0x3b9,0x342,0x3ca,
-0xe643,0x3b9,0x308,0x342,0xe602,0x399,0x306,0xe602,0x399,0x304,0xe602,0x399,0x300,0xe602,0x1ffe,0x300,
-0xe602,0x1ffe,0x301,0xe602,0x1ffe,0x342,0xe602,0x3c5,0x306,0xe602,0x3c5,0x304,0x3cb,0xe643,0x3c5,0x308,
-0x300,0xe602,0x3c1,0x313,0xe602,0x3c1,0x314,0xe602,0x3c5,0x342,0x3cb,0xe643,0x3c5,0x308,0x342,0xe602,
-0x3a5,0x306,0xe602,0x3a5,0x304,0xe602,0x3a5,0x300,0xe602,0x3a1,0x314,0xe602,0xa8,0x300,0x1f7c,0xf043,
-0x3c9,0x300,0x345,0xf022,0x3c9,0x345,0x3ce,0xf043,0x3c9,0x301,0x345,0x1ff6,0xf043,0x3c9,0x342,0x345,
-0xe602,0x39f,0x300,0xe602,0x3a9,0x300,0xf022,0x3a9,0x345,0x102,0x2190,0x338,0x102,0x2192,0x338,0x102,
-0x2194,0x338,0x102,0x21d0,0x338,0x102,0x21d4,0x338,0x102,0x21d2,0x338,0x102,0x2203,0x338,0x102,0x2208,
-0x338,0x102,0x220b,0x338,0x102,0x2223,0x338,0x102,0x2225,0x338,0x102,0x223c,0x338,0x102,0x2243,0x338,
-0x102,0x2245,0x338,0x102,0x2248,0x338,0x102,0x3d,0x338,0x102,0x2261,0x338,0x102,0x224d,0x338,0x102,
-0x3c,0x338,0x102,0x3e,0x338,0x102,0x2264,0x338,0x102,0x2265,0x338,0x102,0x2272,0x338,0x102,0x2273,
-0x338,0x102,0x2276,0x338,0x102,0x2277,0x338,0x102,0x227a,0x338,0x102,0x227b,0x338,0x102,0x2282,0x338,
-0x102,0x2283,0x338,0x102,0x2286,0x338,0x102,0x2287,0x338,0x102,0x22a2,0x338,0x102,0x22a8,0x338,0x102,
-0x22a9,0x338,0x102,0x22ab,0x338,0x102,0x227c,0x338,0x102,0x227d,0x338,0x102,0x2291,0x338,0x102,0x2292,
-0x338,0x102,0x22b2,0x338,0x102,0x22b3,0x338,0x102,0x22b4,0x338,0x102,0x22b5,0x338,0x802,0x304b,0x3099,
-0x802,0x304d,0x3099,0x802,0x304f,0x3099,0x802,0x3051,0x3099,0x802,0x3053,0x3099,0x802,0x3055,0x3099,0x802,
-0x3057,0x3099,0x802,0x3059,0x3099,0x802,0x305b,0x3099,0x802,0x305d,0x3099,0x802,0x305f,0x3099,0x802,0x3061,
-0x3099,0x802,0x3064,0x3099,0x802,0x3066,0x3099,0x802,0x3068,0x3099,0x802,0x306f,0x3099,0x802,0x306f,0x309a,
-0x802,0x3072,0x3099,0x802,0x3072,0x309a,0x802,0x3075,0x3099,0x802,0x3075,0x309a,0x802,0x3078,0x3099,0x802,
-0x3078,0x309a,0x802,0x307b,0x3099,0x802,0x307b,0x309a,0x802,0x3046,0x3099,0x802,0x309d,0x3099,0x802,0x30ab,
-0x3099,0x802,0x30ad,0x3099,0x802,0x30af,0x3099,0x802,0x30b1,0x3099,0x802,0x30b3,0x3099,0x802,0x30b5,0x3099,
-0x802,0x30b7,0x3099,0x802,0x30b9,0x3099,0x802,0x30bb,0x3099,0x802,0x30bd,0x3099,0x802,0x30bf,0x3099,0x802,
-0x30c1,0x3099,0x802,0x30c4,0x3099,0x802,0x30c6,0x3099,0x802,0x30c8,0x3099,0x802,0x30cf,0x3099,0x802,0x30cf,
-0x309a,0x802,0x30d2,0x3099,0x802,0x30d2,0x309a,0x802,0x30d5,0x3099,0x802,0x30d5,0x309a,0x802,0x30d8,0x3099,
-0x802,0x30d8,0x309a,0x802,0x30db,0x3099,0x802,0x30db,0x309a,0x802,0x30a6,0x3099,0x802,0x30ef,0x3099,0x802,
-0x30f0,0x3099,0x802,0x30f1,0x3099,0x802,0x30f2,0x3099,0x802,0x30fd,0x3099,0x704,0xd804,0xdc99,0xd804,0xdcba,
-0x704,0xd804,0xdc9b,0xd804,0xdcba,0x704,0xd804,0xdca5,0xd804,0xdcba,4,0xd804,0xdd31,0xd804,0xdd27,4,
-0xd804,0xdd32,0xd804,0xdd27,4,0xd804,0xdf47,0xd804,0xdf3e,4,0xd804,0xdf47,0xd804,0xdf57,4,0xd805,
-0xdcb9,0xd805,0xdcba,4,0xd805,0xdcb9,0xd805,0xdcb0,4,0xd805,0xdcb9,0xd805,0xdcbd,4,0xd805,0xddb8,
-0xd805,0xddaf,4,0xd805,0xddb9,0xd805,0xddaf,0xe6e6,0xe6a1,0x300,0xe6e6,0xe6a1,0x301,0xe6e6,0xe6a1,0x313,
-0xe6e6,0xe6a2,0x308,0x301,1,0x2b9,1,0x3b,1,0xb7,0x702,0x915,0x93c,0x702,0x916,0x93c,
-0x702,0x917,0x93c,0x702,0x91c,0x93c,0x702,0x921,0x93c,0x702,0x922,0x93c,0x702,0x92b,0x93c,0x702,
-0x92f,0x93c,0x702,0x9a1,0x9bc,0x702,0x9a2,0x9bc,0x702,0x9af,0x9bc,0x702,0xa32,0xa3c,0x702,0xa38,
-0xa3c,0x702,0xa16,0xa3c,0x702,0xa17,0xa3c,0x702,0xa1c,0xa3c,0x702,0xa2b,0xa3c,0x702,0xb21,0xb3c,
-0x702,0xb22,0xb3c,2,0xf42,0xfb7,2,0xf4c,0xfb7,2,0xf51,0xfb7,2,0xf56,0xfb7,2,
-0xf5b,0xfb7,2,0xf40,0xfb5,0x8100,0x82a2,0xf71,0xf72,0x8100,0x84a2,0xf71,0xf74,0x8202,0xfb2,0xf80,
-0x8202,0xfb3,0xf80,0x8100,0x82a2,0xf71,0xf80,2,0xf92,0xfb7,2,0xf9c,0xfb7,2,0xfa1,0xfb7,
-2,0xfa6,0xfb7,2,0xfab,0xfb7,2,0xf90,0xfb5,0x3ac,0xe662,0x3b1,0x301,0x3ad,0xe642,0x3b5,
-0x301,0x3ae,0xe662,0x3b7,0x301,0x3af,0xe642,0x3b9,0x301,0x3cc,0xe642,0x3bf,0x301,0x3cd,0xe642,0x3c5,
-0x301,0x3ce,0xe662,0x3c9,0x301,0x386,0xe642,0x391,0x301,0x21,0x3b9,0x388,0xe642,0x395,0x301,0x389,
-0xe642,0x397,0x301,0x390,1,0xe643,0x3b9,0x308,0x301,0x38a,0xe642,0x399,0x301,0x3b0,1,0xe643,
-0x3c5,0x308,0x301,0x38e,0xe642,0x3a5,0x301,0x385,0xe642,0xa8,0x301,1,0x60,0x38c,0xe642,0x39f,
-0x301,0x38f,0xe642,0x3a9,0x301,1,0xb4,0x21,0x3a9,0x21,0x4b,0xc5,0xe662,0x41,0x30a,1,
-0x3008,1,0x3009,0x102,0x2add,0x338,1,0x8c48,1,0x66f4,1,0x8eca,1,0x8cc8,1,0x6ed1,
-1,0x4e32,1,0x53e5,1,0x9f9c,1,0x5951,1,0x91d1,1,0x5587,1,0x5948,1,0x61f6,
-1,0x7669,1,0x7f85,1,0x863f,1,0x87ba,1,0x88f8,1,0x908f,1,0x6a02,1,0x6d1b,
-1,0x70d9,1,0x73de,1,0x843d,1,0x916a,1,0x99f1,1,0x4e82,1,0x5375,1,0x6b04,
-1,0x721b,1,0x862d,1,0x9e1e,1,0x5d50,1,0x6feb,1,0x85cd,1,0x8964,1,0x62c9,
-1,0x81d8,1,0x881f,1,0x5eca,1,0x6717,1,0x6d6a,1,0x72fc,1,0x90ce,1,0x4f86,
-1,0x51b7,1,0x52de,1,0x64c4,1,0x6ad3,1,0x7210,1,0x76e7,1,0x8001,1,0x8606,
-1,0x865c,1,0x8def,1,0x9732,1,0x9b6f,1,0x9dfa,1,0x788c,1,0x797f,1,0x7da0,
-1,0x83c9,1,0x9304,1,0x9e7f,1,0x8ad6,1,0x58df,1,0x5f04,1,0x7c60,1,0x807e,
-1,0x7262,1,0x78ca,1,0x8cc2,1,0x96f7,1,0x58d8,1,0x5c62,1,0x6a13,1,0x6dda,
-1,0x6f0f,1,0x7d2f,1,0x7e37,1,0x964b,1,0x52d2,1,0x808b,1,0x51dc,1,0x51cc,
-1,0x7a1c,1,0x7dbe,1,0x83f1,1,0x9675,1,0x8b80,1,0x62cf,1,0x8afe,1,0x4e39,
-1,0x5be7,1,0x6012,1,0x7387,1,0x7570,1,0x5317,1,0x78fb,1,0x4fbf,1,0x5fa9,
-1,0x4e0d,1,0x6ccc,1,0x6578,1,0x7d22,1,0x53c3,1,0x585e,1,0x7701,1,0x8449,
-1,0x8aaa,1,0x6bba,1,0x8fb0,1,0x6c88,1,0x62fe,1,0x82e5,1,0x63a0,1,0x7565,
-1,0x4eae,1,0x5169,1,0x51c9,1,0x6881,1,0x7ce7,1,0x826f,1,0x8ad2,1,0x91cf,
-1,0x52f5,1,0x5442,1,0x5973,1,0x5eec,1,0x65c5,1,0x6ffe,1,0x792a,1,0x95ad,
-1,0x9a6a,1,0x9e97,1,0x9ece,1,0x529b,1,0x66c6,1,0x6b77,1,0x8f62,1,0x5e74,
-1,0x6190,1,0x6200,1,0x649a,1,0x6f23,1,0x7149,1,0x7489,1,0x79ca,1,0x7df4,
-1,0x806f,1,0x8f26,1,0x84ee,1,0x9023,1,0x934a,1,0x5217,1,0x52a3,1,0x54bd,
-1,0x70c8,1,0x88c2,1,0x5ec9,1,0x5ff5,1,0x637b,1,0x6bae,1,0x7c3e,1,0x7375,
-1,0x4ee4,1,0x56f9,1,0x5dba,1,0x601c,1,0x73b2,1,0x7469,1,0x7f9a,1,0x8046,
-1,0x9234,1,0x96f6,1,0x9748,1,0x9818,1,0x4f8b,1,0x79ae,1,0x91b4,1,0x96b8,
-1,0x60e1,1,0x4e86,1,0x50da,1,0x5bee,1,0x5c3f,1,0x6599,1,0x71ce,1,0x7642,
-1,0x84fc,1,0x907c,1,0x9f8d,1,0x6688,1,0x962e,1,0x5289,1,0x677b,1,0x67f3,
-1,0x6d41,1,0x6e9c,1,0x7409,1,0x7559,1,0x786b,1,0x7d10,1,0x985e,1,0x516d,
-1,0x622e,1,0x9678,1,0x502b,1,0x5d19,1,0x6dea,1,0x8f2a,1,0x5f8b,1,0x6144,
-1,0x6817,1,0x9686,1,0x5229,1,0x540f,1,0x5c65,1,0x6613,1,0x674e,1,0x68a8,
-1,0x6ce5,1,0x7406,1,0x75e2,1,0x7f79,1,0x88cf,1,0x88e1,1,0x91cc,1,0x96e2,
-1,0x533f,1,0x6eba,1,0x541d,1,0x71d0,1,0x7498,1,0x85fa,1,0x96a3,1,0x9c57,
-1,0x9e9f,1,0x6797,1,0x6dcb,1,0x81e8,1,0x7acb,1,0x7b20,1,0x7c92,1,0x72c0,
-1,0x7099,1,0x8b58,1,0x4ec0,1,0x8336,1,0x523a,1,0x5207,1,0x5ea6,1,0x62d3,
-1,0x7cd6,1,0x5b85,1,0x6d1e,1,0x66b4,1,0x8f3b,1,0x884c,1,0x964d,1,0x898b,
-1,0x5ed3,1,0x5140,1,0x55c0,1,0x585a,1,0x6674,1,0x51de,1,0x732a,1,0x76ca,
-1,0x793c,1,0x795e,1,0x7965,1,0x798f,1,0x9756,1,0x7cbe,1,0x7fbd,1,0x8612,
-1,0x8af8,1,0x9038,1,0x90fd,1,0x98ef,1,0x98fc,1,0x9928,1,0x9db4,1,0x90de,
-1,0x96b7,1,0x4fae,1,0x50e7,1,0x514d,1,0x52c9,1,0x52e4,1,0x5351,1,0x559d,
-1,0x5606,1,0x5668,1,0x5840,1,0x58a8,1,0x5c64,1,0x5c6e,1,0x6094,1,0x6168,
-1,0x618e,1,0x61f2,1,0x654f,1,0x65e2,1,0x6691,1,0x6885,1,0x6d77,1,0x6e1a,
-1,0x6f22,1,0x716e,1,0x722b,1,0x7422,1,0x7891,1,0x793e,1,0x7949,1,0x7948,
-1,0x7950,1,0x7956,1,0x795d,1,0x798d,1,0x798e,1,0x7a40,1,0x7a81,1,0x7bc0,
-1,0x7e09,1,0x7e41,1,0x7f72,1,0x8005,1,0x81ed,1,0x8279,1,0x8457,1,0x8910,
-1,0x8996,1,0x8b01,1,0x8b39,1,0x8cd3,1,0x8d08,1,0x8fb6,1,0x96e3,1,0x97ff,
-1,0x983b,1,0x6075,2,0xd850,0xdeee,1,0x8218,1,0x4e26,1,0x51b5,1,0x5168,1,
-0x4f80,1,0x5145,1,0x5180,1,0x52c7,1,0x52fa,1,0x5555,1,0x5599,1,0x55e2,1,
-0x58b3,1,0x5944,1,0x5954,1,0x5a62,1,0x5b28,1,0x5ed2,1,0x5ed9,1,0x5f69,1,
-0x5fad,1,0x60d8,1,0x614e,1,0x6108,1,0x6160,1,0x6234,1,0x63c4,1,0x641c,1,
-0x6452,1,0x6556,1,0x671b,1,0x6756,1,0x6b79,1,0x6edb,1,0x6ecb,1,0x701e,1,
-0x77a7,1,0x7235,1,0x72af,1,0x7471,1,0x7506,1,0x753b,1,0x761d,1,0x761f,1,
-0x76db,1,0x76f4,1,0x774a,1,0x7740,1,0x78cc,1,0x7ab1,1,0x7c7b,1,0x7d5b,1,
-0x7f3e,1,0x8352,1,0x83ef,1,0x8779,1,0x8941,1,0x8986,1,0x8abf,1,0x8acb,1,
-0x8aed,1,0x8b8a,1,0x8f38,1,0x9072,1,0x9199,1,0x9276,1,0x967c,1,0x97db,1,
-0x980b,1,0x9b12,2,0xd84a,0xdc4a,2,0xd84a,0xdc44,2,0xd84c,0xdfd5,1,0x3b9d,1,0x4018,
-1,0x4039,2,0xd854,0xde49,2,0xd857,0xdcd0,2,0xd85f,0xded3,1,0x9f43,1,0x9f8e,0xe02,
-0x5d9,0x5b4,0x1102,0x5f2,0x5b7,0x1802,0x5e9,0x5c1,0x1902,0x5e9,0x5c2,0xfb49,0x1843,0x5e9,0x5bc,0x5c1,
-0xfb49,0x1943,0x5e9,0x5bc,0x5c2,0x1102,0x5d0,0x5b7,0x1202,0x5d0,0x5b8,0x1502,0x5d0,0x5bc,0x1502,0x5d1,
-0x5bc,0x1502,0x5d2,0x5bc,0x1502,0x5d3,0x5bc,0x1502,0x5d4,0x5bc,0x1502,0x5d5,0x5bc,0x1502,0x5d6,0x5bc,
-0x1502,0x5d8,0x5bc,0x1502,0x5d9,0x5bc,0x1502,0x5da,0x5bc,0x1502,0x5db,0x5bc,0x1502,0x5dc,0x5bc,0x1502,
-0x5de,0x5bc,0x1502,0x5e0,0x5bc,0x1502,0x5e1,0x5bc,0x1502,0x5e3,0x5bc,0x1502,0x5e4,0x5bc,0x1502,0x5e6,
-0x5bc,0x1502,0x5e7,0x5bc,0x1502,0x5e8,0x5bc,0x1502,0x5e9,0x5bc,0x1502,0x5ea,0x5bc,0x1302,0x5d5,0x5b9,
-0x1702,0x5d1,0x5bf,0x1702,0x5db,0x5bf,0x1702,0x5e4,0x5bf,0xd804,0xd834,0xdd57,0xd834,0xdd65,0xd804,0xd834,
-0xdd58,0xd834,0xdd65,0xd834,0xdd5f,0xd834,0xdd6e,4,0xd846,0xd834,0xdd58,0xd834,0xdd65,0xd834,0xdd6e,0xd834,
-0xdd5f,0xd834,0xdd6f,4,0xd846,0xd834,0xdd58,0xd834,0xdd65,0xd834,0xdd6f,0xd834,0xdd5f,0xd834,0xdd70,4,
-0xd846,0xd834,0xdd58,0xd834,0xdd65,0xd834,0xdd70,0xd834,0xdd5f,0xd834,0xdd71,4,0xd846,0xd834,0xdd58,0xd834,
-0xdd65,0xd834,0xdd71,0xd834,0xdd5f,0xd834,0xdd72,4,0xd846,0xd834,0xdd58,0xd834,0xdd65,0xd834,0xdd72,0xd804,
-0xd834,0xddb9,0xd834,0xdd65,0xd804,0xd834,0xddba,0xd834,0xdd65,0xd834,0xddbb,0xd834,0xdd6e,4,0xd846,0xd834,
-0xddb9,0xd834,0xdd65,0xd834,0xdd6e,0xd834,0xddbc,0xd834,0xdd6e,4,0xd846,0xd834,0xddba,0xd834,0xdd65,0xd834,
-0xdd6e,0xd834,0xddbb,0xd834,0xdd6f,4,0xd846,0xd834,0xddb9,0xd834,0xdd65,0xd834,0xdd6f,0xd834,0xddbc,0xd834,
-0xdd6f,4,0xd846,0xd834,0xddba,0xd834,0xdd65,0xd834,0xdd6f,1,0x4e3d,1,0x4e38,1,0x4e41,2,
-0xd840,0xdd22,1,0x4f60,1,0x4fbb,1,0x5002,1,0x507a,1,0x5099,1,0x50cf,1,0x349e,
-2,0xd841,0xde3a,1,0x5154,1,0x5164,1,0x5177,2,0xd841,0xdd1c,1,0x34b9,1,0x5167,
-1,0x518d,2,0xd841,0xdd4b,1,0x5197,1,0x51a4,1,0x4ecc,1,0x51ac,2,0xd864,0xdddf,
-1,0x51f5,1,0x5203,1,0x34df,1,0x523b,1,0x5246,1,0x5272,1,0x5277,1,0x3515,
-1,0x5305,1,0x5306,1,0x5349,1,0x535a,1,0x5373,1,0x537d,1,0x537f,2,0xd842,
-0xde2c,1,0x7070,1,0x53ca,1,0x53df,2,0xd842,0xdf63,1,0x53eb,1,0x53f1,1,0x5406,
-1,0x549e,1,0x5438,1,0x5448,1,0x5468,1,0x54a2,1,0x54f6,1,0x5510,1,0x5553,
-1,0x5563,1,0x5584,1,0x55ab,1,0x55b3,1,0x55c2,1,0x5716,1,0x5717,1,0x5651,
-1,0x5674,1,0x58ee,1,0x57ce,1,0x57f4,1,0x580d,1,0x578b,1,0x5832,1,0x5831,
-1,0x58ac,2,0xd845,0xdce4,1,0x58f2,1,0x58f7,1,0x5906,1,0x591a,1,0x5922,1,
-0x5962,2,0xd845,0xdea8,2,0xd845,0xdeea,1,0x59ec,1,0x5a1b,1,0x5a27,1,0x59d8,1,
-0x5a66,1,0x36ee,1,0x36fc,1,0x5b08,1,0x5b3e,2,0xd846,0xddc8,1,0x5bc3,1,0x5bd8,
-1,0x5bf3,2,0xd846,0xdf18,1,0x5bff,1,0x5c06,1,0x5f53,1,0x5c22,1,0x3781,1,
-0x5c60,1,0x5cc0,1,0x5c8d,2,0xd847,0xdde4,1,0x5d43,2,0xd847,0xdde6,1,0x5d6e,1,
-0x5d6b,1,0x5d7c,1,0x5de1,1,0x5de2,1,0x382f,1,0x5dfd,1,0x5e28,1,0x5e3d,1,
-0x5e69,1,0x3862,2,0xd848,0xdd83,1,0x387c,1,0x5eb0,1,0x5eb3,1,0x5eb6,2,0xd868,
-0xdf92,1,0x5efe,2,0xd848,0xdf31,1,0x8201,1,0x5f22,1,0x38c7,2,0xd84c,0xdeb8,2,
-0xd858,0xddda,1,0x5f62,1,0x5f6b,1,0x38e3,1,0x5f9a,1,0x5fcd,1,0x5fd7,1,0x5ff9,
-1,0x6081,1,0x393a,1,0x391c,2,0xd849,0xded4,1,0x60c7,1,0x6148,1,0x614c,1,
-0x617a,1,0x61b2,1,0x61a4,1,0x61af,1,0x61de,1,0x6210,1,0x621b,1,0x625d,1,
-0x62b1,1,0x62d4,1,0x6350,2,0xd84a,0xdf0c,1,0x633d,1,0x62fc,1,0x6368,1,0x6383,
-1,0x63e4,2,0xd84a,0xdff1,1,0x6422,1,0x63c5,1,0x63a9,1,0x3a2e,1,0x6469,1,
-0x647e,1,0x649d,1,0x6477,1,0x3a6c,1,0x656c,2,0xd84c,0xdc0a,1,0x65e3,1,0x66f8,
-1,0x6649,1,0x3b19,1,0x3b08,1,0x3ae4,1,0x5192,1,0x5195,1,0x6700,1,0x669c,
-1,0x80ad,1,0x43d9,1,0x6721,1,0x675e,1,0x6753,2,0xd84c,0xdfc3,1,0x3b49,1,
-0x67fa,1,0x6785,1,0x6852,2,0xd84d,0xdc6d,1,0x688e,1,0x681f,1,0x6914,1,0x6942,
-1,0x69a3,1,0x69ea,1,0x6aa8,2,0xd84d,0xdea3,1,0x6adb,1,0x3c18,1,0x6b21,2,
-0xd84e,0xdca7,1,0x6b54,1,0x3c4e,1,0x6b72,1,0x6b9f,1,0x6bbb,2,0xd84e,0xde8d,2,
-0xd847,0xdd0b,2,0xd84e,0xdefa,1,0x6c4e,2,0xd84f,0xdcbc,1,0x6cbf,1,0x6ccd,1,0x6c67,
-1,0x6d16,1,0x6d3e,1,0x6d69,1,0x6d78,1,0x6d85,2,0xd84f,0xdd1e,1,0x6d34,1,
-0x6e2f,1,0x6e6e,1,0x3d33,1,0x6ec7,2,0xd84f,0xded1,1,0x6df9,1,0x6f6e,2,0xd84f,
-0xdf5e,2,0xd84f,0xdf8e,1,0x6fc6,1,0x7039,1,0x701b,1,0x3d96,1,0x704a,1,0x707d,
-1,0x7077,1,0x70ad,2,0xd841,0xdd25,1,0x7145,2,0xd850,0xde63,1,0x719c,2,0xd850,
-0xdfab,1,0x7228,1,0x7250,2,0xd851,0xde08,1,0x7280,1,0x7295,2,0xd851,0xdf35,2,
-0xd852,0xdc14,1,0x737a,1,0x738b,1,0x3eac,1,0x73a5,1,0x3eb8,1,0x7447,1,0x745c,
-1,0x7485,1,0x74ca,1,0x3f1b,1,0x7524,2,0xd853,0xdc36,1,0x753e,2,0xd853,0xdc92,
-2,0xd848,0xdd9f,1,0x7610,2,0xd853,0xdfa1,2,0xd853,0xdfb8,2,0xd854,0xdc44,1,0x3ffc,
-1,0x4008,2,0xd854,0xdcf3,2,0xd854,0xdcf2,2,0xd854,0xdd19,2,0xd854,0xdd33,1,0x771e,
-1,0x771f,1,0x778b,1,0x4046,1,0x4096,2,0xd855,0xdc1d,1,0x784e,1,0x40e3,2,
-0xd855,0xde26,2,0xd855,0xde9a,2,0xd855,0xdec5,1,0x79eb,1,0x412f,1,0x7a4a,1,0x7a4f,
-2,0xd856,0xdd7c,2,0xd856,0xdea7,1,0x7aee,1,0x4202,2,0xd856,0xdfab,1,0x7bc6,1,
-0x7bc9,1,0x4227,2,0xd857,0xdc80,1,0x7cd2,1,0x42a0,1,0x7ce8,1,0x7ce3,1,0x7d00,
-2,0xd857,0xdf86,1,0x7d63,1,0x4301,1,0x7dc7,1,0x7e02,1,0x7e45,1,0x4334,2,
-0xd858,0xde28,2,0xd858,0xde47,1,0x4359,2,0xd858,0xded9,1,0x7f7a,2,0xd858,0xdf3e,1,
-0x7f95,1,0x7ffa,2,0xd859,0xdcda,2,0xd859,0xdd23,1,0x8060,2,0xd859,0xdda8,1,0x8070,
-2,0xd84c,0xdf5f,1,0x43d5,1,0x80b2,1,0x8103,1,0x440b,1,0x813e,1,0x5ab5,2,
-0xd859,0xdfa7,2,0xd859,0xdfb5,2,0xd84c,0xdf93,2,0xd84c,0xdf9c,1,0x8204,1,0x8f9e,1,
-0x446b,1,0x8291,1,0x828b,1,0x829d,1,0x52b3,1,0x82b1,1,0x82b3,1,0x82bd,1,
-0x82e6,2,0xd85a,0xdf3c,1,0x831d,1,0x8363,1,0x83ad,1,0x8323,1,0x83bd,1,0x83e7,
-1,0x8353,1,0x83ca,1,0x83cc,1,0x83dc,2,0xd85b,0xdc36,2,0xd85b,0xdd6b,2,0xd85b,
-0xdcd5,1,0x452b,1,0x84f1,1,0x84f3,1,0x8516,2,0xd85c,0xdfca,1,0x8564,2,0xd85b,
-0xdf2c,1,0x455d,1,0x4561,2,0xd85b,0xdfb1,2,0xd85c,0xdcd2,1,0x456b,1,0x8650,1,
-0x8667,1,0x8669,1,0x86a9,1,0x8688,1,0x870e,1,0x86e2,1,0x8728,1,0x876b,1,
-0x8786,1,0x45d7,1,0x87e1,1,0x8801,1,0x45f9,1,0x8860,1,0x8863,2,0xd85d,0xde67,
-1,0x88d7,1,0x88de,1,0x4635,1,0x88fa,1,0x34bb,2,0xd85e,0xdcae,2,0xd85e,0xdd66,
-1,0x46be,1,0x46c7,1,0x8aa0,1,0x8c55,2,0xd85f,0xdca8,1,0x8cab,1,0x8cc1,1,
-0x8d1b,1,0x8d77,2,0xd85f,0xdf2f,2,0xd842,0xdc04,1,0x8dcb,1,0x8dbc,1,0x8df0,2,
-0xd842,0xdcde,1,0x8ed4,2,0xd861,0xddd2,2,0xd861,0xdded,1,0x9094,1,0x90f1,1,0x9111,
-2,0xd861,0xdf2e,1,0x911b,1,0x9238,1,0x92d7,1,0x92d8,1,0x927c,1,0x93f9,1,
-0x9415,2,0xd862,0xdffa,1,0x958b,1,0x4995,1,0x95b7,2,0xd863,0xdd77,1,0x49e6,1,
-0x96c3,1,0x5db2,1,0x9723,2,0xd864,0xdd45,2,0xd864,0xde1a,1,0x4a6e,1,0x4a76,1,
-0x97e0,2,0xd865,0xdc0a,1,0x4ab2,2,0xd865,0xdc96,1,0x9829,2,0xd865,0xddb6,1,0x98e2,
-1,0x4b33,1,0x9929,1,0x99a7,1,0x99c2,1,0x99fe,1,0x4bce,2,0xd866,0xdf30,1,
-0x9c40,1,0x9cfd,1,0x4cce,1,0x4ced,1,0x9d67,2,0xd868,0xdcce,1,0x4cf8,2,0xd868,
-0xdd05,2,0xd868,0xde0e,2,0xd868,0xde91,1,0x9ebb,1,0x4d56,1,0x9ef9,1,0x9efe,1,
-0x9f05,1,0x9f0f,1,0x9f16,1,0x9f3b,2,0xd869,0xde00
+0x2c02,0x2978,0x348b,0x2e82,0x2976,0xb48b,0x2f42,0x297c,0xb48b,0x6bc2,0x2b74,0xb48b,0x6bc2,0x2b76,2,0xe602,
+0x41,0x302,0x600,0x3d4c,0x602,0x3d48,0x606,0x3d54,0x8612,0x3d50,0xe602,0x41,0x308,0x8608,0x3bc,0xe602,
+0x41,0x30a,0x8602,0x3f4,0xca02,0x43,0x327,0x8602,0x3c10,0xe602,0x45,0x302,0x600,0x3d80,0x602,0x3d7c,
+0x606,0x3d88,0x8612,0x3d84,0xe602,0x49,0x308,0x8602,0x3c5c,0xe602,0x4f,0x302,0x600,0x3da4,0x602,0x3da0,
+0x606,0x3dac,0x8612,0x3da8,0xe602,0x4f,0x303,0x602,0x3c98,0x608,0x458,0x8610,0x3c9c,0xe602,0x4f,0x308,
+0x8608,0x454,0xe602,0x55,0x308,0x600,0x3b6,0x602,0x3ae,0x608,0x3aa,0x8618,0x3b2,0xe602,0x61,0x302,
+0x600,0x3d4e,0x602,0x3d4a,0x606,0x3d56,0x8612,0x3d52,0xe602,0x61,0x308,0x8608,0x3be,0xe602,0x61,0x30a,
+0x8602,0x3f6,0xca02,0x63,0x327,0x8602,0x3c12,0xe602,0x65,0x302,0x600,0x3d82,0x602,0x3d7e,0x606,0x3d8a,
+0x8612,0x3d86,0xe602,0x69,0x308,0x8602,0x3c5e,0xe602,0x6f,0x302,0x600,0x3da6,0x602,0x3da2,0x606,0x3dae,
+0x8612,0x3daa,0xe602,0x6f,0x303,0x602,0x3c9a,0x608,0x45a,0x8610,0x3c9e,0xe602,0x6f,0x308,0x8608,0x456,
+0xe602,0x75,0x308,0x600,0x3b8,0x602,0x3b0,0x608,0x3ac,0x8618,0x3b4,0xe602,0x41,0x306,0x600,0x3d60,
+0x602,0x3d5c,0x606,0x3d68,0x8612,0x3d64,0xe602,0x61,0x306,0x600,0x3d62,0x602,0x3d5e,0x606,0x3d6a,0x8612,
+0x3d66,0xe602,0x45,0x304,0x600,0x3c28,0x8602,0x3c2c,0xe602,0x65,0x304,0x600,0x3c2a,0x8602,0x3c2e,0xe602,
+0x4f,0x304,0x600,0x3ca0,0x8602,0x3ca4,0xe602,0x6f,0x304,0x600,0x3ca2,0x8602,0x3ca6,0xe602,0x53,0x301,
+0x860e,0x3cc8,0xe602,0x73,0x301,0x860e,0x3cca,0xe602,0x53,0x30c,0x860e,0x3ccc,0xe602,0x73,0x30c,0x860e,
+0x3cce,0xe602,0x55,0x303,0x8602,0x3cf0,0xe602,0x75,0x303,0x8602,0x3cf2,0xe602,0x55,0x304,0x8610,0x3cf4,
+0xe602,0x75,0x304,0x8610,0x3cf6,0xd802,0x4f,0x31b,0x600,0x3db8,0x602,0x3db4,0x606,0x3dc0,0x612,0x3dbc,
+0x8646,0x3dc4,0xd802,0x6f,0x31b,0x600,0x3dba,0x602,0x3db6,0x606,0x3dc2,0x612,0x3dbe,0x8646,0x3dc6,0xd802,
+0x55,0x31b,0x600,0x3dd4,0x602,0x3dd0,0x606,0x3ddc,0x612,0x3dd8,0x8646,0x3de0,0xd802,0x75,0x31b,0x600,
+0x3dd6,0x602,0x3dd2,0x606,0x3dde,0x612,0x3dda,0x8646,0x3de2,0xca02,0x4f,0x328,0x8608,0x3d8,0xca02,0x6f,
+0x328,0x8608,0x3da,0xe602,0x41,0x307,0x8608,0x3c0,0xe602,0x61,0x307,0x8608,0x3c2,0xca02,0x45,0x327,
+0x860c,0x3c38,0xca02,0x65,0x327,0x860c,0x3c3a,0xe602,0x4f,0x307,0x8608,0x460,0xe602,0x6f,0x307,0x8608,
+0x462,0xe602,0x3b1,0x301,0x868a,0x3f68,0xe602,0x3b7,0x301,0x868a,0x3f88,0xe602,0x3b9,0x308,0x600,0x3fa4,
+0x602,0x720,0x8684,0x3fae,0xe602,0x3c5,0x308,0x600,0x3fc4,0x602,0x760,0x8684,0x3fce,0xe602,0x3c9,0x301,
+0x868a,0x3fe8,2,0xcc6,0xcc2,0x99aa,0x1996,2,0xdd9,0xdcf,0x9b94,0x1bba,0xdc02,0x4c,0x323,0x8608,
+0x3c70,0xdc02,0x6c,0x323,0x8608,0x3c72,0xdc02,0x52,0x323,0x8608,0x3cb8,0xdc02,0x72,0x323,0x8608,0x3cba,
+0xdc02,0x53,0x323,0x860e,0x3cd0,0xdc02,0x73,0x323,0x860e,0x3cd2,0xdc02,0x41,0x323,0x604,0x3d58,0x860c,
+0x3d6c,0xdc02,0x61,0x323,0x604,0x3d5a,0x860c,0x3d6e,0xdc02,0x45,0x323,0x8604,0x3d8c,0xdc02,0x65,0x323,
+0x8604,0x3d8e,0xdc02,0x4f,0x323,0x8604,0x3db0,0xdc02,0x6f,0x323,0x8604,0x3db2,0xe602,0x3b1,0x313,0x600,
+0x3e05,0x602,0x3e09,0x684,0x3e0d,0x868a,0x3f00,0xe602,0x3b1,0x314,0x600,0x3e07,0x602,0x3e0b,0x684,0x3e0f,
+0x868a,0x3f02,0x1f00,0xe643,0x3b1,0x313,0x300,0x868a,0x3f04,0x1f01,0xe643,0x3b1,0x314,0x300,0x868a,0x3f06,
+0x1f00,0xe643,0x3b1,0x313,0x301,0x868a,0x3f08,0x1f01,0xe643,0x3b1,0x314,0x301,0x868a,0x3f0a,0x1f00,0xe643,
+0x3b1,0x313,0x342,0x868a,0x3f0c,0x1f01,0xe643,0x3b1,0x314,0x342,0x868a,0x3f0e,0xe602,0x391,0x313,0x600,
+0x3e15,0x602,0x3e19,0x684,0x3e1d,0x868a,0x3f10,0xe602,0x391,0x314,0x600,0x3e17,0x602,0x3e1b,0x684,0x3e1f,
+0x868a,0x3f12,0x1f08,0xe643,0x391,0x313,0x300,0x868a,0x3f14,0x1f09,0xe643,0x391,0x314,0x300,0x868a,0x3f16,
+0x1f08,0xe643,0x391,0x313,0x301,0x868a,0x3f18,0x1f09,0xe643,0x391,0x314,0x301,0x868a,0x3f1a,0x1f08,0xe643,
+0x391,0x313,0x342,0x868a,0x3f1c,0x1f09,0xe643,0x391,0x314,0x342,0x868a,0x3f1e,0xe602,0x3b5,0x313,0x600,
+0x3e24,0x8602,0x3e28,0xe602,0x3b5,0x314,0x600,0x3e26,0x8602,0x3e2a,0xe602,0x395,0x313,0x600,0x3e34,0x8602,
+0x3e38,0xe602,0x395,0x314,0x600,0x3e36,0x8602,0x3e3a,0xe602,0x3b7,0x313,0x600,0x3e45,0x602,0x3e49,0x684,
+0x3e4d,0x868a,0x3f20,0xe602,0x3b7,0x314,0x600,0x3e47,0x602,0x3e4b,0x684,0x3e4f,0x868a,0x3f22,0x1f20,0xe643,
+0x3b7,0x313,0x300,0x868a,0x3f24,0x1f21,0xe643,0x3b7,0x314,0x300,0x868a,0x3f26,0x1f20,0xe643,0x3b7,0x313,
+0x301,0x868a,0x3f28,0x1f21,0xe643,0x3b7,0x314,0x301,0x868a,0x3f2a,0x1f20,0xe643,0x3b7,0x313,0x342,0x868a,
+0x3f2c,0x1f21,0xe643,0x3b7,0x314,0x342,0x868a,0x3f2e,0xe602,0x397,0x313,0x600,0x3e55,0x602,0x3e59,0x684,
+0x3e5d,0x868a,0x3f30,0xe602,0x397,0x314,0x600,0x3e57,0x602,0x3e5b,0x684,0x3e5f,0x868a,0x3f32,0x1f28,0xe643,
+0x397,0x313,0x300,0x868a,0x3f34,0x1f29,0xe643,0x397,0x314,0x300,0x868a,0x3f36,0x1f28,0xe643,0x397,0x313,
+0x301,0x868a,0x3f38,0x1f29,0xe643,0x397,0x314,0x301,0x868a,0x3f3a,0x1f28,0xe643,0x397,0x313,0x342,0x868a,
+0x3f3c,0x1f29,0xe643,0x397,0x314,0x342,0x868a,0x3f3e,0xe602,0x3b9,0x313,0x600,0x3e64,0x602,0x3e68,0x8684,
+0x3e6c,0xe602,0x3b9,0x314,0x600,0x3e66,0x602,0x3e6a,0x8684,0x3e6e,0xe602,0x399,0x313,0x600,0x3e74,0x602,
+0x3e78,0x8684,0x3e7c,0xe602,0x399,0x314,0x600,0x3e76,0x602,0x3e7a,0x8684,0x3e7e,0xe602,0x3bf,0x313,0x600,
+0x3e84,0x8602,0x3e88,0xe602,0x3bf,0x314,0x600,0x3e86,0x8602,0x3e8a,0xe602,0x39f,0x313,0x600,0x3e94,0x8602,
+0x3e98,0xe602,0x39f,0x314,0x600,0x3e96,0x8602,0x3e9a,0xe602,0x3c5,0x313,0x600,0x3ea4,0x602,0x3ea8,0x8684,
+0x3eac,0xe602,0x3c5,0x314,0x600,0x3ea6,0x602,0x3eaa,0x8684,0x3eae,0xe602,0x3a5,0x314,0x600,0x3eb6,0x602,
+0x3eba,0x8684,0x3ebe,0xe602,0x3c9,0x313,0x600,0x3ec5,0x602,0x3ec9,0x684,0x3ecd,0x868a,0x3f40,0xe602,0x3c9,
+0x314,0x600,0x3ec7,0x602,0x3ecb,0x684,0x3ecf,0x868a,0x3f42,0x1f60,0xe643,0x3c9,0x313,0x300,0x868a,0x3f44,
+0x1f61,0xe643,0x3c9,0x314,0x300,0x868a,0x3f46,0x1f60,0xe643,0x3c9,0x313,0x301,0x868a,0x3f48,0x1f61,0xe643,
+0x3c9,0x314,0x301,0x868a,0x3f4a,0x1f60,0xe643,0x3c9,0x313,0x342,0x868a,0x3f4c,0x1f61,0xe643,0x3c9,0x314,
+0x342,0x868a,0x3f4e,0xe602,0x3a9,0x313,0x600,0x3ed5,0x602,0x3ed9,0x684,0x3edd,0x868a,0x3f50,0xe602,0x3a9,
+0x314,0x600,0x3ed7,0x602,0x3edb,0x684,0x3edf,0x868a,0x3f52,0x1f68,0xe643,0x3a9,0x313,0x300,0x868a,0x3f54,
+0x1f69,0xe643,0x3a9,0x314,0x300,0x868a,0x3f56,0x1f68,0xe643,0x3a9,0x313,0x301,0x868a,0x3f58,0x1f69,0xe643,
+0x3a9,0x314,0x301,0x868a,0x3f5a,0x1f68,0xe643,0x3a9,0x313,0x342,0x868a,0x3f5c,0x1f69,0xe643,0x3a9,0x314,
+0x342,0x868a,0x3f5e,0xe602,0x3b1,0x300,0x868a,0x3f64,0xe602,0x3b7,0x300,0x868a,0x3f84,0xe602,0x3c9,0x300,
+0x868a,0x3fe4,0xe602,0x3b1,0x342,0x868a,0x3f6e,0xe602,0x3b7,0x342,0x868a,0x3f8e,0xe602,0x3c9,0x342,0x868a,
+0x3fee,3,0xe602,0x41,0x300,0xe602,0x41,0x301,0xe602,0x41,0x303,0xe602,0x45,0x300,0xe602,0x45,
+0x301,0xe602,0x45,0x308,0xe602,0x49,0x300,0xe602,0x49,0x301,0xe602,0x49,0x302,0xe602,0x4e,0x303,
+0xe602,0x4f,0x300,0xe602,0x4f,0x301,0xe602,0x55,0x300,0xe602,0x55,0x301,0xe602,0x55,0x302,0xe602,
+0x59,0x301,0xe602,0x61,0x300,0xe602,0x61,0x301,0xe602,0x61,0x303,0xe602,0x65,0x300,0xe602,0x65,
+0x301,0xe602,0x65,0x308,0xe602,0x69,0x300,0xe602,0x69,0x301,0xe602,0x69,0x302,0xe602,0x6e,0x303,
+0xe602,0x6f,0x300,0xe602,0x6f,0x301,0xe602,0x75,0x300,0xe602,0x75,0x301,0xe602,0x75,0x302,0xe602,
+0x79,0x301,0xe602,0x79,0x308,0xe602,0x41,0x304,0xe602,0x61,0x304,0xca02,0x41,0x328,0xca02,0x61,
+0x328,0xe602,0x43,0x301,0xe602,0x63,0x301,0xe602,0x43,0x302,0xe602,0x63,0x302,0xe602,0x43,0x307,
+0xe602,0x63,0x307,0xe602,0x43,0x30c,0xe602,0x63,0x30c,0xe602,0x44,0x30c,0xe602,0x64,0x30c,0xe602,
+0x45,0x306,0xe602,0x65,0x306,0xe602,0x45,0x307,0xe602,0x65,0x307,0xca02,0x45,0x328,0xca02,0x65,
+0x328,0xe602,0x45,0x30c,0xe602,0x65,0x30c,0xe602,0x47,0x302,0xe602,0x67,0x302,0xe602,0x47,0x306,
+0xe602,0x67,0x306,0xe602,0x47,0x307,0xe602,0x67,0x307,0xca02,0x47,0x327,0xca02,0x67,0x327,0xe602,
+0x48,0x302,0xe602,0x68,0x302,0xe602,0x49,0x303,0xe602,0x69,0x303,0xe602,0x49,0x304,0xe602,0x69,
+0x304,0xe602,0x49,0x306,0xe602,0x69,0x306,0xca02,0x49,0x328,0xca02,0x69,0x328,0xe602,0x49,0x307,
+0xe602,0x4a,0x302,0xe602,0x6a,0x302,0xca02,0x4b,0x327,0xca02,0x6b,0x327,0xe602,0x4c,0x301,0xe602,
+0x6c,0x301,0xca02,0x4c,0x327,0xca02,0x6c,0x327,0xe602,0x4c,0x30c,0xe602,0x6c,0x30c,0xe602,0x4e,
+0x301,0xe602,0x6e,0x301,0xca02,0x4e,0x327,0xca02,0x6e,0x327,0xe602,0x4e,0x30c,0xe602,0x6e,0x30c,
+0xe602,0x4f,0x306,0xe602,0x6f,0x306,0xe602,0x4f,0x30b,0xe602,0x6f,0x30b,0xe602,0x52,0x301,0xe602,
+0x72,0x301,0xca02,0x52,0x327,0xca02,0x72,0x327,0xe602,0x52,0x30c,0xe602,0x72,0x30c,0xe602,0x53,
+0x302,0xe602,0x73,0x302,0xca02,0x53,0x327,0xca02,0x73,0x327,0xca02,0x54,0x327,0xca02,0x74,0x327,
+0xe602,0x54,0x30c,0xe602,0x74,0x30c,0xe602,0x55,0x306,0xe602,0x75,0x306,0xe602,0x55,0x30a,0xe602,
+0x75,0x30a,0xe602,0x55,0x30b,0xe602,0x75,0x30b,0xca02,0x55,0x328,0xca02,0x75,0x328,0xe602,0x57,
+0x302,0xe602,0x77,0x302,0xe602,0x59,0x302,0xe602,0x79,0x302,0xe602,0x59,0x308,0xe602,0x5a,0x301,
+0xe602,0x7a,0x301,0xe602,0x5a,0x307,0xe602,0x7a,0x307,0xe602,0x5a,0x30c,0xe602,0x7a,0x30c,0xe602,
+0x41,0x30c,0xe602,0x61,0x30c,0xe602,0x49,0x30c,0xe602,0x69,0x30c,0xe602,0x4f,0x30c,0xe602,0x6f,
+0x30c,0xe602,0x55,0x30c,0xe602,0x75,0x30c,0xdc,0xe643,0x55,0x308,0x304,0xfc,0xe643,0x75,0x308,
+0x304,0xdc,0xe643,0x55,0x308,0x301,0xfc,0xe643,0x75,0x308,0x301,0xdc,0xe643,0x55,0x308,0x30c,
+0xfc,0xe643,0x75,0x308,0x30c,0xdc,0xe643,0x55,0x308,0x300,0xfc,0xe643,0x75,0x308,0x300,0xc4,
+0xe643,0x41,0x308,0x304,0xe4,0xe643,0x61,0x308,0x304,0x226,0xe643,0x41,0x307,0x304,0x227,0xe643,
+0x61,0x307,0x304,0xe602,0xc6,0x304,0xe602,0xe6,0x304,0xe602,0x47,0x30c,0xe602,0x67,0x30c,0xe602,
+0x4b,0x30c,0xe602,0x6b,0x30c,0x1ea,0xe643,0x4f,0x328,0x304,0x1eb,0xe643,0x6f,0x328,0x304,0xe602,
+0x1b7,0x30c,0xe602,0x292,0x30c,0xe602,0x6a,0x30c,0xe602,0x47,0x301,0xe602,0x67,0x301,0xe602,0x4e,
+0x300,0xe602,0x6e,0x300,0xc5,0xe643,0x41,0x30a,0x301,0xe5,0xe643,0x61,0x30a,0x301,0xe602,0xc6,
+0x301,0xe602,0xe6,0x301,0xe602,0xd8,0x301,0xe602,0xf8,0x301,0xe602,0x41,0x30f,0xe602,0x61,0x30f,
+0xe602,0x41,0x311,0xe602,0x61,0x311,0xe602,0x45,0x30f,0xe602,0x65,0x30f,0xe602,0x45,0x311,0xe602,
+0x65,0x311,0xe602,0x49,0x30f,0xe602,0x69,0x30f,0xe602,0x49,0x311,0xe602,0x69,0x311,0xe602,0x4f,
+0x30f,0xe602,0x6f,0x30f,0xe602,0x4f,0x311,0xe602,0x6f,0x311,0xe602,0x52,0x30f,0xe602,0x72,0x30f,
+0xe602,0x52,0x311,0xe602,0x72,0x311,0xe602,0x55,0x30f,0xe602,0x75,0x30f,0xe602,0x55,0x311,0xe602,
+0x75,0x311,0xdc02,0x53,0x326,0xdc02,0x73,0x326,0xdc02,0x54,0x326,0xdc02,0x74,0x326,0xe602,0x48,
+0x30c,0xe602,0x68,0x30c,0xd6,0xe643,0x4f,0x308,0x304,0xf6,0xe643,0x6f,0x308,0x304,0xd5,0xe643,
+0x4f,0x303,0x304,0xf5,0xe643,0x6f,0x303,0x304,0x22e,0xe643,0x4f,0x307,0x304,0x22f,0xe643,0x6f,
+0x307,0x304,0xe602,0x59,0x304,0xe602,0x79,0x304,0xe602,0xa8,0x301,0xe602,0x391,0x301,0xe602,0x395,
+0x301,0xe602,0x397,0x301,0xe602,0x399,0x301,0xe602,0x39f,0x301,0xe602,0x3a5,0x301,0xe602,0x3a9,0x301,
+0x3ca,0xe643,0x3b9,0x308,0x301,0xe602,0x399,0x308,0xe602,0x3a5,0x308,0xe602,0x3b5,0x301,0xe602,0x3b9,
+0x301,0x3cb,0xe643,0x3c5,0x308,0x301,0xe602,0x3bf,0x301,0xe602,0x3c5,0x301,0xe602,0x3d2,0x301,0xe602,
+0x3d2,0x308,0xe602,0x415,0x300,0xe602,0x415,0x308,0xe602,0x413,0x301,0xe602,0x406,0x308,0xe602,0x41a,
+0x301,0xe602,0x418,0x300,0xe602,0x423,0x306,0xe602,0x418,0x306,0xe602,0x438,0x306,0xe602,0x435,0x300,
+0xe602,0x435,0x308,0xe602,0x433,0x301,0xe602,0x456,0x308,0xe602,0x43a,0x301,0xe602,0x438,0x300,0xe602,
+0x443,0x306,0xe602,0x474,0x30f,0xe602,0x475,0x30f,0xe602,0x416,0x306,0xe602,0x436,0x306,0xe602,0x410,
+0x306,0xe602,0x430,0x306,0xe602,0x410,0x308,0xe602,0x430,0x308,0xe602,0x415,0x306,0xe602,0x435,0x306,
+0xe602,0x4d8,0x308,0xe602,0x4d9,0x308,0xe602,0x416,0x308,0xe602,0x436,0x308,0xe602,0x417,0x308,0xe602,
+0x437,0x308,0xe602,0x418,0x304,0xe602,0x438,0x304,0xe602,0x418,0x308,0xe602,0x438,0x308,0xe602,0x41e,
+0x308,0xe602,0x43e,0x308,0xe602,0x4e8,0x308,0xe602,0x4e9,0x308,0xe602,0x42d,0x308,0xe602,0x44d,0x308,
+0xe602,0x423,0x304,0xe602,0x443,0x304,0xe602,0x423,0x308,0xe602,0x443,0x308,0xe602,0x423,0x30b,0xe602,
+0x443,0x30b,0xe602,0x427,0x308,0xe602,0x447,0x308,0xe602,0x42b,0x308,0xe602,0x44b,0x308,0xe602,0x627,
+0x653,0xe602,0x627,0x654,0xe602,0x648,0x654,0xdc02,0x627,0x655,0xe602,0x64a,0x654,0xe602,0x6d5,0x654,
+0xe602,0x6c1,0x654,0xe602,0x6d2,0x654,0x702,0x928,0x93c,0x702,0x930,0x93c,0x702,0x933,0x93c,2,
+0x9c7,0x9be,2,0x9c7,0x9d7,2,0xb47,0xb56,2,0xb47,0xb3e,2,0xb47,0xb57,2,0xb92,
+0xbd7,2,0xbc6,0xbbe,2,0xbc7,0xbbe,2,0xbc6,0xbd7,0x5b02,0xc46,0xc56,2,0xcbf,0xcd5,
+2,0xcc6,0xcd5,2,0xcc6,0xcd6,0xcca,0x43,0xcc6,0xcc2,0xcd5,2,0xd46,0xd3e,2,0xd47,
+0xd3e,2,0xd46,0xd57,0x902,0xdd9,0xdca,0xddc,0x943,0xdd9,0xdcf,0xdca,2,0xdd9,0xddf,2,
+0x1025,0x102e,2,0x1b05,0x1b35,2,0x1b07,0x1b35,2,0x1b09,0x1b35,2,0x1b0b,0x1b35,2,0x1b0d,
+0x1b35,2,0x1b11,0x1b35,2,0x1b3a,0x1b35,2,0x1b3c,0x1b35,2,0x1b3e,0x1b35,2,0x1b3f,0x1b35,
+2,0x1b42,0x1b35,0xdc02,0x41,0x325,0xdc02,0x61,0x325,0xe602,0x42,0x307,0xe602,0x62,0x307,0xdc02,
+0x42,0x323,0xdc02,0x62,0x323,0xdc02,0x42,0x331,0xdc02,0x62,0x331,0xc7,0xe643,0x43,0x327,0x301,
+0xe7,0xe643,0x63,0x327,0x301,0xe602,0x44,0x307,0xe602,0x64,0x307,0xdc02,0x44,0x323,0xdc02,0x64,
+0x323,0xdc02,0x44,0x331,0xdc02,0x64,0x331,0xca02,0x44,0x327,0xca02,0x64,0x327,0xdc02,0x44,0x32d,
+0xdc02,0x64,0x32d,0x112,0xe643,0x45,0x304,0x300,0x113,0xe643,0x65,0x304,0x300,0x112,0xe643,0x45,
+0x304,0x301,0x113,0xe643,0x65,0x304,0x301,0xdc02,0x45,0x32d,0xdc02,0x65,0x32d,0xdc02,0x45,0x330,
+0xdc02,0x65,0x330,0x228,0xe643,0x45,0x327,0x306,0x229,0xe643,0x65,0x327,0x306,0xe602,0x46,0x307,
+0xe602,0x66,0x307,0xe602,0x47,0x304,0xe602,0x67,0x304,0xe602,0x48,0x307,0xe602,0x68,0x307,0xdc02,
+0x48,0x323,0xdc02,0x68,0x323,0xe602,0x48,0x308,0xe602,0x68,0x308,0xca02,0x48,0x327,0xca02,0x68,
+0x327,0xdc02,0x48,0x32e,0xdc02,0x68,0x32e,0xdc02,0x49,0x330,0xdc02,0x69,0x330,0xcf,0xe643,0x49,
+0x308,0x301,0xef,0xe643,0x69,0x308,0x301,0xe602,0x4b,0x301,0xe602,0x6b,0x301,0xdc02,0x4b,0x323,
+0xdc02,0x6b,0x323,0xdc02,0x4b,0x331,0xdc02,0x6b,0x331,0x1e36,0xe643,0x4c,0x323,0x304,0x1e37,0xe643,
+0x6c,0x323,0x304,0xdc02,0x4c,0x331,0xdc02,0x6c,0x331,0xdc02,0x4c,0x32d,0xdc02,0x6c,0x32d,0xe602,
+0x4d,0x301,0xe602,0x6d,0x301,0xe602,0x4d,0x307,0xe602,0x6d,0x307,0xdc02,0x4d,0x323,0xdc02,0x6d,
+0x323,0xe602,0x4e,0x307,0xe602,0x6e,0x307,0xdc02,0x4e,0x323,0xdc02,0x6e,0x323,0xdc02,0x4e,0x331,
+0xdc02,0x6e,0x331,0xdc02,0x4e,0x32d,0xdc02,0x6e,0x32d,0xd5,0xe643,0x4f,0x303,0x301,0xf5,0xe643,
+0x6f,0x303,0x301,0xd5,0xe643,0x4f,0x303,0x308,0xf5,0xe643,0x6f,0x303,0x308,0x14c,0xe643,0x4f,
+0x304,0x300,0x14d,0xe643,0x6f,0x304,0x300,0x14c,0xe643,0x4f,0x304,0x301,0x14d,0xe643,0x6f,0x304,
+0x301,0xe602,0x50,0x301,0xe602,0x70,0x301,0xe602,0x50,0x307,0xe602,0x70,0x307,0xe602,0x52,0x307,
+0xe602,0x72,0x307,0x1e5a,0xe643,0x52,0x323,0x304,0x1e5b,0xe643,0x72,0x323,0x304,0xdc02,0x52,0x331,
+0xdc02,0x72,0x331,0xe602,0x53,0x307,0xe602,0x73,0x307,0x15a,0xe643,0x53,0x301,0x307,0x15b,0xe643,
+0x73,0x301,0x307,0x160,0xe643,0x53,0x30c,0x307,0x161,0xe643,0x73,0x30c,0x307,0x1e62,0xe643,0x53,
+0x323,0x307,0x1e63,0xe643,0x73,0x323,0x307,0xe602,0x54,0x307,0xe602,0x74,0x307,0xdc02,0x54,0x323,
+0xdc02,0x74,0x323,0xdc02,0x54,0x331,0xdc02,0x74,0x331,0xdc02,0x54,0x32d,0xdc02,0x74,0x32d,0xdc02,
+0x55,0x324,0xdc02,0x75,0x324,0xdc02,0x55,0x330,0xdc02,0x75,0x330,0xdc02,0x55,0x32d,0xdc02,0x75,
+0x32d,0x168,0xe643,0x55,0x303,0x301,0x169,0xe643,0x75,0x303,0x301,0x16a,0xe643,0x55,0x304,0x308,
+0x16b,0xe643,0x75,0x304,0x308,0xe602,0x56,0x303,0xe602,0x76,0x303,0xdc02,0x56,0x323,0xdc02,0x76,
+0x323,0xe602,0x57,0x300,0xe602,0x77,0x300,0xe602,0x57,0x301,0xe602,0x77,0x301,0xe602,0x57,0x308,
+0xe602,0x77,0x308,0xe602,0x57,0x307,0xe602,0x77,0x307,0xdc02,0x57,0x323,0xdc02,0x77,0x323,0xe602,
+0x58,0x307,0xe602,0x78,0x307,0xe602,0x58,0x308,0xe602,0x78,0x308,0xe602,0x59,0x307,0xe602,0x79,
+0x307,0xe602,0x5a,0x302,0xe602,0x7a,0x302,0xdc02,0x5a,0x323,0xdc02,0x7a,0x323,0xdc02,0x5a,0x331,
+0xdc02,0x7a,0x331,0xdc02,0x68,0x331,0xe602,0x74,0x308,0xe602,0x77,0x30a,0xe602,0x79,0x30a,0xe602,
+0x17f,0x307,0xe602,0x41,0x309,0xe602,0x61,0x309,0xc2,0xe643,0x41,0x302,0x301,0xe2,0xe643,0x61,
+0x302,0x301,0xc2,0xe643,0x41,0x302,0x300,0xe2,0xe643,0x61,0x302,0x300,0xc2,0xe643,0x41,0x302,
+0x309,0xe2,0xe643,0x61,0x302,0x309,0xc2,0xe643,0x41,0x302,0x303,0xe2,0xe643,0x61,0x302,0x303,
+0x1ea0,0xe643,0x41,0x323,0x302,0x1ea1,0xe643,0x61,0x323,0x302,0x102,0xe643,0x41,0x306,0x301,0x103,
+0xe643,0x61,0x306,0x301,0x102,0xe643,0x41,0x306,0x300,0x103,0xe643,0x61,0x306,0x300,0x102,0xe643,
+0x41,0x306,0x309,0x103,0xe643,0x61,0x306,0x309,0x102,0xe643,0x41,0x306,0x303,0x103,0xe643,0x61,
+0x306,0x303,0x1ea0,0xe643,0x41,0x323,0x306,0x1ea1,0xe643,0x61,0x323,0x306,0xe602,0x45,0x309,0xe602,
+0x65,0x309,0xe602,0x45,0x303,0xe602,0x65,0x303,0xca,0xe643,0x45,0x302,0x301,0xea,0xe643,0x65,
+0x302,0x301,0xca,0xe643,0x45,0x302,0x300,0xea,0xe643,0x65,0x302,0x300,0xca,0xe643,0x45,0x302,
+0x309,0xea,0xe643,0x65,0x302,0x309,0xca,0xe643,0x45,0x302,0x303,0xea,0xe643,0x65,0x302,0x303,
+0x1eb8,0xe643,0x45,0x323,0x302,0x1eb9,0xe643,0x65,0x323,0x302,0xe602,0x49,0x309,0xe602,0x69,0x309,
+0xdc02,0x49,0x323,0xdc02,0x69,0x323,0xe602,0x4f,0x309,0xe602,0x6f,0x309,0xd4,0xe643,0x4f,0x302,
+0x301,0xf4,0xe643,0x6f,0x302,0x301,0xd4,0xe643,0x4f,0x302,0x300,0xf4,0xe643,0x6f,0x302,0x300,
+0xd4,0xe643,0x4f,0x302,0x309,0xf4,0xe643,0x6f,0x302,0x309,0xd4,0xe643,0x4f,0x302,0x303,0xf4,
+0xe643,0x6f,0x302,0x303,0x1ecc,0xe643,0x4f,0x323,0x302,0x1ecd,0xe643,0x6f,0x323,0x302,0x1a0,0xe643,
+0x4f,0x31b,0x301,0x1a1,0xe643,0x6f,0x31b,0x301,0x1a0,0xe643,0x4f,0x31b,0x300,0x1a1,0xe643,0x6f,
+0x31b,0x300,0x1a0,0xe643,0x4f,0x31b,0x309,0x1a1,0xe643,0x6f,0x31b,0x309,0x1a0,0xe643,0x4f,0x31b,
+0x303,0x1a1,0xe643,0x6f,0x31b,0x303,0x1a0,0xdc43,0x4f,0x31b,0x323,0x1a1,0xdc43,0x6f,0x31b,0x323,
+0xdc02,0x55,0x323,0xdc02,0x75,0x323,0xe602,0x55,0x309,0xe602,0x75,0x309,0x1af,0xe643,0x55,0x31b,
+0x301,0x1b0,0xe643,0x75,0x31b,0x301,0x1af,0xe643,0x55,0x31b,0x300,0x1b0,0xe643,0x75,0x31b,0x300,
+0x1af,0xe643,0x55,0x31b,0x309,0x1b0,0xe643,0x75,0x31b,0x309,0x1af,0xe643,0x55,0x31b,0x303,0x1b0,
+0xe643,0x75,0x31b,0x303,0x1af,0xdc43,0x55,0x31b,0x323,0x1b0,0xdc43,0x75,0x31b,0x323,0xe602,0x59,
+0x300,0xe602,0x79,0x300,0xdc02,0x59,0x323,0xdc02,0x79,0x323,0xe602,0x59,0x309,0xe602,0x79,0x309,
+0xe602,0x59,0x303,0xe602,0x79,0x303,0x1f10,0xe643,0x3b5,0x313,0x300,0x1f11,0xe643,0x3b5,0x314,0x300,
+0x1f10,0xe643,0x3b5,0x313,0x301,0x1f11,0xe643,0x3b5,0x314,0x301,0x1f18,0xe643,0x395,0x313,0x300,0x1f19,
+0xe643,0x395,0x314,0x300,0x1f18,0xe643,0x395,0x313,0x301,0x1f19,0xe643,0x395,0x314,0x301,0x1f30,0xe643,
+0x3b9,0x313,0x300,0x1f31,0xe643,0x3b9,0x314,0x300,0x1f30,0xe643,0x3b9,0x313,0x301,0x1f31,0xe643,0x3b9,
+0x314,0x301,0x1f30,0xe643,0x3b9,0x313,0x342,0x1f31,0xe643,0x3b9,0x314,0x342,0x1f38,0xe643,0x399,0x313,
+0x300,0x1f39,0xe643,0x399,0x314,0x300,0x1f38,0xe643,0x399,0x313,0x301,0x1f39,0xe643,0x399,0x314,0x301,
+0x1f38,0xe643,0x399,0x313,0x342,0x1f39,0xe643,0x399,0x314,0x342,0x1f40,0xe643,0x3bf,0x313,0x300,0x1f41,
+0xe643,0x3bf,0x314,0x300,0x1f40,0xe643,0x3bf,0x313,0x301,0x1f41,0xe643,0x3bf,0x314,0x301,0x1f48,0xe643,
+0x39f,0x313,0x300,0x1f49,0xe643,0x39f,0x314,0x300,0x1f48,0xe643,0x39f,0x313,0x301,0x1f49,0xe643,0x39f,
+0x314,0x301,0x1f50,0xe643,0x3c5,0x313,0x300,0x1f51,0xe643,0x3c5,0x314,0x300,0x1f50,0xe643,0x3c5,0x313,
+0x301,0x1f51,0xe643,0x3c5,0x314,0x301,0x1f50,0xe643,0x3c5,0x313,0x342,0x1f51,0xe643,0x3c5,0x314,0x342,
+0x1f59,0xe643,0x3a5,0x314,0x300,0x1f59,0xe643,0x3a5,0x314,0x301,0x1f59,0xe643,0x3a5,0x314,0x342,0xe602,
+0x3b5,0x300,0xe602,0x3b9,0x300,0xe602,0x3bf,0x300,0xe602,0x3c5,0x300,0x1f00,0xf043,0x3b1,0x313,0x345,
+0x1f01,0xf043,0x3b1,0x314,0x345,0x1f02,0x345,2,0xf044,0x3b1,0x313,0x300,0x345,0x1f03,0x345,2,
+0xf044,0x3b1,0x314,0x300,0x345,0x1f04,0x345,2,0xf044,0x3b1,0x313,0x301,0x345,0x1f05,0x345,2,
+0xf044,0x3b1,0x314,0x301,0x345,0x1f06,0x345,2,0xf044,0x3b1,0x313,0x342,0x345,0x1f07,0x345,2,
+0xf044,0x3b1,0x314,0x342,0x345,0x1f08,0xf043,0x391,0x313,0x345,0x1f09,0xf043,0x391,0x314,0x345,0x1f0a,
+0x345,2,0xf044,0x391,0x313,0x300,0x345,0x1f0b,0x345,2,0xf044,0x391,0x314,0x300,0x345,0x1f0c,
+0x345,2,0xf044,0x391,0x313,0x301,0x345,0x1f0d,0x345,2,0xf044,0x391,0x314,0x301,0x345,0x1f0e,
+0x345,2,0xf044,0x391,0x313,0x342,0x345,0x1f0f,0x345,2,0xf044,0x391,0x314,0x342,0x345,0x1f20,
+0xf043,0x3b7,0x313,0x345,0x1f21,0xf043,0x3b7,0x314,0x345,0x1f22,0x345,2,0xf044,0x3b7,0x313,0x300,
+0x345,0x1f23,0x345,2,0xf044,0x3b7,0x314,0x300,0x345,0x1f24,0x345,2,0xf044,0x3b7,0x313,0x301,
+0x345,0x1f25,0x345,2,0xf044,0x3b7,0x314,0x301,0x345,0x1f26,0x345,2,0xf044,0x3b7,0x313,0x342,
+0x345,0x1f27,0x345,2,0xf044,0x3b7,0x314,0x342,0x345,0x1f28,0xf043,0x397,0x313,0x345,0x1f29,0xf043,
+0x397,0x314,0x345,0x1f2a,0x345,2,0xf044,0x397,0x313,0x300,0x345,0x1f2b,0x345,2,0xf044,0x397,
+0x314,0x300,0x345,0x1f2c,0x345,2,0xf044,0x397,0x313,0x301,0x345,0x1f2d,0x345,2,0xf044,0x397,
+0x314,0x301,0x345,0x1f2e,0x345,2,0xf044,0x397,0x313,0x342,0x345,0x1f2f,0x345,2,0xf044,0x397,
+0x314,0x342,0x345,0x1f60,0xf043,0x3c9,0x313,0x345,0x1f61,0xf043,0x3c9,0x314,0x345,0x1f62,0x345,2,
+0xf044,0x3c9,0x313,0x300,0x345,0x1f63,0x345,2,0xf044,0x3c9,0x314,0x300,0x345,0x1f64,0x345,2,
+0xf044,0x3c9,0x313,0x301,0x345,0x1f65,0x345,2,0xf044,0x3c9,0x314,0x301,0x345,0x1f66,0x345,2,
+0xf044,0x3c9,0x313,0x342,0x345,0x1f67,0x345,2,0xf044,0x3c9,0x314,0x342,0x345,0x1f68,0xf043,0x3a9,
+0x313,0x345,0x1f69,0xf043,0x3a9,0x314,0x345,0x1f6a,0x345,2,0xf044,0x3a9,0x313,0x300,0x345,0x1f6b,
+0x345,2,0xf044,0x3a9,0x314,0x300,0x345,0x1f6c,0x345,2,0xf044,0x3a9,0x313,0x301,0x345,0x1f6d,
+0x345,2,0xf044,0x3a9,0x314,0x301,0x345,0x1f6e,0x345,2,0xf044,0x3a9,0x313,0x342,0x345,0x1f6f,
+0x345,2,0xf044,0x3a9,0x314,0x342,0x345,0xe602,0x3b1,0x306,0xe602,0x3b1,0x304,0x1f70,0xf043,0x3b1,
+0x300,0x345,0xf002,0x3b1,0x345,0x3ac,0xf043,0x3b1,0x301,0x345,0x1fb6,0xf043,0x3b1,0x342,0x345,0xe602,
+0x391,0x306,0xe602,0x391,0x304,0xe602,0x391,0x300,0xf002,0x391,0x345,0xe602,0xa8,0x342,0x1f74,0xf043,
+0x3b7,0x300,0x345,0xf002,0x3b7,0x345,0x3ae,0xf043,0x3b7,0x301,0x345,0x1fc6,0xf043,0x3b7,0x342,0x345,
+0xe602,0x395,0x300,0xe602,0x397,0x300,0xf002,0x397,0x345,0xe602,0x1fbf,0x300,0xe602,0x1fbf,0x301,0xe602,
+0x1fbf,0x342,0xe602,0x3b9,0x306,0xe602,0x3b9,0x304,0x3ca,0xe643,0x3b9,0x308,0x300,0xe602,0x3b9,0x342,
+0x3ca,0xe643,0x3b9,0x308,0x342,0xe602,0x399,0x306,0xe602,0x399,0x304,0xe602,0x399,0x300,0xe602,0x1ffe,
+0x300,0xe602,0x1ffe,0x301,0xe602,0x1ffe,0x342,0xe602,0x3c5,0x306,0xe602,0x3c5,0x304,0x3cb,0xe643,0x3c5,
+0x308,0x300,0xe602,0x3c1,0x313,0xe602,0x3c1,0x314,0xe602,0x3c5,0x342,0x3cb,0xe643,0x3c5,0x308,0x342,
+0xe602,0x3a5,0x306,0xe602,0x3a5,0x304,0xe602,0x3a5,0x300,0xe602,0x3a1,0x314,0xe602,0xa8,0x300,0x1f7c,
+0xf043,0x3c9,0x300,0x345,0xf002,0x3c9,0x345,0x3ce,0xf043,0x3c9,0x301,0x345,0x1ff6,0xf043,0x3c9,0x342,
+0x345,0xe602,0x39f,0x300,0xe602,0x3a9,0x300,0xf002,0x3a9,0x345,0x102,0x2190,0x338,0x102,0x2192,0x338,
+0x102,0x2194,0x338,0x102,0x21d0,0x338,0x102,0x21d4,0x338,0x102,0x21d2,0x338,0x102,0x2203,0x338,0x102,
+0x2208,0x338,0x102,0x220b,0x338,0x102,0x2223,0x338,0x102,0x2225,0x338,0x102,0x223c,0x338,0x102,0x2243,
+0x338,0x102,0x2245,0x338,0x102,0x2248,0x338,0x102,0x3d,0x338,0x102,0x2261,0x338,0x102,0x224d,0x338,
+0x102,0x3c,0x338,0x102,0x3e,0x338,0x102,0x2264,0x338,0x102,0x2265,0x338,0x102,0x2272,0x338,0x102,
+0x2273,0x338,0x102,0x2276,0x338,0x102,0x2277,0x338,0x102,0x227a,0x338,0x102,0x227b,0x338,0x102,0x2282,
+0x338,0x102,0x2283,0x338,0x102,0x2286,0x338,0x102,0x2287,0x338,0x102,0x22a2,0x338,0x102,0x22a8,0x338,
+0x102,0x22a9,0x338,0x102,0x22ab,0x338,0x102,0x227c,0x338,0x102,0x227d,0x338,0x102,0x2291,0x338,0x102,
+0x2292,0x338,0x102,0x22b2,0x338,0x102,0x22b3,0x338,0x102,0x22b4,0x338,0x102,0x22b5,0x338,0x802,0x304b,
+0x3099,0x802,0x304d,0x3099,0x802,0x304f,0x3099,0x802,0x3051,0x3099,0x802,0x3053,0x3099,0x802,0x3055,0x3099,
+0x802,0x3057,0x3099,0x802,0x3059,0x3099,0x802,0x305b,0x3099,0x802,0x305d,0x3099,0x802,0x305f,0x3099,0x802,
+0x3061,0x3099,0x802,0x3064,0x3099,0x802,0x3066,0x3099,0x802,0x3068,0x3099,0x802,0x306f,0x3099,0x802,0x306f,
+0x309a,0x802,0x3072,0x3099,0x802,0x3072,0x309a,0x802,0x3075,0x3099,0x802,0x3075,0x309a,0x802,0x3078,0x3099,
+0x802,0x3078,0x309a,0x802,0x307b,0x3099,0x802,0x307b,0x309a,0x802,0x3046,0x3099,0x802,0x309d,0x3099,0x802,
+0x30ab,0x3099,0x802,0x30ad,0x3099,0x802,0x30af,0x3099,0x802,0x30b1,0x3099,0x802,0x30b3,0x3099,0x802,0x30b5,
+0x3099,0x802,0x30b7,0x3099,0x802,0x30b9,0x3099,0x802,0x30bb,0x3099,0x802,0x30bd,0x3099,0x802,0x30bf,0x3099,
+0x802,0x30c1,0x3099,0x802,0x30c4,0x3099,0x802,0x30c6,0x3099,0x802,0x30c8,0x3099,0x802,0x30cf,0x3099,0x802,
+0x30cf,0x309a,0x802,0x30d2,0x3099,0x802,0x30d2,0x309a,0x802,0x30d5,0x3099,0x802,0x30d5,0x309a,0x802,0x30d8,
+0x3099,0x802,0x30d8,0x309a,0x802,0x30db,0x3099,0x802,0x30db,0x309a,0x802,0x30a6,0x3099,0x802,0x30ef,0x3099,
+0x802,0x30f0,0x3099,0x802,0x30f1,0x3099,0x802,0x30f2,0x3099,0x802,0x30fd,0x3099,0x704,0xd804,0xdc99,0xd804,
+0xdcba,0x704,0xd804,0xdc9b,0xd804,0xdcba,0x704,0xd804,0xdca5,0xd804,0xdcba,4,0xd804,0xdd31,0xd804,0xdd27,
+4,0xd804,0xdd32,0xd804,0xdd27,4,0xd804,0xdf47,0xd804,0xdf3e,4,0xd804,0xdf47,0xd804,0xdf57,4,
+0xd805,0xdcb9,0xd805,0xdcba,4,0xd805,0xdcb9,0xd805,0xdcb0,4,0xd805,0xdcb9,0xd805,0xdcbd,4,0xd805,
+0xddb8,0xd805,0xddaf,4,0xd805,0xddb9,0xd805,0xddaf,1,0x2b9,1,0x3b,1,0xb7,0x702,0x915,
+0x93c,0x702,0x916,0x93c,0x702,0x917,0x93c,0x702,0x91c,0x93c,0x702,0x921,0x93c,0x702,0x922,0x93c,
+0x702,0x92b,0x93c,0x702,0x92f,0x93c,0x702,0x9a1,0x9bc,0x702,0x9a2,0x9bc,0x702,0x9af,0x9bc,0x702,
+0xa32,0xa3c,0x702,0xa38,0xa3c,0x702,0xa16,0xa3c,0x702,0xa17,0xa3c,0x702,0xa1c,0xa3c,0x702,0xa2b,
+0xa3c,0x702,0xb21,0xb3c,0x702,0xb22,0xb3c,2,0xf42,0xfb7,2,0xf4c,0xfb7,2,0xf51,0xfb7,
+2,0xf56,0xfb7,2,0xf5b,0xfb7,2,0xf40,0xfb5,0x8202,0xfb2,0xf80,0x8202,0xfb3,0xf80,2,
+0xf92,0xfb7,2,0xf9c,0xfb7,2,0xfa1,0xfb7,2,0xfa6,0xfb7,2,0xfab,0xfb7,2,0xf90,
+0xfb5,1,0x3b9,1,0x60,1,0xb4,1,0x3a9,1,0x4b,1,0x3008,1,0x3009,0x102,
+0x2add,0x338,1,0x8c48,1,0x66f4,1,0x8eca,1,0x8cc8,1,0x6ed1,1,0x4e32,1,0x53e5,
+1,0x9f9c,1,0x5951,1,0x91d1,1,0x5587,1,0x5948,1,0x61f6,1,0x7669,1,0x7f85,
+1,0x863f,1,0x87ba,1,0x88f8,1,0x908f,1,0x6a02,1,0x6d1b,1,0x70d9,1,0x73de,
+1,0x843d,1,0x916a,1,0x99f1,1,0x4e82,1,0x5375,1,0x6b04,1,0x721b,1,0x862d,
+1,0x9e1e,1,0x5d50,1,0x6feb,1,0x85cd,1,0x8964,1,0x62c9,1,0x81d8,1,0x881f,
+1,0x5eca,1,0x6717,1,0x6d6a,1,0x72fc,1,0x90ce,1,0x4f86,1,0x51b7,1,0x52de,
+1,0x64c4,1,0x6ad3,1,0x7210,1,0x76e7,1,0x8001,1,0x8606,1,0x865c,1,0x8def,
+1,0x9732,1,0x9b6f,1,0x9dfa,1,0x788c,1,0x797f,1,0x7da0,1,0x83c9,1,0x9304,
+1,0x9e7f,1,0x8ad6,1,0x58df,1,0x5f04,1,0x7c60,1,0x807e,1,0x7262,1,0x78ca,
+1,0x8cc2,1,0x96f7,1,0x58d8,1,0x5c62,1,0x6a13,1,0x6dda,1,0x6f0f,1,0x7d2f,
+1,0x7e37,1,0x964b,1,0x52d2,1,0x808b,1,0x51dc,1,0x51cc,1,0x7a1c,1,0x7dbe,
+1,0x83f1,1,0x9675,1,0x8b80,1,0x62cf,1,0x8afe,1,0x4e39,1,0x5be7,1,0x6012,
+1,0x7387,1,0x7570,1,0x5317,1,0x78fb,1,0x4fbf,1,0x5fa9,1,0x4e0d,1,0x6ccc,
+1,0x6578,1,0x7d22,1,0x53c3,1,0x585e,1,0x7701,1,0x8449,1,0x8aaa,1,0x6bba,
+1,0x8fb0,1,0x6c88,1,0x62fe,1,0x82e5,1,0x63a0,1,0x7565,1,0x4eae,1,0x5169,
+1,0x51c9,1,0x6881,1,0x7ce7,1,0x826f,1,0x8ad2,1,0x91cf,1,0x52f5,1,0x5442,
+1,0x5973,1,0x5eec,1,0x65c5,1,0x6ffe,1,0x792a,1,0x95ad,1,0x9a6a,1,0x9e97,
+1,0x9ece,1,0x529b,1,0x66c6,1,0x6b77,1,0x8f62,1,0x5e74,1,0x6190,1,0x6200,
+1,0x649a,1,0x6f23,1,0x7149,1,0x7489,1,0x79ca,1,0x7df4,1,0x806f,1,0x8f26,
+1,0x84ee,1,0x9023,1,0x934a,1,0x5217,1,0x52a3,1,0x54bd,1,0x70c8,1,0x88c2,
+1,0x5ec9,1,0x5ff5,1,0x637b,1,0x6bae,1,0x7c3e,1,0x7375,1,0x4ee4,1,0x56f9,
+1,0x5dba,1,0x601c,1,0x73b2,1,0x7469,1,0x7f9a,1,0x8046,1,0x9234,1,0x96f6,
+1,0x9748,1,0x9818,1,0x4f8b,1,0x79ae,1,0x91b4,1,0x96b8,1,0x60e1,1,0x4e86,
+1,0x50da,1,0x5bee,1,0x5c3f,1,0x6599,1,0x71ce,1,0x7642,1,0x84fc,1,0x907c,
+1,0x9f8d,1,0x6688,1,0x962e,1,0x5289,1,0x677b,1,0x67f3,1,0x6d41,1,0x6e9c,
+1,0x7409,1,0x7559,1,0x786b,1,0x7d10,1,0x985e,1,0x516d,1,0x622e,1,0x9678,
+1,0x502b,1,0x5d19,1,0x6dea,1,0x8f2a,1,0x5f8b,1,0x6144,1,0x6817,1,0x9686,
+1,0x5229,1,0x540f,1,0x5c65,1,0x6613,1,0x674e,1,0x68a8,1,0x6ce5,1,0x7406,
+1,0x75e2,1,0x7f79,1,0x88cf,1,0x88e1,1,0x91cc,1,0x96e2,1,0x533f,1,0x6eba,
+1,0x541d,1,0x71d0,1,0x7498,1,0x85fa,1,0x96a3,1,0x9c57,1,0x9e9f,1,0x6797,
+1,0x6dcb,1,0x81e8,1,0x7acb,1,0x7b20,1,0x7c92,1,0x72c0,1,0x7099,1,0x8b58,
+1,0x4ec0,1,0x8336,1,0x523a,1,0x5207,1,0x5ea6,1,0x62d3,1,0x7cd6,1,0x5b85,
+1,0x6d1e,1,0x66b4,1,0x8f3b,1,0x884c,1,0x964d,1,0x898b,1,0x5ed3,1,0x5140,
+1,0x55c0,1,0x585a,1,0x6674,1,0x51de,1,0x732a,1,0x76ca,1,0x793c,1,0x795e,
+1,0x7965,1,0x798f,1,0x9756,1,0x7cbe,1,0x7fbd,1,0x8612,1,0x8af8,1,0x9038,
+1,0x90fd,1,0x98ef,1,0x98fc,1,0x9928,1,0x9db4,1,0x90de,1,0x96b7,1,0x4fae,
+1,0x50e7,1,0x514d,1,0x52c9,1,0x52e4,1,0x5351,1,0x559d,1,0x5606,1,0x5668,
+1,0x5840,1,0x58a8,1,0x5c64,1,0x5c6e,1,0x6094,1,0x6168,1,0x618e,1,0x61f2,
+1,0x654f,1,0x65e2,1,0x6691,1,0x6885,1,0x6d77,1,0x6e1a,1,0x6f22,1,0x716e,
+1,0x722b,1,0x7422,1,0x7891,1,0x793e,1,0x7949,1,0x7948,1,0x7950,1,0x7956,
+1,0x795d,1,0x798d,1,0x798e,1,0x7a40,1,0x7a81,1,0x7bc0,1,0x7e09,1,0x7e41,
+1,0x7f72,1,0x8005,1,0x81ed,1,0x8279,1,0x8457,1,0x8910,1,0x8996,1,0x8b01,
+1,0x8b39,1,0x8cd3,1,0x8d08,1,0x8fb6,1,0x96e3,1,0x97ff,1,0x983b,1,0x6075,
+2,0xd850,0xdeee,1,0x8218,1,0x4e26,1,0x51b5,1,0x5168,1,0x4f80,1,0x5145,1,
+0x5180,1,0x52c7,1,0x52fa,1,0x5555,1,0x5599,1,0x55e2,1,0x58b3,1,0x5944,1,
+0x5954,1,0x5a62,1,0x5b28,1,0x5ed2,1,0x5ed9,1,0x5f69,1,0x5fad,1,0x60d8,1,
+0x614e,1,0x6108,1,0x6160,1,0x6234,1,0x63c4,1,0x641c,1,0x6452,1,0x6556,1,
+0x671b,1,0x6756,1,0x6b79,1,0x6edb,1,0x6ecb,1,0x701e,1,0x77a7,1,0x7235,1,
+0x72af,1,0x7471,1,0x7506,1,0x753b,1,0x761d,1,0x761f,1,0x76db,1,0x76f4,1,
+0x774a,1,0x7740,1,0x78cc,1,0x7ab1,1,0x7c7b,1,0x7d5b,1,0x7f3e,1,0x8352,1,
+0x83ef,1,0x8779,1,0x8941,1,0x8986,1,0x8abf,1,0x8acb,1,0x8aed,1,0x8b8a,1,
+0x8f38,1,0x9072,1,0x9199,1,0x9276,1,0x967c,1,0x97db,1,0x980b,1,0x9b12,2,
+0xd84a,0xdc4a,2,0xd84a,0xdc44,2,0xd84c,0xdfd5,1,0x3b9d,1,0x4018,1,0x4039,2,0xd854,
+0xde49,2,0xd857,0xdcd0,2,0xd85f,0xded3,1,0x9f43,1,0x9f8e,0xe02,0x5d9,0x5b4,0x1102,0x5f2,
+0x5b7,0x1802,0x5e9,0x5c1,0x1902,0x5e9,0x5c2,0xfb49,0x1843,0x5e9,0x5bc,0x5c1,0xfb49,0x1943,0x5e9,0x5bc,
+0x5c2,0x1102,0x5d0,0x5b7,0x1202,0x5d0,0x5b8,0x1502,0x5d0,0x5bc,0x1502,0x5d1,0x5bc,0x1502,0x5d2,0x5bc,
+0x1502,0x5d3,0x5bc,0x1502,0x5d4,0x5bc,0x1502,0x5d5,0x5bc,0x1502,0x5d6,0x5bc,0x1502,0x5d8,0x5bc,0x1502,
+0x5d9,0x5bc,0x1502,0x5da,0x5bc,0x1502,0x5db,0x5bc,0x1502,0x5dc,0x5bc,0x1502,0x5de,0x5bc,0x1502,0x5e0,
+0x5bc,0x1502,0x5e1,0x5bc,0x1502,0x5e3,0x5bc,0x1502,0x5e4,0x5bc,0x1502,0x5e6,0x5bc,0x1502,0x5e7,0x5bc,
+0x1502,0x5e8,0x5bc,0x1502,0x5e9,0x5bc,0x1502,0x5ea,0x5bc,0x1302,0x5d5,0x5b9,0x1702,0x5d1,0x5bf,0x1702,
+0x5db,0x5bf,0x1702,0x5e4,0x5bf,0xd804,0xd834,0xdd57,0xd834,0xdd65,0xd804,0xd834,0xdd58,0xd834,0xdd65,0xd834,
+0xdd5f,0xd834,0xdd6e,4,0xd846,0xd834,0xdd58,0xd834,0xdd65,0xd834,0xdd6e,0xd834,0xdd5f,0xd834,0xdd6f,4,
+0xd846,0xd834,0xdd58,0xd834,0xdd65,0xd834,0xdd6f,0xd834,0xdd5f,0xd834,0xdd70,4,0xd846,0xd834,0xdd58,0xd834,
+0xdd65,0xd834,0xdd70,0xd834,0xdd5f,0xd834,0xdd71,4,0xd846,0xd834,0xdd58,0xd834,0xdd65,0xd834,0xdd71,0xd834,
+0xdd5f,0xd834,0xdd72,4,0xd846,0xd834,0xdd58,0xd834,0xdd65,0xd834,0xdd72,0xd804,0xd834,0xddb9,0xd834,0xdd65,
+0xd804,0xd834,0xddba,0xd834,0xdd65,0xd834,0xddbb,0xd834,0xdd6e,4,0xd846,0xd834,0xddb9,0xd834,0xdd65,0xd834,
+0xdd6e,0xd834,0xddbc,0xd834,0xdd6e,4,0xd846,0xd834,0xddba,0xd834,0xdd65,0xd834,0xdd6e,0xd834,0xddbb,0xd834,
+0xdd6f,4,0xd846,0xd834,0xddb9,0xd834,0xdd65,0xd834,0xdd6f,0xd834,0xddbc,0xd834,0xdd6f,4,0xd846,0xd834,
+0xddba,0xd834,0xdd65,0xd834,0xdd6f,1,0x4e3d,1,0x4e38,1,0x4e41,2,0xd840,0xdd22,1,0x4f60,
+1,0x4fbb,1,0x5002,1,0x507a,1,0x5099,1,0x50cf,1,0x349e,2,0xd841,0xde3a,1,
+0x5154,1,0x5164,1,0x5177,2,0xd841,0xdd1c,1,0x34b9,1,0x5167,1,0x518d,2,0xd841,
+0xdd4b,1,0x5197,1,0x51a4,1,0x4ecc,1,0x51ac,2,0xd864,0xdddf,1,0x51f5,1,0x5203,
+1,0x34df,1,0x523b,1,0x5246,1,0x5272,1,0x5277,1,0x3515,1,0x5305,1,0x5306,
+1,0x5349,1,0x535a,1,0x5373,1,0x537d,1,0x537f,2,0xd842,0xde2c,1,0x7070,1,
+0x53ca,1,0x53df,2,0xd842,0xdf63,1,0x53eb,1,0x53f1,1,0x5406,1,0x549e,1,0x5438,
+1,0x5448,1,0x5468,1,0x54a2,1,0x54f6,1,0x5510,1,0x5553,1,0x5563,1,0x5584,
+1,0x55ab,1,0x55b3,1,0x55c2,1,0x5716,1,0x5717,1,0x5651,1,0x5674,1,0x58ee,
+1,0x57ce,1,0x57f4,1,0x580d,1,0x578b,1,0x5832,1,0x5831,1,0x58ac,2,0xd845,
+0xdce4,1,0x58f2,1,0x58f7,1,0x5906,1,0x591a,1,0x5922,1,0x5962,2,0xd845,0xdea8,
+2,0xd845,0xdeea,1,0x59ec,1,0x5a1b,1,0x5a27,1,0x59d8,1,0x5a66,1,0x36ee,1,
+0x36fc,1,0x5b08,1,0x5b3e,2,0xd846,0xddc8,1,0x5bc3,1,0x5bd8,1,0x5bf3,2,0xd846,
+0xdf18,1,0x5bff,1,0x5c06,1,0x5f53,1,0x5c22,1,0x3781,1,0x5c60,1,0x5cc0,1,
+0x5c8d,2,0xd847,0xdde4,1,0x5d43,2,0xd847,0xdde6,1,0x5d6e,1,0x5d6b,1,0x5d7c,1,
+0x5de1,1,0x5de2,1,0x382f,1,0x5dfd,1,0x5e28,1,0x5e3d,1,0x5e69,1,0x3862,2,
+0xd848,0xdd83,1,0x387c,1,0x5eb0,1,0x5eb3,1,0x5eb6,2,0xd868,0xdf92,1,0x5efe,2,
+0xd848,0xdf31,1,0x8201,1,0x5f22,1,0x38c7,2,0xd84c,0xdeb8,2,0xd858,0xddda,1,0x5f62,
+1,0x5f6b,1,0x38e3,1,0x5f9a,1,0x5fcd,1,0x5fd7,1,0x5ff9,1,0x6081,1,0x393a,
+1,0x391c,2,0xd849,0xded4,1,0x60c7,1,0x6148,1,0x614c,1,0x617a,1,0x61b2,1,
+0x61a4,1,0x61af,1,0x61de,1,0x6210,1,0x621b,1,0x625d,1,0x62b1,1,0x62d4,1,
+0x6350,2,0xd84a,0xdf0c,1,0x633d,1,0x62fc,1,0x6368,1,0x6383,1,0x63e4,2,0xd84a,
+0xdff1,1,0x6422,1,0x63c5,1,0x63a9,1,0x3a2e,1,0x6469,1,0x647e,1,0x649d,1,
+0x6477,1,0x3a6c,1,0x656c,2,0xd84c,0xdc0a,1,0x65e3,1,0x66f8,1,0x6649,1,0x3b19,
+1,0x3b08,1,0x3ae4,1,0x5192,1,0x5195,1,0x6700,1,0x669c,1,0x80ad,1,0x43d9,
+1,0x6721,1,0x675e,1,0x6753,2,0xd84c,0xdfc3,1,0x3b49,1,0x67fa,1,0x6785,1,
+0x6852,2,0xd84d,0xdc6d,1,0x688e,1,0x681f,1,0x6914,1,0x6942,1,0x69a3,1,0x69ea,
+1,0x6aa8,2,0xd84d,0xdea3,1,0x6adb,1,0x3c18,1,0x6b21,2,0xd84e,0xdca7,1,0x6b54,
+1,0x3c4e,1,0x6b72,1,0x6b9f,1,0x6bbb,2,0xd84e,0xde8d,2,0xd847,0xdd0b,2,0xd84e,
+0xdefa,1,0x6c4e,2,0xd84f,0xdcbc,1,0x6cbf,1,0x6ccd,1,0x6c67,1,0x6d16,1,0x6d3e,
+1,0x6d69,1,0x6d78,1,0x6d85,2,0xd84f,0xdd1e,1,0x6d34,1,0x6e2f,1,0x6e6e,1,
+0x3d33,1,0x6ec7,2,0xd84f,0xded1,1,0x6df9,1,0x6f6e,2,0xd84f,0xdf5e,2,0xd84f,0xdf8e,
+1,0x6fc6,1,0x7039,1,0x701b,1,0x3d96,1,0x704a,1,0x707d,1,0x7077,1,0x70ad,
+2,0xd841,0xdd25,1,0x7145,2,0xd850,0xde63,1,0x719c,2,0xd850,0xdfab,1,0x7228,1,
+0x7250,2,0xd851,0xde08,1,0x7280,1,0x7295,2,0xd851,0xdf35,2,0xd852,0xdc14,1,0x737a,
+1,0x738b,1,0x3eac,1,0x73a5,1,0x3eb8,1,0x7447,1,0x745c,1,0x7485,1,0x74ca,
+1,0x3f1b,1,0x7524,2,0xd853,0xdc36,1,0x753e,2,0xd853,0xdc92,2,0xd848,0xdd9f,1,
+0x7610,2,0xd853,0xdfa1,2,0xd853,0xdfb8,2,0xd854,0xdc44,1,0x3ffc,1,0x4008,2,0xd854,
+0xdcf3,2,0xd854,0xdcf2,2,0xd854,0xdd19,2,0xd854,0xdd33,1,0x771e,1,0x771f,1,0x778b,
+1,0x4046,1,0x4096,2,0xd855,0xdc1d,1,0x784e,1,0x40e3,2,0xd855,0xde26,2,0xd855,
+0xde9a,2,0xd855,0xdec5,1,0x79eb,1,0x412f,1,0x7a4a,1,0x7a4f,2,0xd856,0xdd7c,2,
+0xd856,0xdea7,1,0x7aee,1,0x4202,2,0xd856,0xdfab,1,0x7bc6,1,0x7bc9,1,0x4227,2,
+0xd857,0xdc80,1,0x7cd2,1,0x42a0,1,0x7ce8,1,0x7ce3,1,0x7d00,2,0xd857,0xdf86,1,
+0x7d63,1,0x4301,1,0x7dc7,1,0x7e02,1,0x7e45,1,0x4334,2,0xd858,0xde28,2,0xd858,
+0xde47,1,0x4359,2,0xd858,0xded9,1,0x7f7a,2,0xd858,0xdf3e,1,0x7f95,1,0x7ffa,2,
+0xd859,0xdcda,2,0xd859,0xdd23,1,0x8060,2,0xd859,0xdda8,1,0x8070,2,0xd84c,0xdf5f,1,
+0x43d5,1,0x80b2,1,0x8103,1,0x440b,1,0x813e,1,0x5ab5,2,0xd859,0xdfa7,2,0xd859,
+0xdfb5,2,0xd84c,0xdf93,2,0xd84c,0xdf9c,1,0x8204,1,0x8f9e,1,0x446b,1,0x8291,1,
+0x828b,1,0x829d,1,0x52b3,1,0x82b1,1,0x82b3,1,0x82bd,1,0x82e6,2,0xd85a,0xdf3c,
+1,0x831d,1,0x8363,1,0x83ad,1,0x8323,1,0x83bd,1,0x83e7,1,0x8353,1,0x83ca,
+1,0x83cc,1,0x83dc,2,0xd85b,0xdc36,2,0xd85b,0xdd6b,2,0xd85b,0xdcd5,1,0x452b,1,
+0x84f1,1,0x84f3,1,0x8516,2,0xd85c,0xdfca,1,0x8564,2,0xd85b,0xdf2c,1,0x455d,1,
+0x4561,2,0xd85b,0xdfb1,2,0xd85c,0xdcd2,1,0x456b,1,0x8650,1,0x8667,1,0x8669,1,
+0x86a9,1,0x8688,1,0x870e,1,0x86e2,1,0x8728,1,0x876b,1,0x8786,1,0x45d7,1,
+0x87e1,1,0x8801,1,0x45f9,1,0x8860,1,0x8863,2,0xd85d,0xde67,1,0x88d7,1,0x88de,
+1,0x4635,1,0x88fa,1,0x34bb,2,0xd85e,0xdcae,2,0xd85e,0xdd66,1,0x46be,1,0x46c7,
+1,0x8aa0,1,0x8c55,2,0xd85f,0xdca8,1,0x8cab,1,0x8cc1,1,0x8d1b,1,0x8d77,2,
+0xd85f,0xdf2f,2,0xd842,0xdc04,1,0x8dcb,1,0x8dbc,1,0x8df0,2,0xd842,0xdcde,1,0x8ed4,
+2,0xd861,0xddd2,2,0xd861,0xdded,1,0x9094,1,0x90f1,1,0x9111,2,0xd861,0xdf2e,1,
+0x911b,1,0x9238,1,0x92d7,1,0x92d8,1,0x927c,1,0x93f9,1,0x9415,2,0xd862,0xdffa,
+1,0x958b,1,0x4995,1,0x95b7,2,0xd863,0xdd77,1,0x49e6,1,0x96c3,1,0x5db2,1,
+0x9723,2,0xd864,0xdd45,2,0xd864,0xde1a,1,0x4a6e,1,0x4a76,1,0x97e0,2,0xd865,0xdc0a,
+1,0x4ab2,2,0xd865,0xdc96,1,0x9829,2,0xd865,0xddb6,1,0x98e2,1,0x4b33,1,0x9929,
+1,0x99a7,1,0x99c2,1,0x99fe,1,0x4bce,2,0xd866,0xdf30,1,0x9c40,1,0x9cfd,1,
+0x4cce,1,0x4ced,1,0x9d67,2,0xd868,0xdcce,1,0x4cf8,2,0xd868,0xdd05,2,0xd868,0xde0e,
+2,0xd868,0xde91,1,0x9ebb,1,0x4d56,1,0x9ef9,1,0x9efe,1,0x9f05,1,0x9f0f,1,
+0x9f16,1,0x9f3b,2,0xd869,0xde00,0x3ac,0xe642,0x3b1,0x301,0x3ad,0xe642,0x3b5,0x301,0x3ae,0xe642,
+0x3b7,0x301,0x3af,0xe642,0x3b9,0x301,0x3cc,0xe642,0x3bf,0x301,0x3cd,0xe642,0x3c5,0x301,0x3ce,0xe642,
+0x3c9,0x301,0x386,0xe642,0x391,0x301,0x388,0xe642,0x395,0x301,0x389,0xe642,0x397,0x301,0x390,1,
+0xe643,0x3b9,0x308,0x301,0x38a,0xe642,0x399,0x301,0x3b0,1,0xe643,0x3c5,0x308,0x301,0x38e,0xe642,
+0x3a5,0x301,0x385,0xe642,0xa8,0x301,0x38c,0xe642,0x39f,0x301,0x38f,0xe642,0x3a9,0x301,0xc5,0xe642,
+0x41,0x30a,0xe6e6,0xe681,0x300,0xe6e6,0xe681,0x301,0xe6e6,0xe681,0x313,0xe6e6,0xe682,0x308,0x301,0x8100,
+0x8282,0xf71,0xf72,0x8100,0x8482,0xf71,0xf74,0x8100,0x8282,0xf71,0xf80,0
 };
 
 static const uint8_t norm2_nfc_data_smallFCD[256]={
@@ -1139,13 +1143,13 @@ static const UTrie2 norm2_nfc_data_trie={
     norm2_nfc_data_trieIndex+2720,
     NULL,
     2720,
-    7004,
+    7056,
     0x188,
     0xb1c,
-    0x0,
-    0x0,
+    0x1,
+    0x1,
     0x30000,
-    0x25f8,
+    0x262c,
     NULL, 0, FALSE, FALSE, 0, NULL
 };
 
diff --git a/icu4c/source/common/norm2allmodes.h b/icu4c/source/common/norm2allmodes.h
index 559858c4fe9..638fc87b5c4 100644
--- a/icu4c/source/common/norm2allmodes.h
+++ b/icu4c/source/common/norm2allmodes.h
@@ -23,6 +23,7 @@
 #include "unicode/unistr.h"
 #include "cpputils.h"
 #include "normalizer2impl.h"
+#include "ustr_imp.h"  // U_EDITS_NO_RESET
 
 U_NAMESPACE_BEGIN
 
@@ -211,8 +212,8 @@ private:
     virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const {
         return impl.isDecompYes(impl.getNorm16(c)) ? UNORM_YES : UNORM_NO;
     }
-    virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasDecompBoundary(c, TRUE); }
-    virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasDecompBoundary(c, FALSE); }
+    virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasDecompBoundaryBefore(c); }
+    virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasDecompBoundaryAfter(c); }
     virtual UBool isInert(UChar32 c) const { return impl.isDecompInert(c); }
 };
 
@@ -236,12 +237,12 @@ private:
         if (U_FAILURE(errorCode)) {
             return;
         }
-        if (edits != nullptr) {
+        if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
             edits->reset();
         }
         const uint8_t *s = reinterpret_cast<const uint8_t *>(src.data());
-        impl.composeUTF8(options, s, s + src.length(),
-                         onlyContiguous, TRUE, sink, edits, errorCode);
+        impl.composeUTF8(options, onlyContiguous, s, s + src.length(),
+                         &sink, edits, errorCode);
         sink.Flush();
     }
 
@@ -295,10 +296,10 @@ private:
         return impl.hasCompBoundaryBefore(c);
     }
     virtual UBool hasBoundaryAfter(UChar32 c) const override {
-        return impl.hasCompBoundaryAfter(c, onlyContiguous, FALSE);
+        return impl.hasCompBoundaryAfter(c, onlyContiguous);
     }
     virtual UBool isInert(UChar32 c) const override {
-        return impl.hasCompBoundaryAfter(c, onlyContiguous, TRUE);
+        return impl.isCompInert(c, onlyContiguous);
     }
 
     const UBool onlyContiguous;
diff --git a/icu4c/source/common/normalizer2.cpp b/icu4c/source/common/normalizer2.cpp
index 28e5f353afb..a62a8d930ba 100644
--- a/icu4c/source/common/normalizer2.cpp
+++ b/icu4c/source/common/normalizer2.cpp
@@ -30,6 +30,7 @@
 #include "normalizer2impl.h"
 #include "uassert.h"
 #include "ucln_cmn.h"
+#include "ustr_imp.h"  // U_EDITS_NO_RESET
 
 using icu::Normalizer2Impl;
 
@@ -90,14 +91,18 @@ class NoopNormalizer2 : public Normalizer2 {
         return dest;
     }
     virtual void
-    normalizeUTF8(uint32_t /*options*/, StringPiece src, ByteSink &sink,
+    normalizeUTF8(uint32_t options, StringPiece src, ByteSink &sink,
                   Edits *edits, UErrorCode &errorCode) const override {
         if(U_SUCCESS(errorCode)) {
-            sink.Append(src.data(), src.length());
             if (edits != nullptr) {
-                edits->reset();
+                if ((options & U_EDITS_NO_RESET) == 0) {
+                    edits->reset();
+                }
                 edits->addUnchanged(src.length());
             }
+            if ((options & U_OMIT_UNCHANGED_TEXT) == 0) {
+                sink.Append(src.data(), src.length());
+            }
             sink.Flush();
         }
     }
diff --git a/icu4c/source/common/normalizer2impl.cpp b/icu4c/source/common/normalizer2impl.cpp
index 5ab29e42e8d..1249aede85e 100644
--- a/icu4c/source/common/normalizer2impl.cpp
+++ b/icu4c/source/common/normalizer2impl.cpp
@@ -59,27 +59,27 @@ inline uint8_t leadByteForCP(UChar32 c) {
 
 /**
  * Returns the code point from one single well-formed UTF-8 byte sequence
- * between src and limit.
+ * between cpStart and cpLimit.
  *
  * UTrie2 UTF-8 macros do not assemble whole code points (for efficiency).
  * When we do need the code point, we call this function.
  * We should not need it for normalization-inert data (norm16==0).
  * Illegal sequences yield the error value norm16==0 just like real normalization-inert code points.
  */
-UChar32 codePointFromValidUTF8(const uint8_t *src, const uint8_t *limit) {
+UChar32 codePointFromValidUTF8(const uint8_t *cpStart, const uint8_t *cpLimit) {
     // Similar to U8_NEXT_UNSAFE(s, i, c).
-    U_ASSERT(src < limit);
-    uint8_t c = *src;
-    switch(limit-src) {
+    U_ASSERT(cpStart < cpLimit);
+    uint8_t c = *cpStart;
+    switch(cpLimit-cpStart) {
     case 1:
         return c;
     case 2:
-        return ((c&0x1f)<<6) | (src[1]&0x3f);
+        return ((c&0x1f)<<6) | (cpStart[1]&0x3f);
     case 3:
         // no need for (c&0xf) because the upper bits are truncated after <<12 in the cast to (UChar)
-        return (UChar)((c<<12) | ((src[1]&0x3f)<<6) | (src[2]&0x3f));
+        return (UChar)((c<<12) | ((cpStart[1]&0x3f)<<6) | (cpStart[2]&0x3f));
     case 4:
-        return ((c&7)<<18) | ((src[1]&0x3f)<<12) | ((src[2]&0x3f)<<6) | (src[3]&0x3f);
+        return ((c&7)<<18) | ((cpStart[1]&0x3f)<<12) | ((cpStart[2]&0x3f)<<6) | (cpStart[3]&0x3f);
     default:
         U_ASSERT(FALSE);  // Should not occur.
         return U_SENTINEL;
@@ -87,18 +87,22 @@ UChar32 codePointFromValidUTF8(const uint8_t *src, const uint8_t *limit) {
 }
 
 /**
- * Returns the offset from the Jamo L base if [src, limit[ is a single Jamo L code point.
+ * Returns the last code point in [start, p[ if it is valid and in U+1000..U+D7FF.
  * Otherwise returns a negative value.
  */
-int32_t getJamoLMinusBase(const uint8_t *src, const uint8_t *limit) {
-    // Jamo L: E1 84 80..92
-    if ((limit - src) == 3 && *src == 0xe1 && src[1] == 0x84) {
-        uint8_t l = src[2] - 0x80;
-        if (l < Hangul::JAMO_L_COUNT) {
-            return l;
+UChar32 previousHangulOrJamo(const uint8_t *start, const uint8_t *p) {
+    if ((p - start) >= 3) {
+        p -= 3;
+        uint8_t l = *p;
+        uint8_t t1, t2;
+        if (0xe1 <= l && l <= 0xed &&
+                (t1 = (uint8_t)(p[1] - 0x80)) <= 0x3f &&
+                (t2 = (uint8_t)(p[2] - 0x80)) <= 0x3f &&
+                (l < 0xed || t1 <= 0x1f)) {
+            return ((l & 0xf) << 12) | (t1 << 6) | t2;
         }
     }
-    return -1;
+    return U_SENTINEL;
 }
 
 /**
@@ -125,12 +129,6 @@ int32_t getJamoTMinusBase(const uint8_t *src, const uint8_t *limit) {
     return -1;
 }
 
-void giveByteSinkAllocationHint(ByteSink &sink, int32_t desiredCapacity) {
-    char scratch[1];
-    int32_t capacity;
-    sink.GetAppendBuffer(1, desiredCapacity, scratch, UPRV_LENGTHOF(scratch), &capacity);
-}
-
 /** The bytes at [src, nextSrc[ were mapped to valid (s16, s16Length). */
 UBool
 appendChange(const uint8_t *src, const uint8_t *nextSrc,
@@ -185,6 +183,37 @@ appendCodePoint(const uint8_t *src, const uint8_t *nextSrc, UChar32 c,
     sink.Append(buffer, length);
 }
 
+void
+appendCodePointDelta(const uint8_t *cpStart, const uint8_t *cpLimit, int32_t delta,
+                     ByteSink &sink, Edits *edits) {
+    char buffer[U8_MAX_LENGTH];
+    int32_t length;
+    int32_t cpLength = (int32_t)(cpLimit - cpStart);
+    if (cpLength == 1) {
+        // The builder makes ASCII map to ASCII.
+        buffer[0] = (uint8_t)(*cpStart + delta);
+        length = 1;
+    } else {
+        int32_t trail = *(cpLimit-1) + delta;
+        if (0x80 <= trail && trail <= 0xbf) {
+            // The delta only changes the last trail byte.
+            --cpLimit;
+            length = 0;
+            do { buffer[length++] = *cpStart++; } while (cpStart < cpLimit);
+            buffer[length++] = (uint8_t)trail;
+        } else {
+            // Decode the code point, add the delta, re-encode.
+            UChar32 c = codePointFromValidUTF8(cpStart, cpLimit) + delta;
+            length = 0;
+            U8_APPEND_UNSAFE(buffer, length, c);
+        }
+    }
+    if (edits != nullptr) {
+        edits->addReplace(cpLength, length);
+    }
+    sink.Append(buffer, length);
+}
+
 UBool
 appendUnchanged(const uint8_t *s, const uint8_t *limit,
                 ByteSink &sink, uint32_t options, Edits *edits,
@@ -210,6 +239,17 @@ appendUnchanged(const uint8_t *s, const uint8_t *limit,
 
 // ReorderingBuffer -------------------------------------------------------- ***
 
+ReorderingBuffer::ReorderingBuffer(const Normalizer2Impl &ni, UnicodeString &dest,
+                                   UErrorCode &errorCode) :
+        impl(ni), str(dest),
+        start(str.getBuffer(8)), reorderStart(start), limit(start),
+        remainingCapacity(str.getCapacity()), lastCC(0) {
+    if (start == nullptr && U_SUCCESS(errorCode)) {
+        // getBuffer() already did str.setToBogus()
+        errorCode = U_MEMORY_ALLOCATION_ERROR;
+    }
+}
+
 UBool ReorderingBuffer::init(int32_t destCapacity, UErrorCode &errorCode) {
     int32_t length=str.length();
     start=str.getBuffer(destCapacity);
@@ -415,16 +455,12 @@ uint8_t ReorderingBuffer::previousCC() {
         return 0;
     }
     UChar32 c=*--codePointStart;
-    if(c<Normalizer2Impl::MIN_CCC_LCCC_CP) {
-        return 0;
-    }
-
     UChar c2;
     if(U16_IS_TRAIL(c) && start<codePointStart && U16_IS_LEAD(c2=*(codePointStart-1))) {
         --codePointStart;
         c=U16_GET_SUPPLEMENTARY(c2, c);
     }
-    return Normalizer2Impl::getCCFromYesOrMaybe(impl.getNorm16(c));
+    return impl.getCCFromYesOrMaybeCP(c);
 }
 
 // Inserts c somewhere before the last character.
@@ -462,68 +498,36 @@ Normalizer2Impl::init(const int32_t *inIndexes, const UTrie2 *inTrie,
                       const uint16_t *inExtraData, const uint8_t *inSmallFCD) {
     minDecompNoCP=inIndexes[IX_MIN_DECOMP_NO_CP];
     minCompNoMaybeCP=inIndexes[IX_MIN_COMP_NO_MAYBE_CP];
+    minLcccCP=inIndexes[IX_MIN_LCCC_CP];
 
     minYesNo=inIndexes[IX_MIN_YES_NO];
     minYesNoMappingsOnly=inIndexes[IX_MIN_YES_NO_MAPPINGS_ONLY];
     minNoNo=inIndexes[IX_MIN_NO_NO];
+    minNoNoCompBoundaryBefore=inIndexes[IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE];
+    minNoNoCompNoMaybeCC=inIndexes[IX_MIN_NO_NO_COMP_NO_MAYBE_CC];
+    minNoNoEmpty=inIndexes[IX_MIN_NO_NO_EMPTY];
     limitNoNo=inIndexes[IX_LIMIT_NO_NO];
     minMaybeYes=inIndexes[IX_MIN_MAYBE_YES];
+    U_ASSERT((minMaybeYes&7)==0);  // 8-aligned for noNoDelta bit fields
+    centerNoNoDelta=(minMaybeYes>>DELTA_SHIFT)-MAX_DELTA-1;
 
     normTrie=inTrie;
 
     maybeYesCompositions=inExtraData;
-    extraData=maybeYesCompositions+(MIN_NORMAL_MAYBE_YES-minMaybeYes);
+    extraData=maybeYesCompositions+((MIN_NORMAL_MAYBE_YES-minMaybeYes)>>OFFSET_SHIFT);
 
     smallFCD=inSmallFCD;
-
-    // Build tccc180[].
-    // gennorm2 enforces lccc=0 for c<MIN_CCC_LCCC_CP=U+0300.
-    uint8_t bits=0;
-    for(UChar c=0; c<0x180; bits>>=1) {
-        if((c&0xff)==0) {
-            bits=smallFCD[c>>8];  // one byte per 0x100 code points
-        }
-        if(bits&1) {
-            for(int i=0; i<0x20; ++i, ++c) {
-                tccc180[c]=(uint8_t)getFCD16FromNormData(c);
-            }
-        } else {
-            uprv_memset(tccc180+c, 0, 0x20);
-            c+=0x20;
-        }
-    }
 }
 
-uint8_t Normalizer2Impl::getTrailCCFromCompYesAndZeroCC(const UChar *cpStart, const UChar *cpLimit) const {
-    UChar32 c;
-    if(cpStart==(cpLimit-1)) {
-        c=*cpStart;
-    } else {
-        c=U16_GET_SUPPLEMENTARY(cpStart[0], cpStart[1]);
-    }
-    uint16_t prevNorm16=getNorm16(c);
-    if(prevNorm16<=minYesNo) {
-        return 0;  // yesYes and Hangul LV/LVT have ccc=tccc=0
-    } else {
-        return (uint8_t)(*getMapping(prevNorm16)>>8);  // tccc from yesNo
-    }
-}
-
-namespace {
-
 class LcccContext {
 public:
     LcccContext(const Normalizer2Impl &ni, UnicodeSet &s) : impl(ni), set(s) {}
 
     void handleRange(UChar32 start, UChar32 end, uint16_t norm16) {
-        if(impl.isAlgorithmicNoNo(norm16)) {
-            // Range of code points with same-norm16-value algorithmic decompositions.
-            // They might have different non-zero FCD16 values.
-            do {
-                uint16_t fcd16=impl.getFCD16(start);
-                if(fcd16>0xff) { set.add(start); }
-            } while(++start<=end);
-        } else {
+        if (norm16 > Normalizer2Impl::MIN_NORMAL_MAYBE_YES &&
+                norm16 != Normalizer2Impl::JAMO_VT) {
+            set.add(start, end);
+        } else if (impl.minNoNoCompNoMaybeCC <= norm16 && norm16 < impl.limitNoNo) {
             uint16_t fcd16=impl.getFCD16(start);
             if(fcd16>0xff) { set.add(start, end); }
         }
@@ -534,6 +538,8 @@ private:
     UnicodeSet &set;
 };
 
+namespace {
+
 struct PropertyStartsContext {
     PropertyStartsContext(const Normalizer2Impl &ni, const USetAdder *adder)
             : impl(ni), sa(adder) {}
@@ -558,7 +564,8 @@ enumNorm16PropertyStartsRange(const void *context, UChar32 start, UChar32 end, u
     const PropertyStartsContext *ctx=(const PropertyStartsContext *)context;
     const USetAdder *sa=ctx->sa;
     sa->add(sa->set, start);
-    if(start!=end && ctx->impl.isAlgorithmicNoNo((uint16_t)value)) {
+    if (start != end && ctx->impl.isAlgorithmicNoNo((uint16_t)value) &&
+            (value & Normalizer2Impl::DELTA_TCCC_MASK) > Normalizer2Impl::DELTA_TCCC_1) {
         // Range of code points with same-norm16-value algorithmic decompositions.
         // They might have different non-zero FCD16 values.
         uint16_t prevFCD16=ctx->impl.getFCD16(start);
@@ -590,7 +597,6 @@ U_CDECL_END
 
 void
 Normalizer2Impl::addLcccChars(UnicodeSet &set) const {
-    /* add the start code point of each same-value range of each trie */
     LcccContext context(*this, set);
     utrie2_enum(normTrie, NULL, enumLcccRange, &context);
 }
@@ -767,157 +773,174 @@ Normalizer2Impl::decompose(const UChar *src, const UChar *limit,
 // fail the quick check loop and/or where the quick check loop's overhead
 // is unlikely to be amortized.
 // Called by the compose() and makeFCD() implementations.
-UBool Normalizer2Impl::decomposeShort(const UChar *src, const UChar *limit,
-                                      ReorderingBuffer &buffer,
-                                      UErrorCode &errorCode) const {
+const UChar *
+Normalizer2Impl::decomposeShort(const UChar *src, const UChar *limit,
+                                UBool stopAtCompBoundary, UBool onlyContiguous,
+                                ReorderingBuffer &buffer, UErrorCode &errorCode) const {
+    if (U_FAILURE(errorCode)) {
+        return nullptr;
+    }
     while(src<limit) {
+        if (stopAtCompBoundary && *src < minCompNoMaybeCP) {
+            return src;
+        }
+        const UChar *prevSrc = src;
         UChar32 c;
         uint16_t norm16;
         UTRIE2_U16_NEXT16(normTrie, src, limit, c, norm16);
+        if (stopAtCompBoundary && norm16HasCompBoundaryBefore(norm16)) {
+            return prevSrc;
+        }
         if(!decompose(c, norm16, buffer, errorCode)) {
-            return FALSE;
+            return nullptr;
+        }
+        if (stopAtCompBoundary && norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+            return src;
         }
     }
-    return TRUE;
+    return src;
 }
 
 UBool Normalizer2Impl::decompose(UChar32 c, uint16_t norm16,
                                  ReorderingBuffer &buffer,
                                  UErrorCode &errorCode) const {
-    // Only loops for 1:1 algorithmic mappings.
-    for(;;) {
-        // get the decomposition and the lead and trail cc's
-        if(isDecompYes(norm16)) {
-            // c does not decompose
+    // get the decomposition and the lead and trail cc's
+    if (norm16 >= limitNoNo) {
+        if (isMaybeOrNonZeroCC(norm16)) {
             return buffer.append(c, getCCFromYesOrMaybe(norm16), errorCode);
-        } else if(isHangul(norm16)) {
-            // Hangul syllable: decompose algorithmically
-            UChar jamos[3];
-            return buffer.appendZeroCC(jamos, jamos+Hangul::decompose(c, jamos), errorCode);
-        } else if(isDecompNoAlgorithmic(norm16)) {
-            c=mapAlgorithmic(c, norm16);
-            norm16=getNorm16(c);
-        } else {
-            // c decomposes, get everything from the variable-length extra data
-            const uint16_t *mapping=getMapping(norm16);
-            uint16_t firstUnit=*mapping;
-            int32_t length=firstUnit&MAPPING_LENGTH_MASK;
-            uint8_t leadCC, trailCC;
-            trailCC=(uint8_t)(firstUnit>>8);
-            if(firstUnit&MAPPING_HAS_CCC_LCCC_WORD) {
-                leadCC=(uint8_t)(*(mapping-1)>>8);
-            } else {
-                leadCC=0;
-            }
-            return buffer.append((const UChar *)mapping+1, length, leadCC, trailCC, errorCode);
         }
+        // Maps to an isCompYesAndZeroCC.
+        c=mapAlgorithmic(c, norm16);
+        norm16=getNorm16(c);
     }
+    if (norm16 < minYesNo) {
+        // c does not decompose
+        return buffer.append(c, 0, errorCode);
+    } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
+        // Hangul syllable: decompose algorithmically
+        UChar jamos[3];
+        return buffer.appendZeroCC(jamos, jamos+Hangul::decompose(c, jamos), errorCode);
+    }
+    // c decomposes, get everything from the variable-length extra data
+    const uint16_t *mapping=getMapping(norm16);
+    uint16_t firstUnit=*mapping;
+    int32_t length=firstUnit&MAPPING_LENGTH_MASK;
+    uint8_t leadCC, trailCC;
+    trailCC=(uint8_t)(firstUnit>>8);
+    if(firstUnit&MAPPING_HAS_CCC_LCCC_WORD) {
+        leadCC=(uint8_t)(*(mapping-1)>>8);
+    } else {
+        leadCC=0;
+    }
+    return buffer.append((const UChar *)mapping+1, length, leadCC, trailCC, errorCode);
 }
 
 const uint8_t *
 Normalizer2Impl::decomposeShort(const uint8_t *src, const uint8_t *limit,
-                                UBool stopAtCompBoundary, ReorderingBuffer &buffer,
-                                UErrorCode &errorCode) const {
+                                UBool stopAtCompBoundary, UBool onlyContiguous,
+                                ReorderingBuffer &buffer, UErrorCode &errorCode) const {
     if (U_FAILURE(errorCode)) {
         return nullptr;
     }
-    // UTF-8 version of decomposeShort() + findNextCompBoundary() together
     while (src < limit) {
-        const uint8_t *nextSrc = src;
+        const uint8_t *prevSrc = src;
         uint16_t norm16;
-        UTRIE2_U8_NEXT16(normTrie, nextSrc, limit, norm16);
+        UTRIE2_U8_NEXT16(normTrie, src, limit, norm16);
         // Get the decomposition and the lead and trail cc's.
-        // Only loops for 1:1 algorithmic mappings.
         UChar32 c = U_SENTINEL;
-        for (;;) {
-            if (stopAtCompBoundary && isCompYesAndZeroCC(norm16)) {
-                return src;
-            }
-            // norm16!=0 guarantees that [src, nextSrc[ is valid UTF-8.
-            // We do not see invalid UTF-8 here because
-            // its norm16==0 is normalization-inert,
-            // so it gets copied unchanged in the fast path,
-            // and we stop the slow path where invalid UTF-8 begins.
-            U_ASSERT(norm16 != 0);
-            if (isDecompYes(norm16)) {
-                if (c < 0) {
-                    c = codePointFromValidUTF8(src, nextSrc);
-                }
-                // does not decompose
+        if (norm16 >= limitNoNo) {
+            if (isMaybeOrNonZeroCC(norm16)) {
+                // No boundaries around this character.
+                c = codePointFromValidUTF8(prevSrc, src);
                 if (!buffer.append(c, getCCFromYesOrMaybe(norm16), errorCode)) {
                     return nullptr;
                 }
-                break;
-            } else if (isHangul(norm16)) {
-                // Hangul syllable: decompose algorithmically
-                if (c < 0) {
-                    c = codePointFromValidUTF8(src, nextSrc);
-                }
-                char16_t jamos[3];
-                if (!buffer.appendZeroCC(jamos, jamos+Hangul::decompose(c, jamos), errorCode)) {
-                    return nullptr;
-                }
-                break;
-            } else if (isDecompNoAlgorithmic(norm16)) {
-                if (c < 0) {
-                    c = codePointFromValidUTF8(src, nextSrc);
-                }
-                c = mapAlgorithmic(c, norm16);
-                norm16 = getNorm16(c);
+                continue;
+            }
+            // Maps to an isCompYesAndZeroCC.
+            if (stopAtCompBoundary) {
+                return prevSrc;
+            }
+            c = codePointFromValidUTF8(prevSrc, src);
+            c = mapAlgorithmic(c, norm16);
+            norm16 = getNorm16(c);
+        } else if (stopAtCompBoundary && norm16 < minNoNoCompNoMaybeCC) {
+            return prevSrc;
+        }
+        // norm16!=INERT guarantees that [prevSrc, src[ is valid UTF-8.
+        // We do not see invalid UTF-8 here because
+        // its norm16==INERT is normalization-inert,
+        // so it gets copied unchanged in the fast path,
+        // and we stop the slow path where invalid UTF-8 begins.
+        U_ASSERT(norm16 != INERT);
+        if (norm16 < minYesNo) {
+            if (c < 0) {
+                c = codePointFromValidUTF8(prevSrc, src);
+            }
+            // does not decompose
+            if (!buffer.append(c, 0, errorCode)) {
+                return nullptr;
+            }
+        } else if (isHangulLV(norm16) || isHangulLVT(norm16)) {
+            // Hangul syllable: decompose algorithmically
+            if (c < 0) {
+                c = codePointFromValidUTF8(prevSrc, src);
+            }
+            char16_t jamos[3];
+            if (!buffer.appendZeroCC(jamos, jamos+Hangul::decompose(c, jamos), errorCode)) {
+                return nullptr;
+            }
+        } else {
+            // The character decomposes, get everything from the variable-length extra data.
+            const uint16_t *mapping = getMapping(norm16);
+            uint16_t firstUnit = *mapping;
+            int32_t length = firstUnit & MAPPING_LENGTH_MASK;
+            uint8_t trailCC = (uint8_t)(firstUnit >> 8);
+            uint8_t leadCC;
+            if (firstUnit & MAPPING_HAS_CCC_LCCC_WORD) {
+                leadCC = (uint8_t)(*(mapping-1) >> 8);
             } else {
-                // The character decomposes, get everything from the variable-length extra data.
-                const uint16_t *mapping = getMapping(norm16);
-                uint16_t firstUnit = *mapping;
-                int32_t length = firstUnit & MAPPING_LENGTH_MASK;
-                uint8_t leadCC;
-                if (firstUnit & MAPPING_HAS_CCC_LCCC_WORD) {
-                    leadCC = (uint8_t)(*(mapping-1) >> 8);
-                } else {
-                    leadCC = 0;
-                }
-                if (stopAtCompBoundary && length != 0 && leadCC == 0) {
-                    int32_t i = 1;  // skip over the firstUnit
-                    U16_NEXT_UNSAFE(mapping, i, c);
-                    if (isCompYesAndZeroCC(getNorm16(c))) {
-                        return src;
-                    }
-                }
-                uint8_t trailCC = (uint8_t)(firstUnit >> 8);
-                if (!buffer.append((const char16_t *)mapping+1, length, leadCC, trailCC, errorCode)) {
-                    return nullptr;
-                }
-                break;
+                leadCC = 0;
+            }
+            if (!buffer.append((const char16_t *)mapping+1, length, leadCC, trailCC, errorCode)) {
+                return nullptr;
             }
         }
-        src = nextSrc;
+        if (stopAtCompBoundary && norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+            return src;
+        }
     }
     return src;
 }
 
 const UChar *
 Normalizer2Impl::getDecomposition(UChar32 c, UChar buffer[4], int32_t &length) const {
-    const UChar *decomp=NULL;
     uint16_t norm16;
-    for(;;) {
-        if(c<minDecompNoCP || isDecompYes(norm16=getNorm16(c))) {
-            // c does not decompose
-            return decomp;
-        } else if(isHangul(norm16)) {
-            // Hangul syllable: decompose algorithmically
-            length=Hangul::decompose(c, buffer);
-            return buffer;
-        } else if(isDecompNoAlgorithmic(norm16)) {
-            c=mapAlgorithmic(c, norm16);
-            decomp=buffer;
-            length=0;
-            U16_APPEND_UNSAFE(buffer, length, c);
-        } else {
-            // c decomposes, get everything from the variable-length extra data
-            const uint16_t *mapping=getMapping(norm16);
-            length=*mapping&MAPPING_LENGTH_MASK;
-            return (const UChar *)mapping+1;
-        }
+    if(c<minDecompNoCP || isMaybeOrNonZeroCC(norm16=getNorm16(c))) {
+        // c does not decompose
+        return nullptr;
     }
+    const UChar *decomp = nullptr;
+    if(isDecompNoAlgorithmic(norm16)) {
+        // Maps to an isCompYesAndZeroCC.
+        c=mapAlgorithmic(c, norm16);
+        decomp=buffer;
+        length=0;
+        U16_APPEND_UNSAFE(buffer, length, c);
+        // The mapping might decompose further.
+        norm16 = getNorm16(c);
+    }
+    if (norm16 < minYesNo) {
+        return decomp;
+    } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
+        // Hangul syllable: decompose algorithmically
+        length=Hangul::decompose(c, buffer);
+        return buffer;
+    }
+    // c decomposes, get everything from the variable-length extra data
+    const uint16_t *mapping=getMapping(norm16);
+    length=*mapping&MAPPING_LENGTH_MASK;
+    return (const UChar *)mapping+1;
 }
 
 // The capacity of the buffer must be 30=MAPPING_LENGTH_MASK-1
@@ -926,13 +949,11 @@ Normalizer2Impl::getDecomposition(UChar32 c, UChar buffer[4], int32_t &length) c
 // The maximum length of a normal mapping is 31=MAPPING_LENGTH_MASK.
 const UChar *
 Normalizer2Impl::getRawDecomposition(UChar32 c, UChar buffer[30], int32_t &length) const {
-    // We do not loop in this method because an algorithmic mapping itself
-    // becomes a final result rather than having to be decomposed recursively.
     uint16_t norm16;
     if(c<minDecompNoCP || isDecompYes(norm16=getNorm16(c))) {
         // c does not decompose
         return NULL;
-    } else if(isHangul(norm16)) {
+    } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
         // Hangul syllable: decompose algorithmically
         Hangul::getRawDecomposition(c, buffer);
         length=2;
@@ -942,30 +963,29 @@ Normalizer2Impl::getRawDecomposition(UChar32 c, UChar buffer[30], int32_t &lengt
         length=0;
         U16_APPEND_UNSAFE(buffer, length, c);
         return buffer;
-    } else {
-        // c decomposes, get everything from the variable-length extra data
-        const uint16_t *mapping=getMapping(norm16);
-        uint16_t firstUnit=*mapping;
-        int32_t mLength=firstUnit&MAPPING_LENGTH_MASK;  // length of normal mapping
-        if(firstUnit&MAPPING_HAS_RAW_MAPPING) {
-            // Read the raw mapping from before the firstUnit and before the optional ccc/lccc word.
-            // Bit 7=MAPPING_HAS_CCC_LCCC_WORD
-            const uint16_t *rawMapping=mapping-((firstUnit>>7)&1)-1;
-            uint16_t rm0=*rawMapping;
-            if(rm0<=MAPPING_LENGTH_MASK) {
-                length=rm0;
-                return (const UChar *)rawMapping-rm0;
-            } else {
-                // Copy the normal mapping and replace its first two code units with rm0.
-                buffer[0]=(UChar)rm0;
-                u_memcpy(buffer+1, (const UChar *)mapping+1+2, mLength-2);
-                length=mLength-1;
-                return buffer;
-            }
+    }
+    // c decomposes, get everything from the variable-length extra data
+    const uint16_t *mapping=getMapping(norm16);
+    uint16_t firstUnit=*mapping;
+    int32_t mLength=firstUnit&MAPPING_LENGTH_MASK;  // length of normal mapping
+    if(firstUnit&MAPPING_HAS_RAW_MAPPING) {
+        // Read the raw mapping from before the firstUnit and before the optional ccc/lccc word.
+        // Bit 7=MAPPING_HAS_CCC_LCCC_WORD
+        const uint16_t *rawMapping=mapping-((firstUnit>>7)&1)-1;
+        uint16_t rm0=*rawMapping;
+        if(rm0<=MAPPING_LENGTH_MASK) {
+            length=rm0;
+            return (const UChar *)rawMapping-rm0;
         } else {
-            length=mLength;
-            return (const UChar *)mapping+1;
+            // Copy the normal mapping and replace its first two code units with rm0.
+            buffer[0]=(UChar)rm0;
+            u_memcpy(buffer+1, (const UChar *)mapping+1+2, mLength-2);
+            length=mLength-1;
+            return buffer;
         }
+    } else {
+        length=mLength;
+        return (const UChar *)mapping+1;
     }
 }
 
@@ -996,43 +1016,60 @@ void Normalizer2Impl::decomposeAndAppend(const UChar *src, const UChar *limit,
     }
 }
 
-// Note: hasDecompBoundary() could be implemented as aliases to
-// hasFCDBoundaryBefore() and hasFCDBoundaryAfter()
-// at the cost of building the FCD trie for a decomposition normalizer.
-UBool Normalizer2Impl::hasDecompBoundary(UChar32 c, UBool before) const {
-    for(;;) {
-        if(c<minDecompNoCP) {
-            return TRUE;
-        }
-        uint16_t norm16=getNorm16(c);
-        if(isHangul(norm16) || isDecompYesAndZeroCC(norm16)) {
-            return TRUE;
-        } else if(norm16>MIN_NORMAL_MAYBE_YES) {
-            return FALSE;  // ccc!=0
-        } else if(isDecompNoAlgorithmic(norm16)) {
-            c=mapAlgorithmic(c, norm16);
-        } else {
-            // c decomposes, get everything from the variable-length extra data
-            const uint16_t *mapping=getMapping(norm16);
-            uint16_t firstUnit=*mapping;
-            if((firstUnit&MAPPING_LENGTH_MASK)==0) {
-                return FALSE;
-            }
-            if(!before) {
-                // decomp after-boundary: same as hasFCDBoundaryAfter(),
-                // fcd16<=1 || trailCC==0
-                if(firstUnit>0x1ff) {
-                    return FALSE;  // trailCC>1
-                }
-                if(firstUnit<=0xff) {
-                    return TRUE;  // trailCC==0
-                }
-                // if(trailCC==1) test leadCC==0, same as checking for before-boundary
-            }
-            // TRUE if leadCC==0 (hasFCDBoundaryBefore())
-            return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (*(mapping-1)&0xff00)==0;
-        }
+UBool Normalizer2Impl::hasDecompBoundaryBefore(UChar32 c) const {
+    return c < minLcccCP || (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) ||
+        norm16HasDecompBoundaryBefore(getNorm16(c));
+}
+
+UBool Normalizer2Impl::norm16HasDecompBoundaryBefore(uint16_t norm16) const {
+    if (norm16 < minNoNoCompNoMaybeCC) {
+        return TRUE;
     }
+    if (norm16 >= limitNoNo) {
+        return norm16 <= MIN_NORMAL_MAYBE_YES || norm16 == JAMO_VT;
+    }
+    // c decomposes, get everything from the variable-length extra data
+    const uint16_t *mapping=getMapping(norm16);
+    uint16_t firstUnit=*mapping;
+    // TRUE if leadCC==0 (hasFCDBoundaryBefore())
+    return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (*(mapping-1)&0xff00)==0;
+}
+
+UBool Normalizer2Impl::hasDecompBoundaryAfter(UChar32 c) const {
+    if (c < minDecompNoCP) {
+        return TRUE;
+    }
+    if (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) {
+        return TRUE;
+    }
+    return norm16HasDecompBoundaryAfter(getNorm16(c));
+}
+
+UBool Normalizer2Impl::norm16HasDecompBoundaryAfter(uint16_t norm16) const {
+    if(norm16 <= minYesNo || isHangulLVT(norm16)) {
+        return TRUE;
+    }
+    if (norm16 >= limitNoNo) {
+        if (isMaybeOrNonZeroCC(norm16)) {
+            return norm16 <= MIN_NORMAL_MAYBE_YES || norm16 == JAMO_VT;
+        }
+        // Maps to an isCompYesAndZeroCC.
+        return (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1;
+    }
+    // c decomposes, get everything from the variable-length extra data
+    const uint16_t *mapping=getMapping(norm16);
+    uint16_t firstUnit=*mapping;
+    // decomp after-boundary: same as hasFCDBoundaryAfter(),
+    // fcd16<=1 || trailCC==0
+    if(firstUnit>0x1ff) {
+        return FALSE;  // trailCC>1
+    }
+    if(firstUnit<=0xff) {
+        return TRUE;  // trailCC==0
+    }
+    // if(trailCC==1) test leadCC==0, same as checking for before-boundary
+    // TRUE if leadCC==0 (hasFCDBoundaryBefore())
+    return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (*(mapping-1)&0xff00)==0;
 }
 
 /*
@@ -1310,6 +1347,7 @@ Normalizer2Impl::composePair(UChar32 a, UChar32 b) const {
     if(isInert(norm16)) {
         return U_SENTINEL;
     } else if(norm16<minYesNoMappingsOnly) {
+        // a combines forward.
         if(isJamoL(norm16)) {
             b-=Hangul::JAMO_V_BASE;
             if(0<=b && b<Hangul::JAMO_V_COUNT) {
@@ -1320,26 +1358,26 @@ Normalizer2Impl::composePair(UChar32 a, UChar32 b) const {
             } else {
                 return U_SENTINEL;
             }
-        } else if(isHangul(norm16)) {
+        } else if(isHangulLV(norm16)) {
             b-=Hangul::JAMO_T_BASE;
-            if(Hangul::isHangulWithoutJamoT(a) && 0<b && b<Hangul::JAMO_T_COUNT) {  // not b==0!
+            if(0<b && b<Hangul::JAMO_T_COUNT) {  // not b==0!
                 return a+b;
             } else {
                 return U_SENTINEL;
             }
         } else {
             // 'a' has a compositions list in extraData
-            list=extraData+norm16;
+            list=getMapping(norm16);
             if(norm16>minYesNo) {  // composite 'a' has both mapping & compositions list
                 list+=  // mapping pointer
-                    1+  // +1 to skip the first unit with the mapping lenth
+                    1+  // +1 to skip the first unit with the mapping length
                     (*list&MAPPING_LENGTH_MASK);  // + mapping length
             }
         }
     } else if(norm16<minMaybeYes || MIN_NORMAL_MAYBE_YES<=norm16) {
         return U_SENTINEL;
     } else {
-        list=maybeYesCompositions+norm16-minMaybeYes;
+        list=getCompositionsListForMaybe(norm16);
     }
     if(b<0 || 0x10ffff<b) {  // combine(list, b) requires a valid code point b
         return U_SENTINEL;
@@ -1361,18 +1399,6 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
                          UBool doCompose,
                          ReorderingBuffer &buffer,
                          UErrorCode &errorCode) const {
-    /*
-     * prevBoundary points to the last character before the current one
-     * that has a composition boundary before it with ccc==0 and quick check "yes".
-     * Keeping track of prevBoundary saves us looking for a composition boundary
-     * when we find a "no" or "maybe".
-     *
-     * When we back out from prevSrc back to prevBoundary,
-     * then we also remove those same characters (which had been simply copied
-     * or canonically-order-inserted) from the ReorderingBuffer.
-     * Therefore, at all times, the [prevBoundary..prevSrc[ source units
-     * must correspond 1:1 to destination units at the end of the destination buffer.
-     */
     const UChar *prevBoundary=src;
     UChar32 minNoMaybeCP=minCompNoMaybeCP;
     if(limit==NULL) {
@@ -1382,231 +1408,260 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
         if(U_FAILURE(errorCode)) {
             return FALSE;
         }
-        if(prevBoundary<src) {
-            // Set prevBoundary to the last character in the prefix.
-            prevBoundary=src-1;
-        }
         limit=u_strchr(src, 0);
+        if (prevBoundary != src) {
+            if (hasCompBoundaryAfter(*(src-1), onlyContiguous)) {
+                prevBoundary = src;
+            } else {
+                buffer.removeSuffix(1);
+                prevBoundary = --src;
+            }
+        }
     }
 
-    const UChar *prevSrc;
-    UChar32 c=0;
-    uint16_t norm16=0;
-
-    // only for isNormalized
-    uint8_t prevCC=0;
-
-    for(;;) {
-        // count code units below the minimum or with irrelevant data for the quick check
-        for(prevSrc=src; src!=limit;) {
+    for (;;) {
+        // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
+        // or with (compYes && ccc==0) properties.
+        const UChar *prevSrc;
+        UChar32 c = 0;
+        uint16_t norm16 = 0;
+        for (;;) {
+            if (src == limit) {
+                if (prevBoundary != limit && doCompose) {
+                    buffer.appendZeroCC(prevBoundary, limit, errorCode);
+                }
+                return TRUE;
+            }
             if( (c=*src)<minNoMaybeCP ||
                 isCompYesAndZeroCC(norm16=UTRIE2_GET16_FROM_U16_SINGLE_LEAD(normTrie, c))
             ) {
                 ++src;
-            } else if(!U16_IS_SURROGATE(c)) {
-                break;
             } else {
-                UChar c2;
-                if(U16_IS_SURROGATE_LEAD(c)) {
-                    if((src+1)!=limit && U16_IS_TRAIL(c2=src[1])) {
-                        c=U16_GET_SUPPLEMENTARY(c, c2);
-                    }
-                } else /* trail surrogate */ {
-                    if(prevSrc<src && U16_IS_LEAD(c2=*(src-1))) {
-                        --src;
-                        c=U16_GET_SUPPLEMENTARY(c2, c);
-                    }
-                }
-                if(isCompYesAndZeroCC(norm16=getNorm16(c))) {
-                    src+=U16_LENGTH(c);
+                prevSrc = src++;
+                if(!U16_IS_SURROGATE(c)) {
+                    break;
                 } else {
-                    break;
+                    UChar c2;
+                    if(U16_IS_SURROGATE_LEAD(c)) {
+                        if(src!=limit && U16_IS_TRAIL(c2=*src)) {
+                            ++src;
+                            c=U16_GET_SUPPLEMENTARY(c, c2);
+                        }
+                    } else /* trail surrogate */ {
+                        if(prevBoundary<prevSrc && U16_IS_LEAD(c2=*(prevSrc-1))) {
+                            --prevSrc;
+                            c=U16_GET_SUPPLEMENTARY(c2, c);
+                        }
+                    }
+                    if(!isCompYesAndZeroCC(norm16=getNorm16(c))) {
+                        break;
+                    }
                 }
             }
         }
-        // copy these code units all at once
-        if(src!=prevSrc) {
-            if(doCompose) {
-                if(!buffer.appendZeroCC(prevSrc, src, errorCode)) {
-                    break;
-                }
-            } else {
-                prevCC=0;
-            }
-            if(src==limit) {
-                break;
-            }
-            // Set prevBoundary to the last character in the quick check loop.
-            prevBoundary=src-1;
-            if( U16_IS_TRAIL(*prevBoundary) && prevSrc<prevBoundary &&
-                U16_IS_LEAD(*(prevBoundary-1))
-            ) {
-                --prevBoundary;
-            }
-            // The start of the current character (c).
-            prevSrc=src;
-        } else if(src==limit) {
-            break;
-        }
+        // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
+        // The current character is either a "noNo" (has a mapping)
+        // or a "maybeYes" (combines backward)
+        // or a "yesYes" with ccc!=0.
+        // It is not a Hangul syllable or Jamo L because those have "yes" properties.
 
-        src+=U16_LENGTH(c);
-        /*
-         * isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
-         * c is either a "noNo" (has a mapping) or a "maybeYes" (combines backward)
-         * or has ccc!=0.
-         * Check for Jamo V/T, then for regular characters.
-         * c is not a Hangul syllable or Jamo L because those have "yes" properties.
-         */
-        if(isJamoVT(norm16) && prevBoundary!=prevSrc) {
+        // Medium-fast path: Handle cases that do not require full decomposition and recomposition.
+        if (!isMaybeOrNonZeroCC(norm16)) {  // minNoNo <= norm16 < minMaybeYes
+            if (!doCompose) {
+                return FALSE;
+            }
+            // Fast path for mapping a character that is immediately surrounded by boundaries.
+            // In this case, we need not decompose around the current character.
+            if (isDecompNoAlgorithmic(norm16)) {
+                // Maps to a single isCompYesAndZeroCC character
+                // which also implies hasCompBoundaryBefore.
+                if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
+                        hasCompBoundaryBefore(src, limit)) {
+                    if (prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
+                        break;
+                    }
+                    if(!buffer.append(mapAlgorithmic(c, norm16), 0, errorCode)) {
+                        break;
+                    }
+                    prevBoundary = src;
+                    continue;
+                }
+            } else if (norm16 < minNoNoCompBoundaryBefore) {
+                // The mapping is comp-normalized which also implies hasCompBoundaryBefore.
+                if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
+                        hasCompBoundaryBefore(src, limit)) {
+                    if (prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
+                        break;
+                    }
+                    const UChar *mapping = reinterpret_cast<const UChar *>(getMapping(norm16));
+                    int32_t length = *mapping++ & MAPPING_LENGTH_MASK;
+                    if(!buffer.appendZeroCC(mapping, mapping + length, errorCode)) {
+                        break;
+                    }
+                    prevBoundary = src;
+                    continue;
+                }
+            } else if (norm16 >= minNoNoEmpty) {
+                // The current character maps to nothing.
+                // Simply omit it from the output if there is a boundary before _or_ after it.
+                // The character itself implies no boundaries.
+                if (hasCompBoundaryBefore(src, limit) ||
+                        hasCompBoundaryAfter(prevBoundary, prevSrc, onlyContiguous)) {
+                    if (prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
+                        break;
+                    }
+                    prevBoundary = src;
+                    continue;
+                }
+            }
+            // Other "noNo" type, or need to examine more text around this character:
+            // Fall through to the slow path.
+        } else if (isJamoVT(norm16) && prevBoundary != prevSrc) {
             UChar prev=*(prevSrc-1);
-            UBool needToDecompose=FALSE;
             if(c<Hangul::JAMO_T_BASE) {
-                // c is a Jamo Vowel, compose with previous Jamo L and following Jamo T.
-                prev=(UChar)(prev-Hangul::JAMO_L_BASE);
-                if(prev<Hangul::JAMO_L_COUNT) {
-                    if(!doCompose) {
+                // The current character is a Jamo Vowel,
+                // compose with previous Jamo L and following Jamo T.
+                UChar l = (UChar)(prev-Hangul::JAMO_L_BASE);
+                if(l<Hangul::JAMO_L_COUNT) {
+                    if (!doCompose) {
                         return FALSE;
                     }
-                    UChar syllable=(UChar)
-                        (Hangul::HANGUL_BASE+
-                         (prev*Hangul::JAMO_V_COUNT+(c-Hangul::JAMO_V_BASE))*
-                         Hangul::JAMO_T_COUNT);
-                    UChar t;
-                    if(src!=limit && (t=(UChar)(*src-Hangul::JAMO_T_BASE))<Hangul::JAMO_T_COUNT) {
+                    int32_t t;
+                    if (src != limit &&
+                            0 < (t = ((int32_t)*src - Hangul::JAMO_T_BASE)) &&
+                            t < Hangul::JAMO_T_COUNT) {
+                        // The next character is a Jamo T.
                         ++src;
-                        syllable+=t;  // The next character was a Jamo T.
-                        prevBoundary=src;
-                        buffer.setLastChar(syllable);
+                    } else if (hasCompBoundaryBefore(src, limit)) {
+                        // No Jamo T follows, not even via decomposition.
+                        t = 0;
+                    } else {
+                        t = -1;
+                    }
+                    if (t >= 0) {
+                        UChar32 syllable = Hangul::HANGUL_BASE +
+                            (l*Hangul::JAMO_V_COUNT + (c-Hangul::JAMO_V_BASE)) *
+                            Hangul::JAMO_T_COUNT + t;
+                        --prevSrc;  // Replace the Jamo L as well.
+                        if (prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
+                            break;
+                        }
+                        if(!buffer.appendBMP((UChar)syllable, 0, errorCode)) {
+                            break;
+                        }
+                        prevBoundary = src;
                         continue;
                     }
                     // If we see L+V+x where x!=T then we drop to the slow path,
                     // decompose and recompose.
                     // This is to deal with NFKC finding normal L and V but a
-                    // compatibility variant of a T. We need to either fully compose that
-                    // combination here (which would complicate the code and may not work
-                    // with strange custom data) or use the slow path -- or else our replacing
-                    // two input characters (L+V) with one output character (LV syllable)
-                    // would violate the invariant that [prevBoundary..prevSrc[ has the same
-                    // length as what we appended to the buffer since prevBoundary.
-                    needToDecompose=TRUE;
+                    // compatibility variant of a T.
+                    // We need to either fully compose that combination here
+                    // (which would complicate the code and may not work with strange custom data)
+                    // or use the slow path.
                 }
-            } else if(Hangul::isHangulWithoutJamoT(prev)) {
-                // c is a Jamo Trailing consonant,
+            } else if (Hangul::isHangulLV(prev)) {
+                // The current character is a Jamo Trailing consonant,
                 // compose with previous Hangul LV that does not contain a Jamo T.
-                if(!doCompose) {
+                if (!doCompose) {
                     return FALSE;
                 }
-                buffer.setLastChar((UChar)(prev+c-Hangul::JAMO_T_BASE));
-                prevBoundary=src;
-                continue;
-            }
-            if(!needToDecompose) {
-                // The Jamo V/T did not compose into a Hangul syllable.
-                if(doCompose) {
-                    if(!buffer.appendBMP((UChar)c, 0, errorCode)) {
-                        break;
-                    }
-                } else {
-                    prevCC=0;
-                }
-                continue;
-            }
-        }
-        /*
-         * Source buffer pointers:
-         *
-         *  all done      quick check   current char  not yet
-         *                "yes" but     (c)           processed
-         *                may combine
-         *                forward
-         * [-------------[-------------[-------------[-------------[
-         * |             |             |             |             |
-         * orig. src     prevBoundary  prevSrc       src           limit
-         *
-         *
-         * Destination buffer pointers inside the ReorderingBuffer:
-         *
-         *  all done      might take    not filled yet
-         *                characters for
-         *                reordering
-         * [-------------[-------------[-------------[
-         * |             |             |             |
-         * start         reorderStart  limit         |
-         *                             +remainingCap.+
-         */
-        if(norm16>=MIN_YES_YES_WITH_CC) {
-            uint8_t cc=(uint8_t)norm16;  // cc!=0
-            if( onlyContiguous &&  // FCC
-                (doCompose ? buffer.getLastCC() : prevCC)==0 &&
-                prevBoundary<prevSrc &&
-                // buffer.getLastCC()==0 && prevBoundary<prevSrc tell us that
-                // [prevBoundary..prevSrc[ (which is exactly one character under these conditions)
-                // passed the quick check "yes && ccc==0" test.
-                // Check whether the last character was a "yesYes" or a "yesNo".
-                // If a "yesNo", then we get its trailing ccc from its
-                // mapping and check for canonical order.
-                // All other cases are ok.
-                getTrailCCFromCompYesAndZeroCC(prevBoundary, prevSrc)>cc
-            ) {
-                // Fails FCD test, need to decompose and contiguously recompose.
-                if(!doCompose) {
-                    return FALSE;
-                }
-            } else if(doCompose) {
-                if(!buffer.append(c, cc, errorCode)) {
+                UChar32 syllable = prev + c - Hangul::JAMO_T_BASE;
+                --prevSrc;  // Replace the Hangul LV as well.
+                if (prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
                     break;
                 }
+                if(!buffer.appendBMP((UChar)syllable, 0, errorCode)) {
+                    break;
+                }
+                prevBoundary = src;
                 continue;
-            } else if(prevCC<=cc) {
-                prevCC=cc;
-                continue;
-            } else {
-                return FALSE;
             }
-        } else if(!doCompose && !isMaybeOrNonZeroCC(norm16)) {
-            return FALSE;
+            // No matching context, or may need to decompose surrounding text first:
+            // Fall through to the slow path.
+        } else if (norm16 > JAMO_VT) {  // norm16 >= MIN_YES_YES_WITH_CC
+            // One or more combining marks that do not combine-back:
+            // Check for canonical order, copy unchanged if ok and
+            // if followed by a character with a boundary-before.
+            uint8_t cc = getCCFromNormalYesOrMaybe(norm16);  // cc!=0
+            if (onlyContiguous /* FCC */ && getPreviousTrailCC(prevBoundary, prevSrc) > cc) {
+                // Fails FCD test, need to decompose and contiguously recompose.
+                if (!doCompose) {
+                    return FALSE;
+                }
+            } else {
+                // If !onlyContiguous (not FCC), then we ignore the tccc of
+                // the previous character which passed the quick check "yes && ccc==0" test.
+                const UChar *nextSrc;
+                uint16_t n16;
+                for (;;) {
+                    if (src == limit) {
+                        if (doCompose) {
+                            buffer.appendZeroCC(prevBoundary, limit, errorCode);
+                        }
+                        return TRUE;
+                    }
+                    uint8_t prevCC = cc;
+                    nextSrc = src;
+                    UTRIE2_U16_NEXT16(normTrie, nextSrc, limit, c, n16);
+                    if (n16 >= MIN_YES_YES_WITH_CC) {
+                        cc = getCCFromNormalYesOrMaybe(n16);
+                        if (prevCC > cc) {
+                            if (!doCompose) {
+                                return FALSE;
+                            }
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                    src = nextSrc;
+                }
+                // src is after the last in-order combining mark.
+                // If there is a boundary here, then we continue with no change.
+                if (norm16HasCompBoundaryBefore(n16)) {
+                    if (isCompYesAndZeroCC(n16)) {
+                        src = nextSrc;
+                    }
+                    continue;
+                }
+                // Use the slow path. There is no boundary in [prevSrc, src[.
+            }
         }
 
-        /*
-         * Find appropriate boundaries around this character,
-         * decompose the source text from between the boundaries,
-         * and recompose it.
-         *
-         * We may need to remove the last few characters from the ReorderingBuffer
-         * to account for source text that was copied or appended
-         * but needs to take part in the recomposition.
-         */
-
-        /*
-         * Find the last composition boundary in [prevBoundary..src[.
-         * It is either the decomposition of the current character (at prevSrc),
-         * or prevBoundary.
-         */
-        if(hasCompBoundaryBefore(c, norm16)) {
-            prevBoundary=prevSrc;
-        } else if(doCompose) {
-            buffer.removeSuffix((int32_t)(prevSrc-prevBoundary));
+        // Slow path: Find the nearest boundaries around the current character,
+        // decompose and recompose.
+        if (prevBoundary != prevSrc && !norm16HasCompBoundaryBefore(norm16)) {
+            const UChar *p = prevSrc;
+            UTRIE2_U16_PREV16(normTrie, prevBoundary, p, c, norm16);
+            if (!norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                prevSrc = p;
+            }
         }
-
-        // Find the next composition boundary in [src..limit[ -
-        // modifies src to point to the next starter.
-        src=(UChar *)findNextCompBoundary(src, limit);
-
-        // Decompose [prevBoundary..src[ into the buffer and then recompose that part of it.
-        int32_t recomposeStartIndex=buffer.length();
-        if(!decomposeShort(prevBoundary, src, buffer, errorCode)) {
+        if (doCompose && prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
             break;
         }
+        int32_t recomposeStartIndex=buffer.length();
+        // We know there is not a boundary here.
+        decomposeShort(prevSrc, src, FALSE /* !stopAtCompBoundary */, onlyContiguous,
+                       buffer, errorCode);
+        // Decompose until the next boundary.
+        src = decomposeShort(src, limit, TRUE /* stopAtCompBoundary */, onlyContiguous,
+                             buffer, errorCode);
+        if (U_FAILURE(errorCode)) {
+            break;
+        }
+        if ((src - prevSrc) > INT32_MAX) {  // guard before buffer.equals()
+            errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
+            return TRUE;
+        }
         recompose(buffer, recomposeStartIndex, onlyContiguous);
         if(!doCompose) {
-            if(!buffer.equals(prevBoundary, src)) {
+            if(!buffer.equals(prevSrc, src)) {
                 return FALSE;
             }
             buffer.remove();
-            prevCC=0;
         }
-
-        // Move to the next starter. We never need to look back before this point again.
         prevBoundary=src;
     }
     return TRUE;
@@ -1619,30 +1674,28 @@ const UChar *
 Normalizer2Impl::composeQuickCheck(const UChar *src, const UChar *limit,
                                    UBool onlyContiguous,
                                    UNormalizationCheckResult *pQCResult) const {
-    /*
-     * prevBoundary points to the last character before the current one
-     * that has a composition boundary before it with ccc==0 and quick check "yes".
-     */
     const UChar *prevBoundary=src;
     UChar32 minNoMaybeCP=minCompNoMaybeCP;
     if(limit==NULL) {
         UErrorCode errorCode=U_ZERO_ERROR;
         src=copyLowPrefixFromNulTerminated(src, minNoMaybeCP, NULL, errorCode);
-        if(prevBoundary<src) {
-            // Set prevBoundary to the last character in the prefix.
-            prevBoundary=src-1;
-        }
         limit=u_strchr(src, 0);
+        if (prevBoundary != src) {
+            if (hasCompBoundaryAfter(*(src-1), onlyContiguous)) {
+                prevBoundary = src;
+            } else {
+                prevBoundary = --src;
+            }
+        }
     }
 
-    const UChar *prevSrc;
-    UChar32 c=0;
-    uint16_t norm16=0;
-    uint8_t prevCC=0;
-
     for(;;) {
-        // count code units below the minimum or with irrelevant data for the quick check
-        for(prevSrc=src;;) {
+        // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
+        // or with (compYes && ccc==0) properties.
+        const UChar *prevSrc;
+        UChar32 c = 0;
+        uint16_t norm16 = 0;
+        for (;;) {
             if(src==limit) {
                 return src;
             }
@@ -1650,72 +1703,93 @@ Normalizer2Impl::composeQuickCheck(const UChar *src, const UChar *limit,
                 isCompYesAndZeroCC(norm16=UTRIE2_GET16_FROM_U16_SINGLE_LEAD(normTrie, c))
             ) {
                 ++src;
-            } else if(!U16_IS_SURROGATE(c)) {
-                break;
             } else {
-                UChar c2;
-                if(U16_IS_SURROGATE_LEAD(c)) {
-                    if((src+1)!=limit && U16_IS_TRAIL(c2=src[1])) {
-                        c=U16_GET_SUPPLEMENTARY(c, c2);
-                    }
-                } else /* trail surrogate */ {
-                    if(prevSrc<src && U16_IS_LEAD(c2=*(src-1))) {
-                        --src;
-                        c=U16_GET_SUPPLEMENTARY(c2, c);
-                    }
-                }
-                if(isCompYesAndZeroCC(norm16=getNorm16(c))) {
-                    src+=U16_LENGTH(c);
-                } else {
+                prevSrc = src++;
+                if(!U16_IS_SURROGATE(c)) {
                     break;
+                } else {
+                    UChar c2;
+                    if(U16_IS_SURROGATE_LEAD(c)) {
+                        if(src!=limit && U16_IS_TRAIL(c2=*src)) {
+                            ++src;
+                            c=U16_GET_SUPPLEMENTARY(c, c2);
+                        }
+                    } else /* trail surrogate */ {
+                        if(prevBoundary<prevSrc && U16_IS_LEAD(c2=*(prevSrc-1))) {
+                            --prevSrc;
+                            c=U16_GET_SUPPLEMENTARY(c2, c);
+                        }
+                    }
+                    if(!isCompYesAndZeroCC(norm16=getNorm16(c))) {
+                        break;
+                    }
                 }
             }
         }
-        if(src!=prevSrc) {
-            // Set prevBoundary to the last character in the quick check loop.
-            prevBoundary=src-1;
-            if( U16_IS_TRAIL(*prevBoundary) && prevSrc<prevBoundary &&
-                U16_IS_LEAD(*(prevBoundary-1))
-            ) {
-                --prevBoundary;
+        // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
+        // The current character is either a "noNo" (has a mapping)
+        // or a "maybeYes" (combines backward)
+        // or a "yesYes" with ccc!=0.
+        // It is not a Hangul syllable or Jamo L because those have "yes" properties.
+
+        uint16_t prevNorm16 = INERT;
+        if (prevBoundary != prevSrc) {
+            if (norm16HasCompBoundaryBefore(norm16)) {
+                prevBoundary = prevSrc;
+            } else {
+                const UChar *p = prevSrc;
+                uint16_t n16;
+                UTRIE2_U16_PREV16(normTrie, prevBoundary, p, c, n16);
+                if (norm16HasCompBoundaryAfter(n16, onlyContiguous)) {
+                    prevBoundary = prevSrc;
+                } else {
+                    prevBoundary = p;
+                    prevNorm16 = n16;
+                }
             }
-            prevCC=0;
-            // The start of the current character (c).
-            prevSrc=src;
         }
 
-        src+=U16_LENGTH(c);
-        /*
-         * isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
-         * c is either a "noNo" (has a mapping) or a "maybeYes" (combines backward)
-         * or has ccc!=0.
-         */
         if(isMaybeOrNonZeroCC(norm16)) {
             uint8_t cc=getCCFromYesOrMaybe(norm16);
-            if( onlyContiguous &&  // FCC
-                cc!=0 &&
-                prevCC==0 &&
-                prevBoundary<prevSrc &&
-                // prevCC==0 && prevBoundary<prevSrc tell us that
-                // [prevBoundary..prevSrc[ (which is exactly one character under these conditions)
-                // passed the quick check "yes && ccc==0" test.
-                // Check whether the last character was a "yesYes" or a "yesNo".
-                // If a "yesNo", then we get its trailing ccc from its
-                // mapping and check for canonical order.
-                // All other cases are ok.
-                getTrailCCFromCompYesAndZeroCC(prevBoundary, prevSrc)>cc
-            ) {
-                // Fails FCD test.
-            } else if(prevCC<=cc || cc==0) {
-                prevCC=cc;
-                if(norm16<MIN_YES_YES_WITH_CC) {
-                    if(pQCResult!=NULL) {
-                        *pQCResult=UNORM_MAYBE;
-                    } else {
-                        return prevBoundary;
+            if (onlyContiguous /* FCC */ && cc != 0 &&
+                    getTrailCCFromCompYesAndZeroCC(prevNorm16) > cc) {
+                // The [prevBoundary..prevSrc[ character
+                // passed the quick check "yes && ccc==0" test
+                // but is out of canonical order with the current combining mark.
+            } else {
+                // If !onlyContiguous (not FCC), then we ignore the tccc of
+                // the previous character which passed the quick check "yes && ccc==0" test.
+                const UChar *nextSrc;
+                for (;;) {
+                    if (norm16 < MIN_YES_YES_WITH_CC) {
+                        if (pQCResult != nullptr) {
+                            *pQCResult = UNORM_MAYBE;
+                        } else {
+                            return prevBoundary;
+                        }
                     }
+                    if (src == limit) {
+                        return src;
+                    }
+                    uint8_t prevCC = cc;
+                    nextSrc = src;
+                    UTRIE2_U16_NEXT16(normTrie, nextSrc, limit, c, norm16);
+                    if (isMaybeOrNonZeroCC(norm16)) {
+                        cc = getCCFromYesOrMaybe(norm16);
+                        if (!(prevCC <= cc || cc == 0)) {
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                    src = nextSrc;
+                }
+                // src is after the last in-order combining mark.
+                if (isCompYesAndZeroCC(norm16)) {
+                    prevBoundary = src;
+                    src = nextSrc;
+                    continue;
                 }
-                continue;
             }
         }
         if(pQCResult!=NULL) {
@@ -1732,10 +1806,10 @@ void Normalizer2Impl::composeAndAppend(const UChar *src, const UChar *limit,
                                        ReorderingBuffer &buffer,
                                        UErrorCode &errorCode) const {
     if(!buffer.isEmpty()) {
-        const UChar *firstStarterInSrc=findNextCompBoundary(src, limit);
+        const UChar *firstStarterInSrc=findNextCompBoundary(src, limit, onlyContiguous);
         if(src!=firstStarterInSrc) {
             const UChar *lastStarterInDest=findPreviousCompBoundary(buffer.getStart(),
-                                                                    buffer.getLimit());
+                                                                    buffer.getLimit(), onlyContiguous);
             int32_t destSuffixLength=(int32_t)(buffer.getLimit()-lastStarterInDest);
             UnicodeString middle(lastStarterInDest, destSuffixLength);
             buffer.removeSuffix(destSuffixLength);
@@ -1760,162 +1834,37 @@ void Normalizer2Impl::composeAndAppend(const UChar *src, const UChar *limit,
     }
 }
 
-namespace {
-
-const int32_t COMP_NO_CP = 0xfffffc00;  // U_SENTINEL << 10 (negative)
-const int32_t COMP_BOUNDARY_BEFORE = 0x200;
-const int32_t COMP_BOUNDARY_AFTER = 0x100;
-
-}  // namespace
-
-/**
- * Returns composition properties as an int with bit fields.
- * Bits 31..10: algorithmic-decomp cp if that is compYes, else U_SENTINEL
- * Bit       9: has boundary before
- * Bit       8: has boundary after
- * Bits   7..0: tccc if decompNo, else 0
- */
-int32_t
-Normalizer2Impl::getCompProps(const uint8_t *src, const uint8_t *limit,
-                              uint16_t norm16, UBool onlyContiguous) const {
-    UChar32 c = U_SENTINEL;
-    for (;;) {
-        if (isInert(norm16)) {
-            return (c << 10) | COMP_BOUNDARY_BEFORE | COMP_BOUNDARY_AFTER;
-        } else if (norm16 <= minYesNo) {
-            int32_t props = COMP_BOUNDARY_BEFORE;
-            // Hangul: norm16==minYesNo
-            // Hangul LVT has a boundary after it.
-            // Hangul LV and non-inert yesYes characters combine forward.
-            if (isHangul(norm16)) {
-                // Do not modify c so that we don't confuse the fast path
-                // for algorithmic decompositions surrounded by boundaries.
-                UChar syllable;
-                if (c >= 0) {
-                    syllable = (UChar)c;
-                } else {
-                    // One branch of codePointFromValidUTF8(src, limit).
-                    U_ASSERT((limit - src) == 3);
-                    syllable = (UChar)((*src<<12) | ((src[1]&0x3f)<<6) | (src[2]&0x3f));
-                }
-                if (!Hangul::isHangulWithoutJamoT(syllable)) {
-                    props |= COMP_BOUNDARY_AFTER;
-                }
-            }
-            return (c << 10) | props;
-        } else if (norm16 >= minMaybeYes) {
-            if (norm16 >= MIN_YES_YES_WITH_CC) {
-                return (c << 10);
-            } else {
-                // Do not return c>=0 for a compMaybe character.
-                return COMP_NO_CP;
-            }
-        } else if (isDecompNoAlgorithmic(norm16)) {
-            if (c < 0) {
-                c = codePointFromValidUTF8(src, limit);
-            }
-            c = mapAlgorithmic(c, norm16);
-            norm16 = getNorm16(c);
-        } else {
-            // c decomposes, get everything from the variable-length extra data.
-            const uint16_t *mapping = getMapping(norm16);
-            uint16_t firstUnit = *mapping;
-            int32_t props = firstUnit >> 8;  // tccc
-            if (norm16 < minNoNo) {
-                props |= (c << 10) | COMP_BOUNDARY_BEFORE;
-            } else {
-                // Do not return c>=0 for a compNo character.
-                props |= COMP_NO_CP;
-                if ((firstUnit & MAPPING_LENGTH_MASK) != 0 &&
-                        ((firstUnit & MAPPING_HAS_CCC_LCCC_WORD) == 0 ||
-                            (*(mapping-1) & 0xff00) == 0)) {
-                    // The decomposition is not empty, and lccc==0.
-                    int32_t i = 1;  // skip over the firstUnit
-                    UChar32 firstCP;
-                    U16_NEXT_UNSAFE(mapping, i, firstCP);
-                    if (isCompYesAndZeroCC(getNorm16(firstCP))) {
-                        props |= COMP_BOUNDARY_BEFORE;
-                    }
-                }
-            }
-            // comp-boundary-after if
-            //   not MAPPING_NO_COMP_BOUNDARY_AFTER
-            //     (which is set if
-            //       c is not deleted, and
-            //       it and its decomposition do not combine forward, and it has a starter)
-            //   and if FCC then trailCC<=1
-            if ((firstUnit & MAPPING_NO_COMP_BOUNDARY_AFTER) == 0 &&
-                    (!onlyContiguous || firstUnit <= 0x1ff)) {
-                props |= COMP_BOUNDARY_AFTER;
-            }
-            return props;
-        }
-    }
-}
-
 UBool
-Normalizer2Impl::composeUTF8(uint32_t options,
+Normalizer2Impl::composeUTF8(uint32_t options, UBool onlyContiguous,
                              const uint8_t *src, const uint8_t *limit,
-                             UBool onlyContiguous, UBool doCompose,
-                             ByteSink &sink, Edits *edits, UErrorCode &errorCode) const {
+                             ByteSink *sink, Edits *edits, UErrorCode &errorCode) const {
     U_ASSERT(limit != nullptr);
+    UnicodeString s16;
     uint8_t minNoMaybeLead = leadByteForCP(minCompNoMaybeCP);
+    const uint8_t *prevBoundary = src;
 
     for (;;) {
         // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
         // or with (compYes && ccc==0) properties.
-        const uint8_t *prevSrc = src;
-        const uint8_t *nextSrc;
+        const uint8_t *prevSrc;
         uint16_t norm16 = 0;
         for (;;) {
             if (src == limit) {
-                if (src != prevSrc && doCompose) {
-                    appendUnchanged(prevSrc, limit, sink, options, edits, errorCode);
+                if (prevBoundary != limit && sink != nullptr) {
+                    appendUnchanged(prevBoundary, limit, *sink, options, edits, errorCode);
                 }
                 return TRUE;
             }
             if (*src < minNoMaybeLead) {
                 ++src;
             } else {
-                nextSrc = src;
-                UTRIE2_U8_NEXT16(normTrie, nextSrc, limit, norm16);
-                if (isCompYesAndZeroCC(norm16)) {
-                    src = nextSrc;
-                } else {
+                prevSrc = src;
+                UTRIE2_U8_NEXT16(normTrie, src, limit, norm16);
+                if (!isCompYesAndZeroCC(norm16)) {
                     break;
                 }
             }
         }
-
-        // Copy this sequence.
-        // Omit the last character if there is not a boundary between it and the current one.
-        int32_t props = getCompProps(src, nextSrc, norm16, onlyContiguous);
-        int32_t prevProps = 0;
-        if (src != prevSrc) {
-            const uint8_t *p = src;
-            if ((props & COMP_BOUNDARY_BEFORE) == 0) {
-                uint16_t prevNorm16 = 0;
-                UTRIE2_U8_PREV16(normTrie, prevSrc, p, prevNorm16);
-                prevProps = getCompProps(p, src, prevNorm16, onlyContiguous);
-                if (prevProps & COMP_BOUNDARY_AFTER) {
-                    p = src;
-                }
-            }
-            if (p != prevSrc) {
-                if (doCompose) {
-                    if ((limit - prevSrc) <= INT32_MAX) {
-                        // Allocation hint for the full remaining string,
-                        // not just for what we are copying now.
-                        giveByteSinkAllocationHint(sink, (int32_t)(limit - prevSrc));
-                    }
-                    if (!appendUnchanged(prevSrc, p, sink, options, edits, errorCode)) {
-                        break;
-                    }
-                }
-                prevSrc = p;
-            }
-        }
-
         // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
         // The current character is either a "noNo" (has a mapping)
         // or a "maybeYes" (combines backward)
@@ -1924,47 +1873,93 @@ Normalizer2Impl::composeUTF8(uint32_t options,
 
         // Medium-fast path: Handle cases that do not require full decomposition and recomposition.
         if (!isMaybeOrNonZeroCC(norm16)) {  // minNoNo <= norm16 < minMaybeYes
-            if (!doCompose) {
+            if (sink == nullptr) {
                 return FALSE;
             }
             // Fast path for mapping a character that is immediately surrounded by boundaries.
-            // In this case, we need not decompose around the current character
-            // So far, we only do this for algorithmic mappings to a compYes code point;
-            // props>=0 only when this is the case.
-            // Algorithmic mappings are common when the normalization data includes case folding.
-            // If we knew that a full decomposition is composition-normalized
-            // (does not partially recompose),
-            // or if we had the recomposition directly available in the data,
-            // then we could extend this fastpath to such mappings.
-            if (props >= 0 &&  // alg. decomp to compYes
-                    prevSrc == src &&  // has boundary before
-                    ((props & COMP_BOUNDARY_AFTER) || hasCompBoundaryBefore(nextSrc, limit))) {
-                appendCodePoint(src, nextSrc, props >> 10, sink, edits);
-                src = nextSrc;
-                continue;
+            // In this case, we need not decompose around the current character.
+            if (isDecompNoAlgorithmic(norm16)) {
+                // Maps to a single isCompYesAndZeroCC character
+                // which also implies hasCompBoundaryBefore.
+                if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
+                        hasCompBoundaryBefore(src, limit)) {
+                    if (prevBoundary != prevSrc &&
+                            !appendUnchanged(prevBoundary, prevSrc, *sink, options, edits, errorCode)) {
+                        break;
+                    }
+                    appendCodePointDelta(prevSrc, src, getAlgorithmicDelta(norm16), *sink, edits);
+                    prevBoundary = src;
+                    continue;
+                }
+            } else if (norm16 < minNoNoCompBoundaryBefore) {
+                // The mapping is comp-normalized which also implies hasCompBoundaryBefore.
+                if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
+                        hasCompBoundaryBefore(src, limit)) {
+                    if (prevBoundary != prevSrc &&
+                            !appendUnchanged(prevBoundary, prevSrc, *sink, options, edits, errorCode)) {
+                        break;
+                    }
+                    const uint16_t *mapping = getMapping(norm16);
+                    int32_t length = *mapping++ & MAPPING_LENGTH_MASK;
+                    if (!appendChange(prevSrc, src, (const UChar *)mapping, length,
+                                      *sink, edits, errorCode)) {
+                        break;
+                    }
+                    prevBoundary = src;
+                    continue;
+                }
+            } else if (norm16 >= minNoNoEmpty) {
+                // The current character maps to nothing.
+                // Simply omit it from the output if there is a boundary before _or_ after it.
+                // The character itself implies no boundaries.
+                if (hasCompBoundaryBefore(src, limit) ||
+                        hasCompBoundaryAfter(prevBoundary, prevSrc, onlyContiguous)) {
+                    if (prevBoundary != prevSrc &&
+                            !appendUnchanged(prevBoundary, prevSrc, *sink, options, edits, errorCode)) {
+                        break;
+                    }
+                    if (edits != nullptr) {
+                        edits->addReplace((int32_t)(src - prevSrc), 0);
+                    }
+                    prevBoundary = src;
+                    continue;
+                }
             }
-        } else if (isJamoVT(norm16) && prevSrc != src) {
+            // Other "noNo" type, or need to examine more text around this character:
+            // Fall through to the slow path.
+        } else if (isJamoVT(norm16)) {
             // Jamo L: E1 84 80..92
             // Jamo V: E1 85 A1..B5
             // Jamo T: E1 86 A8..E1 87 82
-            U_ASSERT((nextSrc - src) == 3 && *src == 0xe1);
-            UChar32 prev;
-            if (src[1] == 0x85) {
+            U_ASSERT((src - prevSrc) == 3 && *prevSrc == 0xe1);
+            UChar32 prev = previousHangulOrJamo(prevBoundary, prevSrc);
+            if (prevSrc[1] == 0x85) {
                 // The current character is a Jamo Vowel,
                 // compose with previous Jamo L and following Jamo T.
-                if ((prev = getJamoLMinusBase(prevSrc, src)) >= 0) {
-                    if (!doCompose) {
+                UChar32 l = prev - Hangul::JAMO_L_BASE;
+                if ((uint32_t)l < Hangul::JAMO_L_COUNT) {
+                    if (sink == nullptr) {
                         return FALSE;
                     }
-                    UChar32 syllable = Hangul::HANGUL_BASE +
-                         (prev*Hangul::JAMO_V_COUNT + (src[2]-0xa1)) *
-                         Hangul::JAMO_T_COUNT;
-                    int32_t t = getJamoTMinusBase(nextSrc, limit);
+                    int32_t t = getJamoTMinusBase(src, limit);
                     if (t >= 0) {
-                        nextSrc += 3;
-                        syllable += t;  // The next character was a Jamo T.
-                        appendCodePoint(prevSrc, nextSrc, syllable, sink, edits);
-                        src = nextSrc;
+                        // The next character is a Jamo T.
+                        src += 3;
+                    } else if (hasCompBoundaryBefore(src, limit)) {
+                        // No Jamo T follows, not even via decomposition.
+                        t = 0;
+                    }
+                    if (t >= 0) {
+                        UChar32 syllable = Hangul::HANGUL_BASE +
+                            (l*Hangul::JAMO_V_COUNT + (prevSrc[2]-0xa1)) *
+                            Hangul::JAMO_T_COUNT + t;
+                        prevSrc -= 3;  // Replace the Jamo L as well.
+                        if (prevBoundary != prevSrc &&
+                                !appendUnchanged(prevBoundary, prevSrc, *sink, options, edits, errorCode)) {
+                            break;
+                        }
+                        appendCodePoint(prevSrc, src, syllable, *sink, edits);
+                        prevBoundary = src;
                         continue;
                     }
                     // If we see L+V+x where x!=T then we drop to the slow path,
@@ -1975,47 +1970,53 @@ Normalizer2Impl::composeUTF8(uint32_t options,
                     // (which would complicate the code and may not work with strange custom data)
                     // or use the slow path.
                 }
-            } else if (Hangul::isHangulWithoutJamoT(prev = codePointFromValidUTF8(prevSrc, src))) {
+            } else if (Hangul::isHangulLV(prev)) {
                 // The current character is a Jamo Trailing consonant,
                 // compose with previous Hangul LV that does not contain a Jamo T.
-                if (!doCompose) {
+                if (sink == nullptr) {
                     return FALSE;
                 }
-                UChar32 syllable = prev + getJamoTMinusBase(src, nextSrc);
-                appendCodePoint(prevSrc, nextSrc, syllable, sink, edits);
-                src = nextSrc;
+                UChar32 syllable = prev + getJamoTMinusBase(prevSrc, src);
+                prevSrc -= 3;  // Replace the Hangul LV as well.
+                if (prevBoundary != prevSrc &&
+                        !appendUnchanged(prevBoundary, prevSrc, *sink, options, edits, errorCode)) {
+                    break;
+                }
+                appendCodePoint(prevSrc, src, syllable, *sink, edits);
+                prevBoundary = src;
                 continue;
             }
+            // No matching context, or may need to decompose surrounding text first:
+            // Fall through to the slow path.
         } else if (norm16 > JAMO_VT) {  // norm16 >= MIN_YES_YES_WITH_CC
             // One or more combining marks that do not combine-back:
             // Check for canonical order, copy unchanged if ok and
             // if followed by a character with a boundary-before.
-            uint8_t cc = (uint8_t)norm16;  // cc!=0
-            if (onlyContiguous /* FCC */ && (uint8_t)prevProps > cc) {
+            uint8_t cc = getCCFromNormalYesOrMaybe(norm16);  // cc!=0
+            if (onlyContiguous /* FCC */ && getPreviousTrailCC(prevBoundary, prevSrc) > cc) {
                 // Fails FCD test, need to decompose and contiguously recompose.
-                if (!doCompose) {
+                if (sink == nullptr) {
                     return FALSE;
                 }
             } else {
                 // If !onlyContiguous (not FCC), then we ignore the tccc of
                 // the previous character which passed the quick check "yes && ccc==0" test.
-                const uint8_t *p = nextSrc;
-                const uint8_t *q;
+                const uint8_t *nextSrc;
                 uint16_t n16;
                 for (;;) {
-                    if (p == limit) {
-                        if (doCompose) {
-                            appendUnchanged(prevSrc, limit, sink, options, edits, errorCode);
+                    if (src == limit) {
+                        if (sink != nullptr) {
+                            appendUnchanged(prevBoundary, limit, *sink, options, edits, errorCode);
                         }
                         return TRUE;
                     }
                     uint8_t prevCC = cc;
-                    q = p;
-                    UTRIE2_U8_NEXT16(normTrie, q, limit, n16);
+                    nextSrc = src;
+                    UTRIE2_U8_NEXT16(normTrie, nextSrc, limit, n16);
                     if (n16 >= MIN_YES_YES_WITH_CC) {
-                        cc = (uint8_t)n16;
+                        cc = getCCFromNormalYesOrMaybe(n16);
                         if (prevCC > cc) {
-                            if (!doCompose) {
+                            if (sink == nullptr) {
                                 return FALSE;
                             }
                             break;
@@ -2023,165 +2024,151 @@ Normalizer2Impl::composeUTF8(uint32_t options,
                     } else {
                         break;
                     }
-                    p = q;
+                    src = nextSrc;
                 }
-                // p is after the last in-order combining mark.
-                // If there is a boundary here, then we copy and continue.
-                // Copy some of hasCompBoundaryBefore() to postpone decoding the code point.
-                if (isCompYesAndZeroCC(n16) ||
-                        (!isMaybeOrNonZeroCC(n16) &&
-                            hasCompBoundaryBefore(codePointFromValidUTF8(p, q), n16))) {
-                    if (doCompose && !appendUnchanged(prevSrc, p, sink, options, edits, errorCode)) {
-                        return TRUE;
+                // src is after the last in-order combining mark.
+                // If there is a boundary here, then we continue with no change.
+                if (norm16HasCompBoundaryBefore(n16)) {
+                    if (isCompYesAndZeroCC(n16)) {
+                        src = nextSrc;
                     }
-                    src = p;
                     continue;
                 }
-                // Use the slow path. There is no boundary in [nextSrc, p[.
-                nextSrc = p;
+                // Use the slow path. There is no boundary in [prevSrc, src[.
             }
         }
 
         // Slow path: Find the nearest boundaries around the current character,
         // decompose and recompose.
-        // TODO: Inefficient create&destroy of the buffer because
-        // we want to avoid creating one if we do not need it.
-        // Try to make it cheaper, try to use a plain char16_t[] on the stack
-        // until it overflows.
-        // TODO: Port this newer code with Edits support,
-        // and maybe with Appendable style if it does not noticeably hurt UnicodeString performance,
-        // back to UTF-16.
-        // Should be able to remove some then-unnecessary code from ReorderingBuffer.
-        // Might not need findNextCompBoundary() and such any more.
-        UnicodeString s16;
-        ReorderingBuffer buffer(*this, s16);
-        // Decompose the previous (if any) and current characters.
-        // We know there is not a boundary here.
-        decomposeShort(prevSrc, nextSrc, FALSE /* !stopAtCompBoundary */, buffer, errorCode);
-        // Decompose until the next boundary.
-        src = decomposeShort(nextSrc, limit, TRUE /* stopAtCompBoundary */, buffer, errorCode);
-        if (src == nullptr) {  // U_FAILURE
+        if (prevBoundary != prevSrc && !norm16HasCompBoundaryBefore(norm16)) {
+            const uint8_t *p = prevSrc;
+            UTRIE2_U8_PREV16(normTrie, prevBoundary, p, norm16);
+            if (!norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                prevSrc = p;
+            }
+        }
+        ReorderingBuffer buffer(*this, s16, errorCode);
+        if (U_FAILURE(errorCode)) {
             break;
         }
-        if ((src - prevSrc) > INT32_MAX) {
+        // We know there is not a boundary here.
+        decomposeShort(prevSrc, src, FALSE /* !stopAtCompBoundary */, onlyContiguous,
+                       buffer, errorCode);
+        // Decompose until the next boundary.
+        src = decomposeShort(src, limit, TRUE /* stopAtCompBoundary */, onlyContiguous,
+                             buffer, errorCode);
+        if (U_FAILURE(errorCode)) {
+            break;
+        }
+        if ((src - prevSrc) > INT32_MAX) {  // guard before buffer.equals()
             errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
             return TRUE;
         }
         recompose(buffer, 0, onlyContiguous);
-        if (buffer.equals(prevSrc, src)) {
-            if (doCompose && !appendUnchanged(prevSrc, src, sink, options, edits, errorCode)) {
+        if (!buffer.equals(prevSrc, src)) {
+            if (sink == nullptr) {
+                return FALSE;
+            }
+            if (prevBoundary != prevSrc &&
+                    !appendUnchanged(prevBoundary, prevSrc, *sink, options, edits, errorCode)) {
                 break;
             }
-        } else if (doCompose) {
             if (!appendChange(prevSrc, src, buffer.getStart(), buffer.length(),
-                              sink, edits, errorCode)) {
+                              *sink, edits, errorCode)) {
                 break;
             }
-        } else {
-            return TRUE;
+            prevBoundary = src;
         }
     }
     return TRUE;
 }
 
-/**
- * Does c have a composition boundary before it?
- * True if its decomposition begins with a character that has
- * ccc=0 && NFC_QC=Yes (isCompYesAndZeroCC()).
- * As a shortcut, this is true if c itself has ccc=0 && NFC_QC=Yes
- * (isCompYesAndZeroCC()) so we need not decompose.
- */
-UBool Normalizer2Impl::hasCompBoundaryBefore(UChar32 c, uint16_t norm16) const {
-    for(;;) {
-        if(isCompYesAndZeroCC(norm16)) {
-            return TRUE;
-        } else if(isMaybeOrNonZeroCC(norm16)) {
-            return FALSE;
-        } else if(isDecompNoAlgorithmic(norm16)) {
-            c=mapAlgorithmic(c, norm16);
-            norm16=getNorm16(c);
-        } else {
-            // c decomposes, get everything from the variable-length extra data
-            const uint16_t *mapping=getMapping(norm16);
-            uint16_t firstUnit=*mapping;
-            if((firstUnit&MAPPING_LENGTH_MASK)==0) {
-                return FALSE;
-            }
-            if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD) && (*(mapping-1)&0xff00)) {
-                return FALSE;  // non-zero leadCC
-            }
-            int32_t i=1;  // skip over the firstUnit
-            UChar32 c;
-            U16_NEXT_UNSAFE(mapping, i, c);
-            return isCompYesAndZeroCC(getNorm16(c));
-        }
-    }
-}
-
-UBool Normalizer2Impl::hasCompBoundaryAfter(UChar32 c, UBool onlyContiguous, UBool testInert) const {
-    for(;;) {
-        uint16_t norm16=getNorm16(c);
-        if(isInert(norm16)) {
-            return TRUE;
-        } else if(norm16<minYesNoMappingsOnly) {
-            // Hangul: norm16==minYesNo
-            // Hangul LVT has a boundary after it.
-            // Hangul LV and non-inert yesYes characters combine forward.
-            return isHangul(norm16) && !Hangul::isHangulWithoutJamoT((UChar)c);
-        } else if(norm16>= (testInert ? minNoNo : minMaybeYes)) {
-            return FALSE;
-        } else if(isDecompNoAlgorithmic(norm16)) {
-            c=mapAlgorithmic(c, norm16);
-        } else {
-            // c decomposes, get everything from the variable-length extra data.
-            // If testInert, then c must be a yesNo character which has lccc=0,
-            // otherwise it could be a noNo.
-            const uint16_t *mapping=getMapping(norm16);
-            uint16_t firstUnit=*mapping;
-            // TRUE if
-            //   not MAPPING_NO_COMP_BOUNDARY_AFTER
-            //     (which is set if
-            //       c is not deleted, and
-            //       it and its decomposition do not combine forward, and it has a starter)
-            //   and if FCC then trailCC<=1
-            return
-                (firstUnit&MAPPING_NO_COMP_BOUNDARY_AFTER)==0 &&
-                (!onlyContiguous || firstUnit<=0x1ff);
-        }
+UBool Normalizer2Impl::hasCompBoundaryBefore(const UChar *src, const UChar *limit) const {
+    if (src == limit || *src < minCompNoMaybeCP) {
+        return TRUE;
     }
+    UChar32 c;
+    uint16_t norm16;
+    UTRIE2_U16_NEXT16(normTrie, src, limit, c, norm16);
+    return norm16HasCompBoundaryBefore(norm16);
 }
 
 UBool Normalizer2Impl::hasCompBoundaryBefore(const uint8_t *src, const uint8_t *limit) const {
     if (src == limit) {
-        return FALSE;
+        return TRUE;
     }
-    const uint8_t *q = src;
     uint16_t norm16;
-    UTRIE2_U8_NEXT16(normTrie, q, limit, norm16);
-    // Copy some of hasCompBoundaryBefore() to postpone decoding the code point.
-    return isCompYesAndZeroCC(norm16) ||
-        (!isMaybeOrNonZeroCC(norm16) &&
-            hasCompBoundaryBefore(codePointFromValidUTF8(src, q), norm16));
+    UTRIE2_U8_NEXT16(normTrie, src, limit, norm16);
+    return norm16HasCompBoundaryBefore(norm16);
 }
 
-const UChar *Normalizer2Impl::findPreviousCompBoundary(const UChar *start, const UChar *p) const {
+UBool Normalizer2Impl::hasCompBoundaryAfter(const UChar *start, const UChar *p,
+                                            UBool onlyContiguous) const {
+    if (start == p) {
+        return TRUE;
+    }
+    UChar32 c;
+    uint16_t norm16;
+    UTRIE2_U16_PREV16(normTrie, start, p, c, norm16);
+    return norm16HasCompBoundaryAfter(norm16, onlyContiguous);
+}
+
+UBool Normalizer2Impl::hasCompBoundaryAfter(const uint8_t *start, const uint8_t *p,
+                                            UBool onlyContiguous) const {
+    if (start == p) {
+        return TRUE;
+    }
+    uint16_t norm16;
+    UTRIE2_U8_PREV16(normTrie, start, p, norm16);
+    return norm16HasCompBoundaryAfter(norm16, onlyContiguous);
+}
+
+const UChar *Normalizer2Impl::findPreviousCompBoundary(const UChar *start, const UChar *p,
+                                                       UBool onlyContiguous) const {
     BackwardUTrie2StringIterator iter(normTrie, start, p);
-    uint16_t norm16;
-    do {
-        norm16=iter.previous16();
-    } while(!hasCompBoundaryBefore(iter.codePoint, norm16));
-    // We could also test hasCompBoundaryAfter() and return iter.codePointLimit,
-    // but that's probably not worth the extra cost.
-    return iter.codePointStart;
+    for(;;) {
+        uint16_t norm16=iter.previous16();
+        if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+            return iter.codePointLimit;
+        }
+        if (hasCompBoundaryBefore(iter.codePoint, norm16)) {
+            return iter.codePointStart;
+        }
+    }
 }
 
-const UChar *Normalizer2Impl::findNextCompBoundary(const UChar *p, const UChar *limit) const {
+const UChar *Normalizer2Impl::findNextCompBoundary(const UChar *p, const UChar *limit,
+                                                   UBool onlyContiguous) const {
     ForwardUTrie2StringIterator iter(normTrie, p, limit);
-    uint16_t norm16;
-    do {
-        norm16=iter.next16();
-    } while(!hasCompBoundaryBefore(iter.codePoint, norm16));
-    return iter.codePointStart;
+    for(;;) {
+        uint16_t norm16=iter.next16();
+        if (hasCompBoundaryBefore(iter.codePoint, norm16)) {
+            return iter.codePointStart;
+        }
+        if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+            return iter.codePointLimit;
+        }
+    }
+}
+
+uint8_t Normalizer2Impl::getPreviousTrailCC(const UChar *start, const UChar *p) const {
+    if (start == p) {
+        return 0;
+    }
+    int32_t i = (int32_t)(p - start);
+    UChar32 c;
+    U16_PREV(start, 0, i, c);
+    return (uint8_t)getFCD16(c);
+}
+
+uint8_t Normalizer2Impl::getPreviousTrailCC(const uint8_t *start, const uint8_t *p) const {
+    if (start == p) {
+        return 0;
+    }
+    int32_t i = (int32_t)(p - start);
+    UChar32 c;
+    U8_PREV(start, 0, i, c);
+    return (uint8_t)getFCD16(c);
 }
 
 // Note: normalizer2impl.cpp r30982 (2011-nov-27)
@@ -2189,43 +2176,41 @@ const UChar *Normalizer2Impl::findNextCompBoundary(const UChar *p, const UChar *
 // That provided faster access to FCD data than getFCD16FromNormData()
 // but required synchronization and consumed some 10kB of heap memory
 // in any process that uses FCD (e.g., via collation).
-// tccc180[] and smallFCD[] are intended to help with any loss of performance,
-// at least for Latin & CJK.
+// minDecompNoCP etc. and smallFCD[] are intended to help with any loss of performance,
+// at least for ASCII & CJK.
 
 // Gets the FCD value from the regular normalization data.
 uint16_t Normalizer2Impl::getFCD16FromNormData(UChar32 c) const {
-    // Only loops for 1:1 algorithmic mappings.
-    for(;;) {
-        uint16_t norm16=getNorm16(c);
-        if(norm16<=minYesNo) {
-            // no decomposition or Hangul syllable, all zeros
-            return 0;
-        } else if(norm16>=MIN_NORMAL_MAYBE_YES) {
+    uint16_t norm16=getNorm16(c);
+    if (norm16 >= limitNoNo) {
+        if(norm16>=MIN_NORMAL_MAYBE_YES) {
             // combining mark
-            norm16&=0xff;
+            norm16=getCCFromNormalYesOrMaybe(norm16);
             return norm16|(norm16<<8);
         } else if(norm16>=minMaybeYes) {
             return 0;
-        } else if(isDecompNoAlgorithmic(norm16)) {
-            c=mapAlgorithmic(c, norm16);
-        } else {
-            // c decomposes, get everything from the variable-length extra data
-            const uint16_t *mapping=getMapping(norm16);
-            uint16_t firstUnit=*mapping;
-            if((firstUnit&MAPPING_LENGTH_MASK)==0) {
-                // A character that is deleted (maps to an empty string) must
-                // get the worst-case lccc and tccc values because arbitrary
-                // characters on both sides will become adjacent.
-                return 0x1ff;
-            } else {
-                norm16=firstUnit>>8;  // tccc
-                if(firstUnit&MAPPING_HAS_CCC_LCCC_WORD) {
-                    norm16|=*(mapping-1)&0xff00;  // lccc
-                }
-                return norm16;
+        } else {  // isDecompNoAlgorithmic(norm16)
+            uint16_t deltaTrailCC = norm16 & DELTA_TCCC_MASK;
+            if (deltaTrailCC <= DELTA_TCCC_1) {
+                return deltaTrailCC >> OFFSET_SHIFT;
             }
+            // Maps to an isCompYesAndZeroCC.
+            c=mapAlgorithmic(c, norm16);
+            norm16=getNorm16(c);
         }
     }
+    if(norm16<=minYesNo || isHangulLVT(norm16)) {
+        // no decomposition or Hangul syllable, all zeros
+        return 0;
+    }
+    // c decomposes, get everything from the variable-length extra data
+    const uint16_t *mapping=getMapping(norm16);
+    uint16_t firstUnit=*mapping;
+    norm16=firstUnit>>8;  // tccc
+    if(firstUnit&MAPPING_HAS_CCC_LCCC_WORD) {
+        norm16|=*(mapping-1)&0xff00;  // lccc
+    }
+    return norm16;
 }
 
 // Dual functionality:
@@ -2240,7 +2225,7 @@ Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
     const UChar *prevBoundary=src;
     int32_t prevFCD16=0;
     if(limit==NULL) {
-        src=copyLowPrefixFromNulTerminated(src, MIN_CCC_LCCC_CP, buffer, errorCode);
+        src=copyLowPrefixFromNulTerminated(src, minLcccCP, buffer, errorCode);
         if(U_FAILURE(errorCode)) {
             return src;
         }
@@ -2269,7 +2254,7 @@ Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
     for(;;) {
         // count code units with lccc==0
         for(prevSrc=src; src!=limit;) {
-            if((c=*src)<MIN_CCC_LCCC_CP) {
+            if((c=*src)<minLcccCP) {
                 prevFCD16=~c;
                 ++src;
             } else if(!singleLeadMightHaveNonZeroFCD16(c)) {
@@ -2308,11 +2293,15 @@ Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
             prevBoundary=src;
             // We know that the previous character's lccc==0.
             if(prevFCD16<0) {
-                // Fetching the fcd16 value was deferred for this below-U+0300 code point.
+                // Fetching the fcd16 value was deferred for this below-minLcccCP code point.
                 UChar32 prev=~prevFCD16;
-                prevFCD16= prev<0x180 ? tccc180[prev] : getFCD16FromNormData(prev);
-                if(prevFCD16>1) {
-                    --prevBoundary;
+                if(prev<minDecompNoCP) {
+                    prevFCD16=0;
+                } else {
+                    prevFCD16=getFCD16FromNormData(prev);
+                    if(prevFCD16>1) {
+                        --prevBoundary;
+                    }
                 }
             } else {
                 const UChar *p=src-1;
@@ -2364,7 +2353,8 @@ Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
              * The source text does not fulfill the conditions for FCD.
              * Decompose and reorder a limited piece of the text.
              */
-            if(!decomposeShort(prevBoundary, src, *buffer, errorCode)) {
+            decomposeShort(prevBoundary, src, FALSE, FALSE, *buffer, errorCode);
+            if (U_FAILURE(errorCode)) {
                 break;
             }
             prevBoundary=src;
@@ -2408,16 +2398,33 @@ void Normalizer2Impl::makeFCDAndAppend(const UChar *src, const UChar *limit,
 }
 
 const UChar *Normalizer2Impl::findPreviousFCDBoundary(const UChar *start, const UChar *p) const {
-    while(start<p && previousFCD16(start, p)>0xff) {}
+    while(start<p) {
+        const UChar *codePointLimit = p;
+        UChar32 c;
+        uint16_t norm16;
+        UTRIE2_U16_PREV16(normTrie, start, p, c, norm16);
+        if (c < minDecompNoCP || norm16HasDecompBoundaryAfter(norm16)) {
+            return codePointLimit;
+        }
+        if (norm16HasDecompBoundaryBefore(norm16)) {
+            return p;
+        }
+    }
     return p;
 }
 
 const UChar *Normalizer2Impl::findNextFCDBoundary(const UChar *p, const UChar *limit) const {
     while(p<limit) {
         const UChar *codePointStart=p;
-        if(nextFCD16(p, limit)<=0xff) {
+        UChar32 c;
+        uint16_t norm16;
+        UTRIE2_U16_NEXT16(normTrie, p, limit, c, norm16);
+        if (c < minLcccCP || norm16HasDecompBoundaryBefore(norm16)) {
             return codePointStart;
         }
+        if (norm16HasDecompBoundaryAfter(norm16)) {
+            return p;
+        }
     }
     return p;
 }
@@ -2461,34 +2468,43 @@ void CanonIterData::addToStartSet(UChar32 origin, UChar32 decompLead, UErrorCode
     }
 }
 
+// C++ class for friend access to private Normalizer2Impl members.
+class InitCanonIterData {
+public:
+    static void doInit(Normalizer2Impl *impl, UErrorCode &errorCode);
+    static void handleRange(Normalizer2Impl *impl, UChar32 start, UChar32 end, uint16_t value, UErrorCode &errorCode);
+};
+
 U_CDECL_BEGIN
 
+// UInitOnce instantiation function for CanonIterData
+static void U_CALLCONV
+initCanonIterData(Normalizer2Impl *impl, UErrorCode &errorCode) {
+    InitCanonIterData::doInit(impl, errorCode);
+}
+
 // Call Normalizer2Impl::makeCanonIterDataFromNorm16() for a range of same-norm16 characters.
 //     context: the Normalizer2Impl
 static UBool U_CALLCONV
 enumCIDRangeHandler(const void *context, UChar32 start, UChar32 end, uint32_t value) {
     UErrorCode errorCode = U_ZERO_ERROR;
-    if (value != 0) {
+    if (value != Normalizer2Impl::INERT) {
         Normalizer2Impl *impl = (Normalizer2Impl *)context;
-        impl->makeCanonIterDataFromNorm16(
-            start, end, (uint16_t)value, *impl->fCanonIterData, errorCode);
+        InitCanonIterData::handleRange(impl, start, end, (uint16_t)value, errorCode);
     }
     return U_SUCCESS(errorCode);
 }
 
+U_CDECL_END
 
-
-// UInitOnce instantiation function for CanonIterData
-
-static void U_CALLCONV 
-initCanonIterData(Normalizer2Impl *impl, UErrorCode &errorCode) {
+void InitCanonIterData::doInit(Normalizer2Impl *impl, UErrorCode &errorCode) {
     U_ASSERT(impl->fCanonIterData == NULL);
     impl->fCanonIterData = new CanonIterData(errorCode);
     if (impl->fCanonIterData == NULL) {
         errorCode=U_MEMORY_ALLOCATION_ERROR;
     }
     if (U_SUCCESS(errorCode)) {
-        utrie2_enum(impl->getNormTrie(), NULL, enumCIDRangeHandler, impl);
+        utrie2_enum(impl->normTrie, NULL, enumCIDRangeHandler, impl);
         utrie2_freeze(impl->fCanonIterData->trie, UTRIE2_32_VALUE_BITS, &errorCode);
     }
     if (U_FAILURE(errorCode)) {
@@ -2497,12 +2513,15 @@ initCanonIterData(Normalizer2Impl *impl, UErrorCode &errorCode) {
     }
 }
 
-U_CDECL_END
+void InitCanonIterData::handleRange(
+        Normalizer2Impl *impl, UChar32 start, UChar32 end, uint16_t value, UErrorCode &errorCode) {
+    impl->makeCanonIterDataFromNorm16(start, end, value, *impl->fCanonIterData, errorCode);
+}
 
-void Normalizer2Impl::makeCanonIterDataFromNorm16(UChar32 start, UChar32 end, uint16_t norm16,
+void Normalizer2Impl::makeCanonIterDataFromNorm16(UChar32 start, UChar32 end, const uint16_t norm16,
                                                   CanonIterData &newData,
                                                   UErrorCode &errorCode) const {
-    if(norm16==0 || (minYesNo<=norm16 && norm16<minNoNo)) {
+    if(isInert(norm16) || (minYesNo<=norm16 && norm16<minNoNo)) {
         // Inert, or 2-way mapping (including Hangul syllable).
         // We do not write a canonStartSet for any yesNo character.
         // Composites from 2-way mappings are added at runtime from the
@@ -2514,7 +2533,7 @@ void Normalizer2Impl::makeCanonIterDataFromNorm16(UChar32 start, UChar32 end, ui
     for(UChar32 c=start; c<=end; ++c) {
         uint32_t oldValue=utrie2_get32(newData.trie, c);
         uint32_t newValue=oldValue;
-        if(norm16>=minMaybeYes) {
+        if(isMaybeOrNonZeroCC(norm16)) {
             // not a segment starter if it occurs in a decomposition or has cc!=0
             newValue|=CANON_NOT_SEGMENT_STARTER;
             if(norm16<MIN_NORMAL_MAYBE_YES) {
@@ -2525,12 +2544,16 @@ void Normalizer2Impl::makeCanonIterDataFromNorm16(UChar32 start, UChar32 end, ui
         } else {
             // c has a one-way decomposition
             UChar32 c2=c;
+            // Do not modify the whole-range norm16 value.
             uint16_t norm16_2=norm16;
-            while(limitNoNo<=norm16_2 && norm16_2<minMaybeYes) {
-                c2=mapAlgorithmic(c2, norm16_2);
-                norm16_2=getNorm16(c2);
+            if (isDecompNoAlgorithmic(norm16_2)) {
+                // Maps to an isCompYesAndZeroCC.
+                c2 = mapAlgorithmic(c2, norm16_2);
+                norm16_2 = getNorm16(c2);
+                // No compatibility mappings for the CanonicalIterator.
+                U_ASSERT(!(isHangulLV(norm16_2) || isHangulLVT(norm16_2)));
             }
-            if(minYesNo<=norm16_2 && norm16_2<limitNoNo) {
+            if (norm16_2 > minYesNo) {
                 // c decomposes, get everything from the variable-length extra data
                 const uint16_t *mapping=getMapping(norm16_2);
                 uint16_t firstUnit=*mapping;
@@ -2633,7 +2656,7 @@ unorm2_swap(const UDataSwapper *ds,
     uint8_t *outBytes;
 
     const int32_t *inIndexes;
-    int32_t indexes[Normalizer2Impl::IX_MIN_MAYBE_YES+1];
+    int32_t indexes[Normalizer2Impl::IX_TOTAL_SIZE+1];
 
     int32_t i, offset, nextOffset, size;
 
@@ -2651,7 +2674,7 @@ unorm2_swap(const UDataSwapper *ds,
         pInfo->dataFormat[1]==0x72 &&
         pInfo->dataFormat[2]==0x6d &&
         pInfo->dataFormat[3]==0x32 &&
-        (formatVersion0==1 || formatVersion0==2)
+        (1<=formatVersion0 && formatVersion0<=3)
     )) {
         udata_printError(ds, "unorm2_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as Normalizer2 data\n",
                          pInfo->dataFormat[0], pInfo->dataFormat[1],
@@ -2668,8 +2691,10 @@ unorm2_swap(const UDataSwapper *ds,
     int32_t minIndexesLength;
     if(formatVersion0==1) {
         minIndexesLength=Normalizer2Impl::IX_MIN_MAYBE_YES+1;
-    } else {
+    } else if(formatVersion0==2) {
         minIndexesLength=Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY+1;
+    } else {
+        minIndexesLength=Normalizer2Impl::IX_MIN_LCCC_CP+1;
     }
 
     if(length>=0) {
@@ -2683,7 +2708,7 @@ unorm2_swap(const UDataSwapper *ds,
     }
 
     /* read the first few indexes */
-    for(i=0; i<=Normalizer2Impl::IX_MIN_MAYBE_YES; ++i) {
+    for(i=0; i<UPRV_LENGTHOF(indexes); ++i) {
         indexes[i]=udata_readInt32(ds, inIndexes[i]);
     }
 
diff --git a/icu4c/source/common/normalizer2impl.h b/icu4c/source/common/normalizer2impl.h
index d2f64808a26..fdc0d3b3c5e 100644
--- a/icu4c/source/common/normalizer2impl.h
+++ b/icu4c/source/common/normalizer2impl.h
@@ -37,6 +37,8 @@ struct CanonIterData;
 
 class ByteSink;
 class Edits;
+class InitCanonIterData;
+class LcccContext;
 
 class U_COMMON_API Hangul {
 public:
@@ -66,9 +68,9 @@ public:
         return HANGUL_BASE<=c && c<HANGUL_LIMIT;
     }
     static inline UBool
-    isHangulWithoutJamoT(UChar c) {
+    isHangulLV(UChar32 c) {
         c-=HANGUL_BASE;
-        return c<HANGUL_COUNT && c%JAMO_T_COUNT==0;
+        return 0<=c && c<HANGUL_COUNT && c%JAMO_T_COUNT==0;
     }
     static inline UBool isJamoL(UChar32 c) {
         return (uint32_t)(c-JAMO_L_BASE)<JAMO_L_COUNT;
@@ -76,6 +78,14 @@ public:
     static inline UBool isJamoV(UChar32 c) {
         return (uint32_t)(c-JAMO_V_BASE)<JAMO_V_COUNT;
     }
+    static inline UBool isJamoT(UChar32 c) {
+        int32_t t=c-JAMO_T_BASE;
+        return 0<t && t<JAMO_T_COUNT;  // not JAMO_T_BASE itself
+    }
+    static UBool isJamo(UChar32 c) {
+        return JAMO_L_BASE<=c && c<=JAMO_T_END &&
+            (c<=JAMO_L_END || (JAMO_V_BASE<=c && c<=JAMO_V_END) || JAMO_T_BASE<c);
+    }
 
     /**
      * Decomposes c, which must be a Hangul syllable, into buffer
@@ -120,10 +130,13 @@ class Normalizer2Impl;
 
 class U_COMMON_API ReorderingBuffer : public UMemory {
 public:
+    /** Constructs only; init() should be called. */
     ReorderingBuffer(const Normalizer2Impl &ni, UnicodeString &dest) :
         impl(ni), str(dest),
         start(NULL), reorderStart(NULL), limit(NULL),
         remainingCapacity(0), lastCC(0) {}
+    /** Constructs, removes the string contents, and initializes for a small initial capacity. */
+    ReorderingBuffer(const Normalizer2Impl &ni, UnicodeString &dest, UErrorCode &errorCode);
     ~ReorderingBuffer() {
         if(start!=NULL) {
             str.releaseBuffer((int32_t)(limit-start));
@@ -140,11 +153,6 @@ public:
     UBool equals(const UChar *start, const UChar *limit) const;
     UBool equals(const uint8_t *otherStart, const uint8_t *otherLimit) const;
 
-    // For Hangul composition, replacing the Leading consonant Jamo with the syllable.
-    void setLastChar(UChar c) {
-        *(limit-1)=c;
-    }
-
     UBool append(UChar32 c, uint8_t cc, UErrorCode &errorCode) {
         return (c<=0xffff) ?
             appendBMP((UChar)c, cc, errorCode) :
@@ -222,6 +230,12 @@ private:
     UChar *codePointStart, *codePointLimit;
 };
 
+/**
+ * Low-level implementation of the Unicode Normalization Algorithm.
+ * For the data structure and details see the documentation at the end of
+ * this normalizer2impl.h and in the design doc at
+ * http://site.icu-project.org/design/normalization/custom
+ */
 class U_COMMON_API Normalizer2Impl : public UObject {
 public:
     Normalizer2Impl() : normTrie(NULL), fCanonIterData(NULL) {
@@ -238,8 +252,6 @@ public:
 
     // low-level properties ------------------------------------------------ ***
 
-    const UTrie2 *getNormTrie() const { return normTrie; }
-
     UBool ensureCanonIterData(UErrorCode &errorCode) const;
 
     uint16_t getNorm16(UChar32 c) const { return UTRIE2_GET16(normTrie, c); }
@@ -259,15 +271,22 @@ public:
 
     uint8_t getCC(uint16_t norm16) const {
         if(norm16>=MIN_NORMAL_MAYBE_YES) {
-            return (uint8_t)norm16;
+            return getCCFromNormalYesOrMaybe(norm16);
         }
         if(norm16<minNoNo || limitNoNo<=norm16) {
             return 0;
         }
         return getCCFromNoNo(norm16);
     }
+    static uint8_t getCCFromNormalYesOrMaybe(uint16_t norm16) {
+        return (uint8_t)(norm16 >> OFFSET_SHIFT);
+    }
     static uint8_t getCCFromYesOrMaybe(uint16_t norm16) {
-        return norm16>=MIN_NORMAL_MAYBE_YES ? (uint8_t)norm16 : 0;
+        return norm16>=MIN_NORMAL_MAYBE_YES ? getCCFromNormalYesOrMaybe(norm16) : 0;
+    }
+    uint8_t getCCFromYesOrMaybeCP(UChar32 c) const {
+        if (c < minCompNoMaybeCP) { return 0; }
+        return getCCFromYesOrMaybe(getNorm16(c));
     }
 
     /**
@@ -276,10 +295,8 @@ public:
      * @return The lccc(c) in bits 15..8 and tccc(c) in bits 7..0.
      */
     uint16_t getFCD16(UChar32 c) const {
-        if(c<0) {
+        if(c<minDecompNoCP) {
             return 0;
-        } else if(c<0x180) {
-            return tccc180[c];
         } else if(c<=0xffff) {
             if(!singleLeadMightHaveNonZeroFCD16(c)) { return 0; }
         }
@@ -295,9 +312,7 @@ public:
      */
     uint16_t nextFCD16(const UChar *&s, const UChar *limit) const {
         UChar32 c=*s++;
-        if(c<0x180) {
-            return tccc180[c];
-        } else if(!singleLeadMightHaveNonZeroFCD16(c)) {
+        if(c<minDecompNoCP || !singleLeadMightHaveNonZeroFCD16(c)) {
             return 0;
         }
         UChar c2;
@@ -315,8 +330,8 @@ public:
      */
     uint16_t previousFCD16(const UChar *start, const UChar *&s) const {
         UChar32 c=*--s;
-        if(c<0x180) {
-            return tccc180[c];
+        if(c<minDecompNoCP) {
+            return 0;
         }
         if(!U16_IS_TRAIL(c)) {
             if(!singleLeadMightHaveNonZeroFCD16(c)) {
@@ -332,8 +347,6 @@ public:
         return getFCD16FromNormData(c);
     }
 
-    /** Returns the FCD data for U+0000<=c<U+0180. */
-    uint16_t getFCD16FromBelow180(UChar32 c) const { return tccc180[c]; }
     /** Returns TRUE if the single-or-lead code unit c might have non-zero FCD data. */
     UBool singleLeadMightHaveNonZeroFCD16(UChar32 lead) const {
         // 0<=lead<=0xffff
@@ -344,9 +357,6 @@ public:
     /** Returns the FCD value from the regular normalization data. */
     uint16_t getFCD16FromNormData(UChar32 c) const;
 
-    void makeCanonIterDataFromNorm16(UChar32 start, UChar32 end, uint16_t norm16,
-                                     CanonIterData &newData, UErrorCode &errorCode) const;
-
     /**
      * Gets the decomposition for one code point.
      * @param c code point
@@ -371,14 +381,25 @@ public:
     UBool getCanonStartSet(UChar32 c, UnicodeSet &set) const;
 
     enum {
-        MIN_CCC_LCCC_CP=0x300
-    };
+        // Fixed norm16 values.
+        MIN_YES_YES_WITH_CC=0xfe02,
+        JAMO_VT=0xfe00,
+        MIN_NORMAL_MAYBE_YES=0xfc00,
+        JAMO_L=2,  // offset=1 hasCompBoundaryAfter=FALSE
+        INERT=1,  // offset=0 hasCompBoundaryAfter=TRUE
+
+        // norm16 bit 0 is comp-boundary-after.
+        HAS_COMP_BOUNDARY_AFTER=1,
+        OFFSET_SHIFT=1,
+
+        // For algorithmic one-way mappings, norm16 bits 2..1 indicate the
+        // tccc (0, 1, >1) for quick FCC boundary-after tests.
+        DELTA_TCCC_0=0,
+        DELTA_TCCC_1=2,
+        DELTA_TCCC_GT_1=4,
+        DELTA_TCCC_MASK=6,
+        DELTA_SHIFT=3,
 
-    enum {
-        MIN_YES_YES_WITH_CC=0xff01,
-        JAMO_VT=0xff00,
-        MIN_NORMAL_MAYBE_YES=0xfe00,
-        JAMO_L=1,
         MAX_DELTA=0x40
     };
 
@@ -398,21 +419,32 @@ public:
         IX_MIN_COMP_NO_MAYBE_CP,
 
         // Norm16 value thresholds for quick check combinations and types of extra data.
-        IX_MIN_YES_NO,  // Mappings & compositions in [minYesNo..minYesNoMappingsOnly[.
+
+        // Mappings & compositions in [minYesNo..minYesNoMappingsOnly[.
+        IX_MIN_YES_NO,
+        // Mappings are comp-normalized.
         IX_MIN_NO_NO,
         IX_LIMIT_NO_NO,
         IX_MIN_MAYBE_YES,
 
-        IX_MIN_YES_NO_MAPPINGS_ONLY,  // Mappings only in [minYesNoMappingsOnly..minNoNo[.
+        // Mappings only in [minYesNoMappingsOnly..minNoNo[.
+        IX_MIN_YES_NO_MAPPINGS_ONLY,
+        // Mappings are not comp-normalized but have a comp boundary before.
+        IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE,
+        // Mappings do not have a comp boundary before.
+        IX_MIN_NO_NO_COMP_NO_MAYBE_CC,
+        // Mappings to the empty string.
+        IX_MIN_NO_NO_EMPTY,
 
-        IX_RESERVED15,
+        IX_MIN_LCCC_CP,
+        IX_RESERVED19,
         IX_COUNT
     };
 
     enum {
         MAPPING_HAS_CCC_LCCC_WORD=0x80,
         MAPPING_HAS_RAW_MAPPING=0x40,
-        MAPPING_NO_COMP_BOUNDARY_AFTER=0x20,
+        // unused bit 0x20,
         MAPPING_LENGTH_MASK=0x1f
     };
 
@@ -462,10 +494,10 @@ public:
                           ReorderingBuffer &buffer,
                           UErrorCode &errorCode) const;
 
-    UBool composeUTF8(uint32_t options,
+    /** sink==nullptr: isNormalized() */
+    UBool composeUTF8(uint32_t options, UBool onlyContiguous,
                       const uint8_t *src, const uint8_t *limit,
-                      UBool onlyContiguous, UBool doCompose,
-                      ByteSink &sink, icu::Edits *edits, UErrorCode &errorCode) const;
+                      ByteSink *sink, icu::Edits *edits, UErrorCode &errorCode) const;
 
     const UChar *makeFCD(const UChar *src, const UChar *limit,
                          ReorderingBuffer *buffer, UErrorCode &errorCode) const;
@@ -475,27 +507,42 @@ public:
                           ReorderingBuffer &buffer,
                           UErrorCode &errorCode) const;
 
-    UBool hasDecompBoundary(UChar32 c, UBool before) const;
+    UBool hasDecompBoundaryBefore(UChar32 c) const;
+    UBool norm16HasDecompBoundaryBefore(uint16_t norm16) const;
+    UBool hasDecompBoundaryAfter(UChar32 c) const;
+    UBool norm16HasDecompBoundaryAfter(uint16_t norm16) const;
     UBool isDecompInert(UChar32 c) const { return isDecompYesAndZeroCC(getNorm16(c)); }
 
     UBool hasCompBoundaryBefore(UChar32 c) const {
-        return c<minCompNoMaybeCP || hasCompBoundaryBefore(c, getNorm16(c));
+        return c<minCompNoMaybeCP || norm16HasCompBoundaryBefore(getNorm16(c));
+    }
+    UBool hasCompBoundaryAfter(UChar32 c, UBool onlyContiguous) const {
+        return norm16HasCompBoundaryAfter(getNorm16(c), onlyContiguous);
+    }
+    UBool isCompInert(UChar32 c, UBool onlyContiguous) const {
+        uint16_t norm16=getNorm16(c);
+        return isCompYesAndZeroCC(norm16) &&
+            (norm16 & HAS_COMP_BOUNDARY_AFTER) != 0 &&
+            (!onlyContiguous || isInert(norm16) || *getMapping(norm16) <= 0x1ff);
     }
-    UBool hasCompBoundaryAfter(UChar32 c, UBool onlyContiguous, UBool testInert) const;
 
-    UBool hasFCDBoundaryBefore(UChar32 c) const { return c<MIN_CCC_LCCC_CP || getFCD16(c)<=0xff; }
-    UBool hasFCDBoundaryAfter(UChar32 c) const {
-        uint16_t fcd16=getFCD16(c);
-        return fcd16<=1 || (fcd16&0xff)==0;
-    }
+    UBool hasFCDBoundaryBefore(UChar32 c) const { return hasDecompBoundaryBefore(c); }
+    UBool hasFCDBoundaryAfter(UChar32 c) const { return hasDecompBoundaryAfter(c); }
     UBool isFCDInert(UChar32 c) const { return getFCD16(c)<=1; }
 private:
+    friend class InitCanonIterData;
+    friend class LcccContext;
+
     UBool isMaybe(uint16_t norm16) const { return minMaybeYes<=norm16 && norm16<=JAMO_VT; }
     UBool isMaybeOrNonZeroCC(uint16_t norm16) const { return norm16>=minMaybeYes; }
-    static UBool isInert(uint16_t norm16) { return norm16==0; }
-    static UBool isJamoL(uint16_t norm16) { return norm16==1; }
+    static UBool isInert(uint16_t norm16) { return norm16==INERT; }
+    static UBool isJamoL(uint16_t norm16) { return norm16==JAMO_L; }
     static UBool isJamoVT(uint16_t norm16) { return norm16==JAMO_VT; }
-    UBool isHangul(uint16_t norm16) const { return norm16==minYesNo; }
+    uint16_t hangulLVT() const { return minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER; }
+    UBool isHangulLV(uint16_t norm16) const { return norm16==minYesNo; }
+    UBool isHangulLVT(uint16_t norm16) const {
+        return norm16==hangulLVT();
+    }
     UBool isCompYesAndZeroCC(uint16_t norm16) const { return norm16<minNoNo; }
     // UBool isCompYes(uint16_t norm16) const {
     //     return norm16>=MIN_YES_YES_WITH_CC || norm16<minNoNo;
@@ -514,7 +561,7 @@ private:
     /**
      * A little faster and simpler than isDecompYesAndZeroCC() but does not include
      * the MaybeYes which combine-forward and have ccc=0.
-     * (Standard Unicode 5.2 normalization does not have such characters.)
+     * (Standard Unicode 10 normalization does not have such characters.)
      */
     UBool isMostDecompYesAndZeroCC(uint16_t norm16) const {
         return norm16<minYesNo || norm16==MIN_NORMAL_MAYBE_YES || norm16==JAMO_VT;
@@ -524,7 +571,7 @@ private:
     // For use with isCompYes().
     // Perhaps the compiler can combine the two tests for MIN_YES_YES_WITH_CC.
     // static uint8_t getCCFromYes(uint16_t norm16) {
-    //     return norm16>=MIN_YES_YES_WITH_CC ? (uint8_t)norm16 : 0;
+    //     return norm16>=MIN_YES_YES_WITH_CC ? getCCFromNormalYesOrMaybe(norm16) : 0;
     // }
     uint8_t getCCFromNoNo(uint16_t norm16) const {
         const uint16_t *mapping=getMapping(norm16);
@@ -535,30 +582,47 @@ private:
         }
     }
     // requires that the [cpStart..cpLimit[ character passes isCompYesAndZeroCC()
-    uint8_t getTrailCCFromCompYesAndZeroCC(const UChar *cpStart, const UChar *cpLimit) const;
+    uint8_t getTrailCCFromCompYesAndZeroCC(uint16_t norm16) const {
+        if(norm16<=minYesNo) {
+            return 0;  // yesYes and Hangul LV have ccc=tccc=0
+        } else {
+            // For Hangul LVT we harmlessly fetch a firstUnit with tccc=0 here.
+            return (uint8_t)(*getMapping(norm16)>>8);  // tccc from yesNo
+        }
+    }
+    uint8_t getPreviousTrailCC(const UChar *start, const UChar *p) const;
+    uint8_t getPreviousTrailCC(const uint8_t *start, const uint8_t *p) const;
 
     // Requires algorithmic-NoNo.
     UChar32 mapAlgorithmic(UChar32 c, uint16_t norm16) const {
-        return c+norm16-(minMaybeYes-MAX_DELTA-1);
+        return c+(norm16>>DELTA_SHIFT)-centerNoNoDelta;
+    }
+    UChar32 getAlgorithmicDelta(uint16_t norm16) const {
+        return (norm16>>DELTA_SHIFT)-centerNoNoDelta;
     }
 
     // Requires minYesNo<norm16<limitNoNo.
-    const uint16_t *getMapping(uint16_t norm16) const { return extraData+norm16; }
+    const uint16_t *getMapping(uint16_t norm16) const { return extraData+(norm16>>OFFSET_SHIFT); }
     const uint16_t *getCompositionsListForDecompYes(uint16_t norm16) const {
-        if(norm16==0 || MIN_NORMAL_MAYBE_YES<=norm16) {
+        if(norm16<JAMO_L || MIN_NORMAL_MAYBE_YES<=norm16) {
             return NULL;
         } else if(norm16<minMaybeYes) {
-            return extraData+norm16;  // for yesYes; if Jamo L: harmless empty list
+            return getMapping(norm16);  // for yesYes; if Jamo L: harmless empty list
         } else {
             return maybeYesCompositions+norm16-minMaybeYes;
         }
     }
     const uint16_t *getCompositionsListForComposite(uint16_t norm16) const {
-        const uint16_t *list=extraData+norm16;  // composite has both mapping & compositions list
+        // A composite has both mapping & compositions list.
+        const uint16_t *list=getMapping(norm16);
         return list+  // mapping pointer
-            1+  // +1 to skip the first unit with the mapping lenth
+            1+  // +1 to skip the first unit with the mapping length
             (*list&MAPPING_LENGTH_MASK);  // + mapping length
     }
+    const uint16_t *getCompositionsListForMaybe(uint16_t norm16) const {
+        // minMaybeYes<=norm16<MIN_NORMAL_MAYBE_YES
+        return maybeYesCompositions+((norm16-minMaybeYes)>>OFFSET_SHIFT);
+    }
     /**
      * @param c code point must have compositions
      * @return compositions list pointer
@@ -573,55 +637,78 @@ private:
                                                 UChar32 minNeedDataCP,
                                                 ReorderingBuffer *buffer,
                                                 UErrorCode &errorCode) const;
-    UBool decomposeShort(const UChar *src, const UChar *limit,
-                         ReorderingBuffer &buffer, UErrorCode &errorCode) const;
+    const UChar *decomposeShort(const UChar *src, const UChar *limit,
+                                UBool stopAtCompBoundary, UBool onlyContiguous,
+                                ReorderingBuffer &buffer, UErrorCode &errorCode) const;
     UBool decompose(UChar32 c, uint16_t norm16,
                     ReorderingBuffer &buffer, UErrorCode &errorCode) const;
 
     const uint8_t *decomposeShort(const uint8_t *src, const uint8_t *limit,
-                                  UBool stopAtCompBoundary, ReorderingBuffer &buffer,
-                                  UErrorCode &errorCode) const;
+                                  UBool stopAtCompBoundary, UBool onlyContiguous,
+                                  ReorderingBuffer &buffer, UErrorCode &errorCode) const;
 
     static int32_t combine(const uint16_t *list, UChar32 trail);
     void addComposites(const uint16_t *list, UnicodeSet &set) const;
     void recompose(ReorderingBuffer &buffer, int32_t recomposeStartIndex,
                    UBool onlyContiguous) const;
 
-    int32_t getCompProps(const uint8_t *src, const uint8_t *limit,
-                         uint16_t norm16, UBool onlyContiguous) const;
-
-    UBool hasCompBoundaryBefore(UChar32 c, uint16_t norm16) const;
+    UBool hasCompBoundaryBefore(UChar32 c, uint16_t norm16) const {
+        return c<minCompNoMaybeCP || norm16HasCompBoundaryBefore(norm16);
+    }
+    UBool norm16HasCompBoundaryBefore(uint16_t norm16) const  {
+        return norm16 < minNoNoCompNoMaybeCC || isAlgorithmicNoNo(norm16);
+    }
+    UBool hasCompBoundaryBefore(const UChar *src, const UChar *limit) const;
     UBool hasCompBoundaryBefore(const uint8_t *src, const uint8_t *limit) const;
+    UBool hasCompBoundaryAfter(const UChar *start, const UChar *p,
+                               UBool onlyContiguous) const;
+    UBool hasCompBoundaryAfter(const uint8_t *start, const uint8_t *p,
+                               UBool onlyContiguous) const;
+    UBool norm16HasCompBoundaryAfter(uint16_t norm16, UBool onlyContiguous) const {
+        return (norm16 & HAS_COMP_BOUNDARY_AFTER) != 0 &&
+            (!onlyContiguous || isTrailCC01ForCompBoundaryAfter(norm16));
+    }
+    /** For FCC: Given norm16 HAS_COMP_BOUNDARY_AFTER, does it have tccc<=1? */
+    UBool isTrailCC01ForCompBoundaryAfter(uint16_t norm16) const {
+        return isInert(norm16) || (isDecompNoAlgorithmic(norm16) ?
+            (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1 : *getMapping(norm16) <= 0x1ff);
+    }
 
-    const UChar *findPreviousCompBoundary(const UChar *start, const UChar *p) const;
-    const UChar *findNextCompBoundary(const UChar *p, const UChar *limit) const;
+    const UChar *findPreviousCompBoundary(const UChar *start, const UChar *p, UBool onlyContiguous) const;
+    const UChar *findNextCompBoundary(const UChar *p, const UChar *limit, UBool onlyContiguous) const;
 
     const UChar *findPreviousFCDBoundary(const UChar *start, const UChar *p) const;
     const UChar *findNextFCDBoundary(const UChar *p, const UChar *limit) const;
 
+    void makeCanonIterDataFromNorm16(UChar32 start, UChar32 end, const uint16_t norm16,
+                                     CanonIterData &newData, UErrorCode &errorCode) const;
+
     int32_t getCanonValue(UChar32 c) const;
     const UnicodeSet &getCanonStartSet(int32_t n) const;
 
     // UVersionInfo dataVersion;
 
-    // Code point thresholds for quick check codes.
-    UChar32 minDecompNoCP;
-    UChar32 minCompNoMaybeCP;
+    // BMP code point thresholds for quick check loops looking at single UTF-16 code units.
+    UChar minDecompNoCP;
+    UChar minCompNoMaybeCP;
+    UChar minLcccCP;
 
     // Norm16 value thresholds for quick check combinations and types of extra data.
     uint16_t minYesNo;
     uint16_t minYesNoMappingsOnly;
     uint16_t minNoNo;
+    uint16_t minNoNoCompBoundaryBefore;
+    uint16_t minNoNoCompNoMaybeCC;
+    uint16_t minNoNoEmpty;
     uint16_t limitNoNo;
+    uint16_t centerNoNoDelta;
     uint16_t minMaybeYes;
 
     const UTrie2 *normTrie;
     const uint16_t *maybeYesCompositions;
     const uint16_t *extraData;  // mappings and/or compositions for yesYes, yesNo & noNo characters
     const uint8_t *smallFCD;  // [0x100] one bit per 32 BMP code points, set if any FCD!=0
-    uint8_t tccc180[0x180];  // tccc values for U+0000..U+017F
 
-public:  // CanonIterData is public to allow access from C callback functions.
     UInitOnce       fCanonIterDataInitOnce;
     CanonIterData  *fCanonIterData;
 };
@@ -677,13 +764,14 @@ unorm_getFCD16(UChar32 c);
 
 /**
  * Format of Normalizer2 .nrm data files.
- * Format version 2.0.
+ * Format version 3.0.
  *
  * Normalizer2 .nrm data files provide data for the Unicode Normalization algorithms.
  * ICU ships with data files for standard Unicode Normalization Forms
  * NFC and NFD (nfc.nrm), NFKC and NFKD (nfkc.nrm) and NFKC_Casefold (nfkc_cf.nrm).
  * Custom (application-specific) data can be built into additional .nrm files
  * with the gennorm2 build tool.
+ * ICU ships with one such file, uts46.nrm, for the implementation of UTS #46.
  *
  * Normalizer2.getInstance() causes a .nrm file to be loaded, unless it has been
  * cached already. Internally, Normalizer2Impl.load() reads the .nrm file.
@@ -714,14 +802,20 @@ unorm_getFCD16(UChar32 c);
  *      with a decomposition mapping, that is, with NF*D_QC=No.
  *      minCompNoMaybeCP=indexes[IX_MIN_COMP_NO_MAYBE_CP] is the lowest code point
  *      with NF*C_QC=No (has a one-way mapping) or Maybe (combines backward).
+ *      minLcccCP=indexes[IX_MIN_LCCC_CP] (index 18, new in formatVersion 3)
+ *      is the lowest code point with lccc!=0.
  *
- *      The next five indexes are thresholds of 16-bit trie values for ranges of
+ *      The next eight indexes are thresholds of 16-bit trie values for ranges of
  *      values indicating multiple normalization properties.
+ *      They are listed here in threshold order, not in the order they are stored in the indexes.
  *          minYesNo=indexes[IX_MIN_YES_NO];
+ *          minYesNoMappingsOnly=indexes[IX_MIN_YES_NO_MAPPINGS_ONLY];
  *          minNoNo=indexes[IX_MIN_NO_NO];
+ *          minNoNoCompBoundaryBefore=indexes[IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE];
+ *          minNoNoCompNoMaybeCC=indexes[IX_MIN_NO_NO_COMP_NO_MAYBE_CC];
+ *          minNoNoEmpty=indexes[IX_MIN_NO_NO_EMPTY];
  *          limitNoNo=indexes[IX_LIMIT_NO_NO];
  *          minMaybeYes=indexes[IX_MIN_MAYBE_YES];
- *          minYesNoMappingsOnly=indexes[IX_MIN_YES_NO_MAPPINGS_ONLY];
  *      See the normTrie description below and the design doc for details.
  *
  * UTrie2 normTrie; -- see utrie2_impl.h and utrie2.h
@@ -729,12 +823,14 @@ unorm_getFCD16(UChar32 c);
  *      The trie holds the main normalization data. Each code point is mapped to a 16-bit value.
  *      Rather than using independent bits in the value (which would require more than 16 bits),
  *      information is extracted primarily via range checks.
+ *      Except, format version 3 uses bit 0 for hasCompBoundaryAfter().
  *      For example, a 16-bit value norm16 in the range minYesNo<=norm16<minNoNo
  *      means that the character has NF*C_QC=Yes and NF*D_QC=No properties,
  *      which means it has a two-way (round-trip) decomposition mapping.
  *      Values in the range 2<=norm16<limitNoNo are also directly indexes into the extraData
  *      pointing to mappings, compositions lists, or both.
- *      Value norm16==0 means that the character is normalization-inert, that is,
+ *      Value norm16==INERT (0 in versions 1 & 2, 1 in version 3)
+ *      means that the character is normalization-inert, that is,
  *      it does not have a mapping, does not participate in composition, has a zero
  *      canonical combining class, and forms a boundary where text before it and after it
  *      can be normalized independently.
@@ -748,7 +844,7 @@ unorm_getFCD16(UChar32 c);
  *      The trie has a value for each lead surrogate code unit representing the "worst case"
  *      properties of the 1024 supplementary characters whose UTF-16 form starts with
  *      the lead surrogate. If all of the 1024 supplementary characters are normalization-inert,
- *      then their lead surrogate code unit has the trie value 0.
+ *      then their lead surrogate code unit has the trie value INERT.
  *      When the lead surrogate unit's value exceeds the quick check minimum during processing,
  *      the properties for the full supplementary code point need to be looked up.
  *
@@ -757,6 +853,7 @@ unorm_getFCD16(UChar32 c);
  *
  *      There is only one byte offset for the end of these two arrays.
  *      The split between them is given by the constant and variable mentioned above.
+ *      In version 3, the difference must be shifted right by OFFSET_SHIFT.
  *
  *      The maybeYesCompositions array contains compositions lists for characters that
  *      combine both forward (as starters in composition pairs)
@@ -773,6 +870,8 @@ unorm_getFCD16(UChar32 c);
  *      followed by only mappings for "NoNo" characters.
  *      (Referring to pairs of NFC/NFD quick check values.)
  *      The norm16 values of those characters are directly indexes into the extraData array.
+ *      In version 3, the norm16 values must be shifted right by OFFSET_SHIFT
+ *      for accessing extraData.
  *
  *      The data structures for compositions lists and mappings are described in the design doc.
  *
@@ -803,6 +902,50 @@ unorm_getFCD16(UChar32 c);
  *   This is fully equivalent with formatVersion 1's MAPPING_PLUS_COMPOSITION_LIST flag.
  *   It is needed for the new (in ICU 49) composePair(), not for other normalization.
  * - Addition of the smallFCD[] bit set.
+ *
+ * Changes from format version 2 to format version 3 (ICU 60) ------------------
+ *
+ * - norm16 bit 0 indicates hasCompBoundaryAfter(),
+ *   except that for contiguous composition (FCC) the tccc must be checked as well.
+ *   Data indexes and ccc values are shifted left by one (OFFSET_SHIFT).
+ *   Thresholds like minNoNo are tested before shifting.
+ *
+ * - Algorithmic mapping deltas are shifted left by two more bits (total DELTA_SHIFT),
+ *   to make room for two bits (three values) indicating whether the tccc is 0, 1, or greater.
+ *   See DELTA_TCCC_MASK etc.
+ *   This helps with fetching tccc/FCD values and FCC hasCompBoundaryAfter().
+ *   minMaybeYes is 8-aligned so that the DELTA_TCCC_MASK bits can be tested directly.
+ *
+ * - Algorithmic mappings are only used for mapping to "comp yes and ccc=0" characters,
+ *   and ASCII characters are mapped algorithmically only to other ASCII characters.
+ *   This helps with hasCompBoundaryBefore() and compose() fast paths.
+ *   It is never necessary any more to loop for algorithmic mappings.
+ *
+ * - Addition of indexes[IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE],
+ *   indexes[IX_MIN_NO_NO_COMP_NO_MAYBE_CC], and indexes[IX_MIN_NO_NO_EMPTY],
+ *   and separation of the noNo extraData into distinct ranges.
+ *   With this, the noNo norm16 value indicates whether the mapping is
+ *   compose-normalized, not normalized but hasCompBoundaryBefore(),
+ *   not even that, or maps to an empty string.
+ *   hasCompBoundaryBefore() can be determined solely from the norm16 value.
+ *
+ * - The norm16 value for Hangul LVT is now different from that for Hangul LV,
+ *   so that hasCompBoundaryAfter() need not check for the syllable type.
+ *   For Hangul LV, minYesNo continues to be used (no comp-boundary-after).
+ *   For Hangul LVT, minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER is used.
+ *   The extraData units at these indexes are set to firstUnit=2 and firstUnit=3, respectively,
+ *   to simplify some code.
+ *
+ * - The extraData firstUnit bit 5 is no longer necessary
+ *   (norm16 bit 0 used instead of firstUnit MAPPING_NO_COMP_BOUNDARY_AFTER),
+ *   is reserved again, and always set to 0.
+ *
+ * - Addition of indexes[IX_MIN_LCCC_CP], the first code point where lccc!=0.
+ *   This used to be hardcoded to U+0300, but in data like NFKC_Casefold it is lower:
+ *   U+00AD Soft Hyphen maps to an empty string,
+ *   which is artificially assigned "worst case" values lccc=1 and tccc=255.
+ *
+ * - A mapping to an empty string has explicit lccc=1 and tccc=255 values.
  */
 
 #endif  /* !UCONFIG_NO_NORMALIZATION */
diff --git a/icu4c/source/common/ucasemap.cpp b/icu4c/source/common/ucasemap.cpp
index 1f83c0d6a06..57bf3a52a4e 100644
--- a/icu4c/source/common/ucasemap.cpp
+++ b/icu4c/source/common/ucasemap.cpp
@@ -820,7 +820,7 @@ ucasemap_mapUTF8(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_P
         return 0;
     }
 
-    if(edits!=NULL) {
+    if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
         edits->reset();
     }
     destLength=stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR
diff --git a/icu4c/source/common/unicode/normalizer2.h b/icu4c/source/common/unicode/normalizer2.h
index f0d77978804..f71ccb8b839 100644
--- a/icu4c/source/common/unicode/normalizer2.h
+++ b/icu4c/source/common/unicode/normalizer2.h
@@ -240,7 +240,7 @@ public:
      *                  pass the U_SUCCESS() test, or else the function returns
      *                  immediately. Check for U_FAILURE() on output or use with
      *                  function chaining. (See User Guide for details.)
-     * @internal ICU 60 technology preview, may be changed or removed in the future
+     * @draft ICU 60
      */
     virtual void
     normalizeUTF8(uint32_t options, StringPiece src, ByteSink &sink,
@@ -510,7 +510,35 @@ public:
     virtual UnicodeString &
     normalize(const UnicodeString &src,
               UnicodeString &dest,
-              UErrorCode &errorCode) const;
+              UErrorCode &errorCode) const override;
+
+    /**
+     * Normalizes a UTF-8 string and optionally records how source substrings
+     * relate to changed and unchanged result substrings.
+     *
+     * Currently implemented completely only for "compose" modes,
+     * such as for NFC, NFKC, and NFKC_Casefold
+     * (UNORM2_COMPOSE and UNORM2_COMPOSE_CONTIGUOUS).
+     * Otherwise currently converts to & from UTF-16 and does not support edits.
+     *
+     * @param options   Options bit set, usually 0. See U_OMIT_UNCHANGED_TEXT.
+     * @param src       Source UTF-8 string.
+     * @param sink      A ByteSink to which the normalized UTF-8 result string is written.
+     *                  sink.Flush() is called at the end.
+     * @param edits     Records edits for index mapping, working with styled text,
+     *                  and getting only changes (if any).
+     *                  The Edits contents is undefined if any error occurs.
+     *                  This function calls edits->reset() first. edits can be nullptr.
+     * @param errorCode Standard ICU error code. Its input value must
+     *                  pass the U_SUCCESS() test, or else the function returns
+     *                  immediately. Check for U_FAILURE() on output or use with
+     *                  function chaining. (See User Guide for details.)
+     * @draft ICU 60
+     */
+    virtual void
+    normalizeUTF8(uint32_t options, StringPiece src, ByteSink &sink,
+                  Edits *edits, UErrorCode &errorCode) const override;
+
     /**
      * Appends the normalized form of the second string to the first string
      * (merging them at the boundary) and returns the first string.
@@ -528,7 +556,7 @@ public:
     virtual UnicodeString &
     normalizeSecondAndAppend(UnicodeString &first,
                              const UnicodeString &second,
-                             UErrorCode &errorCode) const;
+                             UErrorCode &errorCode) const override;
     /**
      * Appends the second string to the first string
      * (merging them at the boundary) and returns the first string.
@@ -546,7 +574,7 @@ public:
     virtual UnicodeString &
     append(UnicodeString &first,
            const UnicodeString &second,
-           UErrorCode &errorCode) const;
+           UErrorCode &errorCode) const override;
 
     /**
      * Gets the decomposition mapping of c.
@@ -560,7 +588,7 @@ public:
      * @stable ICU 4.6
      */
     virtual UBool
-    getDecomposition(UChar32 c, UnicodeString &decomposition) const;
+    getDecomposition(UChar32 c, UnicodeString &decomposition) const override;
 
     /**
      * Gets the raw decomposition mapping of c.
@@ -574,7 +602,7 @@ public:
      * @stable ICU 49
      */
     virtual UBool
-    getRawDecomposition(UChar32 c, UnicodeString &decomposition) const;
+    getRawDecomposition(UChar32 c, UnicodeString &decomposition) const override;
 
     /**
      * Performs pairwise composition of a & b and returns the composite if there is one.
@@ -587,7 +615,7 @@ public:
      * @stable ICU 49
      */
     virtual UChar32
-    composePair(UChar32 a, UChar32 b) const;
+    composePair(UChar32 a, UChar32 b) const override;
 
     /**
      * Gets the combining class of c.
@@ -598,7 +626,7 @@ public:
      * @stable ICU 49
      */
     virtual uint8_t
-    getCombiningClass(UChar32 c) const;
+    getCombiningClass(UChar32 c) const override;
 
     /**
      * Tests if the string is normalized.
@@ -612,7 +640,7 @@ public:
      * @stable ICU 4.4
      */
     virtual UBool
-    isNormalized(const UnicodeString &s, UErrorCode &errorCode) const;
+    isNormalized(const UnicodeString &s, UErrorCode &errorCode) const override;
     /**
      * Tests if the string is normalized.
      * For details see the Normalizer2 base class documentation.
@@ -625,7 +653,7 @@ public:
      * @stable ICU 4.4
      */
     virtual UNormalizationCheckResult
-    quickCheck(const UnicodeString &s, UErrorCode &errorCode) const;
+    quickCheck(const UnicodeString &s, UErrorCode &errorCode) const override;
     /**
      * Returns the end of the normalized substring of the input string.
      * For details see the Normalizer2 base class documentation.
@@ -638,7 +666,7 @@ public:
      * @stable ICU 4.4
      */
     virtual int32_t
-    spanQuickCheckYes(const UnicodeString &s, UErrorCode &errorCode) const;
+    spanQuickCheckYes(const UnicodeString &s, UErrorCode &errorCode) const override;
 
     /**
      * Tests if the character always has a normalization boundary before it,
@@ -648,7 +676,7 @@ public:
      * @return TRUE if c has a normalization boundary before it
      * @stable ICU 4.4
      */
-    virtual UBool hasBoundaryBefore(UChar32 c) const;
+    virtual UBool hasBoundaryBefore(UChar32 c) const override;
 
     /**
      * Tests if the character always has a normalization boundary after it,
@@ -658,7 +686,7 @@ public:
      * @return TRUE if c has a normalization boundary after it
      * @stable ICU 4.4
      */
-    virtual UBool hasBoundaryAfter(UChar32 c) const;
+    virtual UBool hasBoundaryAfter(UChar32 c) const override;
 
     /**
      * Tests if the character is normalization-inert.
@@ -667,7 +695,7 @@ public:
      * @return TRUE if c is normalization-inert
      * @stable ICU 4.4
      */
-    virtual UBool isInert(UChar32 c) const;
+    virtual UBool isInert(UChar32 c) const override;
 private:
     UnicodeString &
     normalize(const UnicodeString &src,
@@ -675,6 +703,12 @@ private:
               USetSpanCondition spanCondition,
               UErrorCode &errorCode) const;
 
+    void
+    normalizeUTF8(uint32_t options, const char *src, int32_t length,
+                  ByteSink &sink, Edits *edits,
+                  USetSpanCondition spanCondition,
+                  UErrorCode &errorCode) const;
+
     UnicodeString &
     normalizeSecondAndAppend(UnicodeString &first,
                              const UnicodeString &second,
diff --git a/icu4c/source/common/unicode/stringoptions.h b/icu4c/source/common/unicode/stringoptions.h
index 270b9de691c..d8b29fd40d8 100644
--- a/icu4c/source/common/unicode/stringoptions.h
+++ b/icu4c/source/common/unicode/stringoptions.h
@@ -182,6 +182,7 @@
 // ucasemap_imp.h #define U_TITLECASE_ITERATOR_MASK 0xe0
 // ucasemap_imp.h #define U_TITLECASE_ADJUSTMENT_MASK 0x600
 // ustr_imp.h #define _STRNCMP_STYLE 0x1000
+// ustr_imp.h #define U_EDITS_NO_RESET 0x2000
 // unormcmp.cpp #define _COMPARE_EQUIV 0x80000
 
 #endif  // __STRINGOPTIONS_H__
diff --git a/icu4c/source/common/ustr_imp.h b/icu4c/source/common/ustr_imp.h
index 9815915ff52..3c2d8574f8d 100644
--- a/icu4c/source/common/ustr_imp.h
+++ b/icu4c/source/common/ustr_imp.h
@@ -25,6 +25,11 @@
  */
 #define _STRNCMP_STYLE 0x1000
 
+/**
+ * Internal option for string transformation functions to not first reset the Edits object.
+ */
+#define U_EDITS_NO_RESET 0x2000
+
 /**
  * Compare two strings in code point order or code unit order.
  * Works in strcmp style (both lengths -1),
diff --git a/icu4c/source/common/ustrcase.cpp b/icu4c/source/common/ustrcase.cpp
index 6fffb90a389..bd910cf0dc5 100644
--- a/icu4c/source/common/ustrcase.cpp
+++ b/icu4c/source/common/ustrcase.cpp
@@ -1103,7 +1103,7 @@ ustrcase_map(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
         return 0;
     }
 
-    if(edits!=NULL) {
+    if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
         edits->reset();
     }
     destLength=stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR
diff --git a/icu4c/source/common/utrie2.cpp b/icu4c/source/common/utrie2.cpp
index cec7224d90f..8f9183bafad 100644
--- a/icu4c/source/common/utrie2.cpp
+++ b/icu4c/source/common/utrie2.cpp
@@ -746,7 +746,7 @@ uint16_t BackwardUTrie2StringIterator::previous16() {
     codePointLimit=codePointStart;
     if(start>=codePointStart) {
         codePoint=U_SENTINEL;
-        return 0;
+        return trie->errorValue;
     }
     uint16_t result;
     UTRIE2_U16_PREV16(trie, start, codePointStart, codePoint, result);
@@ -757,7 +757,7 @@ uint16_t ForwardUTrie2StringIterator::next16() {
     codePointStart=codePointLimit;
     if(codePointLimit==limit) {
         codePoint=U_SENTINEL;
-        return 0;
+        return trie->errorValue;
     }
     uint16_t result;
     UTRIE2_U16_NEXT16(trie, codePointLimit, limit, codePoint, result);
diff --git a/icu4c/source/data/in/nfc.nrm b/icu4c/source/data/in/nfc.nrm
index 76168750f23..d92f277c25d 100644
Binary files a/icu4c/source/data/in/nfc.nrm and b/icu4c/source/data/in/nfc.nrm differ
diff --git a/icu4c/source/data/in/nfkc.nrm b/icu4c/source/data/in/nfkc.nrm
index c4b7e722844..1289141ba58 100644
Binary files a/icu4c/source/data/in/nfkc.nrm and b/icu4c/source/data/in/nfkc.nrm differ
diff --git a/icu4c/source/data/in/nfkc_cf.nrm b/icu4c/source/data/in/nfkc_cf.nrm
index 9d91ad32ab4..c6b1e1a8351 100644
Binary files a/icu4c/source/data/in/nfkc_cf.nrm and b/icu4c/source/data/in/nfkc_cf.nrm differ
diff --git a/icu4c/source/data/in/uts46.nrm b/icu4c/source/data/in/uts46.nrm
index 7270a67b41d..ee765dec403 100644
Binary files a/icu4c/source/data/in/uts46.nrm and b/icu4c/source/data/in/uts46.nrm differ
diff --git a/icu4c/source/test/cintltst/cnormtst.c b/icu4c/source/test/cintltst/cnormtst.c
index 2ee0cc93eca..18412f71a67 100644
--- a/icu4c/source/test/cintltst/cnormtst.c
+++ b/icu4c/source/test/cintltst/cnormtst.c
@@ -159,6 +159,7 @@ void addNormTest(TestNode** root)
 }
 
 static const char* const modeStrings[]={
+    "?",
     "UNORM_NONE",
     "UNORM_NFD",
     "UNORM_NFKD",
@@ -183,7 +184,7 @@ static void TestNormCases(UNormalizationMode mode,
         length2= unorm_normalize(source, -1, mode, 0, NULL, 0, &status2);
         if(neededLen!=length2) {
           log_err("ERROR in unorm_normalize(%s)[%d]: "
-                  "preflight length/NUL %d!=%d preflight length/srcLength\n",
+                  "preflight length/srcLength %d!=%d preflight length/NUL\n",
                   modeStrings[mode], (int)x, (int)neededLen, (int)length2);
         }
         if(status==U_BUFFER_OVERFLOW_ERROR)
@@ -192,14 +193,14 @@ static void TestNormCases(UNormalizationMode mode,
         }
         length2=unorm_normalize(source, u_strlen(source), mode, 0, result, UPRV_LENGTHOF(result), &status); 
         if(U_FAILURE(status) || neededLen!=length2) {
-            log_data_err("ERROR in unorm_normalize(%s/NUL) at %s:  %s - (Are you missing data?)\n",
+            log_data_err("ERROR in unorm_normalize(%s/srcLength) at %s:  %s - (Are you missing data?)\n",
                          modeStrings[mode], austrdup(source), myErrorName(status));
         } else {
             assertEqual(result, cases[x][expIndex], x);
         }
         length2=unorm_normalize(source, -1, mode, 0, result, UPRV_LENGTHOF(result), &status); 
         if(U_FAILURE(status) || neededLen!=length2) {
-            log_data_err("ERROR in unorm_normalize(%s/srcLength) at %s:  %s - (Are you missing data?)\n",
+            log_data_err("ERROR in unorm_normalize(%s/NUL) at %s:  %s - (Are you missing data?)\n",
                          modeStrings[mode], austrdup(source), myErrorName(status));
         } else {
             assertEqual(result, cases[x][expIndex], x);
diff --git a/icu4c/source/test/intltest/normconf.cpp b/icu4c/source/test/intltest/normconf.cpp
index e6619ea58a4..50d4a6fec05 100644
--- a/icu4c/source/test/intltest/normconf.cpp
+++ b/icu4c/source/test/intltest/normconf.cpp
@@ -406,11 +406,11 @@ UBool NormalizerConformanceTest::checkConformance(const UnicodeString* field,
 }
 
 static const char *const kModeStrings[UNORM_MODE_COUNT] = {
-    "?", "D", "KD", "C", "KC", "FCD"
+    "?", "none", "D", "KD", "C", "KC", "FCD"
 };
 
 static const char *const kMessages[UNORM_MODE_COUNT] = {
-    "?!=?", "c3!=D(c%d)", "c5!=KC(c%d)", "c2!=C(c%d)", "c4!=KC(c%d)", "FCD"
+    "?!=?", "?!=?", "c3!=D(c%d)", "c5!=KC(c%d)", "c2!=C(c%d)", "c4!=KC(c%d)", "FCD"
 };
 
 UBool NormalizerConformanceTest::checkNorm(UNormalizationMode mode, int32_t options,
@@ -450,6 +450,7 @@ UBool NormalizerConformanceTest::checkNorm(UNormalizationMode mode, int32_t opti
     std::string exp8;
     exp.toUTF8String(exp8);
     std::string out8;
+    out8.reserve(exp8.length());
     Edits edits;
     Edits *editsPtr = (mode == UNORM_NFC || mode == UNORM_NFKC) ? &edits : nullptr;
     StringByteSink<std::string> sink(&out8);
diff --git a/icu4c/source/test/intltest/tstnorm.cpp b/icu4c/source/test/intltest/tstnorm.cpp
index db6719434ff..25ebdc19b08 100644
--- a/icu4c/source/test/intltest/tstnorm.cpp
+++ b/icu4c/source/test/intltest/tstnorm.cpp
@@ -55,6 +55,9 @@ void BasicNormalizerTest::runIndexedTest(int32_t index, UBool exec,
 #endif
     TESTCASE_AUTO(TestFilteredNormalizer2Coverage);
     TESTCASE_AUTO(TestNormalizeUTF8WithEdits);
+    TESTCASE_AUTO(TestLowMappingToEmpty_D);
+    TESTCASE_AUTO(TestLowMappingToEmpty_FCD);
+    TESTCASE_AUTO(TestNormalizeIllFormedText);
     TESTCASE_AUTO_END;
 }
 
@@ -1374,6 +1377,10 @@ initExpectedSkippables(UnicodeSet skipSets[UNORM_MODE_COUNT], UErrorCode &errorC
     delete [] combineBackCharsAndCc;
 }
 
+static const char *const kModeStrings[UNORM_MODE_COUNT] = {
+    "?", "none", "D", "KD", "C", "KC", "FCD"
+};
+
 void
 BasicNormalizerTest::TestSkippable() {
     UnicodeSet diff, skipSets[UNORM_MODE_COUNT], expectSets[UNORM_MODE_COUNT];
@@ -1395,7 +1402,8 @@ BasicNormalizerTest::TestSkippable() {
 
     for(int32_t i=UNORM_NONE; i<UNORM_MODE_COUNT; ++i) {
         if(skipSets[i]!=expectSets[i]) {
-            errln("error: TestSkippable skipSets[%d]!=expectedSets[%d]\n", i, i);
+            const char *ms=kModeStrings[i];
+            errln("error: TestSkippable skipSets[%s]!=expectedSets[%s]\n", ms, ms);
             // Note: This used to depend on hardcoded UnicodeSet patterns generated by
             // Mark's unicodetools.com.ibm.text.UCD.NFSkippable, by
             // running com.ibm.text.UCD.Main with the option NFSkippable.
@@ -1531,7 +1539,7 @@ BasicNormalizerTest::TestNormalizeUTF8WithEdits() {
         return;
     }
     static const char *const src =
-        u8"  AÄA\u0308A\u0308\u0323Ä\u0323,\u1100\u1161가\u11A8가\u3133  ";
+        u8"  AÄA\u0308A\u0308\u00ad\u0323Ä\u0323,\u00ad\u1100\u1161가\u11A8가\u3133  ";
     std::string expected = u8"  aääạ\u0308ạ\u0308,가각갃  ";
     std::string result;
     StringByteSink<std::string> sink(&result);
@@ -1544,9 +1552,10 @@ BasicNormalizerTest::TestNormalizeUTF8WithEdits() {
         { TRUE, 1, 1 },  // A→a
         { TRUE, 2, 2 },  // Ä→ä
         { TRUE, 3, 2 },  // A\u0308→ä
-        { TRUE, 5, 5 },  // A\u0308\u0323→ạ\u0308
+        { TRUE, 7, 5 },  // A\u0308\u00ad\u0323→ạ\u0308 removes the soft hyphen
         { TRUE, 4, 5 },  // Ä\u0323→ ạ\u0308
         { FALSE, 1, 1 },  // comma
+        { TRUE, 2, 0 },  // U+00AD soft hyphen maps to empty
         { TRUE, 6, 3 },  // \u1100\u1161→ 가
         { TRUE, 6, 3 },  // 가\u11A8→ 각
         { TRUE, 6, 3 },  // 가\u3133→ 갃
@@ -1568,6 +1577,138 @@ BasicNormalizerTest::TestNormalizeUTF8WithEdits() {
             edits.getFineIterator(), edits.getFineIterator(),
             expectedChanges, UPRV_LENGTHOF(expectedChanges),
             TRUE, errorCode);
+
+    // With filter: The normalization code does not see the "A" substrings.
+    UnicodeSet filter(u"[^A]", errorCode);
+    FilteredNormalizer2 fn2(*nfkc_cf, filter);
+    expected = u8"  AäA\u0308A\u0323\u0308ạ\u0308,가각갃  ";
+    result.clear();
+    edits.reset();
+    fn2.normalizeUTF8(0, src, sink, &edits, errorCode);
+    assertSuccess("filtered normalizeUTF8", errorCode.get());
+    assertEquals("filtered normalizeUTF8", expected.c_str(), result.c_str());
+    static const EditChange filteredChanges[] = {
+        { FALSE, 3, 3 },  // 2 spaces + A
+        { TRUE, 2, 2 },  // Ä→ä
+        { FALSE, 4, 4 },  // A\u0308A
+        { TRUE, 6, 4 },  // \u0308\u00ad\u0323→\u0323\u0308 removes the soft hyphen
+        { TRUE, 4, 5 },  // Ä\u0323→ ạ\u0308
+        { FALSE, 1, 1 },  // comma
+        { TRUE, 2, 0 },  // U+00AD soft hyphen maps to empty
+        { TRUE, 6, 3 },  // \u1100\u1161→ 가
+        { TRUE, 6, 3 },  // 가\u11A8→ 각
+        { TRUE, 6, 3 },  // 가\u3133→ 갃
+        { FALSE, 2, 2 }  // 2 spaces
+    };
+    TestUtility::checkEditsIter(*this, u"filtered normalizeUTF8",
+            edits.getFineIterator(), edits.getFineIterator(),
+            filteredChanges, UPRV_LENGTHOF(filteredChanges),
+            TRUE, errorCode);
+
+    // Omit unchanged text.
+    // Note that the result is not normalized because the inner normalizer
+    // does not see text across filter spans.
+    expected = u8"ä\u0323\u0308ạ\u0308가각갃";
+    result.clear();
+    edits.reset();
+    fn2.normalizeUTF8(U_OMIT_UNCHANGED_TEXT, src, sink, &edits, errorCode);
+    assertSuccess("filtered normalizeUTF8 omit unchanged", errorCode.get());
+    assertEquals("filtered normalizeUTF8 omit unchanged", expected.c_str(), result.c_str());
+    TestUtility::checkEditsIter(*this, u"filtered normalizeUTF8 omit unchanged",
+            edits.getFineIterator(), edits.getFineIterator(),
+            filteredChanges, UPRV_LENGTHOF(filteredChanges),
+            TRUE, errorCode);
+}
+
+void
+BasicNormalizerTest::TestLowMappingToEmpty_D() {
+    IcuTestErrorCode errorCode(*this, "TestLowMappingToEmpty_D");
+    const Normalizer2 *n2 = Normalizer2::getInstance(
+        nullptr, "nfkc_cf", UNORM2_DECOMPOSE, errorCode);
+    if (errorCode.logDataIfFailureAndReset("Normalizer2::getInstance() call failed")) {
+        return;
+    }
+    checkLowMappingToEmpty(*n2);
+
+    UnicodeString sh(u'\u00AD');
+    assertFalse("soft hyphen is not normalized", n2->isNormalized(sh, errorCode));
+    UnicodeString result = n2->normalize(sh, errorCode);
+    assertTrue("soft hyphen normalizes to empty", result.isEmpty());
+    assertEquals("soft hyphen QC=No", UNORM_NO, n2->quickCheck(sh, errorCode));
+    assertEquals("soft hyphen spanQuickCheckYes", 0, n2->spanQuickCheckYes(sh, errorCode));
+
+    UnicodeString s(u"\u00ADÄ\u00AD\u0323");
+    result = n2->normalize(s, errorCode);
+    assertEquals("normalize string with soft hyphens", u"a\u0323\u0308", result);
+}
+
+void
+BasicNormalizerTest::TestLowMappingToEmpty_FCD() {
+    IcuTestErrorCode errorCode(*this, "TestLowMappingToEmpty_FCD");
+    const Normalizer2 *n2 = Normalizer2::getInstance(
+        nullptr, "nfkc_cf", UNORM2_FCD, errorCode);
+    if (errorCode.logDataIfFailureAndReset("Normalizer2::getInstance() call failed")) {
+        return;
+    }
+    checkLowMappingToEmpty(*n2);
+
+    UnicodeString sh(u'\u00AD');
+    assertTrue("soft hyphen is FCD", n2->isNormalized(sh, errorCode));
+
+    UnicodeString s(u"\u00ADÄ\u00AD\u0323");
+    UnicodeString result = n2->normalize(s, errorCode);
+    assertEquals("normalize string with soft hyphens", u"\u00ADa\u0323\u0308", result);
+}
+
+void
+BasicNormalizerTest::checkLowMappingToEmpty(const Normalizer2 &n2) {
+    UnicodeString mapping;
+    assertTrue("getDecomposition(soft hyphen)", n2.getDecomposition(0xad, mapping));
+    assertTrue("soft hyphen maps to empty", mapping.isEmpty());
+    assertFalse("soft hyphen has no boundary before", n2.hasBoundaryBefore(0xad));
+    assertFalse("soft hyphen has no boundary after", n2.hasBoundaryAfter(0xad));
+    assertFalse("soft hyphen is not inert", n2.isInert(0xad));
+}
+
+void
+BasicNormalizerTest::TestNormalizeIllFormedText() {
+    IcuTestErrorCode errorCode(*this, "TestNormalizeIllFormedText");
+    const Normalizer2 *nfkc_cf = Normalizer2::getNFKCCasefoldInstance(errorCode);
+    if(errorCode.logDataIfFailureAndReset("Normalizer2::getNFKCCasefoldInstance() call failed")) {
+        return;
+    }
+    // Normalization behavior for ill-formed text is not defined.
+    // ICU currently treats ill-formed sequences as normalization-inert
+    // and copies them unchanged.
+    UnicodeString src(u"  A");
+    src.append((char16_t)0xD800).append(u"ÄA\u0308").append((char16_t)0xD900).
+        append(u"A\u0308\u00ad\u0323").append((char16_t)0xDBFF).
+        append(u"Ä\u0323,\u00ad").append((char16_t)0xDC00).
+        append(u"\u1100\u1161가\u11A8가\u3133  ").append((char16_t)0xDFFF);
+    UnicodeString expected(u"  a");
+    expected.append((char16_t)0xD800).append(u"ää").append((char16_t)0xD900).
+        append(u"ạ\u0308").append((char16_t)0xDBFF).
+        append(u"ạ\u0308,").append((char16_t)0xDC00).
+        append(u"가각갃  ").append((char16_t)0xDFFF);
+    UnicodeString result = nfkc_cf->normalize(src, errorCode);
+    assertSuccess("normalize", errorCode.get());
+    assertEquals("normalize", expected, result);
+
+    std::string src8(u8"  A");
+    src8.append("\x80").append(u8"ÄA\u0308").append("\xC0\x80").
+        append(u8"A\u0308\u00ad\u0323").append("\xED\xA0\x80").
+        append(u8"Ä\u0323,\u00ad").append("\xF4\x90\x80\x80").
+        append(u8"\u1100\u1161가\u11A8가\u3133  ").append("\xF0");
+    std::string expected8(u8"  a");
+    expected8.append("\x80").append(u8"ää").append("\xC0\x80").
+        append(u8"ạ\u0308").append("\xED\xA0\x80").
+        append(u8"ạ\u0308,").append("\xF4\x90\x80\x80").
+        append(u8"가각갃  ").append("\xF0");
+    std::string result8;
+    StringByteSink<std::string> sink(&result8);
+    nfkc_cf->normalizeUTF8(0, src8, sink, nullptr, errorCode);
+    assertSuccess("normalizeUTF8", errorCode.get());
+    assertEquals("normalizeUTF8", expected8.c_str(), result8.c_str());
 }
 
 #endif /* #if !UCONFIG_NO_NORMALIZATION */
diff --git a/icu4c/source/test/intltest/tstnorm.h b/icu4c/source/test/intltest/tstnorm.h
index 0153acf4e55..d98aafd7094 100644
--- a/icu4c/source/test/intltest/tstnorm.h
+++ b/icu4c/source/test/intltest/tstnorm.h
@@ -48,6 +48,9 @@ public:
     void TestCustomFCC();
     void TestFilteredNormalizer2Coverage();
     void TestNormalizeUTF8WithEdits();
+    void TestLowMappingToEmpty_D();
+    void TestLowMappingToEmpty_FCD();
+    void TestNormalizeIllFormedText();
 
 private:
     UnicodeString canonTests[24][3];
@@ -83,6 +86,7 @@ private:
     static UnicodeString hex(UChar ch);
     static UnicodeString hex(const UnicodeString& str);
 
+    void checkLowMappingToEmpty(const Normalizer2 &n2);
 };
 
 #endif /* #if !UCONFIG_NO_NORMALIZATION */
diff --git a/icu4c/source/tools/gennorm2/extradata.cpp b/icu4c/source/tools/gennorm2/extradata.cpp
index b98889e8611..ae074949d3d 100644
--- a/icu4c/source/tools/gennorm2/extradata.cpp
+++ b/icu4c/source/tools/gennorm2/extradata.cpp
@@ -26,19 +26,20 @@ U_NAMESPACE_BEGIN
 ExtraData::ExtraData(Norms &n, UBool fast) :
         Norms::Enumerator(n),
         yesYesCompositions(1000, (UChar32)0xffff, 2),  // 0=inert, 1=Jamo L, 2=start of compositions
-        yesNoMappingsAndCompositions(1000, (UChar32)0, 1),  // 0=Hangul, 1=start of normal data
-        optimizeFast(fast) {}
+        yesNoMappingsAndCompositions(1000, (UChar32)0, 1),  // 0=Hangul LV, 1=start of normal data
+        yesNoMappingsOnly(1000, (UChar32)0, 1),  // 0=Hangul LVT, 1=start of normal data
+        optimizeFast(fast) {
+    // Hangul LV algorithmically decomposes to two Jamo.
+    // Some code may harmlessly read this firstUnit.
+    yesNoMappingsAndCompositions.setCharAt(0, 2);
+    // Hangul LVT algorithmically decomposes to three Jamo.
+    // Some code may harmlessly read this firstUnit.
+    yesNoMappingsOnly.setCharAt(0, 3);
+}
 
 int32_t ExtraData::writeMapping(UChar32 c, const Norm &norm, UnicodeString &dataString) {
     UnicodeString &m=*norm.mapping;
     int32_t length=m.length();
-    if(length>Normalizer2Impl::MAPPING_LENGTH_MASK) {
-        fprintf(stderr,
-                "gennorm2 error: "
-                "mapping for U+%04lX longer than maximum of %d\n",
-                (long)c, Normalizer2Impl::MAPPING_LENGTH_MASK);
-        exit(U_INVALID_FORMAT_ERROR);
-    }
     // Write the mapping & raw mapping extraData.
     int32_t firstUnit=length|(norm.trailCC<<8);
     int32_t preMappingLength=0;
@@ -81,9 +82,6 @@ int32_t ExtraData::writeMapping(UChar32 c, const Norm &norm, UnicodeString &data
         ++preMappingLength;
         firstUnit|=Normalizer2Impl::MAPPING_HAS_CCC_LCCC_WORD;
     }
-    if(norm.hasNoCompBoundaryAfter) {
-        firstUnit|=Normalizer2Impl::MAPPING_NO_COMP_BOUNDARY_AFTER;
-    }
     dataString.append((UChar)firstUnit);
     dataString.append(m);
     return preMappingLength;
@@ -109,6 +107,22 @@ int32_t ExtraData::writeNoNoMapping(UChar32 c, const Norm &norm,
     return offset;
 }
 
+UBool ExtraData::setNoNoDelta(UChar32 c, Norm &norm) const {
+    // Try a compact, algorithmic encoding to a single compYesAndZeroCC code point.
+    // Do not map from ASCII to non-ASCII.
+    if(norm.mappingCP>=0 &&
+            !(c<=0x7f && norm.mappingCP>0x7f) &&
+            norms.getNormRef(norm.mappingCP).type<Norm::NO_NO_COMP_YES) {
+        int32_t delta=norm.mappingCP-c;
+        if(-Normalizer2Impl::MAX_DELTA<=delta && delta<=Normalizer2Impl::MAX_DELTA) {
+            norm.type=Norm::NO_NO_DELTA;
+            norm.offset=delta;
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
 void ExtraData::writeCompositions(UChar32 c, const Norm &norm, UnicodeString &dataString) {
     if(norm.cc!=0) {
         fprintf(stderr,
@@ -189,29 +203,27 @@ void ExtraData::writeExtraData(UChar32 c, Norm &norm) {
         norm.offset=yesNoMappingsOnly.length()+
                 writeMapping(c, norm, yesNoMappingsOnly);
         break;
-    case Norm::NO_NO:
-        if(norm.cc==0 && !optimizeFast) {
-            // Try a compact, algorithmic encoding.
-            // Only for ccc=0, because we can't store additional information
-            // and we do not recursively follow an algorithmic encoding for access to the ccc.
-            //
-            // Also, if hasNoCompBoundaryAfter is set, we can only use the algorithmic encoding
-            // if the mappingCP decomposes further, to ensure that there is a place to store it.
-            // We want to see that the final mapping does not have exactly 1 code point,
-            // or else we would have to recursively ensure that the final mapping is stored
-            // in normal extraData.
-            if(norm.mappingCP>=0 &&
-                    (!norm.hasNoCompBoundaryAfter || 1!=norm.mapping->countChar32())) {
-                int32_t delta=norm.mappingCP-c;
-                if(-Normalizer2Impl::MAX_DELTA<=delta && delta<=Normalizer2Impl::MAX_DELTA) {
-                    norm.type=Norm::NO_NO_DELTA;
-                    norm.offset=delta;
-                    break;
-                }
-            }
+    case Norm::NO_NO_COMP_YES:
+        if(!optimizeFast && setNoNoDelta(c, norm)) {
+            break;
         }
-        // TODO: minMappingNotCompYes, minMappingNoCompBoundaryBefore
-        norm.offset=writeNoNoMapping(c, norm, noNoMappings, previousNoNoMappings);
+        norm.offset=writeNoNoMapping(c, norm, noNoMappingsCompYes, previousNoNoMappingsCompYes);
+        break;
+    case Norm::NO_NO_COMP_BOUNDARY_BEFORE:
+        if(!optimizeFast && setNoNoDelta(c, norm)) {
+            break;
+        }
+        norm.offset=writeNoNoMapping(
+            c, norm, noNoMappingsCompBoundaryBefore, previousNoNoMappingsCompBoundaryBefore);
+        break;
+    case Norm::NO_NO_COMP_NO_MAYBE_CC:
+        norm.offset=writeNoNoMapping(
+            c, norm, noNoMappingsCompNoMaybeCC, previousNoNoMappingsCompNoMaybeCC);
+        break;
+    case Norm::NO_NO_EMPTY:
+        // There can be multiple extra data entries for mappings to the empty string
+        // if they have different raw mappings.
+        norm.offset=writeNoNoMapping(c, norm, noNoMappingsEmpty, previousNoNoMappingsEmpty);
         break;
     case Norm::MAYBE_YES_COMBINES_FWD:
         norm.offset=maybeYesCompositions.length();
diff --git a/icu4c/source/tools/gennorm2/extradata.h b/icu4c/source/tools/gennorm2/extradata.h
index cec9d9a94fb..0a8e73087d5 100644
--- a/icu4c/source/tools/gennorm2/extradata.h
+++ b/icu4c/source/tools/gennorm2/extradata.h
@@ -36,7 +36,10 @@ public:
     UnicodeString yesYesCompositions;
     UnicodeString yesNoMappingsAndCompositions;
     UnicodeString yesNoMappingsOnly;
-    UnicodeString noNoMappings;
+    UnicodeString noNoMappingsCompYes;
+    UnicodeString noNoMappingsCompBoundaryBefore;
+    UnicodeString noNoMappingsCompNoMaybeCC;
+    UnicodeString noNoMappingsEmpty;
 
 private:
     /**
@@ -48,12 +51,16 @@ private:
     int32_t writeMapping(UChar32 c, const Norm &norm, UnicodeString &dataString);
     int32_t writeNoNoMapping(UChar32 c, const Norm &norm,
                              UnicodeString &dataString, Hashtable &previousMappings);
+    UBool setNoNoDelta(UChar32 c, Norm &norm) const;
     /** Requires norm.compositions!=nullptr. */
     void writeCompositions(UChar32 c, const Norm &norm, UnicodeString &dataString);
     void writeExtraData(UChar32 c, Norm &norm);
 
     UBool optimizeFast;
-    Hashtable previousNoNoMappings;  // If constructed in runtime code, pass in UErrorCode.
+    Hashtable previousNoNoMappingsCompYes;  // If constructed in runtime code, pass in UErrorCode.
+    Hashtable previousNoNoMappingsCompBoundaryBefore;
+    Hashtable previousNoNoMappingsCompNoMaybeCC;
+    Hashtable previousNoNoMappingsEmpty;
 };
 
 U_NAMESPACE_END
diff --git a/icu4c/source/tools/gennorm2/n2builder.cpp b/icu4c/source/tools/gennorm2/n2builder.cpp
index 374e91c4884..9bad2d550e1 100644
--- a/icu4c/source/tools/gennorm2/n2builder.cpp
+++ b/icu4c/source/tools/gennorm2/n2builder.cpp
@@ -56,8 +56,8 @@ static UDataInfo dataInfo={
     0,
 
     { 0x4e, 0x72, 0x6d, 0x32 }, /* dataFormat="Nrm2" */
-    { 2, 0, 0, 0 },             /* formatVersion */
-    { 5, 2, 0, 0 }              /* dataVersion (Unicode version) */
+    { 3, 0, 0, 0 },             /* formatVersion */
+    { 10, 0, 0, 0 }             /* dataVersion (Unicode version) */
 };
 
 U_NAMESPACE_BEGIN
@@ -65,8 +65,7 @@ U_NAMESPACE_BEGIN
 class HangulIterator {
 public:
     struct Range {
-        UChar32 start, limit;
-        uint16_t norm16;
+        UChar32 start, end;
     };
 
     HangulIterator() : rangeIndex(0) {}
@@ -77,18 +76,17 @@ public:
             return NULL;
         }
     }
-    void reset() { rangeIndex=0; }
 private:
     static const Range ranges[4];
     int32_t rangeIndex;
 };
 
 const HangulIterator::Range HangulIterator::ranges[4]={
-    { Hangul::JAMO_L_BASE, Hangul::JAMO_L_BASE+Hangul::JAMO_L_COUNT, 1 },
-    { Hangul::JAMO_V_BASE, Hangul::JAMO_V_BASE+Hangul::JAMO_V_COUNT, Normalizer2Impl::JAMO_VT },
+    { Hangul::JAMO_L_BASE, Hangul::JAMO_L_END },
+    { Hangul::JAMO_V_BASE, Hangul::JAMO_V_END },
     // JAMO_T_BASE+1: not U+11A7
-    { Hangul::JAMO_T_BASE+1, Hangul::JAMO_T_BASE+Hangul::JAMO_T_COUNT, Normalizer2Impl::JAMO_VT },
-    { Hangul::HANGUL_BASE, Hangul::HANGUL_BASE+Hangul::HANGUL_COUNT, 0 },  // will become minYesNo
+    { Hangul::JAMO_T_BASE+1, Hangul::JAMO_T_END },
+    { Hangul::HANGUL_BASE, Hangul::HANGUL_END },
 };
 
 Normalizer2DataBuilder::Normalizer2DataBuilder(UErrorCode &errorCode) :
@@ -200,58 +198,109 @@ void Normalizer2DataBuilder::setRoundTripMapping(UChar32 c, const UnicodeString
 }
 
 void Normalizer2DataBuilder::removeMapping(UChar32 c) {
-    Norm *p=checkNormForMapping(norms.getNorm(c), c);
-    if(p!=NULL) {
-        p->mappingType=Norm::REMOVED;
-    }
+    // createNorm(c), not getNorm(c), to record a non-mapping and detect conflicting data.
+    Norm *p=checkNormForMapping(norms.createNorm(c), c);
+    p->mappingType=Norm::REMOVED;
 }
 
-UBool Normalizer2DataBuilder::hasNoCompBoundaryAfter(const BuilderReorderingBuffer &buffer) {
+UBool Normalizer2DataBuilder::mappingHasCompBoundaryAfter(const BuilderReorderingBuffer &buffer) const {
     if(buffer.isEmpty()) {
-        return TRUE;  // Maps-to-empty-string is no boundary of any kind.
+        return FALSE;  // Maps-to-empty-string is no boundary of any kind.
     }
     int32_t lastStarterIndex=buffer.lastStarterIndex();
     if(lastStarterIndex<0) {
-        return TRUE;  // no starter
+        return FALSE;  // no starter
     }
     UChar32 starter=buffer.charAt(lastStarterIndex);
+    if(lastStarterIndex==0 && norms.combinesBack(starter)) {
+        // The last starter is at the beginning of the mapping and combines backward.
+        return FALSE;
+    }
     if(Hangul::isJamoL(starter) ||
             (Hangul::isJamoV(starter) &&
             0<lastStarterIndex && Hangul::isJamoL(buffer.charAt(lastStarterIndex-1)))) {
         // A Jamo leading consonant or an LV pair combines-forward if it is at the end,
         // otherwise it is blocked.
-        return lastStarterIndex==buffer.length()-1;
+        return lastStarterIndex!=buffer.length()-1;
     }
     // Note: There can be no Hangul syllable in the fully decomposed mapping.
-    const Norm *starterNorm=norms.getNorm(starter);
-    if(starterNorm==nullptr || starterNorm->compositions==nullptr) {
-        return FALSE;  // The last starter does not combine forward.
+
+    // Multiple starters can combine into one.
+    // Look for the first of the last sequence of starters, excluding Jamos.
+    int32_t i=lastStarterIndex;
+    UChar32 c;
+    while(0<i && buffer.ccAt(i-1)==0 && !Hangul::isJamo(c=buffer.charAt(i-1))) {
+        starter=c;
+        --i;
+    }
+    // Compose as far as possible, and see if further compositions with
+    // characters following this mapping are possible.
+    const Norm *starterNorm=norms.getNorm(starter);
+    if(i==lastStarterIndex &&
+            (starterNorm==nullptr || starterNorm->compositions==nullptr)) {
+        return TRUE;  // The last starter does not combine forward.
     }
-    // Compose as far as possible, and see if further compositions are possible.
     uint8_t prevCC=0;
-    for(int32_t combMarkIndex=lastStarterIndex+1; combMarkIndex<buffer.length(); ++combMarkIndex) {
-        uint8_t cc=buffer.ccAt(combMarkIndex);  // !=0 because after last starter
-        if(norms.combinesWithCCBetween(*starterNorm, prevCC, cc)) {
+    while(++i<buffer.length()) {
+        uint8_t cc=buffer.ccAt(i);  // !=0 if after last starter
+        if(i>lastStarterIndex && norms.combinesWithCCBetween(*starterNorm, prevCC, cc)) {
             // The starter combines with a mark that reorders before the current one.
-            return TRUE;
+            return FALSE;
         }
-        if(prevCC<cc && (starter=starterNorm->combine(buffer.charAt(combMarkIndex)))>=0) {
-            // The starter combines with this mark into a composite replacement starter.
+        UChar32 c=buffer.charAt(i);
+        if(starterNorm!=nullptr && (prevCC<cc || prevCC==0) &&
+                norms.getNormRef(c).combinesBack && (starter=starterNorm->combine(c))>=0) {
+            // The starter combines with c into a composite replacement starter.
             starterNorm=norms.getNorm(starter);
-            if(starterNorm==nullptr || starterNorm->compositions==nullptr) {
-                return FALSE;  // The composite does not combine further.
+            if(i>=lastStarterIndex &&
+                    (starterNorm==nullptr || starterNorm->compositions==nullptr)) {
+                return TRUE;  // The composite does not combine further.
             }
             // Keep prevCC because we "removed" the combining mark.
+        } else if(cc==0) {
+            starterNorm=norms.getNorm(c);
+            if(i==lastStarterIndex &&
+                    (starterNorm==nullptr || starterNorm->compositions==nullptr)) {
+                return TRUE;  // The new starter does not combine forward.
+            }
+            prevCC=0;
         } else {
             prevCC=cc;
         }
     }
     if(prevCC==0) {
-        return TRUE;  // forward-combining starter at the very end
+        return FALSE;  // forward-combining starter at the very end
     }
     if(norms.combinesWithCCBetween(*starterNorm, prevCC, 256)) {
         // The starter combines with another mark.
-        return TRUE;
+        return FALSE;
+    }
+    return TRUE;
+}
+
+UBool Normalizer2DataBuilder::mappingRecomposes(const BuilderReorderingBuffer &buffer) const {
+    if(buffer.lastStarterIndex()<0) {
+        return FALSE;  // no starter
+    }
+    const Norm *starterNorm=nullptr;
+    uint8_t prevCC=0;
+    for(int32_t i=0; i<buffer.length(); ++i) {
+        UChar32 c=buffer.charAt(i);
+        uint8_t cc=buffer.ccAt(i);
+        if(starterNorm!=nullptr && (prevCC<cc || prevCC==0) &&
+                norms.getNormRef(c).combinesBack && starterNorm->combine(c)>=0) {
+            return TRUE;  // normal composite
+        } else if(cc==0) {
+            if(Hangul::isJamoL(c)) {
+                if((i+1)<buffer.length() && Hangul::isJamoV(buffer.charAt(i+1))) {
+                    return TRUE;  // Hangul syllable
+                }
+                starterNorm=nullptr;
+            } else {
+                starterNorm=norms.getNorm(c);
+            }
+        }
+        prevCC=cc;
     }
     return FALSE;
 }
@@ -264,6 +313,10 @@ void Normalizer2DataBuilder::postProcess(Norm &norm) {
     // Therefore, we cannot compute algorithmic mapping deltas here.
     // Error conditions are checked, but printed later when we do know the offending code point.
     if(norm.hasMapping()) {
+        if(norm.mapping->length()>Normalizer2Impl::MAPPING_LENGTH_MASK) {
+            norm.error="mapping longer than maximum of 31";
+            return;
+        }
         // Ensure canonical order.
         BuilderReorderingBuffer buffer;
         if(norm.rawMapping!=nullptr) {
@@ -272,20 +325,20 @@ void Normalizer2DataBuilder::postProcess(Norm &norm) {
         }
         norms.reorder(*norm.mapping, buffer);
         if(buffer.isEmpty()) {
-            norm.leadCC=norm.trailCC=0;
+            // A character that is deleted (maps to an empty string) must
+            // get the worst-case lccc and tccc values because arbitrary
+            // characters on both sides will become adjacent.
+            norm.leadCC=1;
+            norm.trailCC=0xff;
         } else {
             norm.leadCC=buffer.ccAt(0);
             norm.trailCC=buffer.ccAt(buffer.length()-1);
         }
 
-        // Set the hasNoCompBoundaryAfter flag for use by the last code branch
-        // in Normalizer2Impl::hasCompBoundaryAfter().
-        // For details see the comments on hasNoCompBoundaryAfter(buffer).
-        if(norm.compositions!=nullptr) {
-            norm.hasNoCompBoundaryAfter=TRUE;
-        } else {
-            norm.hasNoCompBoundaryAfter=hasNoCompBoundaryAfter(buffer);
-        }
+        norm.hasCompBoundaryBefore=
+            !buffer.isEmpty() && norm.leadCC==0 && !norms.combinesBack(buffer.charAt(0));
+        norm.hasCompBoundaryAfter=
+            norm.compositions==nullptr && mappingHasCompBoundaryAfter(buffer);
 
         if(norm.combinesBack) {
             norm.error="combines-back and decomposes, not possible in Unicode normalization";
@@ -299,13 +352,25 @@ void Normalizer2DataBuilder::postProcess(Norm &norm) {
             if(norm.compositions!=NULL) {
                 norm.error="combines-forward and has a one-way mapping, "
                            "not possible in Unicode normalization";
+            } else if(buffer.isEmpty()) {
+                norm.type=Norm::NO_NO_EMPTY;
+            } else if(!norm.hasCompBoundaryBefore) {
+                norm.type=Norm::NO_NO_COMP_NO_MAYBE_CC;
+            } else if(mappingRecomposes(buffer)) {
+                norm.type=Norm::NO_NO_COMP_BOUNDARY_BEFORE;
             } else {
-                norm.type=Norm::NO_NO;
+                // The mapping is comp-normalized.
+                norm.type=Norm::NO_NO_COMP_YES;
             }
         }
     } else {  // no mapping
         norm.leadCC=norm.trailCC=norm.cc;
 
+        norm.hasCompBoundaryBefore=
+            norm.cc==0 && !norm.combinesBack;
+        norm.hasCompBoundaryAfter=
+            norm.cc==0 && !norm.combinesBack && norm.compositions==nullptr;
+
         if(norm.combinesBack) {
             if(norm.compositions!=nullptr) {
                 // Earlier code checked ccc=0.
@@ -339,13 +404,6 @@ void Normalizer2DataBuilder::setSmallFCD(UChar32 c) {
 }
 
 void Normalizer2DataBuilder::writeNorm16(UChar32 start, UChar32 end, Norm &norm) {
-    if(start<Normalizer2Impl::MIN_CCC_LCCC_CP && (norm.cc!=0 || norm.leadCC!=0)) {
-        fprintf(stderr,
-                "gennorm2 error: "
-                "U+%04lX below U+0300 has ccc!=0 or lccc!=0, not supported by ICU\n",
-                (long)start);
-        exit(U_INVALID_FORMAT_ERROR);
-    }
     if((norm.leadCC|norm.trailCC)!=0) {
         for(UChar32 c=start; c<=end; ++c) {
             setSmallFCD(c);
@@ -355,37 +413,60 @@ void Normalizer2DataBuilder::writeNorm16(UChar32 start, UChar32 end, Norm &norm)
     int32_t norm16;
     switch(norm.type) {
     case Norm::INERT:
-        norm16=0;
+        norm16=Normalizer2Impl::INERT;
         break;
     case Norm::YES_YES_COMBINES_FWD:
-        norm16=norm.offset;
+        norm16=norm.offset*2;
         break;
     case Norm::YES_NO_COMBINES_FWD:
-        norm16=indexes[Normalizer2Impl::IX_MIN_YES_NO]+norm.offset;
+        norm16=indexes[Normalizer2Impl::IX_MIN_YES_NO]+norm.offset*2;
         break;
     case Norm::YES_NO_MAPPING_ONLY:
-        norm16=indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]+norm.offset;
+        norm16=indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]+norm.offset*2;
         break;
-        // TODO: minMappingNotCompYes, minMappingNoCompBoundaryBefore
-    case Norm::NO_NO:
-        norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO]+norm.offset;
+    case Norm::NO_NO_COMP_YES:
+        norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO]+norm.offset*2;
+        break;
+    case Norm::NO_NO_COMP_BOUNDARY_BEFORE:
+        norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE]+norm.offset*2;
+        break;
+    case Norm::NO_NO_COMP_NO_MAYBE_CC:
+        norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_NO_MAYBE_CC]+norm.offset*2;
+        break;
+    case Norm::NO_NO_EMPTY:
+        norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO_EMPTY]+norm.offset*2;
         break;
     case Norm::NO_NO_DELTA:
-        norm16=getCenterNoNoDelta()+norm.offset;
-        break;
+        {
+            // Positive offset from minNoNoDelta, shifted left for additional bits.
+            int32_t offset=(norm.offset+Normalizer2Impl::MAX_DELTA)<<Normalizer2Impl::DELTA_SHIFT;
+            if(norm.trailCC==0) {
+                // DELTA_TCCC_0==0
+            } else if(norm.trailCC==1) {
+                offset|=Normalizer2Impl::DELTA_TCCC_1;
+            } else {
+                offset|=Normalizer2Impl::DELTA_TCCC_GT_1;
+            }
+            norm16=getMinNoNoDelta()+offset;
+            break;
+        }
     case Norm::MAYBE_YES_COMBINES_FWD:
-        norm16=indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]+norm.offset;
+        norm16=indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]+norm.offset*2;
         break;
     case Norm::MAYBE_YES_SIMPLE:
-        norm16=Normalizer2Impl::MIN_NORMAL_MAYBE_YES+norm.cc;  // ccc=0..255
+        norm16=Normalizer2Impl::MIN_NORMAL_MAYBE_YES+norm.cc*2;  // ccc=0..255
         break;
     case Norm::YES_YES_WITH_CC:
         U_ASSERT(norm.cc!=0);
-        norm16=Normalizer2Impl::MIN_YES_YES_WITH_CC-1+norm.cc;  // ccc=1..255
+        norm16=Normalizer2Impl::MIN_YES_YES_WITH_CC-2+norm.cc*2;  // ccc=1..255
         break;
     default:  // Should not occur.
         exit(U_INTERNAL_PROGRAM_ERROR);
     }
+    U_ASSERT((norm16&1)==0);
+    if(norm.hasCompBoundaryAfter) {
+        norm16|=Normalizer2Impl::HAS_COMP_BOUNDARY_AFTER;
+    }
     IcuToolErrorCode errorCode("gennorm2/writeNorm16()");
     utrie2_setRange32(norm16Trie, start, end, (uint32_t)norm16, TRUE, errorCode);
 
@@ -396,10 +477,13 @@ void Normalizer2DataBuilder::writeNorm16(UChar32 start, UChar32 end, Norm &norm)
     if(isDecompNo && start<indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]) {
         indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=start;
     }
-    UBool isCompNoMaybe= norm.type>=Norm::NO_NO;
+    UBool isCompNoMaybe= norm.type>=Norm::NO_NO_COMP_YES;
     if(isCompNoMaybe && start<indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]) {
         indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=start;
     }
+    if(norm.leadCC!=0 && start<indexes[Normalizer2Impl::IX_MIN_LCCC_CP]) {
+        indexes[Normalizer2Impl::IX_MIN_LCCC_CP]=start;
+    }
 }
 
 void Normalizer2DataBuilder::setHangulData() {
@@ -407,8 +491,8 @@ void Normalizer2DataBuilder::setHangulData() {
     const HangulIterator::Range *range;
     // Check that none of the Hangul/Jamo code points have data.
     while((range=hi.nextRange())!=NULL) {
-        for(UChar32 c=range->start; c<range->limit; ++c) {
-            if(utrie2_get32(norm16Trie, c)!=0) {
+        for(UChar32 c=range->start; c<=range->end; ++c) {
+            if(utrie2_get32(norm16Trie, c)>Normalizer2Impl::INERT) {
                 fprintf(stderr,
                         "gennorm2 error: "
                         "illegal mapping/composition/ccc data for Hangul or Jamo U+%04lX\n",
@@ -419,32 +503,62 @@ void Normalizer2DataBuilder::setHangulData() {
     }
     // Set data for algorithmic runtime handling.
     IcuToolErrorCode errorCode("gennorm2/setHangulData()");
-    hi.reset();
-    while((range=hi.nextRange())!=NULL) {
-        uint16_t norm16=range->norm16;
-        if(norm16==0) {
-            norm16=(uint16_t)indexes[Normalizer2Impl::IX_MIN_YES_NO];  // Hangul LV/LVT encoded as minYesNo
-            if(range->start<indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]) {
-                indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=range->start;
-            }
-        } else {
-            if(range->start<indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]) {  // Jamo V/T are maybeYes
-                indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=range->start;
-            }
-        }
-        utrie2_setRange32(norm16Trie, range->start, range->limit-1, norm16, TRUE, errorCode);
-        errorCode.assertSuccess();
+
+    // Jamo V/T are maybeYes
+    if(Hangul::JAMO_V_BASE<indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]) {
+        indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=Hangul::JAMO_V_BASE;
     }
+    utrie2_setRange32(norm16Trie, Hangul::JAMO_L_BASE, Hangul::JAMO_L_END,
+                      Normalizer2Impl::JAMO_L, TRUE, errorCode);
+    utrie2_setRange32(norm16Trie, Hangul::JAMO_V_BASE, Hangul::JAMO_V_END,
+                      Normalizer2Impl::JAMO_VT, TRUE, errorCode);
+    // JAMO_T_BASE+1: not U+11A7
+    utrie2_setRange32(norm16Trie, Hangul::JAMO_T_BASE+1, Hangul::JAMO_T_END,
+                      Normalizer2Impl::JAMO_VT, TRUE, errorCode);
+
+    // Hangul LV encoded as minYesNo
+    uint32_t lv=indexes[Normalizer2Impl::IX_MIN_YES_NO];
+    // Hangul LVT encoded as minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER
+    uint32_t lvt=indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]|
+        Normalizer2Impl::HAS_COMP_BOUNDARY_AFTER;
+    if(Hangul::HANGUL_BASE<indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]) {
+        indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=Hangul::HANGUL_BASE;
+    }
+    // Set the first LV, then write all other Hangul syllables as LVT,
+    // then overwrite the remaining LV.
+    // The UTrie2 should be able to compact this into 7 32-item blocks
+    // because JAMO_T_COUNT is 28 and the UTrie2 granularity is 4.
+    // (7*32=8*28 smallest common multiple)
+    utrie2_set32(norm16Trie, Hangul::HANGUL_BASE, lv, errorCode);
+    utrie2_setRange32(norm16Trie, Hangul::HANGUL_BASE+1, Hangul::HANGUL_END,
+                      lvt, TRUE, errorCode);
+    UChar32 c=Hangul::HANGUL_BASE;
+    while((c+=Hangul::JAMO_T_COUNT)<=Hangul::HANGUL_END) {
+        utrie2_set32(norm16Trie, c, lv, errorCode);
+    }
+    errorCode.assertSuccess();
 }
 
+namespace {
+
+struct Norm16Summary {
+    uint32_t maxNorm16;
+    // ANDing values yields 0 bits where any value has a 0.
+    // Used for worst-case HAS_COMP_BOUNDARY_AFTER.
+    uint32_t andedNorm16;
+};
+
+}  // namespace
+
 U_CDECL_BEGIN
 
 static UBool U_CALLCONV
 enumRangeMaxValue(const void *context, UChar32 /*start*/, UChar32 /*end*/, uint32_t value) {
-    uint32_t *pMaxValue=(uint32_t *)context;
-    if(value>*pMaxValue) {
-        *pMaxValue=value;
+    Norm16Summary *p=(Norm16Summary *)context;
+    if(value>p->maxNorm16) {
+        p->maxNorm16=value;
     }
+    p->andedNorm16&=value;
     return TRUE;
 }
 
@@ -452,7 +566,7 @@ U_CDECL_END
 
 void Normalizer2DataBuilder::processData() {
     IcuToolErrorCode errorCode("gennorm2/processData()");
-    norm16Trie=utrie2_open(0, 0, errorCode);
+    norm16Trie=utrie2_open(Normalizer2Impl::INERT, Normalizer2Impl::INERT, errorCode);
     errorCode.assertSuccess();
 
     // Build composition lists before recursive decomposition,
@@ -479,26 +593,37 @@ void Normalizer2DataBuilder::processData() {
     norms.enumRanges(extra);
 
     extraData=extra.yesYesCompositions;
-    indexes[Normalizer2Impl::IX_MIN_YES_NO]=extraData.length();
+    indexes[Normalizer2Impl::IX_MIN_YES_NO]=extraData.length()*2;
     extraData.append(extra.yesNoMappingsAndCompositions);
-    indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]=extraData.length();
+    indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]=extraData.length()*2;
     extraData.append(extra.yesNoMappingsOnly);
-    // TODO: minMappingNotCompYes, minMappingNoCompBoundaryBefore
-    indexes[Normalizer2Impl::IX_MIN_NO_NO]=extraData.length();
-    extraData.append(extra.noNoMappings);
-    indexes[Normalizer2Impl::IX_LIMIT_NO_NO]=extraData.length();
+    indexes[Normalizer2Impl::IX_MIN_NO_NO]=extraData.length()*2;
+    extraData.append(extra.noNoMappingsCompYes);
+    indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE]=extraData.length()*2;
+    extraData.append(extra.noNoMappingsCompBoundaryBefore);
+    indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_NO_MAYBE_CC]=extraData.length()*2;
+    extraData.append(extra.noNoMappingsCompNoMaybeCC);
+    indexes[Normalizer2Impl::IX_MIN_NO_NO_EMPTY]=extraData.length()*2;
+    extraData.append(extra.noNoMappingsEmpty);
+    indexes[Normalizer2Impl::IX_LIMIT_NO_NO]=extraData.length()*2;
 
+    // Pad the maybeYesCompositions length to a multiple of 4,
+    // so that NO_NO_DELTA bits 2..1 can be used without subtracting the center.
+    while(extra.maybeYesCompositions.length()&3) {
+        extra.maybeYesCompositions.append((UChar)0);
+    }
     extraData.insert(0, extra.maybeYesCompositions);
     indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]=
         Normalizer2Impl::MIN_NORMAL_MAYBE_YES-
-        extra.maybeYesCompositions.length();
+        extra.maybeYesCompositions.length()*2;
 
     // Pad to even length for 4-byte alignment of following data.
     if(extraData.length()&1) {
         extraData.append((UChar)0);
     }
 
-    int32_t minNoNoDelta=getCenterNoNoDelta()-Normalizer2Impl::MAX_DELTA;
+    int32_t minNoNoDelta=getMinNoNoDelta();
+    U_ASSERT((minNoNoDelta&7)==0);
     if(indexes[Normalizer2Impl::IX_LIMIT_NO_NO]>minNoNoDelta) {
         fprintf(stderr,
                 "gennorm2 error: "
@@ -509,6 +634,7 @@ void Normalizer2DataBuilder::processData() {
     // writeNorm16() and setHangulData() reduce these as needed.
     indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=0x110000;
     indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=0x110000;
+    indexes[Normalizer2Impl::IX_MIN_LCCC_CP]=0x110000;
 
     // Map each code point to its norm16 value,
     // including the properties that fit directly,
@@ -529,17 +655,21 @@ void Normalizer2DataBuilder::processData() {
     // inner loops if necessary.
     // However, that seems like overkill for an optimization for supplementary characters.
     for(UChar lead=0xd800; lead<0xdc00; ++lead) {
-        uint32_t maxValue=utrie2_get32(norm16Trie, lead);
-        utrie2_enumForLeadSurrogate(norm16Trie, lead, NULL, enumRangeMaxValue, &maxValue);
-        if( maxValue>=(uint32_t)indexes[Normalizer2Impl::IX_LIMIT_NO_NO] &&
-            maxValue>(uint32_t)indexes[Normalizer2Impl::IX_MIN_NO_NO]
-        ) {
+        uint32_t surrogateCPNorm16=utrie2_get32(norm16Trie, lead);
+        Norm16Summary summary={ surrogateCPNorm16, surrogateCPNorm16 };
+        utrie2_enumForLeadSurrogate(norm16Trie, lead, NULL, enumRangeMaxValue, &summary);
+        uint32_t norm16=summary.maxNorm16;
+        if(norm16>=(uint32_t)indexes[Normalizer2Impl::IX_LIMIT_NO_NO] &&
+                norm16>(uint32_t)indexes[Normalizer2Impl::IX_MIN_NO_NO]) {
             // Set noNo ("worst" value) if it got into "less-bad" maybeYes or ccc!=0.
             // Otherwise it might end up at something like JAMO_VT which stays in
             // the inner decomposition quick check loop.
-            maxValue=(uint32_t)indexes[Normalizer2Impl::IX_LIMIT_NO_NO]-1;
+            norm16=(uint32_t)indexes[Normalizer2Impl::IX_LIMIT_NO_NO]-1;
         }
-        utrie2_set32ForLeadSurrogateCodeUnit(norm16Trie, lead, maxValue, errorCode);
+        norm16=
+            (norm16&~Normalizer2Impl::HAS_COMP_BOUNDARY_AFTER)|
+            (summary.andedNorm16&Normalizer2Impl::HAS_COMP_BOUNDARY_AFTER);
+        utrie2_set32ForLeadSurrogateCodeUnit(norm16Trie, lead, norm16, errorCode);
     }
 
     // Adjust supplementary minimum code points to break quick check loops at their lead surrogates.
@@ -554,6 +684,10 @@ void Normalizer2DataBuilder::processData() {
     if(minCP>=0x10000) {
         indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=U16_LEAD(minCP);
     }
+    minCP=indexes[Normalizer2Impl::IX_MIN_LCCC_CP];
+    if(minCP>=0x10000) {
+        indexes[Normalizer2Impl::IX_MIN_LCCC_CP]=U16_LEAD(minCP);
+    }
 
     utrie2_freeze(norm16Trie, UTRIE2_16_VALUE_BITS, errorCode);
     norm16TrieLength=utrie2_serialize(norm16Trie, NULL, 0, errorCode);
@@ -583,11 +717,15 @@ void Normalizer2DataBuilder::processData() {
         printf("size of binary data file contents:  %5ld bytes\n", (long)totalSize);
         printf("minDecompNoCodePoint:              U+%04lX\n", (long)indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]);
         printf("minCompNoMaybeCodePoint:           U+%04lX\n", (long)indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]);
-        printf("minYesNo:                          0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_YES_NO]);
+        printf("minLcccCodePoint:                  U+%04lX\n", (long)indexes[Normalizer2Impl::IX_MIN_LCCC_CP]);
+        printf("minYesNo: (with compositions)      0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_YES_NO]);
         printf("minYesNoMappingsOnly:              0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]);
-        // TODO: minMappingNotCompYes, minMappingNoCompBoundaryBefore
-        printf("minNoNo:                           0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO]);
+        printf("minNoNo: (comp-normalized)         0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO]);
+        printf("minNoNoCompBoundaryBefore:         0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE]);
+        printf("minNoNoCompNoMaybeCC:              0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_NO_MAYBE_CC]);
+        printf("minNoNoEmpty:                      0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO_EMPTY]);
         printf("limitNoNo:                         0x%04x\n", (int)indexes[Normalizer2Impl::IX_LIMIT_NO_NO]);
+        printf("minNoNoDelta:                      0x%04x\n", (int)minNoNoDelta);
         printf("minMaybeYes:                       0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]);
     }
 
diff --git a/icu4c/source/tools/gennorm2/n2builder.h b/icu4c/source/tools/gennorm2/n2builder.h
index 1fca0b70571..c1421599dac 100644
--- a/icu4c/source/tools/gennorm2/n2builder.h
+++ b/icu4c/source/tools/gennorm2/n2builder.h
@@ -73,22 +73,21 @@ private:
     Norm *checkNormForMapping(Norm *p, UChar32 c);  // check for permitted overrides
 
     /**
-     * Computes the MAPPING_NO_COMP_BOUNDARY_AFTER flag for a character's mapping
-     * (especially for a "YesNo" which has a round-trip mapping).
-     * This flag is used in Normalizer2Impl::hasCompBoundaryAfter().
-     *
      * A starter character with a mapping does not have a composition boundary after it
      * if the character itself combines-forward (which is tested by the caller of this function),
      * or it is deleted (mapped to the empty string),
      * or its mapping contains no starter,
      * or the last starter combines-forward.
      */
-    UBool hasNoCompBoundaryAfter(const BuilderReorderingBuffer &buffer);
+    UBool mappingHasCompBoundaryAfter(const BuilderReorderingBuffer &buffer) const;
+    /** Returns TRUE if the mapping by itself recomposes, that is, it is not comp-normalized. */
+    UBool mappingRecomposes(const BuilderReorderingBuffer &buffer) const;
     void postProcess(Norm &norm);
 
     void setSmallFCD(UChar32 c);
-    int32_t getCenterNoNoDelta() {
-        return indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]-Normalizer2Impl::MAX_DELTA-1;
+    int32_t getMinNoNoDelta() const {
+        return indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]-
+            ((2*Normalizer2Impl::MAX_DELTA+1)<<Normalizer2Impl::DELTA_SHIFT);
     }
     void writeNorm16(UChar32 start, UChar32 end, Norm &norm);
     void setHangulData();
diff --git a/icu4c/source/tools/gennorm2/norms.cpp b/icu4c/source/tools/gennorm2/norms.cpp
index f5a3809ee43..f0fb291aac3 100644
--- a/icu4c/source/tools/gennorm2/norms.cpp
+++ b/icu4c/source/tools/gennorm2/norms.cpp
@@ -99,6 +99,14 @@ Norm *Norms::getNorm(UChar32 c) {
     return norms+i;
 }
 
+const Norm *Norms::getNorm(UChar32 c) const {
+    uint32_t i=utrie2_get32(normTrie, c);
+    if(i==0) {
+        return nullptr;
+    }
+    return norms+i;
+}
+
 const Norm &Norms::getNormRef(UChar32 c) const {
     return norms[utrie2_get32(normTrie, c)];
 }
@@ -118,9 +126,7 @@ Norm *Norms::createNorm(UChar32 c) {
 
 void Norms::reorder(UnicodeString &mapping, BuilderReorderingBuffer &buffer) const {
     int32_t length=mapping.length();
-    if(length>Normalizer2Impl::MAPPING_LENGTH_MASK) {
-        return;  // writeMapping() will complain about it and print the code point.
-    }
+    U_ASSERT(length<=Normalizer2Impl::MAPPING_LENGTH_MASK);
     const char16_t *s=mapping.getBuffer();
     int32_t i=0;
     UChar32 c;
diff --git a/icu4c/source/tools/gennorm2/norms.h b/icu4c/source/tools/gennorm2/norms.h
index 052298ed7ed..d41e9329967 100644
--- a/icu4c/source/tools/gennorm2/norms.h
+++ b/icu4c/source/tools/gennorm2/norms.h
@@ -89,7 +89,7 @@ struct Norm {
     UVector32 *compositions;  // (trail, composite) pairs
     uint8_t cc, leadCC, trailCC;
     UBool combinesBack;
-    UBool hasNoCompBoundaryAfter;
+    UBool hasCompBoundaryBefore, hasCompBoundaryAfter;
 
     /**
      * Overall type of normalization properties.
@@ -112,9 +112,14 @@ struct Norm {
         YES_NO_COMBINES_FWD,
         /** Starter with a round-trip mapping but no compositions. */
         YES_NO_MAPPING_ONLY,
-        // TODO: minMappingNotCompYes, minMappingNoCompBoundaryBefore
-        /** Has a one-way mapping. */
-        NO_NO,
+        /** Has a one-way mapping which is comp-normalized. */
+        NO_NO_COMP_YES,
+        /** Has a one-way mapping which is not comp-normalized but has a comp boundary before. */
+        NO_NO_COMP_BOUNDARY_BEFORE,
+        /** Has a one-way mapping which does not have a comp boundary before. */
+        NO_NO_COMP_NO_MAYBE_CC,
+        /** Has a one-way mapping to the empty string. */
+        NO_NO_EMPTY,
         /** Has an algorithmic one-way mapping to a single code point. */
         NO_NO_DELTA,
         /**
@@ -149,11 +154,15 @@ public:
     Norm *allocNorm();
     /** Returns an existing Norm unit, or nullptr if c has no data. */
     Norm *getNorm(UChar32 c);
+    const Norm *getNorm(UChar32 c) const;
     /** Returns a Norm unit, creating a new one if necessary. */
     Norm *createNorm(UChar32 c);
     /** Returns an existing Norm unit, or an immutable empty object if c has no data. */
     const Norm &getNormRef(UChar32 c) const;
     uint8_t getCC(UChar32 c) const { return getNormRef(c).cc; }
+    UBool combinesBack(UChar32 c) const {
+        return Hangul::isJamoV(c) || Hangul::isJamoT(c) || getNormRef(c).combinesBack;
+    }
 
     void reorder(UnicodeString &mapping, BuilderReorderingBuffer &buffer) const;
 
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/impl/Norm2AllModes.java b/icu4j/main/classes/core/src/com/ibm/icu/impl/Norm2AllModes.java
index a3ac7a3d513..8ae6ca919dd 100644
--- a/icu4j/main/classes/core/src/com/ibm/icu/impl/Norm2AllModes.java
+++ b/icu4j/main/classes/core/src/com/ibm/icu/impl/Norm2AllModes.java
@@ -185,9 +185,9 @@ public final class Norm2AllModes {
             return impl.isDecompYes(impl.getNorm16(c)) ? 1 : 0;
         }
         @Override
-        public boolean hasBoundaryBefore(int c) { return impl.hasDecompBoundary(c, true); }
+        public boolean hasBoundaryBefore(int c) { return impl.hasDecompBoundaryBefore(c); }
         @Override
-        public boolean hasBoundaryAfter(int c) { return impl.hasDecompBoundary(c, false); }
+        public boolean hasBoundaryAfter(int c) { return impl.hasDecompBoundaryAfter(c); }
         @Override
         public boolean isInert(int c) { return impl.isDecompInert(c); }
     }
@@ -238,11 +238,11 @@ public final class Norm2AllModes {
         public boolean hasBoundaryBefore(int c) { return impl.hasCompBoundaryBefore(c); }
         @Override
         public boolean hasBoundaryAfter(int c) {
-            return impl.hasCompBoundaryAfter(c, onlyContiguous, false);
+            return impl.hasCompBoundaryAfter(c, onlyContiguous);
         }
         @Override
         public boolean isInert(int c) {
-            return impl.hasCompBoundaryAfter(c, onlyContiguous, true);
+            return impl.isCompInert(c, onlyContiguous);
         }
 
         private final boolean onlyContiguous;
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/impl/Normalizer2Impl.java b/icu4j/main/classes/core/src/com/ibm/icu/impl/Normalizer2Impl.java
index e0670b96124..9cb231590b1 100644
--- a/icu4j/main/classes/core/src/com/ibm/icu/impl/Normalizer2Impl.java
+++ b/icu4j/main/classes/core/src/com/ibm/icu/impl/Normalizer2Impl.java
@@ -19,6 +19,12 @@ import com.ibm.icu.text.UnicodeSet;
 import com.ibm.icu.util.ICUUncheckedIOException;
 import com.ibm.icu.util.VersionInfo;
 
+/**
+ * Low-level implementation of the Unicode Normalization Algorithm.
+ * For the data structure and details see the documentation at the end of
+ * C++ normalizer2impl.h and in the design doc at
+ * http://site.icu-project.org/design/normalization/custom
+ */
 public final class Normalizer2Impl {
     public static final class Hangul {
         /* Korean Hangul and Jamo constants */
@@ -47,9 +53,9 @@ public final class Normalizer2Impl {
         public static boolean isHangul(int c) {
             return HANGUL_BASE<=c && c<HANGUL_LIMIT;
         }
-        public static boolean isHangulWithoutJamoT(char c) {
+        public static boolean isHangulLV(int c) {
             c-=HANGUL_BASE;
-            return c<HANGUL_COUNT && c%JAMO_T_COUNT==0;
+            return 0<=c && c<HANGUL_COUNT && c%JAMO_T_COUNT==0;
         }
         public static boolean isJamoL(int c) {
             return JAMO_L_BASE<=c && c<JAMO_L_LIMIT;
@@ -57,6 +63,14 @@ public final class Normalizer2Impl {
         public static boolean isJamoV(int c) {
             return JAMO_V_BASE<=c && c<JAMO_V_LIMIT;
         }
+        public static boolean isJamoT(int c) {
+            int t=c-JAMO_T_BASE;
+            return 0<t && t<JAMO_T_COUNT;  // not JAMO_T_BASE itself
+        }
+        public static boolean isJamo(int c) {
+            return JAMO_L_BASE<=c && c<=JAMO_T_END &&
+                (c<=JAMO_L_END || (JAMO_V_BASE<=c && c<=JAMO_V_END) || JAMO_T_BASE<c);
+        }
 
         /**
          * Decomposes c, which must be a Hangul syllable, into buffer
@@ -155,11 +169,6 @@ public final class Normalizer2Impl {
             return UTF16Plus.equal(str, 0, str.length(), s, start, limit);
         }
 
-        // For Hangul composition, replacing the Leading consonant Jamo with the syllable.
-        public void setLastChar(char c) {
-            str.setCharAt(str.length()-1, c);
-        }
-
         public void append(int c, int cc) {
             if(lastCC<=cc || cc==0) {
                 str.appendCodePoint(c);
@@ -205,7 +214,6 @@ public final class Normalizer2Impl {
         // The following append() methods work like C++ appendZeroCC().
         // They assume that the cc or trailCC of their input is 0.
         // Most of them implement Appendable interface methods.
-        // @Override when we switch to Java 6
         @Override
         public ReorderingBuffer append(char c) {
             str.append(c);
@@ -218,7 +226,6 @@ public final class Normalizer2Impl {
             lastCC=0;
             reorderStart=str.length();
         }
-        // @Override when we switch to Java 6
         @Override
         public ReorderingBuffer append(CharSequence s) {
             if(s.length()!=0) {
@@ -228,7 +235,6 @@ public final class Normalizer2Impl {
             }
             return this;
         }
-        // @Override when we switch to Java 6
         @Override
         public ReorderingBuffer append(CharSequence s, int start, int limit) {
             if(start!=limit) {
@@ -343,10 +349,7 @@ public final class Normalizer2Impl {
             }
             int c=str.codePointBefore(codePointStart);
             codePointStart-=Character.charCount(c);
-            if(c<MIN_CCC_LCCC_CP) {
-                return 0;
-            }
-            return getCCFromYesOrMaybe(impl.getNorm16(c));
+            return impl.getCCFromYesOrMaybeCP(c);
         }
 
         private int codePointStart, codePointLimit;
@@ -415,10 +418,9 @@ public final class Normalizer2Impl {
     public Normalizer2Impl() {}
 
     private static final class IsAcceptable implements ICUBinary.Authenticate {
-        // @Override when we switch to Java 6
         @Override
         public boolean isDataVersionAcceptable(byte version[]) {
-            return version[0]==2;
+            return version[0]==3;
         }
     }
     private static final IsAcceptable IS_ACCEPTABLE = new IsAcceptable();
@@ -428,7 +430,7 @@ public final class Normalizer2Impl {
         try {
             dataVersion=ICUBinary.readHeaderAndDataVersion(bytes, DATA_FORMAT, IS_ACCEPTABLE);
             int indexesLength=bytes.getInt()/4;  // inIndexes[IX_NORM_TRIE_OFFSET]/4
-            if(indexesLength<=IX_MIN_YES_NO_MAPPINGS_ONLY) {
+            if(indexesLength<=IX_MIN_LCCC_CP) {
                 throw new ICUUncheckedIOException("Normalizer2 data: not enough indexes");
             }
             int[] inIndexes=new int[indexesLength];
@@ -439,12 +441,18 @@ public final class Normalizer2Impl {
 
             minDecompNoCP=inIndexes[IX_MIN_DECOMP_NO_CP];
             minCompNoMaybeCP=inIndexes[IX_MIN_COMP_NO_MAYBE_CP];
+            minLcccCP=inIndexes[IX_MIN_LCCC_CP];
 
             minYesNo=inIndexes[IX_MIN_YES_NO];
             minYesNoMappingsOnly=inIndexes[IX_MIN_YES_NO_MAPPINGS_ONLY];
             minNoNo=inIndexes[IX_MIN_NO_NO];
+            minNoNoCompBoundaryBefore=inIndexes[IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE];
+            minNoNoCompNoMaybeCC=inIndexes[IX_MIN_NO_NO_COMP_NO_MAYBE_CC];
+            minNoNoEmpty=inIndexes[IX_MIN_NO_NO_EMPTY];
             limitNoNo=inIndexes[IX_LIMIT_NO_NO];
             minMaybeYes=inIndexes[IX_MIN_MAYBE_YES];
+            assert((minMaybeYes&7)==0);  // 8-aligned for noNoDelta bit fields
+            centerNoNoDelta=(minMaybeYes>>DELTA_SHIFT)-MAX_DELTA-1;
 
             // Read the normTrie.
             int offset=inIndexes[IX_NORM_TRIE_OFFSET];
@@ -462,7 +470,7 @@ public final class Normalizer2Impl {
             int numChars=(nextOffset-offset)/2;
             if(numChars!=0) {
                 maybeYesCompositions=ICUBinary.getString(bytes, numChars, 0);
-                extraData=maybeYesCompositions.substring(MIN_NORMAL_MAYBE_YES-minMaybeYes);
+                extraData=maybeYesCompositions.substring((MIN_NORMAL_MAYBE_YES-minMaybeYes)>>OFFSET_SHIFT);
             }
 
             // smallFCD: new in formatVersion 2
@@ -470,23 +478,6 @@ public final class Normalizer2Impl {
             smallFCD=new byte[0x100];
             bytes.get(smallFCD);
 
-            // Build tccc180[].
-            // gennorm2 enforces lccc=0 for c<MIN_CCC_LCCC_CP=U+0300.
-            tccc180=new int[0x180];
-            int bits=0;
-            for(int c=0; c<0x180; bits>>=1) {
-                if((c&0xff)==0) {
-                    bits=smallFCD[c>>8];  // one byte per 0x100 code points
-                }
-                if((bits&1)!=0) {
-                    for(int i=0; i<0x20; ++i, ++c) {
-                        tccc180[c]=getFCD16FromNormData(c)&0xff;
-                    }
-                } else {
-                    c+=0x20;
-                }
-            }
-
             return this;
         } catch(IOException e) {
             throw new ICUUncheckedIOException(e);
@@ -497,14 +488,9 @@ public final class Normalizer2Impl {
     }
 
     private void enumLcccRange(int start, int end, int norm16, UnicodeSet set) {
-        if(isAlgorithmicNoNo(norm16)) {
-            // Range of code points with same-norm16-value algorithmic decompositions.
-            // They might have different non-zero FCD16 values.
-            do {
-                int fcd16=getFCD16(start);
-                if(fcd16>0xff) { set.add(start); }
-            } while(++start<=end);
-        } else {
+        if (norm16 > MIN_NORMAL_MAYBE_YES && norm16 != JAMO_VT) {
+            set.add(start, end);
+        } else if (minNoNoCompNoMaybeCC <= norm16 && norm16 < limitNoNo) {
             int fcd16=getFCD16(start);
             if(fcd16>0xff) { set.add(start, end); }
         }
@@ -513,7 +499,7 @@ public final class Normalizer2Impl {
     private void enumNorm16PropertyStartsRange(int start, int end, int value, UnicodeSet set) {
         /* add the start code point to the USet */
         set.add(start);
-        if(start!=end && isAlgorithmicNoNo(value)) {
+        if(start!=end && isAlgorithmicNoNo(value) && (value & DELTA_TCCC_MASK) > DELTA_TCCC_1) {
             // Range of code points with same-norm16-value algorithmic decompositions.
             // They might have different non-zero FCD16 values.
             int prevFCD16=getFCD16(start);
@@ -528,7 +514,6 @@ public final class Normalizer2Impl {
     }
 
     public void addLcccChars(UnicodeSet set) {
-        /* add the start code point of each same-value range of each trie */
         Iterator<Trie2.Range> trieIterator=normTrie.iterator();
         Trie2.Range range;
         while(trieIterator.hasNext() && !(range=trieIterator.next()).leadSurrogate) {
@@ -572,15 +557,13 @@ public final class Normalizer2Impl {
 
     // low-level properties ------------------------------------------------ ***
 
-    public Trie2_16 getNormTrie() { return normTrie; }
-
     // Note: Normalizer2Impl.java r30983 (2011-nov-27)
     // still had getFCDTrie() which built and cached an FCD trie.
     // That provided faster access to FCD data than getFCD16FromNormData()
     // but required synchronization and consumed some 10kB of heap memory
     // in any process that uses FCD (e.g., via collation).
-    // tccc180[] and smallFCD[] are intended to help with any loss of performance,
-    // at least for Latin & CJK.
+    // minDecompNoCP etc. and smallFCD[] are intended to help with any loss of performance,
+    // at least for ASCII & CJK.
 
     /**
      * Builds the canonical-iterator data for this instance.
@@ -597,7 +580,7 @@ public final class Normalizer2Impl {
             Trie2.Range range;
             while(trieIterator.hasNext() && !(range=trieIterator.next()).leadSurrogate) {
                 final int norm16=range.value;
-                if(norm16==0 || (minYesNo<=norm16 && norm16<minNoNo)) {
+                if(isInert(norm16) || (minYesNo<=norm16 && norm16<minNoNo)) {
                     // Inert, or 2-way mapping (including Hangul syllable).
                     // We do not write a canonStartSet for any yesNo character.
                     // Composites from 2-way mappings are added at runtime from the
@@ -609,7 +592,7 @@ public final class Normalizer2Impl {
                 for(int c=range.startCodePoint; c<=range.endCodePoint; ++c) {
                     final int oldValue=newData.get(c);
                     int newValue=oldValue;
-                    if(norm16>=minMaybeYes) {
+                    if(isMaybeOrNonZeroCC(norm16)) {
                         // not a segment starter if it occurs in a decomposition or has cc!=0
                         newValue|=CANON_NOT_SEGMENT_STARTER;
                         if(norm16<MIN_NORMAL_MAYBE_YES) {
@@ -620,33 +603,38 @@ public final class Normalizer2Impl {
                     } else {
                         // c has a one-way decomposition
                         int c2=c;
+                        // Do not modify the whole-range norm16 value.
                         int norm16_2=norm16;
-                        while(limitNoNo<=norm16_2 && norm16_2<minMaybeYes) {
-                            c2=this.mapAlgorithmic(c2, norm16_2);
-                            norm16_2=getNorm16(c2);
+                        if (isDecompNoAlgorithmic(norm16_2)) {
+                            // Maps to an isCompYesAndZeroCC.
+                            c2 = mapAlgorithmic(c2, norm16_2);
+                            norm16_2 = getNorm16(c2);
+                            // No compatibility mappings for the CanonicalIterator.
+                            assert(!(isHangulLV(norm16_2) || isHangulLVT(norm16_2)));
                         }
-                        if(minYesNo<=norm16_2 && norm16_2<limitNoNo) {
+                        if (norm16_2 > minYesNo) {
                             // c decomposes, get everything from the variable-length extra data
-                            int firstUnit=extraData.charAt(norm16_2);
+                            int mapping=norm16_2>>OFFSET_SHIFT;
+                            int firstUnit=extraData.charAt(mapping);
                             int length=firstUnit&MAPPING_LENGTH_MASK;
                             if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
-                                if(c==c2 && (extraData.charAt(norm16_2-1)&0xff)!=0) {
+                                if(c==c2 && (extraData.charAt(mapping-1)&0xff)!=0) {
                                     newValue|=CANON_NOT_SEGMENT_STARTER;  // original c has cc!=0
                                 }
                             }
                             // Skip empty mappings (no characters in the decomposition).
                             if(length!=0) {
-                                ++norm16_2;  // skip over the firstUnit
+                                ++mapping;  // skip over the firstUnit
                                 // add c to first code point's start set
-                                int limit=norm16_2+length;
-                                c2=extraData.codePointAt(norm16_2);
+                                int limit=mapping+length;
+                                c2=extraData.codePointAt(mapping);
                                 addToStartSet(newData, c, c2);
                                 // Set CANON_NOT_SEGMENT_STARTER for each remaining code point of a
                                 // one-way mapping. A 2-way mapping is possible here after
                                 // intermediate algorithmic mapping.
                                 if(norm16_2>=minNoNo) {
-                                    while((norm16_2+=Character.charCount(c2))<limit) {
-                                        c2=extraData.codePointAt(norm16_2);
+                                    while((mapping+=Character.charCount(c2))<limit) {
+                                        c2=extraData.codePointAt(mapping);
                                         int c2Value=newData.get(c2);
                                         if((c2Value&CANON_NOT_SEGMENT_STARTER)==0) {
                                             newData.set(c2, c2Value|CANON_NOT_SEGMENT_STARTER);
@@ -686,15 +674,22 @@ public final class Normalizer2Impl {
 
     public int getCC(int norm16) {
         if(norm16>=MIN_NORMAL_MAYBE_YES) {
-            return norm16&0xff;
+            return getCCFromNormalYesOrMaybe(norm16);
         }
         if(norm16<minNoNo || limitNoNo<=norm16) {
             return 0;
         }
         return getCCFromNoNo(norm16);
     }
+    public static int getCCFromNormalYesOrMaybe(int norm16) {
+        return (norm16 >> OFFSET_SHIFT) & 0xff;
+    }
     public static int getCCFromYesOrMaybe(int norm16) {
-        return norm16>=MIN_NORMAL_MAYBE_YES ? norm16&0xff : 0;
+        return norm16>=MIN_NORMAL_MAYBE_YES ? getCCFromNormalYesOrMaybe(norm16) : 0;
+    }
+    public int getCCFromYesOrMaybeCP(int c) {
+        if (c < minCompNoMaybeCP) { return 0; }
+        return getCCFromYesOrMaybe(getNorm16(c));
     }
 
     /**
@@ -703,17 +698,13 @@ public final class Normalizer2Impl {
      * @return The lccc(c) in bits 15..8 and tccc(c) in bits 7..0.
      */
     public int getFCD16(int c) {
-        if(c<0) {
+        if(c<minDecompNoCP) {
             return 0;
-        } else if(c<0x180) {
-            return tccc180[c];
         } else if(c<=0xffff) {
             if(!singleLeadMightHaveNonZeroFCD16(c)) { return 0; }
         }
         return getFCD16FromNormData(c);
     }
-    /** Returns the FCD data for U+0000<=c<U+0180. */
-    public int getFCD16FromBelow180(int c) { return tccc180[c]; }
     /** Returns true if the single-or-lead code unit c might have non-zero FCD data. */
     public boolean singleLeadMightHaveNonZeroFCD16(int lead) {
         // 0<=lead<=0xffff
@@ -724,37 +715,36 @@ public final class Normalizer2Impl {
 
     /** Gets the FCD value from the regular normalization data. */
     public int getFCD16FromNormData(int c) {
-        // Only loops for 1:1 algorithmic mappings.
-        for(;;) {
-            int norm16=getNorm16(c);
-            if(norm16<=minYesNo) {
-                // no decomposition or Hangul syllable, all zeros
-                return 0;
-            } else if(norm16>=MIN_NORMAL_MAYBE_YES) {
+        int norm16=getNorm16(c);
+        if (norm16 >= limitNoNo) {
+            if(norm16>=MIN_NORMAL_MAYBE_YES) {
                 // combining mark
-                norm16&=0xff;
+                norm16=getCCFromNormalYesOrMaybe(norm16);
                 return norm16|(norm16<<8);
             } else if(norm16>=minMaybeYes) {
                 return 0;
-            } else if(isDecompNoAlgorithmic(norm16)) {
-                c=mapAlgorithmic(c, norm16);
-            } else {
-                // c decomposes, get everything from the variable-length extra data
-                int firstUnit=extraData.charAt(norm16);
-                if((firstUnit&MAPPING_LENGTH_MASK)==0) {
-                    // A character that is deleted (maps to an empty string) must
-                    // get the worst-case lccc and tccc values because arbitrary
-                    // characters on both sides will become adjacent.
-                    return 0x1ff;
-                } else {
-                    int fcd16=firstUnit>>8;  // tccc
-                    if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
-                        fcd16|=extraData.charAt(norm16-1)&0xff00;  // lccc
-                    }
-                    return fcd16;
+            } else {  // isDecompNoAlgorithmic(norm16)
+                int deltaTrailCC = norm16 & DELTA_TCCC_MASK;
+                if (deltaTrailCC <= DELTA_TCCC_1) {
+                    return deltaTrailCC >> OFFSET_SHIFT;
                 }
+                // Maps to an isCompYesAndZeroCC.
+                c=mapAlgorithmic(c, norm16);
+                norm16=getNorm16(c);
             }
         }
+        if(norm16<=minYesNo || isHangulLVT(norm16)) {
+            // no decomposition or Hangul syllable, all zeros
+            return 0;
+        }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int firstUnit=extraData.charAt(mapping);
+        int fcd16=firstUnit>>8;  // tccc
+        if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
+            fcd16|=extraData.charAt(mapping-1)&0xff00;  // lccc
+        }
+        return fcd16;
     }
 
     /**
@@ -763,30 +753,34 @@ public final class Normalizer2Impl {
      * @return c's decomposition, if it has one; returns null if it does not have a decomposition
      */
     public String getDecomposition(int c) {
-        int decomp=-1;
         int norm16;
-        for(;;) {
-            if(c<minDecompNoCP || isDecompYes(norm16=getNorm16(c))) {
-                // c does not decompose
-            } else if(isHangul(norm16)) {
-                // Hangul syllable: decompose algorithmically
-                StringBuilder buffer=new StringBuilder();
-                Hangul.decompose(c, buffer);
-                return buffer.toString();
-            } else if(isDecompNoAlgorithmic(norm16)) {
-                decomp=c=mapAlgorithmic(c, norm16);
-                continue;
-            } else {
-                // c decomposes, get everything from the variable-length extra data
-                int length=extraData.charAt(norm16++)&MAPPING_LENGTH_MASK;
-                return extraData.substring(norm16, norm16+length);
-            }
+        if(c<minDecompNoCP || isMaybeOrNonZeroCC(norm16=getNorm16(c))) {
+            // c does not decompose
+            return null;
+        }
+        int decomp = -1;
+        if(isDecompNoAlgorithmic(norm16)) {
+            // Maps to an isCompYesAndZeroCC.
+            decomp=c=mapAlgorithmic(c, norm16);
+            // The mapping might decompose further.
+            norm16 = getNorm16(c);
+        }
+        if (norm16 < minYesNo) {
             if(decomp<0) {
                 return null;
             } else {
                 return UTF16.valueOf(decomp);
             }
+        } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
+            // Hangul syllable: decompose algorithmically
+            StringBuilder buffer=new StringBuilder();
+            Hangul.decompose(c, buffer);
+            return buffer.toString();
         }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int length=extraData.charAt(mapping++)&MAPPING_LENGTH_MASK;
+        return extraData.substring(mapping, mapping+length);
     }
 
     /**
@@ -795,40 +789,38 @@ public final class Normalizer2Impl {
      * @return c's raw decomposition, if it has one; returns null if it does not have a decomposition
      */
     public String getRawDecomposition(int c) {
-        // We do not loop in this method because an algorithmic mapping itself
-        // becomes a final result rather than having to be decomposed recursively.
         int norm16;
         if(c<minDecompNoCP || isDecompYes(norm16=getNorm16(c))) {
             // c does not decompose
             return null;
-        } else if(isHangul(norm16)) {
+        } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
             // Hangul syllable: decompose algorithmically
             StringBuilder buffer=new StringBuilder();
             Hangul.getRawDecomposition(c, buffer);
             return buffer.toString();
         } else if(isDecompNoAlgorithmic(norm16)) {
             return UTF16.valueOf(mapAlgorithmic(c, norm16));
-        } else {
-            // c decomposes, get everything from the variable-length extra data
-            int firstUnit=extraData.charAt(norm16);
-            int mLength=firstUnit&MAPPING_LENGTH_MASK;  // length of normal mapping
-            if((firstUnit&MAPPING_HAS_RAW_MAPPING)!=0) {
-                // Read the raw mapping from before the firstUnit and before the optional ccc/lccc word.
-                // Bit 7=MAPPING_HAS_CCC_LCCC_WORD
-                int rawMapping=norm16-((firstUnit>>7)&1)-1;
-                char rm0=extraData.charAt(rawMapping);
-                if(rm0<=MAPPING_LENGTH_MASK) {
-                    return extraData.substring(rawMapping-rm0, rawMapping);
-                } else {
-                    // Copy the normal mapping and replace its first two code units with rm0.
-                    StringBuilder buffer=new StringBuilder(mLength-1).append(rm0);
-                    norm16+=1+2;  // skip over the firstUnit and the first two mapping code units
-                    return buffer.append(extraData, norm16, norm16+mLength-2).toString();
-                }
+        }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int firstUnit=extraData.charAt(mapping);
+        int mLength=firstUnit&MAPPING_LENGTH_MASK;  // length of normal mapping
+        if((firstUnit&MAPPING_HAS_RAW_MAPPING)!=0) {
+            // Read the raw mapping from before the firstUnit and before the optional ccc/lccc word.
+            // Bit 7=MAPPING_HAS_CCC_LCCC_WORD
+            int rawMapping=mapping-((firstUnit>>7)&1)-1;
+            char rm0=extraData.charAt(rawMapping);
+            if(rm0<=MAPPING_LENGTH_MASK) {
+                return extraData.substring(rawMapping-rm0, rawMapping);
             } else {
-                norm16+=1;  // skip over the firstUnit
-                return extraData.substring(norm16, norm16+mLength);
+                // Copy the normal mapping and replace its first two code units with rm0.
+                StringBuilder buffer=new StringBuilder(mLength-1).append(rm0);
+                mapping+=1+2;  // skip over the firstUnit and the first two mapping code units
+                return buffer.append(extraData, mapping, mapping+mLength-2).toString();
             }
+        } else {
+            mapping+=1;  // skip over the firstUnit
+            return extraData.substring(mapping, mapping+mLength);
         }
     }
 
@@ -876,12 +868,25 @@ public final class Normalizer2Impl {
         return true;
     }
 
-    public static final int MIN_CCC_LCCC_CP=0x300;
+    // Fixed norm16 values.
+    public static final int MIN_YES_YES_WITH_CC=0xfe02;
+    public static final int JAMO_VT=0xfe00;
+    public static final int MIN_NORMAL_MAYBE_YES=0xfc00;
+    public static final int JAMO_L=2;  // offset=1 hasCompBoundaryAfter=FALSE
+    public static final int INERT=1;  // offset=0 hasCompBoundaryAfter=TRUE
+
+    // norm16 bit 0 is comp-boundary-after.
+    public static final int HAS_COMP_BOUNDARY_AFTER=1;
+    public static final int OFFSET_SHIFT=1;
+
+    // For algorithmic one-way mappings, norm16 bits 2..1 indicate the
+    // tccc (0, 1, >1) for quick FCC boundary-after tests.
+    public static final int DELTA_TCCC_0=0;
+    public static final int DELTA_TCCC_1=2;
+    public static final int DELTA_TCCC_GT_1=4;
+    public static final int DELTA_TCCC_MASK=6;
+    public static final int DELTA_SHIFT=3;
 
-    public static final int MIN_YES_YES_WITH_CC=0xff01;
-    public static final int JAMO_VT=0xff00;
-    public static final int MIN_NORMAL_MAYBE_YES=0xfe00;
-    public static final int JAMO_L=1;
     public static final int MAX_DELTA=0x40;
 
     // Byte offsets from the start of the data, after the generic header.
@@ -898,18 +903,26 @@ public final class Normalizer2Impl {
     // Norm16 value thresholds for quick check combinations and types of extra data.
     // Mappings & compositions in [minYesNo..minYesNoMappingsOnly[.
     public static final int IX_MIN_YES_NO=10;
+    // Mappings are comp-normalized.
     public static final int IX_MIN_NO_NO=11;
     public static final int IX_LIMIT_NO_NO=12;
     public static final int IX_MIN_MAYBE_YES=13;
 
     // Mappings only in [minYesNoMappingsOnly..minNoNo[.
     public static final int IX_MIN_YES_NO_MAPPINGS_ONLY=14;
+    // Mappings are not comp-normalized but have a comp boundary before.
+    public static final int IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE=15;
+    // Mappings do not have a comp boundary before.
+    public static final int IX_MIN_NO_NO_COMP_NO_MAYBE_CC=16;
+    // Mappings to the empty string.
+    public static final int IX_MIN_NO_NO_EMPTY=17;
 
-    public static final int IX_COUNT=16;
+    public static final int IX_MIN_LCCC_CP=18;
+    public static final int IX_COUNT=20;
 
     public static final int MAPPING_HAS_CCC_LCCC_WORD=0x80;
     public static final int MAPPING_HAS_RAW_MAPPING=0x40;
-    public static final int MAPPING_NO_COMP_BOUNDARY_AFTER=0x20;
+    // unused bit 0x20;
     public static final int MAPPING_LENGTH_MASK=0x1f;
 
     public static final int COMP_1_LAST_TUPLE=0x8000;
@@ -1044,6 +1057,7 @@ public final class Normalizer2Impl {
         buffer.append(s, 0, src, firstCC, prevCC);
         buffer.append(s, src, limit);
     }
+
     // Very similar to composeQuickCheck(): Make the same changes in both places if relevant.
     // doCompose: normalize
     // !doCompose: isNormalized (buffer must be empty and initialized)
@@ -1051,241 +1065,240 @@ public final class Normalizer2Impl {
                            boolean onlyContiguous,
                            boolean doCompose,
                            ReorderingBuffer buffer) {
+        int prevBoundary=src;
         int minNoMaybeCP=minCompNoMaybeCP;
 
-        /*
-         * prevBoundary points to the last character before the current one
-         * that has a composition boundary before it with ccc==0 and quick check "yes".
-         * Keeping track of prevBoundary saves us looking for a composition boundary
-         * when we find a "no" or "maybe".
-         *
-         * When we back out from prevSrc back to prevBoundary,
-         * then we also remove those same characters (which had been simply copied
-         * or canonically-order-inserted) from the ReorderingBuffer.
-         * Therefore, at all times, the [prevBoundary..prevSrc[ source units
-         * must correspond 1:1 to destination units at the end of the destination buffer.
-         */
-        int prevBoundary=src;
-        int prevSrc;
-        int c=0;
-        int norm16=0;
-
-        // only for isNormalized
-        int prevCC=0;
-
-        for(;;) {
-            // count code units below the minimum or with irrelevant data for the quick check
-            for(prevSrc=src; src!=limit;) {
+        for (;;) {
+            // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
+            // or with (compYes && ccc==0) properties.
+            int prevSrc;
+            int c = 0;
+            int norm16 = 0;
+            for (;;) {
+                if (src == limit) {
+                    if (prevBoundary != limit && doCompose) {
+                        buffer.append(s, prevBoundary, limit);
+                    }
+                    return true;
+                }
                 if( (c=s.charAt(src))<minNoMaybeCP ||
                     isCompYesAndZeroCC(norm16=normTrie.getFromU16SingleLead((char)c))
                 ) {
                     ++src;
-                } else if(!UTF16.isSurrogate((char)c)) {
-                    break;
                 } else {
-                    char c2;
-                    if(UTF16Plus.isSurrogateLead(c)) {
-                        if((src+1)!=limit && Character.isLowSurrogate(c2=s.charAt(src+1))) {
-                            c=Character.toCodePoint((char)c, c2);
-                        }
-                    } else /* trail surrogate */ {
-                        if(prevSrc<src && Character.isHighSurrogate(c2=s.charAt(src-1))) {
-                            --src;
-                            c=Character.toCodePoint(c2, (char)c);
-                        }
-                    }
-                    if(isCompYesAndZeroCC(norm16=getNorm16(c))) {
-                        src+=Character.charCount(c);
-                    } else {
+                    prevSrc = src++;
+                    if(!UTF16.isSurrogate((char)c)) {
                         break;
+                    } else {
+                        char c2;
+                        if(UTF16Plus.isSurrogateLead(c)) {
+                            if(src!=limit && Character.isLowSurrogate(c2=s.charAt(src))) {
+                                ++src;
+                                c=Character.toCodePoint((char)c, c2);
+                            }
+                        } else /* trail surrogate */ {
+                            if(prevBoundary<prevSrc && Character.isHighSurrogate(c2=s.charAt(prevSrc-1))) {
+                                --prevSrc;
+                                c=Character.toCodePoint(c2, (char)c);
+                            }
+                        }
+                        if(!isCompYesAndZeroCC(norm16=getNorm16(c))) {
+                            break;
+                        }
                     }
                 }
             }
-            // copy these code units all at once
-            if(src!=prevSrc) {
-                if(src==limit) {
-                    if(doCompose) {
-                        buffer.flushAndAppendZeroCC(s, prevSrc, src);
-                    }
-                    break;
-                }
-                // Set prevBoundary to the last character in the quick check loop.
-                prevBoundary=src-1;
-                if( Character.isLowSurrogate(s.charAt(prevBoundary)) && prevSrc<prevBoundary &&
-                    Character.isHighSurrogate(s.charAt(prevBoundary-1))
-                ) {
-                    --prevBoundary;
-                }
-                if(doCompose) {
-                    // The last "quick check yes" character is excluded from the
-                    // flush-and-append call in case it needs to be modified.
-                    buffer.flushAndAppendZeroCC(s, prevSrc, prevBoundary);
-                    buffer.append(s, prevBoundary, src);
-                } else {
-                    prevCC=0;
-                }
-                // The start of the current character (c).
-                prevSrc=src;
-            } else if(src==limit) {
-                break;
-            }
+            // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
+            // The current character is either a "noNo" (has a mapping)
+            // or a "maybeYes" (combines backward)
+            // or a "yesYes" with ccc!=0.
+            // It is not a Hangul syllable or Jamo L because those have "yes" properties.
 
-            src+=Character.charCount(c);
-            /*
-             * isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
-             * c is either a "noNo" (has a mapping) or a "maybeYes" (combines backward)
-             * or has ccc!=0.
-             * Check for Jamo V/T, then for regular characters.
-             * c is not a Hangul syllable or Jamo L because those have "yes" properties.
-             */
-            if(isJamoVT(norm16) && prevBoundary!=prevSrc) {
+            // Medium-fast path: Handle cases that do not require full decomposition and recomposition.
+            if (!isMaybeOrNonZeroCC(norm16)) {  // minNoNo <= norm16 < minMaybeYes
+                if (!doCompose) {
+                    return false;
+                }
+                // Fast path for mapping a character that is immediately surrounded by boundaries.
+                // In this case, we need not decompose around the current character.
+                if (isDecompNoAlgorithmic(norm16)) {
+                    // Maps to a single isCompYesAndZeroCC character
+                    // which also implies hasCompBoundaryBefore.
+                    if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
+                            hasCompBoundaryBefore(s, src, limit)) {
+                        if (prevBoundary != prevSrc) {
+                            buffer.append(s, prevBoundary, prevSrc);
+                        }
+                        buffer.append(mapAlgorithmic(c, norm16), 0);
+                        prevBoundary = src;
+                        continue;
+                    }
+                } else if (norm16 < minNoNoCompBoundaryBefore) {
+                    // The mapping is comp-normalized which also implies hasCompBoundaryBefore.
+                    if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
+                            hasCompBoundaryBefore(s, src, limit)) {
+                        if (prevBoundary != prevSrc) {
+                            buffer.append(s, prevBoundary, prevSrc);
+                        }
+                        int mapping = norm16 >> OFFSET_SHIFT;
+                        int length = extraData.charAt(mapping++) & MAPPING_LENGTH_MASK;
+                        buffer.append(extraData, mapping, mapping + length);
+                        prevBoundary = src;
+                        continue;
+                    }
+                } else if (norm16 >= minNoNoEmpty) {
+                    // The current character maps to nothing.
+                    // Simply omit it from the output if there is a boundary before _or_ after it.
+                    // The character itself implies no boundaries.
+                    if (hasCompBoundaryBefore(s, src, limit) ||
+                            hasCompBoundaryAfter(s, prevBoundary, prevSrc, onlyContiguous)) {
+                        if (prevBoundary != prevSrc) {
+                            buffer.append(s, prevBoundary, prevSrc);
+                        }
+                        prevBoundary = src;
+                        continue;
+                    }
+                }
+                // Other "noNo" type, or need to examine more text around this character:
+                // Fall through to the slow path.
+            } else if (isJamoVT(norm16) && prevBoundary != prevSrc) {
                 char prev=s.charAt(prevSrc-1);
-                boolean needToDecompose=false;
                 if(c<Hangul.JAMO_T_BASE) {
-                    // c is a Jamo Vowel, compose with previous Jamo L and following Jamo T.
-                    prev-=Hangul.JAMO_L_BASE;
-                    if(prev<Hangul.JAMO_L_COUNT) {
-                        if(!doCompose) {
+                    // The current character is a Jamo Vowel,
+                    // compose with previous Jamo L and following Jamo T.
+                    char l = (char)(prev-Hangul.JAMO_L_BASE);
+                    if(l<Hangul.JAMO_L_COUNT) {
+                        if (!doCompose) {
                             return false;
                         }
-                        char syllable=(char)
-                            (Hangul.HANGUL_BASE+
-                             (prev*Hangul.JAMO_V_COUNT+(c-Hangul.JAMO_V_BASE))*
-                             Hangul.JAMO_T_COUNT);
-                        char t;
-                        if(src!=limit && (t=(char)(s.charAt(src)-Hangul.JAMO_T_BASE))<Hangul.JAMO_T_COUNT) {
+                        int t;
+                        if (src != limit &&
+                                0 < (t = (s.charAt(src) - Hangul.JAMO_T_BASE)) &&
+                                t < Hangul.JAMO_T_COUNT) {
+                            // The next character is a Jamo T.
                             ++src;
-                            syllable+=t;  // The next character was a Jamo T.
-                            prevBoundary=src;
-                            buffer.setLastChar(syllable);
+                        } else if (hasCompBoundaryBefore(s, src, limit)) {
+                            // No Jamo T follows, not even via decomposition.
+                            t = 0;
+                        } else {
+                            t = -1;
+                        }
+                        if (t >= 0) {
+                            int syllable = Hangul.HANGUL_BASE +
+                                (l*Hangul.JAMO_V_COUNT + (c-Hangul.JAMO_V_BASE)) *
+                                Hangul.JAMO_T_COUNT + t;
+                            --prevSrc;  // Replace the Jamo L as well.
+                            if (prevBoundary != prevSrc) {
+                                buffer.append(s, prevBoundary, prevSrc);
+                            }
+                            buffer.append((char)syllable);
+                            prevBoundary = src;
                             continue;
                         }
                         // If we see L+V+x where x!=T then we drop to the slow path,
                         // decompose and recompose.
                         // This is to deal with NFKC finding normal L and V but a
-                        // compatibility variant of a T. We need to either fully compose that
-                        // combination here (which would complicate the code and may not work
-                        // with strange custom data) or use the slow path -- or else our replacing
-                        // two input characters (L+V) with one output character (LV syllable)
-                        // would violate the invariant that [prevBoundary..prevSrc[ has the same
-                        // length as what we appended to the buffer since prevBoundary.
-                        needToDecompose=true;
+                        // compatibility variant of a T.
+                        // We need to either fully compose that combination here
+                        // (which would complicate the code and may not work with strange custom data)
+                        // or use the slow path.
                     }
-                } else if(Hangul.isHangulWithoutJamoT(prev)) {
-                    // c is a Jamo Trailing consonant,
+                } else if (Hangul.isHangulLV(prev)) {
+                    // The current character is a Jamo Trailing consonant,
                     // compose with previous Hangul LV that does not contain a Jamo T.
-                    if(!doCompose) {
+                    if (!doCompose) {
                         return false;
                     }
-                    buffer.setLastChar((char)(prev+c-Hangul.JAMO_T_BASE));
-                    prevBoundary=src;
-                    continue;
-                }
-                if(!needToDecompose) {
-                    // The Jamo V/T did not compose into a Hangul syllable.
-                    if(doCompose) {
-                        buffer.append((char)c);
-                    } else {
-                        prevCC=0;
+                    int syllable = prev + c - Hangul.JAMO_T_BASE;
+                    --prevSrc;  // Replace the Hangul LV as well.
+                    if (prevBoundary != prevSrc) {
+                        buffer.append(s, prevBoundary, prevSrc);
                     }
+                    buffer.append((char)syllable);
+                    prevBoundary = src;
                     continue;
                 }
-            }
-            /*
-             * Source buffer pointers:
-             *
-             *  all done      quick check   current char  not yet
-             *                "yes" but     (c)           processed
-             *                may combine
-             *                forward
-             * [-------------[-------------[-------------[-------------[
-             * |             |             |             |             |
-             * orig. src     prevBoundary  prevSrc       src           limit
-             *
-             *
-             * Destination buffer pointers inside the ReorderingBuffer:
-             *
-             *  all done      might take    not filled yet
-             *                characters for
-             *                reordering
-             * [-------------[-------------[-------------[
-             * |             |             |             |
-             * start         reorderStart  limit         |
-             *                             +remainingCap.+
-             */
-            if(norm16>=MIN_YES_YES_WITH_CC) {
-                int cc=norm16&0xff;  // cc!=0
-                if( onlyContiguous &&  // FCC
-                    (doCompose ? buffer.getLastCC() : prevCC)==0 &&
-                    prevBoundary<prevSrc &&
-                    // buffer.getLastCC()==0 && prevBoundary<prevSrc tell us that
-                    // [prevBoundary..prevSrc[ (which is exactly one character under these conditions)
-                    // passed the quick check "yes && ccc==0" test.
-                    // Check whether the last character was a "yesYes" or a "yesNo".
-                    // If a "yesNo", then we get its trailing ccc from its
-                    // mapping and check for canonical order.
-                    // All other cases are ok.
-                    getTrailCCFromCompYesAndZeroCC(s, prevBoundary, prevSrc)>cc
-                ) {
+                // No matching context, or may need to decompose surrounding text first:
+                // Fall through to the slow path.
+            } else if (norm16 > JAMO_VT) {  // norm16 >= MIN_YES_YES_WITH_CC
+                // One or more combining marks that do not combine-back:
+                // Check for canonical order, copy unchanged if ok and
+                // if followed by a character with a boundary-before.
+                int cc = getCCFromNormalYesOrMaybe(norm16);  // cc!=0
+                if (onlyContiguous /* FCC */ && getPreviousTrailCC(s, prevBoundary, prevSrc) > cc) {
                     // Fails FCD test, need to decompose and contiguously recompose.
-                    if(!doCompose) {
+                    if (!doCompose) {
                         return false;
                     }
-                } else if(doCompose) {
-                    buffer.append(c, cc);
-                    continue;
-                } else if(prevCC<=cc) {
-                    prevCC=cc;
-                    continue;
                 } else {
-                    return false;
+                    // If !onlyContiguous (not FCC), then we ignore the tccc of
+                    // the previous character which passed the quick check "yes && ccc==0" test.
+                    int n16;
+                    for (;;) {
+                        if (src == limit) {
+                            if (doCompose) {
+                                buffer.append(s, prevBoundary, limit);
+                            }
+                            return true;
+                        }
+                        int prevCC = cc;
+                        c = Character.codePointAt(s, src);
+                        n16 = normTrie.get(c);
+                        if (n16 >= MIN_YES_YES_WITH_CC) {
+                            cc = getCCFromNormalYesOrMaybe(n16);
+                            if (prevCC > cc) {
+                                if (!doCompose) {
+                                    return false;
+                                }
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                        src += Character.charCount(c);
+                    }
+                    // p is after the last in-order combining mark.
+                    // If there is a boundary here, then we continue with no change.
+                    if (norm16HasCompBoundaryBefore(n16)) {
+                        if (isCompYesAndZeroCC(n16)) {
+                            src += Character.charCount(c);
+                        }
+                        continue;
+                    }
+                    // Use the slow path. There is no boundary in [prevSrc, src[.
                 }
-            } else if(!doCompose && !isMaybeOrNonZeroCC(norm16)) {
-                return false;
             }
 
-            /*
-             * Find appropriate boundaries around this character,
-             * decompose the source text from between the boundaries,
-             * and recompose it.
-             *
-             * We may need to remove the last few characters from the ReorderingBuffer
-             * to account for source text that was copied or appended
-             * but needs to take part in the recomposition.
-             */
-
-            /*
-             * Find the last composition boundary in [prevBoundary..src[.
-             * It is either the decomposition of the current character (at prevSrc),
-             * or prevBoundary.
-             */
-            if(hasCompBoundaryBefore(c, norm16)) {
-                prevBoundary=prevSrc;
-            } else if(doCompose) {
-                buffer.removeSuffix(prevSrc-prevBoundary);
+            // Slow path: Find the nearest boundaries around the current character,
+            // decompose and recompose.
+            if (prevBoundary != prevSrc && !norm16HasCompBoundaryBefore(norm16)) {
+                c = Character.codePointBefore(s, prevSrc);
+                norm16 = normTrie.get(c);
+                if (!norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                    prevSrc -= Character.charCount(c);
+                }
+            }
+            if (doCompose && prevBoundary != prevSrc) {
+                buffer.append(s, prevBoundary, prevSrc);
             }
-
-            // Find the next composition boundary in [src..limit[ -
-            // modifies src to point to the next starter.
-            src=findNextCompBoundary(s, src, limit);
-
-            // Decompose [prevBoundary..src[ into the buffer and then recompose that part of it.
             int recomposeStartIndex=buffer.length();
-            decomposeShort(s, prevBoundary, src, buffer);
+            // We know there is not a boundary here.
+            decomposeShort(s, prevSrc, src, false /* !stopAtCompBoundary */, onlyContiguous,
+                           buffer);
+            // Decompose until the next boundary.
+            src = decomposeShort(s, src, limit, true /* stopAtCompBoundary */, onlyContiguous,
+                                 buffer);
             recompose(buffer, recomposeStartIndex, onlyContiguous);
             if(!doCompose) {
-                if(!buffer.equals(s, prevBoundary, src)) {
+                if(!buffer.equals(s, prevSrc, src)) {
                     return false;
                 }
                 buffer.remove();
-                prevCC=0;
             }
-
-            // Move to the next starter. We never need to look back before this point again.
             prevBoundary=src;
         }
-        return true;
     }
+
     /**
      * Very similar to compose(): Make the same changes in both places if relevant.
      * doSpan: spanQuickCheckYes (ignore bit 0 of the return value)
@@ -1297,21 +1310,16 @@ public final class Normalizer2Impl {
     public int composeQuickCheck(CharSequence s, int src, int limit,
                                  boolean onlyContiguous, boolean doSpan) {
         int qcResult=0;
+        int prevBoundary=src;
         int minNoMaybeCP=minCompNoMaybeCP;
 
-        /*
-         * prevBoundary points to the last character before the current one
-         * that has a composition boundary before it with ccc==0 and quick check "yes".
-         */
-        int prevBoundary=src;
-        int prevSrc;
-        int c=0;
-        int norm16=0;
-        int prevCC=0;
-
         for(;;) {
-            // count code units below the minimum or with irrelevant data for the quick check
-            for(prevSrc=src;;) {
+            // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
+            // or with (compYes && ccc==0) properties.
+            int prevSrc;
+            int c = 0;
+            int norm16 = 0;
+            for (;;) {
                 if(src==limit) {
                     return (src<<1)|qcResult;  // "yes" or "maybe"
                 }
@@ -1319,72 +1327,88 @@ public final class Normalizer2Impl {
                     isCompYesAndZeroCC(norm16=normTrie.getFromU16SingleLead((char)c))
                 ) {
                     ++src;
-                } else if(!UTF16.isSurrogate((char)c)) {
-                    break;
                 } else {
-                    char c2;
-                    if(UTF16Plus.isSurrogateLead(c)) {
-                        if((src+1)!=limit && Character.isLowSurrogate(c2=s.charAt(src+1))) {
-                            c=Character.toCodePoint((char)c, c2);
-                        }
-                    } else /* trail surrogate */ {
-                        if(prevSrc<src && Character.isHighSurrogate(c2=s.charAt(src-1))) {
-                            --src;
-                            c=Character.toCodePoint(c2, (char)c);
-                        }
-                    }
-                    if(isCompYesAndZeroCC(norm16=getNorm16(c))) {
-                        src+=Character.charCount(c);
-                    } else {
+                    prevSrc = src++;
+                    if(!UTF16.isSurrogate((char)c)) {
                         break;
+                    } else {
+                        char c2;
+                        if(UTF16Plus.isSurrogateLead(c)) {
+                            if(src!=limit && Character.isLowSurrogate(c2=s.charAt(src))) {
+                                ++src;
+                                c=Character.toCodePoint((char)c, c2);
+                            }
+                        } else /* trail surrogate */ {
+                            if(prevBoundary<prevSrc && Character.isHighSurrogate(c2=s.charAt(prevSrc-1))) {
+                                --prevSrc;
+                                c=Character.toCodePoint(c2, (char)c);
+                            }
+                        }
+                        if(!isCompYesAndZeroCC(norm16=getNorm16(c))) {
+                            break;
+                        }
                     }
                 }
             }
-            if(src!=prevSrc) {
-                // Set prevBoundary to the last character in the quick check loop.
-                prevBoundary=src-1;
-                if( Character.isLowSurrogate(s.charAt(prevBoundary)) && prevSrc<prevBoundary &&
-                        Character.isHighSurrogate(s.charAt(prevBoundary-1))
-                ) {
-                    --prevBoundary;
+            // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
+            // The current character is either a "noNo" (has a mapping)
+            // or a "maybeYes" (combines backward)
+            // or a "yesYes" with ccc!=0.
+            // It is not a Hangul syllable or Jamo L because those have "yes" properties.
+
+            int prevNorm16 = INERT;
+            if (prevBoundary != prevSrc) {
+                prevBoundary = prevSrc;
+                if (!norm16HasCompBoundaryBefore(norm16)) {
+                    c = Character.codePointBefore(s, prevSrc);
+                    int n16 = getNorm16(c);
+                    if (!norm16HasCompBoundaryAfter(n16, onlyContiguous)) {
+                        prevBoundary -= Character.charCount(c);
+                        prevNorm16 = n16;
+                    }
                 }
-                prevCC=0;
-                // The start of the current character (c).
-                prevSrc=src;
             }
 
-            src+=Character.charCount(c);
-            /*
-             * isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
-             * c is either a "noNo" (has a mapping) or a "maybeYes" (combines backward)
-             * or has ccc!=0.
-             */
             if(isMaybeOrNonZeroCC(norm16)) {
                 int cc=getCCFromYesOrMaybe(norm16);
-                if( onlyContiguous &&  // FCC
-                    cc!=0 &&
-                    prevCC==0 &&
-                    prevBoundary<prevSrc &&
-                    // prevCC==0 && prevBoundary<prevSrc tell us that
-                    // [prevBoundary..prevSrc[ (which is exactly one character under these conditions)
-                    // passed the quick check "yes && ccc==0" test.
-                    // Check whether the last character was a "yesYes" or a "yesNo".
-                    // If a "yesNo", then we get its trailing ccc from its
-                    // mapping and check for canonical order.
-                    // All other cases are ok.
-                    getTrailCCFromCompYesAndZeroCC(s, prevBoundary, prevSrc)>cc
-                ) {
-                    // Fails FCD test.
-                } else if(prevCC<=cc || cc==0) {
-                    prevCC=cc;
-                    if(norm16<MIN_YES_YES_WITH_CC) {
-                        if(!doSpan) {
-                            qcResult=1;
-                        } else {
-                            return prevBoundary<<1;  // spanYes does not care to know it's "maybe"
+                if (onlyContiguous /* FCC */ && cc != 0 &&
+                        getTrailCCFromCompYesAndZeroCC(prevNorm16) > cc) {
+                    // The [prevBoundary..prevSrc[ character
+                    // passed the quick check "yes && ccc==0" test
+                    // but is out of canonical order with the current combining mark.
+                } else {
+                    // If !onlyContiguous (not FCC), then we ignore the tccc of
+                    // the previous character which passed the quick check "yes && ccc==0" test.
+                    for (;;) {
+                        if (norm16 < MIN_YES_YES_WITH_CC) {
+                            if (!doSpan) {
+                                qcResult = 1;
+                            } else {
+                                return prevBoundary << 1;  // spanYes does not care to know it's "maybe"
+                            }
                         }
+                        if (src == limit) {
+                            return (src<<1) | qcResult;  // "yes" or "maybe"
+                        }
+                        int prevCC = cc;
+                        c = Character.codePointAt(s, src);
+                        norm16 = getNorm16(c);
+                        if (isMaybeOrNonZeroCC(norm16)) {
+                            cc = getCCFromYesOrMaybe(norm16);
+                            if (!(prevCC <= cc || cc == 0)) {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                        src += Character.charCount(c);
+                    }
+                    // src is after the last in-order combining mark.
+                    if (isCompYesAndZeroCC(norm16)) {
+                        prevBoundary = src;
+                        src += Character.charCount(c);
+                        continue;
                     }
-                    continue;
                 }
             }
             return prevBoundary<<1;  // "no"
@@ -1396,10 +1420,10 @@ public final class Normalizer2Impl {
                                  ReorderingBuffer buffer) {
         int src=0, limit=s.length();
         if(!buffer.isEmpty()) {
-            int firstStarterInSrc=findNextCompBoundary(s, 0, limit);
+            int firstStarterInSrc=findNextCompBoundary(s, 0, limit, onlyContiguous);
             if(0!=firstStarterInSrc) {
                 int lastStarterInDest=findPreviousCompBoundary(buffer.getStringBuilder(),
-                                                               buffer.length());
+                                                               buffer.length(), onlyContiguous);
                 StringBuilder middle=new StringBuilder((buffer.length()-lastStarterInDest)+
                                                        firstStarterInSrc+16);
                 middle.append(buffer.getStringBuilder(), lastStarterInDest, buffer.length());
@@ -1436,7 +1460,7 @@ public final class Normalizer2Impl {
         for(;;) {
             // count code units with lccc==0
             for(prevSrc=src; src!=limit;) {
-                if((c=s.charAt(src))<MIN_CCC_LCCC_CP) {
+                if((c=s.charAt(src))<minLcccCP) {
                     prevFCD16=~c;
                     ++src;
                 } else if(!singleLeadMightHaveNonZeroFCD16(c)) {
@@ -1475,11 +1499,15 @@ public final class Normalizer2Impl {
                 prevBoundary=src;
                 // We know that the previous character's lccc==0.
                 if(prevFCD16<0) {
-                    // Fetching the fcd16 value was deferred for this below-U+0300 code point.
+                    // Fetching the fcd16 value was deferred for this below-minLcccCP code point.
                     int prev=~prevFCD16;
-                    prevFCD16= prev<0x180 ? tccc180[prev] : getFCD16FromNormData(prev);
-                    if(prevFCD16>1) {
-                        --prevBoundary;
+                    if(prev<minDecompNoCP) {
+                        prevFCD16=0;
+                    } else {
+                        prevFCD16=getFCD16FromNormData(prev);
+                        if(prevFCD16>1) {
+                            --prevBoundary;
+                        }
                     }
                 } else {
                     int p=src-1;
@@ -1539,7 +1567,7 @@ public final class Normalizer2Impl {
                  * The source text does not fulfill the conditions for FCD.
                  * Decompose and reorder a limited piece of the text.
                  */
-                decomposeShort(s, prevBoundary, src, buffer);
+                decomposeShort(s, prevBoundary, src, false, false, buffer);
                 prevBoundary=src;
                 prevFCD16=0;
             }
@@ -1569,93 +1597,87 @@ public final class Normalizer2Impl {
         }
     }
 
-    // Note: hasDecompBoundary() could be implemented as aliases to
-    // hasFCDBoundaryBefore() and hasFCDBoundaryAfter()
-    // at the cost of building the FCD trie for a decomposition normalizer.
-    public boolean hasDecompBoundary(int c, boolean before) {
-        for(;;) {
-            if(c<minDecompNoCP) {
-                return true;
-            }
-            int norm16=getNorm16(c);
-            if(isHangul(norm16) || isDecompYesAndZeroCC(norm16)) {
-                return true;
-            } else if(norm16>MIN_NORMAL_MAYBE_YES) {
-                return false;  // ccc!=0
-            } else if(isDecompNoAlgorithmic(norm16)) {
-                c=mapAlgorithmic(c, norm16);
-            } else {
-                // c decomposes, get everything from the variable-length extra data
-                int firstUnit=extraData.charAt(norm16);
-                if((firstUnit&MAPPING_LENGTH_MASK)==0) {
-                    return false;
-                }
-                if(!before) {
-                    // decomp after-boundary: same as hasFCDBoundaryAfter(),
-                    // fcd16<=1 || trailCC==0
-                    if(firstUnit>0x1ff) {
-                        return false;  // trailCC>1
-                    }
-                    if(firstUnit<=0xff) {
-                        return true;  // trailCC==0
-                    }
-                    // if(trailCC==1) test leadCC==0, same as checking for before-boundary
-                }
-                // true if leadCC==0 (hasFCDBoundaryBefore())
-                return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (extraData.charAt(norm16-1)&0xff00)==0;
-            }
+    public boolean hasDecompBoundaryBefore(int c) {
+        return c < minLcccCP || (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) ||
+            norm16HasDecompBoundaryBefore(getNorm16(c));
+    }
+    public boolean norm16HasDecompBoundaryBefore(int norm16) {
+        if (norm16 < minNoNoCompNoMaybeCC) {
+            return true;
         }
+        if (norm16 >= limitNoNo) {
+            return norm16 <= MIN_NORMAL_MAYBE_YES || norm16 == JAMO_VT;
+        }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int firstUnit=extraData.charAt(mapping);
+        // true if leadCC==0 (hasFCDBoundaryBefore())
+        return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (extraData.charAt(mapping-1)&0xff00)==0;
+    }
+    public boolean hasDecompBoundaryAfter(int c) {
+        if (c < minDecompNoCP) {
+            return true;
+        }
+        if (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) {
+            return true;
+        }
+        return norm16HasDecompBoundaryAfter(getNorm16(c));
+    }
+    public boolean norm16HasDecompBoundaryAfter(int norm16) {
+        if(norm16 <= minYesNo || isHangulLVT(norm16)) {
+            return true;
+        }
+        if (norm16 >= limitNoNo) {
+            if (isMaybeOrNonZeroCC(norm16)) {
+                return norm16 <= MIN_NORMAL_MAYBE_YES || norm16 == JAMO_VT;
+            }
+            // Maps to an isCompYesAndZeroCC.
+            return (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1;
+        }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int firstUnit=extraData.charAt(mapping);
+        // decomp after-boundary: same as hasFCDBoundaryAfter(),
+        // fcd16<=1 || trailCC==0
+        if(firstUnit>0x1ff) {
+            return false;  // trailCC>1
+        }
+        if(firstUnit<=0xff) {
+            return true;  // trailCC==0
+        }
+        // if(trailCC==1) test leadCC==0, same as checking for before-boundary
+        // true if leadCC==0 (hasFCDBoundaryBefore())
+        return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (extraData.charAt(mapping-1)&0xff00)==0;
     }
     public boolean isDecompInert(int c) { return isDecompYesAndZeroCC(getNorm16(c)); }
 
     public boolean hasCompBoundaryBefore(int c) {
-        return c<minCompNoMaybeCP || hasCompBoundaryBefore(c, getNorm16(c));
+        return c<minCompNoMaybeCP || norm16HasCompBoundaryBefore(getNorm16(c));
     }
-    public boolean hasCompBoundaryAfter(int c, boolean onlyContiguous, boolean testInert) {
-        for(;;) {
-            int norm16=getNorm16(c);
-            if(isInert(norm16)) {
-                return true;
-            } else if(norm16<=minYesNo) {
-                // Hangul: norm16==minYesNo
-                // Hangul LVT has a boundary after it.
-                // Hangul LV and non-inert yesYes characters combine forward.
-                return isHangul(norm16) && !Hangul.isHangulWithoutJamoT((char)c);
-            } else if(norm16>= (testInert ? minNoNo : minMaybeYes)) {
-                return false;
-            } else if(isDecompNoAlgorithmic(norm16)) {
-                c=mapAlgorithmic(c, norm16);
-            } else {
-                // c decomposes, get everything from the variable-length extra data.
-                // If testInert, then c must be a yesNo character which has lccc=0,
-                // otherwise it could be a noNo.
-                int firstUnit=extraData.charAt(norm16);
-                // true if
-                //   not MAPPING_NO_COMP_BOUNDARY_AFTER
-                //     (which is set if
-                //       c is not deleted, and
-                //       it and its decomposition do not combine forward, and it has a starter)
-                //   and if FCC then trailCC<=1
-                return
-                    (firstUnit&MAPPING_NO_COMP_BOUNDARY_AFTER)==0 &&
-                    (!onlyContiguous || firstUnit<=0x1ff);
-            }
-        }
+    public boolean hasCompBoundaryAfter(int c, boolean onlyContiguous) {
+        return norm16HasCompBoundaryAfter(getNorm16(c), onlyContiguous);
+    }
+    public boolean isCompInert(int c, boolean onlyContiguous) {
+        int norm16=getNorm16(c);
+        return isCompYesAndZeroCC(norm16) &&
+            (norm16 & HAS_COMP_BOUNDARY_AFTER) != 0 &&
+            (!onlyContiguous || isInert(norm16) || extraData.charAt(norm16>>OFFSET_SHIFT) <= 0x1ff);
     }
 
-    public boolean hasFCDBoundaryBefore(int c) { return c<MIN_CCC_LCCC_CP || getFCD16(c)<=0xff; }
-    public boolean hasFCDBoundaryAfter(int c) {
-        int fcd16=getFCD16(c);
-        return fcd16<=1 || (fcd16&0xff)==0;
-    }
+    public boolean hasFCDBoundaryBefore(int c) { return hasDecompBoundaryBefore(c); }
+    public boolean hasFCDBoundaryAfter(int c) { return hasDecompBoundaryAfter(c); }
     public boolean isFCDInert(int c) { return getFCD16(c)<=1; }
 
     private boolean isMaybe(int norm16) { return minMaybeYes<=norm16 && norm16<=JAMO_VT; }
     private boolean isMaybeOrNonZeroCC(int norm16) { return norm16>=minMaybeYes; }
-    private static boolean isInert(int norm16) { return norm16==0; }
-    private static boolean isJamoL(int norm16) { return norm16==1; }
+    private static boolean isInert(int norm16) { return norm16==INERT; }
+    private static boolean isJamoL(int norm16) { return norm16==JAMO_L; }
     private static boolean isJamoVT(int norm16) { return norm16==JAMO_VT; }
-    private boolean isHangul(int norm16) { return norm16==minYesNo; }
+    private int hangulLVT() { return minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER; }
+    private boolean isHangulLV(int norm16) { return norm16==minYesNo; }
+    private boolean isHangulLVT(int norm16) {
+        return norm16==hangulLVT();
+    }
     private boolean isCompYesAndZeroCC(int norm16) { return norm16<minNoNo; }
     // UBool isCompYes(uint16_t norm16) const {
     //     return norm16>=MIN_YES_YES_WITH_CC || norm16<minNoNo;
@@ -1674,7 +1696,7 @@ public final class Normalizer2Impl {
     /**
      * A little faster and simpler than isDecompYesAndZeroCC() but does not include
      * the MaybeYes which combine-forward and have ccc=0.
-     * (Standard Unicode 5.2 normalization does not have such characters.)
+     * (Standard Unicode 10 normalization does not have such characters.)
      */
     private boolean isMostDecompYesAndZeroCC(int norm16) {
         return norm16<minYesNo || norm16==MIN_NORMAL_MAYBE_YES || norm16==JAMO_VT;
@@ -1684,44 +1706,38 @@ public final class Normalizer2Impl {
     // For use with isCompYes().
     // Perhaps the compiler can combine the two tests for MIN_YES_YES_WITH_CC.
     // static uint8_t getCCFromYes(uint16_t norm16) {
-    //     return norm16>=MIN_YES_YES_WITH_CC ? (uint8_t)norm16 : 0;
+    //     return norm16>=MIN_YES_YES_WITH_CC ? getCCFromNormalYesOrMaybe(norm16) : 0;
     // }
     private int getCCFromNoNo(int norm16) {
-        if((extraData.charAt(norm16)&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
-            return extraData.charAt(norm16-1)&0xff;
+        int mapping=norm16>>OFFSET_SHIFT;
+        if((extraData.charAt(mapping)&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
+            return extraData.charAt(mapping-1)&0xff;
         } else {
             return 0;
         }
     }
-    // requires that the [cpStart..cpLimit[ character passes isCompYesAndZeroCC()
-    int getTrailCCFromCompYesAndZeroCC(CharSequence s, int cpStart, int cpLimit) {
-        int c;
-        if(cpStart==(cpLimit-1)) {
-            c=s.charAt(cpStart);
+    int getTrailCCFromCompYesAndZeroCC(int norm16) {
+        if(norm16<=minYesNo) {
+            return 0;  // yesYes and Hangul LV have ccc=tccc=0
         } else {
-            c=Character.codePointAt(s, cpStart);
-        }
-        int prevNorm16=getNorm16(c);
-        if(prevNorm16<=minYesNo) {
-            return 0;  // yesYes and Hangul LV/LVT have ccc=tccc=0
-        } else {
-            return extraData.charAt(prevNorm16)>>8;  // tccc from yesNo
+            // For Hangul LVT we harmlessly fetch a firstUnit with tccc=0 here.
+            return extraData.charAt(norm16>>OFFSET_SHIFT)>>8;  // tccc from yesNo
         }
     }
 
     // Requires algorithmic-NoNo.
     private int mapAlgorithmic(int c, int norm16) {
-        return c+norm16-(minMaybeYes-MAX_DELTA-1);
+        return c+(norm16>>DELTA_SHIFT)-centerNoNoDelta;
     }
 
     // Requires minYesNo<norm16<limitNoNo.
-    // private int getMapping(int norm16) { return /*extraData+*/norm16; }
+    // private int getMapping(int norm16) { return extraData+(norm16>>OFFSET_SHIFT); }
 
     /**
      * @return index into maybeYesCompositions, or -1
      */
     private int getCompositionsListForDecompYes(int norm16) {
-        if(norm16==0 || MIN_NORMAL_MAYBE_YES<=norm16) {
+        if(norm16<JAMO_L || MIN_NORMAL_MAYBE_YES<=norm16) {
             return -1;
         } else {
             if((norm16-=minMaybeYes)<0) {
@@ -1730,19 +1746,24 @@ public final class Normalizer2Impl {
                 // same as (MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16
                 norm16+=MIN_NORMAL_MAYBE_YES;  // for yesYes; if Jamo L: harmless empty list
             }
-            return norm16;
+            return norm16>>OFFSET_SHIFT;
         }
     }
     /**
      * @return index into maybeYesCompositions
      */
     private int getCompositionsListForComposite(int norm16) {
-        // composite has both mapping & compositions list
-        int firstUnit=extraData.charAt(norm16);
-        return (MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16+  // mapping in maybeYesCompositions
-            1+  // +1 to skip the first unit with the mapping lenth
+        // A composite has both mapping & compositions list.
+        int list=((MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16)>>OFFSET_SHIFT;
+        int firstUnit=maybeYesCompositions.charAt(list);
+        return list+  // mapping in maybeYesCompositions
+            1+  // +1 to skip the first unit with the mapping length
             (firstUnit&MAPPING_LENGTH_MASK);  // + mapping length
     }
+    private int getCompositionsListForMaybe(int norm16) {
+        // minMaybeYes<=norm16<MIN_NORMAL_MAYBE_YES
+        return (norm16-minMaybeYes)>>OFFSET_SHIFT;
+    }
     /**
      * @param c code point must have compositions
      * @return index into maybeYesCompositions
@@ -1758,44 +1779,58 @@ public final class Normalizer2Impl {
     // is unlikely to be amortized.
     // Called by the compose() and makeFCD() implementations.
     // Public in Java for collation implementation code.
-    public void decomposeShort(CharSequence s, int src, int limit,
-                               ReorderingBuffer buffer) {
+    private int decomposeShort(
+            CharSequence s, int src, int limit,
+            boolean stopAtCompBoundary, boolean onlyContiguous,
+            ReorderingBuffer buffer) {
         while(src<limit) {
             int c=Character.codePointAt(s, src);
-            src+=Character.charCount(c);
-            decompose(c, getNorm16(c), buffer);
-        }
-    }
-    private void decompose(int c, int norm16,
-                           ReorderingBuffer buffer) {
-        // Only loops for 1:1 algorithmic mappings.
-        for(;;) {
-            // get the decomposition and the lead and trail cc's
-            if(isDecompYes(norm16)) {
-                // c does not decompose
-                buffer.append(c, getCCFromYesOrMaybe(norm16));
-            } else if(isHangul(norm16)) {
-                // Hangul syllable: decompose algorithmically
-                Hangul.decompose(c, buffer);
-            } else if(isDecompNoAlgorithmic(norm16)) {
-                c=mapAlgorithmic(c, norm16);
-                norm16=getNorm16(c);
-                continue;
-            } else {
-                // c decomposes, get everything from the variable-length extra data
-                int firstUnit=extraData.charAt(norm16);
-                int length=firstUnit&MAPPING_LENGTH_MASK;
-                int leadCC, trailCC;
-                trailCC=firstUnit>>8;
-                if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
-                    leadCC=extraData.charAt(norm16-1)>>8;
-                } else {
-                    leadCC=0;
-                }
-                ++norm16;  // skip over the firstUnit
-                buffer.append(extraData, norm16, norm16+length, leadCC, trailCC);
+            if (stopAtCompBoundary && c < minCompNoMaybeCP) {
+                return src;
             }
-            return;
+            int norm16 = getNorm16(c);
+            if (stopAtCompBoundary && norm16HasCompBoundaryBefore(norm16)) {
+                return src;
+            }
+            src+=Character.charCount(c);
+            decompose(c, norm16, buffer);
+            if (stopAtCompBoundary && norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                return src;
+            }
+        }
+        return src;
+    }
+    private void decompose(int c, int norm16, ReorderingBuffer buffer) {
+        // get the decomposition and the lead and trail cc's
+        if (norm16 >= limitNoNo) {
+            if (isMaybeOrNonZeroCC(norm16)) {
+                buffer.append(c, getCCFromYesOrMaybe(norm16));
+                return;
+            }
+            // Maps to an isCompYesAndZeroCC.
+            c=mapAlgorithmic(c, norm16);
+            norm16=getNorm16(c);
+        }
+        if (norm16 < minYesNo) {
+            // c does not decompose
+            buffer.append(c, 0);
+        } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
+            // Hangul syllable: decompose algorithmically
+            Hangul.decompose(c, buffer);
+        } else {
+            // c decomposes, get everything from the variable-length extra data
+            int mapping=norm16>>OFFSET_SHIFT;
+            int firstUnit=extraData.charAt(mapping);
+            int length=firstUnit&MAPPING_LENGTH_MASK;
+            int leadCC, trailCC;
+            trailCC=firstUnit>>8;
+            if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
+                leadCC=extraData.charAt(mapping-1)>>8;
+            } else {
+                leadCC=0;
+            }
+            ++mapping;  // skip over the firstUnit
+            buffer.append(extraData, mapping, mapping+length, leadCC, trailCC);
         }
     }
 
@@ -2052,6 +2087,7 @@ public final class Normalizer2Impl {
         if(isInert(norm16)) {
             return -1;
         } else if(norm16<minYesNoMappingsOnly) {
+            // a combines forward.
             if(isJamoL(norm16)) {
                 b-=Hangul.JAMO_V_BASE;
                 if(0<=b && b<Hangul.JAMO_V_COUNT) {
@@ -2062,28 +2098,26 @@ public final class Normalizer2Impl {
                 } else {
                     return -1;
                 }
-            } else if(isHangul(norm16)) {
+            } else if(isHangulLV(norm16)) {
                 b-=Hangul.JAMO_T_BASE;
-                if(Hangul.isHangulWithoutJamoT((char)a) && 0<b && b<Hangul.JAMO_T_COUNT) {  // not b==0!
+                if(0<b && b<Hangul.JAMO_T_COUNT) {  // not b==0!
                     return a+b;
                 } else {
                     return -1;
                 }
             } else {
                 // 'a' has a compositions list in extraData
-                list=norm16;
+                list=((MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16)>>OFFSET_SHIFT;
                 if(norm16>minYesNo) {  // composite 'a' has both mapping & compositions list
                     list+=  // mapping pointer
-                        1+  // +1 to skip the first unit with the mapping lenth
-                        (extraData.charAt(list)&MAPPING_LENGTH_MASK);  // + mapping length
+                        1+  // +1 to skip the first unit with the mapping length
+                        (maybeYesCompositions.charAt(list)&MAPPING_LENGTH_MASK);  // + mapping length
                 }
-                // Turn the offset-into-extraData into an offset-into-maybeYesCompositions.
-                list+=MIN_NORMAL_MAYBE_YES-minMaybeYes;
             }
         } else if(norm16<minMaybeYes || MIN_NORMAL_MAYBE_YES<=norm16) {
             return -1;
         } else {
-            list=norm16-minMaybeYes;  // offset into maybeYesCompositions
+            list=getCompositionsListForMaybe(norm16);  // offset into maybeYesCompositions
         }
         if(b<0 || 0x10ffff<b) {  // combine(list, b) requires a valid code point b
             return -1;
@@ -2099,40 +2133,42 @@ public final class Normalizer2Impl {
      * (isCompYesAndZeroCC()) so we need not decompose.
      */
     private boolean hasCompBoundaryBefore(int c, int norm16) {
-        for(;;) {
-            if(isCompYesAndZeroCC(norm16)) {
-                return true;
-            } else if(isMaybeOrNonZeroCC(norm16)) {
-                return false;
-            } else if(isDecompNoAlgorithmic(norm16)) {
-                c=mapAlgorithmic(c, norm16);
-                norm16=getNorm16(c);
-            } else {
-                // c decomposes, get everything from the variable-length extra data
-                int firstUnit=extraData.charAt(norm16);
-                if((firstUnit&MAPPING_LENGTH_MASK)==0) {
-                    return false;
-                }
-                if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0 && (extraData.charAt(norm16-1)&0xff00)!=0) {
-                    return false;  // non-zero leadCC
-                }
-                return isCompYesAndZeroCC(getNorm16(Character.codePointAt(extraData, norm16+1)));
-            }
-        }
+        return c<minCompNoMaybeCP || norm16HasCompBoundaryBefore(norm16);
     }
-    private int findPreviousCompBoundary(CharSequence s, int p) {
+    private boolean norm16HasCompBoundaryBefore(int norm16) {
+        return norm16 < minNoNoCompNoMaybeCC || isAlgorithmicNoNo(norm16);
+    }
+    private boolean hasCompBoundaryBefore(CharSequence s, int src, int limit) {
+        return src == limit || hasCompBoundaryBefore(Character.codePointAt(s, src));
+    }
+    private boolean norm16HasCompBoundaryAfter(int norm16, boolean onlyContiguous) {
+        return (norm16 & HAS_COMP_BOUNDARY_AFTER) != 0 &&
+            (!onlyContiguous || isTrailCC01ForCompBoundaryAfter(norm16));
+    }
+    private boolean hasCompBoundaryAfter(CharSequence s, int start, int p, boolean onlyContiguous) {
+        return start == p || hasCompBoundaryAfter(Character.codePointBefore(s, p), onlyContiguous);
+    }
+    /** For FCC: Given norm16 HAS_COMP_BOUNDARY_AFTER, does it have tccc<=1? */
+    private boolean isTrailCC01ForCompBoundaryAfter(int norm16) {
+        return isInert(norm16) || (isDecompNoAlgorithmic(norm16) ?
+            (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1 : extraData.charAt(norm16 >> OFFSET_SHIFT) <= 0x1ff);
+    }
+
+    private int findPreviousCompBoundary(CharSequence s, int p, boolean onlyContiguous) {
         while(p>0) {
             int c=Character.codePointBefore(s, p);
-            p-=Character.charCount(c);
-            if(hasCompBoundaryBefore(c)) {
+            int norm16 = getNorm16(c);
+            if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                break;
+            }
+            p-=Character.charCount(c);
+            if(hasCompBoundaryBefore(c, norm16)) {
                 break;
             }
-            // We could also test hasCompBoundaryAfter() and return iter.codePointLimit,
-            // but that's probably not worth the extra cost.
         }
         return p;
     }
-    private int findNextCompBoundary(CharSequence s, int p, int limit) {
+    private int findNextCompBoundary(CharSequence s, int p, int limit, boolean onlyContiguous) {
         while(p<limit) {
             int c=Character.codePointAt(s, p);
             int norm16=normTrie.get(c);
@@ -2140,6 +2176,9 @@ public final class Normalizer2Impl {
                 break;
             }
             p+=Character.charCount(c);
+            if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                break;
+            }
         }
         return p;
     }
@@ -2147,8 +2186,12 @@ public final class Normalizer2Impl {
     private int findPreviousFCDBoundary(CharSequence s, int p) {
         while(p>0) {
             int c=Character.codePointBefore(s, p);
+            int norm16;
+            if (c < minDecompNoCP || norm16HasDecompBoundaryAfter(norm16 = getNorm16(c))) {
+                break;
+            }
             p-=Character.charCount(c);
-            if(c<MIN_CCC_LCCC_CP || getFCD16(c)<=0xff) {
+            if (norm16HasDecompBoundaryBefore(norm16)) {
                 break;
             }
         }
@@ -2157,14 +2200,25 @@ public final class Normalizer2Impl {
     private int findNextFCDBoundary(CharSequence s, int p, int limit) {
         while(p<limit) {
             int c=Character.codePointAt(s, p);
-            if(c<MIN_CCC_LCCC_CP || getFCD16(c)<=0xff) {
+            int norm16;
+            if (c < minLcccCP || norm16HasDecompBoundaryBefore(norm16 = getNorm16(c))) {
                 break;
             }
             p+=Character.charCount(c);
+            if (norm16HasDecompBoundaryAfter(norm16)) {
+                break;
+            }
         }
         return p;
     }
 
+    private int getPreviousTrailCC(CharSequence s, int start, int p) {
+        if (start == p) {
+            return 0;
+        }
+        return getFCD16(Character.codePointBefore(s, p));
+    }
+
     private void addToStartSet(Trie2Writable newData, int origin, int decompLead) {
         int canonValue=newData.get(decompLead);
         if((canonValue&(CANON_HAS_SET|CANON_VALUE_MASK))==0 && origin!=0) {
@@ -2192,22 +2246,26 @@ public final class Normalizer2Impl {
     @SuppressWarnings("unused")
     private VersionInfo dataVersion;
 
-    // Code point thresholds for quick check codes.
+    // BMP code point thresholds for quick check loops looking at single UTF-16 code units.
     private int minDecompNoCP;
     private int minCompNoMaybeCP;
+    private int minLcccCP;
 
     // Norm16 value thresholds for quick check combinations and types of extra data.
     private int minYesNo;
     private int minYesNoMappingsOnly;
     private int minNoNo;
+    private int minNoNoCompBoundaryBefore;
+    private int minNoNoCompNoMaybeCC;
+    private int minNoNoEmpty;
     private int limitNoNo;
+    private int centerNoNoDelta;
     private int minMaybeYes;
 
     private Trie2_16 normTrie;
     private String maybeYesCompositions;
     private String extraData;  // mappings and/or compositions for yesYes, yesNo & noNo characters
     private byte[] smallFCD;  // [0x100] one bit per 32 BMP code points, set if any FCD!=0
-    private int[] tccc180;  // [0x180] tccc values for U+0000..U+017F
 
     private Trie2_32 canonIterData;
     private ArrayList<UnicodeSet> canonStartSets;
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/text/Normalizer2.java b/icu4j/main/classes/core/src/com/ibm/icu/text/Normalizer2.java
index e2e40de4df4..be113062cb6 100644
--- a/icu4j/main/classes/core/src/com/ibm/icu/text/Normalizer2.java
+++ b/icu4j/main/classes/core/src/com/ibm/icu/text/Normalizer2.java
@@ -223,8 +223,10 @@ public abstract class Normalizer2 {
             if(spanLength==src.length()) {
                 return (String)src;
             }
-            StringBuilder sb=new StringBuilder(src.length()).append(src, 0, spanLength);
-            return normalizeSecondAndAppend(sb, src.subSequence(spanLength, src.length())).toString();
+            if (spanLength != 0) {
+                StringBuilder sb=new StringBuilder(src.length()).append(src, 0, spanLength);
+                return normalizeSecondAndAppend(sb, src.subSequence(spanLength, src.length())).toString();
+            }
         }
         return normalize(src, new StringBuilder(src.length())).toString();
     }
diff --git a/icu4j/main/shared/data/icudata.jar b/icu4j/main/shared/data/icudata.jar
index f95484640df..9f756def957 100755
--- a/icu4j/main/shared/data/icudata.jar
+++ b/icu4j/main/shared/data/icudata.jar
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a9b7099447b42325988ae448908ba0e690cf9c8259667c49019cc15d3a0fb760
-size 12224152
+oid sha256:d4b1866a85ceb079d912a3283e5ec6a7d6988df8c0e56e98fd67def82c35dcf3
+size 12225515
diff --git a/icu4j/main/shared/data/testdata.jar b/icu4j/main/shared/data/testdata.jar
index 7530a122feb..b328d872ff9 100755
--- a/icu4j/main/shared/data/testdata.jar
+++ b/icu4j/main/shared/data/testdata.jar
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a7bc00733ee580f117cfecc6c1790df5c495dea56dddd2472f6253c4baafd664
-size 812715
+oid sha256:fd856769e94b963fb8a0b63148c63349198ef0c0ec3729173170ccbfd94c4999
+size 812769
diff --git a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/normalizer/BasicTest.java b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/normalizer/BasicTest.java
index d88f3caa346..f146ba959fb 100644
--- a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/normalizer/BasicTest.java
+++ b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/normalizer/BasicTest.java
@@ -183,8 +183,8 @@ public class BasicTest extends TestFmwk {
     @Test
     public void TestCanonCompose() throws Exception{
         Normalizer norm = new Normalizer("", Normalizer.NFC,0);
-        iterateTest(norm, canonTests, 2);
         staticTest(Normalizer.NFC, canonTests, 2);
+        iterateTest(norm, canonTests, 2);
         composeTest(Normalizer.NFC, canonTests, 2);
     }
 
@@ -2412,6 +2412,10 @@ public class BasicTest extends TestFmwk {
         return skipSets;
     }
 
+    private static String[] kModeStrings = {
+        "D", "C", "KD", "KC"
+    };
+
     @Test
     public void TestSkippable() {
         UnicodeSet[] skipSets = new UnicodeSet[] {
@@ -2440,7 +2444,8 @@ public class BasicTest extends TestFmwk {
         }
         for(int i=0; i<expectSets.length; ++i) {
             if(!skipSets[i].equals(expectSets[i])) {
-                errln("error: TestSkippable skipSets["+i+"]!=expectedSets["+i+"]\n");
+                String ms = kModeStrings[i];
+                errln("error: TestSkippable skipSets["+ms+"]!=expectedSets["+ms+"]\n");
                 // Note: This used to depend on hardcoded UnicodeSet patterns generated by
                 // Mark's unicodetools.com.ibm.text.UCD.NFSkippable, by
                 // running com.ibm.text.UCD.Main with the option NFSkippable.
@@ -2797,6 +2802,58 @@ public class BasicTest extends TestFmwk {
                 " \u1E09", out);
     }
 
+    @Test
+    public void TestLowMappingToEmpty_D() {
+        Normalizer2 n2 = Normalizer2.getInstance(null, "nfkc_cf", Normalizer2.Mode.DECOMPOSE);
+        checkLowMappingToEmpty(n2);
+
+        String sh = "\u00AD";
+        assertFalse("soft hyphen is not normalized", n2.isNormalized(sh));
+        String result = n2.normalize(sh);
+        assertTrue("soft hyphen normalizes to empty", result.isEmpty());
+        assertEquals("soft hyphen QC=No", Normalizer.NO, n2.quickCheck(sh));
+        assertEquals("soft hyphen spanQuickCheckYes", 0, n2.spanQuickCheckYes(sh));
+
+        String s = "\u00ADÄ\u00AD\u0323";
+        result = n2.normalize(s);
+        assertEquals("normalize string with soft hyphens", "a\u0323\u0308", result);
+    }
+
+    @Test
+    public void TestLowMappingToEmpty_FCD() {
+        Normalizer2 n2 = Normalizer2.getInstance(null, "nfkc_cf", Normalizer2.Mode.FCD);
+        checkLowMappingToEmpty(n2);
+
+        String sh = "\u00AD";
+        assertTrue("soft hyphen is FCD", n2.isNormalized(sh));
+
+        String s = "\u00ADÄ\u00AD\u0323";
+        String result = n2.normalize(s);
+        assertEquals("normalize string with soft hyphens", "\u00ADa\u0323\u0308", result);
+    }
+
+    private void checkLowMappingToEmpty(Normalizer2 n2) {
+        String mapping = n2.getDecomposition(0xad);
+        assertNotNull("getDecomposition(soft hyphen)", mapping);
+        assertTrue("soft hyphen maps to empty", mapping.isEmpty());
+        assertFalse("soft hyphen has no boundary before", n2.hasBoundaryBefore(0xad));
+        assertFalse("soft hyphen has no boundary after", n2.hasBoundaryAfter(0xad));
+        assertFalse("soft hyphen is not inert", n2.isInert(0xad));
+    }
+
+    @Test
+    public void TestNormalizeIllFormedText() {
+        Normalizer2 nfkc_cf = Normalizer2.getNFKCCasefoldInstance();
+        // Normalization behavior for ill-formed text is not defined.
+        // ICU currently treats ill-formed sequences as normalization-inert
+        // and copies them unchanged.
+        String src = "  A\uD800ÄA\u0308\uD900A\u0308\u00ad\u0323\uDBFFÄ\u0323," +
+                "\u00ad\uDC00\u1100\u1161가\u11A8가\u3133  \uDFFF";
+        String expected = "  a\uD800ää\uD900ạ\u0308\uDBFFạ\u0308,\uDC00가각갃  \uDFFF";
+        String result = nfkc_cf.normalize(src);
+        assertEquals("normalize", expected, result);
+    }
+
     @Test
     public void TestNFC() {
         // Coverage tests.
@@ -2848,18 +2905,6 @@ public class BasicTest extends TestFmwk {
         assertTrue("noop.isInert()", noop.isInert(0x0308));
     }
 
-    /*
-     * This unit test covers two 'get' methods in class Normalizer2Impl. It only tests that
-     * an object is returned.
-     */
-    @Test
-    public void TestGetsFromImpl() {
-       Normalizer2Impl nfcImpl = Norm2AllModes.getNFCInstance().impl;
-       assertNotEquals("getNormTrie() returns null", null, nfcImpl.getNormTrie());
-       assertNotEquals("getFCD16FromBelow180() returns null", null,
-                       nfcImpl.getFCD16FromBelow180(0));
-    }
-
     /*
      * Abstract class Normalizer2 has non-abstract methods which are overwritten by
      * its derived classes. To test these methods a derived class is defined here.
diff --git a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/normalizer/ConformanceTest.java b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/normalizer/ConformanceTest.java
index ae35f5864d9..75924f023ad 100644
--- a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/normalizer/ConformanceTest.java
+++ b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/normalizer/ConformanceTest.java
@@ -36,7 +36,7 @@ public class ConformanceTest extends TestFmwk {
     static  String[] moreCases ={
         // Markus 2001aug30
         "0061 0332 0308;00E4 0332;0061 0332 0308;00E4 0332;0061 0332 0308; # Markus 0",
-    
+
         // Markus 2001oct26 - test edge case for iteration: U+0f73.cc==0 but decomposition.lead.cc==129
         "0061 0301 0F73;00E1 0F71 0F72;0061 0F71 0F72 0301;00E1 0F71 0F72;0061 0F71 0F72 0301; # Markus 1"
     };
@@ -54,7 +54,7 @@ public class ConformanceTest extends TestFmwk {
     public void TestConformance_3_2() throws Exception{
         runConformance("unicode/NormalizationTest-3.2.0.txt",Normalizer.UNICODE_3_2);
     }
-    
+
     public void runConformance(String fileName, int options) throws Exception{
         String line = null;
         String[] fields = new String[5];
@@ -88,10 +88,10 @@ public class ConformanceTest extends TestFmwk {
 
                 // Parse out the fields
                 hexsplit(line, ';', fields, buf);
-                
+
                 // Remove a single code point from the "other" UnicodeSet
                 if(fields[0].length()==UTF16.moveCodePointOffset(fields[0],0, 1)) {
-                    c=UTF16.charAt(fields[0],0); 
+                    c=UTF16.charAt(fields[0],0);
                     if(0xac20<=c && c<=0xd73f) {
                         // not an exhaustive test run: skip most Hangul syllables
                         if(c==0xac20) {
@@ -132,7 +132,7 @@ public class ConformanceTest extends TestFmwk {
             logln("Total: " + passCount + " lines passed");
         }
     }
-    
+
     /**
      * Verify the conformance of the given line of the Unicode
      * normalization (UTR 15) test suite file.  For each line,
@@ -154,74 +154,16 @@ public class ConformanceTest extends TestFmwk {
         String out,fcd;
         int i=0;
         for (i=0; i<5; ++i) {
+            int fieldNum = i+1;
             if (i<3) {
-                out = Normalizer.normalize(field[i], Normalizer.NFC, options);
-                pass &= assertEqual("C", field[i], out, field[1], "c2!=C(c" + (i+1));
-                
-                out = iterativeNorm(field[i], Normalizer.NFC, buf, +1,options);
-                pass &= assertEqual("C(+1)", field[i], out, field[1], "c2!=C(c" + (i+1));
-                
-                out = iterativeNorm(field[i], Normalizer.NFC, buf, -1,options);
-                pass &= assertEqual("C(-1)", field[i], out, field[1], "c2!=C(c" + (i+1));
-
-                out = iterativeNorm(new StringCharacterIterator(field[i]), Normalizer.NFC, buf, +1,options);
-                pass &= assertEqual("C(+1)", field[i], out, field[1], "c2!=C(c" + (i+1));
-                
-                out = iterativeNorm(new StringCharacterIterator(field[i]), Normalizer.NFC, buf, -1,options);
-                pass &= assertEqual("C(-1)", field[i], out, field[1], "c2!=C(c" + (i+1));
-                 
-                out = Normalizer.normalize(field[i], Normalizer.NFD);
-                pass &= assertEqual("D", field[i], out, field[2], "c3!=D(c" + (i+1));
-                
-                out = iterativeNorm(field[i], Normalizer.NFD, buf, +1,options);
-                pass &= assertEqual("D(+1)", field[i], out, field[2], "c3!=D(c" + (i+1));
-                
-                out = iterativeNorm(field[i], Normalizer.NFD, buf, -1,options);
-                pass &= assertEqual("D(-1)", field[i], out, field[2], "c3!=D(c" + (i+1));
-
-                out = iterativeNorm(new StringCharacterIterator(field[i]), Normalizer.NFD, buf, +1,options);
-                pass &= assertEqual("D(+1)", field[i], out, field[2], "c3!=D(c" + (i+1));
-                
-                out = iterativeNorm(new StringCharacterIterator(field[i]), Normalizer.NFD, buf, -1,options);
-                pass &= assertEqual("D(-1)", field[i], out, field[2], "c3!=D(c" + (i+1));
-                
-                cross(field[2] /*NFD String*/, field[1]/*NFC String*/, Normalizer.NFC);
-                cross(field[1] /*NFC String*/, field[2]/*NFD String*/, Normalizer.NFD);
+                pass &= checkNorm(Normalizer.NFC, options, field[i], field[1], fieldNum);
+                pass &= checkNorm(Normalizer.NFD, options, field[i], field[2], fieldNum);
             }
-            out = Normalizer.normalize(field[i], Normalizer.NFKC,options);
-            pass &= assertEqual("KC", field[i], out, field[3], "c4!=KC(c" + (i+1));
-            
-            out = iterativeNorm(field[i], Normalizer.NFKC, buf, +1,options);
-            pass &= assertEqual("KD(+1)", field[i], out, field[3], "c4!=KC(c" + (i+1));
-            
-            out = iterativeNorm(field[i], Normalizer.NFKC, buf, -1,options);
-            pass &= assertEqual("KD(-1)", field[i], out, field[3], "c4!=KC(c" + (i+1));
-
-            out = iterativeNorm(new StringCharacterIterator(field[i]), Normalizer.NFKC, buf, +1,options);
-            pass &= assertEqual("KD(+1)", field[i], out, field[3], "c4!=KC(c" + (i+1));
-            
-            out = iterativeNorm(new StringCharacterIterator(field[i]), Normalizer.NFKC, buf, -1,options);
-            pass &= assertEqual("KD(-1)", field[i], out, field[3], "c4!=KC(c" + (i+1));
-              
-
-            out = Normalizer.normalize(field[i], Normalizer.NFKD,options);
-            pass &= assertEqual("KD", field[i], out, field[4], "c5!=KD(c" + (i+1));
-            
-            out = iterativeNorm(field[i], Normalizer.NFKD, buf, +1,options);
-            pass &= assertEqual("KD(+1)", field[i], out, field[4], "c5!=KD(c" + (i+1));
-            
-            out = iterativeNorm(field[i], Normalizer.NFKD, buf, -1,options);
-            pass &= assertEqual("KD(-1)", field[i], out, field[4], "c5!=KD(c" + (i+1));
-         
-            out = iterativeNorm(new StringCharacterIterator(field[i]), Normalizer.NFKD, buf, +1,options);
-            pass &= assertEqual("KD(+1)", field[i], out, field[4], "c5!=KD(c" + (i+1));
-            
-            out = iterativeNorm(new StringCharacterIterator(field[i]), Normalizer.NFKD, buf, -1,options);
-            pass &= assertEqual("KD(-1)", field[i], out, field[4], "c5!=KD(c" + (i+1));
-            
+            pass &= checkNorm(Normalizer.NFKC, options, field[i], field[3], fieldNum);
+            pass &= checkNorm(Normalizer.NFKD, options, field[i], field[4], fieldNum);
             cross(field[4] /*NFKD String*/, field[3]/*NFKC String*/, Normalizer.NFKC);
             cross(field[3] /*NFKC String*/, field[4]/*NFKD String*/, Normalizer.NFKD);
-  
+
         }
         compare(field[1],field[2]);
         compare(field[0],field[1]);
@@ -243,7 +185,7 @@ public class ConformanceTest extends TestFmwk {
             errln("Normalizer error: quickCheck(NFKD(s), Normalizer.NFKD) is Normalizer.NO");
             pass = false;
         }
-    
+
         if(!Normalizer.isNormalized(field[1], Normalizer.NFC, options)) {
             errln("Normalizer error: isNormalized(NFC(s), Normalizer.NFC) is false");
             pass = false;
@@ -298,24 +240,24 @@ public class ConformanceTest extends TestFmwk {
             errln("Normalizer error: quickCheck(NFKD(s), Normalizer.FCD) is Normalizer.NO");
             pass = false;
         }
-        
+
         out = iterativeNorm(new StringCharacterIterator(field[0]), Normalizer.FCD, buf, +1,options);
         out = iterativeNorm(new StringCharacterIterator(field[0]), Normalizer.FCD, buf, -1,options);
-        
+
         out = iterativeNorm(new StringCharacterIterator(field[2]), Normalizer.FCD, buf, +1,options);
         out = iterativeNorm(new StringCharacterIterator(field[2]), Normalizer.FCD, buf, -1,options);
-        
+
         out = iterativeNorm(new StringCharacterIterator(field[4]), Normalizer.FCD, buf, +1,options);
         out = iterativeNorm(new StringCharacterIterator(field[4]), Normalizer.FCD, buf, -1,options);
-        
+
         out=Normalizer.normalize(fcd, Normalizer.NFD);
         if(!out.equals(field[2])) {
             errln("Normalizer error: NFD(FCD(s))!=NFD(s)");
             pass = false;
-        }    
+        }
         if (!pass) {
             errln("FAIL: " + line);
-        }     
+        }
         if(field[0]!=field[2]) {
             // two strings that are canonically equivalent must test
             // equal under a canonical caseless match
@@ -327,9 +269,57 @@ public class ConformanceTest extends TestFmwk {
                pass=false;
             }
         }
-        
+
         return pass;
     }
+
+    private static int getModeNumber(Normalizer.Mode mode) {
+        if (mode == Normalizer.NFD) { return 0; }
+        if (mode == Normalizer.NFKD) { return 1; }
+        if (mode == Normalizer.NFC) { return 2; }
+        if (mode == Normalizer.NFKC) { return 3; }
+        return -1;
+    }
+    private static final String[] kModeStrings = {
+        "D", "KD", "C", "KC"
+    };
+    private static final String[] kMessages = {
+        "c3!=D(c%d)", "c5!=KC(c%d)", "c2!=C(c%d)", "c4!=KC(c%d)"
+    };
+
+    boolean checkNorm(Normalizer.Mode mode, int options,  // Normalizer2 norm2,
+            String s, String exp, int field) throws Exception {
+        String modeString = kModeStrings[getModeNumber(mode)];
+        String msg = String.format(kMessages[getModeNumber(mode)], field);
+        StringBuffer buf = new StringBuffer();
+        String out = Normalizer.normalize(s, mode, options);
+        if (!assertEqual(modeString, "", s, out, exp, msg)) {
+            return false;
+        }
+
+        out = iterativeNorm(s, mode, buf, +1,options);
+        if (!assertEqual(modeString, "(+1)", s, out, exp, msg)) {
+            return false;
+        }
+
+        out = iterativeNorm(s, mode, buf, -1,options);
+        if (!assertEqual(modeString, "(-1)", s, out, exp, msg)) {
+            return false;
+        }
+
+        out = iterativeNorm(new StringCharacterIterator(s), mode, buf, +1,options);
+        if (!assertEqual(modeString, "(+1)", s, out, exp, msg)) {
+            return false;
+        }
+
+        out = iterativeNorm(new StringCharacterIterator(s), mode, buf, -1,options);
+        if (!assertEqual(modeString, "(-1)", s, out, exp, msg)) {
+            return false;
+        }
+
+        return true;
+    }
+
     // two strings that are canonically equivalent must test
     // equal under a canonical caseless match
     // see UAX #21 Case Mappings and Jitterbug 2021 and
@@ -339,26 +329,26 @@ public class ConformanceTest extends TestFmwk {
             if(Normalizer.compare(UTF16.charAt(s1,0),UTF16.charAt(s2,0),Normalizer.COMPARE_IGNORE_CASE)!=0){
                 errln("Normalizer.compare(int,int) failed for s1: "
                         +Utility.hex(s1) + " s2: " + Utility.hex(s2));
-            }    
+            }
         }
         if(s1.length()==1 && s2.length()>1){
             if(Normalizer.compare(UTF16.charAt(s1,0),s2,Normalizer.COMPARE_IGNORE_CASE)!=0){
                 errln("Normalizer.compare(int,String) failed for s1: "
                         +Utility.hex(s1) + " s2: " + Utility.hex(s2));
-            }    
+            }
         }
         if(s1.length()>1 && s2.length()>1){
             // TODO: Re-enable this tests after UTC fixes UAX 21
             if(Normalizer.compare(s1.toCharArray(),s2.toCharArray(),Normalizer.COMPARE_IGNORE_CASE)!=0){
                 errln("Normalizer.compare(char[],char[]) failed for s1: "
                         +Utility.hex(s1) + " s2: " + Utility.hex(s2));
-            }    
-        }    
+            }
+        }
     }
     private void cross(String s1, String s2,Normalizer.Mode mode){
         String result = Normalizer.normalize(s1,mode);
         if(!result.equals(s2)){
-            errln("cross test failed s1: " + Utility.hex(s1) + " s2: " 
+            errln("cross test failed s1: " + Utility.hex(s1) + " s2: "
                         +Utility.hex(s2));
         }
     }
@@ -389,7 +379,7 @@ public class ConformanceTest extends TestFmwk {
         }
         return buf.toString();
     }
-    
+
     /**
      * Do a normalization using the iterative API in the given direction.
      * @param str a Java StringCharacterIterator
@@ -421,18 +411,19 @@ public class ConformanceTest extends TestFmwk {
 
     /**
      * @param op name of normalization form, e.g., "KC"
+     * @param op2 name of test case variant, e.g., "(-1)"
      * @param s string being normalized
      * @param got value received
      * @param exp expected value
      * @param msg description of this test
      * @returns true if got == exp
      */
-    private boolean assertEqual(String op, String s, String got,
+    private boolean assertEqual(String op, String op2, String s, String got,
                                 String exp, String msg) {
         if (exp.equals(got)) {
             return true;
         }
-        errln(("      " + msg + ") " + op + "(" + s + ")=" + hex(got) +
+        errln(("      " + msg + ": " + op + op2 + '(' + s + ")=" + hex(got) +
                              ", exp. " + hex(exp)));
         return false;
     }
@@ -459,7 +450,7 @@ public class ConformanceTest extends TestFmwk {
             }
             // Our field is from pos..delim-1.
             buf.setLength(0);
-            
+
             String toHex = s.substring(pos,delim);
             pos = delim;
             int index = 0;
@@ -478,7 +469,7 @@ public class ConformanceTest extends TestFmwk {
                     index = spacePos+1;
                 }
             }
-            
+
             if (buf.length() < 1) {
                 throw new IllegalArgumentException("Empty field " + i + " in " + s);
             }
@@ -492,13 +483,13 @@ public class ConformanceTest extends TestFmwk {
             throw new IllegalArgumentException("Out of range hex " +
                                                 hex + " in " + s);
         }else if (hex > 0xFFFF){
-            buf.append((char)((hex>>10)+0xd7c0)); 
+            buf.append((char)((hex>>10)+0xd7c0));
             buf.append((char)((hex&0x3ff)|0xdc00));
         }else{
             buf.append((char) hex);
         }
     }
-            
+
     // Specific tests for debugging.  These are generally failures
     // taken from the conformance file, but culled out to make
     // debugging easier.  These can be eliminated without affecting
@@ -516,6 +507,6 @@ public class ConformanceTest extends TestFmwk {
         hexsplit(line, ';', fields, buf);
         checkConformance(fields, line,options);
     }
-    
+
 
 }