Merge Android 24Q1 Release (ab/11220357)

Bug: 319669529
Merged-In: Icfd0ce32db4f770bd1b0c5f164c4c87e846ae1d9
Change-Id: I97001fa86dc3f6af805ebf43156e941b0e1aa75a

87 files changed, 16904 insertions, 1009 deletions

diff --git a/TEST_MAPPING b/TEST_MAPPING
index 279657d..287c353 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -2,6 +2,25 @@
   "presubmit": [
     {
       "name": "minikin_tests"
+    },
+    {
+      "name": "CtsTextTestCases",
+      "options": [
+          {
+              "exclude-annotation": "androidx.test.filters.FlakyTest"
+          },
+          {
+              "exclude-annotation": "androidx.test.filters.LargeTest"
+          }
+      ]
+    },
+    {
+      "name": "CtsGraphicsTestCases",
+      "options": [
+          {
+              "exclude-annotation": "androidx.test.filters.FlakyTest"
+          }
+      ]
     }
   ]
 }
diff --git a/include/minikin/AndroidLineBreakerHelper.h b/include/minikin/AndroidLineBreakerHelper.h
index 302d2b1..88dd2dd 100644
--- a/include/minikin/AndroidLineBreakerHelper.h
+++ b/include/minikin/AndroidLineBreakerHelper.h
@@ -74,11 +74,17 @@ private:
 class StaticLayoutNative {
 public:
     StaticLayoutNative(BreakStrategy strategy, HyphenationFrequency frequency, bool isJustified,
-                       std::vector<float>&& indents)
+                       std::vector<float>&& indents, bool useBoundsForWidth)
             : mStrategy(strategy),
               mFrequency(frequency),
               mIsJustified(isJustified),
-              mIndents(std::move(indents)) {}
+              mIndents(std::move(indents)),
+              mUseBoundsForWidth(useBoundsForWidth) {}
+
+    StaticLayoutNative(BreakStrategy strategy, HyphenationFrequency frequency, bool isJustified,
+                       std::vector<float>&& indents)
+            : StaticLayoutNative(strategy, frequency, isJustified, std::move(indents),
+                                 false /* useBoundsForWidth */) {}
 
     LineBreakResult computeBreaks(const U16StringPiece& textBuf, const MeasuredText& measuredText,
                                   // Line width arguments
@@ -90,7 +96,8 @@ public:
         AndroidLineWidth lineWidth(firstWidth, firstWidthLineCount, restWidth, mIndents,
                                    indentsOffset);
         return breakIntoLines(textBuf, mStrategy, mFrequency, mIsJustified, measuredText, lineWidth,
-                              TabStops(tabStops, tabStopSize, defaultTabStopWidth));
+                              TabStops(tabStops, tabStopSize, defaultTabStopWidth),
+                              mUseBoundsForWidth);
     }
 
     inline BreakStrategy getStrategy() const { return mStrategy; }
@@ -104,6 +111,7 @@ private:
     const std::vector<float> mIndents;
     const std::vector<float> mLeftPaddings;
     const std::vector<float> mRightPaddings;
+    const bool mUseBoundsForWidth;
 };
 
 }  // namespace android
diff --git a/include/minikin/BoundsCache.h b/include/minikin/BoundsCache.h
deleted file mode 100644
index 64f2b49..0000000
--- a/include/minikin/BoundsCache.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MINIKIN_BOUNDS_CACHE_H
-#define MINIKIN_BOUNDS_CACHE_H
-
-#include "minikin/LayoutCache.h"
-
-#include <mutex>
-
-#include <utils/LruCache.h>
-
-#include "minikin/BoundsCache.h"
-#include "minikin/FontCollection.h"
-#include "minikin/Hasher.h"
-#include "minikin/MinikinPaint.h"
-
-namespace minikin {
-
-// Cache entry
-struct BoundsValue {
-    MinikinRect rect;
-    float advance;
-};
-
-// Used for callback for LayoutCache.
-struct ValueExtractor {
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint);
-    std::unique_ptr<BoundsValue> value;
-};
-
-class BoundsCache : private android::OnEntryRemoved<LayoutCacheKey, BoundsValue*> {
-public:
-    void clear() {
-        std::lock_guard<std::mutex> lock(mMutex);
-        mCache.clear();
-    }
-
-    // Do not use BoundsCache inside the callback function, otherwise dead-lock may happen.
-    template <typename F>
-    void getOrCreate(const U16StringPiece& text, const Range& range, const MinikinPaint& paint,
-                     bool dir, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen, F& f) {
-        LayoutCacheKey key(text, range, paint, dir, startHyphen, endHyphen);
-        if (paint.skipCache() || range.getLength() >= LENGTH_LIMIT_CACHE) {
-            LayoutPiece piece = LayoutPiece(text, range, dir, paint, startHyphen, endHyphen);
-            f(getBounds(piece, paint), piece.advance());
-            return;
-        }
-        {
-            std::lock_guard<std::mutex> lock(mMutex);
-            BoundsValue* value = mCache.get(key);
-            if (value != nullptr) {
-                f(value->rect, value->advance);
-                return;
-            }
-        }
-        // Doing text layout takes long time, so releases the mutex during doing layout.
-        // Don't care even if we do the same layout in other thread.
-        key.copyText();
-        ValueExtractor ve;
-        LayoutCache::getInstance().getOrCreate(text, range, paint, dir, startHyphen, endHyphen, ve);
-        f(ve.value->rect, ve.value->advance);
-        {
-            std::lock_guard<std::mutex> lock(mMutex);
-            mCache.put(key, ve.value.release());
-        }
-    }
-
-    static BoundsCache& getInstance() {
-        static BoundsCache cache(kMaxEntries);
-        return cache;
-    }
-
-    // Compute new bounding box for the layout piece.
-    static MinikinRect getBounds(const LayoutPiece& layoutPiece, const MinikinPaint& paint);
-
-protected:
-    BoundsCache(uint32_t maxEntries) : mCache(maxEntries) {
-        mCache.setOnEntryRemovedListener(this);
-    }
-
-private:
-    // callback for OnEntryRemoved
-    void operator()(LayoutCacheKey& key, BoundsValue*& value) {
-        key.freeText();
-        delete value;
-    }
-
-    std::mutex mMutex;
-    android::LruCache<LayoutCacheKey, BoundsValue*> mCache GUARDED_BY(mMutex) GUARDED_BY(mMutex);
-    // LRU cache capacity. Should be fine to be less than LayoutCache#kMaxEntries since bbox
-    // calculation happens less than layout calculation.
-    static const size_t kMaxEntries = 500;
-};
-
-}  // namespace minikin
-#endif  // MINIKIN_BOUNDS_CACHE_H
diff --git a/include/minikin/Characters.h b/include/minikin/Characters.h
index 074d134..d298d07 100644
--- a/include/minikin/Characters.h
+++ b/include/minikin/Characters.h
@@ -34,6 +34,7 @@ constexpr uint32_t CHAR_MAQAF = 0x05BE;
 constexpr uint32_t CHAR_UCAS_HYPHEN = 0x1400;
 constexpr uint32_t CHAR_ZWJ = 0x200D;
 constexpr uint32_t CHAR_HYPHEN = 0x2010;
+constexpr uint32_t CHAR_REPLACEMENT_CHARACTER = 0xFFFD;
 
 }  // namespace minikin
 
diff --git a/include/minikin/Constants.h b/include/minikin/Constants.h
new file mode 100644
index 0000000..ba074e4
--- /dev/null
+++ b/include/minikin/Constants.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINIKIN_CONST_H
+#define MINIKIN_CONST_H
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "minikin/FontVariation.h"
+
+namespace minikin {
+
+constexpr uint32_t MakeTag(char c1, char c2, char c3, char c4) {
+    return ((uint32_t)c1 << 24) | ((uint32_t)c2 << 16) | ((uint32_t)c3 << 8) | (uint32_t)c4;
+}
+
+// Axis tags
+const uint32_t TAG_wght = MakeTag('w', 'g', 'h', 't');
+const uint32_t TAG_ital = MakeTag('i', 't', 'a', 'l');
+
+}  // namespace minikin
+
+#endif  // MINIKIN_CONST_H
diff --git a/include/minikin/Debug.h b/include/minikin/Debug.h
new file mode 100644
index 0000000..20d8d8d
--- /dev/null
+++ b/include/minikin/Debug.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINIKIN_DEBUG_H
+#define MINIKIN_DEBUG_H
+
+#include <string>
+
+namespace minikin {
+
+struct Point;
+struct MinikinRect;
+struct MinikinExtent;
+struct MinikinPaint;
+struct FontFeature;
+class Range;
+class U16StringPiece;
+class LayoutPiece;
+
+namespace debug {
+
+// Convert UTF16 string to std::string for debugging purpose.
+std::string toUtf8(const U16StringPiece& text);
+
+std::string toString(const Point& point);
+std::string toString(const MinikinRect& rect);
+std::string toString(const Range& range);
+std::string toString(const MinikinExtent& extent);
+std::string toString(const LayoutPiece& layout);
+std::string toString(const MinikinPaint& paint);
+std::string toString(const FontFeature& feature);
+std::string toString(const std::vector<FontFeature>& features);
+
+}  // namespace debug
+
+}  // namespace minikin
+#endif  // MINIKIN_DEBUG_H
diff --git a/include/minikin/FamilyVariant.h b/include/minikin/FamilyVariant.h
index 1734a1f..7711484 100644
--- a/include/minikin/FamilyVariant.h
+++ b/include/minikin/FamilyVariant.h
@@ -18,6 +18,7 @@
 #define MINIKIN_FAMILY_VARIANT_H
 
 #include <cstdint>
+#include <ostream>
 
 namespace minikin {
 
@@ -28,6 +29,19 @@ enum class FamilyVariant : uint8_t {
     ELEGANT = 2,  // Must be the same as FontConfig.VARIANT_ELEGANT
 };
 
+inline std::ostream& operator<<(std::ostream& os, const FamilyVariant& variant) {
+    switch (variant) {
+        case FamilyVariant::DEFAULT:
+            return os << "default";
+        case FamilyVariant::COMPACT:
+            return os << "compact";
+        case FamilyVariant::ELEGANT:
+            return os << "elegant";
+        default:
+            return os << "[UNKNOWN]";
+    }
+}
+
 }  // namespace minikin
 
 #endif  // MINIKIN_FAMILY_VARIANT_H
diff --git a/include/minikin/Font.h b/include/minikin/Font.h
index f144bea..5f85b77 100644
--- a/include/minikin/Font.h
+++ b/include/minikin/Font.h
@@ -20,7 +20,9 @@
 #include <gtest/gtest_prod.h>
 
 #include <atomic>
+#include <map>
 #include <memory>
+#include <mutex>
 #include <unordered_set>
 
 #include "minikin/Buffer.h"
@@ -38,33 +40,65 @@ class Font;
 // attributes representing transforms (fake bold, fake italic) to match styles
 class FontFakery {
 public:
-    FontFakery() : mFakeBold(false), mFakeItalic(false) {}
-    FontFakery(bool fakeBold, bool fakeItalic) : mFakeBold(fakeBold), mFakeItalic(fakeItalic) {}
+    FontFakery() : FontFakery(false, false, -1, -1) {}
+    FontFakery(bool fakeBold, bool fakeItalic) : FontFakery(fakeBold, fakeItalic, -1, -1) {}
+    FontFakery(bool fakeBold, bool fakeItalic, int16_t wghtAdjustment, int8_t italAdjustment)
+            : mBits(pack(fakeBold, fakeItalic, wghtAdjustment, italAdjustment)) {}
+
     // TODO: want to support graded fake bolding
-    bool isFakeBold() { return mFakeBold; }
-    bool isFakeItalic() { return mFakeItalic; }
-    inline bool operator==(const FontFakery& o) const {
-        return mFakeBold == o.mFakeBold && mFakeItalic == o.mFakeItalic;
+    bool isFakeBold() { return (mBits & MASK_FAKE_BOLD) != 0; }
+    bool isFakeItalic() { return (mBits & MASK_FAKE_ITALIC) != 0; }
+    bool hasAdjustment() const { return hasWghtAdjustment() || hasItalAdjustment(); }
+    bool hasWghtAdjustment() const { return (mBits & MASK_HAS_WGHT_ADJUSTMENT) != 0; }
+    bool hasItalAdjustment() const { return (mBits & MASK_HAS_ITAL_ADJUSTMENT) != 0; }
+    int16_t wghtAdjustment() const {
+        if (hasWghtAdjustment()) {
+            return (mBits & MASK_WGHT_ADJUSTMENT) >> WGHT_ADJUSTMENT_SHIFT;
+        } else {
+            return -1;
+        }
+    }
+
+    int8_t italAdjustment() const {
+        if (hasItalAdjustment()) {
+            return (mBits & MASK_ITAL_ADJUSTMENT) != 0 ? 1 : 0;
+        } else {
+            return -1;
+        }
     }
+
+    uint16_t bits() const { return mBits; }
+
+    inline bool operator==(const FontFakery& o) const { return mBits == o.mBits; }
     inline bool operator!=(const FontFakery& o) const { return !(*this == o); }
 
 private:
-    bool mFakeBold;
-    bool mFakeItalic;
-};
-
-struct FakedFont {
-    inline bool operator==(const FakedFont& o) const {
-        return font == o.font && fakery == o.fakery;
+    static constexpr uint16_t MASK_FAKE_BOLD = 1u;
+    static constexpr uint16_t MASK_FAKE_ITALIC = 1u << 1;
+    static constexpr uint16_t MASK_HAS_WGHT_ADJUSTMENT = 1u << 2;
+    static constexpr uint16_t MASK_HAS_ITAL_ADJUSTMENT = 1u << 3;
+    static constexpr uint16_t MASK_ITAL_ADJUSTMENT = 1u << 4;
+    static constexpr uint16_t MASK_WGHT_ADJUSTMENT = 0b1111111111u << 5;
+    static constexpr uint16_t WGHT_ADJUSTMENT_SHIFT = 5;
+
+    uint16_t pack(bool isFakeBold, bool isFakeItalic, int16_t wghtAdjustment,
+                  int8_t italAdjustment) {
+        uint16_t bits = 0u;
+        bits |= isFakeBold ? MASK_FAKE_BOLD : 0;
+        bits |= isFakeItalic ? MASK_FAKE_ITALIC : 0;
+        if (wghtAdjustment != -1) {
+            bits |= MASK_HAS_WGHT_ADJUSTMENT;
+            bits |= (static_cast<uint16_t>(wghtAdjustment) << WGHT_ADJUSTMENT_SHIFT) &
+                    MASK_WGHT_ADJUSTMENT;
+        }
+        if (italAdjustment != -1) {
+            bits |= MASK_HAS_ITAL_ADJUSTMENT;
+            bits |= (italAdjustment == 1) ? MASK_ITAL_ADJUSTMENT : 0;
+        }
+        return bits;
     }
-    inline bool operator!=(const FakedFont& o) const { return !(*this == o); }
 
-    // ownership is the enclosing FontCollection
-    // FakedFont will be stored in the LayoutCache. It is not a good idea too keep font instance
-    // even if the enclosing FontCollection, i.e. Typeface is GC-ed. The layout cache is only
-    // purged when it is overflown, thus intentionally keep only reference.
-    const std::shared_ptr<Font>& font;
-    FontFakery fakery;
+    const uint16_t mBits;
 };
 
 // Represents a single font file.
@@ -121,9 +155,16 @@ public:
     // This locale list is just for API compatibility. This is not used in font selection or family
     // fallback.
     uint32_t getLocaleListId() const { return mLocaleListId; }
-    const std::shared_ptr<MinikinFont>& typeface() const;
     inline FontStyle style() const { return mStyle; }
+
     const HbFontUniquePtr& baseFont() const;
+    const std::shared_ptr<MinikinFont>& baseTypeface() const;
+
+    // Returns an adjusted hb_font_t instance and MinikinFont instance.
+    // Passing -1 each means do not override the current variation settings.
+    HbFontUniquePtr getAdjustedFont(int wght, int ital) const;
+    const std::shared_ptr<MinikinFont>& getAdjustedTypeface(int wght, int ital) const;
+
     BufferReader typefaceMetadataReader() const { return mTypefaceMetadataReader; }
 
     std::unordered_set<AxisTag> getSupportedAxes() const;
@@ -139,6 +180,11 @@ private:
 
         std::shared_ptr<MinikinFont> mTypeface;
         HbFontUniquePtr mBaseFont;
+
+        const std::shared_ptr<MinikinFont>& getAdjustedTypeface(int wght, int ital) const;
+        mutable std::mutex mMutex;
+        mutable std::map<uint16_t, std::shared_ptr<MinikinFont>> mVarTypefaceCache
+                GUARDED_BY(mMutex);
     };
 
     // Use Builder instead.
@@ -152,6 +198,7 @@ private:
     void resetExternalRefs(ExternalRefs* refs);
 
     const ExternalRefs* getExternalRefs() const;
+    std::vector<FontVariation> getAdjustedVariations(int wght, int ital) const;
 
     static HbFontUniquePtr prepareFont(const std::shared_ptr<MinikinFont>& typeface);
     static FontStyle analyzeStyle(const HbFontUniquePtr& font);
@@ -172,6 +219,28 @@ private:
     FRIEND_TEST(FontTest, MoveAssignmentTest);
 };
 
+struct FakedFont {
+    inline bool operator==(const FakedFont& o) const {
+        return font == o.font && fakery == o.fakery;
+    }
+    inline bool operator!=(const FakedFont& o) const { return !(*this == o); }
+
+    HbFontUniquePtr hbFont() const {
+        return font->getAdjustedFont(fakery.wghtAdjustment(), fakery.italAdjustment());
+    }
+
+    const std::shared_ptr<MinikinFont>& typeface() const {
+        return font->getAdjustedTypeface(fakery.wghtAdjustment(), fakery.italAdjustment());
+    }
+
+    // ownership is the enclosing FontCollection
+    // FakedFont will be stored in the LayoutCache. It is not a good idea too keep font instance
+    // even if the enclosing FontCollection, i.e. Typeface is GC-ed. The layout cache is only
+    // purged when it is overflown, thus intentionally keep only reference.
+    const std::shared_ptr<Font>& font;
+    FontFakery fakery;
+};
+
 }  // namespace minikin
 
 #endif  // MINIKIN_FONT_H
diff --git a/include/minikin/FontCollection.h b/include/minikin/FontCollection.h
index 1679abc..ee0315e 100644
--- a/include/minikin/FontCollection.h
+++ b/include/minikin/FontCollection.h
@@ -34,6 +34,8 @@ namespace minikin {
 // The maximum number of font families.
 constexpr uint32_t MAX_FAMILY_COUNT = 254;
 
+class LocaleList;
+
 class FontCollection {
 public:
     static std::shared_ptr<FontCollection> create(
@@ -147,6 +149,8 @@ public:
         return itemize(text, style, localeListId, familyVariant, text.size());
     }
 
+    MinikinExtent getReferenceExtentForLocale(const MinikinPaint& paint) const;
+
     // Returns true if there is a glyph for the code point and variation selector pair.
     // Returns false if no fonts have a glyph for the code point and variation
     // selector pair, or invalid variation selector is passed.
@@ -223,6 +227,9 @@ private:
 
     bool isPrimaryFamily(const std::shared_ptr<FontFamily>& fontFamily) const;
 
+    void filterFamilyByLocale(const LocaleList& localeList,
+                              const std::function<void(const FontFamily& family)>& callback) const;
+
     static uint32_t calcLocaleMatchingScore(uint32_t userLocaleListId,
                                             const FontFamily& fontFamily);
 
diff --git a/include/minikin/FontFamily.h b/include/minikin/FontFamily.h
index 6161f5c..c61a076 100644
--- a/include/minikin/FontFamily.h
+++ b/include/minikin/FontFamily.h
@@ -30,6 +30,13 @@
 
 namespace minikin {
 
+enum VariationFamilyType : uint8_t {
+    None = 0,
+    SingleFont_wghtOnly = 1,
+    SingleFont_wght_ital = 2,
+    TwoFont_wght = 3,
+};
+
 class FontFamily {
 public:
     static std::shared_ptr<FontFamily> create(std::vector<std::shared_ptr<Font>>&& fonts);
@@ -37,7 +44,8 @@ public:
                                               std::vector<std::shared_ptr<Font>>&& fonts);
     static std::shared_ptr<FontFamily> create(uint32_t localeListId, FamilyVariant variant,
                                               std::vector<std::shared_ptr<Font>>&& fonts,
-                                              bool isCustomFallback, bool isDefaultFallback);
+                                              bool isCustomFallback, bool isDefaultFallback,
+                                              VariationFamilyType varFamilyType);
 
     FontFamily(FontFamily&&) = default;
     FontFamily& operator=(FontFamily&&) = default;
@@ -47,6 +55,7 @@ public:
                             const std::vector<std::shared_ptr<FontFamily>>& families);
 
     FakedFont getClosestMatch(FontStyle style) const;
+    FakedFont getVariationFamilyAdjustment(FontStyle style) const;
 
     uint32_t localeListId() const { return mLocaleListId; }
     FamilyVariant variant() const { return mVariant; }
@@ -80,7 +89,7 @@ public:
 private:
     FontFamily(uint32_t localeListId, FamilyVariant variant,
                std::vector<std::shared_ptr<Font>>&& fonts, bool isCustomFallback,
-               bool isDefaultFallback);
+               bool isDefaultFallback, VariationFamilyType varFamilyType);
     explicit FontFamily(BufferReader* reader, const std::shared_ptr<std::vector<Font>>& fonts);
 
     void writeTo(BufferWriter* writer, uint32_t* fontIndex) const;
@@ -103,6 +112,7 @@ private:
     bool mIsColorEmoji;                // 1 byte
     bool mIsCustomFallback;            // 1 byte
     bool mIsDefaultFallback;           // 1 byte
+    VariationFamilyType mVarFamilyType;  // 1byte
 
     MINIKIN_PREVENT_COPY_AND_ASSIGN(FontFamily);
 };
diff --git a/include/minikin/FontFeature.h b/include/minikin/FontFeature.h
new file mode 100644
index 0000000..c47594b
--- /dev/null
+++ b/include/minikin/FontFeature.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINIKIN_FONT_FEATURE_H
+#define MINIKIN_FONT_FEATURE_H
+
+#include <hb.h>
+
+#include <ostream>
+#include <string_view>
+#include <vector>
+
+namespace minikin {
+
+struct MinikinPaint;
+
+// Subset of the hb_feature_t since we don't allow setting features on ranges.
+struct FontFeature {
+    hb_tag_t tag;
+    uint32_t value;
+
+    static std::vector<FontFeature> parse(std::string_view fontFeatureString);
+};
+
+/**
+ * Returns the final set of font features based on the features requested by this paint object and
+ * extra defaults or implied font features.
+ *
+ * Features are included from the paint object if they are:
+ *   1) in a supported range
+ *
+ * Default features are added based if they are:
+ *   1) implied due to Paint settings such as letterSpacing
+ *   2) default features that do not conflict with requested features
+ */
+std::vector<hb_feature_t> cleanAndAddDefaultFontFeatures(const MinikinPaint& features);
+
+// For gtest output
+inline std::ostream& operator<<(std::ostream& os, const FontFeature& feature) {
+    return os << static_cast<char>(feature.tag >> 24) << static_cast<char>(feature.tag >> 16)
+              << static_cast<char>(feature.tag >> 8) << static_cast<char>(feature.tag) << " "
+              << feature.value;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const std::vector<FontFeature>& features) {
+    for (size_t i = 0; i < features.size(); ++i) {
+        if (i != 0) {
+            os << ", ";
+        }
+        os << features;
+    }
+    return os;
+}
+
+constexpr bool operator==(const FontFeature& l, const FontFeature& r) {
+    return l.tag == r.tag && l.value == r.value;
+}
+
+constexpr bool operator!=(const FontFeature& l, const FontFeature& r) {
+    return !(l == r);
+}
+
+}  // namespace minikin
+#endif  // MINIKIN_LAYOUT_H
diff --git a/include/minikin/FontStyle.h b/include/minikin/FontStyle.h
index 51e4ad8..7a9e597 100644
--- a/include/minikin/FontStyle.h
+++ b/include/minikin/FontStyle.h
@@ -19,6 +19,8 @@
 
 #include <minikin/Buffer.h>
 
+#include <ostream>
+
 namespace minikin {
 
 // FontStyle represents style information.
@@ -61,10 +63,6 @@ public:
     constexpr uint16_t weight() const { return mWeight; }
     constexpr Slant slant() const { return mSlant; }
 
-    constexpr bool operator==(const FontStyle& other) const {
-        return weight() == other.weight() && slant() == other.slant();
-    }
-
     constexpr uint32_t identifier() const {
         return (static_cast<uint32_t>(weight()) << 16) | static_cast<uint32_t>(slant());
     }
@@ -74,6 +72,29 @@ private:
     Slant mSlant;
 };
 
+inline std::ostream& operator<<(std::ostream& os, const FontStyle::Slant& slant) {
+    switch (slant) {
+        case FontStyle::Slant::ITALIC:
+            return os << "italic";
+        case FontStyle::Slant::UPRIGHT:
+            return os << "upright";
+        default:
+            return os << "[UNKNOWN]";
+    }
+}
+
+inline std::ostream& operator<<(std::ostream& os, const FontStyle& style) {
+    return os << "{weight=" << style.weight() << ", slant=" << style.slant() << "}";
+}
+
+constexpr bool operator==(const FontStyle& l, const FontStyle& r) {
+    return l.weight() == r.weight() && l.slant() == r.slant();
+}
+
+constexpr bool operator!=(const FontStyle& l, const FontStyle& r) {
+    return !(l == r);
+}
+
 }  // namespace minikin
 
 #endif  // MINIKIN_FONT_STYLE_H
diff --git a/include/minikin/Hasher.h b/include/minikin/Hasher.h
index 4a76b29..dcfdd0b 100644
--- a/include/minikin/Hasher.h
+++ b/include/minikin/Hasher.h
@@ -18,9 +18,9 @@
 #define MINIKIN_HASHER_H
 
 #include <cstdint>
-
 #include <string>
 
+#include "minikin/FontFeature.h"
 #include "minikin/Macros.h"
 
 namespace minikin {
@@ -57,6 +57,21 @@ public:
         return update(bits.i);
     }
 
+    inline Hasher& update(const std::vector<FontFeature>& features) {
+        uint32_t size = features.size();
+        update(size);
+        for (const FontFeature& feature : features) {
+            update(feature);
+        }
+        return *this;
+    }
+
+    inline Hasher& update(const FontFeature& feature) {
+        update(feature.tag);
+        update(feature.value);
+        return *this;
+    }
+
     inline Hasher& updateShorts(const uint16_t* data, uint32_t length) {
         update(length);
         uint32_t i;
diff --git a/include/minikin/Layout.h b/include/minikin/Layout.h
index 388a7a7..d1f2137 100644
--- a/include/minikin/Layout.h
+++ b/include/minikin/Layout.h
@@ -78,7 +78,13 @@ public:
 
     static float measureText(const U16StringPiece& str, const Range& range, Bidi bidiFlags,
                              const MinikinPaint& paint, StartHyphenEdit startHyphen,
-                             EndHyphenEdit endHyphen, float* advances);
+                             EndHyphenEdit endHyphen, float* advances) {
+        return measureText(str, range, bidiFlags, paint, startHyphen, endHyphen, advances, nullptr);
+    }
+
+    static float measureText(const U16StringPiece& str, const Range& range, Bidi bidiFlags,
+                             const MinikinPaint& paint, StartHyphenEdit startHyphen,
+                             EndHyphenEdit endHyphen, float* advances, MinikinRect* bounds);
 
     const std::vector<float>& advances() const { return mAdvances; }
 
@@ -87,6 +93,7 @@ public:
     const Font* getFont(int i) const { return mGlyphs[i].font.font.get(); }
     const std::shared_ptr<Font>& getFontRef(int i) const { return mGlyphs[i].font.font; }
     FontFakery getFakery(int i) const { return mGlyphs[i].font.fakery; }
+    const std::shared_ptr<MinikinFont>& typeface(int i) const { return mGlyphs[i].font.typeface(); }
     unsigned int getGlyphId(int i) const { return mGlyphs[i].glyph_id; }
     float getX(int i) const { return mGlyphs[i].x; }
     float getY(int i) const { return mGlyphs[i].y; }
@@ -115,18 +122,18 @@ private:
     static float doLayoutRunCached(const U16StringPiece& textBuf, const Range& range, bool isRtl,
                                    const MinikinPaint& paint, size_t dstStart,
                                    StartHyphenEdit startHyphen, EndHyphenEdit endHyphen,
-                                   Layout* layout, float* advances);
+                                   Layout* layout, float* advances, MinikinRect* bounds);
 
     // Lay out a single word
     static float doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize,
                               bool isRtl, const MinikinPaint& paint, size_t bufStart,
                               StartHyphenEdit startHyphen, EndHyphenEdit endHyphen, Layout* layout,
-                              float* advances);
+                              float* advances, MinikinRect* bounds);
 
     // Lay out a single bidi run
     void doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, bool isRtl,
                      const MinikinPaint& paint, StartHyphenEdit startHyphen,
-                     EndHyphenEdit endHyphen);
+                     EndHyphenEdit endHyphen, MinikinRect* bounds);
 
     std::vector<LayoutGlyph> mGlyphs;
 
diff --git a/include/minikin/LayoutCache.h b/include/minikin/LayoutCache.h
index a1cc34a..fa572fb 100644
--- a/include/minikin/LayoutCache.h
+++ b/include/minikin/LayoutCache.h
@@ -55,6 +55,7 @@ public:
               mStartHyphen(startHyphen),
               mEndHyphen(endHyphen),
               mIsRtl(dir),
+              mFontFeatureSettings(paint.fontFeatureSettings),
               mHash(computeHash()) {}
 
     bool operator==(const LayoutCacheKey& o) const {
@@ -64,6 +65,7 @@ public:
                mFontFlags == o.mFontFlags && mLocaleListId == o.mLocaleListId &&
                mFamilyVariant == o.mFamilyVariant && mStartHyphen == o.mStartHyphen &&
                mEndHyphen == o.mEndHyphen && mIsRtl == o.mIsRtl && mNchars == o.mNchars &&
+               mFontFeatureSettings == o.mFontFeatureSettings &&
                !memcmp(mChars, o.mChars, mNchars * sizeof(uint16_t));
     }
 
@@ -77,6 +79,7 @@ public:
     void freeText() {
         delete[] mChars;
         mChars = NULL;
+        mFontFeatureSettings.clear();
     }
 
     uint32_t getMemoryUsage() const { return sizeof(LayoutCacheKey) + sizeof(uint16_t) * mNchars; }
@@ -99,6 +102,7 @@ private:
     StartHyphenEdit mStartHyphen;
     EndHyphenEdit mEndHyphen;
     bool mIsRtl;
+    std::vector<FontFeature> mFontFeatureSettings;
     // Note: any fields added to MinikinPaint must also be reflected here.
     // TODO: language matching (possibly integrate into style)
     android::hash_t mHash;
@@ -120,11 +124,33 @@ private:
                 .update(packHyphenEdit(mStartHyphen, mEndHyphen))
                 .update(mIsRtl)
                 .updateShorts(mChars, mNchars)
+                .update(mFontFeatureSettings)
                 .hash();
     }
 };
 
-class LayoutCache : private android::OnEntryRemoved<LayoutCacheKey, LayoutPiece*> {
+// A class holds a layout information and bounding box of it. The bounding box can be invalid if not
+// calculated.
+class LayoutSlot {
+public:
+    LayoutSlot(LayoutPiece&& layout)
+            : mLayout(std::move(layout)), mBounds(MinikinRect::makeInvalid()) {}
+    LayoutSlot(LayoutPiece&& layout, MinikinRect&& bounds)
+            : mLayout(std::move(layout)), mBounds(std::move(bounds)) {}
+    LayoutSlot(const LayoutPiece& layout, const MinikinRect& bounds)
+            : mLayout(layout), mBounds(bounds) {}
+
+    const LayoutPiece mLayout;
+    MinikinRect mBounds;
+
+private:
+    LayoutSlot(const LayoutSlot&) = delete;
+    LayoutSlot& operator=(const LayoutSlot&) = delete;
+    LayoutSlot(LayoutSlot&&) = delete;
+    LayoutSlot& operator=(LayoutSlot&&) = delete;
+};
+
+class LayoutCache : private android::OnEntryRemoved<LayoutCacheKey, LayoutSlot*> {
 public:
     void clear() {
         std::lock_guard<std::mutex> lock(mMutex);
@@ -134,29 +160,55 @@ public:
     // Do not use LayoutCache inside the callback function, otherwise dead-lock may happen.
     template <typename F>
     void getOrCreate(const U16StringPiece& text, const Range& range, const MinikinPaint& paint,
-                     bool dir, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen, F& f) {
+                     bool dir, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen,
+                     bool boundsCalculation, F& f) {
         LayoutCacheKey key(text, range, paint, dir, startHyphen, endHyphen);
         if (paint.skipCache() || range.getLength() >= LENGTH_LIMIT_CACHE) {
-            f(LayoutPiece(text, range, dir, paint, startHyphen, endHyphen), paint);
+            LayoutPiece piece(text, range, dir, paint, startHyphen, endHyphen);
+            if (boundsCalculation) {
+                f(piece, paint, LayoutPiece::calculateBounds(piece, paint));
+            } else {
+                f(piece, paint, MinikinRect::makeInvalid());
+            }
             return;
         }
+
+        LayoutSlot* cachedSlot;
         {
             std::lock_guard<std::mutex> lock(mMutex);
-            LayoutPiece* layout = mCache.get(key);
-            if (layout != nullptr) {
-                f(*layout, paint);
+            cachedSlot = mCache.get(key);
+
+            if (cachedSlot != nullptr) {
+                if (boundsCalculation && !cachedSlot->mBounds.isValid()) {
+                    MinikinRect bounds = LayoutPiece::calculateBounds(cachedSlot->mLayout, paint);
+                    LayoutPiece lp = cachedSlot->mLayout;
+                    f(lp, paint, bounds);
+                    cachedSlot->mBounds = bounds;
+                } else {
+                    f(cachedSlot->mLayout, paint, cachedSlot->mBounds);
+                }
                 return;
             }
         }
         // Doing text layout takes long time, so releases the mutex during doing layout.
         // Don't care even if we do the same layout in other thred.
         key.copyText();
-        std::unique_ptr<LayoutPiece> layout =
-                std::make_unique<LayoutPiece>(text, range, dir, paint, startHyphen, endHyphen);
-        f(*layout, paint);
+
+        std::unique_ptr<LayoutSlot> slot;
+        if (boundsCalculation) {
+            LayoutPiece lp = LayoutPiece(text, range, dir, paint, startHyphen, endHyphen);
+            MinikinRect rect = LayoutPiece::calculateBounds(lp, paint);
+
+            slot = std::make_unique<LayoutSlot>(std::move(lp), std::move(rect));
+        } else {
+            slot = std::make_unique<LayoutSlot>(
+                    LayoutPiece(text, range, dir, paint, startHyphen, endHyphen));
+        }
+
+        f(slot->mLayout, paint, slot->mBounds);
         {
             std::lock_guard<std::mutex> lock(mMutex);
-            mCache.put(key, layout.release());
+            mCache.put(key, slot.release());
         }
     }
 
@@ -177,12 +229,12 @@ protected:
 
 private:
     // callback for OnEntryRemoved
-    void operator()(LayoutCacheKey& key, LayoutPiece*& value) {
+    void operator()(LayoutCacheKey& key, LayoutSlot*& value) {
         key.freeText();
         delete value;
     }
 
-    android::LruCache<LayoutCacheKey, LayoutPiece*> mCache GUARDED_BY(mMutex);
+    android::LruCache<LayoutCacheKey, LayoutSlot*> mCache GUARDED_BY(mMutex);
 
     // static const size_t kMaxEntries = LruCache<LayoutCacheKey, Layout*>::kUnlimitedCapacity;
 
diff --git a/include/minikin/LayoutCore.h b/include/minikin/LayoutCore.h
index cade517..cf5b958 100644
--- a/include/minikin/LayoutCore.h
+++ b/include/minikin/LayoutCore.h
@@ -17,15 +17,16 @@
 #ifndef MINIKIN_LAYOUT_CORE_H
 #define MINIKIN_LAYOUT_CORE_H
 
-#include <vector>
-
 #include <gtest/gtest_prod.h>
 
+#include <vector>
+
 #include "minikin/FontFamily.h"
 #include "minikin/Hyphenator.h"
 #include "minikin/MinikinExtent.h"
 #include "minikin/MinikinFont.h"
 #include "minikin/MinikinRect.h"
+#include "minikin/Point.h"
 #include "minikin/Range.h"
 #include "minikin/U16StringPiece.h"
 
@@ -33,19 +34,12 @@ namespace minikin {
 
 struct MinikinPaint;
 
-struct Point {
-    Point() : x(0), y(0) {}
-    Point(float x, float y) : x(x), y(y) {}
-    bool operator==(const Point& o) const { return x == o.x && y == o.y; }
-    float x;
-    float y;
-};
-
 // Immutable, recycle-able layout result.
 class LayoutPiece {
 public:
     LayoutPiece(const U16StringPiece& textBuf, const Range& range, bool isRtl,
                 const MinikinPaint& paint, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen);
+    ~LayoutPiece();
 
     // Low level accessors.
     const std::vector<uint8_t>& fontIndices() const { return mFontIndices; }
@@ -68,12 +62,14 @@ public:
                sizeof(MinikinRect) + sizeof(MinikinExtent);
     }
 
+    static MinikinRect calculateBounds(const LayoutPiece& layout, const MinikinPaint& paint);
+
 private:
     FRIEND_TEST(LayoutTest, doLayoutWithPrecomputedPiecesTest);
 
-    std::vector<uint8_t> mFontIndices;  // per glyph
-    std::vector<uint32_t> mGlyphIds;    // per glyph
-    std::vector<Point> mPoints;         // per glyph
+    std::vector<uint8_t> mFontIndices;      // per glyph
+    std::vector<uint32_t> mGlyphIds;        // per glyph
+    std::vector<Point> mPoints;             // per glyph
 
     std::vector<float> mAdvances;  // per code units
 
@@ -83,10 +79,6 @@ private:
     std::vector<FakedFont> mFonts;
 };
 
-// For gtest output
-inline std::ostream& operator<<(std::ostream& os, const Point& p) {
-    return os << "(" << p.x << ", " << p.y << ")";
-}
 }  // namespace minikin
 
 #endif  // MINIKIN_LAYOUT_CORE_H
diff --git a/include/minikin/LayoutPieces.h b/include/minikin/LayoutPieces.h
index 7985ecc..d98ba35 100644
--- a/include/minikin/LayoutPieces.h
+++ b/include/minikin/LayoutPieces.h
@@ -30,14 +30,19 @@ struct LayoutPieces {
 
     struct Key {
         Key(const Range& range, HyphenEdit hyphenEdit, bool dir, uint32_t paintId)
-                : range(range), hyphenEdit(hyphenEdit), dir(dir), paintId(paintId) {}
+                : range(range),
+                  hyphenEdit(hyphenEdit),
+                  dir(dir),
+                  paintId(paintId),
+                  hash(calcHash()) {}
 
         Range range;
         HyphenEdit hyphenEdit;
         bool dir;
         uint32_t paintId;
+        uint32_t hash;
 
-        uint32_t hash() const {
+        uint32_t calcHash() const {
             return Hasher()
                     .update(range.getStart())
                     .update(range.getEnd())
@@ -58,7 +63,7 @@ struct LayoutPieces {
     };
 
     struct KeyHasher {
-        std::size_t operator()(const Key& key) const { return key.hash(); }
+        std::size_t operator()(const Key& key) const { return key.hash; }
     };
 
     struct PaintHasher {
@@ -70,10 +75,10 @@ struct LayoutPieces {
 
     uint32_t nextPaintId;
     std::unordered_map<MinikinPaint, uint32_t, PaintHasher> paintMap;
-    std::unordered_map<Key, LayoutPiece, KeyHasher> offsetMap;
+    std::unordered_map<Key, LayoutSlot, KeyHasher> offsetMap;
 
     void insert(const Range& range, HyphenEdit edit, const LayoutPiece& layout, bool dir,
-                const MinikinPaint& paint) {
+                const MinikinPaint& paint, const MinikinRect& rect) {
         uint32_t paintId = findPaintId(paint);
         if (paintId == kNoPaintId) {
             paintId = nextPaintId++;
@@ -81,22 +86,29 @@ struct LayoutPieces {
         }
         offsetMap.emplace(std::piecewise_construct,
                           std::forward_as_tuple(range, edit, dir, paintId),
-                          std::forward_as_tuple(layout));
+                          std::forward_as_tuple(layout, rect));
     }
 
     template <typename F>
     void getOrCreate(const U16StringPiece& textBuf, const Range& range, const Range& context,
                      const MinikinPaint& paint, bool dir, StartHyphenEdit startEdit,
-                     EndHyphenEdit endEdit, uint32_t paintId, F& f) const {
+                     EndHyphenEdit endEdit, uint32_t paintId, bool boundsCalculation, F& f) const {
         const HyphenEdit edit = packHyphenEdit(startEdit, endEdit);
         auto it = offsetMap.find(Key(range, edit, dir, paintId));
-        if (it == offsetMap.end()) {
-            LayoutCache::getInstance().getOrCreate(textBuf.substr(context),
-                                                   range - context.getStart(), paint, dir,
-                                                   startEdit, endEdit, f);
-        } else {
-            f(it->second, paint);
+        if (it != offsetMap.end()) {
+            const LayoutPiece& piece = it->second.mLayout;
+            const MinikinRect& bounds = it->second.mBounds;
+            if (boundsCalculation && !bounds.isValid()) {
+                f(piece, paint, LayoutPiece::calculateBounds(piece, paint));
+            } else {
+                f(piece, paint, bounds);
+            }
+            return;
         }
+
+        LayoutCache::getInstance().getOrCreate(textBuf.substr(context), range - context.getStart(),
+                                               paint, dir, startEdit, endEdit, boundsCalculation,
+                                               f);
     }
 
     uint32_t findPaintId(const MinikinPaint& paint) const {
@@ -107,7 +119,7 @@ struct LayoutPieces {
     uint32_t getMemoryUsage() const {
         uint32_t result = 0;
         for (const auto& i : offsetMap) {
-            result += i.first.getMemoryUsage() + i.second.getMemoryUsage();
+            result += i.first.getMemoryUsage() + i.second.mLayout.getMemoryUsage();
         }
         result += (sizeof(MinikinPaint) + sizeof(uint32_t)) * paintMap.size();
         return result;
diff --git a/include/minikin/LineBreakStyle.h b/include/minikin/LineBreakStyle.h
index f474cbd..aadf5bb 100644
--- a/include/minikin/LineBreakStyle.h
+++ b/include/minikin/LineBreakStyle.h
@@ -26,6 +26,8 @@ enum class LineBreakStyle : uint8_t {
     Loose = 1,
     Normal = 2,
     Strict = 3,
+    NoBreak = 4,
+    Auto = 5,
 };
 
 // The line break word style(lw) of the strings.
@@ -33,6 +35,7 @@ enum class LineBreakStyle : uint8_t {
 enum class LineBreakWordStyle : uint8_t {
     None = 0,
     Phrase = 1,
+    Auto = 2,
 };
 
 }  // namespace minikin
diff --git a/include/minikin/LineBreaker.h b/include/minikin/LineBreaker.h
index 5d3e752..7fee1b7 100644
--- a/include/minikin/LineBreaker.h
+++ b/include/minikin/LineBreaker.h
@@ -99,6 +99,7 @@ public:
     std::vector<float> ascents;
     std::vector<float> descents;
     std::vector<int> flags;
+    std::vector<MinikinRect> bounds;
 
     LineBreakResult(LineBreakResult&&) = default;
     LineBreakResult& operator=(LineBreakResult&&) = default;
@@ -109,6 +110,7 @@ public:
         std::reverse(ascents.begin(), ascents.end());
         std::reverse(descents.begin(), descents.end());
         std::reverse(flags.begin(), flags.end());
+        std::reverse(bounds.begin(), bounds.end());
     }
 
 private:
@@ -118,7 +120,7 @@ private:
 LineBreakResult breakIntoLines(const U16StringPiece& textBuffer, BreakStrategy strategy,
                                HyphenationFrequency frequency, bool justified,
                                const MeasuredText& measuredText, const LineWidth& lineWidth,
-                               const TabStops& tabStops);
+                               const TabStops& tabStops, bool useBoundsForWidth);
 
 }  // namespace minikin
 
diff --git a/include/minikin/MeasuredText.h b/include/minikin/MeasuredText.h
index fa37eb6..a3b8bf1 100644
--- a/include/minikin/MeasuredText.h
+++ b/include/minikin/MeasuredText.h
@@ -31,6 +31,27 @@
 
 namespace minikin {
 
+// Structs that of line metrics information.
+struct LineMetrics {
+    LineMetrics() : advance(0) {}
+    LineMetrics(const MinikinExtent& extent, const MinikinRect& bounds, float advance)
+            : extent(extent), bounds(bounds), advance(advance) {}
+
+    void append(const LineMetrics& metrics) {
+        append(metrics.extent, metrics.bounds, metrics.advance);
+    }
+
+    void append(const MinikinExtent& nextExtent, const MinikinRect& nextBounds, float nextAdvance) {
+        extent.extendBy(nextExtent);
+        bounds.join(nextBounds, advance, 0);
+        advance += nextAdvance;
+    }
+
+    MinikinExtent extent;
+    MinikinRect bounds;
+    float advance;
+};
+
 class Run {
 public:
     Run(const Range& range) : mRange(range) {}
@@ -42,6 +63,9 @@ public:
     // Returns true if this run can be broken into multiple pieces for line breaking.
     virtual bool canBreak() const = 0;
 
+    // Returns true if this run can be hyphenated.
+    virtual bool canHyphenate() const = 0;
+
     // Return the line break style(lb) for this run.
     virtual LineBreakStyle lineBreakStyle() const = 0;
 
@@ -53,13 +77,17 @@ public:
 
     // Fills the each character's advances, extents and overhangs.
     virtual void getMetrics(const U16StringPiece& text, std::vector<float>* advances,
-                            LayoutPieces* precomputed, LayoutPieces* outPieces) const = 0;
+                            std::vector<uint8_t>* flags, LayoutPieces* precomputed,
+                            bool boundsCalculation, LayoutPieces* outPieces) const = 0;
 
     virtual std::pair<float, MinikinRect> getBounds(const U16StringPiece& text, const Range& range,
                                                     const LayoutPieces& pieces) const = 0;
     virtual MinikinExtent getExtent(const U16StringPiece& text, const Range& range,
                                     const LayoutPieces& pieces) const = 0;
 
+    virtual LineMetrics getLineMetrics(const U16StringPiece& text, const Range& range,
+                                       const LayoutPieces& pieces) const = 0;
+
     virtual void appendLayout(const U16StringPiece& text, const Range& range,
                               const Range& contextRange, const LayoutPieces& pieces,
                               const MinikinPaint& paint, uint32_t outOrigin,
@@ -93,11 +121,12 @@ protected:
 class StyleRun : public Run {
 public:
     StyleRun(const Range& range, MinikinPaint&& paint, int lineBreakStyle, int lineBreakWordStyle,
-             bool isRtl)
+             bool hyphenation, bool isRtl)
             : Run(range),
               mPaint(std::move(paint)),
               mLineBreakStyle(lineBreakStyle),
               mLineBreakWordStyle(lineBreakWordStyle),
+              mHyphenation(hyphenation),
               mIsRtl(isRtl) {}
 
     bool canBreak() const override { return true; }
@@ -107,11 +136,13 @@ public:
     LineBreakWordStyle lineBreakWordStyle() const override {
         return static_cast<LineBreakWordStyle>(mLineBreakWordStyle);
     }
+    bool canHyphenate() const override { return mHyphenation; }
     uint32_t getLocaleListId() const override { return mPaint.localeListId; }
     bool isRtl() const override { return mIsRtl; }
 
     void getMetrics(const U16StringPiece& text, std::vector<float>* advances,
-                    LayoutPieces* precomputed, LayoutPieces* outPieces) const override;
+                    std::vector<uint8_t>* flags, LayoutPieces* precomputed, bool boundsCalculation,
+                    LayoutPieces* outPieces) const override;
 
     std::pair<float, MinikinRect> getBounds(const U16StringPiece& text, const Range& range,
                                             const LayoutPieces& pieces) const override;
@@ -119,6 +150,9 @@ public:
     MinikinExtent getExtent(const U16StringPiece& text, const Range& range,
                             const LayoutPieces& pieces) const override;
 
+    LineMetrics getLineMetrics(const U16StringPiece& text, const Range& range,
+                               const LayoutPieces& pieces) const override;
+
     void appendLayout(const U16StringPiece& text, const Range& range, const Range& contextRange,
                       const LayoutPieces& pieces, const MinikinPaint& paint, uint32_t outOrigin,
                       StartHyphenEdit startHyphen, EndHyphenEdit endHyphen,
@@ -135,6 +169,7 @@ private:
     MinikinPaint mPaint;
     int mLineBreakStyle;
     int mLineBreakWordStyle;
+    const bool mHyphenation;
     const bool mIsRtl;
 };
 
@@ -145,12 +180,14 @@ public:
 
     bool isRtl() const { return false; }
     bool canBreak() const { return false; }
+    bool canHyphenate() const { return false; }
     LineBreakStyle lineBreakStyle() const override { return LineBreakStyle::None; }
     LineBreakWordStyle lineBreakWordStyle() const override { return LineBreakWordStyle::None; }
     uint32_t getLocaleListId() const { return mLocaleListId; }
 
     void getMetrics(const U16StringPiece& /* text */, std::vector<float>* advances,
-                    LayoutPieces* /* precomputed */, LayoutPieces* /* outPieces */) const override {
+                    std::vector<uint8_t>* /*flags*/, LayoutPieces* /* precomputed */, bool,
+                    LayoutPieces* /* outPieces */) const override {
         (*advances)[mRange.getStart()] = mWidth;
         // TODO: Get the extents information from the caller.
     }
@@ -167,6 +204,11 @@ public:
         return MinikinExtent();
     }
 
+    LineMetrics getLineMetrics(const U16StringPiece& /*text*/, const Range& /*range*/,
+                               const LayoutPieces& /*pieces*/) const override {
+        return LineMetrics();
+    }
+
     void appendLayout(const U16StringPiece& /* text */, const Range& /* range */,
                       const Range& /* contextRange */, const LayoutPieces& /* pieces */,
                       const MinikinPaint& /* paint */, uint32_t /* outOrigin */,
@@ -209,10 +251,45 @@ public:
     // The style information.
     std::vector<std::unique_ptr<Run>> runs;
 
+    // Per character flags.
+    // The loweset bit represents that that character *may* have overhang. If this bit is not set,
+    // the character doesn't have overhang. If this bit is set, the character *may* have overhang.
+    // This information is used for determining using the bounding box based line breaking.
+    static constexpr uint8_t MAY_OVERHANG_BIT = 0b0000'0001;
+    std::vector<uint8_t> flags;
+
     // The copied layout pieces for construcing final layouts.
     // TODO: Stop assigning width/extents if layout pieces are available for reducing memory impact.
     LayoutPieces layoutPieces;
 
+    bool hasOverhang(const Range& range) const {
+        // Heuristics: Check first 5 and last 5 characters and treat there is overhang if at least
+        // one character has overhang.
+        constexpr uint32_t CHARS_TO_DUMPER = 5;
+
+        if (range.getLength() < CHARS_TO_DUMPER * 2) {
+            for (uint32_t i : range) {
+                if ((flags[i] & MAY_OVERHANG_BIT) == MAY_OVERHANG_BIT) {
+                    return true;
+                }
+            }
+        } else {
+            Range first = Range(range.getStart(), range.getStart() + CHARS_TO_DUMPER);
+            Range last = Range(range.getEnd() - CHARS_TO_DUMPER, range.getEnd());
+            for (uint32_t i : first) {
+                if ((flags[i] & MAY_OVERHANG_BIT) == MAY_OVERHANG_BIT) {
+                    return true;
+                }
+            }
+            for (uint32_t i : last) {
+                if ((flags[i] & MAY_OVERHANG_BIT) == MAY_OVERHANG_BIT) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     uint32_t getMemoryUsage() const {
         return sizeof(float) * widths.size() + sizeof(HyphenBreak) * hyphenBreaks.size() +
                layoutPieces.getMemoryUsage();
@@ -223,6 +300,7 @@ public:
                        EndHyphenEdit endHyphen);
     MinikinRect getBounds(const U16StringPiece& textBuf, const Range& range) const;
     MinikinExtent getExtent(const U16StringPiece& textBuf, const Range& range) const;
+    LineMetrics getLineMetrics(const U16StringPiece& textBuf, const Range& range) const;
 
     MeasuredText(MeasuredText&&) = default;
     MeasuredText& operator=(MeasuredText&&) = default;
@@ -233,14 +311,15 @@ private:
     friend class MeasuredTextBuilder;
 
     void measure(const U16StringPiece& textBuf, bool computeHyphenation, bool computeLayout,
-                 bool ignoreHyphenKerning, MeasuredText* hint);
+                 bool computeBounds, bool ignoreHyphenKerning, MeasuredText* hint);
 
     // Use MeasuredTextBuilder instead.
     MeasuredText(const U16StringPiece& textBuf, std::vector<std::unique_ptr<Run>>&& runs,
-                 bool computeHyphenation, bool computeLayout, bool ignoreHyphenKerning,
-                 MeasuredText* hint)
-            : widths(textBuf.size()), runs(std::move(runs)) {
-        measure(textBuf, computeHyphenation, computeLayout, ignoreHyphenKerning, hint);
+                 bool computeHyphenation, bool computeLayout, bool computeBounds,
+                 bool ignoreHyphenKerning, MeasuredText* hint)
+            : widths(textBuf.size()), runs(std::move(runs)), flags(textBuf.size(), 0) {
+        measure(textBuf, computeHyphenation, computeLayout, computeBounds, ignoreHyphenKerning,
+                hint);
     }
 };
 
@@ -249,9 +328,10 @@ public:
     MeasuredTextBuilder() {}
 
     void addStyleRun(int32_t start, int32_t end, MinikinPaint&& paint, int lineBreakStyle,
-                     int lineBreakWordStyle, bool isRtl) {
+                     int lineBreakWordStyle, bool hyphenation, bool isRtl) {
         mRuns.emplace_back(std::make_unique<StyleRun>(Range(start, end), std::move(paint),
-                                                      lineBreakStyle, lineBreakWordStyle, isRtl));
+                                                      lineBreakStyle, lineBreakWordStyle,
+                                                      hyphenation, isRtl));
     }
 
     void addReplacementRun(int32_t start, int32_t end, float width, uint32_t localeListId) {
@@ -267,10 +347,16 @@ public:
     std::unique_ptr<MeasuredText> build(const U16StringPiece& textBuf, bool computeHyphenation,
                                         bool computeLayout, bool ignoreHyphenKerning,
                                         MeasuredText* hint) {
+        return build(textBuf, computeHyphenation, computeLayout, false, ignoreHyphenKerning, hint);
+    }
+
+    std::unique_ptr<MeasuredText> build(const U16StringPiece& textBuf, bool computeHyphenation,
+                                        bool computeLayout, bool computeBounds,
+                                        bool ignoreHyphenKerning, MeasuredText* hint) {
         // Unable to use make_unique here since make_unique is not a friend of MeasuredText.
-        return std::unique_ptr<MeasuredText>(new MeasuredText(textBuf, std::move(mRuns),
-                                                              computeHyphenation, computeLayout,
-                                                              ignoreHyphenKerning, hint));
+        return std::unique_ptr<MeasuredText>(
+                new MeasuredText(textBuf, std::move(mRuns), computeHyphenation, computeLayout,
+                                 computeBounds, ignoreHyphenKerning, hint));
     }
 
     MINIKIN_PREVENT_COPY_ASSIGN_AND_MOVE(MeasuredTextBuilder);
diff --git a/include/minikin/MinikinExtent.h b/include/minikin/MinikinExtent.h
index ac9b49f..baa56ff 100644
--- a/include/minikin/MinikinExtent.h
+++ b/include/minikin/MinikinExtent.h
@@ -25,24 +25,29 @@ namespace minikin {
 struct MinikinExtent {
     MinikinExtent() : ascent(0), descent(0) {}
     MinikinExtent(float ascent, float descent) : ascent(ascent), descent(descent) {}
-    bool operator==(const MinikinExtent& o) const {
-        return ascent == o.ascent && descent == o.descent;
-    }
-    float ascent;   // negative
-    float descent;  // positive
-
-    void reset() { ascent = descent = 0.0; }
 
     void extendBy(const MinikinExtent& e) {
         ascent = std::min(ascent, e.ascent);
         descent = std::max(descent, e.descent);
     }
+
+    float ascent;   // negative
+    float descent;  // positive
 };
 
 // For gtest output
 inline std::ostream& operator<<(std::ostream& os, const MinikinExtent& e) {
-    return os << e.ascent << ", " << e.descent;
+    return os << "(ascent = " << e.ascent << ", descent = " << e.descent << ")";
+}
+
+inline bool operator==(const MinikinExtent& l, const MinikinExtent& r) {
+    return l.ascent == r.ascent && l.descent == r.descent;
 }
+
+inline bool operator!=(const MinikinExtent& l, const MinikinExtent& r) {
+    return !(l == r);
+}
+
 }  // namespace minikin
 
 #endif  // MINIKIN_MINIKIN_EXTENT_H
diff --git a/include/minikin/MinikinFont.h b/include/minikin/MinikinFont.h
index 4d3ba9c..6d5f006 100644
--- a/include/minikin/MinikinFont.h
+++ b/include/minikin/MinikinFont.h
@@ -75,10 +75,6 @@ public:
             const std::vector<FontVariation>&) const {
         return nullptr;
     }
-
-    static uint32_t MakeTag(char c1, char c2, char c3, char c4) {
-        return ((uint32_t)c1 << 24) | ((uint32_t)c2 << 16) | ((uint32_t)c3 << 8) | (uint32_t)c4;
-    }
 };
 
 }  // namespace minikin
diff --git a/include/minikin/MinikinPaint.h b/include/minikin/MinikinPaint.h
index 54b476f..04cab1d 100644
--- a/include/minikin/MinikinPaint.h
+++ b/include/minikin/MinikinPaint.h
@@ -23,6 +23,7 @@
 #include "minikin/FamilyVariant.h"
 #include "minikin/FontCollection.h"
 #include "minikin/FontFamily.h"
+#include "minikin/FontFeature.h"
 #include "minikin/Hasher.h"
 
 namespace minikin {
@@ -45,7 +46,7 @@ enum MinikinFontFlags {
 };
 
 // Possibly move into own .h file?
-// Note: if you add a field here, either add it to LayoutCacheKey or to skipCache()
+// Note: if you add a field here, either add it to LayoutCacheKey
 struct MinikinPaint {
     MinikinPaint(const std::shared_ptr<FontCollection>& font)
             : size(0),
@@ -59,7 +60,7 @@ struct MinikinPaint {
               fontFeatureSettings(),
               font(font) {}
 
-    bool skipCache() const { return !fontFeatureSettings.empty(); }
+    bool skipCache() const;
 
     float size;
     float scaleX;
@@ -70,7 +71,7 @@ struct MinikinPaint {
     uint32_t localeListId;
     FontStyle fontStyle;
     FamilyVariant familyVariant;
-    std::string fontFeatureSettings;
+    std::vector<FontFeature> fontFeatureSettings;
     std::shared_ptr<FontCollection> font;
 
     void copyFrom(const MinikinPaint& paint) { *this = paint; }
@@ -100,7 +101,7 @@ struct MinikinPaint {
                 .update(localeListId)
                 .update(fontStyle.identifier())
                 .update(static_cast<uint8_t>(familyVariant))
-                .updateString(fontFeatureSettings)
+                .update(fontFeatureSettings)
                 .update(font->getId())
                 .hash();
     }
diff --git a/include/minikin/MinikinRect.h b/include/minikin/MinikinRect.h
index 38c2180..f37cc2f 100644
--- a/include/minikin/MinikinRect.h
+++ b/include/minikin/MinikinRect.h
@@ -19,45 +19,63 @@
 
 #include <ostream>
 
+#include "minikin/Point.h"
+
 namespace minikin {
 
 struct MinikinRect {
     MinikinRect() : mLeft(0), mTop(0), mRight(0), mBottom(0) {}
     MinikinRect(float left, float top, float right, float bottom)
             : mLeft(left), mTop(top), mRight(right), mBottom(bottom) {}
-    bool operator==(const MinikinRect& o) const {
-        return mLeft == o.mLeft && mTop == o.mTop && mRight == o.mRight && mBottom == o.mBottom;
-    }
-    bool operator!=(const MinikinRect& o) const { return !(*this == o); }
-    float mLeft;
-    float mTop;
-    float mRight;
-    float mBottom;
 
     bool isEmpty() const { return mLeft == mRight || mTop == mBottom; }
-    void set(const MinikinRect& r) {
-        mLeft = r.mLeft;
-        mTop = r.mTop;
-        mRight = r.mRight;
-        mBottom = r.mBottom;
-    }
+    bool isValid() const { return !std::isnan(mLeft); }
+    float width() const { return mRight - mLeft; }
+
+    void setEmpty() { mLeft = mRight = mTop = mBottom = 0; }
+
+    // Shift the rectangle with given amount.
     void offset(float dx, float dy) {
         mLeft += dx;
         mTop += dy;
         mRight += dx;
         mBottom += dy;
     }
-    void setEmpty() { mLeft = mTop = mRight = mBottom = 0.0; }
-    void join(const MinikinRect& r) {
+
+    // Update the rectangle with the union of the given rectangle with shifting.
+    void join(float l, float t, float r, float b, float dx, float dy) {
         if (isEmpty()) {
-            set(r);
-        } else if (!r.isEmpty()) {
-            mLeft = std::min(mLeft, r.mLeft);
-            mTop = std::min(mTop, r.mTop);
-            mRight = std::max(mRight, r.mRight);
-            mBottom = std::max(mBottom, r.mBottom);
+            mLeft = l + dx;
+            mTop = t + dy;
+            mRight = r + dx;
+            mBottom = b + dy;
+        } else {
+            mLeft = std::min(mLeft, l + dx);
+            mTop = std::min(mTop, t + dy);
+            mRight = std::max(mRight, r + dx);
+            mBottom = std::max(mBottom, b + dy);
         }
     }
+
+    void offset(const Point& p) { offset(p.x, p.y); }
+    void join(const MinikinRect& r) { return join(r.mLeft, r.mTop, r.mRight, r.mBottom, 0, 0); }
+    void join(const MinikinRect& r, float dx, float dy) {
+        return join(r.mLeft, r.mTop, r.mRight, r.mBottom, dx, dy);
+    }
+    void join(const MinikinRect& r, const Point& p) {
+        return join(r.mLeft, r.mTop, r.mRight, r.mBottom, p.x, p.y);
+    }
+
+    static MinikinRect makeInvalid() {
+        return MinikinRect(
+                std::numeric_limits<float>::quiet_NaN(), std::numeric_limits<float>::quiet_NaN(),
+                std::numeric_limits<float>::quiet_NaN(), std::numeric_limits<float>::quiet_NaN());
+    }
+
+    float mLeft;
+    float mTop;
+    float mRight;
+    float mBottom;
 };
 
 // For gtest output
@@ -65,6 +83,14 @@ inline std::ostream& operator<<(std::ostream& os, const MinikinRect& r) {
     return os << "(" << r.mLeft << ", " << r.mTop << ")-(" << r.mRight << ", " << r.mBottom << ")";
 }
 
+inline bool operator==(const MinikinRect& l, const MinikinRect& r) {
+    return l.mLeft == r.mLeft && l.mTop == r.mTop && l.mRight == r.mRight && l.mBottom == r.mBottom;
+}
+
+inline bool operator!=(const MinikinRect& l, const MinikinRect& r) {
+    return !(l == r);
+}
+
 }  // namespace minikin
 
 #endif  // MINIKIN_MINIKIN_RECT_H
diff --git a/include/minikin/Point.h b/include/minikin/Point.h
new file mode 100644
index 0000000..c3fe2f3
--- /dev/null
+++ b/include/minikin/Point.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINIKIN_POINT_H
+#define MINIKIN_POINT_H
+
+#include <ostream>
+
+namespace minikin {
+
+struct Point {
+    Point(float x, float y) : x(x), y(y) {}
+    float x, y;
+};
+
+// For gtest
+inline std::ostream& operator<<(std::ostream& os, const Point& p) {
+    return os << "(" << p.x << ", " << p.y << ")";
+}
+
+inline bool operator==(const Point& l, const Point& r) {
+    return l.x == r.x && l.y == r.y;
+}
+
+inline bool operator!=(const Point& l, const Point& r) {
+    return !(l == r);
+}
+
+}  // namespace minikin
+
+#endif  // MINIKIN_POINT_H
diff --git a/include/minikin/Range.h b/include/minikin/Range.h
index 991912d..f8b8ba8 100644
--- a/include/minikin/Range.h
+++ b/include/minikin/Range.h
@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <limits>
+#include <ostream>
 #include <utility>
 
 namespace minikin {
@@ -117,6 +118,11 @@ private:
     uint32_t mEnd;
 };
 
+// For gtest output
+inline std::ostream& operator<<(std::ostream& os, const Range& r) {
+    return os << "(" << r.getStart() << ", " << r.getEnd() << ")";
+}
+
 }  // namespace minikin
 
 #endif  // MINIKIN_RANGE_H
diff --git a/libs/minikin/Android.bp b/libs/minikin/Android.bp
index 5c7abf2..d23f053 100644
--- a/libs/minikin/Android.bp
+++ b/libs/minikin/Android.bp
@@ -28,7 +28,6 @@ cc_library {
     host_supported: true,
     srcs: [
         "BidiUtils.cpp",
-        "BoundsCache.cpp",
         "CmapCoverage.cpp",
         "Emoji.cpp",
         "Font.cpp",
@@ -53,6 +52,7 @@ cc_library {
         "MinikinFontFactory.cpp",
         "MinikinInternal.cpp",
         "OptimalLineBreaker.cpp",
+        "ScriptUtils.cpp",
         "SparseBitSet.cpp",
         "SystemFonts.cpp",
         "WordBreaker.cpp",
@@ -68,12 +68,16 @@ cc_library {
     product_variables: {
         debuggable: {
             // Enable assertion on eng and userdebug build.
-            cppflags: ["-DENABLE_ASSERTION"],
+            srcs: [
+                "Debug.cpp",
+            ],
+            cppflags: [ "-DENABLE_ASSERTION" ],
         },
     },
     shared_libs: [
         "liblog",
         "libharfbuzz_ng",
+        "libcutils",
     ],
     header_libs: [
         "libbase_headers",
@@ -86,6 +90,7 @@ cc_library {
         android: {
             shared_libs: [
                 "libicu",
+                "aconfig_text_flags_c_lib",
             ],
             export_shared_lib_headers: [
                 "libicu",
diff --git a/libs/minikin/BoundsCache.cpp b/libs/minikin/BoundsCache.cpp
deleted file mode 100644
index 1edc853..0000000
--- a/libs/minikin/BoundsCache.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "minikin/BoundsCache.h"
-
-namespace minikin {
-
-void ValueExtractor::operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint) {
-    value.reset(new BoundsValue);
-    value->rect = BoundsCache::getBounds(layoutPiece, paint);
-    value->advance = layoutPiece.advance();
-}
-
-// static
-MinikinRect BoundsCache::getBounds(const LayoutPiece& layoutPiece, const MinikinPaint& paint) {
-    MinikinRect pieceBounds;
-    MinikinRect tmpRect;
-    for (uint32_t i = 0; i < layoutPiece.glyphCount(); ++i) {
-        const FakedFont& font = layoutPiece.fontAt(i);
-        const Point& point = layoutPiece.pointAt(i);
-
-        MinikinFont* minikinFont = font.font->typeface().get();
-        minikinFont->GetBounds(&tmpRect, layoutPiece.glyphIdAt(i), paint, font.fakery);
-        tmpRect.offset(point.x, point.y);
-        pieceBounds.join(tmpRect);
-    }
-    return pieceBounds;
-}
-
-}  // namespace minikin
diff --git a/libs/minikin/Debug.cpp b/libs/minikin/Debug.cpp
new file mode 100644
index 0000000..8168a77
--- /dev/null
+++ b/libs/minikin/Debug.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "minikin/Debug.h"
+
+#include <unicode/utf16.h>
+#include <unicode/utf8.h>
+
+#include <sstream>
+
+#include "minikin/FontFeature.h"
+#include "minikin/FontFileParser.h"
+#include "minikin/LayoutCore.h"
+#include "minikin/LocaleList.h"
+#include "minikin/MinikinExtent.h"
+#include "minikin/MinikinPaint.h"
+#include "minikin/MinikinRect.h"
+#include "minikin/Point.h"
+#include "minikin/Range.h"
+#include "minikin/U16StringPiece.h"
+
+namespace minikin {
+
+namespace debug {
+
+std::string toUtf8(const U16StringPiece& text) {
+    std::string output;
+    output.resize(text.size() * 4);
+    uint32_t in_i = 0;
+    uint32_t out_i = 0;
+    bool isError = false;
+
+    while (in_i < text.size()) {
+        uint32_t ch;
+        U16_NEXT(text, in_i, text.size(), ch);
+        U8_APPEND(output, out_i, output.size(), ch, isError);
+        if (isError) {
+            return "";
+        }
+    }
+
+    output.resize(out_i);
+    return output;
+}
+
+std::string toString(const Point& point) {
+    std::stringstream ss;
+    ss << point;
+    return ss.str();
+}
+
+std::string toString(const MinikinRect& rect) {
+    std::stringstream ss;
+    ss << rect;
+    return ss.str();
+}
+
+std::string toString(const Range& range) {
+    std::stringstream ss;
+    ss << range;
+    return ss.str();
+}
+
+std::string toString(const MinikinExtent& extent) {
+    std::stringstream ss;
+    ss << extent;
+    return ss.str();
+}
+
+std::string toString(const FontFeature& feature) {
+    std::stringstream ss;
+    ss << feature;
+    return ss.str();
+}
+
+std::string toString(const std::vector<FontFeature>& features) {
+    std::stringstream ss;
+    ss << features;
+    return ss.str();
+}
+
+std::string toString(const LayoutPiece& layout) {
+    std::stringstream ss;
+    ss << "{advance=" << layout.advance() << ", extent=" << toString(layout.extent())
+       << ", glyphs=";
+
+    for (uint32_t i = 0; i < layout.glyphCount(); ++i) {
+        ss << "{id:" << layout.glyphIdAt(i) << ", pos = " << toString(layout.pointAt(i))
+           << ", font = \""
+           << FontFileParser(layout.fontAt(i).hbFont()).getPostScriptName().value_or("[UNKNOWN]")
+           << "\"}, ";
+    }
+    return ss.str();
+}
+
+std::string toString(const MinikinPaint& paint) {
+    std::stringstream ss;
+    ss << "{size=" << paint.size << ", scaleX=" << paint.scaleX << ", skewX=" << paint.skewX
+       << ", letterSpacing=" << paint.letterSpacing << ", wordSpacing=" << paint.wordSpacing
+       << ", fontFlags=" << paint.fontFlags
+       << ", localeList=" << getLocaleString(paint.localeListId)
+       << ", fontStyle=" << paint.fontStyle << ", familyVariant=" << paint.familyVariant
+       << ", fontFeatureSettings=" << paint.fontFeatureSettings
+       << ", fontCollectionId=" << paint.font->getId();
+    return ss.str();
+}
+
+}  // namespace debug
+
+}  // namespace minikin
diff --git a/libs/minikin/FeatureFlags.h b/libs/minikin/FeatureFlags.h
new file mode 100644
index 0000000..9cfcf9d
--- /dev/null
+++ b/libs/minikin/FeatureFlags.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINIKIN_FEATURE_FLAGS_H
+#define MINIKIN_FEATURE_FLAGS_H
+
+#ifdef __ANDROID__
+#include <com_android_text_flags.h>
+#endif  // __ANDROID__
+
+namespace features {
+
+#ifdef __ANDROID__
+#define DEFINE_FEATURE_FLAG_ACCESSOROR(feature_name)                \
+    inline bool feature_name() {                                    \
+        static bool flag = com_android_text_flags_##feature_name(); \
+        return flag;                                                \
+    }
+#else  //  __ANDROID__
+#define DEFINE_FEATURE_FLAG_ACCESSOROR(feature_name) \
+    inline bool feature_name() {                     \
+        return true;                                 \
+    }
+#endif  //  __ANDROID__
+
+DEFINE_FEATURE_FLAG_ACCESSOROR(phrase_strict_fallback)
+DEFINE_FEATURE_FLAG_ACCESSOROR(word_style_auto)
+DEFINE_FEATURE_FLAG_ACCESSOROR(inter_character_justification)
+
+}  // namespace features
+
+#endif  // FEATURE_FLAGS
diff --git a/libs/minikin/Font.cpp b/libs/minikin/Font.cpp
index bf7450a..a044b90 100644
--- a/libs/minikin/Font.cpp
+++ b/libs/minikin/Font.cpp
@@ -27,12 +27,35 @@
 #include "FontUtils.h"
 #include "LocaleListCache.h"
 #include "MinikinInternal.h"
+#include "minikin/Constants.h"
 #include "minikin/HbUtils.h"
 #include "minikin/MinikinFont.h"
 #include "minikin/MinikinFontFactory.h"
 
 namespace minikin {
 
+namespace {
+
+// |-------|-------|
+//                 X : (1 bit) 1 if weight variation is available, otherwise 0.
+//                Y  : (1 bit) 1 if italic variation is available, otherwise 0.
+//               I   : (1 bit) 1 for italic, 0 for upright
+//     WWWWWWWWWW    : (10 bits) unsigned 10 bits integer for weight value.
+inline uint16_t packKey(int wght, int ital) {
+    uint16_t res = 0;
+    if (wght != -1) {
+        res |= 1u;
+        res |= static_cast<uint16_t>(wght) << 3;
+    }
+    if (ital != -1) {
+        res |= 1u << 1;
+        res |= (ital == 1) ? 1 << 2 : 0;
+    }
+    return res;
+}
+
+}  // namespace
+
 std::shared_ptr<Font> Font::Builder::build() {
     if (mIsWeightSet && mIsSlantSet) {
         // No need to read OS/2 header of the font file.
@@ -62,7 +85,7 @@ Font::Font(BufferReader* reader) : mExternalRefsHolder(nullptr), mTypefaceMetada
 void Font::writeTo(BufferWriter* writer) const {
     mStyle.writeTo(writer);
     LocaleListCache::writeTo(writer, mLocaleListId);
-    MinikinFontFactory::getInstance().write(writer, typeface().get());
+    MinikinFontFactory::getInstance().write(writer, baseTypeface().get());
 }
 
 Font::Font(Font&& o) noexcept
@@ -91,7 +114,7 @@ void Font::resetExternalRefs(ExternalRefs* refs) {
     }
 }
 
-const std::shared_ptr<MinikinFont>& Font::typeface() const {
+const std::shared_ptr<MinikinFont>& Font::baseTypeface() const {
     return getExternalRefs()->mTypeface;
 }
 
@@ -154,7 +177,7 @@ HbFontUniquePtr Font::prepareFont(const std::shared_ptr<MinikinFont>& typeface)
 
 // static
 FontStyle Font::analyzeStyle(const HbFontUniquePtr& font) {
-    HbBlob os2Table(font, MinikinFont::MakeTag('O', 'S', '/', '2'));
+    HbBlob os2Table(font, MakeTag('O', 'S', '/', '2'));
     if (!os2Table) {
         return FontStyle();
     }
@@ -169,7 +192,7 @@ FontStyle Font::analyzeStyle(const HbFontUniquePtr& font) {
 }
 
 std::unordered_set<AxisTag> Font::getSupportedAxes() const {
-    HbBlob fvarTable(baseFont(), MinikinFont::MakeTag('f', 'v', 'a', 'r'));
+    HbBlob fvarTable(baseFont(), MakeTag('f', 'v', 'a', 'r'));
     if (!fvarTable) {
         return std::unordered_set<AxisTag>();
     }
@@ -178,4 +201,75 @@ std::unordered_set<AxisTag> Font::getSupportedAxes() const {
     return supportedAxes;
 }
 
+HbFontUniquePtr Font::getAdjustedFont(int wght, int ital) const {
+    if (wght == -1 && ital == -1) {
+        return HbFontUniquePtr(hb_font_reference(baseFont().get()));
+    }
+
+    HbFontUniquePtr font(hb_font_create_sub_font(baseFont().get()));
+    std::vector<hb_variation_t> variations;
+    variations.reserve(baseTypeface()->GetAxes().size());
+    for (const FontVariation& variation : baseTypeface()->GetAxes()) {
+        if (wght != -1 && variation.axisTag == TAG_wght) {
+            continue;  // Add wght axis later
+        } else if (ital != -1 && variation.axisTag == TAG_ital) {
+            continue;  // Add ital axis later
+        } else {
+            variations.push_back({variation.axisTag, variation.value});
+        }
+    }
+    if (wght != -1) {
+        variations.push_back({TAG_wght, static_cast<float>(wght)});
+    }
+    if (ital != -1) {
+        variations.push_back({TAG_ital, static_cast<float>(ital)});
+    }
+    hb_font_set_variations(font.get(), variations.data(), variations.size());
+    return font;
+}
+
+const std::shared_ptr<MinikinFont>& Font::getAdjustedTypeface(int wght, int ital) const {
+    return getExternalRefs()->getAdjustedTypeface(wght, ital);
+}
+
+const std::shared_ptr<MinikinFont>& Font::ExternalRefs::getAdjustedTypeface(int wght,
+                                                                            int ital) const {
+    if (wght == -1 && ital == -1) {
+        return mTypeface;
+    }
+
+    const uint16_t key = packKey(wght, ital);
+
+    std::lock_guard<std::mutex> lock(mMutex);
+
+    std::map<uint16_t, std::shared_ptr<MinikinFont>>::iterator it = mVarTypefaceCache.find(key);
+    if (it != mVarTypefaceCache.end()) {
+        return it->second;
+    }
+
+    std::vector<FontVariation> variations;
+    variations.reserve(mTypeface->GetAxes().size());
+    for (const FontVariation& variation : mTypeface->GetAxes()) {
+        if (wght != -1 && variation.axisTag == TAG_wght) {
+            continue;  // Add wght axis later
+        } else if (ital != -1 && variation.axisTag == TAG_ital) {
+            continue;  // Add ital axis later
+        } else {
+            variations.push_back({variation.axisTag, variation.value});
+        }
+    }
+    if (wght != -1) {
+        variations.push_back({TAG_wght, static_cast<float>(wght)});
+    }
+    if (ital != -1) {
+        variations.push_back({TAG_ital, static_cast<float>(ital)});
+    }
+    std::shared_ptr<MinikinFont> newTypeface = mTypeface->createFontWithVariation(variations);
+
+    auto [result_iterator, _] =
+            mVarTypefaceCache.insert(std::make_pair(key, std::move(newTypeface)));
+
+    return result_iterator->second;
+}
+
 }  // namespace minikin
diff --git a/libs/minikin/FontCollection.cpp b/libs/minikin/FontCollection.cpp
index 0c1a173..84e5dd9 100644
--- a/libs/minikin/FontCollection.cpp
+++ b/libs/minikin/FontCollection.cpp
@@ -30,6 +30,8 @@
 #include "minikin/Characters.h"
 #include "minikin/Emoji.h"
 #include "minikin/FontFileParser.h"
+#include "minikin/MinikinExtent.h"
+#include "minikin/MinikinPaint.h"
 
 using std::vector;
 
@@ -606,6 +608,89 @@ FontCollection::FamilyMatchResult FontCollection::FamilyMatchResult::intersect(
     return b.build();
 }
 
+void FontCollection::filterFamilyByLocale(
+        const LocaleList& localeList,
+        const std::function<void(const FontFamily& family)>& callback) const {
+    for (uint8_t i = 0; i < mFamilyCount; ++i) {
+        const auto& family = getFamilyAt(i);
+
+        uint32_t fontLocaleId = family->localeListId();
+        if (fontLocaleId == LocaleListCache::kInvalidListId) {
+            continue;
+        }
+        const LocaleList& fontLocaleList = LocaleListCache::getById(fontLocaleId);
+        if (!localeList.atLeastOneScriptMatch(fontLocaleList)) {
+            continue;
+        }
+
+        callback(*family.get());
+    }
+}
+
+MinikinExtent FontCollection::getReferenceExtentForLocale(const MinikinPaint& paint) const {
+    uint32_t localeId = paint.localeListId;
+    MinikinExtent result(0, 0);
+    for (uint8_t i = 0; i < mFamilyCount; ++i) {
+        const auto& family = getFamilyAt(i);
+        if (!family->isCustomFallback()) {
+            break;
+        }
+
+        // Use this family
+        MinikinExtent extent(0, 0);
+        FakedFont font = getFamilyAt(i)->getClosestMatch(paint.fontStyle);
+        font.typeface()->GetFontExtent(&extent, paint, font.fakery);
+        result.extendBy(extent);
+    }
+
+    if (localeId == LocaleListCache::kInvalidListId) {
+        return result;
+    }
+
+    // If default is requested, use compact one.
+    const FamilyVariant requestVariant = paint.familyVariant == FamilyVariant::DEFAULT
+                                                 ? FamilyVariant::COMPACT
+                                                 : paint.familyVariant;
+    const LocaleList& requestedLocaleList = LocaleListCache::getById(localeId);
+
+    bool familyFound = false;
+    filterFamilyByLocale(requestedLocaleList, [&](const FontFamily& family) {
+        const FamilyVariant familyVariant = family.variant() == FamilyVariant::DEFAULT
+                                                    ? FamilyVariant::COMPACT
+                                                    : family.variant();
+
+        if (familyVariant != requestVariant) {
+            return;
+        }
+
+        MinikinExtent extent(0, 0);
+        FakedFont font = family.getClosestMatch(paint.fontStyle);
+        font.typeface()->GetFontExtent(&extent, paint, font.fakery);
+        result.extendBy(extent);
+
+        familyFound = true;
+    });
+
+    // If nothing matches, try non-variant match cases since it is used for fallback.
+    filterFamilyByLocale(requestedLocaleList, [&](const FontFamily& family) {
+        // Use this family
+        MinikinExtent extent(0, 0);
+        FakedFont font = family.getClosestMatch(paint.fontStyle);
+        font.typeface()->GetFontExtent(&extent, paint, font.fakery);
+        result.extendBy(extent);
+
+        familyFound = true;
+    });
+
+    // If nothing matches, use default font.
+    if (!familyFound) {
+        FakedFont font = getFamilyAt(0)->getClosestMatch(paint.fontStyle);
+        font.typeface()->GetFontExtent(&result, paint, font.fakery);
+    }
+
+    return result;
+}
+
 std::vector<FontCollection::Run> FontCollection::itemize(U16StringPiece text, FontStyle,
                                                          uint32_t localeListId,
                                                          FamilyVariant familyVariant,
diff --git a/libs/minikin/FontFamily.cpp b/libs/minikin/FontFamily.cpp
index 836674c..e6da84e 100644
--- a/libs/minikin/FontFamily.cpp
+++ b/libs/minikin/FontFamily.cpp
@@ -29,6 +29,7 @@
 #include "LocaleListCache.h"
 #include "MinikinInternal.h"
 #include "minikin/CmapCoverage.h"
+#include "minikin/Constants.h"
 #include "minikin/FamilyVariant.h"
 #include "minikin/HbUtils.h"
 #include "minikin/MinikinFont.h"
@@ -44,21 +45,23 @@ std::shared_ptr<FontFamily> FontFamily::create(std::vector<std::shared_ptr<Font>
 std::shared_ptr<FontFamily> FontFamily::create(FamilyVariant variant,
                                                std::vector<std::shared_ptr<Font>>&& fonts) {
     return create(kEmptyLocaleListId, variant, std::move(fonts), false /* isCustomFallback */,
-                  false /* isDefaultFallback */);
+                  false /* isDefaultFallback */, VariationFamilyType::None);
 }
 
 // static
 std::shared_ptr<FontFamily> FontFamily::create(uint32_t localeListId, FamilyVariant variant,
                                                std::vector<std::shared_ptr<Font>>&& fonts,
-                                               bool isCustomFallback, bool isDefaultFallback) {
+                                               bool isCustomFallback, bool isDefaultFallback,
+                                               VariationFamilyType varFamilyType) {
     // TODO(b/174672300): Revert back to make_shared.
     return std::shared_ptr<FontFamily>(new FontFamily(localeListId, variant, std::move(fonts),
-                                                      isCustomFallback, isDefaultFallback));
+                                                      isCustomFallback, isDefaultFallback,
+                                                      varFamilyType));
 }
 
 FontFamily::FontFamily(uint32_t localeListId, FamilyVariant variant,
                        std::vector<std::shared_ptr<Font>>&& fonts, bool isCustomFallback,
-                       bool isDefaultFallback)
+                       bool isDefaultFallback, VariationFamilyType varFamilyType)
         : mFonts(std::make_unique<std::shared_ptr<Font>[]>(fonts.size())),
           // computeCoverage may update supported axes and coverages later.
           mSupportedAxes(nullptr),
@@ -72,7 +75,8 @@ FontFamily::FontFamily(uint32_t localeListId, FamilyVariant variant,
           mIsColorEmoji(LocaleListCache::getById(localeListId).getEmojiStyle() ==
                         EmojiStyle::EMOJI),
           mIsCustomFallback(isCustomFallback),
-          mIsDefaultFallback(isDefaultFallback) {
+          mIsDefaultFallback(isDefaultFallback),
+          mVarFamilyType(varFamilyType) {
     MINIKIN_ASSERT(!fonts.empty(), "FontFamily must contain at least one font.");
     MINIKIN_ASSERT(fonts.size() <= std::numeric_limits<uint32_t>::max(),
                    "Number of fonts must be less than 2^32.");
@@ -107,6 +111,7 @@ FontFamily::FontFamily(BufferReader* reader, const std::shared_ptr<std::vector<F
     mIsColorEmoji = static_cast<bool>(reader->read<uint8_t>());
     mIsCustomFallback = static_cast<bool>(reader->read<uint8_t>());
     mIsDefaultFallback = static_cast<bool>(reader->read<uint8_t>());
+    mVarFamilyType = reader->read<VariationFamilyType>();
     mCoverage = SparseBitSet(reader);
     // Read mCmapFmt14Coverage. As it can have null entries, it is stored in the buffer as a sparse
     // array (size, non-null entry count, array of (index, entry)).
@@ -133,6 +138,7 @@ void FontFamily::writeTo(BufferWriter* writer, uint32_t* fontIndex) const {
     writer->write<uint8_t>(mIsColorEmoji);
     writer->write<uint8_t>(mIsCustomFallback);
     writer->write<uint8_t>(mIsDefaultFallback);
+    writer->write<VariationFamilyType>(mVarFamilyType);
     mCoverage.writeTo(writer);
     // Write mCmapFmt14Coverage as a sparse array (size, non-null entry count,
     // array of (index, entry))
@@ -223,6 +229,9 @@ static FontFakery computeFakery(FontStyle wanted, FontStyle actual) {
 }
 
 FakedFont FontFamily::getClosestMatch(FontStyle style) const {
+    if (mVarFamilyType != VariationFamilyType::None) {
+        return getVariationFamilyAdjustment(style);
+    }
     int bestIndex = 0;
     Font* bestFont = mFonts[bestIndex].get();
     int bestMatch = computeMatch(bestFont->style(), style);
@@ -238,9 +247,23 @@ FakedFont FontFamily::getClosestMatch(FontStyle style) const {
     return FakedFont{mFonts[bestIndex], computeFakery(style, bestFont->style())};
 }
 
+FakedFont FontFamily::getVariationFamilyAdjustment(FontStyle style) const {
+    const bool italic = style.slant() == FontStyle::Slant::ITALIC;
+    switch (mVarFamilyType) {
+        case VariationFamilyType::SingleFont_wghtOnly:
+            return FakedFont{mFonts[0], FontFakery(false, italic, style.weight(), -1)};
+        case VariationFamilyType::SingleFont_wght_ital:
+            return FakedFont{mFonts[0], FontFakery(false, false, style.weight(), italic ? 1 : 0)};
+        case VariationFamilyType::TwoFont_wght:
+            return FakedFont{mFonts[italic ? 1 : 0], FontFakery(false, false, style.weight(), -1)};
+        case VariationFamilyType::None:
+            return FakedFont{mFonts[0], FontFakery()};
+    }
+}
+
 void FontFamily::computeCoverage() {
     const std::shared_ptr<Font>& font = getClosestMatch(FontStyle()).font;
-    HbBlob cmapTable(font->baseFont(), MinikinFont::MakeTag('c', 'm', 'a', 'p'));
+    HbBlob cmapTable(font->baseFont(), MakeTag('c', 'm', 'a', 'p'));
     if (cmapTable.get() == nullptr) {
         ALOGE("Could not get cmap table size!\n");
         return;
@@ -333,7 +356,7 @@ std::shared_ptr<FontFamily> FontFamily::createFamilyWithVariation(
         }
         std::shared_ptr<MinikinFont> minikinFont;
         if (supportedVariations) {
-            minikinFont = font->typeface()->createFontWithVariation(variations);
+            minikinFont = font->baseTypeface()->createFontWithVariation(variations);
         }
         if (minikinFont == nullptr) {
             fonts.push_back(font);
@@ -342,7 +365,8 @@ std::shared_ptr<FontFamily> FontFamily::createFamilyWithVariation(
         }
     }
 
-    return create(mLocaleListId, mVariant, std::move(fonts), mIsCustomFallback, mIsDefaultFallback);
+    return create(mLocaleListId, mVariant, std::move(fonts), mIsCustomFallback, mIsDefaultFallback,
+                  VariationFamilyType::None);
 }
 
 }  // namespace minikin
diff --git a/libs/minikin/FontFeatureUtils.cpp b/libs/minikin/FontFeatureUtils.cpp
index e1ec065..cc0749a 100644
--- a/libs/minikin/FontFeatureUtils.cpp
+++ b/libs/minikin/FontFeatureUtils.cpp
@@ -14,12 +14,29 @@
  * limitations under the License.
  */
 
-#include "FontFeatureUtils.h"
-
 #include "StringPiece.h"
+#include "minikin/FontFeature.h"
+#include "minikin/MinikinPaint.h"
 
 namespace minikin {
 
+std::vector<FontFeature> FontFeature::parse(std::string_view fontFeatureSettings) {
+    std::vector<FontFeature> features;
+
+    SplitIterator it(StringPiece(fontFeatureSettings), ',');
+    while (it.hasNext()) {
+        StringPiece featureStr = it.next();
+        static hb_feature_t feature;
+        // We do not allow setting features on ranges. As such, reject any setting that has
+        // non-universal range.
+        if (hb_feature_from_string(featureStr.data(), featureStr.size(), &feature) &&
+            feature.start == 0 && feature.end == (unsigned int)-1) {
+            features.push_back({feature.tag, feature.value});
+        }
+    }
+    return features;
+}
+
 std::vector<hb_feature_t> cleanAndAddDefaultFontFeatures(const MinikinPaint& paint) {
     std::vector<hb_feature_t> features;
     // Disable default-on non-required ligature features if letter-spacing
@@ -40,27 +57,17 @@ std::vector<hb_feature_t> cleanAndAddDefaultFontFeatures(const MinikinPaint& pai
     static constexpr hb_tag_t halt_tag = HB_TAG('h', 'a', 'l', 't');
     static constexpr hb_tag_t palt_tag = HB_TAG('p', 'a', 'l', 't');
 
-    SplitIterator it(paint.fontFeatureSettings, ',');
-    while (it.hasNext()) {
-        StringPiece featureStr = it.next();
-        static hb_feature_t feature;
-        // We do not allow setting features on ranges. As such, reject any setting that has
-        // non-universal range.
-        if (hb_feature_from_string(featureStr.data(), featureStr.size(), &feature) &&
-            feature.start == 0 && feature.end == (unsigned int)-1) {
-            // OpenType requires disabling default `chws` feature if glyph-width features.
-            // https://docs.microsoft.com/en-us/typography/opentype/spec/features_ae#tag-chws
-            // Here, we follow Chrome's impl: not enabling default `chws` feature if `palt` or
-            // `halt` is enabled.
-            // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/platform/fonts/shaping/font_features.cc;drc=77a9a09de0688ca449f5333a305ceaf3f36b6daf;l=215
-            if (default_enable_chws &&
-                (feature.tag == chws_tag ||
-                 (feature.value && (feature.tag == halt_tag || feature.tag == palt_tag)))) {
-                default_enable_chws = false;
-            }
-
-            features.push_back(feature);
+    for (const FontFeature& feature : paint.fontFeatureSettings) {
+        // OpenType requires disabling default `chws` feature if glyph-width features.
+        // https://docs.microsoft.com/en-us/typography/opentype/spec/features_ae#tag-chws
+        // Here, we follow Chrome's impl: not enabling default `chws` feature if `palt` or
+        // `halt` is enabled.
+        // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/platform/fonts/shaping/font_features.cc;drc=77a9a09de0688ca449f5333a305ceaf3f36b6daf;l=215
+        if (feature.tag == chws_tag ||
+            (feature.value && (feature.tag == halt_tag || feature.tag == palt_tag))) {
+            default_enable_chws = false;
         }
+        features.push_back({feature.tag, feature.value, 0, ~0u});
     }
 
     if (default_enable_chws) {
diff --git a/libs/minikin/FontFeatureUtils.h b/libs/minikin/FontFeatureUtils.h
deleted file mode 100644
index 1a02173..0000000
--- a/libs/minikin/FontFeatureUtils.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MINIKIN_FONT_FEATURE_UTILS_H
-#define MINIKIN_FONT_FEATURE_UTILS_H
-
-#include <hb.h>
-
-#include "minikin/MinikinPaint.h"
-
-namespace minikin {
-
-/**
- * Returns the final set of font features based on the features requested by this paint object and
- * extra defaults or implied font features.
- *
- * Features are included from the paint object if they are:
- *   1) in a supported range
- *
- * Default features are added based if they are:
- *   1) implied due to Paint settings such as letterSpacing
- *   2) default features that do not conflict with requested features
- */
-std::vector<hb_feature_t> cleanAndAddDefaultFontFeatures(const MinikinPaint& paint);
-
-}  // namespace minikin
-#endif  // MINIKIN_LAYOUT_UTILS_H
diff --git a/libs/minikin/FontFileParser.cpp b/libs/minikin/FontFileParser.cpp
index 1bcb711..a7d5210 100644
--- a/libs/minikin/FontFileParser.cpp
+++ b/libs/minikin/FontFileParser.cpp
@@ -18,16 +18,16 @@
 
 #define LOG_TAG "Minikin"
 
+#include <hb-ot.h>
+#include <hb.h>
+
 #include <cstdint>
 #include <optional>
 #include <string>
 #include <vector>
 
-#include <hb-ot.h>
-#include <hb.h>
-
 #include "MinikinInternal.h"
-#include "minikin/MinikinFont.h"
+#include "minikin/Constants.h"
 
 namespace minikin {
 
@@ -175,7 +175,7 @@ HbFaceUniquePtr FontFileParser::makeHbFace(const void* buffer, size_t size, uint
 std::optional<uint32_t> FontFileParser::getFontRevision() const {
     if (!mFace) return std::optional<uint32_t>();
 
-    HbBlob headTable(mFace, MinikinFont::MakeTag('h', 'e', 'a', 'd'));
+    HbBlob headTable(mFace, MakeTag('h', 'e', 'a', 'd'));
     if (!headTable) return std::optional<uint32_t>();
 
     uint32_t out = 0;
@@ -211,8 +211,8 @@ std::optional<std::string> FontFileParser::getPostScriptName() const {
 std::optional<bool> FontFileParser::isPostScriptType1Font() const {
     if (!mFace) return std::optional<bool>();
 
-    HbBlob cffTable(mFace, MinikinFont::MakeTag('C', 'F', 'F', ' '));
-    HbBlob cff2Table(mFace, MinikinFont::MakeTag('C', 'F', 'F', '2'));
+    HbBlob cffTable(mFace, MakeTag('C', 'F', 'F', ' '));
+    HbBlob cff2Table(mFace, MakeTag('C', 'F', 'F', '2'));
     return cffTable || cff2Table;
 }
 
diff --git a/libs/minikin/GreedyLineBreaker.cpp b/libs/minikin/GreedyLineBreaker.cpp
index bb2f91c..c4ceabe 100644
--- a/libs/minikin/GreedyLineBreaker.cpp
+++ b/libs/minikin/GreedyLineBreaker.cpp
@@ -16,17 +16,17 @@
 
 #define LOG_TAG "GreedyLineBreak"
 
-#include "minikin/Characters.h"
-#include "minikin/LineBreaker.h"
-#include "minikin/MeasuredText.h"
-#include "minikin/Range.h"
-#include "minikin/U16StringPiece.h"
-
+#include "FeatureFlags.h"
 #include "HyphenatorMap.h"
 #include "LineBreakerUtil.h"
 #include "Locale.h"
 #include "LocaleListCache.h"
 #include "WordBreaker.h"
+#include "minikin/Characters.h"
+#include "minikin/LineBreaker.h"
+#include "minikin/MeasuredText.h"
+#include "minikin/Range.h"
+#include "minikin/U16StringPiece.h"
 
 namespace minikin {
 
@@ -40,18 +40,21 @@ public:
     // destructed.
     GreedyLineBreaker(const U16StringPiece& textBuf, const MeasuredText& measured,
                       const LineWidth& lineWidthLimits, const TabStops& tabStops,
-                      bool enableHyphenation)
+                      bool enableHyphenation, bool useBoundsForWidth)
             : mLineWidthLimit(lineWidthLimits.getAt(0)),
               mTextBuf(textBuf),
               mMeasuredText(measured),
               mLineWidthLimits(lineWidthLimits),
               mTabStops(tabStops),
-              mEnableHyphenation(enableHyphenation) {}
+              mEnableHyphenation(enableHyphenation),
+              mUseBoundsForWidth(useBoundsForWidth) {}
 
-    void process();
+    void process(bool forceWordStyleAutoToPhrase);
 
     LineBreakResult getResult() const;
 
+    bool retryWithPhraseWordBreak = false;
+
 private:
     struct BreakPoint {
         BreakPoint(uint32_t offset, float lineWidth, StartHyphenEdit startHyphen,
@@ -99,6 +102,9 @@ private:
     // This method return true if there is no characters to be processed.
     bool doLineBreakWithGraphemeBounds(const Range& range);
 
+    bool overhangExceedLineLimit(const Range& range);
+    bool doLineBreakWithFallback(const Range& range);
+
     // Info about the line currently processing.
     uint32_t mLineNum = 0;
     double mLineWidth = 0;
@@ -121,6 +127,7 @@ private:
     const LineWidth& mLineWidthLimits;
     const TabStops& mTabStops;
     bool mEnableHyphenation;
+    bool mUseBoundsForWidth;
 
     // The result of line breaking.
     std::vector<BreakPoint> mBreakPoints;
@@ -181,6 +188,10 @@ bool GreedyLineBreaker::tryLineBreakWithHyphenation(const Range& range, WordBrea
         return false;
     }
 
+    if (!targetRun->canHyphenate()) {
+        return false;
+    }
+
     const std::vector<HyphenationType> hyphenResult =
             hyphenate(mTextBuf.substr(targetRange), *mHyphenator);
     Range contextRange = range;
@@ -263,7 +274,8 @@ bool GreedyLineBreaker::doLineBreakWithGraphemeBounds(const Range& range) {
         if (w == 0) {
             continue;  // w == 0 means here is not a grapheme bounds. Don't break here.
         }
-        if (width + w > mLineWidthLimit) {
+        if (width + w > mLineWidthLimit ||
+            overhangExceedLineLimit(Range(range.getStart(), i + 1))) {
             // Okay, here is the longest position.
             breakLineAt(i, width, mLineWidth - width, mSumOfCharWidths - width,
                         EndHyphenEdit::NO_EDIT, StartHyphenEdit::NO_EDIT);
@@ -282,6 +294,72 @@ bool GreedyLineBreaker::doLineBreakWithGraphemeBounds(const Range& range) {
     return true;
 }
 
+bool GreedyLineBreaker::doLineBreakWithFallback(const Range& range) {
+    if (!features::phrase_strict_fallback()) {
+        return false;
+    }
+    Run* targetRun = nullptr;
+    for (const auto& run : mMeasuredText.runs) {
+        if (run->getRange().contains(range)) {
+            targetRun = run.get();
+        }
+    }
+
+    if (targetRun == nullptr) {
+        return false;  // The target range may lay on multiple run. Unable to fallback.
+    }
+
+    if (targetRun->lineBreakWordStyle() == LineBreakWordStyle::None) {
+        return false;  // If the line break word style is already none, nothing can be falled back.
+    }
+
+    WordBreaker wb;
+    wb.setText(mTextBuf.data(), mTextBuf.length());
+    ssize_t next = wb.followingWithLocale(getEffectiveLocale(targetRun->getLocaleListId()),
+                                          targetRun->lineBreakStyle(), LineBreakWordStyle::None,
+                                          range.getStart());
+
+    if (!range.contains(next)) {
+        return false;  // No fallback break points.
+    }
+
+    int32_t prevBreak = -1;
+    float wordWidth = 0;
+    float preBreakWidth = 0;
+    for (uint32_t i = range.getStart(); i < range.getEnd(); ++i) {
+        const float w = mMeasuredText.widths[i];
+        if (w == 0) {
+            continue;  // w == 0 means here is not a grapheme bounds. Don't break here.
+        }
+        if (i == (uint32_t)next) {
+            if (preBreakWidth + wordWidth > mLineWidthLimit) {
+                if (prevBreak == -1) {
+                    return false;  // No candidate before this point. Give up.
+                }
+                breakLineAt(prevBreak, preBreakWidth, mLineWidth - preBreakWidth,
+                            mSumOfCharWidths - preBreakWidth, EndHyphenEdit::NO_EDIT,
+                            StartHyphenEdit::NO_EDIT);
+                return true;
+            }
+            prevBreak = i;
+            next = wb.next();
+            preBreakWidth += wordWidth;
+            wordWidth = w;
+        } else {
+            wordWidth += w;
+        }
+    }
+
+    if (preBreakWidth <= mLineWidthLimit) {
+        breakLineAt(prevBreak, preBreakWidth, mLineWidth - preBreakWidth,
+                    mSumOfCharWidths - preBreakWidth, EndHyphenEdit::NO_EDIT,
+                    StartHyphenEdit::NO_EDIT);
+        return true;
+    }
+
+    return false;
+}
+
 void GreedyLineBreaker::updateLineWidth(uint16_t c, float width) {
     if (c == CHAR_TAB) {
         mSumOfCharWidths = mTabStops.nextTab(mSumOfCharWidths);
@@ -294,18 +372,48 @@ void GreedyLineBreaker::updateLineWidth(uint16_t c, float width) {
     }
 }
 
+bool GreedyLineBreaker::overhangExceedLineLimit(const Range& range) {
+    if (!mUseBoundsForWidth) {
+        return false;
+    }
+    if (!mMeasuredText.hasOverhang(range)) {
+        return false;
+    }
+
+    uint32_t i;
+    for (i = 0; i < range.getLength(); ++i) {
+        uint16_t ch = mTextBuf[range.getEnd() - i - 1];
+        if (!isLineEndSpace(ch)) {
+            break;
+        }
+    }
+    if (i == range.getLength()) {
+        return false;
+    }
+
+    return mMeasuredText.getBounds(mTextBuf, Range(range.getStart(), range.getEnd() - i)).width() >
+           mLineWidthLimit;
+}
+
 void GreedyLineBreaker::processLineBreak(uint32_t offset, WordBreaker* breaker,
                                          bool doHyphenation) {
-    while (mLineWidth > mLineWidthLimit) {
-        const Range lineRange(getPrevLineBreakOffset(), offset);  // The range we need to address.
+    while (mLineWidth > mLineWidthLimit ||
+           overhangExceedLineLimit(Range(getPrevLineBreakOffset(), offset))) {
         if (tryLineBreakWithWordBreak()) {
             continue;  // The word in the new line may still be too long for the line limit.
-        } else if (doHyphenation && tryLineBreakWithHyphenation(lineRange, breaker)) {
+        }
+
+        if (doHyphenation &&
+            tryLineBreakWithHyphenation(Range(getPrevLineBreakOffset(), offset), breaker)) {
             continue;  // TODO: we may be able to return here.
-        } else {
-            if (doLineBreakWithGraphemeBounds(lineRange)) {
-                return;
-            }
+        }
+
+        if (doLineBreakWithFallback(Range(getPrevLineBreakOffset(), offset))) {
+            continue;
+        }
+
+        if (doLineBreakWithGraphemeBounds(Range(getPrevLineBreakOffset(), offset))) {
+            return;
         }
     }
 
@@ -319,24 +427,27 @@ void GreedyLineBreaker::processLineBreak(uint32_t offset, WordBreaker* breaker,
     }
 }
 
-void GreedyLineBreaker::process() {
+void GreedyLineBreaker::process(bool forceWordStyleAutoToPhrase) {
     WordBreaker wordBreaker;
     wordBreaker.setText(mTextBuf.data(), mTextBuf.size());
 
-    // Following two will be initialized after the first iteration.
-    uint32_t localeListId = LocaleListCache::kInvalidListId;
+    WordBreakerTransitionTracker wbTracker;
     uint32_t nextWordBoundaryOffset = 0;
     for (const auto& run : mMeasuredText.runs) {
         const Range range = run->getRange();
 
         // Update locale if necessary.
-        uint32_t newLocaleListId = run->getLocaleListId();
-        if (localeListId != newLocaleListId) {
-            Locale locale = getEffectiveLocale(newLocaleListId);
-            nextWordBoundaryOffset = wordBreaker.followingWithLocale(
-                    locale, run->lineBreakStyle(), run->lineBreakWordStyle(), range.getStart());
+        if (wbTracker.update(*run)) {
+            const LocaleList& localeList = wbTracker.getCurrentLocaleList();
+            const Locale locale = localeList.empty() ? Locale() : localeList[0];
+
+            LineBreakWordStyle lbWordStyle = wbTracker.getCurrentLineBreakWordStyle();
+            std::tie(lbWordStyle, retryWithPhraseWordBreak) =
+                    resolveWordStyleAuto(lbWordStyle, localeList, forceWordStyleAutoToPhrase);
+
+            nextWordBoundaryOffset = wordBreaker.followingWithLocale(locale, run->lineBreakStyle(),
+                                                                     lbWordStyle, range.getStart());
             mHyphenator = HyphenatorMap::lookup(locale);
-            localeListId = newLocaleListId;
         }
 
         for (uint32_t i = range.getStart(); i < range.getEnd(); ++i) {
@@ -371,12 +482,32 @@ LineBreakResult GreedyLineBreaker::getResult() const {
             hasTabChar |= mTextBuf[i] == CHAR_TAB;
         }
 
-        MinikinExtent extent =
-                mMeasuredText.getExtent(mTextBuf, Range(prevBreakOffset, breakPoint.offset));
+        if (mUseBoundsForWidth) {
+            Range range = Range(prevBreakOffset, breakPoint.offset);
+            Range actualRange = trimTrailingLineEndSpaces(mTextBuf, range);
+            if (actualRange.isEmpty()) {
+                // No characters before the line-end-spaces.
+                MinikinExtent extent = mMeasuredText.getExtent(mTextBuf, range);
+                out.ascents.push_back(extent.ascent);
+                out.descents.push_back(extent.descent);
+                out.bounds.emplace_back(0, extent.ascent, breakPoint.lineWidth, extent.descent);
+            } else {
+                LineMetrics metrics = mMeasuredText.getLineMetrics(mTextBuf, actualRange);
+                out.ascents.push_back(metrics.extent.ascent);
+                out.descents.push_back(metrics.extent.descent);
+                out.bounds.emplace_back(metrics.bounds);
+            }
+        } else {
+            MinikinExtent extent =
+                    mMeasuredText.getExtent(mTextBuf, Range(prevBreakOffset, breakPoint.offset));
+            out.ascents.push_back(extent.ascent);
+            out.descents.push_back(extent.descent);
+            // We don't have bounding box if mUseBoundsForWidth is false. Use line ascent/descent
+            // and linew width for the bounding box.
+            out.bounds.emplace_back(0, extent.ascent, breakPoint.lineWidth, extent.descent);
+        }
         out.breakPoints.push_back(breakPoint.offset);
         out.widths.push_back(breakPoint.lineWidth);
-        out.ascents.push_back(extent.ascent);
-        out.descents.push_back(extent.descent);
         out.flags.push_back((hasTabChar ? TAB_BIT : 0) | static_cast<int>(breakPoint.hyphenEdit));
 
         prevBreakOffset = breakPoint.offset;
@@ -388,13 +519,41 @@ LineBreakResult GreedyLineBreaker::getResult() const {
 
 LineBreakResult breakLineGreedy(const U16StringPiece& textBuf, const MeasuredText& measured,
                                 const LineWidth& lineWidthLimits, const TabStops& tabStops,
-                                bool enableHyphenation) {
+                                bool enableHyphenation, bool useBoundsForWidth) {
     if (textBuf.size() == 0) {
         return LineBreakResult();
     }
-    GreedyLineBreaker lineBreaker(textBuf, measured, lineWidthLimits, tabStops, enableHyphenation);
-    lineBreaker.process();
-    return lineBreaker.getResult();
+    GreedyLineBreaker lineBreaker(textBuf, measured, lineWidthLimits, tabStops, enableHyphenation,
+                                  useBoundsForWidth);
+    lineBreaker.process(false);
+    LineBreakResult res = lineBreaker.getResult();
+
+    if (!features::word_style_auto()) {
+        return res;
+    }
+
+    // The line breaker says that retry with phrase based word break because of the auto option and
+    // given locales.
+    if (!lineBreaker.retryWithPhraseWordBreak) {
+        return res;
+    }
+
+    // If the line break result is more than heuristics threshold, don't try pharse based word
+    // break.
+    if (res.breakPoints.size() >= LBW_AUTO_HEURISTICS_LINE_COUNT) {
+        return res;
+    }
+
+    GreedyLineBreaker phLineBreaker(textBuf, measured, lineWidthLimits, tabStops, enableHyphenation,
+                                    useBoundsForWidth);
+    phLineBreaker.process(true);
+    LineBreakResult res2 = phLineBreaker.getResult();
+
+    if (res2.breakPoints.size() < LBW_AUTO_HEURISTICS_LINE_COUNT) {
+        return res2;
+    } else {
+        return res;
+    }
 }
 
 }  // namespace minikin
diff --git a/libs/minikin/GreedyLineBreaker.h b/libs/minikin/GreedyLineBreaker.h
index ead93e4..9d17ec2 100644
--- a/libs/minikin/GreedyLineBreaker.h
+++ b/libs/minikin/GreedyLineBreaker.h
@@ -27,7 +27,7 @@ namespace minikin {
 
 LineBreakResult breakLineGreedy(const U16StringPiece& textBuf, const MeasuredText& measured,
                                 const LineWidth& lineWidthLimits, const TabStops& tabStops,
-                                bool enableHyphenation);
+                                bool enableHyphenation, bool useBoundsForWidth);
 
 }  // namespace minikin
 
diff --git a/libs/minikin/Layout.cpp b/libs/minikin/Layout.cpp
index e7d41c8..6369109 100644
--- a/libs/minikin/Layout.cpp
+++ b/libs/minikin/Layout.cpp
@@ -18,12 +18,6 @@
 
 #include "minikin/Layout.h"
 
-#include <cmath>
-#include <iostream>
-#include <mutex>
-#include <string>
-#include <vector>
-
 #include <hb-icu.h>
 #include <hb-ot.h>
 #include <log/log.h>
@@ -31,18 +25,22 @@
 #include <unicode/utf16.h>
 #include <utils/LruCache.h>
 
-#include "minikin/Emoji.h"
-#include "minikin/HbUtils.h"
-#include "minikin/LayoutCache.h"
-#include "minikin/LayoutPieces.h"
-#include "minikin/Macros.h"
+#include <cmath>
+#include <iostream>
+#include <mutex>
+#include <string>
+#include <vector>
 
 #include "BidiUtils.h"
 #include "LayoutSplitter.h"
 #include "LayoutUtils.h"
 #include "LocaleListCache.h"
 #include "MinikinInternal.h"
-
+#include "minikin/Emoji.h"
+#include "minikin/HbUtils.h"
+#include "minikin/LayoutCache.h"
+#include "minikin/LayoutPieces.h"
+#include "minikin/Macros.h"
 namespace minikin {
 
 void Layout::doLayout(const U16StringPiece& textBuf, const Range& range, Bidi bidiFlags,
@@ -53,19 +51,27 @@ void Layout::doLayout(const U16StringPiece& textBuf, const Range& range, Bidi bi
     mGlyphs.reserve(count);
     for (const BidiText::RunInfo& runInfo : BidiText(textBuf, range, bidiFlags)) {
         doLayoutRunCached(textBuf, runInfo.range, runInfo.isRtl, paint, range.getStart(),
-                          startHyphen, endHyphen, this, nullptr);
+                          startHyphen, endHyphen, this, nullptr, nullptr);
     }
 }
 
 float Layout::measureText(const U16StringPiece& textBuf, const Range& range, Bidi bidiFlags,
                           const MinikinPaint& paint, StartHyphenEdit startHyphen,
-                          EndHyphenEdit endHyphen, float* advances) {
+                          EndHyphenEdit endHyphen, float* advances, MinikinRect* bounds) {
     float advance = 0;
+
+    MinikinRect tmpBounds;
     for (const BidiText::RunInfo& runInfo : BidiText(textBuf, range, bidiFlags)) {
         const size_t offset = range.toRangeOffset(runInfo.range.getStart());
         float* advancesForRun = advances ? advances + offset : nullptr;
-        advance += doLayoutRunCached(textBuf, runInfo.range, runInfo.isRtl, paint, 0, startHyphen,
-                                     endHyphen, nullptr, advancesForRun);
+        tmpBounds.setEmpty();
+        float run_advance = doLayoutRunCached(textBuf, runInfo.range, runInfo.isRtl, paint, 0,
+                                              startHyphen, endHyphen, nullptr, advancesForRun,
+                                              bounds ? &tmpBounds : nullptr);
+        if (bounds) {
+            bounds->join(tmpBounds, advance, 0);
+        }
+        advance += run_advance;
     }
     return advance;
 }
@@ -73,11 +79,12 @@ float Layout::measureText(const U16StringPiece& textBuf, const Range& range, Bid
 float Layout::doLayoutRunCached(const U16StringPiece& textBuf, const Range& range, bool isRtl,
                                 const MinikinPaint& paint, size_t dstStart,
                                 StartHyphenEdit startHyphen, EndHyphenEdit endHyphen,
-                                Layout* layout, float* advances) {
+                                Layout* layout, float* advances, MinikinRect* bounds) {
     if (!range.isValid()) {
         return 0.0f;  // ICU failed to retrieve the bidi run?
     }
     float advance = 0;
+    MinikinRect tmpBounds;
     for (const auto[context, piece] : LayoutSplitter(textBuf, range, isRtl)) {
         // Hyphenation only applies to the start/end of run.
         const StartHyphenEdit pieceStartHyphen =
@@ -86,25 +93,32 @@ float Layout::doLayoutRunCached(const U16StringPiece& textBuf, const Range& rang
                 (piece.getEnd() == range.getEnd()) ? endHyphen : EndHyphenEdit::NO_EDIT;
         float* advancesForRun =
                 advances ? advances + (piece.getStart() - range.getStart()) : nullptr;
-        advance += doLayoutWord(textBuf.data() + context.getStart(),
-                                piece.getStart() - context.getStart(), piece.getLength(),
-                                context.getLength(), isRtl, paint, piece.getStart() - dstStart,
-                                pieceStartHyphen, pieceEndHyphen, layout, advancesForRun);
+        tmpBounds.setEmpty();
+        float word_advance = doLayoutWord(
+                textBuf.data() + context.getStart(), piece.getStart() - context.getStart(),
+                piece.getLength(), context.getLength(), isRtl, paint, piece.getStart() - dstStart,
+                pieceStartHyphen, pieceEndHyphen, layout, advancesForRun,
+                bounds ? &tmpBounds : nullptr);
+        if (bounds) {
+            bounds->join(tmpBounds, advance, 0);
+        }
+        advance += word_advance;
     }
     return advance;
 }
 
 class LayoutAppendFunctor {
 public:
-    LayoutAppendFunctor(Layout* layout, float* advances, float* totalAdvance, uint32_t outOffset,
-                        float wordSpacing)
+    LayoutAppendFunctor(Layout* layout, float* advances, uint32_t outOffset, float wordSpacing,
+                        MinikinRect* bounds)
             : mLayout(layout),
               mAdvances(advances),
-              mTotalAdvance(totalAdvance),
               mOutOffset(outOffset),
-              mWordSpacing(wordSpacing) {}
+              mWordSpacing(wordSpacing),
+              mBounds(bounds) {}
 
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */) {
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */,
+                    const MinikinRect& bounds) {
         if (mLayout) {
             mLayout->appendLayout(layoutPiece, mOutOffset, mWordSpacing);
         }
@@ -112,30 +126,37 @@ public:
             const std::vector<float>& advances = layoutPiece.advances();
             std::copy(advances.begin(), advances.end(), mAdvances);
         }
-        if (mTotalAdvance) {
-            *mTotalAdvance = layoutPiece.advance();
+        if (mBounds) {
+            mBounds->join(bounds, mTotalAdvance, 0);
         }
+        mTotalAdvance += layoutPiece.advance();
     }
 
+    float getTotalAdvance() { return mTotalAdvance; }
+
 private:
     Layout* mLayout;
     float* mAdvances;
-    float* mTotalAdvance;
+    float mTotalAdvance{0};
     const uint32_t mOutOffset;
     const float mWordSpacing;
+    MinikinRect* mBounds;
 };
 
 float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize,
                            bool isRtl, const MinikinPaint& paint, size_t bufStart,
                            StartHyphenEdit startHyphen, EndHyphenEdit endHyphen, Layout* layout,
-                           float* advances) {
+                           float* advances, MinikinRect* bounds) {
     float wordSpacing = count == 1 && isWordSpace(buf[start]) ? paint.wordSpacing : 0;
     float totalAdvance = 0;
+    const bool boundsCalculation = bounds != nullptr;
 
     const U16StringPiece textBuf(buf, bufSize);
     const Range range(start, start + count);
-    LayoutAppendFunctor f(layout, advances, &totalAdvance, bufStart, wordSpacing);
-    LayoutCache::getInstance().getOrCreate(textBuf, range, paint, isRtl, startHyphen, endHyphen, f);
+    LayoutAppendFunctor f(layout, advances, bufStart, wordSpacing, bounds);
+    LayoutCache::getInstance().getOrCreate(textBuf, range, paint, isRtl, startHyphen, endHyphen,
+                                           boundsCalculation, f);
+    totalAdvance = f.getTotalAdvance();
 
     if (wordSpacing != 0) {
         totalAdvance += wordSpacing;
diff --git a/libs/minikin/LayoutCore.cpp b/libs/minikin/LayoutCore.cpp
index 6f33ad7..b079e85 100644
--- a/libs/minikin/LayoutCore.cpp
+++ b/libs/minikin/LayoutCore.cpp
@@ -15,6 +15,7 @@
  */
 
 #define LOG_TAG "Minikin"
+#define ATRACE_TAG ATRACE_TAG_VIEW
 
 #include "minikin/LayoutCore.h"
 
@@ -24,6 +25,7 @@
 #include <unicode/ubidi.h>
 #include <unicode/utf16.h>
 #include <utils/LruCache.h>
+#include <utils/Trace.h>
 
 #include <cmath>
 #include <iostream>
@@ -32,11 +34,12 @@
 #include <vector>
 
 #include "BidiUtils.h"
-#include "FontFeatureUtils.h"
 #include "LayoutUtils.h"
 #include "LocaleListCache.h"
 #include "MinikinInternal.h"
+#include "ScriptUtils.h"
 #include "minikin/Emoji.h"
+#include "minikin/FontFeature.h"
 #include "minikin/HbUtils.h"
 #include "minikin/LayoutCache.h"
 #include "minikin/LayoutPieces.h"
@@ -136,45 +139,6 @@ static bool isColorBitmapFont(const HbFontUniquePtr& font) {
     return cbdt;
 }
 
-static hb_codepoint_t decodeUtf16(const uint16_t* chars, size_t len, ssize_t* iter) {
-    UChar32 result;
-    U16_NEXT(chars, *iter, (ssize_t)len, result);
-    if (U_IS_SURROGATE(result)) {  // isolated surrogate
-        result = 0xFFFDu;          // U+FFFD REPLACEMENT CHARACTER
-    }
-    return (hb_codepoint_t)result;
-}
-
-static hb_script_t getScriptRun(const uint16_t* chars, size_t len, ssize_t* iter) {
-    if (size_t(*iter) == len) {
-        return HB_SCRIPT_UNKNOWN;
-    }
-    uint32_t cp = decodeUtf16(chars, len, iter);
-    hb_unicode_funcs_t* unicode_func = hb_unicode_funcs_get_default();
-    hb_script_t current_script = hb_unicode_script(unicode_func, cp);
-    for (;;) {
-        if (size_t(*iter) == len) break;
-        const ssize_t prev_iter = *iter;
-        cp = decodeUtf16(chars, len, iter);
-        const hb_script_t script = hb_unicode_script(unicode_func, cp);
-        if (script != current_script) {
-            if (current_script == HB_SCRIPT_INHERITED || current_script == HB_SCRIPT_COMMON) {
-                current_script = script;
-            } else if (script == HB_SCRIPT_INHERITED || script == HB_SCRIPT_COMMON) {
-                continue;
-            } else {
-                *iter = prev_iter;
-                break;
-            }
-        }
-    }
-    if (current_script == HB_SCRIPT_INHERITED) {
-        current_script = HB_SCRIPT_COMMON;
-    }
-
-    return current_script;
-}
-
 /**
  * Disable certain scripts (mostly those with cursive connection) from having letterspacing
  * applied. See https://github.com/behdad/harfbuzz/issues/64 for more details.
@@ -349,7 +313,7 @@ LayoutPiece::LayoutPiece(const U16StringPiece& textBuf, const Range& range, bool
     double size = paint.size;
     double scaleX = paint.scaleX;
 
-    std::unordered_map<const Font*, uint32_t> fontMap;
+    std::unordered_map<const MinikinFont*, uint32_t> fontMap;
 
     float x = 0;
     float y = 0;
@@ -358,19 +322,20 @@ LayoutPiece::LayoutPiece(const U16StringPiece& textBuf, const Range& range, bool
          isRtl ? --run_ix : ++run_ix) {
         FontCollection::Run& run = items[run_ix];
         FakedFont fakedFont = paint.font->getBestFont(substr, run, paint.fontStyle);
-        auto it = fontMap.find(fakedFont.font.get());
+        const std::shared_ptr<MinikinFont>& typeface = fakedFont.typeface();
+        auto it = fontMap.find(typeface.get());
         uint8_t font_ix;
         if (it == fontMap.end()) {
             // First time to see this font.
             font_ix = mFonts.size();
             mFonts.push_back(fakedFont);
-            fontMap.insert(std::make_pair(fakedFont.font.get(), font_ix));
+            fontMap.insert(std::make_pair(typeface.get(), font_ix));
 
             // We override some functions which are not thread safe.
-            HbFontUniquePtr font(hb_font_create_sub_font(fakedFont.font->baseFont().get()));
+            HbFontUniquePtr font(hb_font_create_sub_font(fakedFont.hbFont().get()));
             hb_font_set_funcs(
                     font.get(), isColorBitmapFont(font) ? getFontFuncsForEmoji() : getFontFuncs(),
-                    new SkiaArguments({fakedFont.font->typeface().get(), &paint, fakedFont.fakery}),
+                    new SkiaArguments({fakedFont.typeface().get(), &paint, fakedFont.fakery}),
                     [](void* data) { delete reinterpret_cast<SkiaArguments*>(data); });
             hbFonts.push_back(std::move(font));
         } else {
@@ -387,7 +352,7 @@ LayoutPiece::LayoutPiece(const U16StringPiece& textBuf, const Range& range, bool
         }
         if (needExtent) {
             MinikinExtent verticalExtent;
-            fakedFont.font->typeface()->GetFontExtent(&verticalExtent, paint, fakedFont.fakery);
+            typeface->GetFontExtent(&verticalExtent, paint, fakedFont.fakery);
             mExtent.extendBy(verticalExtent);
         }
 
@@ -400,11 +365,10 @@ LayoutPiece::LayoutPiece(const U16StringPiece& textBuf, const Range& range, bool
 
         // Note: scriptRunStart and scriptRunEnd, as well as run.start and run.end, run between 0
         // and count.
-        ssize_t scriptRunEnd;
-        for (ssize_t scriptRunStart = run.start; scriptRunStart < run.end;
-             scriptRunStart = scriptRunEnd) {
-            scriptRunEnd = scriptRunStart;
-            hb_script_t script = getScriptRun(buf + start, run.end, &scriptRunEnd /* iterator */);
+        for (const auto [range, script] : ScriptText(textBuf, run.start, run.end)) {
+            ssize_t scriptRunStart = range.getStart();
+            ssize_t scriptRunEnd = range.getEnd();
+
             // After the last line, scriptRunEnd is guaranteed to have increased, since the only
             // time getScriptRun does not increase its iterator is when it has already reached the
             // end of the buffer. But that can't happen, since if we have already reached the end
@@ -494,4 +458,22 @@ LayoutPiece::LayoutPiece(const U16StringPiece& textBuf, const Range& range, bool
     mAdvance = x;
 }
 
+// static
+MinikinRect LayoutPiece::calculateBounds(const LayoutPiece& layout, const MinikinPaint& paint) {
+    ATRACE_CALL();
+    MinikinRect out;
+    for (uint32_t i = 0; i < layout.glyphCount(); ++i) {
+        MinikinRect bounds;
+        uint32_t glyphId = layout.glyphIdAt(i);
+        const FakedFont& fakedFont = layout.fontAt(i);
+        const Point& pos = layout.pointAt(i);
+
+        fakedFont.typeface()->GetBounds(&bounds, glyphId, paint, fakedFont.fakery);
+        out.join(bounds, pos);
+    }
+    return out;
+}
+
+LayoutPiece::~LayoutPiece() {}
+
 }  // namespace minikin
diff --git a/libs/minikin/LineBreaker.cpp b/libs/minikin/LineBreaker.cpp
index 12cf9bd..20a075c 100644
--- a/libs/minikin/LineBreaker.cpp
+++ b/libs/minikin/LineBreaker.cpp
@@ -24,13 +24,13 @@ namespace minikin {
 LineBreakResult breakIntoLines(const U16StringPiece& textBuffer, BreakStrategy strategy,
                                HyphenationFrequency frequency, bool justified,
                                const MeasuredText& measuredText, const LineWidth& lineWidth,
-                               const TabStops& tabStops) {
+                               const TabStops& tabStops, bool useBoundsForWidth) {
     if (strategy == BreakStrategy::Greedy || textBuffer.hasChar(CHAR_TAB)) {
         return breakLineGreedy(textBuffer, measuredText, lineWidth, tabStops,
-                               frequency != HyphenationFrequency::None);
+                               frequency != HyphenationFrequency::None, useBoundsForWidth);
     } else {
-        return breakLineOptimal(textBuffer, measuredText, lineWidth, strategy, frequency,
-                                justified);
+        return breakLineOptimal(textBuffer, measuredText, lineWidth, strategy, frequency, justified,
+                                useBoundsForWidth);
     }
 }
 
diff --git a/libs/minikin/LineBreakerUtil.h b/libs/minikin/LineBreakerUtil.h
index 5764c5e..030e677 100644
--- a/libs/minikin/LineBreakerUtil.h
+++ b/libs/minikin/LineBreakerUtil.h
@@ -19,19 +19,21 @@
 
 #include <vector>
 
-#include "minikin/Hyphenator.h"
-#include "minikin/MeasuredText.h"
-#include "minikin/U16StringPiece.h"
-
 #include "HyphenatorMap.h"
 #include "LayoutUtils.h"
 #include "Locale.h"
 #include "LocaleListCache.h"
 #include "MinikinInternal.h"
 #include "WordBreaker.h"
+#include "minikin/Hyphenator.h"
+#include "minikin/LineBreakStyle.h"
+#include "minikin/MeasuredText.h"
+#include "minikin/U16StringPiece.h"
 
 namespace minikin {
 
+constexpr uint32_t LBW_AUTO_HEURISTICS_LINE_COUNT = 5;
+
 // ParaWidth is used to hold cumulative width from beginning of paragraph. Note that for very large
 // paragraphs, accuracy could degrade using only 32-bit float. Note however that float is used
 // extensively on the Java side for this. This is a typedef so that we can easily change it based
@@ -55,6 +57,15 @@ inline bool isLineEndSpace(uint16_t c) {
            || c == 0x3000;
 }
 
+inline Range trimTrailingLineEndSpaces(const U16StringPiece& textBuf, const Range& range) {
+    for (uint32_t i = 0; i < range.getLength(); i++) {
+        if (!isLineEndSpace(textBuf[range.getEnd() - i - 1])) {
+            return Range(range.getStart(), range.getEnd() - i);
+        }
+    }
+    return Range(range.getStart(), range.getStart());
+}
+
 inline Locale getEffectiveLocale(uint32_t localeListId) {
     const LocaleList& localeList = LocaleListCache::getById(localeListId);
     return localeList.empty() ? Locale() : localeList[0];
@@ -125,6 +136,58 @@ inline void populateHyphenationPoints(
     }
 }
 
+// Class for tracking the word breaker transition point.
+class WordBreakerTransitionTracker {
+public:
+    // Update the word breaker transition information. This function return true if the word
+    // breaker need to be updated.
+    bool update(const Run& run) {
+        const uint32_t newLocaleListId = run.getLocaleListId();
+        const LineBreakStyle newLineBreakStyle = run.lineBreakStyle();
+        const LineBreakWordStyle newLineBreakWordStyle = run.lineBreakWordStyle();
+        const bool isUpdate = localeListId != newLocaleListId ||
+                              lineBreakStyle != newLineBreakStyle ||
+                              lineBreakWordStyle != newLineBreakWordStyle;
+
+        localeListId = newLocaleListId;
+        lineBreakStyle = newLineBreakStyle;
+        lineBreakWordStyle = newLineBreakWordStyle;
+
+        return isUpdate;
+    }
+
+    const LocaleList& getCurrentLocaleList() const {
+        return LocaleListCache::getById(localeListId);
+    }
+
+    LineBreakStyle getCurrentLineBreakStyle() const { return lineBreakStyle; }
+
+    LineBreakWordStyle getCurrentLineBreakWordStyle() const { return lineBreakWordStyle; }
+
+private:
+    uint32_t localeListId = LocaleListCache::kInvalidListId;
+    LineBreakStyle lineBreakStyle = LineBreakStyle::None;
+    LineBreakWordStyle lineBreakWordStyle = LineBreakWordStyle::None;
+};
+
+inline std::pair<LineBreakWordStyle, bool> resolveWordStyleAuto(LineBreakWordStyle lbWordStyle,
+                                                                const LocaleList& localeList,
+                                                                bool forceWordStyleAutoToPhrase) {
+    if (lbWordStyle == LineBreakWordStyle::Auto) {
+        if (forceWordStyleAutoToPhrase) {
+            return std::make_pair(LineBreakWordStyle::Phrase, false);
+        } else if (localeList.hasKorean()) {
+            return std::make_pair(LineBreakWordStyle::Phrase, false);
+        } else if (localeList.hasJapanese()) {
+            return std::make_pair(LineBreakWordStyle::None, true);
+        } else {
+            return std::make_pair(LineBreakWordStyle::None, false);
+        }
+    } else {
+        return std::make_pair(lbWordStyle, false);
+    }
+}
+
 // Processes and retrieve informations from characters in the paragraph.
 struct CharProcessor {
     // The number of spaces.
@@ -157,6 +220,8 @@ struct CharProcessor {
     // The current hyphenator.
     const Hyphenator* hyphenator = nullptr;
 
+    bool retryWithPhraseWordBreak = false;
+
     // Retrieve the current word range.
     inline Range wordRange() const { return breaker.wordRange(); }
 
@@ -175,15 +240,17 @@ struct CharProcessor {
 
     // The user of CharProcessor must call updateLocaleIfNecessary with valid locale at least one
     // time before feeding characters.
-    void updateLocaleIfNecessary(const Run& run) {
-        uint32_t newLocaleListId = run.getLocaleListId();
-        if (localeListId != newLocaleListId) {
-            Locale locale = getEffectiveLocale(newLocaleListId);
-            nextWordBreak = breaker.followingWithLocale(locale, run.lineBreakStyle(),
-                                                        run.lineBreakWordStyle(),
+    void updateLocaleIfNecessary(const Run& run, bool forceWordStyleAutoToPhrase) {
+        if (wbTracker.update(run)) {
+            const LocaleList& localeList = wbTracker.getCurrentLocaleList();
+            const Locale locale = localeList.empty() ? Locale() : localeList[0];
+
+            LineBreakWordStyle lbWordStyle = wbTracker.getCurrentLineBreakWordStyle();
+            std::tie(lbWordStyle, retryWithPhraseWordBreak) =
+                    resolveWordStyleAuto(lbWordStyle, localeList, forceWordStyleAutoToPhrase);
+            nextWordBreak = breaker.followingWithLocale(locale, run.lineBreakStyle(), lbWordStyle,
                                                         run.getRange().getStart());
             hyphenator = HyphenatorMap::lookup(locale);
-            localeListId = newLocaleListId;
         }
     }
 
@@ -212,9 +279,7 @@ struct CharProcessor {
     }
 
 private:
-    // The current locale list id.
-    uint32_t localeListId = LocaleListCache::kInvalidListId;
-
+    WordBreakerTransitionTracker wbTracker;
     WordBreaker breaker;
 };
 }  // namespace minikin
diff --git a/libs/minikin/Locale.cpp b/libs/minikin/Locale.cpp
index d246020..f7e7323 100644
--- a/libs/minikin/Locale.cpp
+++ b/libs/minikin/Locale.cpp
@@ -467,6 +467,12 @@ bool Locale::supportsScript(uint32_t script) const {
     return supportsScript(mSubScriptBits, scriptToSubScriptBits(packedScript));
 }
 
+bool Locale::supportsScript(char c1, char c2, char c3, char c4) const {
+    uint32_t packedScript = packScript(c1, c2, c3, c4);
+    if (packedScript == mScript) return true;
+    return supportsScript(mSubScriptBits, scriptToSubScriptBits(packedScript));
+}
+
 int Locale::calcScoreFor(const LocaleList& supported) const {
     bool languageScriptMatch = false;
     bool subtagMatch = false;
@@ -528,4 +534,29 @@ LocaleList::LocaleList(std::vector<Locale>&& locales) : mLocales(std::move(local
     }
 }
 
+bool LocaleList::atLeastOneScriptMatch(const LocaleList& list) const {
+    if ((mUnionOfSubScriptBits & list.mUnionOfSubScriptBits) != 0) {
+        return true;
+    }
+
+    for (const Locale& myLocale : mLocales) {
+        for (const Locale& otherLocale : list.mLocales) {
+            if (myLocale.isEqualScript(otherLocale)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool LocaleList::hasScript(char c1, char c2, char c3, char c4) const {
+    for (const Locale& locale : mLocales) {
+        if (locale.supportsScript(c1, c2, c3, c4)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 }  // namespace minikin
diff --git a/libs/minikin/Locale.h b/libs/minikin/Locale.h
index 285bb7b..a19daa9 100644
--- a/libs/minikin/Locale.h
+++ b/libs/minikin/Locale.h
@@ -123,6 +123,7 @@ public:
     // Returns true if this script supports the given script. For example, ja-Jpan supports Hira,
     // ja-Hira doesn't support Jpan.
     bool supportsScript(uint32_t script) const;
+    bool supportsScript(char c1, char c2, char c3, char c4) const;
 
     std::string getString() const;
 
@@ -217,6 +218,11 @@ public:
     // The effective means the first non empty emoji style in the list.
     EmojiStyle getEmojiStyle() const { return mEmojiStyle; }
 
+    bool atLeastOneScriptMatch(const LocaleList& list) const;
+
+    bool hasJapanese() const { return hasScript('J', 'p', 'a', 'n'); }
+    bool hasKorean() const { return hasScript('K', 'o', 'r', 'e'); }
+
 private:
     friend struct Locale;  // for calcScoreFor
 
@@ -231,6 +237,8 @@ private:
     uint8_t getUnionOfSubScriptBits() const { return mUnionOfSubScriptBits; }
     bool isAllTheSameLocale() const { return mIsAllTheSameLocale; }
 
+    bool hasScript(char c1, char c2, char c3, char c4) const;
+
     // Do not copy and assign.
     LocaleList(const LocaleList&) = delete;
     void operator=(const LocaleList&) = delete;
diff --git a/libs/minikin/MeasuredText.cpp b/libs/minikin/MeasuredText.cpp
index 33dab38..8a37dc7 100644
--- a/libs/minikin/MeasuredText.cpp
+++ b/libs/minikin/MeasuredText.cpp
@@ -17,32 +17,40 @@
 #define LOG_TAG "Minikin"
 #include "minikin/MeasuredText.h"
 
-#include "minikin/Layout.h"
-
 #include "BidiUtils.h"
 #include "LayoutSplitter.h"
 #include "LayoutUtils.h"
 #include "LineBreakerUtil.h"
+#include "minikin/Characters.h"
+#include "minikin/Layout.h"
 
 namespace minikin {
 
 // Helper class for composing character advances.
 class AdvancesCompositor {
 public:
-    AdvancesCompositor(std::vector<float>* outAdvances, LayoutPieces* outPieces)
-            : mOutAdvances(outAdvances), mOutPieces(outPieces) {}
+    AdvancesCompositor(std::vector<float>* outAdvances, std::vector<uint8_t>* flags,
+                       LayoutPieces* outPieces)
+            : mOutAdvances(outAdvances), mFlags(flags), mOutPieces(outPieces) {}
 
     void setNextRange(const Range& range, bool dir) {
         mRange = range;
         mDir = dir;
     }
 
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint) {
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint,
+                    const MinikinRect& bounds) {
         const std::vector<float>& advances = layoutPiece.advances();
         std::copy(advances.begin(), advances.end(), mOutAdvances->begin() + mRange.getStart());
 
+        if (bounds.mLeft < 0 || bounds.mRight > layoutPiece.advance()) {
+            for (uint32_t i : mRange) {
+                (*mFlags)[i] |= MeasuredText::MAY_OVERHANG_BIT;
+            }
+        }
+
         if (mOutPieces != nullptr) {
-            mOutPieces->insert(mRange, 0 /* no edit */, layoutPiece, mDir, paint);
+            mOutPieces->insert(mRange, 0 /* no edit */, layoutPiece, mDir, paint, bounds);
         }
     }
 
@@ -50,12 +58,14 @@ private:
     Range mRange;
     bool mDir;
     std::vector<float>* mOutAdvances;
+    std::vector<uint8_t>* mFlags;
     LayoutPieces* mOutPieces;
 };
 
 void StyleRun::getMetrics(const U16StringPiece& textBuf, std::vector<float>* advances,
-                          LayoutPieces* precomputed, LayoutPieces* outPieces) const {
-    AdvancesCompositor compositor(advances, outPieces);
+                          std::vector<uint8_t>* flags, LayoutPieces* precomputed,
+                          bool boundsCalculation, LayoutPieces* outPieces) const {
+    AdvancesCompositor compositor(advances, flags, outPieces);
     const Bidi bidiFlag = mIsRtl ? Bidi::FORCE_RTL : Bidi::FORCE_LTR;
     const uint32_t paintId =
             (precomputed == nullptr) ? LayoutPieces::kNoPaintId : precomputed->findPaintId(mPaint);
@@ -65,11 +75,12 @@ void StyleRun::getMetrics(const U16StringPiece& textBuf, std::vector<float>* adv
             if (paintId == LayoutPieces::kNoPaintId) {
                 LayoutCache::getInstance().getOrCreate(
                         textBuf.substr(context), piece - context.getStart(), mPaint, info.isRtl,
-                        StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, compositor);
+                        StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, boundsCalculation,
+                        compositor);
             } else {
                 precomputed->getOrCreate(textBuf, piece, context, mPaint, info.isRtl,
                                          StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, paintId,
-                                         compositor);
+                                         boundsCalculation, compositor);
             }
         }
     }
@@ -80,7 +91,7 @@ class TotalAdvancesCompositor {
 public:
     TotalAdvancesCompositor() : mOut(0) {}
 
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint&) {
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint&, const MinikinRect&) {
         for (float w : layoutPiece.advances()) {
             mOut += w;
         }
@@ -100,7 +111,7 @@ float StyleRun::measureText(const U16StringPiece& textBuf) const {
         for (const auto [context, piece] : LayoutSplitter(textBuf, info.range, info.isRtl)) {
             layoutCache.getOrCreate(textBuf.substr(context), piece - context.getStart(), mPaint,
                                     info.isRtl, StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT,
-                                    compositor);
+                                    false /* bounds calculation */, compositor);
         }
     }
     return compositor.getTotalAdvance();
@@ -117,10 +128,11 @@ public:
         mDir = dir;
     }
 
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint) {
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint,
+                    const MinikinRect& bounds) {
         mTotalAdvance += layoutPiece.advance();
         if (mOutPieces != nullptr) {
-            mOutPieces->insert(mRange, mEdit, layoutPiece, mDir, paint);
+            mOutPieces->insert(mRange, mEdit, layoutPiece, mDir, paint, bounds);
         }
     }
 
@@ -147,16 +159,17 @@ float StyleRun::measureHyphenPiece(const U16StringPiece& textBuf, const Range& r
                     piece.getEnd() == range.getEnd() ? endHyphen : EndHyphenEdit::NO_EDIT;
 
             compositor.setNextContext(piece, packHyphenEdit(startEdit, endEdit), info.isRtl);
-            LayoutCache::getInstance().getOrCreate(textBuf.substr(context),
-                                                   piece - context.getStart(), mPaint, info.isRtl,
-                                                   startEdit, endEdit, compositor);
+            LayoutCache::getInstance().getOrCreate(
+                    textBuf.substr(context), piece - context.getStart(), mPaint, info.isRtl,
+                    startEdit, endEdit, false /* bounds calculation */, compositor);
         }
     }
     return compositor.advance();
 }
 
 void MeasuredText::measure(const U16StringPiece& textBuf, bool computeHyphenation,
-                           bool computeLayout, bool ignoreHyphenKerning, MeasuredText* hint) {
+                           bool computeLayout, bool computeBounds, bool ignoreHyphenKerning,
+                           MeasuredText* hint) {
     if (textBuf.size() == 0) {
         return;
     }
@@ -165,13 +178,14 @@ void MeasuredText::measure(const U16StringPiece& textBuf, bool computeHyphenatio
     CharProcessor proc(textBuf);
     for (const auto& run : runs) {
         const Range& range = run->getRange();
-        run->getMetrics(textBuf, &widths, hint ? &hint->layoutPieces : nullptr, piecesOut);
+        run->getMetrics(textBuf, &widths, &flags, hint ? &hint->layoutPieces : nullptr,
+                        computeBounds, piecesOut);
 
         if (!computeHyphenation || !run->canBreak()) {
             continue;
         }
 
-        proc.updateLocaleIfNecessary(*run);
+        proc.updateLocaleIfNecessary(*run, false /* forceWordStyleAutoToPhrase */);
         for (uint32_t i = range.getStart(); i < range.getEnd(); ++i) {
             // Even if the run is not a candidate of line break, treat the end of run as the line
             // break candidate.
@@ -198,7 +212,8 @@ public:
 
     void setOutOffset(uint32_t outOffset) { mOutOffset = outOffset; }
 
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */) {
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */,
+                    const MinikinRect&) {
         mOutLayout->appendLayout(layoutPiece, mOutOffset, mExtraAdvance);
     }
 
@@ -212,6 +227,7 @@ void StyleRun::appendLayout(const U16StringPiece& textBuf, const Range& range,
                             const MinikinPaint& paint, uint32_t outOrigin,
                             StartHyphenEdit startHyphen, EndHyphenEdit endHyphen,
                             Layout* outLayout) const {
+    bool boundsCalculation = false;
     float wordSpacing = range.getLength() == 1 && isWordSpace(textBuf[range.getStart()])
                                 ? mPaint.wordSpacing
                                 : 0;
@@ -230,11 +246,11 @@ void StyleRun::appendLayout(const U16StringPiece& textBuf, const Range& range,
 
             if (canUsePrecomputedResult) {
                 pieces.getOrCreate(textBuf, piece, context, mPaint, info.isRtl, startEdit, endEdit,
-                                   paintId, compositor);
+                                   paintId, boundsCalculation, compositor);
             } else {
-                LayoutCache::getInstance().getOrCreate(textBuf.substr(context),
-                                                       piece - context.getStart(), paint,
-                                                       info.isRtl, startEdit, endEdit, compositor);
+                LayoutCache::getInstance().getOrCreate(
+                        textBuf.substr(context), piece - context.getStart(), paint, info.isRtl,
+                        startEdit, endEdit, boundsCalculation, compositor);
             }
         }
     }
@@ -245,20 +261,9 @@ class BoundsCompositor {
 public:
     BoundsCompositor() : mAdvance(0) {}
 
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint) {
-        MinikinRect pieceBounds;
-        MinikinRect tmpRect;
-        for (uint32_t i = 0; i < layoutPiece.glyphCount(); ++i) {
-            const FakedFont& font = layoutPiece.fontAt(i);
-            const Point& point = layoutPiece.pointAt(i);
-
-            MinikinFont* minikinFont = font.font->typeface().get();
-            minikinFont->GetBounds(&tmpRect, layoutPiece.glyphIdAt(i), paint, font.fakery);
-            tmpRect.offset(point.x, point.y);
-            pieceBounds.join(tmpRect);
-        }
-        pieceBounds.offset(mAdvance, 0);
-        mBounds.join(pieceBounds);
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */,
+                    const MinikinRect& bounds) {
+        mBounds.join(bounds, mAdvance, 0);
         mAdvance += layoutPiece.advance();
     }
 
@@ -279,7 +284,7 @@ std::pair<float, MinikinRect> StyleRun::getBounds(const U16StringPiece& textBuf,
         for (const auto[context, piece] : LayoutSplitter(textBuf, info.range, info.isRtl)) {
             pieces.getOrCreate(textBuf, piece, context, mPaint, info.isRtl,
                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, paintId,
-                               compositor);
+                               true /* bounds calculation */, compositor);
         }
     }
     return std::make_pair(compositor.advance(), compositor.bounds());
@@ -290,7 +295,8 @@ class ExtentCompositor {
 public:
     ExtentCompositor() {}
 
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */) {
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */,
+                    const MinikinRect&) {
         mExtent.extendBy(layoutPiece.extent());
     }
 
@@ -309,12 +315,42 @@ MinikinExtent StyleRun::getExtent(const U16StringPiece& textBuf, const Range& ra
         for (const auto[context, piece] : LayoutSplitter(textBuf, info.range, info.isRtl)) {
             pieces.getOrCreate(textBuf, piece, context, mPaint, info.isRtl,
                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, paintId,
-                               compositor);
+                               false /* bounds calculation */, compositor);
         }
     }
     return compositor.extent();
 }
 
+class LineMetricsCompositor {
+public:
+    LineMetricsCompositor() {}
+
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */,
+                    const MinikinRect& bounds) {
+        mMetrics.append(layoutPiece.extent(), bounds, layoutPiece.advance());
+    }
+
+    const LineMetrics& metrics() const { return mMetrics; }
+
+private:
+    LineMetrics mMetrics;
+};
+
+LineMetrics StyleRun::getLineMetrics(const U16StringPiece& textBuf, const Range& range,
+                                     const LayoutPieces& pieces) const {
+    LineMetricsCompositor compositor;
+    Bidi bidiFlag = mIsRtl ? Bidi::FORCE_RTL : Bidi::FORCE_LTR;
+    const uint32_t paintId = pieces.findPaintId(mPaint);
+    for (const BidiText::RunInfo info : BidiText(textBuf, range, bidiFlag)) {
+        for (const auto [context, piece] : LayoutSplitter(textBuf, info.range, info.isRtl)) {
+            pieces.getOrCreate(textBuf, piece, context, mPaint, info.isRtl,
+                               StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, paintId,
+                               true /* bounds calculation */, compositor);
+        }
+    }
+    return compositor.metrics();
+}
+
 Layout MeasuredText::buildLayout(const U16StringPiece& textBuf, const Range& range,
                                  const Range& contextRange, const MinikinPaint& paint,
                                  StartHyphenEdit startHyphen, EndHyphenEdit endHyphen) {
@@ -346,8 +382,7 @@ MinikinRect MeasuredText::getBounds(const U16StringPiece& textBuf, const Range&
         }
         auto[advance, bounds] =
                 run->getBounds(textBuf, Range::intersection(runRange, range), layoutPieces);
-        bounds.offset(totalAdvance, 0);
-        rect.join(bounds);
+        rect.join(bounds, totalAdvance, 0);
         totalAdvance += advance;
     }
     return rect;
@@ -360,11 +395,23 @@ MinikinExtent MeasuredText::getExtent(const U16StringPiece& textBuf, const Range
         if (!Range::intersects(range, runRange)) {
             continue;
         }
-        MinikinExtent runExtent =
-                run->getExtent(textBuf, Range::intersection(runRange, range), layoutPieces);
-        extent.extendBy(runExtent);
+        extent.extendBy(
+                run->getExtent(textBuf, Range::intersection(runRange, range), layoutPieces));
     }
     return extent;
 }
 
+LineMetrics MeasuredText::getLineMetrics(const U16StringPiece& textBuf, const Range& range) const {
+    LineMetrics metrics;
+    for (const auto& run : runs) {
+        const Range& runRange = run->getRange();
+        if (!Range::intersects(range, runRange)) {
+            continue;
+        }
+        metrics.append(
+                run->getLineMetrics(textBuf, Range::intersection(runRange, range), layoutPieces));
+    }
+    return metrics;
+}
+
 }  // namespace minikin
diff --git a/libs/minikin/Measurement.cpp b/libs/minikin/Measurement.cpp
index 968ab6f..7797faa 100644
--- a/libs/minikin/Measurement.cpp
+++ b/libs/minikin/Measurement.cpp
@@ -21,8 +21,8 @@
 
 #include "BidiUtils.h"
 #include "LayoutSplitter.h"
-#include "minikin/BoundsCache.h"
 #include "minikin/GraphemeBreak.h"
+#include "minikin/LayoutCache.h"
 
 namespace {
 bool isAsciiOrBidiControlCharacter(uint16_t c) {
@@ -194,11 +194,10 @@ size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t st
 struct BoundsComposer {
     BoundsComposer() : mAdvance(0) {}
 
-    void operator()(const MinikinRect& rect, float advance) {
-        MinikinRect tmp = rect;
-        tmp.offset(mAdvance, 0);
-        mBounds.join(tmp);
-        mAdvance += advance;
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */,
+                    const MinikinRect& bounds) {
+        mBounds.join(bounds, mAdvance, 0);
+        mAdvance += layoutPiece.advance();
     }
 
     float mAdvance;
@@ -215,9 +214,9 @@ void getBounds(const U16StringPiece& str, const Range& range, Bidi bidiFlag,
                     (piece.getStart() == range.getStart()) ? startHyphen : StartHyphenEdit::NO_EDIT;
             const EndHyphenEdit pieceEndHyphen =
                     (piece.getEnd() == range.getEnd()) ? endHyphen : EndHyphenEdit::NO_EDIT;
-            BoundsCache::getInstance().getOrCreate(str.substr(context), piece - context.getStart(),
-                                                   paint, info.isRtl, pieceStartHyphen,
-                                                   pieceEndHyphen, bc);
+            LayoutCache::getInstance().getOrCreate(
+                    str.substr(context), piece - context.getStart(), paint, info.isRtl,
+                    pieceStartHyphen, pieceEndHyphen, true /* bounds calculation */, bc);
             // Increment word spacing for spacer
             if (piece.getLength() == 1 && isWordSpace(str[piece.getStart()])) {
                 bc.mAdvance += paint.wordSpacing;
@@ -230,7 +229,7 @@ void getBounds(const U16StringPiece& str, const Range& range, Bidi bidiFlag,
 struct ExtentComposer {
     ExtentComposer() {}
 
-    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint&) {
+    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint&, const MinikinRect&) {
         extent.extendBy(layoutPiece.extent());
     }
 
@@ -242,9 +241,10 @@ MinikinExtent getFontExtent(const U16StringPiece& textBuf, const Range& range, B
     ExtentComposer composer;
     for (const BidiText::RunInfo info : BidiText(textBuf, range, bidiFlag)) {
         for (const auto [context, piece] : LayoutSplitter(textBuf, info.range, info.isRtl)) {
-            LayoutCache::getInstance().getOrCreate(
-                    textBuf.substr(context), piece - context.getStart(), paint, info.isRtl,
-                    StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, composer);
+            LayoutCache::getInstance().getOrCreate(textBuf.substr(context),
+                                                   piece - context.getStart(), paint, info.isRtl,
+                                                   StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT,
+                                                   false /* bounds calculation */, composer);
         }
     }
     return composer.extent;
diff --git a/libs/minikin/MinikinInternal.cpp b/libs/minikin/MinikinInternal.cpp
index d02f71f..5b81406 100644
--- a/libs/minikin/MinikinInternal.cpp
+++ b/libs/minikin/MinikinInternal.cpp
@@ -17,9 +17,12 @@
 
 #define LOG_TAG "Minikin"
 
+#include "MinikinInternal.h"
+
 #include <log/log.h>
 
-#include "MinikinInternal.h"
+#include "FeatureFlags.h"
+#include "minikin/MinikinPaint.h"
 
 namespace minikin {
 
@@ -45,4 +48,12 @@ bool isVariationSelector(uint32_t codePoint) {
     return isBMPVariationSelector(codePoint) || isVariationSelectorSupplement(codePoint);
 }
 
+bool MinikinPaint::skipCache() const {
+    if (features::inter_character_justification()) {
+        return false;  // if the flag is on, do not skip the cache.
+    } else {
+        return !fontFeatureSettings.empty();
+    }
+}
+
 }  // namespace minikin
diff --git a/libs/minikin/OptimalLineBreaker.cpp b/libs/minikin/OptimalLineBreaker.cpp
index b05a94d..1d11532 100644
--- a/libs/minikin/OptimalLineBreaker.cpp
+++ b/libs/minikin/OptimalLineBreaker.cpp
@@ -19,11 +19,7 @@
 #include <algorithm>
 #include <limits>
 
-#include "minikin/Characters.h"
-#include "minikin/Layout.h"
-#include "minikin/Range.h"
-#include "minikin/U16StringPiece.h"
-
+#include "FeatureFlags.h"
 #include "HyphenatorMap.h"
 #include "LayoutUtils.h"
 #include "LineBreakerUtil.h"
@@ -31,6 +27,10 @@
 #include "LocaleListCache.h"
 #include "MinikinInternal.h"
 #include "WordBreaker.h"
+#include "minikin/Characters.h"
+#include "minikin/Layout.h"
+#include "minikin/Range.h"
+#include "minikin/U16StringPiece.h"
 
 namespace minikin {
 
@@ -41,6 +41,7 @@ namespace {
 constexpr float SCORE_INFTY = std::numeric_limits<float>::max();
 constexpr float SCORE_OVERFULL = 1e12f;
 constexpr float SCORE_DESPERATE = 1e10f;
+constexpr float SCORE_FALLBACK = 1e6f;
 
 // Multiplier for hyphen penalty on last line.
 constexpr float LAST_LINE_PENALTY_MULTIPLIER = 4.0f;
@@ -96,12 +97,13 @@ struct OptimizeContext {
     // fonts), it's only guaranteed to pick one.
     float spaceWidth = 0.0f;
 
+    bool retryWithPhraseWordBreak = false;
+
     // Append desperate break point to the candidates.
-    inline void pushDesperate(uint32_t offset, ParaWidth sumOfCharWidths, uint32_t spaceCount,
-                              bool isRtl) {
-        candidates.emplace_back(offset, sumOfCharWidths, sumOfCharWidths, SCORE_DESPERATE,
-                                spaceCount, spaceCount,
-                                HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, isRtl);
+    inline void pushDesperate(uint32_t offset, ParaWidth sumOfCharWidths, float score,
+                              uint32_t spaceCount, bool isRtl) {
+        candidates.emplace_back(offset, sumOfCharWidths, sumOfCharWidths, score, spaceCount,
+                                spaceCount, HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, isRtl);
     }
 
     // Append hyphenation break point to the candidates.
@@ -156,23 +158,56 @@ struct DesperateBreak {
     // The sum of the character width from the beginning of the word.
     ParaWidth sumOfChars;
 
-    DesperateBreak(uint32_t offset, ParaWidth sumOfChars)
-            : offset(offset), sumOfChars(sumOfChars){};
+    float score;
+
+    DesperateBreak(uint32_t offset, ParaWidth sumOfChars, float score)
+            : offset(offset), sumOfChars(sumOfChars), score(score){};
 };
 
 // Retrieves desperate break points from a word.
-std::vector<DesperateBreak> populateDesperatePoints(const MeasuredText& measured,
-                                                    const Range& range) {
+std::vector<DesperateBreak> populateDesperatePoints(const U16StringPiece& textBuf,
+                                                    const MeasuredText& measured,
+                                                    const Range& range, const Run& run) {
     std::vector<DesperateBreak> out;
-    ParaWidth width = measured.widths[range.getStart()];
-    for (uint32_t i = range.getStart() + 1; i < range.getEnd(); ++i) {
-        const float w = measured.widths[i];
-        if (w == 0) {
-            continue;  // w == 0 means here is not a grapheme bounds. Don't break here.
+
+    if (!features::phrase_strict_fallback() ||
+        run.lineBreakWordStyle() == LineBreakWordStyle::None) {
+        ParaWidth width = measured.widths[range.getStart()];
+        for (uint32_t i = range.getStart() + 1; i < range.getEnd(); ++i) {
+            const float w = measured.widths[i];
+            if (w == 0) {
+                continue;  // w == 0 means here is not a grapheme bounds. Don't break here.
+            }
+            out.emplace_back(i, width, SCORE_DESPERATE);
+            width += w;
+        }
+    } else {
+        WordBreaker wb;
+        wb.setText(textBuf.data(), textBuf.length());
+        ssize_t next = wb.followingWithLocale(getEffectiveLocale(run.getLocaleListId()),
+                                              run.lineBreakStyle(), LineBreakWordStyle::None,
+                                              range.getStart());
+
+        const bool calculateFallback = range.contains(next);
+        ParaWidth width = measured.widths[range.getStart()];
+        for (uint32_t i = range.getStart() + 1; i < range.getEnd(); ++i) {
+            const float w = measured.widths[i];
+            if (w == 0) {
+                continue;  // w == 0 means here is not a grapheme bounds. Don't break here.
+            }
+            if (calculateFallback && i == (uint32_t)next) {
+                out.emplace_back(i, width, SCORE_FALLBACK);
+                next = wb.next();
+                if (!range.contains(next)) {
+                    break;
+                }
+            } else {
+                out.emplace_back(i, width, SCORE_DESPERATE);
+            }
+            width += w;
         }
-        out.emplace_back(i, width);
-        width += w;
     }
+
     return out;
 }
 
@@ -192,7 +227,7 @@ void appendWithMerging(std::vector<HyphenBreak>::const_iterator hyIter,
         // breaks first.
         if (d != desperates.end() && (hyIter == endHyIter || d->offset <= hyIter->offset)) {
             out->pushDesperate(d->offset, proc.sumOfCharWidthsAtPrevWordBreak + d->sumOfChars,
-                               proc.effectiveSpaceCount, isRtl);
+                               d->score, proc.effectiveSpaceCount, isRtl);
             d++;
         } else {
             out->pushHyphenation(hyIter->offset, proc.sumOfCharWidths - hyIter->second,
@@ -206,7 +241,7 @@ void appendWithMerging(std::vector<HyphenBreak>::const_iterator hyIter,
 // Enumerate all line break candidates.
 OptimizeContext populateCandidates(const U16StringPiece& textBuf, const MeasuredText& measured,
                                    const LineWidth& lineWidth, HyphenationFrequency frequency,
-                                   bool isJustified) {
+                                   bool isJustified, bool forceWordStyleAutoToPhrase) {
     const ParaWidth minLineWidth = lineWidth.getMin();
     CharProcessor proc(textBuf);
 
@@ -227,7 +262,7 @@ OptimizeContext populateCandidates(const U16StringPiece& textBuf, const Measured
             result.linePenalty = std::max(penalties.second, result.linePenalty);
         }
 
-        proc.updateLocaleIfNecessary(*run);
+        proc.updateLocaleIfNecessary(*run, forceWordStyleAutoToPhrase);
 
         for (uint32_t i = range.getStart(); i < range.getEnd(); ++i) {
             MINIKIN_ASSERT(textBuf[i] != CHAR_TAB, "TAB is not supported in optimal line breaker");
@@ -252,9 +287,10 @@ OptimizeContext populateCandidates(const U16StringPiece& textBuf, const Measured
                 hyIter++;
             }
             if (proc.widthFromLastWordBreak() > minLineWidth) {
-                desperateBreaks = populateDesperatePoints(measured, contextRange);
+                desperateBreaks = populateDesperatePoints(textBuf, measured, contextRange, *run);
             }
-            appendWithMerging(beginHyIter, doHyphenation ? hyIter : beginHyIter, desperateBreaks,
+            const bool doHyphenationRun = doHyphenation && run->canHyphenate();
+            appendWithMerging(beginHyIter, doHyphenationRun ? hyIter : beginHyIter, desperateBreaks,
                               proc, hyphenPenalty, isRtl, &result);
 
             // We skip breaks for zero-width characters inside replacement spans.
@@ -267,6 +303,7 @@ OptimizeContext populateCandidates(const U16StringPiece& textBuf, const Measured
         }
     }
     result.spaceWidth = proc.spaceWidth;
+    result.retryWithPhraseWordBreak = proc.retryWithPhraseWordBreak;
     return result;
 }
 
@@ -276,7 +313,7 @@ public:
 
     LineBreakResult computeBreaks(const OptimizeContext& context, const U16StringPiece& textBuf,
                                   const MeasuredText& measuredText, const LineWidth& lineWidth,
-                                  BreakStrategy strategy, bool justified);
+                                  BreakStrategy strategy, bool justified, bool useBoundsForWidth);
 
 private:
     // Data used to compute optimal line breaks
@@ -287,14 +324,15 @@ private:
     };
     LineBreakResult finishBreaksOptimal(const U16StringPiece& textBuf, const MeasuredText& measured,
                                         const std::vector<OptimalBreaksData>& breaksData,
-                                        const std::vector<Candidate>& candidates);
+                                        const std::vector<Candidate>& candidates,
+                                        bool useBoundsForWidth);
 };
 
 // Follow "prev" links in candidates array, and copy to result arrays.
 LineBreakResult LineBreakOptimizer::finishBreaksOptimal(
         const U16StringPiece& textBuf, const MeasuredText& measured,
-        const std::vector<OptimalBreaksData>& breaksData,
-        const std::vector<Candidate>& candidates) {
+        const std::vector<OptimalBreaksData>& breaksData, const std::vector<Candidate>& candidates,
+        bool useBoundsForWidth) {
     LineBreakResult result;
     const uint32_t nCand = candidates.size();
     uint32_t prevIndex;
@@ -305,9 +343,28 @@ LineBreakResult LineBreakOptimizer::finishBreaksOptimal(
 
         result.breakPoints.push_back(cand.offset);
         result.widths.push_back(cand.postBreak - prev.preBreak);
-        MinikinExtent extent = measured.getExtent(textBuf, Range(prev.offset, cand.offset));
-        result.ascents.push_back(extent.ascent);
-        result.descents.push_back(extent.descent);
+        if (useBoundsForWidth) {
+            Range range = Range(prev.offset, cand.offset);
+            Range actualRange = trimTrailingLineEndSpaces(textBuf, range);
+            if (actualRange.isEmpty()) {
+                MinikinExtent extent = measured.getExtent(textBuf, range);
+                result.ascents.push_back(extent.ascent);
+                result.descents.push_back(extent.descent);
+                result.bounds.emplace_back(0, extent.ascent, cand.postBreak - prev.preBreak,
+                                           extent.descent);
+            } else {
+                LineMetrics metrics = measured.getLineMetrics(textBuf, actualRange);
+                result.ascents.push_back(metrics.extent.ascent);
+                result.descents.push_back(metrics.extent.descent);
+                result.bounds.emplace_back(metrics.bounds);
+            }
+        } else {
+            MinikinExtent extent = measured.getExtent(textBuf, Range(prev.offset, cand.offset));
+            result.ascents.push_back(extent.ascent);
+            result.descents.push_back(extent.descent);
+            result.bounds.emplace_back(0, extent.ascent, cand.postBreak - prev.preBreak,
+                                       extent.descent);
+        }
 
         const HyphenEdit edit =
                 packHyphenEdit(editForNextLine(prev.hyphenType), editForThisLine(cand.hyphenType));
@@ -321,7 +378,8 @@ LineBreakResult LineBreakOptimizer::computeBreaks(const OptimizeContext& context
                                                   const U16StringPiece& textBuf,
                                                   const MeasuredText& measured,
                                                   const LineWidth& lineWidth,
-                                                  BreakStrategy strategy, bool justified) {
+                                                  BreakStrategy strategy, bool justified,
+                                                  bool useBoundsForWidth) {
     const std::vector<Candidate>& candidates = context.candidates;
     uint32_t active = 0;
     const uint32_t nCand = candidates.size();
@@ -357,7 +415,25 @@ LineBreakResult LineBreakOptimizer::computeBreaks(const OptimizeContext& context
             }
             const float jScore = breaksData[j].score;
             if (jScore + bestHope >= best) continue;
-            const float delta = candidates[j].preBreak - leftEdge;
+            float delta = candidates[j].preBreak - leftEdge;
+
+            if (useBoundsForWidth) {
+                // FIXME: Support bounds based line break for hyphenated break point.
+                if (candidates[i].hyphenType == HyphenationType::DONT_BREAK &&
+                    candidates[j].hyphenType == HyphenationType::DONT_BREAK) {
+                    if (delta >= 0) {
+                        Range range = Range(candidates[j].offset, candidates[i].offset);
+                        Range actualRange = trimTrailingLineEndSpaces(textBuf, range);
+                        if (!actualRange.isEmpty() && measured.hasOverhang(range)) {
+                            float boundsDelta =
+                                    width - measured.getBounds(textBuf, actualRange).width();
+                            if (boundsDelta < 0) {
+                                delta = boundsDelta;
+                            }
+                        }
+                    }
+                }
+            }
 
             // compute width score for line
 
@@ -399,21 +475,52 @@ LineBreakResult LineBreakOptimizer::computeBreaks(const OptimizeContext& context
                               bestPrev,                                            // prev
                               breaksData[bestPrev].lineNumber + 1});               // lineNumber
     }
-    return finishBreaksOptimal(textBuf, measured, breaksData, candidates);
+    return finishBreaksOptimal(textBuf, measured, breaksData, candidates, useBoundsForWidth);
 }
 
 }  // namespace
 
 LineBreakResult breakLineOptimal(const U16StringPiece& textBuf, const MeasuredText& measured,
                                  const LineWidth& lineWidth, BreakStrategy strategy,
-                                 HyphenationFrequency frequency, bool justified) {
+                                 HyphenationFrequency frequency, bool justified,
+                                 bool useBoundsForWidth) {
     if (textBuf.size() == 0) {
         return LineBreakResult();
     }
+
     const OptimizeContext context =
-            populateCandidates(textBuf, measured, lineWidth, frequency, justified);
+            populateCandidates(textBuf, measured, lineWidth, frequency, justified,
+                               false /* forceWordStyleAutoToPhrase */);
     LineBreakOptimizer optimizer;
-    return optimizer.computeBreaks(context, textBuf, measured, lineWidth, strategy, justified);
+    LineBreakResult res = optimizer.computeBreaks(context, textBuf, measured, lineWidth, strategy,
+                                                  justified, useBoundsForWidth);
+
+    if (!features::word_style_auto()) {
+        return res;
+    }
+
+    // The line breaker says that retry with phrase based word break because of the auto option and
+    // given locales.
+    if (!context.retryWithPhraseWordBreak) {
+        return res;
+    }
+
+    // If the line break result is more than heuristics threshold, don't try pharse based word
+    // break.
+    if (res.breakPoints.size() >= LBW_AUTO_HEURISTICS_LINE_COUNT) {
+        return res;
+    }
+
+    const OptimizeContext phContext =
+            populateCandidates(textBuf, measured, lineWidth, frequency, justified,
+                               true /* forceWordStyleAutoToPhrase */);
+    LineBreakResult res2 = optimizer.computeBreaks(phContext, textBuf, measured, lineWidth,
+                                                   strategy, justified, useBoundsForWidth);
+    if (res2.breakPoints.size() < LBW_AUTO_HEURISTICS_LINE_COUNT) {
+        return res2;
+    } else {
+        return res;
+    }
 }
 
 }  // namespace minikin
diff --git a/libs/minikin/OptimalLineBreaker.h b/libs/minikin/OptimalLineBreaker.h
index f13e2a8..da7798d 100644
--- a/libs/minikin/OptimalLineBreaker.h
+++ b/libs/minikin/OptimalLineBreaker.h
@@ -25,7 +25,8 @@ namespace minikin {
 
 LineBreakResult breakLineOptimal(const U16StringPiece& textBuf, const MeasuredText& measured,
                                  const LineWidth& lineWidthLimits, BreakStrategy strategy,
-                                 HyphenationFrequency frequency, bool justified);
+                                 HyphenationFrequency frequency, bool justified,
+                                 bool useBoundsForWidth);
 
 }  // namespace minikin
 
diff --git a/libs/minikin/ScriptUtils.cpp b/libs/minikin/ScriptUtils.cpp
new file mode 100644
index 0000000..90bd5de
--- /dev/null
+++ b/libs/minikin/ScriptUtils.cpp
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "Minikin"
+
+#include "ScriptUtils.h"
+
+#include <unicode/ubidi.h>
+#include <unicode/uscript.h>
+#include <unicode/utf16.h>
+#include <unicode/utypes.h>
+
+#include <algorithm>
+
+#include "MinikinInternal.h"
+#include "minikin/Emoji.h"
+
+namespace minikin {
+
+static hb_codepoint_t decodeUtf16(U16StringPiece text, Range range, uint32_t pos) {
+    uint32_t result;
+    U16_NEXT(text.data(), pos, range.getEnd(), result);
+    if (U_IS_SURROGATE(result)) {  // isolated surrogate
+        result = CHAR_REPLACEMENT_CHARACTER;
+    }
+    return static_cast<hb_codepoint_t>(result);
+}
+
+static UScriptCode getICUScript(uint32_t cp) {
+    UErrorCode status = U_ZERO_ERROR;
+    UScriptCode scriptCode = uscript_getScript(cp, &status);
+    if (U_FAILURE(status)) [[unlikely]] {
+        return USCRIPT_INVALID_CODE;
+    }
+    return scriptCode;
+}
+
+static hb_script_t getHbScript(uint32_t cp) {
+    hb_unicode_funcs_t* unicode_func = hb_unicode_funcs_get_default();
+    return hb_unicode_script(unicode_func, cp);
+}
+
+// static
+std::pair<uint32_t, hb_script_t> ScriptText::getScriptRun(U16StringPiece text, Range range,
+                                                          uint32_t pos) {
+    if (!range.contains(pos)) {
+        return std::make_pair(range.getEnd(), HB_SCRIPT_UNKNOWN);
+    }
+
+    uint32_t cp = decodeUtf16(text, range, pos);
+    UScriptCode current_script = getICUScript(cp);
+    hb_script_t current_hb_script = getHbScript(cp);
+    uint32_t i;
+    for (i = pos + U16_LENGTH(cp); i < range.getEnd(); i += U16_LENGTH(cp)) {
+        cp = decodeUtf16(text, range, i);
+        UScriptCode next_script = getICUScript(cp);
+        if (current_script != next_script) {
+            if (current_script == USCRIPT_INHERITED || current_script == USCRIPT_COMMON) {
+                current_script = next_script;
+                current_hb_script = getHbScript(cp);
+            } else if (next_script == USCRIPT_INHERITED || next_script == USCRIPT_COMMON) {
+                continue;
+            } else {
+                break;
+            }
+        }
+    }
+    if (current_script == USCRIPT_INHERITED) {
+        return std::make_pair(i, HB_SCRIPT_COMMON);
+    } else {
+        return std::make_pair(i, current_hb_script);
+    }
+}
+
+}  // namespace minikin
diff --git a/libs/minikin/ScriptUtils.h b/libs/minikin/ScriptUtils.h
new file mode 100644
index 0000000..7bf575f
--- /dev/null
+++ b/libs/minikin/ScriptUtils.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINIKIN_SCRIPT_UTILS_H
+#define MINIKIN_SCRIPT_UTILS_H
+
+#define LOG_TAG "Minikin"
+
+#include <unicode/ubidi.h>
+
+#include <memory>
+
+#include "minikin/Layout.h"
+#include "minikin/Macros.h"
+#include "minikin/U16StringPiece.h"
+
+namespace minikin {
+
+// A helper class for iterating the bidi run transitions.
+class ScriptText {
+public:
+    struct RunInfo {
+        Range range;
+        hb_script_t script;
+    };
+
+    ScriptText(const U16StringPiece& textBuf, uint32_t start, uint32_t end)
+            : mTextBuf(textBuf), mRange(start, end) {}
+
+    class iterator {
+    public:
+        inline bool operator==(const iterator& o) const {
+            return mStart == o.mStart && mParent == o.mParent;
+        }
+
+        inline bool operator!=(const iterator& o) const { return !(*this == o); }
+
+        inline std::pair<Range, hb_script_t> operator*() const {
+            return std::make_pair(Range(mStart, mEnd), mScript);
+        }
+
+        inline iterator& operator++() {
+            mStart = mEnd;
+            std::tie(mEnd, mScript) = getScriptRun(mParent->mTextBuf, mParent->mRange, mStart);
+            return *this;
+        }
+
+    private:
+        friend class ScriptText;
+
+        iterator(const ScriptText* parent, uint32_t start) : mParent(parent), mStart(start) {
+            std::tie(mEnd, mScript) = getScriptRun(mParent->mTextBuf, mParent->mRange, mStart);
+        }
+
+        const ScriptText* mParent;
+        uint32_t mStart;
+        uint32_t mEnd;
+        hb_script_t mScript;
+    };
+
+    inline iterator begin() const { return iterator(this, mRange.getStart()); }
+    inline iterator end() const { return iterator(this, mRange.getEnd()); }
+
+private:
+    U16StringPiece mTextBuf;
+    Range mRange;
+
+    static std::pair<uint32_t, hb_script_t> getScriptRun(U16StringPiece text, Range range,
+                                                         uint32_t pos);
+
+    MINIKIN_PREVENT_COPY_AND_ASSIGN(ScriptText);
+};
+
+}  // namespace minikin
+
+#endif  // MINIKIN_SCRIPT_UTILS_H
diff --git a/libs/minikin/StringPiece.h b/libs/minikin/StringPiece.h
index befb312..84c7d17 100644
--- a/libs/minikin/StringPiece.h
+++ b/libs/minikin/StringPiece.h
@@ -29,6 +29,7 @@ public:
     StringPiece(const char* data) : mData(data), mLength(data == nullptr ? 0 : strlen(data)) {}
     StringPiece(const char* data, size_t length) : mData(data), mLength(length) {}
     StringPiece(const std::string& str) : mData(str.data()), mLength(str.size()) {}
+    StringPiece(std::string_view str) : mData(str.data()), mLength(str.size()) {}
 
     inline const char* data() const { return mData; }
     inline size_t length() const { return mLength; }
diff --git a/libs/minikin/WordBreaker.cpp b/libs/minikin/WordBreaker.cpp
index ae79d3c..a1e9526 100644
--- a/libs/minikin/WordBreaker.cpp
+++ b/libs/minikin/WordBreaker.cpp
@@ -32,20 +32,54 @@
 namespace minikin {
 
 namespace {
-static UBreakIterator* createNewIterator(const Locale& locale, LineBreakStyle lbStyle,
-                                         LineBreakWordStyle lbWordStyle) {
+static std::unique_ptr<BreakIterator> createNewIterator(const Locale& locale,
+                                                        LineBreakStyle lbStyle,
+                                                        LineBreakWordStyle lbWordStyle) {
+    MINIKIN_ASSERT(lbStyle != LineBreakStyle::Auto,
+                   "LineBreakStyle::Auto must be resolved beforehand.");
+    MINIKIN_ASSERT(lbWordStyle != LineBreakWordStyle::Auto,
+                   "LineBreakWordStyle::Auto must be resolved beforehand.");
+
     // TODO: handle failure status
-    UErrorCode status = U_ZERO_ERROR;
-    char localeID[ULOC_FULLNAME_CAPACITY] = {};
-    uloc_forLanguageTag(locale.getStringWithLineBreakOption(lbStyle, lbWordStyle).c_str(), localeID,
-                        ULOC_FULLNAME_CAPACITY, nullptr, &status);
-    return ubrk_open(UBreakIteratorType::UBRK_LINE, localeID, nullptr, 0, &status);
+    if (lbStyle == LineBreakStyle::NoBreak) {
+        return std::make_unique<NoBreakBreakIterator>();
+    } else {
+        UErrorCode status = U_ZERO_ERROR;
+        char localeID[ULOC_FULLNAME_CAPACITY] = {};
+        uloc_forLanguageTag(locale.getStringWithLineBreakOption(lbStyle, lbWordStyle).c_str(),
+                            localeID, ULOC_FULLNAME_CAPACITY, nullptr, &status);
+        IcuUbrkUniquePtr icuBrkPtr(
+                ubrk_open(UBreakIteratorType::UBRK_LINE, localeID, nullptr, 0, &status));
+        return std::make_unique<ICUBreakIterator>(std::move(icuBrkPtr));
+    }
 }
 }  // namespace
 
+void ICUBreakIterator::setText(UText* text, size_t) {
+    UErrorCode status = U_ZERO_ERROR;
+    ubrk_setUText(mBreaker.get(), text, &status);
+}
+
+bool ICUBreakIterator::isBoundary(int32_t i) {
+    return ubrk_isBoundary(mBreaker.get(), i);
+}
+
+int32_t ICUBreakIterator::following(size_t i) {
+    return ubrk_following(mBreaker.get(), i);
+}
+
+int32_t ICUBreakIterator::next() {
+    return ubrk_next(mBreaker.get());
+}
+
 ICULineBreakerPool::Slot ICULineBreakerPoolImpl::acquire(const Locale& locale,
                                                          LineBreakStyle lbStyle,
                                                          LineBreakWordStyle lbWordStyle) {
+    if (lbStyle == LineBreakStyle::Auto) {
+        lbStyle = locale.supportsScript('J', 'p', 'a', 'n') ? LineBreakStyle::Strict
+                                                            : LineBreakStyle::None;
+    }
+
     const uint64_t id = locale.getIdentifier();
     std::lock_guard<std::mutex> lock(mMutex);
     for (auto i = mPool.begin(); i != mPool.end(); i++) {
@@ -57,8 +91,7 @@ ICULineBreakerPool::Slot ICULineBreakerPoolImpl::acquire(const Locale& locale,
     }
 
     // Not found in pool. Create new one.
-    return {id, lbStyle, lbWordStyle,
-            IcuUbrkUniquePtr(createNewIterator(locale, lbStyle, lbWordStyle))};
+    return {id, lbStyle, lbWordStyle, createNewIterator(locale, lbStyle, lbWordStyle)};
 }
 
 void ICULineBreakerPoolImpl::release(ICULineBreakerPool::Slot&& slot) {
@@ -86,10 +119,9 @@ ssize_t WordBreaker::followingWithLocale(const Locale& locale, LineBreakStyle lb
         return mCurrent;
     }
     mIcuBreaker = mPool->acquire(locale, lbStyle, lbWordStyle);
-    UErrorCode status = U_ZERO_ERROR;
     MINIKIN_ASSERT(mText != nullptr, "setText must be called first");
     // TODO: handle failure status
-    ubrk_setUText(mIcuBreaker.breaker.get(), mUText.get(), &status);
+    mIcuBreaker.breaker->setText(mUText.get(), mTextSize);
     if (mInEmailOrUrl) {
         // Note:
         // Don't reset mCurrent, mLast, or mScanOffset for keeping email/URL context.
@@ -171,9 +203,9 @@ static bool isValidBreak(const uint16_t* buf, size_t bufEnd, int32_t i) {
 // Customized iteratorNext that takes care of both resets and our modifications
 // to ICU's behavior.
 int32_t WordBreaker::iteratorNext() {
-    int32_t result = ubrk_following(mIcuBreaker.breaker.get(), mCurrent);
+    int32_t result = mIcuBreaker.breaker->following(mCurrent);
     while (!isValidBreak(mText, mTextSize, result)) {
-        result = ubrk_next(mIcuBreaker.breaker.get());
+        result = mIcuBreaker.breaker->next();
     }
     return result;
 }
@@ -221,11 +253,11 @@ void WordBreaker::detectEmailOrUrl() {
             }
         }
         if (state == SAW_AT || state == SAW_COLON_SLASH_SLASH) {
-            if (!ubrk_isBoundary(mIcuBreaker.breaker.get(), i)) {
+            if (!mIcuBreaker.breaker->isBoundary(i)) {
                 // If there are combining marks or such at the end of the URL or the email address,
                 // consider them a part of the URL or the email, and skip to the next actual
                 // boundary.
-                i = ubrk_following(mIcuBreaker.breaker.get(), i);
+                i = mIcuBreaker.breaker->following(i);
             }
             mInEmailOrUrl = true;
         } else {
diff --git a/libs/minikin/WordBreaker.h b/libs/minikin/WordBreaker.h
index c4af635..ccb3186 100644
--- a/libs/minikin/WordBreaker.h
+++ b/libs/minikin/WordBreaker.h
@@ -37,6 +37,16 @@
 
 namespace minikin {
 
+class BreakIterator {
+public:
+    BreakIterator() {}
+    virtual ~BreakIterator() {}
+    virtual void setText(UText* text, size_t size) = 0;
+    virtual bool isBoundary(int32_t i) = 0;
+    virtual int32_t following(size_t i) = 0;
+    virtual int32_t next() = 0;
+};
+
 // A class interface for providing pooling implementation of ICU's line breaker.
 // The implementation can be customized for testing purposes.
 class ICULineBreakerPool {
@@ -44,7 +54,7 @@ public:
     struct Slot {
         Slot() : localeId(0), breaker(nullptr) {}
         Slot(uint64_t localeId, LineBreakStyle lbStyle, LineBreakWordStyle lbWordStyle,
-             IcuUbrkUniquePtr&& breaker)
+             std::unique_ptr<BreakIterator>&& breaker)
                 : localeId(localeId),
                   lbStyle(lbStyle),
                   lbWordStyle(lbWordStyle),
@@ -60,7 +70,7 @@ public:
         uint64_t localeId;
         LineBreakStyle lbStyle;
         LineBreakWordStyle lbWordStyle;
-        IcuUbrkUniquePtr breaker;
+        std::unique_ptr<BreakIterator> breaker;
     };
     virtual ~ICULineBreakerPool() {}
     virtual Slot acquire(const Locale& locale, LineBreakStyle lbStyle,
@@ -95,6 +105,33 @@ private:
     mutable std::mutex mMutex;
 };
 
+class ICUBreakIterator : public BreakIterator {
+public:
+    ICUBreakIterator(IcuUbrkUniquePtr&& breaker) : mBreaker(std::move(breaker)) {}
+    virtual ~ICUBreakIterator() {}
+    virtual void setText(UText* text, size_t size);
+    virtual bool isBoundary(int32_t i);
+    virtual int32_t following(size_t i);
+    virtual int32_t next();
+
+private:
+    IcuUbrkUniquePtr mBreaker;
+};
+
+class NoBreakBreakIterator : public BreakIterator {
+public:
+    NoBreakBreakIterator() {}
+    virtual ~NoBreakBreakIterator() {}
+
+    virtual void setText(UText*, size_t size) { mSize = size; }
+    virtual bool isBoundary(int32_t i) { return i == 0 || i == static_cast<int32_t>(mSize); }
+    virtual int32_t following(size_t) { return mSize; }
+    virtual int32_t next() { return mSize; }
+
+private:
+    size_t mSize = 0;
+};
+
 class WordBreaker {
 public:
     virtual ~WordBreaker() { finish(); }
diff --git a/tests/Android.bp b/tests/Android.bp
index 3088ca4..4611594 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -16,15 +16,18 @@ filegroup {
         "data/CustomExtent.ttf",
         "data/Emoji.ttf",
         "data/EmojiBase.ttf",
+        "data/Hangul.ttf",
         "data/Hiragana.ttf",
         "data/Italic.ttf",
         "data/Ja.ttf",
+        "data/Japanese.ttf",
         "data/Ko.ttf",
         "data/Ligature.ttf",
         "data/LayoutTestFont.ttf",
         "data/MultiAxis.ttf",
         "data/NoCmapFormat14.ttf",
         "data/NoGlyphFont.ttf",
+        "data/OvershootTest.ttf",
         "data/OverrideEmoji.ttf",
         "data/Regular.ttf",
         "data/TextEmojiFont.ttf",
@@ -32,6 +35,7 @@ filegroup {
         "data/UnicodeBMPOnly2.ttf",
         "data/UnicodeUCS4.ttf",
         "data/VariationSelectorTest-Regular.ttf",
+        "data/WeightEqualsEmVariableFont.ttf",
         "data/ZhHans.ttf",
         "data/ZhHant.ttf",
         "data/emoji.xml",
diff --git a/tests/data/Hangul.ttf b/tests/data/Hangul.ttf
new file mode 100644
index 0000000..1dff832
--- /dev/null
+++ b/tests/data/Hangul.ttf
diff --git a/tests/data/Hangul.ttx b/tests/data/Hangul.ttx
new file mode 100644
index 0000000..ea17053
--- /dev/null
+++ b/tests/data/Hangul.ttx
@@ -0,0 +1,11819 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2023 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.0">
+
+  <GlyphOrder>
+    <GlyphID id="0" name=".notdef"/>
+    <GlyphID id="1" name="1em"/>
+  </GlyphOrder>
+
+  <head>
+    <tableVersion value="1.0"/>
+    <fontRevision value="1.0"/>
+    <checkSumAdjustment value="0x640cdb2f"/>
+    <magicNumber value="0x5f0f3cf5"/>
+    <flags value="00000000 00000011"/>
+    <unitsPerEm value="100"/>
+    <created value="Fri Mar 17 07:26:00 2017"/>
+    <macStyle value="00000000 00000000"/>
+    <lowestRecPPEM value="7"/>
+    <fontDirectionHint value="2"/>
+    <glyphDataFormat value="0"/>
+  </head>
+
+  <hhea>
+    <tableVersion value="0x00010000"/>
+    <ascent value="0"/>
+    <descent value="0"/>
+    <lineGap value="0"/>
+    <caretSlopeRise value="1"/>
+    <caretSlopeRun value="0"/>
+    <caretOffset value="0"/>
+    <reserved0 value="0"/>
+    <reserved1 value="0"/>
+    <reserved2 value="0"/>
+    <reserved3 value="0"/>
+    <metricDataFormat value="0"/>
+  </hhea>
+
+  <maxp>
+    <tableVersion value="0x10000"/>
+    <maxZones value="0"/>
+    <maxTwilightPoints value="0"/>
+    <maxStorage value="0"/>
+    <maxFunctionDefs value="0"/>
+    <maxInstructionDefs value="0"/>
+    <maxStackElements value="0"/>
+    <maxSizeOfInstructions value="0"/>
+    <maxComponentElements value="0"/>
+  </maxp>
+
+  <OS_2>
+    <!-- The fields 'usFirstCharIndex' and 'usLastCharIndex'
+         will be recalculated by the compiler -->
+    <version value="3"/>
+    <xAvgCharWidth value="594"/>
+    <usWeightClass value="400"/>
+    <usWidthClass value="5"/>
+    <fsType value="00000000 00001000"/>
+    <ySubscriptXSize value="650"/>
+    <ySubscriptYSize value="600"/>
+    <ySubscriptXOffset value="0"/>
+    <ySubscriptYOffset value="75"/>
+    <ySuperscriptXSize value="650"/>
+    <ySuperscriptYSize value="600"/>
+    <ySuperscriptXOffset value="0"/>
+    <ySuperscriptYOffset value="350"/>
+    <yStrikeoutSize value="50"/>
+    <yStrikeoutPosition value="300"/>
+    <sFamilyClass value="0"/>
+    <panose>
+      <bFamilyType value="0"/>
+      <bSerifStyle value="0"/>
+      <bWeight value="5"/>
+      <bProportion value="0"/>
+      <bContrast value="0"/>
+      <bStrokeVariation value="0"/>
+      <bArmStyle value="0"/>
+      <bLetterForm value="0"/>
+      <bMidline value="0"/>
+      <bXHeight value="0"/>
+    </panose>
+    <ulUnicodeRange1 value="00000000 00000000 00000000 00000001"/>
+    <ulUnicodeRange2 value="00000000 00000000 00000000 00000000"/>
+    <ulUnicodeRange3 value="00000000 00000000 00000000 00000000"/>
+    <ulUnicodeRange4 value="00000000 00000000 00000000 00000000"/>
+    <achVendID value="UKWN"/>
+    <fsSelection value="00000000 01000000"/>
+    <usFirstCharIndex value="32"/>
+    <usLastCharIndex value="122"/>
+    <sTypoAscender value="800"/>
+    <sTypoDescender value="-200"/>
+    <sTypoLineGap value="200"/>
+    <usWinAscent value="1000"/>
+    <usWinDescent value="200"/>
+    <ulCodePageRange1 value="00000000 00000000 00000000 00000001"/>
+    <ulCodePageRange2 value="00000000 00000000 00000000 00000000"/>
+    <sxHeight value="500"/>
+    <sCapHeight value="700"/>
+    <usDefaultChar value="0"/>
+    <usBreakChar value="32"/>
+    <usMaxContext value="0"/>
+  </OS_2>
+
+  <hmtx>
+    <mtx name=".notdef" width="50" lsb="0"/>
+    <mtx name="1em" width="100" lsb="0"/>
+  </hmtx>
+
+  <cmap>
+    <tableVersion version="0"/>
+    <cmap_format_12 format="12" reserved="0" length="6" nGroups="1" platformID="3" platEncID="10" language="0">
+      <map code="0x0020" name="1em" />
+      <map code="0x002E" name="1em" />
+
+      <!-- CJK Symbols -->
+      <map code="0x3000" name="1em" /> <!--  IDEOGRAPHIC SPACE -->
+      <map code="0x3001" name="1em" /> <!--  IDEOGRAPHIC COMMA -->
+      <map code="0x3002" name="1em" /> <!--  IDEOGRAPHIC FULL STOP -->
+
+      <!-- Hangul letters -->
+      <map code="0x1100" name="1em"/><!-- HANGUL CHOSEONG KIYEOK -->
+      <map code="0x1101" name="1em"/><!-- HANGUL CHOSEONG SSANGKIYEOK -->
+      <map code="0x1102" name="1em"/><!-- HANGUL CHOSEONG NIEUN -->
+      <map code="0x1103" name="1em"/><!-- HANGUL CHOSEONG TIKEUT -->
+      <map code="0x1104" name="1em"/><!-- HANGUL CHOSEONG SSANGTIKEUT -->
+      <map code="0x1105" name="1em"/><!-- HANGUL CHOSEONG RIEUL -->
+      <map code="0x1106" name="1em"/><!-- HANGUL CHOSEONG MIEUM -->
+      <map code="0x1107" name="1em"/><!-- HANGUL CHOSEONG PIEUP -->
+      <map code="0x1108" name="1em"/><!-- HANGUL CHOSEONG SSANGPIEUP -->
+      <map code="0x1109" name="1em"/><!-- HANGUL CHOSEONG SIOS -->
+      <map code="0x110a" name="1em"/><!-- HANGUL CHOSEONG SSANGSIOS -->
+      <map code="0x110b" name="1em"/><!-- HANGUL CHOSEONG IEUNG -->
+      <map code="0x110c" name="1em"/><!-- HANGUL CHOSEONG CIEUC -->
+      <map code="0x110d" name="1em"/><!-- HANGUL CHOSEONG SSANGCIEUC -->
+      <map code="0x110e" name="1em"/><!-- HANGUL CHOSEONG CHIEUCH -->
+      <map code="0x110f" name="1em"/><!-- HANGUL CHOSEONG KHIEUKH -->
+      <map code="0x1110" name="1em"/><!-- HANGUL CHOSEONG THIEUTH -->
+      <map code="0x1111" name="1em"/><!-- HANGUL CHOSEONG PHIEUPH -->
+      <map code="0x1112" name="1em"/><!-- HANGUL CHOSEONG HIEUH -->
+      <map code="0x1113" name="1em"/><!-- HANGUL CHOSEONG NIEUN-KIYEOK -->
+      <map code="0x1114" name="1em"/><!-- HANGUL CHOSEONG SSANGNIEUN -->
+      <map code="0x1115" name="1em"/><!-- HANGUL CHOSEONG NIEUN-TIKEUT -->
+      <map code="0x1116" name="1em"/><!-- HANGUL CHOSEONG NIEUN-PIEUP -->
+      <map code="0x1117" name="1em"/><!-- HANGUL CHOSEONG TIKEUT-KIYEOK -->
+      <map code="0x1118" name="1em"/><!-- HANGUL CHOSEONG RIEUL-NIEUN -->
+      <map code="0x1119" name="1em"/><!-- HANGUL CHOSEONG SSANGRIEUL -->
+      <map code="0x111a" name="1em"/><!-- HANGUL CHOSEONG RIEUL-HIEUH -->
+      <map code="0x111b" name="1em"/><!-- HANGUL CHOSEONG KAPYEOUNRIEUL -->
+      <map code="0x111c" name="1em"/><!-- HANGUL CHOSEONG MIEUM-PIEUP -->
+      <map code="0x111d" name="1em"/><!-- HANGUL CHOSEONG KAPYEOUNMIEUM -->
+      <map code="0x111e" name="1em"/><!-- HANGUL CHOSEONG PIEUP-KIYEOK -->
+      <map code="0x111f" name="1em"/><!-- HANGUL CHOSEONG PIEUP-NIEUN -->
+      <map code="0x1120" name="1em"/><!-- HANGUL CHOSEONG PIEUP-TIKEUT -->
+      <map code="0x1121" name="1em"/><!-- HANGUL CHOSEONG PIEUP-SIOS -->
+      <map code="0x1122" name="1em"/><!-- HANGUL CHOSEONG PIEUP-SIOS-KIYEOK -->
+      <map code="0x1123" name="1em"/><!-- HANGUL CHOSEONG PIEUP-SIOS-TIKEUT -->
+      <map code="0x1124" name="1em"/><!-- HANGUL CHOSEONG PIEUP-SIOS-PIEUP -->
+      <map code="0x1125" name="1em"/><!-- HANGUL CHOSEONG PIEUP-SSANGSIOS -->
+      <map code="0x1126" name="1em"/><!-- HANGUL CHOSEONG PIEUP-SIOS-CIEUC -->
+      <map code="0x1127" name="1em"/><!-- HANGUL CHOSEONG PIEUP-CIEUC -->
+      <map code="0x1128" name="1em"/><!-- HANGUL CHOSEONG PIEUP-CHIEUCH -->
+      <map code="0x1129" name="1em"/><!-- HANGUL CHOSEONG PIEUP-THIEUTH -->
+      <map code="0x112a" name="1em"/><!-- HANGUL CHOSEONG PIEUP-PHIEUPH -->
+      <map code="0x112b" name="1em"/><!-- HANGUL CHOSEONG KAPYEOUNPIEUP -->
+      <map code="0x112c" name="1em"/><!-- HANGUL CHOSEONG KAPYEOUNSSANGPIEUP -->
+      <map code="0x112d" name="1em"/><!-- HANGUL CHOSEONG SIOS-KIYEOK -->
+      <map code="0x112e" name="1em"/><!-- HANGUL CHOSEONG SIOS-NIEUN -->
+      <map code="0x112f" name="1em"/><!-- HANGUL CHOSEONG SIOS-TIKEUT -->
+      <map code="0x1130" name="1em"/><!-- HANGUL CHOSEONG SIOS-RIEUL -->
+      <map code="0x1131" name="1em"/><!-- HANGUL CHOSEONG SIOS-MIEUM -->
+      <map code="0x1132" name="1em"/><!-- HANGUL CHOSEONG SIOS-PIEUP -->
+      <map code="0x1133" name="1em"/><!-- HANGUL CHOSEONG SIOS-PIEUP-KIYEOK -->
+      <map code="0x1134" name="1em"/><!-- HANGUL CHOSEONG SIOS-SSANGSIOS -->
+      <map code="0x1135" name="1em"/><!-- HANGUL CHOSEONG SIOS-IEUNG -->
+      <map code="0x1136" name="1em"/><!-- HANGUL CHOSEONG SIOS-CIEUC -->
+      <map code="0x1137" name="1em"/><!-- HANGUL CHOSEONG SIOS-CHIEUCH -->
+      <map code="0x1138" name="1em"/><!-- HANGUL CHOSEONG SIOS-KHIEUKH -->
+      <map code="0x1139" name="1em"/><!-- HANGUL CHOSEONG SIOS-THIEUTH -->
+      <map code="0x113a" name="1em"/><!-- HANGUL CHOSEONG SIOS-PHIEUPH -->
+      <map code="0x113b" name="1em"/><!-- HANGUL CHOSEONG SIOS-HIEUH -->
+      <map code="0x113c" name="1em"/><!-- HANGUL CHOSEONG CHITUEUMSIOS -->
+      <map code="0x113d" name="1em"/><!-- HANGUL CHOSEONG CHITUEUMSSANGSIOS -->
+      <map code="0x113e" name="1em"/><!-- HANGUL CHOSEONG CEONGCHIEUMSIOS -->
+      <map code="0x113f" name="1em"/><!-- HANGUL CHOSEONG CEONGCHIEUMSSANGSIOS -->
+      <map code="0x1140" name="1em"/><!-- HANGUL CHOSEONG PANSIOS -->
+      <map code="0x1141" name="1em"/><!-- HANGUL CHOSEONG IEUNG-KIYEOK -->
+      <map code="0x1142" name="1em"/><!-- HANGUL CHOSEONG IEUNG-TIKEUT -->
+      <map code="0x1143" name="1em"/><!-- HANGUL CHOSEONG IEUNG-MIEUM -->
+      <map code="0x1144" name="1em"/><!-- HANGUL CHOSEONG IEUNG-PIEUP -->
+      <map code="0x1145" name="1em"/><!-- HANGUL CHOSEONG IEUNG-SIOS -->
+      <map code="0x1146" name="1em"/><!-- HANGUL CHOSEONG IEUNG-PANSIOS -->
+      <map code="0x1147" name="1em"/><!-- HANGUL CHOSEONG SSANGIEUNG -->
+      <map code="0x1148" name="1em"/><!-- HANGUL CHOSEONG IEUNG-CIEUC -->
+      <map code="0x1149" name="1em"/><!-- HANGUL CHOSEONG IEUNG-CHIEUCH -->
+      <map code="0x114a" name="1em"/><!-- HANGUL CHOSEONG IEUNG-THIEUTH -->
+      <map code="0x114b" name="1em"/><!-- HANGUL CHOSEONG IEUNG-PHIEUPH -->
+      <map code="0x114c" name="1em"/><!-- HANGUL CHOSEONG YESIEUNG -->
+      <map code="0x114d" name="1em"/><!-- HANGUL CHOSEONG CIEUC-IEUNG -->
+      <map code="0x114e" name="1em"/><!-- HANGUL CHOSEONG CHITUEUMCIEUC -->
+      <map code="0x114f" name="1em"/><!-- HANGUL CHOSEONG CHITUEUMSSANGCIEUC -->
+      <map code="0x1150" name="1em"/><!-- HANGUL CHOSEONG CEONGCHIEUMCIEUC -->
+      <map code="0x1151" name="1em"/><!-- HANGUL CHOSEONG CEONGCHIEUMSSANGCIEUC -->
+      <map code="0x1152" name="1em"/><!-- HANGUL CHOSEONG CHIEUCH-KHIEUKH -->
+      <map code="0x1153" name="1em"/><!-- HANGUL CHOSEONG CHIEUCH-HIEUH -->
+      <map code="0x1154" name="1em"/><!-- HANGUL CHOSEONG CHITUEUMCHIEUCH -->
+      <map code="0x1155" name="1em"/><!-- HANGUL CHOSEONG CEONGCHIEUMCHIEUCH -->
+      <map code="0x1156" name="1em"/><!-- HANGUL CHOSEONG PHIEUPH-PIEUP -->
+      <map code="0x1157" name="1em"/><!-- HANGUL CHOSEONG KAPYEOUNPHIEUPH -->
+      <map code="0x1158" name="1em"/><!-- HANGUL CHOSEONG SSANGHIEUH -->
+      <map code="0x1159" name="1em"/><!-- HANGUL CHOSEONG YEORINHIEUH -->
+      <map code="0x115a" name="1em"/><!-- HANGUL CHOSEONG KIYEOK-TIKEUT -->
+      <map code="0x115b" name="1em"/><!-- HANGUL CHOSEONG NIEUN-SIOS -->
+      <map code="0x115c" name="1em"/><!-- HANGUL CHOSEONG NIEUN-CIEUC -->
+      <map code="0x115d" name="1em"/><!-- HANGUL CHOSEONG NIEUN-HIEUH -->
+      <map code="0x115e" name="1em"/><!-- HANGUL CHOSEONG TIKEUT-RIEUL -->
+      <map code="0x115f" name="1em"/><!-- HANGUL CHOSEONG FILLER -->
+      <map code="0x1160" name="1em"/><!-- HANGUL JUNGSEONG FILLER -->
+      <map code="0x1161" name="1em"/><!-- HANGUL JUNGSEONG A -->
+      <map code="0x1162" name="1em"/><!-- HANGUL JUNGSEONG AE -->
+      <map code="0x1163" name="1em"/><!-- HANGUL JUNGSEONG YA -->
+      <map code="0x1164" name="1em"/><!-- HANGUL JUNGSEONG YAE -->
+      <map code="0x1165" name="1em"/><!-- HANGUL JUNGSEONG EO -->
+      <map code="0x1166" name="1em"/><!-- HANGUL JUNGSEONG E -->
+      <map code="0x1167" name="1em"/><!-- HANGUL JUNGSEONG YEO -->
+      <map code="0x1168" name="1em"/><!-- HANGUL JUNGSEONG YE -->
+      <map code="0x1169" name="1em"/><!-- HANGUL JUNGSEONG O -->
+      <map code="0x116a" name="1em"/><!-- HANGUL JUNGSEONG WA -->
+      <map code="0x116b" name="1em"/><!-- HANGUL JUNGSEONG WAE -->
+      <map code="0x116c" name="1em"/><!-- HANGUL JUNGSEONG OE -->
+      <map code="0x116d" name="1em"/><!-- HANGUL JUNGSEONG YO -->
+      <map code="0x116e" name="1em"/><!-- HANGUL JUNGSEONG U -->
+      <map code="0x116f" name="1em"/><!-- HANGUL JUNGSEONG WEO -->
+      <map code="0x1170" name="1em"/><!-- HANGUL JUNGSEONG WE -->
+      <map code="0x1171" name="1em"/><!-- HANGUL JUNGSEONG WI -->
+      <map code="0x1172" name="1em"/><!-- HANGUL JUNGSEONG YU -->
+      <map code="0x1173" name="1em"/><!-- HANGUL JUNGSEONG EU -->
+      <map code="0x1174" name="1em"/><!-- HANGUL JUNGSEONG YI -->
+      <map code="0x1175" name="1em"/><!-- HANGUL JUNGSEONG I -->
+      <map code="0x1176" name="1em"/><!-- HANGUL JUNGSEONG A-O -->
+      <map code="0x1177" name="1em"/><!-- HANGUL JUNGSEONG A-U -->
+      <map code="0x1178" name="1em"/><!-- HANGUL JUNGSEONG YA-O -->
+      <map code="0x1179" name="1em"/><!-- HANGUL JUNGSEONG YA-YO -->
+      <map code="0x117a" name="1em"/><!-- HANGUL JUNGSEONG EO-O -->
+      <map code="0x117b" name="1em"/><!-- HANGUL JUNGSEONG EO-U -->
+      <map code="0x117c" name="1em"/><!-- HANGUL JUNGSEONG EO-EU -->
+      <map code="0x117d" name="1em"/><!-- HANGUL JUNGSEONG YEO-O -->
+      <map code="0x117e" name="1em"/><!-- HANGUL JUNGSEONG YEO-U -->
+      <map code="0x117f" name="1em"/><!-- HANGUL JUNGSEONG O-EO -->
+      <map code="0x1180" name="1em"/><!-- HANGUL JUNGSEONG O-E -->
+      <map code="0x1181" name="1em"/><!-- HANGUL JUNGSEONG O-YE -->
+      <map code="0x1182" name="1em"/><!-- HANGUL JUNGSEONG O-O -->
+      <map code="0x1183" name="1em"/><!-- HANGUL JUNGSEONG O-U -->
+      <map code="0x1184" name="1em"/><!-- HANGUL JUNGSEONG YO-YA -->
+      <map code="0x1185" name="1em"/><!-- HANGUL JUNGSEONG YO-YAE -->
+      <map code="0x1186" name="1em"/><!-- HANGUL JUNGSEONG YO-YEO -->
+      <map code="0x1187" name="1em"/><!-- HANGUL JUNGSEONG YO-O -->
+      <map code="0x1188" name="1em"/><!-- HANGUL JUNGSEONG YO-I -->
+      <map code="0x1189" name="1em"/><!-- HANGUL JUNGSEONG U-A -->
+      <map code="0x118a" name="1em"/><!-- HANGUL JUNGSEONG U-AE -->
+      <map code="0x118b" name="1em"/><!-- HANGUL JUNGSEONG U-EO-EU -->
+      <map code="0x118c" name="1em"/><!-- HANGUL JUNGSEONG U-YE -->
+      <map code="0x118d" name="1em"/><!-- HANGUL JUNGSEONG U-U -->
+      <map code="0x118e" name="1em"/><!-- HANGUL JUNGSEONG YU-A -->
+      <map code="0x118f" name="1em"/><!-- HANGUL JUNGSEONG YU-EO -->
+      <map code="0x1190" name="1em"/><!-- HANGUL JUNGSEONG YU-E -->
+      <map code="0x1191" name="1em"/><!-- HANGUL JUNGSEONG YU-YEO -->
+      <map code="0x1192" name="1em"/><!-- HANGUL JUNGSEONG YU-YE -->
+      <map code="0x1193" name="1em"/><!-- HANGUL JUNGSEONG YU-U -->
+      <map code="0x1194" name="1em"/><!-- HANGUL JUNGSEONG YU-I -->
+      <map code="0x1195" name="1em"/><!-- HANGUL JUNGSEONG EU-U -->
+      <map code="0x1196" name="1em"/><!-- HANGUL JUNGSEONG EU-EU -->
+      <map code="0x1197" name="1em"/><!-- HANGUL JUNGSEONG YI-U -->
+      <map code="0x1198" name="1em"/><!-- HANGUL JUNGSEONG I-A -->
+      <map code="0x1199" name="1em"/><!-- HANGUL JUNGSEONG I-YA -->
+      <map code="0x119a" name="1em"/><!-- HANGUL JUNGSEONG I-O -->
+      <map code="0x119b" name="1em"/><!-- HANGUL JUNGSEONG I-U -->
+      <map code="0x119c" name="1em"/><!-- HANGUL JUNGSEONG I-EU -->
+      <map code="0x119d" name="1em"/><!-- HANGUL JUNGSEONG I-ARAEA -->
+      <map code="0x119e" name="1em"/><!-- HANGUL JUNGSEONG ARAEA -->
+      <map code="0x119f" name="1em"/><!-- HANGUL JUNGSEONG ARAEA-EO -->
+      <map code="0x11a0" name="1em"/><!-- HANGUL JUNGSEONG ARAEA-U -->
+      <map code="0x11a1" name="1em"/><!-- HANGUL JUNGSEONG ARAEA-I -->
+      <map code="0x11a2" name="1em"/><!-- HANGUL JUNGSEONG SSANGARAEA -->
+      <map code="0x11a3" name="1em"/><!-- HANGUL JUNGSEONG A-EU -->
+      <map code="0x11a4" name="1em"/><!-- HANGUL JUNGSEONG YA-U -->
+      <map code="0x11a5" name="1em"/><!-- HANGUL JUNGSEONG YEO-YA -->
+      <map code="0x11a6" name="1em"/><!-- HANGUL JUNGSEONG O-YA -->
+      <map code="0x11a7" name="1em"/><!-- HANGUL JUNGSEONG O-YAE -->
+      <map code="0x11a8" name="1em"/><!-- HANGUL JONGSEONG KIYEOK -->
+      <map code="0x11a9" name="1em"/><!-- HANGUL JONGSEONG SSANGKIYEOK -->
+      <map code="0x11aa" name="1em"/><!-- HANGUL JONGSEONG KIYEOK-SIOS -->
+      <map code="0x11ab" name="1em"/><!-- HANGUL JONGSEONG NIEUN -->
+      <map code="0x11ac" name="1em"/><!-- HANGUL JONGSEONG NIEUN-CIEUC -->
+      <map code="0x11ad" name="1em"/><!-- HANGUL JONGSEONG NIEUN-HIEUH -->
+      <map code="0x11ae" name="1em"/><!-- HANGUL JONGSEONG TIKEUT -->
+      <map code="0x11af" name="1em"/><!-- HANGUL JONGSEONG RIEUL -->
+      <map code="0x11b0" name="1em"/><!-- HANGUL JONGSEONG RIEUL-KIYEOK -->
+      <map code="0x11b1" name="1em"/><!-- HANGUL JONGSEONG RIEUL-MIEUM -->
+      <map code="0x11b2" name="1em"/><!-- HANGUL JONGSEONG RIEUL-PIEUP -->
+      <map code="0x11b3" name="1em"/><!-- HANGUL JONGSEONG RIEUL-SIOS -->
+      <map code="0x11b4" name="1em"/><!-- HANGUL JONGSEONG RIEUL-THIEUTH -->
+      <map code="0x11b5" name="1em"/><!-- HANGUL JONGSEONG RIEUL-PHIEUPH -->
+      <map code="0x11b6" name="1em"/><!-- HANGUL JONGSEONG RIEUL-HIEUH -->
+      <map code="0x11b7" name="1em"/><!-- HANGUL JONGSEONG MIEUM -->
+      <map code="0x11b8" name="1em"/><!-- HANGUL JONGSEONG PIEUP -->
+      <map code="0x11b9" name="1em"/><!-- HANGUL JONGSEONG PIEUP-SIOS -->
+      <map code="0x11ba" name="1em"/><!-- HANGUL JONGSEONG SIOS -->
+      <map code="0x11bb" name="1em"/><!-- HANGUL JONGSEONG SSANGSIOS -->
+      <map code="0x11bc" name="1em"/><!-- HANGUL JONGSEONG IEUNG -->
+      <map code="0x11bd" name="1em"/><!-- HANGUL JONGSEONG CIEUC -->
+      <map code="0x11be" name="1em"/><!-- HANGUL JONGSEONG CHIEUCH -->
+      <map code="0x11bf" name="1em"/><!-- HANGUL JONGSEONG KHIEUKH -->
+      <map code="0x11c0" name="1em"/><!-- HANGUL JONGSEONG THIEUTH -->
+      <map code="0x11c1" name="1em"/><!-- HANGUL JONGSEONG PHIEUPH -->
+      <map code="0x11c2" name="1em"/><!-- HANGUL JONGSEONG HIEUH -->
+      <map code="0x11c3" name="1em"/><!-- HANGUL JONGSEONG KIYEOK-RIEUL -->
+      <map code="0x11c4" name="1em"/><!-- HANGUL JONGSEONG KIYEOK-SIOS-KIYEOK -->
+      <map code="0x11c5" name="1em"/><!-- HANGUL JONGSEONG NIEUN-KIYEOK -->
+      <map code="0x11c6" name="1em"/><!-- HANGUL JONGSEONG NIEUN-TIKEUT -->
+      <map code="0x11c7" name="1em"/><!-- HANGUL JONGSEONG NIEUN-SIOS -->
+      <map code="0x11c8" name="1em"/><!-- HANGUL JONGSEONG NIEUN-PANSIOS -->
+      <map code="0x11c9" name="1em"/><!-- HANGUL JONGSEONG NIEUN-THIEUTH -->
+      <map code="0x11ca" name="1em"/><!-- HANGUL JONGSEONG TIKEUT-KIYEOK -->
+      <map code="0x11cb" name="1em"/><!-- HANGUL JONGSEONG TIKEUT-RIEUL -->
+      <map code="0x11cc" name="1em"/><!-- HANGUL JONGSEONG RIEUL-KIYEOK-SIOS -->
+      <map code="0x11cd" name="1em"/><!-- HANGUL JONGSEONG RIEUL-NIEUN -->
+      <map code="0x11ce" name="1em"/><!-- HANGUL JONGSEONG RIEUL-TIKEUT -->
+      <map code="0x11cf" name="1em"/><!-- HANGUL JONGSEONG RIEUL-TIKEUT-HIEUH -->
+      <map code="0x11d0" name="1em"/><!-- HANGUL JONGSEONG SSANGRIEUL -->
+      <map code="0x11d1" name="1em"/><!-- HANGUL JONGSEONG RIEUL-MIEUM-KIYEOK -->
+      <map code="0x11d2" name="1em"/><!-- HANGUL JONGSEONG RIEUL-MIEUM-SIOS -->
+      <map code="0x11d3" name="1em"/><!-- HANGUL JONGSEONG RIEUL-PIEUP-SIOS -->
+      <map code="0x11d4" name="1em"/><!-- HANGUL JONGSEONG RIEUL-PIEUP-HIEUH -->
+      <map code="0x11d5" name="1em"/><!-- HANGUL JONGSEONG RIEUL-KAPYEOUNPIEUP -->
+      <map code="0x11d6" name="1em"/><!-- HANGUL JONGSEONG RIEUL-SSANGSIOS -->
+      <map code="0x11d7" name="1em"/><!-- HANGUL JONGSEONG RIEUL-PANSIOS -->
+      <map code="0x11d8" name="1em"/><!-- HANGUL JONGSEONG RIEUL-KHIEUKH -->
+      <map code="0x11d9" name="1em"/><!-- HANGUL JONGSEONG RIEUL-YEORINHIEUH -->
+      <map code="0x11da" name="1em"/><!-- HANGUL JONGSEONG MIEUM-KIYEOK -->
+      <map code="0x11db" name="1em"/><!-- HANGUL JONGSEONG MIEUM-RIEUL -->
+      <map code="0x11dc" name="1em"/><!-- HANGUL JONGSEONG MIEUM-PIEUP -->
+      <map code="0x11dd" name="1em"/><!-- HANGUL JONGSEONG MIEUM-SIOS -->
+      <map code="0x11de" name="1em"/><!-- HANGUL JONGSEONG MIEUM-SSANGSIOS -->
+      <map code="0x11df" name="1em"/><!-- HANGUL JONGSEONG MIEUM-PANSIOS -->
+      <map code="0x11e0" name="1em"/><!-- HANGUL JONGSEONG MIEUM-CHIEUCH -->
+      <map code="0x11e1" name="1em"/><!-- HANGUL JONGSEONG MIEUM-HIEUH -->
+      <map code="0x11e2" name="1em"/><!-- HANGUL JONGSEONG KAPYEOUNMIEUM -->
+      <map code="0x11e3" name="1em"/><!-- HANGUL JONGSEONG PIEUP-RIEUL -->
+      <map code="0x11e4" name="1em"/><!-- HANGUL JONGSEONG PIEUP-PHIEUPH -->
+      <map code="0x11e5" name="1em"/><!-- HANGUL JONGSEONG PIEUP-HIEUH -->
+      <map code="0x11e6" name="1em"/><!-- HANGUL JONGSEONG KAPYEOUNPIEUP -->
+      <map code="0x11e7" name="1em"/><!-- HANGUL JONGSEONG SIOS-KIYEOK -->
+      <map code="0x11e8" name="1em"/><!-- HANGUL JONGSEONG SIOS-TIKEUT -->
+      <map code="0x11e9" name="1em"/><!-- HANGUL JONGSEONG SIOS-RIEUL -->
+      <map code="0x11ea" name="1em"/><!-- HANGUL JONGSEONG SIOS-PIEUP -->
+      <map code="0x11eb" name="1em"/><!-- HANGUL JONGSEONG PANSIOS -->
+      <map code="0x11ec" name="1em"/><!-- HANGUL JONGSEONG IEUNG-KIYEOK -->
+      <map code="0x11ed" name="1em"/><!-- HANGUL JONGSEONG IEUNG-SSANGKIYEOK -->
+      <map code="0x11ee" name="1em"/><!-- HANGUL JONGSEONG SSANGIEUNG -->
+      <map code="0x11ef" name="1em"/><!-- HANGUL JONGSEONG IEUNG-KHIEUKH -->
+      <map code="0x11f0" name="1em"/><!-- HANGUL JONGSEONG YESIEUNG -->
+      <map code="0x11f1" name="1em"/><!-- HANGUL JONGSEONG YESIEUNG-SIOS -->
+      <map code="0x11f2" name="1em"/><!-- HANGUL JONGSEONG YESIEUNG-PANSIOS -->
+      <map code="0x11f3" name="1em"/><!-- HANGUL JONGSEONG PHIEUPH-PIEUP -->
+      <map code="0x11f4" name="1em"/><!-- HANGUL JONGSEONG KAPYEOUNPHIEUPH -->
+      <map code="0x11f5" name="1em"/><!-- HANGUL JONGSEONG HIEUH-NIEUN -->
+      <map code="0x11f6" name="1em"/><!-- HANGUL JONGSEONG HIEUH-RIEUL -->
+      <map code="0x11f7" name="1em"/><!-- HANGUL JONGSEONG HIEUH-MIEUM -->
+      <map code="0x11f8" name="1em"/><!-- HANGUL JONGSEONG HIEUH-PIEUP -->
+      <map code="0x11f9" name="1em"/><!-- HANGUL JONGSEONG YEORINHIEUH -->
+      <map code="0x11fa" name="1em"/><!-- HANGUL JONGSEONG KIYEOK-NIEUN -->
+      <map code="0x11fb" name="1em"/><!-- HANGUL JONGSEONG KIYEOK-PIEUP -->
+      <map code="0x11fc" name="1em"/><!-- HANGUL JONGSEONG KIYEOK-CHIEUCH -->
+      <map code="0x11fd" name="1em"/><!-- HANGUL JONGSEONG KIYEOK-KHIEUKH -->
+      <map code="0x11fe" name="1em"/><!-- HANGUL JONGSEONG KIYEOK-HIEUH -->
+      <map code="0x11ff" name="1em"/><!-- HANGUL JONGSEONG SSANGNIEUN -->
+      <map code="0x302e" name="1em"/><!-- HANGUL SINGLE DOT TONE MARK -->
+      <map code="0x302f" name="1em"/><!-- HANGUL DOUBLE DOT TONE MARK -->
+      <map code="0x3131" name="1em"/><!-- HANGUL LETTER KIYEOK -->
+      <map code="0x3132" name="1em"/><!-- HANGUL LETTER SSANGKIYEOK -->
+      <map code="0x3133" name="1em"/><!-- HANGUL LETTER KIYEOK-SIOS -->
+      <map code="0x3134" name="1em"/><!-- HANGUL LETTER NIEUN -->
+      <map code="0x3135" name="1em"/><!-- HANGUL LETTER NIEUN-CIEUC -->
+      <map code="0x3136" name="1em"/><!-- HANGUL LETTER NIEUN-HIEUH -->
+      <map code="0x3137" name="1em"/><!-- HANGUL LETTER TIKEUT -->
+      <map code="0x3138" name="1em"/><!-- HANGUL LETTER SSANGTIKEUT -->
+      <map code="0x3139" name="1em"/><!-- HANGUL LETTER RIEUL -->
+      <map code="0x313a" name="1em"/><!-- HANGUL LETTER RIEUL-KIYEOK -->
+      <map code="0x313b" name="1em"/><!-- HANGUL LETTER RIEUL-MIEUM -->
+      <map code="0x313c" name="1em"/><!-- HANGUL LETTER RIEUL-PIEUP -->
+      <map code="0x313d" name="1em"/><!-- HANGUL LETTER RIEUL-SIOS -->
+      <map code="0x313e" name="1em"/><!-- HANGUL LETTER RIEUL-THIEUTH -->
+      <map code="0x313f" name="1em"/><!-- HANGUL LETTER RIEUL-PHIEUPH -->
+      <map code="0x3140" name="1em"/><!-- HANGUL LETTER RIEUL-HIEUH -->
+      <map code="0x3141" name="1em"/><!-- HANGUL LETTER MIEUM -->
+      <map code="0x3142" name="1em"/><!-- HANGUL LETTER PIEUP -->
+      <map code="0x3143" name="1em"/><!-- HANGUL LETTER SSANGPIEUP -->
+      <map code="0x3144" name="1em"/><!-- HANGUL LETTER PIEUP-SIOS -->
+      <map code="0x3145" name="1em"/><!-- HANGUL LETTER SIOS -->
+      <map code="0x3146" name="1em"/><!-- HANGUL LETTER SSANGSIOS -->
+      <map code="0x3147" name="1em"/><!-- HANGUL LETTER IEUNG -->
+      <map code="0x3148" name="1em"/><!-- HANGUL LETTER CIEUC -->
+      <map code="0x3149" name="1em"/><!-- HANGUL LETTER SSANGCIEUC -->
+      <map code="0x314a" name="1em"/><!-- HANGUL LETTER CHIEUCH -->
+      <map code="0x314b" name="1em"/><!-- HANGUL LETTER KHIEUKH -->
+      <map code="0x314c" name="1em"/><!-- HANGUL LETTER THIEUTH -->
+      <map code="0x314d" name="1em"/><!-- HANGUL LETTER PHIEUPH -->
+      <map code="0x314e" name="1em"/><!-- HANGUL LETTER HIEUH -->
+      <map code="0x314f" name="1em"/><!-- HANGUL LETTER A -->
+      <map code="0x3150" name="1em"/><!-- HANGUL LETTER AE -->
+      <map code="0x3151" name="1em"/><!-- HANGUL LETTER YA -->
+      <map code="0x3152" name="1em"/><!-- HANGUL LETTER YAE -->
+      <map code="0x3153" name="1em"/><!-- HANGUL LETTER EO -->
+      <map code="0x3154" name="1em"/><!-- HANGUL LETTER E -->
+      <map code="0x3155" name="1em"/><!-- HANGUL LETTER YEO -->
+      <map code="0x3156" name="1em"/><!-- HANGUL LETTER YE -->
+      <map code="0x3157" name="1em"/><!-- HANGUL LETTER O -->
+      <map code="0x3158" name="1em"/><!-- HANGUL LETTER WA -->
+      <map code="0x3159" name="1em"/><!-- HANGUL LETTER WAE -->
+      <map code="0x315a" name="1em"/><!-- HANGUL LETTER OE -->
+      <map code="0x315b" name="1em"/><!-- HANGUL LETTER YO -->
+      <map code="0x315c" name="1em"/><!-- HANGUL LETTER U -->
+      <map code="0x315d" name="1em"/><!-- HANGUL LETTER WEO -->
+      <map code="0x315e" name="1em"/><!-- HANGUL LETTER WE -->
+      <map code="0x315f" name="1em"/><!-- HANGUL LETTER WI -->
+      <map code="0x3160" name="1em"/><!-- HANGUL LETTER YU -->
+      <map code="0x3161" name="1em"/><!-- HANGUL LETTER EU -->
+      <map code="0x3162" name="1em"/><!-- HANGUL LETTER YI -->
+      <map code="0x3163" name="1em"/><!-- HANGUL LETTER I -->
+      <map code="0x3164" name="1em"/><!-- HANGUL FILLER -->
+      <map code="0x3165" name="1em"/><!-- HANGUL LETTER SSANGNIEUN -->
+      <map code="0x3166" name="1em"/><!-- HANGUL LETTER NIEUN-TIKEUT -->
+      <map code="0x3167" name="1em"/><!-- HANGUL LETTER NIEUN-SIOS -->
+      <map code="0x3168" name="1em"/><!-- HANGUL LETTER NIEUN-PANSIOS -->
+      <map code="0x3169" name="1em"/><!-- HANGUL LETTER RIEUL-KIYEOK-SIOS -->
+      <map code="0x316a" name="1em"/><!-- HANGUL LETTER RIEUL-TIKEUT -->
+      <map code="0x316b" name="1em"/><!-- HANGUL LETTER RIEUL-PIEUP-SIOS -->
+      <map code="0x316c" name="1em"/><!-- HANGUL LETTER RIEUL-PANSIOS -->
+      <map code="0x316d" name="1em"/><!-- HANGUL LETTER RIEUL-YEORINHIEUH -->
+      <map code="0x316e" name="1em"/><!-- HANGUL LETTER MIEUM-PIEUP -->
+      <map code="0x316f" name="1em"/><!-- HANGUL LETTER MIEUM-SIOS -->
+      <map code="0x3170" name="1em"/><!-- HANGUL LETTER MIEUM-PANSIOS -->
+      <map code="0x3171" name="1em"/><!-- HANGUL LETTER KAPYEOUNMIEUM -->
+      <map code="0x3172" name="1em"/><!-- HANGUL LETTER PIEUP-KIYEOK -->
+      <map code="0x3173" name="1em"/><!-- HANGUL LETTER PIEUP-TIKEUT -->
+      <map code="0x3174" name="1em"/><!-- HANGUL LETTER PIEUP-SIOS-KIYEOK -->
+      <map code="0x3175" name="1em"/><!-- HANGUL LETTER PIEUP-SIOS-TIKEUT -->
+      <map code="0x3176" name="1em"/><!-- HANGUL LETTER PIEUP-CIEUC -->
+      <map code="0x3177" name="1em"/><!-- HANGUL LETTER PIEUP-THIEUTH -->
+      <map code="0x3178" name="1em"/><!-- HANGUL LETTER KAPYEOUNPIEUP -->
+      <map code="0x3179" name="1em"/><!-- HANGUL LETTER KAPYEOUNSSANGPIEUP -->
+      <map code="0x317a" name="1em"/><!-- HANGUL LETTER SIOS-KIYEOK -->
+      <map code="0x317b" name="1em"/><!-- HANGUL LETTER SIOS-NIEUN -->
+      <map code="0x317c" name="1em"/><!-- HANGUL LETTER SIOS-TIKEUT -->
+      <map code="0x317d" name="1em"/><!-- HANGUL LETTER SIOS-PIEUP -->
+      <map code="0x317e" name="1em"/><!-- HANGUL LETTER SIOS-CIEUC -->
+      <map code="0x317f" name="1em"/><!-- HANGUL LETTER PANSIOS -->
+      <map code="0x3180" name="1em"/><!-- HANGUL LETTER SSANGIEUNG -->
+      <map code="0x3181" name="1em"/><!-- HANGUL LETTER YESIEUNG -->
+      <map code="0x3182" name="1em"/><!-- HANGUL LETTER YESIEUNG-SIOS -->
+      <map code="0x3183" name="1em"/><!-- HANGUL LETTER YESIEUNG-PANSIOS -->
+      <map code="0x3184" name="1em"/><!-- HANGUL LETTER KAPYEOUNPHIEUPH -->
+      <map code="0x3185" name="1em"/><!-- HANGUL LETTER SSANGHIEUH -->
+      <map code="0x3186" name="1em"/><!-- HANGUL LETTER YEORINHIEUH -->
+      <map code="0x3187" name="1em"/><!-- HANGUL LETTER YO-YA -->
+      <map code="0x3188" name="1em"/><!-- HANGUL LETTER YO-YAE -->
+      <map code="0x3189" name="1em"/><!-- HANGUL LETTER YO-I -->
+      <map code="0x318a" name="1em"/><!-- HANGUL LETTER YU-YEO -->
+      <map code="0x318b" name="1em"/><!-- HANGUL LETTER YU-YE -->
+      <map code="0x318c" name="1em"/><!-- HANGUL LETTER YU-I -->
+      <map code="0x318d" name="1em"/><!-- HANGUL LETTER ARAEA -->
+      <map code="0x318e" name="1em"/><!-- HANGUL LETTER ARAEAE -->
+      <map code="0xa960" name="1em"/><!-- HANGUL CHOSEONG TIKEUT-MIEUM -->
+      <map code="0xa961" name="1em"/><!-- HANGUL CHOSEONG TIKEUT-PIEUP -->
+      <map code="0xa962" name="1em"/><!-- HANGUL CHOSEONG TIKEUT-SIOS -->
+      <map code="0xa963" name="1em"/><!-- HANGUL CHOSEONG TIKEUT-CIEUC -->
+      <map code="0xa964" name="1em"/><!-- HANGUL CHOSEONG RIEUL-KIYEOK -->
+      <map code="0xa965" name="1em"/><!-- HANGUL CHOSEONG RIEUL-SSANGKIYEOK -->
+      <map code="0xa966" name="1em"/><!-- HANGUL CHOSEONG RIEUL-TIKEUT -->
+      <map code="0xa967" name="1em"/><!-- HANGUL CHOSEONG RIEUL-SSANGTIKEUT -->
+      <map code="0xa968" name="1em"/><!-- HANGUL CHOSEONG RIEUL-MIEUM -->
+      <map code="0xa969" name="1em"/><!-- HANGUL CHOSEONG RIEUL-PIEUP -->
+      <map code="0xa96a" name="1em"/><!-- HANGUL CHOSEONG RIEUL-SSANGPIEUP -->
+      <map code="0xa96b" name="1em"/><!-- HANGUL CHOSEONG RIEUL-KAPYEOUNPIEUP -->
+      <map code="0xa96c" name="1em"/><!-- HANGUL CHOSEONG RIEUL-SIOS -->
+      <map code="0xa96d" name="1em"/><!-- HANGUL CHOSEONG RIEUL-CIEUC -->
+      <map code="0xa96e" name="1em"/><!-- HANGUL CHOSEONG RIEUL-KHIEUKH -->
+      <map code="0xa96f" name="1em"/><!-- HANGUL CHOSEONG MIEUM-KIYEOK -->
+      <map code="0xa970" name="1em"/><!-- HANGUL CHOSEONG MIEUM-TIKEUT -->
+      <map code="0xa971" name="1em"/><!-- HANGUL CHOSEONG MIEUM-SIOS -->
+      <map code="0xa972" name="1em"/><!-- HANGUL CHOSEONG PIEUP-SIOS-THIEUTH -->
+      <map code="0xa973" name="1em"/><!-- HANGUL CHOSEONG PIEUP-KHIEUKH -->
+      <map code="0xa974" name="1em"/><!-- HANGUL CHOSEONG PIEUP-HIEUH -->
+      <map code="0xa975" name="1em"/><!-- HANGUL CHOSEONG SSANGSIOS-PIEUP -->
+      <map code="0xa976" name="1em"/><!-- HANGUL CHOSEONG IEUNG-RIEUL -->
+      <map code="0xa977" name="1em"/><!-- HANGUL CHOSEONG IEUNG-HIEUH -->
+      <map code="0xa978" name="1em"/><!-- HANGUL CHOSEONG SSANGCIEUC-HIEUH -->
+      <map code="0xa979" name="1em"/><!-- HANGUL CHOSEONG SSANGTHIEUTH -->
+      <map code="0xa97a" name="1em"/><!-- HANGUL CHOSEONG PHIEUPH-HIEUH -->
+      <map code="0xa97b" name="1em"/><!-- HANGUL CHOSEONG HIEUH-SIOS -->
+      <map code="0xa97c" name="1em"/><!-- HANGUL CHOSEONG SSANGYEORINHIEUH -->
+      <map code="0xac00" name="1em"/><!-- HANGUL SYLLABLE GA -->
+      <map code="0xac01" name="1em"/><!-- HANGUL SYLLABLE GAG -->
+      <map code="0xac02" name="1em"/><!-- HANGUL SYLLABLE GAGG -->
+      <map code="0xac03" name="1em"/><!-- HANGUL SYLLABLE GAGS -->
+      <map code="0xac04" name="1em"/><!-- HANGUL SYLLABLE GAN -->
+      <map code="0xac05" name="1em"/><!-- HANGUL SYLLABLE GANJ -->
+      <map code="0xac06" name="1em"/><!-- HANGUL SYLLABLE GANH -->
+      <map code="0xac07" name="1em"/><!-- HANGUL SYLLABLE GAD -->
+      <map code="0xac08" name="1em"/><!-- HANGUL SYLLABLE GAL -->
+      <map code="0xac09" name="1em"/><!-- HANGUL SYLLABLE GALG -->
+      <map code="0xac0a" name="1em"/><!-- HANGUL SYLLABLE GALM -->
+      <map code="0xac0b" name="1em"/><!-- HANGUL SYLLABLE GALB -->
+      <map code="0xac0c" name="1em"/><!-- HANGUL SYLLABLE GALS -->
+      <map code="0xac0d" name="1em"/><!-- HANGUL SYLLABLE GALT -->
+      <map code="0xac0e" name="1em"/><!-- HANGUL SYLLABLE GALP -->
+      <map code="0xac0f" name="1em"/><!-- HANGUL SYLLABLE GALH -->
+      <map code="0xac10" name="1em"/><!-- HANGUL SYLLABLE GAM -->
+      <map code="0xac11" name="1em"/><!-- HANGUL SYLLABLE GAB -->
+      <map code="0xac12" name="1em"/><!-- HANGUL SYLLABLE GABS -->
+      <map code="0xac13" name="1em"/><!-- HANGUL SYLLABLE GAS -->
+      <map code="0xac14" name="1em"/><!-- HANGUL SYLLABLE GASS -->
+      <map code="0xac15" name="1em"/><!-- HANGUL SYLLABLE GANG -->
+      <map code="0xac16" name="1em"/><!-- HANGUL SYLLABLE GAJ -->
+      <map code="0xac17" name="1em"/><!-- HANGUL SYLLABLE GAC -->
+      <map code="0xac18" name="1em"/><!-- HANGUL SYLLABLE GAK -->
+      <map code="0xac19" name="1em"/><!-- HANGUL SYLLABLE GAT -->
+      <map code="0xac1a" name="1em"/><!-- HANGUL SYLLABLE GAP -->
+      <map code="0xac1b" name="1em"/><!-- HANGUL SYLLABLE GAH -->
+      <map code="0xac1c" name="1em"/><!-- HANGUL SYLLABLE GAE -->
+      <map code="0xac1d" name="1em"/><!-- HANGUL SYLLABLE GAEG -->
+      <map code="0xac1e" name="1em"/><!-- HANGUL SYLLABLE GAEGG -->
+      <map code="0xac1f" name="1em"/><!-- HANGUL SYLLABLE GAEGS -->
+      <map code="0xac20" name="1em"/><!-- HANGUL SYLLABLE GAEN -->
+      <map code="0xac21" name="1em"/><!-- HANGUL SYLLABLE GAENJ -->
+      <map code="0xac22" name="1em"/><!-- HANGUL SYLLABLE GAENH -->
+      <map code="0xac23" name="1em"/><!-- HANGUL SYLLABLE GAED -->
+      <map code="0xac24" name="1em"/><!-- HANGUL SYLLABLE GAEL -->
+      <map code="0xac25" name="1em"/><!-- HANGUL SYLLABLE GAELG -->
+      <map code="0xac26" name="1em"/><!-- HANGUL SYLLABLE GAELM -->
+      <map code="0xac27" name="1em"/><!-- HANGUL SYLLABLE GAELB -->
+      <map code="0xac28" name="1em"/><!-- HANGUL SYLLABLE GAELS -->
+      <map code="0xac29" name="1em"/><!-- HANGUL SYLLABLE GAELT -->
+      <map code="0xac2a" name="1em"/><!-- HANGUL SYLLABLE GAELP -->
+      <map code="0xac2b" name="1em"/><!-- HANGUL SYLLABLE GAELH -->
+      <map code="0xac2c" name="1em"/><!-- HANGUL SYLLABLE GAEM -->
+      <map code="0xac2d" name="1em"/><!-- HANGUL SYLLABLE GAEB -->
+      <map code="0xac2e" name="1em"/><!-- HANGUL SYLLABLE GAEBS -->
+      <map code="0xac2f" name="1em"/><!-- HANGUL SYLLABLE GAES -->
+      <map code="0xac30" name="1em"/><!-- HANGUL SYLLABLE GAESS -->
+      <map code="0xac31" name="1em"/><!-- HANGUL SYLLABLE GAENG -->
+      <map code="0xac32" name="1em"/><!-- HANGUL SYLLABLE GAEJ -->
+      <map code="0xac33" name="1em"/><!-- HANGUL SYLLABLE GAEC -->
+      <map code="0xac34" name="1em"/><!-- HANGUL SYLLABLE GAEK -->
+      <map code="0xac35" name="1em"/><!-- HANGUL SYLLABLE GAET -->
+      <map code="0xac36" name="1em"/><!-- HANGUL SYLLABLE GAEP -->
+      <map code="0xac37" name="1em"/><!-- HANGUL SYLLABLE GAEH -->
+      <map code="0xac38" name="1em"/><!-- HANGUL SYLLABLE GYA -->
+      <map code="0xac39" name="1em"/><!-- HANGUL SYLLABLE GYAG -->
+      <map code="0xac3a" name="1em"/><!-- HANGUL SYLLABLE GYAGG -->
+      <map code="0xac3b" name="1em"/><!-- HANGUL SYLLABLE GYAGS -->
+      <map code="0xac3c" name="1em"/><!-- HANGUL SYLLABLE GYAN -->
+      <map code="0xac3d" name="1em"/><!-- HANGUL SYLLABLE GYANJ -->
+      <map code="0xac3e" name="1em"/><!-- HANGUL SYLLABLE GYANH -->
+      <map code="0xac3f" name="1em"/><!-- HANGUL SYLLABLE GYAD -->
+      <map code="0xac40" name="1em"/><!-- HANGUL SYLLABLE GYAL -->
+      <map code="0xac41" name="1em"/><!-- HANGUL SYLLABLE GYALG -->
+      <map code="0xac42" name="1em"/><!-- HANGUL SYLLABLE GYALM -->
+      <map code="0xac43" name="1em"/><!-- HANGUL SYLLABLE GYALB -->
+      <map code="0xac44" name="1em"/><!-- HANGUL SYLLABLE GYALS -->
+      <map code="0xac45" name="1em"/><!-- HANGUL SYLLABLE GYALT -->
+      <map code="0xac46" name="1em"/><!-- HANGUL SYLLABLE GYALP -->
+      <map code="0xac47" name="1em"/><!-- HANGUL SYLLABLE GYALH -->
+      <map code="0xac48" name="1em"/><!-- HANGUL SYLLABLE GYAM -->
+      <map code="0xac49" name="1em"/><!-- HANGUL SYLLABLE GYAB -->
+      <map code="0xac4a" name="1em"/><!-- HANGUL SYLLABLE GYABS -->
+      <map code="0xac4b" name="1em"/><!-- HANGUL SYLLABLE GYAS -->
+      <map code="0xac4c" name="1em"/><!-- HANGUL SYLLABLE GYASS -->
+      <map code="0xac4d" name="1em"/><!-- HANGUL SYLLABLE GYANG -->
+      <map code="0xac4e" name="1em"/><!-- HANGUL SYLLABLE GYAJ -->
+      <map code="0xac4f" name="1em"/><!-- HANGUL SYLLABLE GYAC -->
+      <map code="0xac50" name="1em"/><!-- HANGUL SYLLABLE GYAK -->
+      <map code="0xac51" name="1em"/><!-- HANGUL SYLLABLE GYAT -->
+      <map code="0xac52" name="1em"/><!-- HANGUL SYLLABLE GYAP -->
+      <map code="0xac53" name="1em"/><!-- HANGUL SYLLABLE GYAH -->
+      <map code="0xac54" name="1em"/><!-- HANGUL SYLLABLE GYAE -->
+      <map code="0xac55" name="1em"/><!-- HANGUL SYLLABLE GYAEG -->
+      <map code="0xac56" name="1em"/><!-- HANGUL SYLLABLE GYAEGG -->
+      <map code="0xac57" name="1em"/><!-- HANGUL SYLLABLE GYAEGS -->
+      <map code="0xac58" name="1em"/><!-- HANGUL SYLLABLE GYAEN -->
+      <map code="0xac59" name="1em"/><!-- HANGUL SYLLABLE GYAENJ -->
+      <map code="0xac5a" name="1em"/><!-- HANGUL SYLLABLE GYAENH -->
+      <map code="0xac5b" name="1em"/><!-- HANGUL SYLLABLE GYAED -->
+      <map code="0xac5c" name="1em"/><!-- HANGUL SYLLABLE GYAEL -->
+      <map code="0xac5d" name="1em"/><!-- HANGUL SYLLABLE GYAELG -->
+      <map code="0xac5e" name="1em"/><!-- HANGUL SYLLABLE GYAELM -->
+      <map code="0xac5f" name="1em"/><!-- HANGUL SYLLABLE GYAELB -->
+      <map code="0xac60" name="1em"/><!-- HANGUL SYLLABLE GYAELS -->
+      <map code="0xac61" name="1em"/><!-- HANGUL SYLLABLE GYAELT -->
+      <map code="0xac62" name="1em"/><!-- HANGUL SYLLABLE GYAELP -->
+      <map code="0xac63" name="1em"/><!-- HANGUL SYLLABLE GYAELH -->
+      <map code="0xac64" name="1em"/><!-- HANGUL SYLLABLE GYAEM -->
+      <map code="0xac65" name="1em"/><!-- HANGUL SYLLABLE GYAEB -->
+      <map code="0xac66" name="1em"/><!-- HANGUL SYLLABLE GYAEBS -->
+      <map code="0xac67" name="1em"/><!-- HANGUL SYLLABLE GYAES -->
+      <map code="0xac68" name="1em"/><!-- HANGUL SYLLABLE GYAESS -->
+      <map code="0xac69" name="1em"/><!-- HANGUL SYLLABLE GYAENG -->
+      <map code="0xac6a" name="1em"/><!-- HANGUL SYLLABLE GYAEJ -->
+      <map code="0xac6b" name="1em"/><!-- HANGUL SYLLABLE GYAEC -->
+      <map code="0xac6c" name="1em"/><!-- HANGUL SYLLABLE GYAEK -->
+      <map code="0xac6d" name="1em"/><!-- HANGUL SYLLABLE GYAET -->
+      <map code="0xac6e" name="1em"/><!-- HANGUL SYLLABLE GYAEP -->
+      <map code="0xac6f" name="1em"/><!-- HANGUL SYLLABLE GYAEH -->
+      <map code="0xac70" name="1em"/><!-- HANGUL SYLLABLE GEO -->
+      <map code="0xac71" name="1em"/><!-- HANGUL SYLLABLE GEOG -->
+      <map code="0xac72" name="1em"/><!-- HANGUL SYLLABLE GEOGG -->
+      <map code="0xac73" name="1em"/><!-- HANGUL SYLLABLE GEOGS -->
+      <map code="0xac74" name="1em"/><!-- HANGUL SYLLABLE GEON -->
+      <map code="0xac75" name="1em"/><!-- HANGUL SYLLABLE GEONJ -->
+      <map code="0xac76" name="1em"/><!-- HANGUL SYLLABLE GEONH -->
+      <map code="0xac77" name="1em"/><!-- HANGUL SYLLABLE GEOD -->
+      <map code="0xac78" name="1em"/><!-- HANGUL SYLLABLE GEOL -->
+      <map code="0xac79" name="1em"/><!-- HANGUL SYLLABLE GEOLG -->
+      <map code="0xac7a" name="1em"/><!-- HANGUL SYLLABLE GEOLM -->
+      <map code="0xac7b" name="1em"/><!-- HANGUL SYLLABLE GEOLB -->
+      <map code="0xac7c" name="1em"/><!-- HANGUL SYLLABLE GEOLS -->
+      <map code="0xac7d" name="1em"/><!-- HANGUL SYLLABLE GEOLT -->
+      <map code="0xac7e" name="1em"/><!-- HANGUL SYLLABLE GEOLP -->
+      <map code="0xac7f" name="1em"/><!-- HANGUL SYLLABLE GEOLH -->
+      <map code="0xac80" name="1em"/><!-- HANGUL SYLLABLE GEOM -->
+      <map code="0xac81" name="1em"/><!-- HANGUL SYLLABLE GEOB -->
+      <map code="0xac82" name="1em"/><!-- HANGUL SYLLABLE GEOBS -->
+      <map code="0xac83" name="1em"/><!-- HANGUL SYLLABLE GEOS -->
+      <map code="0xac84" name="1em"/><!-- HANGUL SYLLABLE GEOSS -->
+      <map code="0xac85" name="1em"/><!-- HANGUL SYLLABLE GEONG -->
+      <map code="0xac86" name="1em"/><!-- HANGUL SYLLABLE GEOJ -->
+      <map code="0xac87" name="1em"/><!-- HANGUL SYLLABLE GEOC -->
+      <map code="0xac88" name="1em"/><!-- HANGUL SYLLABLE GEOK -->
+      <map code="0xac89" name="1em"/><!-- HANGUL SYLLABLE GEOT -->
+      <map code="0xac8a" name="1em"/><!-- HANGUL SYLLABLE GEOP -->
+      <map code="0xac8b" name="1em"/><!-- HANGUL SYLLABLE GEOH -->
+      <map code="0xac8c" name="1em"/><!-- HANGUL SYLLABLE GE -->
+      <map code="0xac8d" name="1em"/><!-- HANGUL SYLLABLE GEG -->
+      <map code="0xac8e" name="1em"/><!-- HANGUL SYLLABLE GEGG -->
+      <map code="0xac8f" name="1em"/><!-- HANGUL SYLLABLE GEGS -->
+      <map code="0xac90" name="1em"/><!-- HANGUL SYLLABLE GEN -->
+      <map code="0xac91" name="1em"/><!-- HANGUL SYLLABLE GENJ -->
+      <map code="0xac92" name="1em"/><!-- HANGUL SYLLABLE GENH -->
+      <map code="0xac93" name="1em"/><!-- HANGUL SYLLABLE GED -->
+      <map code="0xac94" name="1em"/><!-- HANGUL SYLLABLE GEL -->
+      <map code="0xac95" name="1em"/><!-- HANGUL SYLLABLE GELG -->
+      <map code="0xac96" name="1em"/><!-- HANGUL SYLLABLE GELM -->
+      <map code="0xac97" name="1em"/><!-- HANGUL SYLLABLE GELB -->
+      <map code="0xac98" name="1em"/><!-- HANGUL SYLLABLE GELS -->
+      <map code="0xac99" name="1em"/><!-- HANGUL SYLLABLE GELT -->
+      <map code="0xac9a" name="1em"/><!-- HANGUL SYLLABLE GELP -->
+      <map code="0xac9b" name="1em"/><!-- HANGUL SYLLABLE GELH -->
+      <map code="0xac9c" name="1em"/><!-- HANGUL SYLLABLE GEM -->
+      <map code="0xac9d" name="1em"/><!-- HANGUL SYLLABLE GEB -->
+      <map code="0xac9e" name="1em"/><!-- HANGUL SYLLABLE GEBS -->
+      <map code="0xac9f" name="1em"/><!-- HANGUL SYLLABLE GES -->
+      <map code="0xaca0" name="1em"/><!-- HANGUL SYLLABLE GESS -->
+      <map code="0xaca1" name="1em"/><!-- HANGUL SYLLABLE GENG -->
+      <map code="0xaca2" name="1em"/><!-- HANGUL SYLLABLE GEJ -->
+      <map code="0xaca3" name="1em"/><!-- HANGUL SYLLABLE GEC -->
+      <map code="0xaca4" name="1em"/><!-- HANGUL SYLLABLE GEK -->
+      <map code="0xaca5" name="1em"/><!-- HANGUL SYLLABLE GET -->
+      <map code="0xaca6" name="1em"/><!-- HANGUL SYLLABLE GEP -->
+      <map code="0xaca7" name="1em"/><!-- HANGUL SYLLABLE GEH -->
+      <map code="0xaca8" name="1em"/><!-- HANGUL SYLLABLE GYEO -->
+      <map code="0xaca9" name="1em"/><!-- HANGUL SYLLABLE GYEOG -->
+      <map code="0xacaa" name="1em"/><!-- HANGUL SYLLABLE GYEOGG -->
+      <map code="0xacab" name="1em"/><!-- HANGUL SYLLABLE GYEOGS -->
+      <map code="0xacac" name="1em"/><!-- HANGUL SYLLABLE GYEON -->
+      <map code="0xacad" name="1em"/><!-- HANGUL SYLLABLE GYEONJ -->
+      <map code="0xacae" name="1em"/><!-- HANGUL SYLLABLE GYEONH -->
+      <map code="0xacaf" name="1em"/><!-- HANGUL SYLLABLE GYEOD -->
+      <map code="0xacb0" name="1em"/><!-- HANGUL SYLLABLE GYEOL -->
+      <map code="0xacb1" name="1em"/><!-- HANGUL SYLLABLE GYEOLG -->
+      <map code="0xacb2" name="1em"/><!-- HANGUL SYLLABLE GYEOLM -->
+      <map code="0xacb3" name="1em"/><!-- HANGUL SYLLABLE GYEOLB -->
+      <map code="0xacb4" name="1em"/><!-- HANGUL SYLLABLE GYEOLS -->
+      <map code="0xacb5" name="1em"/><!-- HANGUL SYLLABLE GYEOLT -->
+      <map code="0xacb6" name="1em"/><!-- HANGUL SYLLABLE GYEOLP -->
+      <map code="0xacb7" name="1em"/><!-- HANGUL SYLLABLE GYEOLH -->
+      <map code="0xacb8" name="1em"/><!-- HANGUL SYLLABLE GYEOM -->
+      <map code="0xacb9" name="1em"/><!-- HANGUL SYLLABLE GYEOB -->
+      <map code="0xacba" name="1em"/><!-- HANGUL SYLLABLE GYEOBS -->
+      <map code="0xacbb" name="1em"/><!-- HANGUL SYLLABLE GYEOS -->
+      <map code="0xacbc" name="1em"/><!-- HANGUL SYLLABLE GYEOSS -->
+      <map code="0xacbd" name="1em"/><!-- HANGUL SYLLABLE GYEONG -->
+      <map code="0xacbe" name="1em"/><!-- HANGUL SYLLABLE GYEOJ -->
+      <map code="0xacbf" name="1em"/><!-- HANGUL SYLLABLE GYEOC -->
+      <map code="0xacc0" name="1em"/><!-- HANGUL SYLLABLE GYEOK -->
+      <map code="0xacc1" name="1em"/><!-- HANGUL SYLLABLE GYEOT -->
+      <map code="0xacc2" name="1em"/><!-- HANGUL SYLLABLE GYEOP -->
+      <map code="0xacc3" name="1em"/><!-- HANGUL SYLLABLE GYEOH -->
+      <map code="0xacc4" name="1em"/><!-- HANGUL SYLLABLE GYE -->
+      <map code="0xacc5" name="1em"/><!-- HANGUL SYLLABLE GYEG -->
+      <map code="0xacc6" name="1em"/><!-- HANGUL SYLLABLE GYEGG -->
+      <map code="0xacc7" name="1em"/><!-- HANGUL SYLLABLE GYEGS -->
+      <map code="0xacc8" name="1em"/><!-- HANGUL SYLLABLE GYEN -->
+      <map code="0xacc9" name="1em"/><!-- HANGUL SYLLABLE GYENJ -->
+      <map code="0xacca" name="1em"/><!-- HANGUL SYLLABLE GYENH -->
+      <map code="0xaccb" name="1em"/><!-- HANGUL SYLLABLE GYED -->
+      <map code="0xaccc" name="1em"/><!-- HANGUL SYLLABLE GYEL -->
+      <map code="0xaccd" name="1em"/><!-- HANGUL SYLLABLE GYELG -->
+      <map code="0xacce" name="1em"/><!-- HANGUL SYLLABLE GYELM -->
+      <map code="0xaccf" name="1em"/><!-- HANGUL SYLLABLE GYELB -->
+      <map code="0xacd0" name="1em"/><!-- HANGUL SYLLABLE GYELS -->
+      <map code="0xacd1" name="1em"/><!-- HANGUL SYLLABLE GYELT -->
+      <map code="0xacd2" name="1em"/><!-- HANGUL SYLLABLE GYELP -->
+      <map code="0xacd3" name="1em"/><!-- HANGUL SYLLABLE GYELH -->
+      <map code="0xacd4" name="1em"/><!-- HANGUL SYLLABLE GYEM -->
+      <map code="0xacd5" name="1em"/><!-- HANGUL SYLLABLE GYEB -->
+      <map code="0xacd6" name="1em"/><!-- HANGUL SYLLABLE GYEBS -->
+      <map code="0xacd7" name="1em"/><!-- HANGUL SYLLABLE GYES -->
+      <map code="0xacd8" name="1em"/><!-- HANGUL SYLLABLE GYESS -->
+      <map code="0xacd9" name="1em"/><!-- HANGUL SYLLABLE GYENG -->
+      <map code="0xacda" name="1em"/><!-- HANGUL SYLLABLE GYEJ -->
+      <map code="0xacdb" name="1em"/><!-- HANGUL SYLLABLE GYEC -->
+      <map code="0xacdc" name="1em"/><!-- HANGUL SYLLABLE GYEK -->
+      <map code="0xacdd" name="1em"/><!-- HANGUL SYLLABLE GYET -->
+      <map code="0xacde" name="1em"/><!-- HANGUL SYLLABLE GYEP -->
+      <map code="0xacdf" name="1em"/><!-- HANGUL SYLLABLE GYEH -->
+      <map code="0xace0" name="1em"/><!-- HANGUL SYLLABLE GO -->
+      <map code="0xace1" name="1em"/><!-- HANGUL SYLLABLE GOG -->
+      <map code="0xace2" name="1em"/><!-- HANGUL SYLLABLE GOGG -->
+      <map code="0xace3" name="1em"/><!-- HANGUL SYLLABLE GOGS -->
+      <map code="0xace4" name="1em"/><!-- HANGUL SYLLABLE GON -->
+      <map code="0xace5" name="1em"/><!-- HANGUL SYLLABLE GONJ -->
+      <map code="0xace6" name="1em"/><!-- HANGUL SYLLABLE GONH -->
+      <map code="0xace7" name="1em"/><!-- HANGUL SYLLABLE GOD -->
+      <map code="0xace8" name="1em"/><!-- HANGUL SYLLABLE GOL -->
+      <map code="0xace9" name="1em"/><!-- HANGUL SYLLABLE GOLG -->
+      <map code="0xacea" name="1em"/><!-- HANGUL SYLLABLE GOLM -->
+      <map code="0xaceb" name="1em"/><!-- HANGUL SYLLABLE GOLB -->
+      <map code="0xacec" name="1em"/><!-- HANGUL SYLLABLE GOLS -->
+      <map code="0xaced" name="1em"/><!-- HANGUL SYLLABLE GOLT -->
+      <map code="0xacee" name="1em"/><!-- HANGUL SYLLABLE GOLP -->
+      <map code="0xacef" name="1em"/><!-- HANGUL SYLLABLE GOLH -->
+      <map code="0xacf0" name="1em"/><!-- HANGUL SYLLABLE GOM -->
+      <map code="0xacf1" name="1em"/><!-- HANGUL SYLLABLE GOB -->
+      <map code="0xacf2" name="1em"/><!-- HANGUL SYLLABLE GOBS -->
+      <map code="0xacf3" name="1em"/><!-- HANGUL SYLLABLE GOS -->
+      <map code="0xacf4" name="1em"/><!-- HANGUL SYLLABLE GOSS -->
+      <map code="0xacf5" name="1em"/><!-- HANGUL SYLLABLE GONG -->
+      <map code="0xacf6" name="1em"/><!-- HANGUL SYLLABLE GOJ -->
+      <map code="0xacf7" name="1em"/><!-- HANGUL SYLLABLE GOC -->
+      <map code="0xacf8" name="1em"/><!-- HANGUL SYLLABLE GOK -->
+      <map code="0xacf9" name="1em"/><!-- HANGUL SYLLABLE GOT -->
+      <map code="0xacfa" name="1em"/><!-- HANGUL SYLLABLE GOP -->
+      <map code="0xacfb" name="1em"/><!-- HANGUL SYLLABLE GOH -->
+      <map code="0xacfc" name="1em"/><!-- HANGUL SYLLABLE GWA -->
+      <map code="0xacfd" name="1em"/><!-- HANGUL SYLLABLE GWAG -->
+      <map code="0xacfe" name="1em"/><!-- HANGUL SYLLABLE GWAGG -->
+      <map code="0xacff" name="1em"/><!-- HANGUL SYLLABLE GWAGS -->
+      <map code="0xad00" name="1em"/><!-- HANGUL SYLLABLE GWAN -->
+      <map code="0xad01" name="1em"/><!-- HANGUL SYLLABLE GWANJ -->
+      <map code="0xad02" name="1em"/><!-- HANGUL SYLLABLE GWANH -->
+      <map code="0xad03" name="1em"/><!-- HANGUL SYLLABLE GWAD -->
+      <map code="0xad04" name="1em"/><!-- HANGUL SYLLABLE GWAL -->
+      <map code="0xad05" name="1em"/><!-- HANGUL SYLLABLE GWALG -->
+      <map code="0xad06" name="1em"/><!-- HANGUL SYLLABLE GWALM -->
+      <map code="0xad07" name="1em"/><!-- HANGUL SYLLABLE GWALB -->
+      <map code="0xad08" name="1em"/><!-- HANGUL SYLLABLE GWALS -->
+      <map code="0xad09" name="1em"/><!-- HANGUL SYLLABLE GWALT -->
+      <map code="0xad0a" name="1em"/><!-- HANGUL SYLLABLE GWALP -->
+      <map code="0xad0b" name="1em"/><!-- HANGUL SYLLABLE GWALH -->
+      <map code="0xad0c" name="1em"/><!-- HANGUL SYLLABLE GWAM -->
+      <map code="0xad0d" name="1em"/><!-- HANGUL SYLLABLE GWAB -->
+      <map code="0xad0e" name="1em"/><!-- HANGUL SYLLABLE GWABS -->
+      <map code="0xad0f" name="1em"/><!-- HANGUL SYLLABLE GWAS -->
+      <map code="0xad10" name="1em"/><!-- HANGUL SYLLABLE GWASS -->
+      <map code="0xad11" name="1em"/><!-- HANGUL SYLLABLE GWANG -->
+      <map code="0xad12" name="1em"/><!-- HANGUL SYLLABLE GWAJ -->
+      <map code="0xad13" name="1em"/><!-- HANGUL SYLLABLE GWAC -->
+      <map code="0xad14" name="1em"/><!-- HANGUL SYLLABLE GWAK -->
+      <map code="0xad15" name="1em"/><!-- HANGUL SYLLABLE GWAT -->
+      <map code="0xad16" name="1em"/><!-- HANGUL SYLLABLE GWAP -->
+      <map code="0xad17" name="1em"/><!-- HANGUL SYLLABLE GWAH -->
+      <map code="0xad18" name="1em"/><!-- HANGUL SYLLABLE GWAE -->
+      <map code="0xad19" name="1em"/><!-- HANGUL SYLLABLE GWAEG -->
+      <map code="0xad1a" name="1em"/><!-- HANGUL SYLLABLE GWAEGG -->
+      <map code="0xad1b" name="1em"/><!-- HANGUL SYLLABLE GWAEGS -->
+      <map code="0xad1c" name="1em"/><!-- HANGUL SYLLABLE GWAEN -->
+      <map code="0xad1d" name="1em"/><!-- HANGUL SYLLABLE GWAENJ -->
+      <map code="0xad1e" name="1em"/><!-- HANGUL SYLLABLE GWAENH -->
+      <map code="0xad1f" name="1em"/><!-- HANGUL SYLLABLE GWAED -->
+      <map code="0xad20" name="1em"/><!-- HANGUL SYLLABLE GWAEL -->
+      <map code="0xad21" name="1em"/><!-- HANGUL SYLLABLE GWAELG -->
+      <map code="0xad22" name="1em"/><!-- HANGUL SYLLABLE GWAELM -->
+      <map code="0xad23" name="1em"/><!-- HANGUL SYLLABLE GWAELB -->
+      <map code="0xad24" name="1em"/><!-- HANGUL SYLLABLE GWAELS -->
+      <map code="0xad25" name="1em"/><!-- HANGUL SYLLABLE GWAELT -->
+      <map code="0xad26" name="1em"/><!-- HANGUL SYLLABLE GWAELP -->
+      <map code="0xad27" name="1em"/><!-- HANGUL SYLLABLE GWAELH -->
+      <map code="0xad28" name="1em"/><!-- HANGUL SYLLABLE GWAEM -->
+      <map code="0xad29" name="1em"/><!-- HANGUL SYLLABLE GWAEB -->
+      <map code="0xad2a" name="1em"/><!-- HANGUL SYLLABLE GWAEBS -->
+      <map code="0xad2b" name="1em"/><!-- HANGUL SYLLABLE GWAES -->
+      <map code="0xad2c" name="1em"/><!-- HANGUL SYLLABLE GWAESS -->
+      <map code="0xad2d" name="1em"/><!-- HANGUL SYLLABLE GWAENG -->
+      <map code="0xad2e" name="1em"/><!-- HANGUL SYLLABLE GWAEJ -->
+      <map code="0xad2f" name="1em"/><!-- HANGUL SYLLABLE GWAEC -->
+      <map code="0xad30" name="1em"/><!-- HANGUL SYLLABLE GWAEK -->
+      <map code="0xad31" name="1em"/><!-- HANGUL SYLLABLE GWAET -->
+      <map code="0xad32" name="1em"/><!-- HANGUL SYLLABLE GWAEP -->
+      <map code="0xad33" name="1em"/><!-- HANGUL SYLLABLE GWAEH -->
+      <map code="0xad34" name="1em"/><!-- HANGUL SYLLABLE GOE -->
+      <map code="0xad35" name="1em"/><!-- HANGUL SYLLABLE GOEG -->
+      <map code="0xad36" name="1em"/><!-- HANGUL SYLLABLE GOEGG -->
+      <map code="0xad37" name="1em"/><!-- HANGUL SYLLABLE GOEGS -->
+      <map code="0xad38" name="1em"/><!-- HANGUL SYLLABLE GOEN -->
+      <map code="0xad39" name="1em"/><!-- HANGUL SYLLABLE GOENJ -->
+      <map code="0xad3a" name="1em"/><!-- HANGUL SYLLABLE GOENH -->
+      <map code="0xad3b" name="1em"/><!-- HANGUL SYLLABLE GOED -->
+      <map code="0xad3c" name="1em"/><!-- HANGUL SYLLABLE GOEL -->
+      <map code="0xad3d" name="1em"/><!-- HANGUL SYLLABLE GOELG -->
+      <map code="0xad3e" name="1em"/><!-- HANGUL SYLLABLE GOELM -->
+      <map code="0xad3f" name="1em"/><!-- HANGUL SYLLABLE GOELB -->
+      <map code="0xad40" name="1em"/><!-- HANGUL SYLLABLE GOELS -->
+      <map code="0xad41" name="1em"/><!-- HANGUL SYLLABLE GOELT -->
+      <map code="0xad42" name="1em"/><!-- HANGUL SYLLABLE GOELP -->
+      <map code="0xad43" name="1em"/><!-- HANGUL SYLLABLE GOELH -->
+      <map code="0xad44" name="1em"/><!-- HANGUL SYLLABLE GOEM -->
+      <map code="0xad45" name="1em"/><!-- HANGUL SYLLABLE GOEB -->
+      <map code="0xad46" name="1em"/><!-- HANGUL SYLLABLE GOEBS -->
+      <map code="0xad47" name="1em"/><!-- HANGUL SYLLABLE GOES -->
+      <map code="0xad48" name="1em"/><!-- HANGUL SYLLABLE GOESS -->
+      <map code="0xad49" name="1em"/><!-- HANGUL SYLLABLE GOENG -->
+      <map code="0xad4a" name="1em"/><!-- HANGUL SYLLABLE GOEJ -->
+      <map code="0xad4b" name="1em"/><!-- HANGUL SYLLABLE GOEC -->
+      <map code="0xad4c" name="1em"/><!-- HANGUL SYLLABLE GOEK -->
+      <map code="0xad4d" name="1em"/><!-- HANGUL SYLLABLE GOET -->
+      <map code="0xad4e" name="1em"/><!-- HANGUL SYLLABLE GOEP -->
+      <map code="0xad4f" name="1em"/><!-- HANGUL SYLLABLE GOEH -->
+      <map code="0xad50" name="1em"/><!-- HANGUL SYLLABLE GYO -->
+      <map code="0xad51" name="1em"/><!-- HANGUL SYLLABLE GYOG -->
+      <map code="0xad52" name="1em"/><!-- HANGUL SYLLABLE GYOGG -->
+      <map code="0xad53" name="1em"/><!-- HANGUL SYLLABLE GYOGS -->
+      <map code="0xad54" name="1em"/><!-- HANGUL SYLLABLE GYON -->
+      <map code="0xad55" name="1em"/><!-- HANGUL SYLLABLE GYONJ -->
+      <map code="0xad56" name="1em"/><!-- HANGUL SYLLABLE GYONH -->
+      <map code="0xad57" name="1em"/><!-- HANGUL SYLLABLE GYOD -->
+      <map code="0xad58" name="1em"/><!-- HANGUL SYLLABLE GYOL -->
+      <map code="0xad59" name="1em"/><!-- HANGUL SYLLABLE GYOLG -->
+      <map code="0xad5a" name="1em"/><!-- HANGUL SYLLABLE GYOLM -->
+      <map code="0xad5b" name="1em"/><!-- HANGUL SYLLABLE GYOLB -->
+      <map code="0xad5c" name="1em"/><!-- HANGUL SYLLABLE GYOLS -->
+      <map code="0xad5d" name="1em"/><!-- HANGUL SYLLABLE GYOLT -->
+      <map code="0xad5e" name="1em"/><!-- HANGUL SYLLABLE GYOLP -->
+      <map code="0xad5f" name="1em"/><!-- HANGUL SYLLABLE GYOLH -->
+      <map code="0xad60" name="1em"/><!-- HANGUL SYLLABLE GYOM -->
+      <map code="0xad61" name="1em"/><!-- HANGUL SYLLABLE GYOB -->
+      <map code="0xad62" name="1em"/><!-- HANGUL SYLLABLE GYOBS -->
+      <map code="0xad63" name="1em"/><!-- HANGUL SYLLABLE GYOS -->
+      <map code="0xad64" name="1em"/><!-- HANGUL SYLLABLE GYOSS -->
+      <map code="0xad65" name="1em"/><!-- HANGUL SYLLABLE GYONG -->
+      <map code="0xad66" name="1em"/><!-- HANGUL SYLLABLE GYOJ -->
+      <map code="0xad67" name="1em"/><!-- HANGUL SYLLABLE GYOC -->
+      <map code="0xad68" name="1em"/><!-- HANGUL SYLLABLE GYOK -->
+      <map code="0xad69" name="1em"/><!-- HANGUL SYLLABLE GYOT -->
+      <map code="0xad6a" name="1em"/><!-- HANGUL SYLLABLE GYOP -->
+      <map code="0xad6b" name="1em"/><!-- HANGUL SYLLABLE GYOH -->
+      <map code="0xad6c" name="1em"/><!-- HANGUL SYLLABLE GU -->
+      <map code="0xad6d" name="1em"/><!-- HANGUL SYLLABLE GUG -->
+      <map code="0xad6e" name="1em"/><!-- HANGUL SYLLABLE GUGG -->
+      <map code="0xad6f" name="1em"/><!-- HANGUL SYLLABLE GUGS -->
+      <map code="0xad70" name="1em"/><!-- HANGUL SYLLABLE GUN -->
+      <map code="0xad71" name="1em"/><!-- HANGUL SYLLABLE GUNJ -->
+      <map code="0xad72" name="1em"/><!-- HANGUL SYLLABLE GUNH -->
+      <map code="0xad73" name="1em"/><!-- HANGUL SYLLABLE GUD -->
+      <map code="0xad74" name="1em"/><!-- HANGUL SYLLABLE GUL -->
+      <map code="0xad75" name="1em"/><!-- HANGUL SYLLABLE GULG -->
+      <map code="0xad76" name="1em"/><!-- HANGUL SYLLABLE GULM -->
+      <map code="0xad77" name="1em"/><!-- HANGUL SYLLABLE GULB -->
+      <map code="0xad78" name="1em"/><!-- HANGUL SYLLABLE GULS -->
+      <map code="0xad79" name="1em"/><!-- HANGUL SYLLABLE GULT -->
+      <map code="0xad7a" name="1em"/><!-- HANGUL SYLLABLE GULP -->
+      <map code="0xad7b" name="1em"/><!-- HANGUL SYLLABLE GULH -->
+      <map code="0xad7c" name="1em"/><!-- HANGUL SYLLABLE GUM -->
+      <map code="0xad7d" name="1em"/><!-- HANGUL SYLLABLE GUB -->
+      <map code="0xad7e" name="1em"/><!-- HANGUL SYLLABLE GUBS -->
+      <map code="0xad7f" name="1em"/><!-- HANGUL SYLLABLE GUS -->
+      <map code="0xad80" name="1em"/><!-- HANGUL SYLLABLE GUSS -->
+      <map code="0xad81" name="1em"/><!-- HANGUL SYLLABLE GUNG -->
+      <map code="0xad82" name="1em"/><!-- HANGUL SYLLABLE GUJ -->
+      <map code="0xad83" name="1em"/><!-- HANGUL SYLLABLE GUC -->
+      <map code="0xad84" name="1em"/><!-- HANGUL SYLLABLE GUK -->
+      <map code="0xad85" name="1em"/><!-- HANGUL SYLLABLE GUT -->
+      <map code="0xad86" name="1em"/><!-- HANGUL SYLLABLE GUP -->
+      <map code="0xad87" name="1em"/><!-- HANGUL SYLLABLE GUH -->
+      <map code="0xad88" name="1em"/><!-- HANGUL SYLLABLE GWEO -->
+      <map code="0xad89" name="1em"/><!-- HANGUL SYLLABLE GWEOG -->
+      <map code="0xad8a" name="1em"/><!-- HANGUL SYLLABLE GWEOGG -->
+      <map code="0xad8b" name="1em"/><!-- HANGUL SYLLABLE GWEOGS -->
+      <map code="0xad8c" name="1em"/><!-- HANGUL SYLLABLE GWEON -->
+      <map code="0xad8d" name="1em"/><!-- HANGUL SYLLABLE GWEONJ -->
+      <map code="0xad8e" name="1em"/><!-- HANGUL SYLLABLE GWEONH -->
+      <map code="0xad8f" name="1em"/><!-- HANGUL SYLLABLE GWEOD -->
+      <map code="0xad90" name="1em"/><!-- HANGUL SYLLABLE GWEOL -->
+      <map code="0xad91" name="1em"/><!-- HANGUL SYLLABLE GWEOLG -->
+      <map code="0xad92" name="1em"/><!-- HANGUL SYLLABLE GWEOLM -->
+      <map code="0xad93" name="1em"/><!-- HANGUL SYLLABLE GWEOLB -->
+      <map code="0xad94" name="1em"/><!-- HANGUL SYLLABLE GWEOLS -->
+      <map code="0xad95" name="1em"/><!-- HANGUL SYLLABLE GWEOLT -->
+      <map code="0xad96" name="1em"/><!-- HANGUL SYLLABLE GWEOLP -->
+      <map code="0xad97" name="1em"/><!-- HANGUL SYLLABLE GWEOLH -->
+      <map code="0xad98" name="1em"/><!-- HANGUL SYLLABLE GWEOM -->
+      <map code="0xad99" name="1em"/><!-- HANGUL SYLLABLE GWEOB -->
+      <map code="0xad9a" name="1em"/><!-- HANGUL SYLLABLE GWEOBS -->
+      <map code="0xad9b" name="1em"/><!-- HANGUL SYLLABLE GWEOS -->
+      <map code="0xad9c" name="1em"/><!-- HANGUL SYLLABLE GWEOSS -->
+      <map code="0xad9d" name="1em"/><!-- HANGUL SYLLABLE GWEONG -->
+      <map code="0xad9e" name="1em"/><!-- HANGUL SYLLABLE GWEOJ -->
+      <map code="0xad9f" name="1em"/><!-- HANGUL SYLLABLE GWEOC -->
+      <map code="0xada0" name="1em"/><!-- HANGUL SYLLABLE GWEOK -->
+      <map code="0xada1" name="1em"/><!-- HANGUL SYLLABLE GWEOT -->
+      <map code="0xada2" name="1em"/><!-- HANGUL SYLLABLE GWEOP -->
+      <map code="0xada3" name="1em"/><!-- HANGUL SYLLABLE GWEOH -->
+      <map code="0xada4" name="1em"/><!-- HANGUL SYLLABLE GWE -->
+      <map code="0xada5" name="1em"/><!-- HANGUL SYLLABLE GWEG -->
+      <map code="0xada6" name="1em"/><!-- HANGUL SYLLABLE GWEGG -->
+      <map code="0xada7" name="1em"/><!-- HANGUL SYLLABLE GWEGS -->
+      <map code="0xada8" name="1em"/><!-- HANGUL SYLLABLE GWEN -->
+      <map code="0xada9" name="1em"/><!-- HANGUL SYLLABLE GWENJ -->
+      <map code="0xadaa" name="1em"/><!-- HANGUL SYLLABLE GWENH -->
+      <map code="0xadab" name="1em"/><!-- HANGUL SYLLABLE GWED -->
+      <map code="0xadac" name="1em"/><!-- HANGUL SYLLABLE GWEL -->
+      <map code="0xadad" name="1em"/><!-- HANGUL SYLLABLE GWELG -->
+      <map code="0xadae" name="1em"/><!-- HANGUL SYLLABLE GWELM -->
+      <map code="0xadaf" name="1em"/><!-- HANGUL SYLLABLE GWELB -->
+      <map code="0xadb0" name="1em"/><!-- HANGUL SYLLABLE GWELS -->
+      <map code="0xadb1" name="1em"/><!-- HANGUL SYLLABLE GWELT -->
+      <map code="0xadb2" name="1em"/><!-- HANGUL SYLLABLE GWELP -->
+      <map code="0xadb3" name="1em"/><!-- HANGUL SYLLABLE GWELH -->
+      <map code="0xadb4" name="1em"/><!-- HANGUL SYLLABLE GWEM -->
+      <map code="0xadb5" name="1em"/><!-- HANGUL SYLLABLE GWEB -->
+      <map code="0xadb6" name="1em"/><!-- HANGUL SYLLABLE GWEBS -->
+      <map code="0xadb7" name="1em"/><!-- HANGUL SYLLABLE GWES -->
+      <map code="0xadb8" name="1em"/><!-- HANGUL SYLLABLE GWESS -->
+      <map code="0xadb9" name="1em"/><!-- HANGUL SYLLABLE GWENG -->
+      <map code="0xadba" name="1em"/><!-- HANGUL SYLLABLE GWEJ -->
+      <map code="0xadbb" name="1em"/><!-- HANGUL SYLLABLE GWEC -->
+      <map code="0xadbc" name="1em"/><!-- HANGUL SYLLABLE GWEK -->
+      <map code="0xadbd" name="1em"/><!-- HANGUL SYLLABLE GWET -->
+      <map code="0xadbe" name="1em"/><!-- HANGUL SYLLABLE GWEP -->
+      <map code="0xadbf" name="1em"/><!-- HANGUL SYLLABLE GWEH -->
+      <map code="0xadc0" name="1em"/><!-- HANGUL SYLLABLE GWI -->
+      <map code="0xadc1" name="1em"/><!-- HANGUL SYLLABLE GWIG -->
+      <map code="0xadc2" name="1em"/><!-- HANGUL SYLLABLE GWIGG -->
+      <map code="0xadc3" name="1em"/><!-- HANGUL SYLLABLE GWIGS -->
+      <map code="0xadc4" name="1em"/><!-- HANGUL SYLLABLE GWIN -->
+      <map code="0xadc5" name="1em"/><!-- HANGUL SYLLABLE GWINJ -->
+      <map code="0xadc6" name="1em"/><!-- HANGUL SYLLABLE GWINH -->
+      <map code="0xadc7" name="1em"/><!-- HANGUL SYLLABLE GWID -->
+      <map code="0xadc8" name="1em"/><!-- HANGUL SYLLABLE GWIL -->
+      <map code="0xadc9" name="1em"/><!-- HANGUL SYLLABLE GWILG -->
+      <map code="0xadca" name="1em"/><!-- HANGUL SYLLABLE GWILM -->
+      <map code="0xadcb" name="1em"/><!-- HANGUL SYLLABLE GWILB -->
+      <map code="0xadcc" name="1em"/><!-- HANGUL SYLLABLE GWILS -->
+      <map code="0xadcd" name="1em"/><!-- HANGUL SYLLABLE GWILT -->
+      <map code="0xadce" name="1em"/><!-- HANGUL SYLLABLE GWILP -->
+      <map code="0xadcf" name="1em"/><!-- HANGUL SYLLABLE GWILH -->
+      <map code="0xadd0" name="1em"/><!-- HANGUL SYLLABLE GWIM -->
+      <map code="0xadd1" name="1em"/><!-- HANGUL SYLLABLE GWIB -->
+      <map code="0xadd2" name="1em"/><!-- HANGUL SYLLABLE GWIBS -->
+      <map code="0xadd3" name="1em"/><!-- HANGUL SYLLABLE GWIS -->
+      <map code="0xadd4" name="1em"/><!-- HANGUL SYLLABLE GWISS -->
+      <map code="0xadd5" name="1em"/><!-- HANGUL SYLLABLE GWING -->
+      <map code="0xadd6" name="1em"/><!-- HANGUL SYLLABLE GWIJ -->
+      <map code="0xadd7" name="1em"/><!-- HANGUL SYLLABLE GWIC -->
+      <map code="0xadd8" name="1em"/><!-- HANGUL SYLLABLE GWIK -->
+      <map code="0xadd9" name="1em"/><!-- HANGUL SYLLABLE GWIT -->
+      <map code="0xadda" name="1em"/><!-- HANGUL SYLLABLE GWIP -->
+      <map code="0xaddb" name="1em"/><!-- HANGUL SYLLABLE GWIH -->
+      <map code="0xaddc" name="1em"/><!-- HANGUL SYLLABLE GYU -->
+      <map code="0xaddd" name="1em"/><!-- HANGUL SYLLABLE GYUG -->
+      <map code="0xadde" name="1em"/><!-- HANGUL SYLLABLE GYUGG -->
+      <map code="0xaddf" name="1em"/><!-- HANGUL SYLLABLE GYUGS -->
+      <map code="0xade0" name="1em"/><!-- HANGUL SYLLABLE GYUN -->
+      <map code="0xade1" name="1em"/><!-- HANGUL SYLLABLE GYUNJ -->
+      <map code="0xade2" name="1em"/><!-- HANGUL SYLLABLE GYUNH -->
+      <map code="0xade3" name="1em"/><!-- HANGUL SYLLABLE GYUD -->
+      <map code="0xade4" name="1em"/><!-- HANGUL SYLLABLE GYUL -->
+      <map code="0xade5" name="1em"/><!-- HANGUL SYLLABLE GYULG -->
+      <map code="0xade6" name="1em"/><!-- HANGUL SYLLABLE GYULM -->
+      <map code="0xade7" name="1em"/><!-- HANGUL SYLLABLE GYULB -->
+      <map code="0xade8" name="1em"/><!-- HANGUL SYLLABLE GYULS -->
+      <map code="0xade9" name="1em"/><!-- HANGUL SYLLABLE GYULT -->
+      <map code="0xadea" name="1em"/><!-- HANGUL SYLLABLE GYULP -->
+      <map code="0xadeb" name="1em"/><!-- HANGUL SYLLABLE GYULH -->
+      <map code="0xadec" name="1em"/><!-- HANGUL SYLLABLE GYUM -->
+      <map code="0xaded" name="1em"/><!-- HANGUL SYLLABLE GYUB -->
+      <map code="0xadee" name="1em"/><!-- HANGUL SYLLABLE GYUBS -->
+      <map code="0xadef" name="1em"/><!-- HANGUL SYLLABLE GYUS -->
+      <map code="0xadf0" name="1em"/><!-- HANGUL SYLLABLE GYUSS -->
+      <map code="0xadf1" name="1em"/><!-- HANGUL SYLLABLE GYUNG -->
+      <map code="0xadf2" name="1em"/><!-- HANGUL SYLLABLE GYUJ -->
+      <map code="0xadf3" name="1em"/><!-- HANGUL SYLLABLE GYUC -->
+      <map code="0xadf4" name="1em"/><!-- HANGUL SYLLABLE GYUK -->
+      <map code="0xadf5" name="1em"/><!-- HANGUL SYLLABLE GYUT -->
+      <map code="0xadf6" name="1em"/><!-- HANGUL SYLLABLE GYUP -->
+      <map code="0xadf7" name="1em"/><!-- HANGUL SYLLABLE GYUH -->
+      <map code="0xadf8" name="1em"/><!-- HANGUL SYLLABLE GEU -->
+      <map code="0xadf9" name="1em"/><!-- HANGUL SYLLABLE GEUG -->
+      <map code="0xadfa" name="1em"/><!-- HANGUL SYLLABLE GEUGG -->
+      <map code="0xadfb" name="1em"/><!-- HANGUL SYLLABLE GEUGS -->
+      <map code="0xadfc" name="1em"/><!-- HANGUL SYLLABLE GEUN -->
+      <map code="0xadfd" name="1em"/><!-- HANGUL SYLLABLE GEUNJ -->
+      <map code="0xadfe" name="1em"/><!-- HANGUL SYLLABLE GEUNH -->
+      <map code="0xadff" name="1em"/><!-- HANGUL SYLLABLE GEUD -->
+      <map code="0xae00" name="1em"/><!-- HANGUL SYLLABLE GEUL -->
+      <map code="0xae01" name="1em"/><!-- HANGUL SYLLABLE GEULG -->
+      <map code="0xae02" name="1em"/><!-- HANGUL SYLLABLE GEULM -->
+      <map code="0xae03" name="1em"/><!-- HANGUL SYLLABLE GEULB -->
+      <map code="0xae04" name="1em"/><!-- HANGUL SYLLABLE GEULS -->
+      <map code="0xae05" name="1em"/><!-- HANGUL SYLLABLE GEULT -->
+      <map code="0xae06" name="1em"/><!-- HANGUL SYLLABLE GEULP -->
+      <map code="0xae07" name="1em"/><!-- HANGUL SYLLABLE GEULH -->
+      <map code="0xae08" name="1em"/><!-- HANGUL SYLLABLE GEUM -->
+      <map code="0xae09" name="1em"/><!-- HANGUL SYLLABLE GEUB -->
+      <map code="0xae0a" name="1em"/><!-- HANGUL SYLLABLE GEUBS -->
+      <map code="0xae0b" name="1em"/><!-- HANGUL SYLLABLE GEUS -->
+      <map code="0xae0c" name="1em"/><!-- HANGUL SYLLABLE GEUSS -->
+      <map code="0xae0d" name="1em"/><!-- HANGUL SYLLABLE GEUNG -->
+      <map code="0xae0e" name="1em"/><!-- HANGUL SYLLABLE GEUJ -->
+      <map code="0xae0f" name="1em"/><!-- HANGUL SYLLABLE GEUC -->
+      <map code="0xae10" name="1em"/><!-- HANGUL SYLLABLE GEUK -->
+      <map code="0xae11" name="1em"/><!-- HANGUL SYLLABLE GEUT -->
+      <map code="0xae12" name="1em"/><!-- HANGUL SYLLABLE GEUP -->
+      <map code="0xae13" name="1em"/><!-- HANGUL SYLLABLE GEUH -->
+      <map code="0xae14" name="1em"/><!-- HANGUL SYLLABLE GYI -->
+      <map code="0xae15" name="1em"/><!-- HANGUL SYLLABLE GYIG -->
+      <map code="0xae16" name="1em"/><!-- HANGUL SYLLABLE GYIGG -->
+      <map code="0xae17" name="1em"/><!-- HANGUL SYLLABLE GYIGS -->
+      <map code="0xae18" name="1em"/><!-- HANGUL SYLLABLE GYIN -->
+      <map code="0xae19" name="1em"/><!-- HANGUL SYLLABLE GYINJ -->
+      <map code="0xae1a" name="1em"/><!-- HANGUL SYLLABLE GYINH -->
+      <map code="0xae1b" name="1em"/><!-- HANGUL SYLLABLE GYID -->
+      <map code="0xae1c" name="1em"/><!-- HANGUL SYLLABLE GYIL -->
+      <map code="0xae1d" name="1em"/><!-- HANGUL SYLLABLE GYILG -->
+      <map code="0xae1e" name="1em"/><!-- HANGUL SYLLABLE GYILM -->
+      <map code="0xae1f" name="1em"/><!-- HANGUL SYLLABLE GYILB -->
+      <map code="0xae20" name="1em"/><!-- HANGUL SYLLABLE GYILS -->
+      <map code="0xae21" name="1em"/><!-- HANGUL SYLLABLE GYILT -->
+      <map code="0xae22" name="1em"/><!-- HANGUL SYLLABLE GYILP -->
+      <map code="0xae23" name="1em"/><!-- HANGUL SYLLABLE GYILH -->
+      <map code="0xae24" name="1em"/><!-- HANGUL SYLLABLE GYIM -->
+      <map code="0xae25" name="1em"/><!-- HANGUL SYLLABLE GYIB -->
+      <map code="0xae26" name="1em"/><!-- HANGUL SYLLABLE GYIBS -->
+      <map code="0xae27" name="1em"/><!-- HANGUL SYLLABLE GYIS -->
+      <map code="0xae28" name="1em"/><!-- HANGUL SYLLABLE GYISS -->
+      <map code="0xae29" name="1em"/><!-- HANGUL SYLLABLE GYING -->
+      <map code="0xae2a" name="1em"/><!-- HANGUL SYLLABLE GYIJ -->
+      <map code="0xae2b" name="1em"/><!-- HANGUL SYLLABLE GYIC -->
+      <map code="0xae2c" name="1em"/><!-- HANGUL SYLLABLE GYIK -->
+      <map code="0xae2d" name="1em"/><!-- HANGUL SYLLABLE GYIT -->
+      <map code="0xae2e" name="1em"/><!-- HANGUL SYLLABLE GYIP -->
+      <map code="0xae2f" name="1em"/><!-- HANGUL SYLLABLE GYIH -->
+      <map code="0xae30" name="1em"/><!-- HANGUL SYLLABLE GI -->
+      <map code="0xae31" name="1em"/><!-- HANGUL SYLLABLE GIG -->
+      <map code="0xae32" name="1em"/><!-- HANGUL SYLLABLE GIGG -->
+      <map code="0xae33" name="1em"/><!-- HANGUL SYLLABLE GIGS -->
+      <map code="0xae34" name="1em"/><!-- HANGUL SYLLABLE GIN -->
+      <map code="0xae35" name="1em"/><!-- HANGUL SYLLABLE GINJ -->
+      <map code="0xae36" name="1em"/><!-- HANGUL SYLLABLE GINH -->
+      <map code="0xae37" name="1em"/><!-- HANGUL SYLLABLE GID -->
+      <map code="0xae38" name="1em"/><!-- HANGUL SYLLABLE GIL -->
+      <map code="0xae39" name="1em"/><!-- HANGUL SYLLABLE GILG -->
+      <map code="0xae3a" name="1em"/><!-- HANGUL SYLLABLE GILM -->
+      <map code="0xae3b" name="1em"/><!-- HANGUL SYLLABLE GILB -->
+      <map code="0xae3c" name="1em"/><!-- HANGUL SYLLABLE GILS -->
+      <map code="0xae3d" name="1em"/><!-- HANGUL SYLLABLE GILT -->
+      <map code="0xae3e" name="1em"/><!-- HANGUL SYLLABLE GILP -->
+      <map code="0xae3f" name="1em"/><!-- HANGUL SYLLABLE GILH -->
+      <map code="0xae40" name="1em"/><!-- HANGUL SYLLABLE GIM -->
+      <map code="0xae41" name="1em"/><!-- HANGUL SYLLABLE GIB -->
+      <map code="0xae42" name="1em"/><!-- HANGUL SYLLABLE GIBS -->
+      <map code="0xae43" name="1em"/><!-- HANGUL SYLLABLE GIS -->
+      <map code="0xae44" name="1em"/><!-- HANGUL SYLLABLE GISS -->
+      <map code="0xae45" name="1em"/><!-- HANGUL SYLLABLE GING -->
+      <map code="0xae46" name="1em"/><!-- HANGUL SYLLABLE GIJ -->
+      <map code="0xae47" name="1em"/><!-- HANGUL SYLLABLE GIC -->
+      <map code="0xae48" name="1em"/><!-- HANGUL SYLLABLE GIK -->
+      <map code="0xae49" name="1em"/><!-- HANGUL SYLLABLE GIT -->
+      <map code="0xae4a" name="1em"/><!-- HANGUL SYLLABLE GIP -->
+      <map code="0xae4b" name="1em"/><!-- HANGUL SYLLABLE GIH -->
+      <map code="0xae4c" name="1em"/><!-- HANGUL SYLLABLE GGA -->
+      <map code="0xae4d" name="1em"/><!-- HANGUL SYLLABLE GGAG -->
+      <map code="0xae4e" name="1em"/><!-- HANGUL SYLLABLE GGAGG -->
+      <map code="0xae4f" name="1em"/><!-- HANGUL SYLLABLE GGAGS -->
+      <map code="0xae50" name="1em"/><!-- HANGUL SYLLABLE GGAN -->
+      <map code="0xae51" name="1em"/><!-- HANGUL SYLLABLE GGANJ -->
+      <map code="0xae52" name="1em"/><!-- HANGUL SYLLABLE GGANH -->
+      <map code="0xae53" name="1em"/><!-- HANGUL SYLLABLE GGAD -->
+      <map code="0xae54" name="1em"/><!-- HANGUL SYLLABLE GGAL -->
+      <map code="0xae55" name="1em"/><!-- HANGUL SYLLABLE GGALG -->
+      <map code="0xae56" name="1em"/><!-- HANGUL SYLLABLE GGALM -->
+      <map code="0xae57" name="1em"/><!-- HANGUL SYLLABLE GGALB -->
+      <map code="0xae58" name="1em"/><!-- HANGUL SYLLABLE GGALS -->
+      <map code="0xae59" name="1em"/><!-- HANGUL SYLLABLE GGALT -->
+      <map code="0xae5a" name="1em"/><!-- HANGUL SYLLABLE GGALP -->
+      <map code="0xae5b" name="1em"/><!-- HANGUL SYLLABLE GGALH -->
+      <map code="0xae5c" name="1em"/><!-- HANGUL SYLLABLE GGAM -->
+      <map code="0xae5d" name="1em"/><!-- HANGUL SYLLABLE GGAB -->
+      <map code="0xae5e" name="1em"/><!-- HANGUL SYLLABLE GGABS -->
+      <map code="0xae5f" name="1em"/><!-- HANGUL SYLLABLE GGAS -->
+      <map code="0xae60" name="1em"/><!-- HANGUL SYLLABLE GGASS -->
+      <map code="0xae61" name="1em"/><!-- HANGUL SYLLABLE GGANG -->
+      <map code="0xae62" name="1em"/><!-- HANGUL SYLLABLE GGAJ -->
+      <map code="0xae63" name="1em"/><!-- HANGUL SYLLABLE GGAC -->
+      <map code="0xae64" name="1em"/><!-- HANGUL SYLLABLE GGAK -->
+      <map code="0xae65" name="1em"/><!-- HANGUL SYLLABLE GGAT -->
+      <map code="0xae66" name="1em"/><!-- HANGUL SYLLABLE GGAP -->
+      <map code="0xae67" name="1em"/><!-- HANGUL SYLLABLE GGAH -->
+      <map code="0xae68" name="1em"/><!-- HANGUL SYLLABLE GGAE -->
+      <map code="0xae69" name="1em"/><!-- HANGUL SYLLABLE GGAEG -->
+      <map code="0xae6a" name="1em"/><!-- HANGUL SYLLABLE GGAEGG -->
+      <map code="0xae6b" name="1em"/><!-- HANGUL SYLLABLE GGAEGS -->
+      <map code="0xae6c" name="1em"/><!-- HANGUL SYLLABLE GGAEN -->
+      <map code="0xae6d" name="1em"/><!-- HANGUL SYLLABLE GGAENJ -->
+      <map code="0xae6e" name="1em"/><!-- HANGUL SYLLABLE GGAENH -->
+      <map code="0xae6f" name="1em"/><!-- HANGUL SYLLABLE GGAED -->
+      <map code="0xae70" name="1em"/><!-- HANGUL SYLLABLE GGAEL -->
+      <map code="0xae71" name="1em"/><!-- HANGUL SYLLABLE GGAELG -->
+      <map code="0xae72" name="1em"/><!-- HANGUL SYLLABLE GGAELM -->
+      <map code="0xae73" name="1em"/><!-- HANGUL SYLLABLE GGAELB -->
+      <map code="0xae74" name="1em"/><!-- HANGUL SYLLABLE GGAELS -->
+      <map code="0xae75" name="1em"/><!-- HANGUL SYLLABLE GGAELT -->
+      <map code="0xae76" name="1em"/><!-- HANGUL SYLLABLE GGAELP -->
+      <map code="0xae77" name="1em"/><!-- HANGUL SYLLABLE GGAELH -->
+      <map code="0xae78" name="1em"/><!-- HANGUL SYLLABLE GGAEM -->
+      <map code="0xae79" name="1em"/><!-- HANGUL SYLLABLE GGAEB -->
+      <map code="0xae7a" name="1em"/><!-- HANGUL SYLLABLE GGAEBS -->
+      <map code="0xae7b" name="1em"/><!-- HANGUL SYLLABLE GGAES -->
+      <map code="0xae7c" name="1em"/><!-- HANGUL SYLLABLE GGAESS -->
+      <map code="0xae7d" name="1em"/><!-- HANGUL SYLLABLE GGAENG -->
+      <map code="0xae7e" name="1em"/><!-- HANGUL SYLLABLE GGAEJ -->
+      <map code="0xae7f" name="1em"/><!-- HANGUL SYLLABLE GGAEC -->
+      <map code="0xae80" name="1em"/><!-- HANGUL SYLLABLE GGAEK -->
+      <map code="0xae81" name="1em"/><!-- HANGUL SYLLABLE GGAET -->
+      <map code="0xae82" name="1em"/><!-- HANGUL SYLLABLE GGAEP -->
+      <map code="0xae83" name="1em"/><!-- HANGUL SYLLABLE GGAEH -->
+      <map code="0xae84" name="1em"/><!-- HANGUL SYLLABLE GGYA -->
+      <map code="0xae85" name="1em"/><!-- HANGUL SYLLABLE GGYAG -->
+      <map code="0xae86" name="1em"/><!-- HANGUL SYLLABLE GGYAGG -->
+      <map code="0xae87" name="1em"/><!-- HANGUL SYLLABLE GGYAGS -->
+      <map code="0xae88" name="1em"/><!-- HANGUL SYLLABLE GGYAN -->
+      <map code="0xae89" name="1em"/><!-- HANGUL SYLLABLE GGYANJ -->
+      <map code="0xae8a" name="1em"/><!-- HANGUL SYLLABLE GGYANH -->
+      <map code="0xae8b" name="1em"/><!-- HANGUL SYLLABLE GGYAD -->
+      <map code="0xae8c" name="1em"/><!-- HANGUL SYLLABLE GGYAL -->
+      <map code="0xae8d" name="1em"/><!-- HANGUL SYLLABLE GGYALG -->
+      <map code="0xae8e" name="1em"/><!-- HANGUL SYLLABLE GGYALM -->
+      <map code="0xae8f" name="1em"/><!-- HANGUL SYLLABLE GGYALB -->
+      <map code="0xae90" name="1em"/><!-- HANGUL SYLLABLE GGYALS -->
+      <map code="0xae91" name="1em"/><!-- HANGUL SYLLABLE GGYALT -->
+      <map code="0xae92" name="1em"/><!-- HANGUL SYLLABLE GGYALP -->
+      <map code="0xae93" name="1em"/><!-- HANGUL SYLLABLE GGYALH -->
+      <map code="0xae94" name="1em"/><!-- HANGUL SYLLABLE GGYAM -->
+      <map code="0xae95" name="1em"/><!-- HANGUL SYLLABLE GGYAB -->
+      <map code="0xae96" name="1em"/><!-- HANGUL SYLLABLE GGYABS -->
+      <map code="0xae97" name="1em"/><!-- HANGUL SYLLABLE GGYAS -->
+      <map code="0xae98" name="1em"/><!-- HANGUL SYLLABLE GGYASS -->
+      <map code="0xae99" name="1em"/><!-- HANGUL SYLLABLE GGYANG -->
+      <map code="0xae9a" name="1em"/><!-- HANGUL SYLLABLE GGYAJ -->
+      <map code="0xae9b" name="1em"/><!-- HANGUL SYLLABLE GGYAC -->
+      <map code="0xae9c" name="1em"/><!-- HANGUL SYLLABLE GGYAK -->
+      <map code="0xae9d" name="1em"/><!-- HANGUL SYLLABLE GGYAT -->
+      <map code="0xae9e" name="1em"/><!-- HANGUL SYLLABLE GGYAP -->
+      <map code="0xae9f" name="1em"/><!-- HANGUL SYLLABLE GGYAH -->
+      <map code="0xaea0" name="1em"/><!-- HANGUL SYLLABLE GGYAE -->
+      <map code="0xaea1" name="1em"/><!-- HANGUL SYLLABLE GGYAEG -->
+      <map code="0xaea2" name="1em"/><!-- HANGUL SYLLABLE GGYAEGG -->
+      <map code="0xaea3" name="1em"/><!-- HANGUL SYLLABLE GGYAEGS -->
+      <map code="0xaea4" name="1em"/><!-- HANGUL SYLLABLE GGYAEN -->
+      <map code="0xaea5" name="1em"/><!-- HANGUL SYLLABLE GGYAENJ -->
+      <map code="0xaea6" name="1em"/><!-- HANGUL SYLLABLE GGYAENH -->
+      <map code="0xaea7" name="1em"/><!-- HANGUL SYLLABLE GGYAED -->
+      <map code="0xaea8" name="1em"/><!-- HANGUL SYLLABLE GGYAEL -->
+      <map code="0xaea9" name="1em"/><!-- HANGUL SYLLABLE GGYAELG -->
+      <map code="0xaeaa" name="1em"/><!-- HANGUL SYLLABLE GGYAELM -->
+      <map code="0xaeab" name="1em"/><!-- HANGUL SYLLABLE GGYAELB -->
+      <map code="0xaeac" name="1em"/><!-- HANGUL SYLLABLE GGYAELS -->
+      <map code="0xaead" name="1em"/><!-- HANGUL SYLLABLE GGYAELT -->
+      <map code="0xaeae" name="1em"/><!-- HANGUL SYLLABLE GGYAELP -->
+      <map code="0xaeaf" name="1em"/><!-- HANGUL SYLLABLE GGYAELH -->
+      <map code="0xaeb0" name="1em"/><!-- HANGUL SYLLABLE GGYAEM -->
+      <map code="0xaeb1" name="1em"/><!-- HANGUL SYLLABLE GGYAEB -->
+      <map code="0xaeb2" name="1em"/><!-- HANGUL SYLLABLE GGYAEBS -->
+      <map code="0xaeb3" name="1em"/><!-- HANGUL SYLLABLE GGYAES -->
+      <map code="0xaeb4" name="1em"/><!-- HANGUL SYLLABLE GGYAESS -->
+      <map code="0xaeb5" name="1em"/><!-- HANGUL SYLLABLE GGYAENG -->
+      <map code="0xaeb6" name="1em"/><!-- HANGUL SYLLABLE GGYAEJ -->
+      <map code="0xaeb7" name="1em"/><!-- HANGUL SYLLABLE GGYAEC -->
+      <map code="0xaeb8" name="1em"/><!-- HANGUL SYLLABLE GGYAEK -->
+      <map code="0xaeb9" name="1em"/><!-- HANGUL SYLLABLE GGYAET -->
+      <map code="0xaeba" name="1em"/><!-- HANGUL SYLLABLE GGYAEP -->
+      <map code="0xaebb" name="1em"/><!-- HANGUL SYLLABLE GGYAEH -->
+      <map code="0xaebc" name="1em"/><!-- HANGUL SYLLABLE GGEO -->
+      <map code="0xaebd" name="1em"/><!-- HANGUL SYLLABLE GGEOG -->
+      <map code="0xaebe" name="1em"/><!-- HANGUL SYLLABLE GGEOGG -->
+      <map code="0xaebf" name="1em"/><!-- HANGUL SYLLABLE GGEOGS -->
+      <map code="0xaec0" name="1em"/><!-- HANGUL SYLLABLE GGEON -->
+      <map code="0xaec1" name="1em"/><!-- HANGUL SYLLABLE GGEONJ -->
+      <map code="0xaec2" name="1em"/><!-- HANGUL SYLLABLE GGEONH -->
+      <map code="0xaec3" name="1em"/><!-- HANGUL SYLLABLE GGEOD -->
+      <map code="0xaec4" name="1em"/><!-- HANGUL SYLLABLE GGEOL -->
+      <map code="0xaec5" name="1em"/><!-- HANGUL SYLLABLE GGEOLG -->
+      <map code="0xaec6" name="1em"/><!-- HANGUL SYLLABLE GGEOLM -->
+      <map code="0xaec7" name="1em"/><!-- HANGUL SYLLABLE GGEOLB -->
+      <map code="0xaec8" name="1em"/><!-- HANGUL SYLLABLE GGEOLS -->
+      <map code="0xaec9" name="1em"/><!-- HANGUL SYLLABLE GGEOLT -->
+      <map code="0xaeca" name="1em"/><!-- HANGUL SYLLABLE GGEOLP -->
+      <map code="0xaecb" name="1em"/><!-- HANGUL SYLLABLE GGEOLH -->
+      <map code="0xaecc" name="1em"/><!-- HANGUL SYLLABLE GGEOM -->
+      <map code="0xaecd" name="1em"/><!-- HANGUL SYLLABLE GGEOB -->
+      <map code="0xaece" name="1em"/><!-- HANGUL SYLLABLE GGEOBS -->
+      <map code="0xaecf" name="1em"/><!-- HANGUL SYLLABLE GGEOS -->
+      <map code="0xaed0" name="1em"/><!-- HANGUL SYLLABLE GGEOSS -->
+      <map code="0xaed1" name="1em"/><!-- HANGUL SYLLABLE GGEONG -->
+      <map code="0xaed2" name="1em"/><!-- HANGUL SYLLABLE GGEOJ -->
+      <map code="0xaed3" name="1em"/><!-- HANGUL SYLLABLE GGEOC -->
+      <map code="0xaed4" name="1em"/><!-- HANGUL SYLLABLE GGEOK -->
+      <map code="0xaed5" name="1em"/><!-- HANGUL SYLLABLE GGEOT -->
+      <map code="0xaed6" name="1em"/><!-- HANGUL SYLLABLE GGEOP -->
+      <map code="0xaed7" name="1em"/><!-- HANGUL SYLLABLE GGEOH -->
+      <map code="0xaed8" name="1em"/><!-- HANGUL SYLLABLE GGE -->
+      <map code="0xaed9" name="1em"/><!-- HANGUL SYLLABLE GGEG -->
+      <map code="0xaeda" name="1em"/><!-- HANGUL SYLLABLE GGEGG -->
+      <map code="0xaedb" name="1em"/><!-- HANGUL SYLLABLE GGEGS -->
+      <map code="0xaedc" name="1em"/><!-- HANGUL SYLLABLE GGEN -->
+      <map code="0xaedd" name="1em"/><!-- HANGUL SYLLABLE GGENJ -->
+      <map code="0xaede" name="1em"/><!-- HANGUL SYLLABLE GGENH -->
+      <map code="0xaedf" name="1em"/><!-- HANGUL SYLLABLE GGED -->
+      <map code="0xaee0" name="1em"/><!-- HANGUL SYLLABLE GGEL -->
+      <map code="0xaee1" name="1em"/><!-- HANGUL SYLLABLE GGELG -->
+      <map code="0xaee2" name="1em"/><!-- HANGUL SYLLABLE GGELM -->
+      <map code="0xaee3" name="1em"/><!-- HANGUL SYLLABLE GGELB -->
+      <map code="0xaee4" name="1em"/><!-- HANGUL SYLLABLE GGELS -->
+      <map code="0xaee5" name="1em"/><!-- HANGUL SYLLABLE GGELT -->
+      <map code="0xaee6" name="1em"/><!-- HANGUL SYLLABLE GGELP -->
+      <map code="0xaee7" name="1em"/><!-- HANGUL SYLLABLE GGELH -->
+      <map code="0xaee8" name="1em"/><!-- HANGUL SYLLABLE GGEM -->
+      <map code="0xaee9" name="1em"/><!-- HANGUL SYLLABLE GGEB -->
+      <map code="0xaeea" name="1em"/><!-- HANGUL SYLLABLE GGEBS -->
+      <map code="0xaeeb" name="1em"/><!-- HANGUL SYLLABLE GGES -->
+      <map code="0xaeec" name="1em"/><!-- HANGUL SYLLABLE GGESS -->
+      <map code="0xaeed" name="1em"/><!-- HANGUL SYLLABLE GGENG -->
+      <map code="0xaeee" name="1em"/><!-- HANGUL SYLLABLE GGEJ -->
+      <map code="0xaeef" name="1em"/><!-- HANGUL SYLLABLE GGEC -->
+      <map code="0xaef0" name="1em"/><!-- HANGUL SYLLABLE GGEK -->
+      <map code="0xaef1" name="1em"/><!-- HANGUL SYLLABLE GGET -->
+      <map code="0xaef2" name="1em"/><!-- HANGUL SYLLABLE GGEP -->
+      <map code="0xaef3" name="1em"/><!-- HANGUL SYLLABLE GGEH -->
+      <map code="0xaef4" name="1em"/><!-- HANGUL SYLLABLE GGYEO -->
+      <map code="0xaef5" name="1em"/><!-- HANGUL SYLLABLE GGYEOG -->
+      <map code="0xaef6" name="1em"/><!-- HANGUL SYLLABLE GGYEOGG -->
+      <map code="0xaef7" name="1em"/><!-- HANGUL SYLLABLE GGYEOGS -->
+      <map code="0xaef8" name="1em"/><!-- HANGUL SYLLABLE GGYEON -->
+      <map code="0xaef9" name="1em"/><!-- HANGUL SYLLABLE GGYEONJ -->
+      <map code="0xaefa" name="1em"/><!-- HANGUL SYLLABLE GGYEONH -->
+      <map code="0xaefb" name="1em"/><!-- HANGUL SYLLABLE GGYEOD -->
+      <map code="0xaefc" name="1em"/><!-- HANGUL SYLLABLE GGYEOL -->
+      <map code="0xaefd" name="1em"/><!-- HANGUL SYLLABLE GGYEOLG -->
+      <map code="0xaefe" name="1em"/><!-- HANGUL SYLLABLE GGYEOLM -->
+      <map code="0xaeff" name="1em"/><!-- HANGUL SYLLABLE GGYEOLB -->
+      <map code="0xaf00" name="1em"/><!-- HANGUL SYLLABLE GGYEOLS -->
+      <map code="0xaf01" name="1em"/><!-- HANGUL SYLLABLE GGYEOLT -->
+      <map code="0xaf02" name="1em"/><!-- HANGUL SYLLABLE GGYEOLP -->
+      <map code="0xaf03" name="1em"/><!-- HANGUL SYLLABLE GGYEOLH -->
+      <map code="0xaf04" name="1em"/><!-- HANGUL SYLLABLE GGYEOM -->
+      <map code="0xaf05" name="1em"/><!-- HANGUL SYLLABLE GGYEOB -->
+      <map code="0xaf06" name="1em"/><!-- HANGUL SYLLABLE GGYEOBS -->
+      <map code="0xaf07" name="1em"/><!-- HANGUL SYLLABLE GGYEOS -->
+      <map code="0xaf08" name="1em"/><!-- HANGUL SYLLABLE GGYEOSS -->
+      <map code="0xaf09" name="1em"/><!-- HANGUL SYLLABLE GGYEONG -->
+      <map code="0xaf0a" name="1em"/><!-- HANGUL SYLLABLE GGYEOJ -->
+      <map code="0xaf0b" name="1em"/><!-- HANGUL SYLLABLE GGYEOC -->
+      <map code="0xaf0c" name="1em"/><!-- HANGUL SYLLABLE GGYEOK -->
+      <map code="0xaf0d" name="1em"/><!-- HANGUL SYLLABLE GGYEOT -->
+      <map code="0xaf0e" name="1em"/><!-- HANGUL SYLLABLE GGYEOP -->
+      <map code="0xaf0f" name="1em"/><!-- HANGUL SYLLABLE GGYEOH -->
+      <map code="0xaf10" name="1em"/><!-- HANGUL SYLLABLE GGYE -->
+      <map code="0xaf11" name="1em"/><!-- HANGUL SYLLABLE GGYEG -->
+      <map code="0xaf12" name="1em"/><!-- HANGUL SYLLABLE GGYEGG -->
+      <map code="0xaf13" name="1em"/><!-- HANGUL SYLLABLE GGYEGS -->
+      <map code="0xaf14" name="1em"/><!-- HANGUL SYLLABLE GGYEN -->
+      <map code="0xaf15" name="1em"/><!-- HANGUL SYLLABLE GGYENJ -->
+      <map code="0xaf16" name="1em"/><!-- HANGUL SYLLABLE GGYENH -->
+      <map code="0xaf17" name="1em"/><!-- HANGUL SYLLABLE GGYED -->
+      <map code="0xaf18" name="1em"/><!-- HANGUL SYLLABLE GGYEL -->
+      <map code="0xaf19" name="1em"/><!-- HANGUL SYLLABLE GGYELG -->
+      <map code="0xaf1a" name="1em"/><!-- HANGUL SYLLABLE GGYELM -->
+      <map code="0xaf1b" name="1em"/><!-- HANGUL SYLLABLE GGYELB -->
+      <map code="0xaf1c" name="1em"/><!-- HANGUL SYLLABLE GGYELS -->
+      <map code="0xaf1d" name="1em"/><!-- HANGUL SYLLABLE GGYELT -->
+      <map code="0xaf1e" name="1em"/><!-- HANGUL SYLLABLE GGYELP -->
+      <map code="0xaf1f" name="1em"/><!-- HANGUL SYLLABLE GGYELH -->
+      <map code="0xaf20" name="1em"/><!-- HANGUL SYLLABLE GGYEM -->
+      <map code="0xaf21" name="1em"/><!-- HANGUL SYLLABLE GGYEB -->
+      <map code="0xaf22" name="1em"/><!-- HANGUL SYLLABLE GGYEBS -->
+      <map code="0xaf23" name="1em"/><!-- HANGUL SYLLABLE GGYES -->
+      <map code="0xaf24" name="1em"/><!-- HANGUL SYLLABLE GGYESS -->
+      <map code="0xaf25" name="1em"/><!-- HANGUL SYLLABLE GGYENG -->
+      <map code="0xaf26" name="1em"/><!-- HANGUL SYLLABLE GGYEJ -->
+      <map code="0xaf27" name="1em"/><!-- HANGUL SYLLABLE GGYEC -->
+      <map code="0xaf28" name="1em"/><!-- HANGUL SYLLABLE GGYEK -->
+      <map code="0xaf29" name="1em"/><!-- HANGUL SYLLABLE GGYET -->
+      <map code="0xaf2a" name="1em"/><!-- HANGUL SYLLABLE GGYEP -->
+      <map code="0xaf2b" name="1em"/><!-- HANGUL SYLLABLE GGYEH -->
+      <map code="0xaf2c" name="1em"/><!-- HANGUL SYLLABLE GGO -->
+      <map code="0xaf2d" name="1em"/><!-- HANGUL SYLLABLE GGOG -->
+      <map code="0xaf2e" name="1em"/><!-- HANGUL SYLLABLE GGOGG -->
+      <map code="0xaf2f" name="1em"/><!-- HANGUL SYLLABLE GGOGS -->
+      <map code="0xaf30" name="1em"/><!-- HANGUL SYLLABLE GGON -->
+      <map code="0xaf31" name="1em"/><!-- HANGUL SYLLABLE GGONJ -->
+      <map code="0xaf32" name="1em"/><!-- HANGUL SYLLABLE GGONH -->
+      <map code="0xaf33" name="1em"/><!-- HANGUL SYLLABLE GGOD -->
+      <map code="0xaf34" name="1em"/><!-- HANGUL SYLLABLE GGOL -->
+      <map code="0xaf35" name="1em"/><!-- HANGUL SYLLABLE GGOLG -->
+      <map code="0xaf36" name="1em"/><!-- HANGUL SYLLABLE GGOLM -->
+      <map code="0xaf37" name="1em"/><!-- HANGUL SYLLABLE GGOLB -->
+      <map code="0xaf38" name="1em"/><!-- HANGUL SYLLABLE GGOLS -->
+      <map code="0xaf39" name="1em"/><!-- HANGUL SYLLABLE GGOLT -->
+      <map code="0xaf3a" name="1em"/><!-- HANGUL SYLLABLE GGOLP -->
+      <map code="0xaf3b" name="1em"/><!-- HANGUL SYLLABLE GGOLH -->
+      <map code="0xaf3c" name="1em"/><!-- HANGUL SYLLABLE GGOM -->
+      <map code="0xaf3d" name="1em"/><!-- HANGUL SYLLABLE GGOB -->
+      <map code="0xaf3e" name="1em"/><!-- HANGUL SYLLABLE GGOBS -->
+      <map code="0xaf3f" name="1em"/><!-- HANGUL SYLLABLE GGOS -->
+      <map code="0xaf40" name="1em"/><!-- HANGUL SYLLABLE GGOSS -->
+      <map code="0xaf41" name="1em"/><!-- HANGUL SYLLABLE GGONG -->
+      <map code="0xaf42" name="1em"/><!-- HANGUL SYLLABLE GGOJ -->
+      <map code="0xaf43" name="1em"/><!-- HANGUL SYLLABLE GGOC -->
+      <map code="0xaf44" name="1em"/><!-- HANGUL SYLLABLE GGOK -->
+      <map code="0xaf45" name="1em"/><!-- HANGUL SYLLABLE GGOT -->
+      <map code="0xaf46" name="1em"/><!-- HANGUL SYLLABLE GGOP -->
+      <map code="0xaf47" name="1em"/><!-- HANGUL SYLLABLE GGOH -->
+      <map code="0xaf48" name="1em"/><!-- HANGUL SYLLABLE GGWA -->
+      <map code="0xaf49" name="1em"/><!-- HANGUL SYLLABLE GGWAG -->
+      <map code="0xaf4a" name="1em"/><!-- HANGUL SYLLABLE GGWAGG -->
+      <map code="0xaf4b" name="1em"/><!-- HANGUL SYLLABLE GGWAGS -->
+      <map code="0xaf4c" name="1em"/><!-- HANGUL SYLLABLE GGWAN -->
+      <map code="0xaf4d" name="1em"/><!-- HANGUL SYLLABLE GGWANJ -->
+      <map code="0xaf4e" name="1em"/><!-- HANGUL SYLLABLE GGWANH -->
+      <map code="0xaf4f" name="1em"/><!-- HANGUL SYLLABLE GGWAD -->
+      <map code="0xaf50" name="1em"/><!-- HANGUL SYLLABLE GGWAL -->
+      <map code="0xaf51" name="1em"/><!-- HANGUL SYLLABLE GGWALG -->
+      <map code="0xaf52" name="1em"/><!-- HANGUL SYLLABLE GGWALM -->
+      <map code="0xaf53" name="1em"/><!-- HANGUL SYLLABLE GGWALB -->
+      <map code="0xaf54" name="1em"/><!-- HANGUL SYLLABLE GGWALS -->
+      <map code="0xaf55" name="1em"/><!-- HANGUL SYLLABLE GGWALT -->
+      <map code="0xaf56" name="1em"/><!-- HANGUL SYLLABLE GGWALP -->
+      <map code="0xaf57" name="1em"/><!-- HANGUL SYLLABLE GGWALH -->
+      <map code="0xaf58" name="1em"/><!-- HANGUL SYLLABLE GGWAM -->
+      <map code="0xaf59" name="1em"/><!-- HANGUL SYLLABLE GGWAB -->
+      <map code="0xaf5a" name="1em"/><!-- HANGUL SYLLABLE GGWABS -->
+      <map code="0xaf5b" name="1em"/><!-- HANGUL SYLLABLE GGWAS -->
+      <map code="0xaf5c" name="1em"/><!-- HANGUL SYLLABLE GGWASS -->
+      <map code="0xaf5d" name="1em"/><!-- HANGUL SYLLABLE GGWANG -->
+      <map code="0xaf5e" name="1em"/><!-- HANGUL SYLLABLE GGWAJ -->
+      <map code="0xaf5f" name="1em"/><!-- HANGUL SYLLABLE GGWAC -->
+      <map code="0xaf60" name="1em"/><!-- HANGUL SYLLABLE GGWAK -->
+      <map code="0xaf61" name="1em"/><!-- HANGUL SYLLABLE GGWAT -->
+      <map code="0xaf62" name="1em"/><!-- HANGUL SYLLABLE GGWAP -->
+      <map code="0xaf63" name="1em"/><!-- HANGUL SYLLABLE GGWAH -->
+      <map code="0xaf64" name="1em"/><!-- HANGUL SYLLABLE GGWAE -->
+      <map code="0xaf65" name="1em"/><!-- HANGUL SYLLABLE GGWAEG -->
+      <map code="0xaf66" name="1em"/><!-- HANGUL SYLLABLE GGWAEGG -->
+      <map code="0xaf67" name="1em"/><!-- HANGUL SYLLABLE GGWAEGS -->
+      <map code="0xaf68" name="1em"/><!-- HANGUL SYLLABLE GGWAEN -->
+      <map code="0xaf69" name="1em"/><!-- HANGUL SYLLABLE GGWAENJ -->
+      <map code="0xaf6a" name="1em"/><!-- HANGUL SYLLABLE GGWAENH -->
+      <map code="0xaf6b" name="1em"/><!-- HANGUL SYLLABLE GGWAED -->
+      <map code="0xaf6c" name="1em"/><!-- HANGUL SYLLABLE GGWAEL -->
+      <map code="0xaf6d" name="1em"/><!-- HANGUL SYLLABLE GGWAELG -->
+      <map code="0xaf6e" name="1em"/><!-- HANGUL SYLLABLE GGWAELM -->
+      <map code="0xaf6f" name="1em"/><!-- HANGUL SYLLABLE GGWAELB -->
+      <map code="0xaf70" name="1em"/><!-- HANGUL SYLLABLE GGWAELS -->
+      <map code="0xaf71" name="1em"/><!-- HANGUL SYLLABLE GGWAELT -->
+      <map code="0xaf72" name="1em"/><!-- HANGUL SYLLABLE GGWAELP -->
+      <map code="0xaf73" name="1em"/><!-- HANGUL SYLLABLE GGWAELH -->
+      <map code="0xaf74" name="1em"/><!-- HANGUL SYLLABLE GGWAEM -->
+      <map code="0xaf75" name="1em"/><!-- HANGUL SYLLABLE GGWAEB -->
+      <map code="0xaf76" name="1em"/><!-- HANGUL SYLLABLE GGWAEBS -->
+      <map code="0xaf77" name="1em"/><!-- HANGUL SYLLABLE GGWAES -->
+      <map code="0xaf78" name="1em"/><!-- HANGUL SYLLABLE GGWAESS -->
+      <map code="0xaf79" name="1em"/><!-- HANGUL SYLLABLE GGWAENG -->
+      <map code="0xaf7a" name="1em"/><!-- HANGUL SYLLABLE GGWAEJ -->
+      <map code="0xaf7b" name="1em"/><!-- HANGUL SYLLABLE GGWAEC -->
+      <map code="0xaf7c" name="1em"/><!-- HANGUL SYLLABLE GGWAEK -->
+      <map code="0xaf7d" name="1em"/><!-- HANGUL SYLLABLE GGWAET -->
+      <map code="0xaf7e" name="1em"/><!-- HANGUL SYLLABLE GGWAEP -->
+      <map code="0xaf7f" name="1em"/><!-- HANGUL SYLLABLE GGWAEH -->
+      <map code="0xaf80" name="1em"/><!-- HANGUL SYLLABLE GGOE -->
+      <map code="0xaf81" name="1em"/><!-- HANGUL SYLLABLE GGOEG -->
+      <map code="0xaf82" name="1em"/><!-- HANGUL SYLLABLE GGOEGG -->
+      <map code="0xaf83" name="1em"/><!-- HANGUL SYLLABLE GGOEGS -->
+      <map code="0xaf84" name="1em"/><!-- HANGUL SYLLABLE GGOEN -->
+      <map code="0xaf85" name="1em"/><!-- HANGUL SYLLABLE GGOENJ -->
+      <map code="0xaf86" name="1em"/><!-- HANGUL SYLLABLE GGOENH -->
+      <map code="0xaf87" name="1em"/><!-- HANGUL SYLLABLE GGOED -->
+      <map code="0xaf88" name="1em"/><!-- HANGUL SYLLABLE GGOEL -->
+      <map code="0xaf89" name="1em"/><!-- HANGUL SYLLABLE GGOELG -->
+      <map code="0xaf8a" name="1em"/><!-- HANGUL SYLLABLE GGOELM -->
+      <map code="0xaf8b" name="1em"/><!-- HANGUL SYLLABLE GGOELB -->
+      <map code="0xaf8c" name="1em"/><!-- HANGUL SYLLABLE GGOELS -->
+      <map code="0xaf8d" name="1em"/><!-- HANGUL SYLLABLE GGOELT -->
+      <map code="0xaf8e" name="1em"/><!-- HANGUL SYLLABLE GGOELP -->
+      <map code="0xaf8f" name="1em"/><!-- HANGUL SYLLABLE GGOELH -->
+      <map code="0xaf90" name="1em"/><!-- HANGUL SYLLABLE GGOEM -->
+      <map code="0xaf91" name="1em"/><!-- HANGUL SYLLABLE GGOEB -->
+      <map code="0xaf92" name="1em"/><!-- HANGUL SYLLABLE GGOEBS -->
+      <map code="0xaf93" name="1em"/><!-- HANGUL SYLLABLE GGOES -->
+      <map code="0xaf94" name="1em"/><!-- HANGUL SYLLABLE GGOESS -->
+      <map code="0xaf95" name="1em"/><!-- HANGUL SYLLABLE GGOENG -->
+      <map code="0xaf96" name="1em"/><!-- HANGUL SYLLABLE GGOEJ -->
+      <map code="0xaf97" name="1em"/><!-- HANGUL SYLLABLE GGOEC -->
+      <map code="0xaf98" name="1em"/><!-- HANGUL SYLLABLE GGOEK -->
+      <map code="0xaf99" name="1em"/><!-- HANGUL SYLLABLE GGOET -->
+      <map code="0xaf9a" name="1em"/><!-- HANGUL SYLLABLE GGOEP -->
+      <map code="0xaf9b" name="1em"/><!-- HANGUL SYLLABLE GGOEH -->
+      <map code="0xaf9c" name="1em"/><!-- HANGUL SYLLABLE GGYO -->
+      <map code="0xaf9d" name="1em"/><!-- HANGUL SYLLABLE GGYOG -->
+      <map code="0xaf9e" name="1em"/><!-- HANGUL SYLLABLE GGYOGG -->
+      <map code="0xaf9f" name="1em"/><!-- HANGUL SYLLABLE GGYOGS -->
+      <map code="0xafa0" name="1em"/><!-- HANGUL SYLLABLE GGYON -->
+      <map code="0xafa1" name="1em"/><!-- HANGUL SYLLABLE GGYONJ -->
+      <map code="0xafa2" name="1em"/><!-- HANGUL SYLLABLE GGYONH -->
+      <map code="0xafa3" name="1em"/><!-- HANGUL SYLLABLE GGYOD -->
+      <map code="0xafa4" name="1em"/><!-- HANGUL SYLLABLE GGYOL -->
+      <map code="0xafa5" name="1em"/><!-- HANGUL SYLLABLE GGYOLG -->
+      <map code="0xafa6" name="1em"/><!-- HANGUL SYLLABLE GGYOLM -->
+      <map code="0xafa7" name="1em"/><!-- HANGUL SYLLABLE GGYOLB -->
+      <map code="0xafa8" name="1em"/><!-- HANGUL SYLLABLE GGYOLS -->
+      <map code="0xafa9" name="1em"/><!-- HANGUL SYLLABLE GGYOLT -->
+      <map code="0xafaa" name="1em"/><!-- HANGUL SYLLABLE GGYOLP -->
+      <map code="0xafab" name="1em"/><!-- HANGUL SYLLABLE GGYOLH -->
+      <map code="0xafac" name="1em"/><!-- HANGUL SYLLABLE GGYOM -->
+      <map code="0xafad" name="1em"/><!-- HANGUL SYLLABLE GGYOB -->
+      <map code="0xafae" name="1em"/><!-- HANGUL SYLLABLE GGYOBS -->
+      <map code="0xafaf" name="1em"/><!-- HANGUL SYLLABLE GGYOS -->
+      <map code="0xafb0" name="1em"/><!-- HANGUL SYLLABLE GGYOSS -->
+      <map code="0xafb1" name="1em"/><!-- HANGUL SYLLABLE GGYONG -->
+      <map code="0xafb2" name="1em"/><!-- HANGUL SYLLABLE GGYOJ -->
+      <map code="0xafb3" name="1em"/><!-- HANGUL SYLLABLE GGYOC -->
+      <map code="0xafb4" name="1em"/><!-- HANGUL SYLLABLE GGYOK -->
+      <map code="0xafb5" name="1em"/><!-- HANGUL SYLLABLE GGYOT -->
+      <map code="0xafb6" name="1em"/><!-- HANGUL SYLLABLE GGYOP -->
+      <map code="0xafb7" name="1em"/><!-- HANGUL SYLLABLE GGYOH -->
+      <map code="0xafb8" name="1em"/><!-- HANGUL SYLLABLE GGU -->
+      <map code="0xafb9" name="1em"/><!-- HANGUL SYLLABLE GGUG -->
+      <map code="0xafba" name="1em"/><!-- HANGUL SYLLABLE GGUGG -->
+      <map code="0xafbb" name="1em"/><!-- HANGUL SYLLABLE GGUGS -->
+      <map code="0xafbc" name="1em"/><!-- HANGUL SYLLABLE GGUN -->
+      <map code="0xafbd" name="1em"/><!-- HANGUL SYLLABLE GGUNJ -->
+      <map code="0xafbe" name="1em"/><!-- HANGUL SYLLABLE GGUNH -->
+      <map code="0xafbf" name="1em"/><!-- HANGUL SYLLABLE GGUD -->
+      <map code="0xafc0" name="1em"/><!-- HANGUL SYLLABLE GGUL -->
+      <map code="0xafc1" name="1em"/><!-- HANGUL SYLLABLE GGULG -->
+      <map code="0xafc2" name="1em"/><!-- HANGUL SYLLABLE GGULM -->
+      <map code="0xafc3" name="1em"/><!-- HANGUL SYLLABLE GGULB -->
+      <map code="0xafc4" name="1em"/><!-- HANGUL SYLLABLE GGULS -->
+      <map code="0xafc5" name="1em"/><!-- HANGUL SYLLABLE GGULT -->
+      <map code="0xafc6" name="1em"/><!-- HANGUL SYLLABLE GGULP -->
+      <map code="0xafc7" name="1em"/><!-- HANGUL SYLLABLE GGULH -->
+      <map code="0xafc8" name="1em"/><!-- HANGUL SYLLABLE GGUM -->
+      <map code="0xafc9" name="1em"/><!-- HANGUL SYLLABLE GGUB -->
+      <map code="0xafca" name="1em"/><!-- HANGUL SYLLABLE GGUBS -->
+      <map code="0xafcb" name="1em"/><!-- HANGUL SYLLABLE GGUS -->
+      <map code="0xafcc" name="1em"/><!-- HANGUL SYLLABLE GGUSS -->
+      <map code="0xafcd" name="1em"/><!-- HANGUL SYLLABLE GGUNG -->
+      <map code="0xafce" name="1em"/><!-- HANGUL SYLLABLE GGUJ -->
+      <map code="0xafcf" name="1em"/><!-- HANGUL SYLLABLE GGUC -->
+      <map code="0xafd0" name="1em"/><!-- HANGUL SYLLABLE GGUK -->
+      <map code="0xafd1" name="1em"/><!-- HANGUL SYLLABLE GGUT -->
+      <map code="0xafd2" name="1em"/><!-- HANGUL SYLLABLE GGUP -->
+      <map code="0xafd3" name="1em"/><!-- HANGUL SYLLABLE GGUH -->
+      <map code="0xafd4" name="1em"/><!-- HANGUL SYLLABLE GGWEO -->
+      <map code="0xafd5" name="1em"/><!-- HANGUL SYLLABLE GGWEOG -->
+      <map code="0xafd6" name="1em"/><!-- HANGUL SYLLABLE GGWEOGG -->
+      <map code="0xafd7" name="1em"/><!-- HANGUL SYLLABLE GGWEOGS -->
+      <map code="0xafd8" name="1em"/><!-- HANGUL SYLLABLE GGWEON -->
+      <map code="0xafd9" name="1em"/><!-- HANGUL SYLLABLE GGWEONJ -->
+      <map code="0xafda" name="1em"/><!-- HANGUL SYLLABLE GGWEONH -->
+      <map code="0xafdb" name="1em"/><!-- HANGUL SYLLABLE GGWEOD -->
+      <map code="0xafdc" name="1em"/><!-- HANGUL SYLLABLE GGWEOL -->
+      <map code="0xafdd" name="1em"/><!-- HANGUL SYLLABLE GGWEOLG -->
+      <map code="0xafde" name="1em"/><!-- HANGUL SYLLABLE GGWEOLM -->
+      <map code="0xafdf" name="1em"/><!-- HANGUL SYLLABLE GGWEOLB -->
+      <map code="0xafe0" name="1em"/><!-- HANGUL SYLLABLE GGWEOLS -->
+      <map code="0xafe1" name="1em"/><!-- HANGUL SYLLABLE GGWEOLT -->
+      <map code="0xafe2" name="1em"/><!-- HANGUL SYLLABLE GGWEOLP -->
+      <map code="0xafe3" name="1em"/><!-- HANGUL SYLLABLE GGWEOLH -->
+      <map code="0xafe4" name="1em"/><!-- HANGUL SYLLABLE GGWEOM -->
+      <map code="0xafe5" name="1em"/><!-- HANGUL SYLLABLE GGWEOB -->
+      <map code="0xafe6" name="1em"/><!-- HANGUL SYLLABLE GGWEOBS -->
+      <map code="0xafe7" name="1em"/><!-- HANGUL SYLLABLE GGWEOS -->
+      <map code="0xafe8" name="1em"/><!-- HANGUL SYLLABLE GGWEOSS -->
+      <map code="0xafe9" name="1em"/><!-- HANGUL SYLLABLE GGWEONG -->
+      <map code="0xafea" name="1em"/><!-- HANGUL SYLLABLE GGWEOJ -->
+      <map code="0xafeb" name="1em"/><!-- HANGUL SYLLABLE GGWEOC -->
+      <map code="0xafec" name="1em"/><!-- HANGUL SYLLABLE GGWEOK -->
+      <map code="0xafed" name="1em"/><!-- HANGUL SYLLABLE GGWEOT -->
+      <map code="0xafee" name="1em"/><!-- HANGUL SYLLABLE GGWEOP -->
+      <map code="0xafef" name="1em"/><!-- HANGUL SYLLABLE GGWEOH -->
+      <map code="0xaff0" name="1em"/><!-- HANGUL SYLLABLE GGWE -->
+      <map code="0xaff1" name="1em"/><!-- HANGUL SYLLABLE GGWEG -->
+      <map code="0xaff2" name="1em"/><!-- HANGUL SYLLABLE GGWEGG -->
+      <map code="0xaff3" name="1em"/><!-- HANGUL SYLLABLE GGWEGS -->
+      <map code="0xaff4" name="1em"/><!-- HANGUL SYLLABLE GGWEN -->
+      <map code="0xaff5" name="1em"/><!-- HANGUL SYLLABLE GGWENJ -->
+      <map code="0xaff6" name="1em"/><!-- HANGUL SYLLABLE GGWENH -->
+      <map code="0xaff7" name="1em"/><!-- HANGUL SYLLABLE GGWED -->
+      <map code="0xaff8" name="1em"/><!-- HANGUL SYLLABLE GGWEL -->
+      <map code="0xaff9" name="1em"/><!-- HANGUL SYLLABLE GGWELG -->
+      <map code="0xaffa" name="1em"/><!-- HANGUL SYLLABLE GGWELM -->
+      <map code="0xaffb" name="1em"/><!-- HANGUL SYLLABLE GGWELB -->
+      <map code="0xaffc" name="1em"/><!-- HANGUL SYLLABLE GGWELS -->
+      <map code="0xaffd" name="1em"/><!-- HANGUL SYLLABLE GGWELT -->
+      <map code="0xaffe" name="1em"/><!-- HANGUL SYLLABLE GGWELP -->
+      <map code="0xafff" name="1em"/><!-- HANGUL SYLLABLE GGWELH -->
+      <map code="0xb000" name="1em"/><!-- HANGUL SYLLABLE GGWEM -->
+      <map code="0xb001" name="1em"/><!-- HANGUL SYLLABLE GGWEB -->
+      <map code="0xb002" name="1em"/><!-- HANGUL SYLLABLE GGWEBS -->
+      <map code="0xb003" name="1em"/><!-- HANGUL SYLLABLE GGWES -->
+      <map code="0xb004" name="1em"/><!-- HANGUL SYLLABLE GGWESS -->
+      <map code="0xb005" name="1em"/><!-- HANGUL SYLLABLE GGWENG -->
+      <map code="0xb006" name="1em"/><!-- HANGUL SYLLABLE GGWEJ -->
+      <map code="0xb007" name="1em"/><!-- HANGUL SYLLABLE GGWEC -->
+      <map code="0xb008" name="1em"/><!-- HANGUL SYLLABLE GGWEK -->
+      <map code="0xb009" name="1em"/><!-- HANGUL SYLLABLE GGWET -->
+      <map code="0xb00a" name="1em"/><!-- HANGUL SYLLABLE GGWEP -->
+      <map code="0xb00b" name="1em"/><!-- HANGUL SYLLABLE GGWEH -->
+      <map code="0xb00c" name="1em"/><!-- HANGUL SYLLABLE GGWI -->
+      <map code="0xb00d" name="1em"/><!-- HANGUL SYLLABLE GGWIG -->
+      <map code="0xb00e" name="1em"/><!-- HANGUL SYLLABLE GGWIGG -->
+      <map code="0xb00f" name="1em"/><!-- HANGUL SYLLABLE GGWIGS -->
+      <map code="0xb010" name="1em"/><!-- HANGUL SYLLABLE GGWIN -->
+      <map code="0xb011" name="1em"/><!-- HANGUL SYLLABLE GGWINJ -->
+      <map code="0xb012" name="1em"/><!-- HANGUL SYLLABLE GGWINH -->
+      <map code="0xb013" name="1em"/><!-- HANGUL SYLLABLE GGWID -->
+      <map code="0xb014" name="1em"/><!-- HANGUL SYLLABLE GGWIL -->
+      <map code="0xb015" name="1em"/><!-- HANGUL SYLLABLE GGWILG -->
+      <map code="0xb016" name="1em"/><!-- HANGUL SYLLABLE GGWILM -->
+      <map code="0xb017" name="1em"/><!-- HANGUL SYLLABLE GGWILB -->
+      <map code="0xb018" name="1em"/><!-- HANGUL SYLLABLE GGWILS -->
+      <map code="0xb019" name="1em"/><!-- HANGUL SYLLABLE GGWILT -->
+      <map code="0xb01a" name="1em"/><!-- HANGUL SYLLABLE GGWILP -->
+      <map code="0xb01b" name="1em"/><!-- HANGUL SYLLABLE GGWILH -->
+      <map code="0xb01c" name="1em"/><!-- HANGUL SYLLABLE GGWIM -->
+      <map code="0xb01d" name="1em"/><!-- HANGUL SYLLABLE GGWIB -->
+      <map code="0xb01e" name="1em"/><!-- HANGUL SYLLABLE GGWIBS -->
+      <map code="0xb01f" name="1em"/><!-- HANGUL SYLLABLE GGWIS -->
+      <map code="0xb020" name="1em"/><!-- HANGUL SYLLABLE GGWISS -->
+      <map code="0xb021" name="1em"/><!-- HANGUL SYLLABLE GGWING -->
+      <map code="0xb022" name="1em"/><!-- HANGUL SYLLABLE GGWIJ -->
+      <map code="0xb023" name="1em"/><!-- HANGUL SYLLABLE GGWIC -->
+      <map code="0xb024" name="1em"/><!-- HANGUL SYLLABLE GGWIK -->
+      <map code="0xb025" name="1em"/><!-- HANGUL SYLLABLE GGWIT -->
+      <map code="0xb026" name="1em"/><!-- HANGUL SYLLABLE GGWIP -->
+      <map code="0xb027" name="1em"/><!-- HANGUL SYLLABLE GGWIH -->
+      <map code="0xb028" name="1em"/><!-- HANGUL SYLLABLE GGYU -->
+      <map code="0xb029" name="1em"/><!-- HANGUL SYLLABLE GGYUG -->
+      <map code="0xb02a" name="1em"/><!-- HANGUL SYLLABLE GGYUGG -->
+      <map code="0xb02b" name="1em"/><!-- HANGUL SYLLABLE GGYUGS -->
+      <map code="0xb02c" name="1em"/><!-- HANGUL SYLLABLE GGYUN -->
+      <map code="0xb02d" name="1em"/><!-- HANGUL SYLLABLE GGYUNJ -->
+      <map code="0xb02e" name="1em"/><!-- HANGUL SYLLABLE GGYUNH -->
+      <map code="0xb02f" name="1em"/><!-- HANGUL SYLLABLE GGYUD -->
+      <map code="0xb030" name="1em"/><!-- HANGUL SYLLABLE GGYUL -->
+      <map code="0xb031" name="1em"/><!-- HANGUL SYLLABLE GGYULG -->
+      <map code="0xb032" name="1em"/><!-- HANGUL SYLLABLE GGYULM -->
+      <map code="0xb033" name="1em"/><!-- HANGUL SYLLABLE GGYULB -->
+      <map code="0xb034" name="1em"/><!-- HANGUL SYLLABLE GGYULS -->
+      <map code="0xb035" name="1em"/><!-- HANGUL SYLLABLE GGYULT -->
+      <map code="0xb036" name="1em"/><!-- HANGUL SYLLABLE GGYULP -->
+      <map code="0xb037" name="1em"/><!-- HANGUL SYLLABLE GGYULH -->
+      <map code="0xb038" name="1em"/><!-- HANGUL SYLLABLE GGYUM -->
+      <map code="0xb039" name="1em"/><!-- HANGUL SYLLABLE GGYUB -->
+      <map code="0xb03a" name="1em"/><!-- HANGUL SYLLABLE GGYUBS -->
+      <map code="0xb03b" name="1em"/><!-- HANGUL SYLLABLE GGYUS -->
+      <map code="0xb03c" name="1em"/><!-- HANGUL SYLLABLE GGYUSS -->
+      <map code="0xb03d" name="1em"/><!-- HANGUL SYLLABLE GGYUNG -->
+      <map code="0xb03e" name="1em"/><!-- HANGUL SYLLABLE GGYUJ -->
+      <map code="0xb03f" name="1em"/><!-- HANGUL SYLLABLE GGYUC -->
+      <map code="0xb040" name="1em"/><!-- HANGUL SYLLABLE GGYUK -->
+      <map code="0xb041" name="1em"/><!-- HANGUL SYLLABLE GGYUT -->
+      <map code="0xb042" name="1em"/><!-- HANGUL SYLLABLE GGYUP -->
+      <map code="0xb043" name="1em"/><!-- HANGUL SYLLABLE GGYUH -->
+      <map code="0xb044" name="1em"/><!-- HANGUL SYLLABLE GGEU -->
+      <map code="0xb045" name="1em"/><!-- HANGUL SYLLABLE GGEUG -->
+      <map code="0xb046" name="1em"/><!-- HANGUL SYLLABLE GGEUGG -->
+      <map code="0xb047" name="1em"/><!-- HANGUL SYLLABLE GGEUGS -->
+      <map code="0xb048" name="1em"/><!-- HANGUL SYLLABLE GGEUN -->
+      <map code="0xb049" name="1em"/><!-- HANGUL SYLLABLE GGEUNJ -->
+      <map code="0xb04a" name="1em"/><!-- HANGUL SYLLABLE GGEUNH -->
+      <map code="0xb04b" name="1em"/><!-- HANGUL SYLLABLE GGEUD -->
+      <map code="0xb04c" name="1em"/><!-- HANGUL SYLLABLE GGEUL -->
+      <map code="0xb04d" name="1em"/><!-- HANGUL SYLLABLE GGEULG -->
+      <map code="0xb04e" name="1em"/><!-- HANGUL SYLLABLE GGEULM -->
+      <map code="0xb04f" name="1em"/><!-- HANGUL SYLLABLE GGEULB -->
+      <map code="0xb050" name="1em"/><!-- HANGUL SYLLABLE GGEULS -->
+      <map code="0xb051" name="1em"/><!-- HANGUL SYLLABLE GGEULT -->
+      <map code="0xb052" name="1em"/><!-- HANGUL SYLLABLE GGEULP -->
+      <map code="0xb053" name="1em"/><!-- HANGUL SYLLABLE GGEULH -->
+      <map code="0xb054" name="1em"/><!-- HANGUL SYLLABLE GGEUM -->
+      <map code="0xb055" name="1em"/><!-- HANGUL SYLLABLE GGEUB -->
+      <map code="0xb056" name="1em"/><!-- HANGUL SYLLABLE GGEUBS -->
+      <map code="0xb057" name="1em"/><!-- HANGUL SYLLABLE GGEUS -->
+      <map code="0xb058" name="1em"/><!-- HANGUL SYLLABLE GGEUSS -->
+      <map code="0xb059" name="1em"/><!-- HANGUL SYLLABLE GGEUNG -->
+      <map code="0xb05a" name="1em"/><!-- HANGUL SYLLABLE GGEUJ -->
+      <map code="0xb05b" name="1em"/><!-- HANGUL SYLLABLE GGEUC -->
+      <map code="0xb05c" name="1em"/><!-- HANGUL SYLLABLE GGEUK -->
+      <map code="0xb05d" name="1em"/><!-- HANGUL SYLLABLE GGEUT -->
+      <map code="0xb05e" name="1em"/><!-- HANGUL SYLLABLE GGEUP -->
+      <map code="0xb05f" name="1em"/><!-- HANGUL SYLLABLE GGEUH -->
+      <map code="0xb060" name="1em"/><!-- HANGUL SYLLABLE GGYI -->
+      <map code="0xb061" name="1em"/><!-- HANGUL SYLLABLE GGYIG -->
+      <map code="0xb062" name="1em"/><!-- HANGUL SYLLABLE GGYIGG -->
+      <map code="0xb063" name="1em"/><!-- HANGUL SYLLABLE GGYIGS -->
+      <map code="0xb064" name="1em"/><!-- HANGUL SYLLABLE GGYIN -->
+      <map code="0xb065" name="1em"/><!-- HANGUL SYLLABLE GGYINJ -->
+      <map code="0xb066" name="1em"/><!-- HANGUL SYLLABLE GGYINH -->
+      <map code="0xb067" name="1em"/><!-- HANGUL SYLLABLE GGYID -->
+      <map code="0xb068" name="1em"/><!-- HANGUL SYLLABLE GGYIL -->
+      <map code="0xb069" name="1em"/><!-- HANGUL SYLLABLE GGYILG -->
+      <map code="0xb06a" name="1em"/><!-- HANGUL SYLLABLE GGYILM -->
+      <map code="0xb06b" name="1em"/><!-- HANGUL SYLLABLE GGYILB -->
+      <map code="0xb06c" name="1em"/><!-- HANGUL SYLLABLE GGYILS -->
+      <map code="0xb06d" name="1em"/><!-- HANGUL SYLLABLE GGYILT -->
+      <map code="0xb06e" name="1em"/><!-- HANGUL SYLLABLE GGYILP -->
+      <map code="0xb06f" name="1em"/><!-- HANGUL SYLLABLE GGYILH -->
+      <map code="0xb070" name="1em"/><!-- HANGUL SYLLABLE GGYIM -->
+      <map code="0xb071" name="1em"/><!-- HANGUL SYLLABLE GGYIB -->
+      <map code="0xb072" name="1em"/><!-- HANGUL SYLLABLE GGYIBS -->
+      <map code="0xb073" name="1em"/><!-- HANGUL SYLLABLE GGYIS -->
+      <map code="0xb074" name="1em"/><!-- HANGUL SYLLABLE GGYISS -->
+      <map code="0xb075" name="1em"/><!-- HANGUL SYLLABLE GGYING -->
+      <map code="0xb076" name="1em"/><!-- HANGUL SYLLABLE GGYIJ -->
+      <map code="0xb077" name="1em"/><!-- HANGUL SYLLABLE GGYIC -->
+      <map code="0xb078" name="1em"/><!-- HANGUL SYLLABLE GGYIK -->
+      <map code="0xb079" name="1em"/><!-- HANGUL SYLLABLE GGYIT -->
+      <map code="0xb07a" name="1em"/><!-- HANGUL SYLLABLE GGYIP -->
+      <map code="0xb07b" name="1em"/><!-- HANGUL SYLLABLE GGYIH -->
+      <map code="0xb07c" name="1em"/><!-- HANGUL SYLLABLE GGI -->
+      <map code="0xb07d" name="1em"/><!-- HANGUL SYLLABLE GGIG -->
+      <map code="0xb07e" name="1em"/><!-- HANGUL SYLLABLE GGIGG -->
+      <map code="0xb07f" name="1em"/><!-- HANGUL SYLLABLE GGIGS -->
+      <map code="0xb080" name="1em"/><!-- HANGUL SYLLABLE GGIN -->
+      <map code="0xb081" name="1em"/><!-- HANGUL SYLLABLE GGINJ -->
+      <map code="0xb082" name="1em"/><!-- HANGUL SYLLABLE GGINH -->
+      <map code="0xb083" name="1em"/><!-- HANGUL SYLLABLE GGID -->
+      <map code="0xb084" name="1em"/><!-- HANGUL SYLLABLE GGIL -->
+      <map code="0xb085" name="1em"/><!-- HANGUL SYLLABLE GGILG -->
+      <map code="0xb086" name="1em"/><!-- HANGUL SYLLABLE GGILM -->
+      <map code="0xb087" name="1em"/><!-- HANGUL SYLLABLE GGILB -->
+      <map code="0xb088" name="1em"/><!-- HANGUL SYLLABLE GGILS -->
+      <map code="0xb089" name="1em"/><!-- HANGUL SYLLABLE GGILT -->
+      <map code="0xb08a" name="1em"/><!-- HANGUL SYLLABLE GGILP -->
+      <map code="0xb08b" name="1em"/><!-- HANGUL SYLLABLE GGILH -->
+      <map code="0xb08c" name="1em"/><!-- HANGUL SYLLABLE GGIM -->
+      <map code="0xb08d" name="1em"/><!-- HANGUL SYLLABLE GGIB -->
+      <map code="0xb08e" name="1em"/><!-- HANGUL SYLLABLE GGIBS -->
+      <map code="0xb08f" name="1em"/><!-- HANGUL SYLLABLE GGIS -->
+      <map code="0xb090" name="1em"/><!-- HANGUL SYLLABLE GGISS -->
+      <map code="0xb091" name="1em"/><!-- HANGUL SYLLABLE GGING -->
+      <map code="0xb092" name="1em"/><!-- HANGUL SYLLABLE GGIJ -->
+      <map code="0xb093" name="1em"/><!-- HANGUL SYLLABLE GGIC -->
+      <map code="0xb094" name="1em"/><!-- HANGUL SYLLABLE GGIK -->
+      <map code="0xb095" name="1em"/><!-- HANGUL SYLLABLE GGIT -->
+      <map code="0xb096" name="1em"/><!-- HANGUL SYLLABLE GGIP -->
+      <map code="0xb097" name="1em"/><!-- HANGUL SYLLABLE GGIH -->
+      <map code="0xb098" name="1em"/><!-- HANGUL SYLLABLE NA -->
+      <map code="0xb099" name="1em"/><!-- HANGUL SYLLABLE NAG -->
+      <map code="0xb09a" name="1em"/><!-- HANGUL SYLLABLE NAGG -->
+      <map code="0xb09b" name="1em"/><!-- HANGUL SYLLABLE NAGS -->
+      <map code="0xb09c" name="1em"/><!-- HANGUL SYLLABLE NAN -->
+      <map code="0xb09d" name="1em"/><!-- HANGUL SYLLABLE NANJ -->
+      <map code="0xb09e" name="1em"/><!-- HANGUL SYLLABLE NANH -->
+      <map code="0xb09f" name="1em"/><!-- HANGUL SYLLABLE NAD -->
+      <map code="0xb0a0" name="1em"/><!-- HANGUL SYLLABLE NAL -->
+      <map code="0xb0a1" name="1em"/><!-- HANGUL SYLLABLE NALG -->
+      <map code="0xb0a2" name="1em"/><!-- HANGUL SYLLABLE NALM -->
+      <map code="0xb0a3" name="1em"/><!-- HANGUL SYLLABLE NALB -->
+      <map code="0xb0a4" name="1em"/><!-- HANGUL SYLLABLE NALS -->
+      <map code="0xb0a5" name="1em"/><!-- HANGUL SYLLABLE NALT -->
+      <map code="0xb0a6" name="1em"/><!-- HANGUL SYLLABLE NALP -->
+      <map code="0xb0a7" name="1em"/><!-- HANGUL SYLLABLE NALH -->
+      <map code="0xb0a8" name="1em"/><!-- HANGUL SYLLABLE NAM -->
+      <map code="0xb0a9" name="1em"/><!-- HANGUL SYLLABLE NAB -->
+      <map code="0xb0aa" name="1em"/><!-- HANGUL SYLLABLE NABS -->
+      <map code="0xb0ab" name="1em"/><!-- HANGUL SYLLABLE NAS -->
+      <map code="0xb0ac" name="1em"/><!-- HANGUL SYLLABLE NASS -->
+      <map code="0xb0ad" name="1em"/><!-- HANGUL SYLLABLE NANG -->
+      <map code="0xb0ae" name="1em"/><!-- HANGUL SYLLABLE NAJ -->
+      <map code="0xb0af" name="1em"/><!-- HANGUL SYLLABLE NAC -->
+      <map code="0xb0b0" name="1em"/><!-- HANGUL SYLLABLE NAK -->
+      <map code="0xb0b1" name="1em"/><!-- HANGUL SYLLABLE NAT -->
+      <map code="0xb0b2" name="1em"/><!-- HANGUL SYLLABLE NAP -->
+      <map code="0xb0b3" name="1em"/><!-- HANGUL SYLLABLE NAH -->
+      <map code="0xb0b4" name="1em"/><!-- HANGUL SYLLABLE NAE -->
+      <map code="0xb0b5" name="1em"/><!-- HANGUL SYLLABLE NAEG -->
+      <map code="0xb0b6" name="1em"/><!-- HANGUL SYLLABLE NAEGG -->
+      <map code="0xb0b7" name="1em"/><!-- HANGUL SYLLABLE NAEGS -->
+      <map code="0xb0b8" name="1em"/><!-- HANGUL SYLLABLE NAEN -->
+      <map code="0xb0b9" name="1em"/><!-- HANGUL SYLLABLE NAENJ -->
+      <map code="0xb0ba" name="1em"/><!-- HANGUL SYLLABLE NAENH -->
+      <map code="0xb0bb" name="1em"/><!-- HANGUL SYLLABLE NAED -->
+      <map code="0xb0bc" name="1em"/><!-- HANGUL SYLLABLE NAEL -->
+      <map code="0xb0bd" name="1em"/><!-- HANGUL SYLLABLE NAELG -->
+      <map code="0xb0be" name="1em"/><!-- HANGUL SYLLABLE NAELM -->
+      <map code="0xb0bf" name="1em"/><!-- HANGUL SYLLABLE NAELB -->
+      <map code="0xb0c0" name="1em"/><!-- HANGUL SYLLABLE NAELS -->
+      <map code="0xb0c1" name="1em"/><!-- HANGUL SYLLABLE NAELT -->
+      <map code="0xb0c2" name="1em"/><!-- HANGUL SYLLABLE NAELP -->
+      <map code="0xb0c3" name="1em"/><!-- HANGUL SYLLABLE NAELH -->
+      <map code="0xb0c4" name="1em"/><!-- HANGUL SYLLABLE NAEM -->
+      <map code="0xb0c5" name="1em"/><!-- HANGUL SYLLABLE NAEB -->
+      <map code="0xb0c6" name="1em"/><!-- HANGUL SYLLABLE NAEBS -->
+      <map code="0xb0c7" name="1em"/><!-- HANGUL SYLLABLE NAES -->
+      <map code="0xb0c8" name="1em"/><!-- HANGUL SYLLABLE NAESS -->
+      <map code="0xb0c9" name="1em"/><!-- HANGUL SYLLABLE NAENG -->
+      <map code="0xb0ca" name="1em"/><!-- HANGUL SYLLABLE NAEJ -->
+      <map code="0xb0cb" name="1em"/><!-- HANGUL SYLLABLE NAEC -->
+      <map code="0xb0cc" name="1em"/><!-- HANGUL SYLLABLE NAEK -->
+      <map code="0xb0cd" name="1em"/><!-- HANGUL SYLLABLE NAET -->
+      <map code="0xb0ce" name="1em"/><!-- HANGUL SYLLABLE NAEP -->
+      <map code="0xb0cf" name="1em"/><!-- HANGUL SYLLABLE NAEH -->
+      <map code="0xb0d0" name="1em"/><!-- HANGUL SYLLABLE NYA -->
+      <map code="0xb0d1" name="1em"/><!-- HANGUL SYLLABLE NYAG -->
+      <map code="0xb0d2" name="1em"/><!-- HANGUL SYLLABLE NYAGG -->
+      <map code="0xb0d3" name="1em"/><!-- HANGUL SYLLABLE NYAGS -->
+      <map code="0xb0d4" name="1em"/><!-- HANGUL SYLLABLE NYAN -->
+      <map code="0xb0d5" name="1em"/><!-- HANGUL SYLLABLE NYANJ -->
+      <map code="0xb0d6" name="1em"/><!-- HANGUL SYLLABLE NYANH -->
+      <map code="0xb0d7" name="1em"/><!-- HANGUL SYLLABLE NYAD -->
+      <map code="0xb0d8" name="1em"/><!-- HANGUL SYLLABLE NYAL -->
+      <map code="0xb0d9" name="1em"/><!-- HANGUL SYLLABLE NYALG -->
+      <map code="0xb0da" name="1em"/><!-- HANGUL SYLLABLE NYALM -->
+      <map code="0xb0db" name="1em"/><!-- HANGUL SYLLABLE NYALB -->
+      <map code="0xb0dc" name="1em"/><!-- HANGUL SYLLABLE NYALS -->
+      <map code="0xb0dd" name="1em"/><!-- HANGUL SYLLABLE NYALT -->
+      <map code="0xb0de" name="1em"/><!-- HANGUL SYLLABLE NYALP -->
+      <map code="0xb0df" name="1em"/><!-- HANGUL SYLLABLE NYALH -->
+      <map code="0xb0e0" name="1em"/><!-- HANGUL SYLLABLE NYAM -->
+      <map code="0xb0e1" name="1em"/><!-- HANGUL SYLLABLE NYAB -->
+      <map code="0xb0e2" name="1em"/><!-- HANGUL SYLLABLE NYABS -->
+      <map code="0xb0e3" name="1em"/><!-- HANGUL SYLLABLE NYAS -->
+      <map code="0xb0e4" name="1em"/><!-- HANGUL SYLLABLE NYASS -->
+      <map code="0xb0e5" name="1em"/><!-- HANGUL SYLLABLE NYANG -->
+      <map code="0xb0e6" name="1em"/><!-- HANGUL SYLLABLE NYAJ -->
+      <map code="0xb0e7" name="1em"/><!-- HANGUL SYLLABLE NYAC -->
+      <map code="0xb0e8" name="1em"/><!-- HANGUL SYLLABLE NYAK -->
+      <map code="0xb0e9" name="1em"/><!-- HANGUL SYLLABLE NYAT -->
+      <map code="0xb0ea" name="1em"/><!-- HANGUL SYLLABLE NYAP -->
+      <map code="0xb0eb" name="1em"/><!-- HANGUL SYLLABLE NYAH -->
+      <map code="0xb0ec" name="1em"/><!-- HANGUL SYLLABLE NYAE -->
+      <map code="0xb0ed" name="1em"/><!-- HANGUL SYLLABLE NYAEG -->
+      <map code="0xb0ee" name="1em"/><!-- HANGUL SYLLABLE NYAEGG -->
+      <map code="0xb0ef" name="1em"/><!-- HANGUL SYLLABLE NYAEGS -->
+      <map code="0xb0f0" name="1em"/><!-- HANGUL SYLLABLE NYAEN -->
+      <map code="0xb0f1" name="1em"/><!-- HANGUL SYLLABLE NYAENJ -->
+      <map code="0xb0f2" name="1em"/><!-- HANGUL SYLLABLE NYAENH -->
+      <map code="0xb0f3" name="1em"/><!-- HANGUL SYLLABLE NYAED -->
+      <map code="0xb0f4" name="1em"/><!-- HANGUL SYLLABLE NYAEL -->
+      <map code="0xb0f5" name="1em"/><!-- HANGUL SYLLABLE NYAELG -->
+      <map code="0xb0f6" name="1em"/><!-- HANGUL SYLLABLE NYAELM -->
+      <map code="0xb0f7" name="1em"/><!-- HANGUL SYLLABLE NYAELB -->
+      <map code="0xb0f8" name="1em"/><!-- HANGUL SYLLABLE NYAELS -->
+      <map code="0xb0f9" name="1em"/><!-- HANGUL SYLLABLE NYAELT -->
+      <map code="0xb0fa" name="1em"/><!-- HANGUL SYLLABLE NYAELP -->
+      <map code="0xb0fb" name="1em"/><!-- HANGUL SYLLABLE NYAELH -->
+      <map code="0xb0fc" name="1em"/><!-- HANGUL SYLLABLE NYAEM -->
+      <map code="0xb0fd" name="1em"/><!-- HANGUL SYLLABLE NYAEB -->
+      <map code="0xb0fe" name="1em"/><!-- HANGUL SYLLABLE NYAEBS -->
+      <map code="0xb0ff" name="1em"/><!-- HANGUL SYLLABLE NYAES -->
+      <map code="0xb100" name="1em"/><!-- HANGUL SYLLABLE NYAESS -->
+      <map code="0xb101" name="1em"/><!-- HANGUL SYLLABLE NYAENG -->
+      <map code="0xb102" name="1em"/><!-- HANGUL SYLLABLE NYAEJ -->
+      <map code="0xb103" name="1em"/><!-- HANGUL SYLLABLE NYAEC -->
+      <map code="0xb104" name="1em"/><!-- HANGUL SYLLABLE NYAEK -->
+      <map code="0xb105" name="1em"/><!-- HANGUL SYLLABLE NYAET -->
+      <map code="0xb106" name="1em"/><!-- HANGUL SYLLABLE NYAEP -->
+      <map code="0xb107" name="1em"/><!-- HANGUL SYLLABLE NYAEH -->
+      <map code="0xb108" name="1em"/><!-- HANGUL SYLLABLE NEO -->
+      <map code="0xb109" name="1em"/><!-- HANGUL SYLLABLE NEOG -->
+      <map code="0xb10a" name="1em"/><!-- HANGUL SYLLABLE NEOGG -->
+      <map code="0xb10b" name="1em"/><!-- HANGUL SYLLABLE NEOGS -->
+      <map code="0xb10c" name="1em"/><!-- HANGUL SYLLABLE NEON -->
+      <map code="0xb10d" name="1em"/><!-- HANGUL SYLLABLE NEONJ -->
+      <map code="0xb10e" name="1em"/><!-- HANGUL SYLLABLE NEONH -->
+      <map code="0xb10f" name="1em"/><!-- HANGUL SYLLABLE NEOD -->
+      <map code="0xb110" name="1em"/><!-- HANGUL SYLLABLE NEOL -->
+      <map code="0xb111" name="1em"/><!-- HANGUL SYLLABLE NEOLG -->
+      <map code="0xb112" name="1em"/><!-- HANGUL SYLLABLE NEOLM -->
+      <map code="0xb113" name="1em"/><!-- HANGUL SYLLABLE NEOLB -->
+      <map code="0xb114" name="1em"/><!-- HANGUL SYLLABLE NEOLS -->
+      <map code="0xb115" name="1em"/><!-- HANGUL SYLLABLE NEOLT -->
+      <map code="0xb116" name="1em"/><!-- HANGUL SYLLABLE NEOLP -->
+      <map code="0xb117" name="1em"/><!-- HANGUL SYLLABLE NEOLH -->
+      <map code="0xb118" name="1em"/><!-- HANGUL SYLLABLE NEOM -->
+      <map code="0xb119" name="1em"/><!-- HANGUL SYLLABLE NEOB -->
+      <map code="0xb11a" name="1em"/><!-- HANGUL SYLLABLE NEOBS -->
+      <map code="0xb11b" name="1em"/><!-- HANGUL SYLLABLE NEOS -->
+      <map code="0xb11c" name="1em"/><!-- HANGUL SYLLABLE NEOSS -->
+      <map code="0xb11d" name="1em"/><!-- HANGUL SYLLABLE NEONG -->
+      <map code="0xb11e" name="1em"/><!-- HANGUL SYLLABLE NEOJ -->
+      <map code="0xb11f" name="1em"/><!-- HANGUL SYLLABLE NEOC -->
+      <map code="0xb120" name="1em"/><!-- HANGUL SYLLABLE NEOK -->
+      <map code="0xb121" name="1em"/><!-- HANGUL SYLLABLE NEOT -->
+      <map code="0xb122" name="1em"/><!-- HANGUL SYLLABLE NEOP -->
+      <map code="0xb123" name="1em"/><!-- HANGUL SYLLABLE NEOH -->
+      <map code="0xb124" name="1em"/><!-- HANGUL SYLLABLE NE -->
+      <map code="0xb125" name="1em"/><!-- HANGUL SYLLABLE NEG -->
+      <map code="0xb126" name="1em"/><!-- HANGUL SYLLABLE NEGG -->
+      <map code="0xb127" name="1em"/><!-- HANGUL SYLLABLE NEGS -->
+      <map code="0xb128" name="1em"/><!-- HANGUL SYLLABLE NEN -->
+      <map code="0xb129" name="1em"/><!-- HANGUL SYLLABLE NENJ -->
+      <map code="0xb12a" name="1em"/><!-- HANGUL SYLLABLE NENH -->
+      <map code="0xb12b" name="1em"/><!-- HANGUL SYLLABLE NED -->
+      <map code="0xb12c" name="1em"/><!-- HANGUL SYLLABLE NEL -->
+      <map code="0xb12d" name="1em"/><!-- HANGUL SYLLABLE NELG -->
+      <map code="0xb12e" name="1em"/><!-- HANGUL SYLLABLE NELM -->
+      <map code="0xb12f" name="1em"/><!-- HANGUL SYLLABLE NELB -->
+      <map code="0xb130" name="1em"/><!-- HANGUL SYLLABLE NELS -->
+      <map code="0xb131" name="1em"/><!-- HANGUL SYLLABLE NELT -->
+      <map code="0xb132" name="1em"/><!-- HANGUL SYLLABLE NELP -->
+      <map code="0xb133" name="1em"/><!-- HANGUL SYLLABLE NELH -->
+      <map code="0xb134" name="1em"/><!-- HANGUL SYLLABLE NEM -->
+      <map code="0xb135" name="1em"/><!-- HANGUL SYLLABLE NEB -->
+      <map code="0xb136" name="1em"/><!-- HANGUL SYLLABLE NEBS -->
+      <map code="0xb137" name="1em"/><!-- HANGUL SYLLABLE NES -->
+      <map code="0xb138" name="1em"/><!-- HANGUL SYLLABLE NESS -->
+      <map code="0xb139" name="1em"/><!-- HANGUL SYLLABLE NENG -->
+      <map code="0xb13a" name="1em"/><!-- HANGUL SYLLABLE NEJ -->
+      <map code="0xb13b" name="1em"/><!-- HANGUL SYLLABLE NEC -->
+      <map code="0xb13c" name="1em"/><!-- HANGUL SYLLABLE NEK -->
+      <map code="0xb13d" name="1em"/><!-- HANGUL SYLLABLE NET -->
+      <map code="0xb13e" name="1em"/><!-- HANGUL SYLLABLE NEP -->
+      <map code="0xb13f" name="1em"/><!-- HANGUL SYLLABLE NEH -->
+      <map code="0xb140" name="1em"/><!-- HANGUL SYLLABLE NYEO -->
+      <map code="0xb141" name="1em"/><!-- HANGUL SYLLABLE NYEOG -->
+      <map code="0xb142" name="1em"/><!-- HANGUL SYLLABLE NYEOGG -->
+      <map code="0xb143" name="1em"/><!-- HANGUL SYLLABLE NYEOGS -->
+      <map code="0xb144" name="1em"/><!-- HANGUL SYLLABLE NYEON -->
+      <map code="0xb145" name="1em"/><!-- HANGUL SYLLABLE NYEONJ -->
+      <map code="0xb146" name="1em"/><!-- HANGUL SYLLABLE NYEONH -->
+      <map code="0xb147" name="1em"/><!-- HANGUL SYLLABLE NYEOD -->
+      <map code="0xb148" name="1em"/><!-- HANGUL SYLLABLE NYEOL -->
+      <map code="0xb149" name="1em"/><!-- HANGUL SYLLABLE NYEOLG -->
+      <map code="0xb14a" name="1em"/><!-- HANGUL SYLLABLE NYEOLM -->
+      <map code="0xb14b" name="1em"/><!-- HANGUL SYLLABLE NYEOLB -->
+      <map code="0xb14c" name="1em"/><!-- HANGUL SYLLABLE NYEOLS -->
+      <map code="0xb14d" name="1em"/><!-- HANGUL SYLLABLE NYEOLT -->
+      <map code="0xb14e" name="1em"/><!-- HANGUL SYLLABLE NYEOLP -->
+      <map code="0xb14f" name="1em"/><!-- HANGUL SYLLABLE NYEOLH -->
+      <map code="0xb150" name="1em"/><!-- HANGUL SYLLABLE NYEOM -->
+      <map code="0xb151" name="1em"/><!-- HANGUL SYLLABLE NYEOB -->
+      <map code="0xb152" name="1em"/><!-- HANGUL SYLLABLE NYEOBS -->
+      <map code="0xb153" name="1em"/><!-- HANGUL SYLLABLE NYEOS -->
+      <map code="0xb154" name="1em"/><!-- HANGUL SYLLABLE NYEOSS -->
+      <map code="0xb155" name="1em"/><!-- HANGUL SYLLABLE NYEONG -->
+      <map code="0xb156" name="1em"/><!-- HANGUL SYLLABLE NYEOJ -->
+      <map code="0xb157" name="1em"/><!-- HANGUL SYLLABLE NYEOC -->
+      <map code="0xb158" name="1em"/><!-- HANGUL SYLLABLE NYEOK -->
+      <map code="0xb159" name="1em"/><!-- HANGUL SYLLABLE NYEOT -->
+      <map code="0xb15a" name="1em"/><!-- HANGUL SYLLABLE NYEOP -->
+      <map code="0xb15b" name="1em"/><!-- HANGUL SYLLABLE NYEOH -->
+      <map code="0xb15c" name="1em"/><!-- HANGUL SYLLABLE NYE -->
+      <map code="0xb15d" name="1em"/><!-- HANGUL SYLLABLE NYEG -->
+      <map code="0xb15e" name="1em"/><!-- HANGUL SYLLABLE NYEGG -->
+      <map code="0xb15f" name="1em"/><!-- HANGUL SYLLABLE NYEGS -->
+      <map code="0xb160" name="1em"/><!-- HANGUL SYLLABLE NYEN -->
+      <map code="0xb161" name="1em"/><!-- HANGUL SYLLABLE NYENJ -->
+      <map code="0xb162" name="1em"/><!-- HANGUL SYLLABLE NYENH -->
+      <map code="0xb163" name="1em"/><!-- HANGUL SYLLABLE NYED -->
+      <map code="0xb164" name="1em"/><!-- HANGUL SYLLABLE NYEL -->
+      <map code="0xb165" name="1em"/><!-- HANGUL SYLLABLE NYELG -->
+      <map code="0xb166" name="1em"/><!-- HANGUL SYLLABLE NYELM -->
+      <map code="0xb167" name="1em"/><!-- HANGUL SYLLABLE NYELB -->
+      <map code="0xb168" name="1em"/><!-- HANGUL SYLLABLE NYELS -->
+      <map code="0xb169" name="1em"/><!-- HANGUL SYLLABLE NYELT -->
+      <map code="0xb16a" name="1em"/><!-- HANGUL SYLLABLE NYELP -->
+      <map code="0xb16b" name="1em"/><!-- HANGUL SYLLABLE NYELH -->
+      <map code="0xb16c" name="1em"/><!-- HANGUL SYLLABLE NYEM -->
+      <map code="0xb16d" name="1em"/><!-- HANGUL SYLLABLE NYEB -->
+      <map code="0xb16e" name="1em"/><!-- HANGUL SYLLABLE NYEBS -->
+      <map code="0xb16f" name="1em"/><!-- HANGUL SYLLABLE NYES -->
+      <map code="0xb170" name="1em"/><!-- HANGUL SYLLABLE NYESS -->
+      <map code="0xb171" name="1em"/><!-- HANGUL SYLLABLE NYENG -->
+      <map code="0xb172" name="1em"/><!-- HANGUL SYLLABLE NYEJ -->
+      <map code="0xb173" name="1em"/><!-- HANGUL SYLLABLE NYEC -->
+      <map code="0xb174" name="1em"/><!-- HANGUL SYLLABLE NYEK -->
+      <map code="0xb175" name="1em"/><!-- HANGUL SYLLABLE NYET -->
+      <map code="0xb176" name="1em"/><!-- HANGUL SYLLABLE NYEP -->
+      <map code="0xb177" name="1em"/><!-- HANGUL SYLLABLE NYEH -->
+      <map code="0xb178" name="1em"/><!-- HANGUL SYLLABLE NO -->
+      <map code="0xb179" name="1em"/><!-- HANGUL SYLLABLE NOG -->
+      <map code="0xb17a" name="1em"/><!-- HANGUL SYLLABLE NOGG -->
+      <map code="0xb17b" name="1em"/><!-- HANGUL SYLLABLE NOGS -->
+      <map code="0xb17c" name="1em"/><!-- HANGUL SYLLABLE NON -->
+      <map code="0xb17d" name="1em"/><!-- HANGUL SYLLABLE NONJ -->
+      <map code="0xb17e" name="1em"/><!-- HANGUL SYLLABLE NONH -->
+      <map code="0xb17f" name="1em"/><!-- HANGUL SYLLABLE NOD -->
+      <map code="0xb180" name="1em"/><!-- HANGUL SYLLABLE NOL -->
+      <map code="0xb181" name="1em"/><!-- HANGUL SYLLABLE NOLG -->
+      <map code="0xb182" name="1em"/><!-- HANGUL SYLLABLE NOLM -->
+      <map code="0xb183" name="1em"/><!-- HANGUL SYLLABLE NOLB -->
+      <map code="0xb184" name="1em"/><!-- HANGUL SYLLABLE NOLS -->
+      <map code="0xb185" name="1em"/><!-- HANGUL SYLLABLE NOLT -->
+      <map code="0xb186" name="1em"/><!-- HANGUL SYLLABLE NOLP -->
+      <map code="0xb187" name="1em"/><!-- HANGUL SYLLABLE NOLH -->
+      <map code="0xb188" name="1em"/><!-- HANGUL SYLLABLE NOM -->
+      <map code="0xb189" name="1em"/><!-- HANGUL SYLLABLE NOB -->
+      <map code="0xb18a" name="1em"/><!-- HANGUL SYLLABLE NOBS -->
+      <map code="0xb18b" name="1em"/><!-- HANGUL SYLLABLE NOS -->
+      <map code="0xb18c" name="1em"/><!-- HANGUL SYLLABLE NOSS -->
+      <map code="0xb18d" name="1em"/><!-- HANGUL SYLLABLE NONG -->
+      <map code="0xb18e" name="1em"/><!-- HANGUL SYLLABLE NOJ -->
+      <map code="0xb18f" name="1em"/><!-- HANGUL SYLLABLE NOC -->
+      <map code="0xb190" name="1em"/><!-- HANGUL SYLLABLE NOK -->
+      <map code="0xb191" name="1em"/><!-- HANGUL SYLLABLE NOT -->
+      <map code="0xb192" name="1em"/><!-- HANGUL SYLLABLE NOP -->
+      <map code="0xb193" name="1em"/><!-- HANGUL SYLLABLE NOH -->
+      <map code="0xb194" name="1em"/><!-- HANGUL SYLLABLE NWA -->
+      <map code="0xb195" name="1em"/><!-- HANGUL SYLLABLE NWAG -->
+      <map code="0xb196" name="1em"/><!-- HANGUL SYLLABLE NWAGG -->
+      <map code="0xb197" name="1em"/><!-- HANGUL SYLLABLE NWAGS -->
+      <map code="0xb198" name="1em"/><!-- HANGUL SYLLABLE NWAN -->
+      <map code="0xb199" name="1em"/><!-- HANGUL SYLLABLE NWANJ -->
+      <map code="0xb19a" name="1em"/><!-- HANGUL SYLLABLE NWANH -->
+      <map code="0xb19b" name="1em"/><!-- HANGUL SYLLABLE NWAD -->
+      <map code="0xb19c" name="1em"/><!-- HANGUL SYLLABLE NWAL -->
+      <map code="0xb19d" name="1em"/><!-- HANGUL SYLLABLE NWALG -->
+      <map code="0xb19e" name="1em"/><!-- HANGUL SYLLABLE NWALM -->
+      <map code="0xb19f" name="1em"/><!-- HANGUL SYLLABLE NWALB -->
+      <map code="0xb1a0" name="1em"/><!-- HANGUL SYLLABLE NWALS -->
+      <map code="0xb1a1" name="1em"/><!-- HANGUL SYLLABLE NWALT -->
+      <map code="0xb1a2" name="1em"/><!-- HANGUL SYLLABLE NWALP -->
+      <map code="0xb1a3" name="1em"/><!-- HANGUL SYLLABLE NWALH -->
+      <map code="0xb1a4" name="1em"/><!-- HANGUL SYLLABLE NWAM -->
+      <map code="0xb1a5" name="1em"/><!-- HANGUL SYLLABLE NWAB -->
+      <map code="0xb1a6" name="1em"/><!-- HANGUL SYLLABLE NWABS -->
+      <map code="0xb1a7" name="1em"/><!-- HANGUL SYLLABLE NWAS -->
+      <map code="0xb1a8" name="1em"/><!-- HANGUL SYLLABLE NWASS -->
+      <map code="0xb1a9" name="1em"/><!-- HANGUL SYLLABLE NWANG -->
+      <map code="0xb1aa" name="1em"/><!-- HANGUL SYLLABLE NWAJ -->
+      <map code="0xb1ab" name="1em"/><!-- HANGUL SYLLABLE NWAC -->
+      <map code="0xb1ac" name="1em"/><!-- HANGUL SYLLABLE NWAK -->
+      <map code="0xb1ad" name="1em"/><!-- HANGUL SYLLABLE NWAT -->
+      <map code="0xb1ae" name="1em"/><!-- HANGUL SYLLABLE NWAP -->
+      <map code="0xb1af" name="1em"/><!-- HANGUL SYLLABLE NWAH -->
+      <map code="0xb1b0" name="1em"/><!-- HANGUL SYLLABLE NWAE -->
+      <map code="0xb1b1" name="1em"/><!-- HANGUL SYLLABLE NWAEG -->
+      <map code="0xb1b2" name="1em"/><!-- HANGUL SYLLABLE NWAEGG -->
+      <map code="0xb1b3" name="1em"/><!-- HANGUL SYLLABLE NWAEGS -->
+      <map code="0xb1b4" name="1em"/><!-- HANGUL SYLLABLE NWAEN -->
+      <map code="0xb1b5" name="1em"/><!-- HANGUL SYLLABLE NWAENJ -->
+      <map code="0xb1b6" name="1em"/><!-- HANGUL SYLLABLE NWAENH -->
+      <map code="0xb1b7" name="1em"/><!-- HANGUL SYLLABLE NWAED -->
+      <map code="0xb1b8" name="1em"/><!-- HANGUL SYLLABLE NWAEL -->
+      <map code="0xb1b9" name="1em"/><!-- HANGUL SYLLABLE NWAELG -->
+      <map code="0xb1ba" name="1em"/><!-- HANGUL SYLLABLE NWAELM -->
+      <map code="0xb1bb" name="1em"/><!-- HANGUL SYLLABLE NWAELB -->
+      <map code="0xb1bc" name="1em"/><!-- HANGUL SYLLABLE NWAELS -->
+      <map code="0xb1bd" name="1em"/><!-- HANGUL SYLLABLE NWAELT -->
+      <map code="0xb1be" name="1em"/><!-- HANGUL SYLLABLE NWAELP -->
+      <map code="0xb1bf" name="1em"/><!-- HANGUL SYLLABLE NWAELH -->
+      <map code="0xb1c0" name="1em"/><!-- HANGUL SYLLABLE NWAEM -->
+      <map code="0xb1c1" name="1em"/><!-- HANGUL SYLLABLE NWAEB -->
+      <map code="0xb1c2" name="1em"/><!-- HANGUL SYLLABLE NWAEBS -->
+      <map code="0xb1c3" name="1em"/><!-- HANGUL SYLLABLE NWAES -->
+      <map code="0xb1c4" name="1em"/><!-- HANGUL SYLLABLE NWAESS -->
+      <map code="0xb1c5" name="1em"/><!-- HANGUL SYLLABLE NWAENG -->
+      <map code="0xb1c6" name="1em"/><!-- HANGUL SYLLABLE NWAEJ -->
+      <map code="0xb1c7" name="1em"/><!-- HANGUL SYLLABLE NWAEC -->
+      <map code="0xb1c8" name="1em"/><!-- HANGUL SYLLABLE NWAEK -->
+      <map code="0xb1c9" name="1em"/><!-- HANGUL SYLLABLE NWAET -->
+      <map code="0xb1ca" name="1em"/><!-- HANGUL SYLLABLE NWAEP -->
+      <map code="0xb1cb" name="1em"/><!-- HANGUL SYLLABLE NWAEH -->
+      <map code="0xb1cc" name="1em"/><!-- HANGUL SYLLABLE NOE -->
+      <map code="0xb1cd" name="1em"/><!-- HANGUL SYLLABLE NOEG -->
+      <map code="0xb1ce" name="1em"/><!-- HANGUL SYLLABLE NOEGG -->
+      <map code="0xb1cf" name="1em"/><!-- HANGUL SYLLABLE NOEGS -->
+      <map code="0xb1d0" name="1em"/><!-- HANGUL SYLLABLE NOEN -->
+      <map code="0xb1d1" name="1em"/><!-- HANGUL SYLLABLE NOENJ -->
+      <map code="0xb1d2" name="1em"/><!-- HANGUL SYLLABLE NOENH -->
+      <map code="0xb1d3" name="1em"/><!-- HANGUL SYLLABLE NOED -->
+      <map code="0xb1d4" name="1em"/><!-- HANGUL SYLLABLE NOEL -->
+      <map code="0xb1d5" name="1em"/><!-- HANGUL SYLLABLE NOELG -->
+      <map code="0xb1d6" name="1em"/><!-- HANGUL SYLLABLE NOELM -->
+      <map code="0xb1d7" name="1em"/><!-- HANGUL SYLLABLE NOELB -->
+      <map code="0xb1d8" name="1em"/><!-- HANGUL SYLLABLE NOELS -->
+      <map code="0xb1d9" name="1em"/><!-- HANGUL SYLLABLE NOELT -->
+      <map code="0xb1da" name="1em"/><!-- HANGUL SYLLABLE NOELP -->
+      <map code="0xb1db" name="1em"/><!-- HANGUL SYLLABLE NOELH -->
+      <map code="0xb1dc" name="1em"/><!-- HANGUL SYLLABLE NOEM -->
+      <map code="0xb1dd" name="1em"/><!-- HANGUL SYLLABLE NOEB -->
+      <map code="0xb1de" name="1em"/><!-- HANGUL SYLLABLE NOEBS -->
+      <map code="0xb1df" name="1em"/><!-- HANGUL SYLLABLE NOES -->
+      <map code="0xb1e0" name="1em"/><!-- HANGUL SYLLABLE NOESS -->
+      <map code="0xb1e1" name="1em"/><!-- HANGUL SYLLABLE NOENG -->
+      <map code="0xb1e2" name="1em"/><!-- HANGUL SYLLABLE NOEJ -->
+      <map code="0xb1e3" name="1em"/><!-- HANGUL SYLLABLE NOEC -->
+      <map code="0xb1e4" name="1em"/><!-- HANGUL SYLLABLE NOEK -->
+      <map code="0xb1e5" name="1em"/><!-- HANGUL SYLLABLE NOET -->
+      <map code="0xb1e6" name="1em"/><!-- HANGUL SYLLABLE NOEP -->
+      <map code="0xb1e7" name="1em"/><!-- HANGUL SYLLABLE NOEH -->
+      <map code="0xb1e8" name="1em"/><!-- HANGUL SYLLABLE NYO -->
+      <map code="0xb1e9" name="1em"/><!-- HANGUL SYLLABLE NYOG -->
+      <map code="0xb1ea" name="1em"/><!-- HANGUL SYLLABLE NYOGG -->
+      <map code="0xb1eb" name="1em"/><!-- HANGUL SYLLABLE NYOGS -->
+      <map code="0xb1ec" name="1em"/><!-- HANGUL SYLLABLE NYON -->
+      <map code="0xb1ed" name="1em"/><!-- HANGUL SYLLABLE NYONJ -->
+      <map code="0xb1ee" name="1em"/><!-- HANGUL SYLLABLE NYONH -->
+      <map code="0xb1ef" name="1em"/><!-- HANGUL SYLLABLE NYOD -->
+      <map code="0xb1f0" name="1em"/><!-- HANGUL SYLLABLE NYOL -->
+      <map code="0xb1f1" name="1em"/><!-- HANGUL SYLLABLE NYOLG -->
+      <map code="0xb1f2" name="1em"/><!-- HANGUL SYLLABLE NYOLM -->
+      <map code="0xb1f3" name="1em"/><!-- HANGUL SYLLABLE NYOLB -->
+      <map code="0xb1f4" name="1em"/><!-- HANGUL SYLLABLE NYOLS -->
+      <map code="0xb1f5" name="1em"/><!-- HANGUL SYLLABLE NYOLT -->
+      <map code="0xb1f6" name="1em"/><!-- HANGUL SYLLABLE NYOLP -->
+      <map code="0xb1f7" name="1em"/><!-- HANGUL SYLLABLE NYOLH -->
+      <map code="0xb1f8" name="1em"/><!-- HANGUL SYLLABLE NYOM -->
+      <map code="0xb1f9" name="1em"/><!-- HANGUL SYLLABLE NYOB -->
+      <map code="0xb1fa" name="1em"/><!-- HANGUL SYLLABLE NYOBS -->
+      <map code="0xb1fb" name="1em"/><!-- HANGUL SYLLABLE NYOS -->
+      <map code="0xb1fc" name="1em"/><!-- HANGUL SYLLABLE NYOSS -->
+      <map code="0xb1fd" name="1em"/><!-- HANGUL SYLLABLE NYONG -->
+      <map code="0xb1fe" name="1em"/><!-- HANGUL SYLLABLE NYOJ -->
+      <map code="0xb1ff" name="1em"/><!-- HANGUL SYLLABLE NYOC -->
+      <map code="0xb200" name="1em"/><!-- HANGUL SYLLABLE NYOK -->
+      <map code="0xb201" name="1em"/><!-- HANGUL SYLLABLE NYOT -->
+      <map code="0xb202" name="1em"/><!-- HANGUL SYLLABLE NYOP -->
+      <map code="0xb203" name="1em"/><!-- HANGUL SYLLABLE NYOH -->
+      <map code="0xb204" name="1em"/><!-- HANGUL SYLLABLE NU -->
+      <map code="0xb205" name="1em"/><!-- HANGUL SYLLABLE NUG -->
+      <map code="0xb206" name="1em"/><!-- HANGUL SYLLABLE NUGG -->
+      <map code="0xb207" name="1em"/><!-- HANGUL SYLLABLE NUGS -->
+      <map code="0xb208" name="1em"/><!-- HANGUL SYLLABLE NUN -->
+      <map code="0xb209" name="1em"/><!-- HANGUL SYLLABLE NUNJ -->
+      <map code="0xb20a" name="1em"/><!-- HANGUL SYLLABLE NUNH -->
+      <map code="0xb20b" name="1em"/><!-- HANGUL SYLLABLE NUD -->
+      <map code="0xb20c" name="1em"/><!-- HANGUL SYLLABLE NUL -->
+      <map code="0xb20d" name="1em"/><!-- HANGUL SYLLABLE NULG -->
+      <map code="0xb20e" name="1em"/><!-- HANGUL SYLLABLE NULM -->
+      <map code="0xb20f" name="1em"/><!-- HANGUL SYLLABLE NULB -->
+      <map code="0xb210" name="1em"/><!-- HANGUL SYLLABLE NULS -->
+      <map code="0xb211" name="1em"/><!-- HANGUL SYLLABLE NULT -->
+      <map code="0xb212" name="1em"/><!-- HANGUL SYLLABLE NULP -->
+      <map code="0xb213" name="1em"/><!-- HANGUL SYLLABLE NULH -->
+      <map code="0xb214" name="1em"/><!-- HANGUL SYLLABLE NUM -->
+      <map code="0xb215" name="1em"/><!-- HANGUL SYLLABLE NUB -->
+      <map code="0xb216" name="1em"/><!-- HANGUL SYLLABLE NUBS -->
+      <map code="0xb217" name="1em"/><!-- HANGUL SYLLABLE NUS -->
+      <map code="0xb218" name="1em"/><!-- HANGUL SYLLABLE NUSS -->
+      <map code="0xb219" name="1em"/><!-- HANGUL SYLLABLE NUNG -->
+      <map code="0xb21a" name="1em"/><!-- HANGUL SYLLABLE NUJ -->
+      <map code="0xb21b" name="1em"/><!-- HANGUL SYLLABLE NUC -->
+      <map code="0xb21c" name="1em"/><!-- HANGUL SYLLABLE NUK -->
+      <map code="0xb21d" name="1em"/><!-- HANGUL SYLLABLE NUT -->
+      <map code="0xb21e" name="1em"/><!-- HANGUL SYLLABLE NUP -->
+      <map code="0xb21f" name="1em"/><!-- HANGUL SYLLABLE NUH -->
+      <map code="0xb220" name="1em"/><!-- HANGUL SYLLABLE NWEO -->
+      <map code="0xb221" name="1em"/><!-- HANGUL SYLLABLE NWEOG -->
+      <map code="0xb222" name="1em"/><!-- HANGUL SYLLABLE NWEOGG -->
+      <map code="0xb223" name="1em"/><!-- HANGUL SYLLABLE NWEOGS -->
+      <map code="0xb224" name="1em"/><!-- HANGUL SYLLABLE NWEON -->
+      <map code="0xb225" name="1em"/><!-- HANGUL SYLLABLE NWEONJ -->
+      <map code="0xb226" name="1em"/><!-- HANGUL SYLLABLE NWEONH -->
+      <map code="0xb227" name="1em"/><!-- HANGUL SYLLABLE NWEOD -->
+      <map code="0xb228" name="1em"/><!-- HANGUL SYLLABLE NWEOL -->
+      <map code="0xb229" name="1em"/><!-- HANGUL SYLLABLE NWEOLG -->
+      <map code="0xb22a" name="1em"/><!-- HANGUL SYLLABLE NWEOLM -->
+      <map code="0xb22b" name="1em"/><!-- HANGUL SYLLABLE NWEOLB -->
+      <map code="0xb22c" name="1em"/><!-- HANGUL SYLLABLE NWEOLS -->
+      <map code="0xb22d" name="1em"/><!-- HANGUL SYLLABLE NWEOLT -->
+      <map code="0xb22e" name="1em"/><!-- HANGUL SYLLABLE NWEOLP -->
+      <map code="0xb22f" name="1em"/><!-- HANGUL SYLLABLE NWEOLH -->
+      <map code="0xb230" name="1em"/><!-- HANGUL SYLLABLE NWEOM -->
+      <map code="0xb231" name="1em"/><!-- HANGUL SYLLABLE NWEOB -->
+      <map code="0xb232" name="1em"/><!-- HANGUL SYLLABLE NWEOBS -->
+      <map code="0xb233" name="1em"/><!-- HANGUL SYLLABLE NWEOS -->
+      <map code="0xb234" name="1em"/><!-- HANGUL SYLLABLE NWEOSS -->
+      <map code="0xb235" name="1em"/><!-- HANGUL SYLLABLE NWEONG -->
+      <map code="0xb236" name="1em"/><!-- HANGUL SYLLABLE NWEOJ -->
+      <map code="0xb237" name="1em"/><!-- HANGUL SYLLABLE NWEOC -->
+      <map code="0xb238" name="1em"/><!-- HANGUL SYLLABLE NWEOK -->
+      <map code="0xb239" name="1em"/><!-- HANGUL SYLLABLE NWEOT -->
+      <map code="0xb23a" name="1em"/><!-- HANGUL SYLLABLE NWEOP -->
+      <map code="0xb23b" name="1em"/><!-- HANGUL SYLLABLE NWEOH -->
+      <map code="0xb23c" name="1em"/><!-- HANGUL SYLLABLE NWE -->
+      <map code="0xb23d" name="1em"/><!-- HANGUL SYLLABLE NWEG -->
+      <map code="0xb23e" name="1em"/><!-- HANGUL SYLLABLE NWEGG -->
+      <map code="0xb23f" name="1em"/><!-- HANGUL SYLLABLE NWEGS -->
+      <map code="0xb240" name="1em"/><!-- HANGUL SYLLABLE NWEN -->
+      <map code="0xb241" name="1em"/><!-- HANGUL SYLLABLE NWENJ -->
+      <map code="0xb242" name="1em"/><!-- HANGUL SYLLABLE NWENH -->
+      <map code="0xb243" name="1em"/><!-- HANGUL SYLLABLE NWED -->
+      <map code="0xb244" name="1em"/><!-- HANGUL SYLLABLE NWEL -->
+      <map code="0xb245" name="1em"/><!-- HANGUL SYLLABLE NWELG -->
+      <map code="0xb246" name="1em"/><!-- HANGUL SYLLABLE NWELM -->
+      <map code="0xb247" name="1em"/><!-- HANGUL SYLLABLE NWELB -->
+      <map code="0xb248" name="1em"/><!-- HANGUL SYLLABLE NWELS -->
+      <map code="0xb249" name="1em"/><!-- HANGUL SYLLABLE NWELT -->
+      <map code="0xb24a" name="1em"/><!-- HANGUL SYLLABLE NWELP -->
+      <map code="0xb24b" name="1em"/><!-- HANGUL SYLLABLE NWELH -->
+      <map code="0xb24c" name="1em"/><!-- HANGUL SYLLABLE NWEM -->
+      <map code="0xb24d" name="1em"/><!-- HANGUL SYLLABLE NWEB -->
+      <map code="0xb24e" name="1em"/><!-- HANGUL SYLLABLE NWEBS -->
+      <map code="0xb24f" name="1em"/><!-- HANGUL SYLLABLE NWES -->
+      <map code="0xb250" name="1em"/><!-- HANGUL SYLLABLE NWESS -->
+      <map code="0xb251" name="1em"/><!-- HANGUL SYLLABLE NWENG -->
+      <map code="0xb252" name="1em"/><!-- HANGUL SYLLABLE NWEJ -->
+      <map code="0xb253" name="1em"/><!-- HANGUL SYLLABLE NWEC -->
+      <map code="0xb254" name="1em"/><!-- HANGUL SYLLABLE NWEK -->
+      <map code="0xb255" name="1em"/><!-- HANGUL SYLLABLE NWET -->
+      <map code="0xb256" name="1em"/><!-- HANGUL SYLLABLE NWEP -->
+      <map code="0xb257" name="1em"/><!-- HANGUL SYLLABLE NWEH -->
+      <map code="0xb258" name="1em"/><!-- HANGUL SYLLABLE NWI -->
+      <map code="0xb259" name="1em"/><!-- HANGUL SYLLABLE NWIG -->
+      <map code="0xb25a" name="1em"/><!-- HANGUL SYLLABLE NWIGG -->
+      <map code="0xb25b" name="1em"/><!-- HANGUL SYLLABLE NWIGS -->
+      <map code="0xb25c" name="1em"/><!-- HANGUL SYLLABLE NWIN -->
+      <map code="0xb25d" name="1em"/><!-- HANGUL SYLLABLE NWINJ -->
+      <map code="0xb25e" name="1em"/><!-- HANGUL SYLLABLE NWINH -->
+      <map code="0xb25f" name="1em"/><!-- HANGUL SYLLABLE NWID -->
+      <map code="0xb260" name="1em"/><!-- HANGUL SYLLABLE NWIL -->
+      <map code="0xb261" name="1em"/><!-- HANGUL SYLLABLE NWILG -->
+      <map code="0xb262" name="1em"/><!-- HANGUL SYLLABLE NWILM -->
+      <map code="0xb263" name="1em"/><!-- HANGUL SYLLABLE NWILB -->
+      <map code="0xb264" name="1em"/><!-- HANGUL SYLLABLE NWILS -->
+      <map code="0xb265" name="1em"/><!-- HANGUL SYLLABLE NWILT -->
+      <map code="0xb266" name="1em"/><!-- HANGUL SYLLABLE NWILP -->
+      <map code="0xb267" name="1em"/><!-- HANGUL SYLLABLE NWILH -->
+      <map code="0xb268" name="1em"/><!-- HANGUL SYLLABLE NWIM -->
+      <map code="0xb269" name="1em"/><!-- HANGUL SYLLABLE NWIB -->
+      <map code="0xb26a" name="1em"/><!-- HANGUL SYLLABLE NWIBS -->
+      <map code="0xb26b" name="1em"/><!-- HANGUL SYLLABLE NWIS -->
+      <map code="0xb26c" name="1em"/><!-- HANGUL SYLLABLE NWISS -->
+      <map code="0xb26d" name="1em"/><!-- HANGUL SYLLABLE NWING -->
+      <map code="0xb26e" name="1em"/><!-- HANGUL SYLLABLE NWIJ -->
+      <map code="0xb26f" name="1em"/><!-- HANGUL SYLLABLE NWIC -->
+      <map code="0xb270" name="1em"/><!-- HANGUL SYLLABLE NWIK -->
+      <map code="0xb271" name="1em"/><!-- HANGUL SYLLABLE NWIT -->
+      <map code="0xb272" name="1em"/><!-- HANGUL SYLLABLE NWIP -->
+      <map code="0xb273" name="1em"/><!-- HANGUL SYLLABLE NWIH -->
+      <map code="0xb274" name="1em"/><!-- HANGUL SYLLABLE NYU -->
+      <map code="0xb275" name="1em"/><!-- HANGUL SYLLABLE NYUG -->
+      <map code="0xb276" name="1em"/><!-- HANGUL SYLLABLE NYUGG -->
+      <map code="0xb277" name="1em"/><!-- HANGUL SYLLABLE NYUGS -->
+      <map code="0xb278" name="1em"/><!-- HANGUL SYLLABLE NYUN -->
+      <map code="0xb279" name="1em"/><!-- HANGUL SYLLABLE NYUNJ -->
+      <map code="0xb27a" name="1em"/><!-- HANGUL SYLLABLE NYUNH -->
+      <map code="0xb27b" name="1em"/><!-- HANGUL SYLLABLE NYUD -->
+      <map code="0xb27c" name="1em"/><!-- HANGUL SYLLABLE NYUL -->
+      <map code="0xb27d" name="1em"/><!-- HANGUL SYLLABLE NYULG -->
+      <map code="0xb27e" name="1em"/><!-- HANGUL SYLLABLE NYULM -->
+      <map code="0xb27f" name="1em"/><!-- HANGUL SYLLABLE NYULB -->
+      <map code="0xb280" name="1em"/><!-- HANGUL SYLLABLE NYULS -->
+      <map code="0xb281" name="1em"/><!-- HANGUL SYLLABLE NYULT -->
+      <map code="0xb282" name="1em"/><!-- HANGUL SYLLABLE NYULP -->
+      <map code="0xb283" name="1em"/><!-- HANGUL SYLLABLE NYULH -->
+      <map code="0xb284" name="1em"/><!-- HANGUL SYLLABLE NYUM -->
+      <map code="0xb285" name="1em"/><!-- HANGUL SYLLABLE NYUB -->
+      <map code="0xb286" name="1em"/><!-- HANGUL SYLLABLE NYUBS -->
+      <map code="0xb287" name="1em"/><!-- HANGUL SYLLABLE NYUS -->
+      <map code="0xb288" name="1em"/><!-- HANGUL SYLLABLE NYUSS -->
+      <map code="0xb289" name="1em"/><!-- HANGUL SYLLABLE NYUNG -->
+      <map code="0xb28a" name="1em"/><!-- HANGUL SYLLABLE NYUJ -->
+      <map code="0xb28b" name="1em"/><!-- HANGUL SYLLABLE NYUC -->
+      <map code="0xb28c" name="1em"/><!-- HANGUL SYLLABLE NYUK -->
+      <map code="0xb28d" name="1em"/><!-- HANGUL SYLLABLE NYUT -->
+      <map code="0xb28e" name="1em"/><!-- HANGUL SYLLABLE NYUP -->
+      <map code="0xb28f" name="1em"/><!-- HANGUL SYLLABLE NYUH -->
+      <map code="0xb290" name="1em"/><!-- HANGUL SYLLABLE NEU -->
+      <map code="0xb291" name="1em"/><!-- HANGUL SYLLABLE NEUG -->
+      <map code="0xb292" name="1em"/><!-- HANGUL SYLLABLE NEUGG -->
+      <map code="0xb293" name="1em"/><!-- HANGUL SYLLABLE NEUGS -->
+      <map code="0xb294" name="1em"/><!-- HANGUL SYLLABLE NEUN -->
+      <map code="0xb295" name="1em"/><!-- HANGUL SYLLABLE NEUNJ -->
+      <map code="0xb296" name="1em"/><!-- HANGUL SYLLABLE NEUNH -->
+      <map code="0xb297" name="1em"/><!-- HANGUL SYLLABLE NEUD -->
+      <map code="0xb298" name="1em"/><!-- HANGUL SYLLABLE NEUL -->
+      <map code="0xb299" name="1em"/><!-- HANGUL SYLLABLE NEULG -->
+      <map code="0xb29a" name="1em"/><!-- HANGUL SYLLABLE NEULM -->
+      <map code="0xb29b" name="1em"/><!-- HANGUL SYLLABLE NEULB -->
+      <map code="0xb29c" name="1em"/><!-- HANGUL SYLLABLE NEULS -->
+      <map code="0xb29d" name="1em"/><!-- HANGUL SYLLABLE NEULT -->
+      <map code="0xb29e" name="1em"/><!-- HANGUL SYLLABLE NEULP -->
+      <map code="0xb29f" name="1em"/><!-- HANGUL SYLLABLE NEULH -->
+      <map code="0xb2a0" name="1em"/><!-- HANGUL SYLLABLE NEUM -->
+      <map code="0xb2a1" name="1em"/><!-- HANGUL SYLLABLE NEUB -->
+      <map code="0xb2a2" name="1em"/><!-- HANGUL SYLLABLE NEUBS -->
+      <map code="0xb2a3" name="1em"/><!-- HANGUL SYLLABLE NEUS -->
+      <map code="0xb2a4" name="1em"/><!-- HANGUL SYLLABLE NEUSS -->
+      <map code="0xb2a5" name="1em"/><!-- HANGUL SYLLABLE NEUNG -->
+      <map code="0xb2a6" name="1em"/><!-- HANGUL SYLLABLE NEUJ -->
+      <map code="0xb2a7" name="1em"/><!-- HANGUL SYLLABLE NEUC -->
+      <map code="0xb2a8" name="1em"/><!-- HANGUL SYLLABLE NEUK -->
+      <map code="0xb2a9" name="1em"/><!-- HANGUL SYLLABLE NEUT -->
+      <map code="0xb2aa" name="1em"/><!-- HANGUL SYLLABLE NEUP -->
+      <map code="0xb2ab" name="1em"/><!-- HANGUL SYLLABLE NEUH -->
+      <map code="0xb2ac" name="1em"/><!-- HANGUL SYLLABLE NYI -->
+      <map code="0xb2ad" name="1em"/><!-- HANGUL SYLLABLE NYIG -->
+      <map code="0xb2ae" name="1em"/><!-- HANGUL SYLLABLE NYIGG -->
+      <map code="0xb2af" name="1em"/><!-- HANGUL SYLLABLE NYIGS -->
+      <map code="0xb2b0" name="1em"/><!-- HANGUL SYLLABLE NYIN -->
+      <map code="0xb2b1" name="1em"/><!-- HANGUL SYLLABLE NYINJ -->
+      <map code="0xb2b2" name="1em"/><!-- HANGUL SYLLABLE NYINH -->
+      <map code="0xb2b3" name="1em"/><!-- HANGUL SYLLABLE NYID -->
+      <map code="0xb2b4" name="1em"/><!-- HANGUL SYLLABLE NYIL -->
+      <map code="0xb2b5" name="1em"/><!-- HANGUL SYLLABLE NYILG -->
+      <map code="0xb2b6" name="1em"/><!-- HANGUL SYLLABLE NYILM -->
+      <map code="0xb2b7" name="1em"/><!-- HANGUL SYLLABLE NYILB -->
+      <map code="0xb2b8" name="1em"/><!-- HANGUL SYLLABLE NYILS -->
+      <map code="0xb2b9" name="1em"/><!-- HANGUL SYLLABLE NYILT -->
+      <map code="0xb2ba" name="1em"/><!-- HANGUL SYLLABLE NYILP -->
+      <map code="0xb2bb" name="1em"/><!-- HANGUL SYLLABLE NYILH -->
+      <map code="0xb2bc" name="1em"/><!-- HANGUL SYLLABLE NYIM -->
+      <map code="0xb2bd" name="1em"/><!-- HANGUL SYLLABLE NYIB -->
+      <map code="0xb2be" name="1em"/><!-- HANGUL SYLLABLE NYIBS -->
+      <map code="0xb2bf" name="1em"/><!-- HANGUL SYLLABLE NYIS -->
+      <map code="0xb2c0" name="1em"/><!-- HANGUL SYLLABLE NYISS -->
+      <map code="0xb2c1" name="1em"/><!-- HANGUL SYLLABLE NYING -->
+      <map code="0xb2c2" name="1em"/><!-- HANGUL SYLLABLE NYIJ -->
+      <map code="0xb2c3" name="1em"/><!-- HANGUL SYLLABLE NYIC -->
+      <map code="0xb2c4" name="1em"/><!-- HANGUL SYLLABLE NYIK -->
+      <map code="0xb2c5" name="1em"/><!-- HANGUL SYLLABLE NYIT -->
+      <map code="0xb2c6" name="1em"/><!-- HANGUL SYLLABLE NYIP -->
+      <map code="0xb2c7" name="1em"/><!-- HANGUL SYLLABLE NYIH -->
+      <map code="0xb2c8" name="1em"/><!-- HANGUL SYLLABLE NI -->
+      <map code="0xb2c9" name="1em"/><!-- HANGUL SYLLABLE NIG -->
+      <map code="0xb2ca" name="1em"/><!-- HANGUL SYLLABLE NIGG -->
+      <map code="0xb2cb" name="1em"/><!-- HANGUL SYLLABLE NIGS -->
+      <map code="0xb2cc" name="1em"/><!-- HANGUL SYLLABLE NIN -->
+      <map code="0xb2cd" name="1em"/><!-- HANGUL SYLLABLE NINJ -->
+      <map code="0xb2ce" name="1em"/><!-- HANGUL SYLLABLE NINH -->
+      <map code="0xb2cf" name="1em"/><!-- HANGUL SYLLABLE NID -->
+      <map code="0xb2d0" name="1em"/><!-- HANGUL SYLLABLE NIL -->
+      <map code="0xb2d1" name="1em"/><!-- HANGUL SYLLABLE NILG -->
+      <map code="0xb2d2" name="1em"/><!-- HANGUL SYLLABLE NILM -->
+      <map code="0xb2d3" name="1em"/><!-- HANGUL SYLLABLE NILB -->
+      <map code="0xb2d4" name="1em"/><!-- HANGUL SYLLABLE NILS -->
+      <map code="0xb2d5" name="1em"/><!-- HANGUL SYLLABLE NILT -->
+      <map code="0xb2d6" name="1em"/><!-- HANGUL SYLLABLE NILP -->
+      <map code="0xb2d7" name="1em"/><!-- HANGUL SYLLABLE NILH -->
+      <map code="0xb2d8" name="1em"/><!-- HANGUL SYLLABLE NIM -->
+      <map code="0xb2d9" name="1em"/><!-- HANGUL SYLLABLE NIB -->
+      <map code="0xb2da" name="1em"/><!-- HANGUL SYLLABLE NIBS -->
+      <map code="0xb2db" name="1em"/><!-- HANGUL SYLLABLE NIS -->
+      <map code="0xb2dc" name="1em"/><!-- HANGUL SYLLABLE NISS -->
+      <map code="0xb2dd" name="1em"/><!-- HANGUL SYLLABLE NING -->
+      <map code="0xb2de" name="1em"/><!-- HANGUL SYLLABLE NIJ -->
+      <map code="0xb2df" name="1em"/><!-- HANGUL SYLLABLE NIC -->
+      <map code="0xb2e0" name="1em"/><!-- HANGUL SYLLABLE NIK -->
+      <map code="0xb2e1" name="1em"/><!-- HANGUL SYLLABLE NIT -->
+      <map code="0xb2e2" name="1em"/><!-- HANGUL SYLLABLE NIP -->
+      <map code="0xb2e3" name="1em"/><!-- HANGUL SYLLABLE NIH -->
+      <map code="0xb2e4" name="1em"/><!-- HANGUL SYLLABLE DA -->
+      <map code="0xb2e5" name="1em"/><!-- HANGUL SYLLABLE DAG -->
+      <map code="0xb2e6" name="1em"/><!-- HANGUL SYLLABLE DAGG -->
+      <map code="0xb2e7" name="1em"/><!-- HANGUL SYLLABLE DAGS -->
+      <map code="0xb2e8" name="1em"/><!-- HANGUL SYLLABLE DAN -->
+      <map code="0xb2e9" name="1em"/><!-- HANGUL SYLLABLE DANJ -->
+      <map code="0xb2ea" name="1em"/><!-- HANGUL SYLLABLE DANH -->
+      <map code="0xb2eb" name="1em"/><!-- HANGUL SYLLABLE DAD -->
+      <map code="0xb2ec" name="1em"/><!-- HANGUL SYLLABLE DAL -->
+      <map code="0xb2ed" name="1em"/><!-- HANGUL SYLLABLE DALG -->
+      <map code="0xb2ee" name="1em"/><!-- HANGUL SYLLABLE DALM -->
+      <map code="0xb2ef" name="1em"/><!-- HANGUL SYLLABLE DALB -->
+      <map code="0xb2f0" name="1em"/><!-- HANGUL SYLLABLE DALS -->
+      <map code="0xb2f1" name="1em"/><!-- HANGUL SYLLABLE DALT -->
+      <map code="0xb2f2" name="1em"/><!-- HANGUL SYLLABLE DALP -->
+      <map code="0xb2f3" name="1em"/><!-- HANGUL SYLLABLE DALH -->
+      <map code="0xb2f4" name="1em"/><!-- HANGUL SYLLABLE DAM -->
+      <map code="0xb2f5" name="1em"/><!-- HANGUL SYLLABLE DAB -->
+      <map code="0xb2f6" name="1em"/><!-- HANGUL SYLLABLE DABS -->
+      <map code="0xb2f7" name="1em"/><!-- HANGUL SYLLABLE DAS -->
+      <map code="0xb2f8" name="1em"/><!-- HANGUL SYLLABLE DASS -->
+      <map code="0xb2f9" name="1em"/><!-- HANGUL SYLLABLE DANG -->
+      <map code="0xb2fa" name="1em"/><!-- HANGUL SYLLABLE DAJ -->
+      <map code="0xb2fb" name="1em"/><!-- HANGUL SYLLABLE DAC -->
+      <map code="0xb2fc" name="1em"/><!-- HANGUL SYLLABLE DAK -->
+      <map code="0xb2fd" name="1em"/><!-- HANGUL SYLLABLE DAT -->
+      <map code="0xb2fe" name="1em"/><!-- HANGUL SYLLABLE DAP -->
+      <map code="0xb2ff" name="1em"/><!-- HANGUL SYLLABLE DAH -->
+      <map code="0xb300" name="1em"/><!-- HANGUL SYLLABLE DAE -->
+      <map code="0xb301" name="1em"/><!-- HANGUL SYLLABLE DAEG -->
+      <map code="0xb302" name="1em"/><!-- HANGUL SYLLABLE DAEGG -->
+      <map code="0xb303" name="1em"/><!-- HANGUL SYLLABLE DAEGS -->
+      <map code="0xb304" name="1em"/><!-- HANGUL SYLLABLE DAEN -->
+      <map code="0xb305" name="1em"/><!-- HANGUL SYLLABLE DAENJ -->
+      <map code="0xb306" name="1em"/><!-- HANGUL SYLLABLE DAENH -->
+      <map code="0xb307" name="1em"/><!-- HANGUL SYLLABLE DAED -->
+      <map code="0xb308" name="1em"/><!-- HANGUL SYLLABLE DAEL -->
+      <map code="0xb309" name="1em"/><!-- HANGUL SYLLABLE DAELG -->
+      <map code="0xb30a" name="1em"/><!-- HANGUL SYLLABLE DAELM -->
+      <map code="0xb30b" name="1em"/><!-- HANGUL SYLLABLE DAELB -->
+      <map code="0xb30c" name="1em"/><!-- HANGUL SYLLABLE DAELS -->
+      <map code="0xb30d" name="1em"/><!-- HANGUL SYLLABLE DAELT -->
+      <map code="0xb30e" name="1em"/><!-- HANGUL SYLLABLE DAELP -->
+      <map code="0xb30f" name="1em"/><!-- HANGUL SYLLABLE DAELH -->
+      <map code="0xb310" name="1em"/><!-- HANGUL SYLLABLE DAEM -->
+      <map code="0xb311" name="1em"/><!-- HANGUL SYLLABLE DAEB -->
+      <map code="0xb312" name="1em"/><!-- HANGUL SYLLABLE DAEBS -->
+      <map code="0xb313" name="1em"/><!-- HANGUL SYLLABLE DAES -->
+      <map code="0xb314" name="1em"/><!-- HANGUL SYLLABLE DAESS -->
+      <map code="0xb315" name="1em"/><!-- HANGUL SYLLABLE DAENG -->
+      <map code="0xb316" name="1em"/><!-- HANGUL SYLLABLE DAEJ -->
+      <map code="0xb317" name="1em"/><!-- HANGUL SYLLABLE DAEC -->
+      <map code="0xb318" name="1em"/><!-- HANGUL SYLLABLE DAEK -->
+      <map code="0xb319" name="1em"/><!-- HANGUL SYLLABLE DAET -->
+      <map code="0xb31a" name="1em"/><!-- HANGUL SYLLABLE DAEP -->
+      <map code="0xb31b" name="1em"/><!-- HANGUL SYLLABLE DAEH -->
+      <map code="0xb31c" name="1em"/><!-- HANGUL SYLLABLE DYA -->
+      <map code="0xb31d" name="1em"/><!-- HANGUL SYLLABLE DYAG -->
+      <map code="0xb31e" name="1em"/><!-- HANGUL SYLLABLE DYAGG -->
+      <map code="0xb31f" name="1em"/><!-- HANGUL SYLLABLE DYAGS -->
+      <map code="0xb320" name="1em"/><!-- HANGUL SYLLABLE DYAN -->
+      <map code="0xb321" name="1em"/><!-- HANGUL SYLLABLE DYANJ -->
+      <map code="0xb322" name="1em"/><!-- HANGUL SYLLABLE DYANH -->
+      <map code="0xb323" name="1em"/><!-- HANGUL SYLLABLE DYAD -->
+      <map code="0xb324" name="1em"/><!-- HANGUL SYLLABLE DYAL -->
+      <map code="0xb325" name="1em"/><!-- HANGUL SYLLABLE DYALG -->
+      <map code="0xb326" name="1em"/><!-- HANGUL SYLLABLE DYALM -->
+      <map code="0xb327" name="1em"/><!-- HANGUL SYLLABLE DYALB -->
+      <map code="0xb328" name="1em"/><!-- HANGUL SYLLABLE DYALS -->
+      <map code="0xb329" name="1em"/><!-- HANGUL SYLLABLE DYALT -->
+      <map code="0xb32a" name="1em"/><!-- HANGUL SYLLABLE DYALP -->
+      <map code="0xb32b" name="1em"/><!-- HANGUL SYLLABLE DYALH -->
+      <map code="0xb32c" name="1em"/><!-- HANGUL SYLLABLE DYAM -->
+      <map code="0xb32d" name="1em"/><!-- HANGUL SYLLABLE DYAB -->
+      <map code="0xb32e" name="1em"/><!-- HANGUL SYLLABLE DYABS -->
+      <map code="0xb32f" name="1em"/><!-- HANGUL SYLLABLE DYAS -->
+      <map code="0xb330" name="1em"/><!-- HANGUL SYLLABLE DYASS -->
+      <map code="0xb331" name="1em"/><!-- HANGUL SYLLABLE DYANG -->
+      <map code="0xb332" name="1em"/><!-- HANGUL SYLLABLE DYAJ -->
+      <map code="0xb333" name="1em"/><!-- HANGUL SYLLABLE DYAC -->
+      <map code="0xb334" name="1em"/><!-- HANGUL SYLLABLE DYAK -->
+      <map code="0xb335" name="1em"/><!-- HANGUL SYLLABLE DYAT -->
+      <map code="0xb336" name="1em"/><!-- HANGUL SYLLABLE DYAP -->
+      <map code="0xb337" name="1em"/><!-- HANGUL SYLLABLE DYAH -->
+      <map code="0xb338" name="1em"/><!-- HANGUL SYLLABLE DYAE -->
+      <map code="0xb339" name="1em"/><!-- HANGUL SYLLABLE DYAEG -->
+      <map code="0xb33a" name="1em"/><!-- HANGUL SYLLABLE DYAEGG -->
+      <map code="0xb33b" name="1em"/><!-- HANGUL SYLLABLE DYAEGS -->
+      <map code="0xb33c" name="1em"/><!-- HANGUL SYLLABLE DYAEN -->
+      <map code="0xb33d" name="1em"/><!-- HANGUL SYLLABLE DYAENJ -->
+      <map code="0xb33e" name="1em"/><!-- HANGUL SYLLABLE DYAENH -->
+      <map code="0xb33f" name="1em"/><!-- HANGUL SYLLABLE DYAED -->
+      <map code="0xb340" name="1em"/><!-- HANGUL SYLLABLE DYAEL -->
+      <map code="0xb341" name="1em"/><!-- HANGUL SYLLABLE DYAELG -->
+      <map code="0xb342" name="1em"/><!-- HANGUL SYLLABLE DYAELM -->
+      <map code="0xb343" name="1em"/><!-- HANGUL SYLLABLE DYAELB -->
+      <map code="0xb344" name="1em"/><!-- HANGUL SYLLABLE DYAELS -->
+      <map code="0xb345" name="1em"/><!-- HANGUL SYLLABLE DYAELT -->
+      <map code="0xb346" name="1em"/><!-- HANGUL SYLLABLE DYAELP -->
+      <map code="0xb347" name="1em"/><!-- HANGUL SYLLABLE DYAELH -->
+      <map code="0xb348" name="1em"/><!-- HANGUL SYLLABLE DYAEM -->
+      <map code="0xb349" name="1em"/><!-- HANGUL SYLLABLE DYAEB -->
+      <map code="0xb34a" name="1em"/><!-- HANGUL SYLLABLE DYAEBS -->
+      <map code="0xb34b" name="1em"/><!-- HANGUL SYLLABLE DYAES -->
+      <map code="0xb34c" name="1em"/><!-- HANGUL SYLLABLE DYAESS -->
+      <map code="0xb34d" name="1em"/><!-- HANGUL SYLLABLE DYAENG -->
+      <map code="0xb34e" name="1em"/><!-- HANGUL SYLLABLE DYAEJ -->
+      <map code="0xb34f" name="1em"/><!-- HANGUL SYLLABLE DYAEC -->
+      <map code="0xb350" name="1em"/><!-- HANGUL SYLLABLE DYAEK -->
+      <map code="0xb351" name="1em"/><!-- HANGUL SYLLABLE DYAET -->
+      <map code="0xb352" name="1em"/><!-- HANGUL SYLLABLE DYAEP -->
+      <map code="0xb353" name="1em"/><!-- HANGUL SYLLABLE DYAEH -->
+      <map code="0xb354" name="1em"/><!-- HANGUL SYLLABLE DEO -->
+      <map code="0xb355" name="1em"/><!-- HANGUL SYLLABLE DEOG -->
+      <map code="0xb356" name="1em"/><!-- HANGUL SYLLABLE DEOGG -->
+      <map code="0xb357" name="1em"/><!-- HANGUL SYLLABLE DEOGS -->
+      <map code="0xb358" name="1em"/><!-- HANGUL SYLLABLE DEON -->
+      <map code="0xb359" name="1em"/><!-- HANGUL SYLLABLE DEONJ -->
+      <map code="0xb35a" name="1em"/><!-- HANGUL SYLLABLE DEONH -->
+      <map code="0xb35b" name="1em"/><!-- HANGUL SYLLABLE DEOD -->
+      <map code="0xb35c" name="1em"/><!-- HANGUL SYLLABLE DEOL -->
+      <map code="0xb35d" name="1em"/><!-- HANGUL SYLLABLE DEOLG -->
+      <map code="0xb35e" name="1em"/><!-- HANGUL SYLLABLE DEOLM -->
+      <map code="0xb35f" name="1em"/><!-- HANGUL SYLLABLE DEOLB -->
+      <map code="0xb360" name="1em"/><!-- HANGUL SYLLABLE DEOLS -->
+      <map code="0xb361" name="1em"/><!-- HANGUL SYLLABLE DEOLT -->
+      <map code="0xb362" name="1em"/><!-- HANGUL SYLLABLE DEOLP -->
+      <map code="0xb363" name="1em"/><!-- HANGUL SYLLABLE DEOLH -->
+      <map code="0xb364" name="1em"/><!-- HANGUL SYLLABLE DEOM -->
+      <map code="0xb365" name="1em"/><!-- HANGUL SYLLABLE DEOB -->
+      <map code="0xb366" name="1em"/><!-- HANGUL SYLLABLE DEOBS -->
+      <map code="0xb367" name="1em"/><!-- HANGUL SYLLABLE DEOS -->
+      <map code="0xb368" name="1em"/><!-- HANGUL SYLLABLE DEOSS -->
+      <map code="0xb369" name="1em"/><!-- HANGUL SYLLABLE DEONG -->
+      <map code="0xb36a" name="1em"/><!-- HANGUL SYLLABLE DEOJ -->
+      <map code="0xb36b" name="1em"/><!-- HANGUL SYLLABLE DEOC -->
+      <map code="0xb36c" name="1em"/><!-- HANGUL SYLLABLE DEOK -->
+      <map code="0xb36d" name="1em"/><!-- HANGUL SYLLABLE DEOT -->
+      <map code="0xb36e" name="1em"/><!-- HANGUL SYLLABLE DEOP -->
+      <map code="0xb36f" name="1em"/><!-- HANGUL SYLLABLE DEOH -->
+      <map code="0xb370" name="1em"/><!-- HANGUL SYLLABLE DE -->
+      <map code="0xb371" name="1em"/><!-- HANGUL SYLLABLE DEG -->
+      <map code="0xb372" name="1em"/><!-- HANGUL SYLLABLE DEGG -->
+      <map code="0xb373" name="1em"/><!-- HANGUL SYLLABLE DEGS -->
+      <map code="0xb374" name="1em"/><!-- HANGUL SYLLABLE DEN -->
+      <map code="0xb375" name="1em"/><!-- HANGUL SYLLABLE DENJ -->
+      <map code="0xb376" name="1em"/><!-- HANGUL SYLLABLE DENH -->
+      <map code="0xb377" name="1em"/><!-- HANGUL SYLLABLE DED -->
+      <map code="0xb378" name="1em"/><!-- HANGUL SYLLABLE DEL -->
+      <map code="0xb379" name="1em"/><!-- HANGUL SYLLABLE DELG -->
+      <map code="0xb37a" name="1em"/><!-- HANGUL SYLLABLE DELM -->
+      <map code="0xb37b" name="1em"/><!-- HANGUL SYLLABLE DELB -->
+      <map code="0xb37c" name="1em"/><!-- HANGUL SYLLABLE DELS -->
+      <map code="0xb37d" name="1em"/><!-- HANGUL SYLLABLE DELT -->
+      <map code="0xb37e" name="1em"/><!-- HANGUL SYLLABLE DELP -->
+      <map code="0xb37f" name="1em"/><!-- HANGUL SYLLABLE DELH -->
+      <map code="0xb380" name="1em"/><!-- HANGUL SYLLABLE DEM -->
+      <map code="0xb381" name="1em"/><!-- HANGUL SYLLABLE DEB -->
+      <map code="0xb382" name="1em"/><!-- HANGUL SYLLABLE DEBS -->
+      <map code="0xb383" name="1em"/><!-- HANGUL SYLLABLE DES -->
+      <map code="0xb384" name="1em"/><!-- HANGUL SYLLABLE DESS -->
+      <map code="0xb385" name="1em"/><!-- HANGUL SYLLABLE DENG -->
+      <map code="0xb386" name="1em"/><!-- HANGUL SYLLABLE DEJ -->
+      <map code="0xb387" name="1em"/><!-- HANGUL SYLLABLE DEC -->
+      <map code="0xb388" name="1em"/><!-- HANGUL SYLLABLE DEK -->
+      <map code="0xb389" name="1em"/><!-- HANGUL SYLLABLE DET -->
+      <map code="0xb38a" name="1em"/><!-- HANGUL SYLLABLE DEP -->
+      <map code="0xb38b" name="1em"/><!-- HANGUL SYLLABLE DEH -->
+      <map code="0xb38c" name="1em"/><!-- HANGUL SYLLABLE DYEO -->
+      <map code="0xb38d" name="1em"/><!-- HANGUL SYLLABLE DYEOG -->
+      <map code="0xb38e" name="1em"/><!-- HANGUL SYLLABLE DYEOGG -->
+      <map code="0xb38f" name="1em"/><!-- HANGUL SYLLABLE DYEOGS -->
+      <map code="0xb390" name="1em"/><!-- HANGUL SYLLABLE DYEON -->
+      <map code="0xb391" name="1em"/><!-- HANGUL SYLLABLE DYEONJ -->
+      <map code="0xb392" name="1em"/><!-- HANGUL SYLLABLE DYEONH -->
+      <map code="0xb393" name="1em"/><!-- HANGUL SYLLABLE DYEOD -->
+      <map code="0xb394" name="1em"/><!-- HANGUL SYLLABLE DYEOL -->
+      <map code="0xb395" name="1em"/><!-- HANGUL SYLLABLE DYEOLG -->
+      <map code="0xb396" name="1em"/><!-- HANGUL SYLLABLE DYEOLM -->
+      <map code="0xb397" name="1em"/><!-- HANGUL SYLLABLE DYEOLB -->
+      <map code="0xb398" name="1em"/><!-- HANGUL SYLLABLE DYEOLS -->
+      <map code="0xb399" name="1em"/><!-- HANGUL SYLLABLE DYEOLT -->
+      <map code="0xb39a" name="1em"/><!-- HANGUL SYLLABLE DYEOLP -->
+      <map code="0xb39b" name="1em"/><!-- HANGUL SYLLABLE DYEOLH -->
+      <map code="0xb39c" name="1em"/><!-- HANGUL SYLLABLE DYEOM -->
+      <map code="0xb39d" name="1em"/><!-- HANGUL SYLLABLE DYEOB -->
+      <map code="0xb39e" name="1em"/><!-- HANGUL SYLLABLE DYEOBS -->
+      <map code="0xb39f" name="1em"/><!-- HANGUL SYLLABLE DYEOS -->
+      <map code="0xb3a0" name="1em"/><!-- HANGUL SYLLABLE DYEOSS -->
+      <map code="0xb3a1" name="1em"/><!-- HANGUL SYLLABLE DYEONG -->
+      <map code="0xb3a2" name="1em"/><!-- HANGUL SYLLABLE DYEOJ -->
+      <map code="0xb3a3" name="1em"/><!-- HANGUL SYLLABLE DYEOC -->
+      <map code="0xb3a4" name="1em"/><!-- HANGUL SYLLABLE DYEOK -->
+      <map code="0xb3a5" name="1em"/><!-- HANGUL SYLLABLE DYEOT -->
+      <map code="0xb3a6" name="1em"/><!-- HANGUL SYLLABLE DYEOP -->
+      <map code="0xb3a7" name="1em"/><!-- HANGUL SYLLABLE DYEOH -->
+      <map code="0xb3a8" name="1em"/><!-- HANGUL SYLLABLE DYE -->
+      <map code="0xb3a9" name="1em"/><!-- HANGUL SYLLABLE DYEG -->
+      <map code="0xb3aa" name="1em"/><!-- HANGUL SYLLABLE DYEGG -->
+      <map code="0xb3ab" name="1em"/><!-- HANGUL SYLLABLE DYEGS -->
+      <map code="0xb3ac" name="1em"/><!-- HANGUL SYLLABLE DYEN -->
+      <map code="0xb3ad" name="1em"/><!-- HANGUL SYLLABLE DYENJ -->
+      <map code="0xb3ae" name="1em"/><!-- HANGUL SYLLABLE DYENH -->
+      <map code="0xb3af" name="1em"/><!-- HANGUL SYLLABLE DYED -->
+      <map code="0xb3b0" name="1em"/><!-- HANGUL SYLLABLE DYEL -->
+      <map code="0xb3b1" name="1em"/><!-- HANGUL SYLLABLE DYELG -->
+      <map code="0xb3b2" name="1em"/><!-- HANGUL SYLLABLE DYELM -->
+      <map code="0xb3b3" name="1em"/><!-- HANGUL SYLLABLE DYELB -->
+      <map code="0xb3b4" name="1em"/><!-- HANGUL SYLLABLE DYELS -->
+      <map code="0xb3b5" name="1em"/><!-- HANGUL SYLLABLE DYELT -->
+      <map code="0xb3b6" name="1em"/><!-- HANGUL SYLLABLE DYELP -->
+      <map code="0xb3b7" name="1em"/><!-- HANGUL SYLLABLE DYELH -->
+      <map code="0xb3b8" name="1em"/><!-- HANGUL SYLLABLE DYEM -->
+      <map code="0xb3b9" name="1em"/><!-- HANGUL SYLLABLE DYEB -->
+      <map code="0xb3ba" name="1em"/><!-- HANGUL SYLLABLE DYEBS -->
+      <map code="0xb3bb" name="1em"/><!-- HANGUL SYLLABLE DYES -->
+      <map code="0xb3bc" name="1em"/><!-- HANGUL SYLLABLE DYESS -->
+      <map code="0xb3bd" name="1em"/><!-- HANGUL SYLLABLE DYENG -->
+      <map code="0xb3be" name="1em"/><!-- HANGUL SYLLABLE DYEJ -->
+      <map code="0xb3bf" name="1em"/><!-- HANGUL SYLLABLE DYEC -->
+      <map code="0xb3c0" name="1em"/><!-- HANGUL SYLLABLE DYEK -->
+      <map code="0xb3c1" name="1em"/><!-- HANGUL SYLLABLE DYET -->
+      <map code="0xb3c2" name="1em"/><!-- HANGUL SYLLABLE DYEP -->
+      <map code="0xb3c3" name="1em"/><!-- HANGUL SYLLABLE DYEH -->
+      <map code="0xb3c4" name="1em"/><!-- HANGUL SYLLABLE DO -->
+      <map code="0xb3c5" name="1em"/><!-- HANGUL SYLLABLE DOG -->
+      <map code="0xb3c6" name="1em"/><!-- HANGUL SYLLABLE DOGG -->
+      <map code="0xb3c7" name="1em"/><!-- HANGUL SYLLABLE DOGS -->
+      <map code="0xb3c8" name="1em"/><!-- HANGUL SYLLABLE DON -->
+      <map code="0xb3c9" name="1em"/><!-- HANGUL SYLLABLE DONJ -->
+      <map code="0xb3ca" name="1em"/><!-- HANGUL SYLLABLE DONH -->
+      <map code="0xb3cb" name="1em"/><!-- HANGUL SYLLABLE DOD -->
+      <map code="0xb3cc" name="1em"/><!-- HANGUL SYLLABLE DOL -->
+      <map code="0xb3cd" name="1em"/><!-- HANGUL SYLLABLE DOLG -->
+      <map code="0xb3ce" name="1em"/><!-- HANGUL SYLLABLE DOLM -->
+      <map code="0xb3cf" name="1em"/><!-- HANGUL SYLLABLE DOLB -->
+      <map code="0xb3d0" name="1em"/><!-- HANGUL SYLLABLE DOLS -->
+      <map code="0xb3d1" name="1em"/><!-- HANGUL SYLLABLE DOLT -->
+      <map code="0xb3d2" name="1em"/><!-- HANGUL SYLLABLE DOLP -->
+      <map code="0xb3d3" name="1em"/><!-- HANGUL SYLLABLE DOLH -->
+      <map code="0xb3d4" name="1em"/><!-- HANGUL SYLLABLE DOM -->
+      <map code="0xb3d5" name="1em"/><!-- HANGUL SYLLABLE DOB -->
+      <map code="0xb3d6" name="1em"/><!-- HANGUL SYLLABLE DOBS -->
+      <map code="0xb3d7" name="1em"/><!-- HANGUL SYLLABLE DOS -->
+      <map code="0xb3d8" name="1em"/><!-- HANGUL SYLLABLE DOSS -->
+      <map code="0xb3d9" name="1em"/><!-- HANGUL SYLLABLE DONG -->
+      <map code="0xb3da" name="1em"/><!-- HANGUL SYLLABLE DOJ -->
+      <map code="0xb3db" name="1em"/><!-- HANGUL SYLLABLE DOC -->
+      <map code="0xb3dc" name="1em"/><!-- HANGUL SYLLABLE DOK -->
+      <map code="0xb3dd" name="1em"/><!-- HANGUL SYLLABLE DOT -->
+      <map code="0xb3de" name="1em"/><!-- HANGUL SYLLABLE DOP -->
+      <map code="0xb3df" name="1em"/><!-- HANGUL SYLLABLE DOH -->
+      <map code="0xb3e0" name="1em"/><!-- HANGUL SYLLABLE DWA -->
+      <map code="0xb3e1" name="1em"/><!-- HANGUL SYLLABLE DWAG -->
+      <map code="0xb3e2" name="1em"/><!-- HANGUL SYLLABLE DWAGG -->
+      <map code="0xb3e3" name="1em"/><!-- HANGUL SYLLABLE DWAGS -->
+      <map code="0xb3e4" name="1em"/><!-- HANGUL SYLLABLE DWAN -->
+      <map code="0xb3e5" name="1em"/><!-- HANGUL SYLLABLE DWANJ -->
+      <map code="0xb3e6" name="1em"/><!-- HANGUL SYLLABLE DWANH -->
+      <map code="0xb3e7" name="1em"/><!-- HANGUL SYLLABLE DWAD -->
+      <map code="0xb3e8" name="1em"/><!-- HANGUL SYLLABLE DWAL -->
+      <map code="0xb3e9" name="1em"/><!-- HANGUL SYLLABLE DWALG -->
+      <map code="0xb3ea" name="1em"/><!-- HANGUL SYLLABLE DWALM -->
+      <map code="0xb3eb" name="1em"/><!-- HANGUL SYLLABLE DWALB -->
+      <map code="0xb3ec" name="1em"/><!-- HANGUL SYLLABLE DWALS -->
+      <map code="0xb3ed" name="1em"/><!-- HANGUL SYLLABLE DWALT -->
+      <map code="0xb3ee" name="1em"/><!-- HANGUL SYLLABLE DWALP -->
+      <map code="0xb3ef" name="1em"/><!-- HANGUL SYLLABLE DWALH -->
+      <map code="0xb3f0" name="1em"/><!-- HANGUL SYLLABLE DWAM -->
+      <map code="0xb3f1" name="1em"/><!-- HANGUL SYLLABLE DWAB -->
+      <map code="0xb3f2" name="1em"/><!-- HANGUL SYLLABLE DWABS -->
+      <map code="0xb3f3" name="1em"/><!-- HANGUL SYLLABLE DWAS -->
+      <map code="0xb3f4" name="1em"/><!-- HANGUL SYLLABLE DWASS -->
+      <map code="0xb3f5" name="1em"/><!-- HANGUL SYLLABLE DWANG -->
+      <map code="0xb3f6" name="1em"/><!-- HANGUL SYLLABLE DWAJ -->
+      <map code="0xb3f7" name="1em"/><!-- HANGUL SYLLABLE DWAC -->
+      <map code="0xb3f8" name="1em"/><!-- HANGUL SYLLABLE DWAK -->
+      <map code="0xb3f9" name="1em"/><!-- HANGUL SYLLABLE DWAT -->
+      <map code="0xb3fa" name="1em"/><!-- HANGUL SYLLABLE DWAP -->
+      <map code="0xb3fb" name="1em"/><!-- HANGUL SYLLABLE DWAH -->
+      <map code="0xb3fc" name="1em"/><!-- HANGUL SYLLABLE DWAE -->
+      <map code="0xb3fd" name="1em"/><!-- HANGUL SYLLABLE DWAEG -->
+      <map code="0xb3fe" name="1em"/><!-- HANGUL SYLLABLE DWAEGG -->
+      <map code="0xb3ff" name="1em"/><!-- HANGUL SYLLABLE DWAEGS -->
+      <map code="0xb400" name="1em"/><!-- HANGUL SYLLABLE DWAEN -->
+      <map code="0xb401" name="1em"/><!-- HANGUL SYLLABLE DWAENJ -->
+      <map code="0xb402" name="1em"/><!-- HANGUL SYLLABLE DWAENH -->
+      <map code="0xb403" name="1em"/><!-- HANGUL SYLLABLE DWAED -->
+      <map code="0xb404" name="1em"/><!-- HANGUL SYLLABLE DWAEL -->
+      <map code="0xb405" name="1em"/><!-- HANGUL SYLLABLE DWAELG -->
+      <map code="0xb406" name="1em"/><!-- HANGUL SYLLABLE DWAELM -->
+      <map code="0xb407" name="1em"/><!-- HANGUL SYLLABLE DWAELB -->
+      <map code="0xb408" name="1em"/><!-- HANGUL SYLLABLE DWAELS -->
+      <map code="0xb409" name="1em"/><!-- HANGUL SYLLABLE DWAELT -->
+      <map code="0xb40a" name="1em"/><!-- HANGUL SYLLABLE DWAELP -->
+      <map code="0xb40b" name="1em"/><!-- HANGUL SYLLABLE DWAELH -->
+      <map code="0xb40c" name="1em"/><!-- HANGUL SYLLABLE DWAEM -->
+      <map code="0xb40d" name="1em"/><!-- HANGUL SYLLABLE DWAEB -->
+      <map code="0xb40e" name="1em"/><!-- HANGUL SYLLABLE DWAEBS -->
+      <map code="0xb40f" name="1em"/><!-- HANGUL SYLLABLE DWAES -->
+      <map code="0xb410" name="1em"/><!-- HANGUL SYLLABLE DWAESS -->
+      <map code="0xb411" name="1em"/><!-- HANGUL SYLLABLE DWAENG -->
+      <map code="0xb412" name="1em"/><!-- HANGUL SYLLABLE DWAEJ -->
+      <map code="0xb413" name="1em"/><!-- HANGUL SYLLABLE DWAEC -->
+      <map code="0xb414" name="1em"/><!-- HANGUL SYLLABLE DWAEK -->
+      <map code="0xb415" name="1em"/><!-- HANGUL SYLLABLE DWAET -->
+      <map code="0xb416" name="1em"/><!-- HANGUL SYLLABLE DWAEP -->
+      <map code="0xb417" name="1em"/><!-- HANGUL SYLLABLE DWAEH -->
+      <map code="0xb418" name="1em"/><!-- HANGUL SYLLABLE DOE -->
+      <map code="0xb419" name="1em"/><!-- HANGUL SYLLABLE DOEG -->
+      <map code="0xb41a" name="1em"/><!-- HANGUL SYLLABLE DOEGG -->
+      <map code="0xb41b" name="1em"/><!-- HANGUL SYLLABLE DOEGS -->
+      <map code="0xb41c" name="1em"/><!-- HANGUL SYLLABLE DOEN -->
+      <map code="0xb41d" name="1em"/><!-- HANGUL SYLLABLE DOENJ -->
+      <map code="0xb41e" name="1em"/><!-- HANGUL SYLLABLE DOENH -->
+      <map code="0xb41f" name="1em"/><!-- HANGUL SYLLABLE DOED -->
+      <map code="0xb420" name="1em"/><!-- HANGUL SYLLABLE DOEL -->
+      <map code="0xb421" name="1em"/><!-- HANGUL SYLLABLE DOELG -->
+      <map code="0xb422" name="1em"/><!-- HANGUL SYLLABLE DOELM -->
+      <map code="0xb423" name="1em"/><!-- HANGUL SYLLABLE DOELB -->
+      <map code="0xb424" name="1em"/><!-- HANGUL SYLLABLE DOELS -->
+      <map code="0xb425" name="1em"/><!-- HANGUL SYLLABLE DOELT -->
+      <map code="0xb426" name="1em"/><!-- HANGUL SYLLABLE DOELP -->
+      <map code="0xb427" name="1em"/><!-- HANGUL SYLLABLE DOELH -->
+      <map code="0xb428" name="1em"/><!-- HANGUL SYLLABLE DOEM -->
+      <map code="0xb429" name="1em"/><!-- HANGUL SYLLABLE DOEB -->
+      <map code="0xb42a" name="1em"/><!-- HANGUL SYLLABLE DOEBS -->
+      <map code="0xb42b" name="1em"/><!-- HANGUL SYLLABLE DOES -->
+      <map code="0xb42c" name="1em"/><!-- HANGUL SYLLABLE DOESS -->
+      <map code="0xb42d" name="1em"/><!-- HANGUL SYLLABLE DOENG -->
+      <map code="0xb42e" name="1em"/><!-- HANGUL SYLLABLE DOEJ -->
+      <map code="0xb42f" name="1em"/><!-- HANGUL SYLLABLE DOEC -->
+      <map code="0xb430" name="1em"/><!-- HANGUL SYLLABLE DOEK -->
+      <map code="0xb431" name="1em"/><!-- HANGUL SYLLABLE DOET -->
+      <map code="0xb432" name="1em"/><!-- HANGUL SYLLABLE DOEP -->
+      <map code="0xb433" name="1em"/><!-- HANGUL SYLLABLE DOEH -->
+      <map code="0xb434" name="1em"/><!-- HANGUL SYLLABLE DYO -->
+      <map code="0xb435" name="1em"/><!-- HANGUL SYLLABLE DYOG -->
+      <map code="0xb436" name="1em"/><!-- HANGUL SYLLABLE DYOGG -->
+      <map code="0xb437" name="1em"/><!-- HANGUL SYLLABLE DYOGS -->
+      <map code="0xb438" name="1em"/><!-- HANGUL SYLLABLE DYON -->
+      <map code="0xb439" name="1em"/><!-- HANGUL SYLLABLE DYONJ -->
+      <map code="0xb43a" name="1em"/><!-- HANGUL SYLLABLE DYONH -->
+      <map code="0xb43b" name="1em"/><!-- HANGUL SYLLABLE DYOD -->
+      <map code="0xb43c" name="1em"/><!-- HANGUL SYLLABLE DYOL -->
+      <map code="0xb43d" name="1em"/><!-- HANGUL SYLLABLE DYOLG -->
+      <map code="0xb43e" name="1em"/><!-- HANGUL SYLLABLE DYOLM -->
+      <map code="0xb43f" name="1em"/><!-- HANGUL SYLLABLE DYOLB -->
+      <map code="0xb440" name="1em"/><!-- HANGUL SYLLABLE DYOLS -->
+      <map code="0xb441" name="1em"/><!-- HANGUL SYLLABLE DYOLT -->
+      <map code="0xb442" name="1em"/><!-- HANGUL SYLLABLE DYOLP -->
+      <map code="0xb443" name="1em"/><!-- HANGUL SYLLABLE DYOLH -->
+      <map code="0xb444" name="1em"/><!-- HANGUL SYLLABLE DYOM -->
+      <map code="0xb445" name="1em"/><!-- HANGUL SYLLABLE DYOB -->
+      <map code="0xb446" name="1em"/><!-- HANGUL SYLLABLE DYOBS -->
+      <map code="0xb447" name="1em"/><!-- HANGUL SYLLABLE DYOS -->
+      <map code="0xb448" name="1em"/><!-- HANGUL SYLLABLE DYOSS -->
+      <map code="0xb449" name="1em"/><!-- HANGUL SYLLABLE DYONG -->
+      <map code="0xb44a" name="1em"/><!-- HANGUL SYLLABLE DYOJ -->
+      <map code="0xb44b" name="1em"/><!-- HANGUL SYLLABLE DYOC -->
+      <map code="0xb44c" name="1em"/><!-- HANGUL SYLLABLE DYOK -->
+      <map code="0xb44d" name="1em"/><!-- HANGUL SYLLABLE DYOT -->
+      <map code="0xb44e" name="1em"/><!-- HANGUL SYLLABLE DYOP -->
+      <map code="0xb44f" name="1em"/><!-- HANGUL SYLLABLE DYOH -->
+      <map code="0xb450" name="1em"/><!-- HANGUL SYLLABLE DU -->
+      <map code="0xb451" name="1em"/><!-- HANGUL SYLLABLE DUG -->
+      <map code="0xb452" name="1em"/><!-- HANGUL SYLLABLE DUGG -->
+      <map code="0xb453" name="1em"/><!-- HANGUL SYLLABLE DUGS -->
+      <map code="0xb454" name="1em"/><!-- HANGUL SYLLABLE DUN -->
+      <map code="0xb455" name="1em"/><!-- HANGUL SYLLABLE DUNJ -->
+      <map code="0xb456" name="1em"/><!-- HANGUL SYLLABLE DUNH -->
+      <map code="0xb457" name="1em"/><!-- HANGUL SYLLABLE DUD -->
+      <map code="0xb458" name="1em"/><!-- HANGUL SYLLABLE DUL -->
+      <map code="0xb459" name="1em"/><!-- HANGUL SYLLABLE DULG -->
+      <map code="0xb45a" name="1em"/><!-- HANGUL SYLLABLE DULM -->
+      <map code="0xb45b" name="1em"/><!-- HANGUL SYLLABLE DULB -->
+      <map code="0xb45c" name="1em"/><!-- HANGUL SYLLABLE DULS -->
+      <map code="0xb45d" name="1em"/><!-- HANGUL SYLLABLE DULT -->
+      <map code="0xb45e" name="1em"/><!-- HANGUL SYLLABLE DULP -->
+      <map code="0xb45f" name="1em"/><!-- HANGUL SYLLABLE DULH -->
+      <map code="0xb460" name="1em"/><!-- HANGUL SYLLABLE DUM -->
+      <map code="0xb461" name="1em"/><!-- HANGUL SYLLABLE DUB -->
+      <map code="0xb462" name="1em"/><!-- HANGUL SYLLABLE DUBS -->
+      <map code="0xb463" name="1em"/><!-- HANGUL SYLLABLE DUS -->
+      <map code="0xb464" name="1em"/><!-- HANGUL SYLLABLE DUSS -->
+      <map code="0xb465" name="1em"/><!-- HANGUL SYLLABLE DUNG -->
+      <map code="0xb466" name="1em"/><!-- HANGUL SYLLABLE DUJ -->
+      <map code="0xb467" name="1em"/><!-- HANGUL SYLLABLE DUC -->
+      <map code="0xb468" name="1em"/><!-- HANGUL SYLLABLE DUK -->
+      <map code="0xb469" name="1em"/><!-- HANGUL SYLLABLE DUT -->
+      <map code="0xb46a" name="1em"/><!-- HANGUL SYLLABLE DUP -->
+      <map code="0xb46b" name="1em"/><!-- HANGUL SYLLABLE DUH -->
+      <map code="0xb46c" name="1em"/><!-- HANGUL SYLLABLE DWEO -->
+      <map code="0xb46d" name="1em"/><!-- HANGUL SYLLABLE DWEOG -->
+      <map code="0xb46e" name="1em"/><!-- HANGUL SYLLABLE DWEOGG -->
+      <map code="0xb46f" name="1em"/><!-- HANGUL SYLLABLE DWEOGS -->
+      <map code="0xb470" name="1em"/><!-- HANGUL SYLLABLE DWEON -->
+      <map code="0xb471" name="1em"/><!-- HANGUL SYLLABLE DWEONJ -->
+      <map code="0xb472" name="1em"/><!-- HANGUL SYLLABLE DWEONH -->
+      <map code="0xb473" name="1em"/><!-- HANGUL SYLLABLE DWEOD -->
+      <map code="0xb474" name="1em"/><!-- HANGUL SYLLABLE DWEOL -->
+      <map code="0xb475" name="1em"/><!-- HANGUL SYLLABLE DWEOLG -->
+      <map code="0xb476" name="1em"/><!-- HANGUL SYLLABLE DWEOLM -->
+      <map code="0xb477" name="1em"/><!-- HANGUL SYLLABLE DWEOLB -->
+      <map code="0xb478" name="1em"/><!-- HANGUL SYLLABLE DWEOLS -->
+      <map code="0xb479" name="1em"/><!-- HANGUL SYLLABLE DWEOLT -->
+      <map code="0xb47a" name="1em"/><!-- HANGUL SYLLABLE DWEOLP -->
+      <map code="0xb47b" name="1em"/><!-- HANGUL SYLLABLE DWEOLH -->
+      <map code="0xb47c" name="1em"/><!-- HANGUL SYLLABLE DWEOM -->
+      <map code="0xb47d" name="1em"/><!-- HANGUL SYLLABLE DWEOB -->
+      <map code="0xb47e" name="1em"/><!-- HANGUL SYLLABLE DWEOBS -->
+      <map code="0xb47f" name="1em"/><!-- HANGUL SYLLABLE DWEOS -->
+      <map code="0xb480" name="1em"/><!-- HANGUL SYLLABLE DWEOSS -->
+      <map code="0xb481" name="1em"/><!-- HANGUL SYLLABLE DWEONG -->
+      <map code="0xb482" name="1em"/><!-- HANGUL SYLLABLE DWEOJ -->
+      <map code="0xb483" name="1em"/><!-- HANGUL SYLLABLE DWEOC -->
+      <map code="0xb484" name="1em"/><!-- HANGUL SYLLABLE DWEOK -->
+      <map code="0xb485" name="1em"/><!-- HANGUL SYLLABLE DWEOT -->
+      <map code="0xb486" name="1em"/><!-- HANGUL SYLLABLE DWEOP -->
+      <map code="0xb487" name="1em"/><!-- HANGUL SYLLABLE DWEOH -->
+      <map code="0xb488" name="1em"/><!-- HANGUL SYLLABLE DWE -->
+      <map code="0xb489" name="1em"/><!-- HANGUL SYLLABLE DWEG -->
+      <map code="0xb48a" name="1em"/><!-- HANGUL SYLLABLE DWEGG -->
+      <map code="0xb48b" name="1em"/><!-- HANGUL SYLLABLE DWEGS -->
+      <map code="0xb48c" name="1em"/><!-- HANGUL SYLLABLE DWEN -->
+      <map code="0xb48d" name="1em"/><!-- HANGUL SYLLABLE DWENJ -->
+      <map code="0xb48e" name="1em"/><!-- HANGUL SYLLABLE DWENH -->
+      <map code="0xb48f" name="1em"/><!-- HANGUL SYLLABLE DWED -->
+      <map code="0xb490" name="1em"/><!-- HANGUL SYLLABLE DWEL -->
+      <map code="0xb491" name="1em"/><!-- HANGUL SYLLABLE DWELG -->
+      <map code="0xb492" name="1em"/><!-- HANGUL SYLLABLE DWELM -->
+      <map code="0xb493" name="1em"/><!-- HANGUL SYLLABLE DWELB -->
+      <map code="0xb494" name="1em"/><!-- HANGUL SYLLABLE DWELS -->
+      <map code="0xb495" name="1em"/><!-- HANGUL SYLLABLE DWELT -->
+      <map code="0xb496" name="1em"/><!-- HANGUL SYLLABLE DWELP -->
+      <map code="0xb497" name="1em"/><!-- HANGUL SYLLABLE DWELH -->
+      <map code="0xb498" name="1em"/><!-- HANGUL SYLLABLE DWEM -->
+      <map code="0xb499" name="1em"/><!-- HANGUL SYLLABLE DWEB -->
+      <map code="0xb49a" name="1em"/><!-- HANGUL SYLLABLE DWEBS -->
+      <map code="0xb49b" name="1em"/><!-- HANGUL SYLLABLE DWES -->
+      <map code="0xb49c" name="1em"/><!-- HANGUL SYLLABLE DWESS -->
+      <map code="0xb49d" name="1em"/><!-- HANGUL SYLLABLE DWENG -->
+      <map code="0xb49e" name="1em"/><!-- HANGUL SYLLABLE DWEJ -->
+      <map code="0xb49f" name="1em"/><!-- HANGUL SYLLABLE DWEC -->
+      <map code="0xb4a0" name="1em"/><!-- HANGUL SYLLABLE DWEK -->
+      <map code="0xb4a1" name="1em"/><!-- HANGUL SYLLABLE DWET -->
+      <map code="0xb4a2" name="1em"/><!-- HANGUL SYLLABLE DWEP -->
+      <map code="0xb4a3" name="1em"/><!-- HANGUL SYLLABLE DWEH -->
+      <map code="0xb4a4" name="1em"/><!-- HANGUL SYLLABLE DWI -->
+      <map code="0xb4a5" name="1em"/><!-- HANGUL SYLLABLE DWIG -->
+      <map code="0xb4a6" name="1em"/><!-- HANGUL SYLLABLE DWIGG -->
+      <map code="0xb4a7" name="1em"/><!-- HANGUL SYLLABLE DWIGS -->
+      <map code="0xb4a8" name="1em"/><!-- HANGUL SYLLABLE DWIN -->
+      <map code="0xb4a9" name="1em"/><!-- HANGUL SYLLABLE DWINJ -->
+      <map code="0xb4aa" name="1em"/><!-- HANGUL SYLLABLE DWINH -->
+      <map code="0xb4ab" name="1em"/><!-- HANGUL SYLLABLE DWID -->
+      <map code="0xb4ac" name="1em"/><!-- HANGUL SYLLABLE DWIL -->
+      <map code="0xb4ad" name="1em"/><!-- HANGUL SYLLABLE DWILG -->
+      <map code="0xb4ae" name="1em"/><!-- HANGUL SYLLABLE DWILM -->
+      <map code="0xb4af" name="1em"/><!-- HANGUL SYLLABLE DWILB -->
+      <map code="0xb4b0" name="1em"/><!-- HANGUL SYLLABLE DWILS -->
+      <map code="0xb4b1" name="1em"/><!-- HANGUL SYLLABLE DWILT -->
+      <map code="0xb4b2" name="1em"/><!-- HANGUL SYLLABLE DWILP -->
+      <map code="0xb4b3" name="1em"/><!-- HANGUL SYLLABLE DWILH -->
+      <map code="0xb4b4" name="1em"/><!-- HANGUL SYLLABLE DWIM -->
+      <map code="0xb4b5" name="1em"/><!-- HANGUL SYLLABLE DWIB -->
+      <map code="0xb4b6" name="1em"/><!-- HANGUL SYLLABLE DWIBS -->
+      <map code="0xb4b7" name="1em"/><!-- HANGUL SYLLABLE DWIS -->
+      <map code="0xb4b8" name="1em"/><!-- HANGUL SYLLABLE DWISS -->
+      <map code="0xb4b9" name="1em"/><!-- HANGUL SYLLABLE DWING -->
+      <map code="0xb4ba" name="1em"/><!-- HANGUL SYLLABLE DWIJ -->
+      <map code="0xb4bb" name="1em"/><!-- HANGUL SYLLABLE DWIC -->
+      <map code="0xb4bc" name="1em"/><!-- HANGUL SYLLABLE DWIK -->
+      <map code="0xb4bd" name="1em"/><!-- HANGUL SYLLABLE DWIT -->
+      <map code="0xb4be" name="1em"/><!-- HANGUL SYLLABLE DWIP -->
+      <map code="0xb4bf" name="1em"/><!-- HANGUL SYLLABLE DWIH -->
+      <map code="0xb4c0" name="1em"/><!-- HANGUL SYLLABLE DYU -->
+      <map code="0xb4c1" name="1em"/><!-- HANGUL SYLLABLE DYUG -->
+      <map code="0xb4c2" name="1em"/><!-- HANGUL SYLLABLE DYUGG -->
+      <map code="0xb4c3" name="1em"/><!-- HANGUL SYLLABLE DYUGS -->
+      <map code="0xb4c4" name="1em"/><!-- HANGUL SYLLABLE DYUN -->
+      <map code="0xb4c5" name="1em"/><!-- HANGUL SYLLABLE DYUNJ -->
+      <map code="0xb4c6" name="1em"/><!-- HANGUL SYLLABLE DYUNH -->
+      <map code="0xb4c7" name="1em"/><!-- HANGUL SYLLABLE DYUD -->
+      <map code="0xb4c8" name="1em"/><!-- HANGUL SYLLABLE DYUL -->
+      <map code="0xb4c9" name="1em"/><!-- HANGUL SYLLABLE DYULG -->
+      <map code="0xb4ca" name="1em"/><!-- HANGUL SYLLABLE DYULM -->
+      <map code="0xb4cb" name="1em"/><!-- HANGUL SYLLABLE DYULB -->
+      <map code="0xb4cc" name="1em"/><!-- HANGUL SYLLABLE DYULS -->
+      <map code="0xb4cd" name="1em"/><!-- HANGUL SYLLABLE DYULT -->
+      <map code="0xb4ce" name="1em"/><!-- HANGUL SYLLABLE DYULP -->
+      <map code="0xb4cf" name="1em"/><!-- HANGUL SYLLABLE DYULH -->
+      <map code="0xb4d0" name="1em"/><!-- HANGUL SYLLABLE DYUM -->
+      <map code="0xb4d1" name="1em"/><!-- HANGUL SYLLABLE DYUB -->
+      <map code="0xb4d2" name="1em"/><!-- HANGUL SYLLABLE DYUBS -->
+      <map code="0xb4d3" name="1em"/><!-- HANGUL SYLLABLE DYUS -->
+      <map code="0xb4d4" name="1em"/><!-- HANGUL SYLLABLE DYUSS -->
+      <map code="0xb4d5" name="1em"/><!-- HANGUL SYLLABLE DYUNG -->
+      <map code="0xb4d6" name="1em"/><!-- HANGUL SYLLABLE DYUJ -->
+      <map code="0xb4d7" name="1em"/><!-- HANGUL SYLLABLE DYUC -->
+      <map code="0xb4d8" name="1em"/><!-- HANGUL SYLLABLE DYUK -->
+      <map code="0xb4d9" name="1em"/><!-- HANGUL SYLLABLE DYUT -->
+      <map code="0xb4da" name="1em"/><!-- HANGUL SYLLABLE DYUP -->
+      <map code="0xb4db" name="1em"/><!-- HANGUL SYLLABLE DYUH -->
+      <map code="0xb4dc" name="1em"/><!-- HANGUL SYLLABLE DEU -->
+      <map code="0xb4dd" name="1em"/><!-- HANGUL SYLLABLE DEUG -->
+      <map code="0xb4de" name="1em"/><!-- HANGUL SYLLABLE DEUGG -->
+      <map code="0xb4df" name="1em"/><!-- HANGUL SYLLABLE DEUGS -->
+      <map code="0xb4e0" name="1em"/><!-- HANGUL SYLLABLE DEUN -->
+      <map code="0xb4e1" name="1em"/><!-- HANGUL SYLLABLE DEUNJ -->
+      <map code="0xb4e2" name="1em"/><!-- HANGUL SYLLABLE DEUNH -->
+      <map code="0xb4e3" name="1em"/><!-- HANGUL SYLLABLE DEUD -->
+      <map code="0xb4e4" name="1em"/><!-- HANGUL SYLLABLE DEUL -->
+      <map code="0xb4e5" name="1em"/><!-- HANGUL SYLLABLE DEULG -->
+      <map code="0xb4e6" name="1em"/><!-- HANGUL SYLLABLE DEULM -->
+      <map code="0xb4e7" name="1em"/><!-- HANGUL SYLLABLE DEULB -->
+      <map code="0xb4e8" name="1em"/><!-- HANGUL SYLLABLE DEULS -->
+      <map code="0xb4e9" name="1em"/><!-- HANGUL SYLLABLE DEULT -->
+      <map code="0xb4ea" name="1em"/><!-- HANGUL SYLLABLE DEULP -->
+      <map code="0xb4eb" name="1em"/><!-- HANGUL SYLLABLE DEULH -->
+      <map code="0xb4ec" name="1em"/><!-- HANGUL SYLLABLE DEUM -->
+      <map code="0xb4ed" name="1em"/><!-- HANGUL SYLLABLE DEUB -->
+      <map code="0xb4ee" name="1em"/><!-- HANGUL SYLLABLE DEUBS -->
+      <map code="0xb4ef" name="1em"/><!-- HANGUL SYLLABLE DEUS -->
+      <map code="0xb4f0" name="1em"/><!-- HANGUL SYLLABLE DEUSS -->
+      <map code="0xb4f1" name="1em"/><!-- HANGUL SYLLABLE DEUNG -->
+      <map code="0xb4f2" name="1em"/><!-- HANGUL SYLLABLE DEUJ -->
+      <map code="0xb4f3" name="1em"/><!-- HANGUL SYLLABLE DEUC -->
+      <map code="0xb4f4" name="1em"/><!-- HANGUL SYLLABLE DEUK -->
+      <map code="0xb4f5" name="1em"/><!-- HANGUL SYLLABLE DEUT -->
+      <map code="0xb4f6" name="1em"/><!-- HANGUL SYLLABLE DEUP -->
+      <map code="0xb4f7" name="1em"/><!-- HANGUL SYLLABLE DEUH -->
+      <map code="0xb4f8" name="1em"/><!-- HANGUL SYLLABLE DYI -->
+      <map code="0xb4f9" name="1em"/><!-- HANGUL SYLLABLE DYIG -->
+      <map code="0xb4fa" name="1em"/><!-- HANGUL SYLLABLE DYIGG -->
+      <map code="0xb4fb" name="1em"/><!-- HANGUL SYLLABLE DYIGS -->
+      <map code="0xb4fc" name="1em"/><!-- HANGUL SYLLABLE DYIN -->
+      <map code="0xb4fd" name="1em"/><!-- HANGUL SYLLABLE DYINJ -->
+      <map code="0xb4fe" name="1em"/><!-- HANGUL SYLLABLE DYINH -->
+      <map code="0xb4ff" name="1em"/><!-- HANGUL SYLLABLE DYID -->
+      <map code="0xb500" name="1em"/><!-- HANGUL SYLLABLE DYIL -->
+      <map code="0xb501" name="1em"/><!-- HANGUL SYLLABLE DYILG -->
+      <map code="0xb502" name="1em"/><!-- HANGUL SYLLABLE DYILM -->
+      <map code="0xb503" name="1em"/><!-- HANGUL SYLLABLE DYILB -->
+      <map code="0xb504" name="1em"/><!-- HANGUL SYLLABLE DYILS -->
+      <map code="0xb505" name="1em"/><!-- HANGUL SYLLABLE DYILT -->
+      <map code="0xb506" name="1em"/><!-- HANGUL SYLLABLE DYILP -->
+      <map code="0xb507" name="1em"/><!-- HANGUL SYLLABLE DYILH -->
+      <map code="0xb508" name="1em"/><!-- HANGUL SYLLABLE DYIM -->
+      <map code="0xb509" name="1em"/><!-- HANGUL SYLLABLE DYIB -->
+      <map code="0xb50a" name="1em"/><!-- HANGUL SYLLABLE DYIBS -->
+      <map code="0xb50b" name="1em"/><!-- HANGUL SYLLABLE DYIS -->
+      <map code="0xb50c" name="1em"/><!-- HANGUL SYLLABLE DYISS -->
+      <map code="0xb50d" name="1em"/><!-- HANGUL SYLLABLE DYING -->
+      <map code="0xb50e" name="1em"/><!-- HANGUL SYLLABLE DYIJ -->
+      <map code="0xb50f" name="1em"/><!-- HANGUL SYLLABLE DYIC -->
+      <map code="0xb510" name="1em"/><!-- HANGUL SYLLABLE DYIK -->
+      <map code="0xb511" name="1em"/><!-- HANGUL SYLLABLE DYIT -->
+      <map code="0xb512" name="1em"/><!-- HANGUL SYLLABLE DYIP -->
+      <map code="0xb513" name="1em"/><!-- HANGUL SYLLABLE DYIH -->
+      <map code="0xb514" name="1em"/><!-- HANGUL SYLLABLE DI -->
+      <map code="0xb515" name="1em"/><!-- HANGUL SYLLABLE DIG -->
+      <map code="0xb516" name="1em"/><!-- HANGUL SYLLABLE DIGG -->
+      <map code="0xb517" name="1em"/><!-- HANGUL SYLLABLE DIGS -->
+      <map code="0xb518" name="1em"/><!-- HANGUL SYLLABLE DIN -->
+      <map code="0xb519" name="1em"/><!-- HANGUL SYLLABLE DINJ -->
+      <map code="0xb51a" name="1em"/><!-- HANGUL SYLLABLE DINH -->
+      <map code="0xb51b" name="1em"/><!-- HANGUL SYLLABLE DID -->
+      <map code="0xb51c" name="1em"/><!-- HANGUL SYLLABLE DIL -->
+      <map code="0xb51d" name="1em"/><!-- HANGUL SYLLABLE DILG -->
+      <map code="0xb51e" name="1em"/><!-- HANGUL SYLLABLE DILM -->
+      <map code="0xb51f" name="1em"/><!-- HANGUL SYLLABLE DILB -->
+      <map code="0xb520" name="1em"/><!-- HANGUL SYLLABLE DILS -->
+      <map code="0xb521" name="1em"/><!-- HANGUL SYLLABLE DILT -->
+      <map code="0xb522" name="1em"/><!-- HANGUL SYLLABLE DILP -->
+      <map code="0xb523" name="1em"/><!-- HANGUL SYLLABLE DILH -->
+      <map code="0xb524" name="1em"/><!-- HANGUL SYLLABLE DIM -->
+      <map code="0xb525" name="1em"/><!-- HANGUL SYLLABLE DIB -->
+      <map code="0xb526" name="1em"/><!-- HANGUL SYLLABLE DIBS -->
+      <map code="0xb527" name="1em"/><!-- HANGUL SYLLABLE DIS -->
+      <map code="0xb528" name="1em"/><!-- HANGUL SYLLABLE DISS -->
+      <map code="0xb529" name="1em"/><!-- HANGUL SYLLABLE DING -->
+      <map code="0xb52a" name="1em"/><!-- HANGUL SYLLABLE DIJ -->
+      <map code="0xb52b" name="1em"/><!-- HANGUL SYLLABLE DIC -->
+      <map code="0xb52c" name="1em"/><!-- HANGUL SYLLABLE DIK -->
+      <map code="0xb52d" name="1em"/><!-- HANGUL SYLLABLE DIT -->
+      <map code="0xb52e" name="1em"/><!-- HANGUL SYLLABLE DIP -->
+      <map code="0xb52f" name="1em"/><!-- HANGUL SYLLABLE DIH -->
+      <map code="0xb530" name="1em"/><!-- HANGUL SYLLABLE DDA -->
+      <map code="0xb531" name="1em"/><!-- HANGUL SYLLABLE DDAG -->
+      <map code="0xb532" name="1em"/><!-- HANGUL SYLLABLE DDAGG -->
+      <map code="0xb533" name="1em"/><!-- HANGUL SYLLABLE DDAGS -->
+      <map code="0xb534" name="1em"/><!-- HANGUL SYLLABLE DDAN -->
+      <map code="0xb535" name="1em"/><!-- HANGUL SYLLABLE DDANJ -->
+      <map code="0xb536" name="1em"/><!-- HANGUL SYLLABLE DDANH -->
+      <map code="0xb537" name="1em"/><!-- HANGUL SYLLABLE DDAD -->
+      <map code="0xb538" name="1em"/><!-- HANGUL SYLLABLE DDAL -->
+      <map code="0xb539" name="1em"/><!-- HANGUL SYLLABLE DDALG -->
+      <map code="0xb53a" name="1em"/><!-- HANGUL SYLLABLE DDALM -->
+      <map code="0xb53b" name="1em"/><!-- HANGUL SYLLABLE DDALB -->
+      <map code="0xb53c" name="1em"/><!-- HANGUL SYLLABLE DDALS -->
+      <map code="0xb53d" name="1em"/><!-- HANGUL SYLLABLE DDALT -->
+      <map code="0xb53e" name="1em"/><!-- HANGUL SYLLABLE DDALP -->
+      <map code="0xb53f" name="1em"/><!-- HANGUL SYLLABLE DDALH -->
+      <map code="0xb540" name="1em"/><!-- HANGUL SYLLABLE DDAM -->
+      <map code="0xb541" name="1em"/><!-- HANGUL SYLLABLE DDAB -->
+      <map code="0xb542" name="1em"/><!-- HANGUL SYLLABLE DDABS -->
+      <map code="0xb543" name="1em"/><!-- HANGUL SYLLABLE DDAS -->
+      <map code="0xb544" name="1em"/><!-- HANGUL SYLLABLE DDASS -->
+      <map code="0xb545" name="1em"/><!-- HANGUL SYLLABLE DDANG -->
+      <map code="0xb546" name="1em"/><!-- HANGUL SYLLABLE DDAJ -->
+      <map code="0xb547" name="1em"/><!-- HANGUL SYLLABLE DDAC -->
+      <map code="0xb548" name="1em"/><!-- HANGUL SYLLABLE DDAK -->
+      <map code="0xb549" name="1em"/><!-- HANGUL SYLLABLE DDAT -->
+      <map code="0xb54a" name="1em"/><!-- HANGUL SYLLABLE DDAP -->
+      <map code="0xb54b" name="1em"/><!-- HANGUL SYLLABLE DDAH -->
+      <map code="0xb54c" name="1em"/><!-- HANGUL SYLLABLE DDAE -->
+      <map code="0xb54d" name="1em"/><!-- HANGUL SYLLABLE DDAEG -->
+      <map code="0xb54e" name="1em"/><!-- HANGUL SYLLABLE DDAEGG -->
+      <map code="0xb54f" name="1em"/><!-- HANGUL SYLLABLE DDAEGS -->
+      <map code="0xb550" name="1em"/><!-- HANGUL SYLLABLE DDAEN -->
+      <map code="0xb551" name="1em"/><!-- HANGUL SYLLABLE DDAENJ -->
+      <map code="0xb552" name="1em"/><!-- HANGUL SYLLABLE DDAENH -->
+      <map code="0xb553" name="1em"/><!-- HANGUL SYLLABLE DDAED -->
+      <map code="0xb554" name="1em"/><!-- HANGUL SYLLABLE DDAEL -->
+      <map code="0xb555" name="1em"/><!-- HANGUL SYLLABLE DDAELG -->
+      <map code="0xb556" name="1em"/><!-- HANGUL SYLLABLE DDAELM -->
+      <map code="0xb557" name="1em"/><!-- HANGUL SYLLABLE DDAELB -->
+      <map code="0xb558" name="1em"/><!-- HANGUL SYLLABLE DDAELS -->
+      <map code="0xb559" name="1em"/><!-- HANGUL SYLLABLE DDAELT -->
+      <map code="0xb55a" name="1em"/><!-- HANGUL SYLLABLE DDAELP -->
+      <map code="0xb55b" name="1em"/><!-- HANGUL SYLLABLE DDAELH -->
+      <map code="0xb55c" name="1em"/><!-- HANGUL SYLLABLE DDAEM -->
+      <map code="0xb55d" name="1em"/><!-- HANGUL SYLLABLE DDAEB -->
+      <map code="0xb55e" name="1em"/><!-- HANGUL SYLLABLE DDAEBS -->
+      <map code="0xb55f" name="1em"/><!-- HANGUL SYLLABLE DDAES -->
+      <map code="0xb560" name="1em"/><!-- HANGUL SYLLABLE DDAESS -->
+      <map code="0xb561" name="1em"/><!-- HANGUL SYLLABLE DDAENG -->
+      <map code="0xb562" name="1em"/><!-- HANGUL SYLLABLE DDAEJ -->
+      <map code="0xb563" name="1em"/><!-- HANGUL SYLLABLE DDAEC -->
+      <map code="0xb564" name="1em"/><!-- HANGUL SYLLABLE DDAEK -->
+      <map code="0xb565" name="1em"/><!-- HANGUL SYLLABLE DDAET -->
+      <map code="0xb566" name="1em"/><!-- HANGUL SYLLABLE DDAEP -->
+      <map code="0xb567" name="1em"/><!-- HANGUL SYLLABLE DDAEH -->
+      <map code="0xb568" name="1em"/><!-- HANGUL SYLLABLE DDYA -->
+      <map code="0xb569" name="1em"/><!-- HANGUL SYLLABLE DDYAG -->
+      <map code="0xb56a" name="1em"/><!-- HANGUL SYLLABLE DDYAGG -->
+      <map code="0xb56b" name="1em"/><!-- HANGUL SYLLABLE DDYAGS -->
+      <map code="0xb56c" name="1em"/><!-- HANGUL SYLLABLE DDYAN -->
+      <map code="0xb56d" name="1em"/><!-- HANGUL SYLLABLE DDYANJ -->
+      <map code="0xb56e" name="1em"/><!-- HANGUL SYLLABLE DDYANH -->
+      <map code="0xb56f" name="1em"/><!-- HANGUL SYLLABLE DDYAD -->
+      <map code="0xb570" name="1em"/><!-- HANGUL SYLLABLE DDYAL -->
+      <map code="0xb571" name="1em"/><!-- HANGUL SYLLABLE DDYALG -->
+      <map code="0xb572" name="1em"/><!-- HANGUL SYLLABLE DDYALM -->
+      <map code="0xb573" name="1em"/><!-- HANGUL SYLLABLE DDYALB -->
+      <map code="0xb574" name="1em"/><!-- HANGUL SYLLABLE DDYALS -->
+      <map code="0xb575" name="1em"/><!-- HANGUL SYLLABLE DDYALT -->
+      <map code="0xb576" name="1em"/><!-- HANGUL SYLLABLE DDYALP -->
+      <map code="0xb577" name="1em"/><!-- HANGUL SYLLABLE DDYALH -->
+      <map code="0xb578" name="1em"/><!-- HANGUL SYLLABLE DDYAM -->
+      <map code="0xb579" name="1em"/><!-- HANGUL SYLLABLE DDYAB -->
+      <map code="0xb57a" name="1em"/><!-- HANGUL SYLLABLE DDYABS -->
+      <map code="0xb57b" name="1em"/><!-- HANGUL SYLLABLE DDYAS -->
+      <map code="0xb57c" name="1em"/><!-- HANGUL SYLLABLE DDYASS -->
+      <map code="0xb57d" name="1em"/><!-- HANGUL SYLLABLE DDYANG -->
+      <map code="0xb57e" name="1em"/><!-- HANGUL SYLLABLE DDYAJ -->
+      <map code="0xb57f" name="1em"/><!-- HANGUL SYLLABLE DDYAC -->
+      <map code="0xb580" name="1em"/><!-- HANGUL SYLLABLE DDYAK -->
+      <map code="0xb581" name="1em"/><!-- HANGUL SYLLABLE DDYAT -->
+      <map code="0xb582" name="1em"/><!-- HANGUL SYLLABLE DDYAP -->
+      <map code="0xb583" name="1em"/><!-- HANGUL SYLLABLE DDYAH -->
+      <map code="0xb584" name="1em"/><!-- HANGUL SYLLABLE DDYAE -->
+      <map code="0xb585" name="1em"/><!-- HANGUL SYLLABLE DDYAEG -->
+      <map code="0xb586" name="1em"/><!-- HANGUL SYLLABLE DDYAEGG -->
+      <map code="0xb587" name="1em"/><!-- HANGUL SYLLABLE DDYAEGS -->
+      <map code="0xb588" name="1em"/><!-- HANGUL SYLLABLE DDYAEN -->
+      <map code="0xb589" name="1em"/><!-- HANGUL SYLLABLE DDYAENJ -->
+      <map code="0xb58a" name="1em"/><!-- HANGUL SYLLABLE DDYAENH -->
+      <map code="0xb58b" name="1em"/><!-- HANGUL SYLLABLE DDYAED -->
+      <map code="0xb58c" name="1em"/><!-- HANGUL SYLLABLE DDYAEL -->
+      <map code="0xb58d" name="1em"/><!-- HANGUL SYLLABLE DDYAELG -->
+      <map code="0xb58e" name="1em"/><!-- HANGUL SYLLABLE DDYAELM -->
+      <map code="0xb58f" name="1em"/><!-- HANGUL SYLLABLE DDYAELB -->
+      <map code="0xb590" name="1em"/><!-- HANGUL SYLLABLE DDYAELS -->
+      <map code="0xb591" name="1em"/><!-- HANGUL SYLLABLE DDYAELT -->
+      <map code="0xb592" name="1em"/><!-- HANGUL SYLLABLE DDYAELP -->
+      <map code="0xb593" name="1em"/><!-- HANGUL SYLLABLE DDYAELH -->
+      <map code="0xb594" name="1em"/><!-- HANGUL SYLLABLE DDYAEM -->
+      <map code="0xb595" name="1em"/><!-- HANGUL SYLLABLE DDYAEB -->
+      <map code="0xb596" name="1em"/><!-- HANGUL SYLLABLE DDYAEBS -->
+      <map code="0xb597" name="1em"/><!-- HANGUL SYLLABLE DDYAES -->
+      <map code="0xb598" name="1em"/><!-- HANGUL SYLLABLE DDYAESS -->
+      <map code="0xb599" name="1em"/><!-- HANGUL SYLLABLE DDYAENG -->
+      <map code="0xb59a" name="1em"/><!-- HANGUL SYLLABLE DDYAEJ -->
+      <map code="0xb59b" name="1em"/><!-- HANGUL SYLLABLE DDYAEC -->
+      <map code="0xb59c" name="1em"/><!-- HANGUL SYLLABLE DDYAEK -->
+      <map code="0xb59d" name="1em"/><!-- HANGUL SYLLABLE DDYAET -->
+      <map code="0xb59e" name="1em"/><!-- HANGUL SYLLABLE DDYAEP -->
+      <map code="0xb59f" name="1em"/><!-- HANGUL SYLLABLE DDYAEH -->
+      <map code="0xb5a0" name="1em"/><!-- HANGUL SYLLABLE DDEO -->
+      <map code="0xb5a1" name="1em"/><!-- HANGUL SYLLABLE DDEOG -->
+      <map code="0xb5a2" name="1em"/><!-- HANGUL SYLLABLE DDEOGG -->
+      <map code="0xb5a3" name="1em"/><!-- HANGUL SYLLABLE DDEOGS -->
+      <map code="0xb5a4" name="1em"/><!-- HANGUL SYLLABLE DDEON -->
+      <map code="0xb5a5" name="1em"/><!-- HANGUL SYLLABLE DDEONJ -->
+      <map code="0xb5a6" name="1em"/><!-- HANGUL SYLLABLE DDEONH -->
+      <map code="0xb5a7" name="1em"/><!-- HANGUL SYLLABLE DDEOD -->
+      <map code="0xb5a8" name="1em"/><!-- HANGUL SYLLABLE DDEOL -->
+      <map code="0xb5a9" name="1em"/><!-- HANGUL SYLLABLE DDEOLG -->
+      <map code="0xb5aa" name="1em"/><!-- HANGUL SYLLABLE DDEOLM -->
+      <map code="0xb5ab" name="1em"/><!-- HANGUL SYLLABLE DDEOLB -->
+      <map code="0xb5ac" name="1em"/><!-- HANGUL SYLLABLE DDEOLS -->
+      <map code="0xb5ad" name="1em"/><!-- HANGUL SYLLABLE DDEOLT -->
+      <map code="0xb5ae" name="1em"/><!-- HANGUL SYLLABLE DDEOLP -->
+      <map code="0xb5af" name="1em"/><!-- HANGUL SYLLABLE DDEOLH -->
+      <map code="0xb5b0" name="1em"/><!-- HANGUL SYLLABLE DDEOM -->
+      <map code="0xb5b1" name="1em"/><!-- HANGUL SYLLABLE DDEOB -->
+      <map code="0xb5b2" name="1em"/><!-- HANGUL SYLLABLE DDEOBS -->
+      <map code="0xb5b3" name="1em"/><!-- HANGUL SYLLABLE DDEOS -->
+      <map code="0xb5b4" name="1em"/><!-- HANGUL SYLLABLE DDEOSS -->
+      <map code="0xb5b5" name="1em"/><!-- HANGUL SYLLABLE DDEONG -->
+      <map code="0xb5b6" name="1em"/><!-- HANGUL SYLLABLE DDEOJ -->
+      <map code="0xb5b7" name="1em"/><!-- HANGUL SYLLABLE DDEOC -->
+      <map code="0xb5b8" name="1em"/><!-- HANGUL SYLLABLE DDEOK -->
+      <map code="0xb5b9" name="1em"/><!-- HANGUL SYLLABLE DDEOT -->
+      <map code="0xb5ba" name="1em"/><!-- HANGUL SYLLABLE DDEOP -->
+      <map code="0xb5bb" name="1em"/><!-- HANGUL SYLLABLE DDEOH -->
+      <map code="0xb5bc" name="1em"/><!-- HANGUL SYLLABLE DDE -->
+      <map code="0xb5bd" name="1em"/><!-- HANGUL SYLLABLE DDEG -->
+      <map code="0xb5be" name="1em"/><!-- HANGUL SYLLABLE DDEGG -->
+      <map code="0xb5bf" name="1em"/><!-- HANGUL SYLLABLE DDEGS -->
+      <map code="0xb5c0" name="1em"/><!-- HANGUL SYLLABLE DDEN -->
+      <map code="0xb5c1" name="1em"/><!-- HANGUL SYLLABLE DDENJ -->
+      <map code="0xb5c2" name="1em"/><!-- HANGUL SYLLABLE DDENH -->
+      <map code="0xb5c3" name="1em"/><!-- HANGUL SYLLABLE DDED -->
+      <map code="0xb5c4" name="1em"/><!-- HANGUL SYLLABLE DDEL -->
+      <map code="0xb5c5" name="1em"/><!-- HANGUL SYLLABLE DDELG -->
+      <map code="0xb5c6" name="1em"/><!-- HANGUL SYLLABLE DDELM -->
+      <map code="0xb5c7" name="1em"/><!-- HANGUL SYLLABLE DDELB -->
+      <map code="0xb5c8" name="1em"/><!-- HANGUL SYLLABLE DDELS -->
+      <map code="0xb5c9" name="1em"/><!-- HANGUL SYLLABLE DDELT -->
+      <map code="0xb5ca" name="1em"/><!-- HANGUL SYLLABLE DDELP -->
+      <map code="0xb5cb" name="1em"/><!-- HANGUL SYLLABLE DDELH -->
+      <map code="0xb5cc" name="1em"/><!-- HANGUL SYLLABLE DDEM -->
+      <map code="0xb5cd" name="1em"/><!-- HANGUL SYLLABLE DDEB -->
+      <map code="0xb5ce" name="1em"/><!-- HANGUL SYLLABLE DDEBS -->
+      <map code="0xb5cf" name="1em"/><!-- HANGUL SYLLABLE DDES -->
+      <map code="0xb5d0" name="1em"/><!-- HANGUL SYLLABLE DDESS -->
+      <map code="0xb5d1" name="1em"/><!-- HANGUL SYLLABLE DDENG -->
+      <map code="0xb5d2" name="1em"/><!-- HANGUL SYLLABLE DDEJ -->
+      <map code="0xb5d3" name="1em"/><!-- HANGUL SYLLABLE DDEC -->
+      <map code="0xb5d4" name="1em"/><!-- HANGUL SYLLABLE DDEK -->
+      <map code="0xb5d5" name="1em"/><!-- HANGUL SYLLABLE DDET -->
+      <map code="0xb5d6" name="1em"/><!-- HANGUL SYLLABLE DDEP -->
+      <map code="0xb5d7" name="1em"/><!-- HANGUL SYLLABLE DDEH -->
+      <map code="0xb5d8" name="1em"/><!-- HANGUL SYLLABLE DDYEO -->
+      <map code="0xb5d9" name="1em"/><!-- HANGUL SYLLABLE DDYEOG -->
+      <map code="0xb5da" name="1em"/><!-- HANGUL SYLLABLE DDYEOGG -->
+      <map code="0xb5db" name="1em"/><!-- HANGUL SYLLABLE DDYEOGS -->
+      <map code="0xb5dc" name="1em"/><!-- HANGUL SYLLABLE DDYEON -->
+      <map code="0xb5dd" name="1em"/><!-- HANGUL SYLLABLE DDYEONJ -->
+      <map code="0xb5de" name="1em"/><!-- HANGUL SYLLABLE DDYEONH -->
+      <map code="0xb5df" name="1em"/><!-- HANGUL SYLLABLE DDYEOD -->
+      <map code="0xb5e0" name="1em"/><!-- HANGUL SYLLABLE DDYEOL -->
+      <map code="0xb5e1" name="1em"/><!-- HANGUL SYLLABLE DDYEOLG -->
+      <map code="0xb5e2" name="1em"/><!-- HANGUL SYLLABLE DDYEOLM -->
+      <map code="0xb5e3" name="1em"/><!-- HANGUL SYLLABLE DDYEOLB -->
+      <map code="0xb5e4" name="1em"/><!-- HANGUL SYLLABLE DDYEOLS -->
+      <map code="0xb5e5" name="1em"/><!-- HANGUL SYLLABLE DDYEOLT -->
+      <map code="0xb5e6" name="1em"/><!-- HANGUL SYLLABLE DDYEOLP -->
+      <map code="0xb5e7" name="1em"/><!-- HANGUL SYLLABLE DDYEOLH -->
+      <map code="0xb5e8" name="1em"/><!-- HANGUL SYLLABLE DDYEOM -->
+      <map code="0xb5e9" name="1em"/><!-- HANGUL SYLLABLE DDYEOB -->
+      <map code="0xb5ea" name="1em"/><!-- HANGUL SYLLABLE DDYEOBS -->
+      <map code="0xb5eb" name="1em"/><!-- HANGUL SYLLABLE DDYEOS -->
+      <map code="0xb5ec" name="1em"/><!-- HANGUL SYLLABLE DDYEOSS -->
+      <map code="0xb5ed" name="1em"/><!-- HANGUL SYLLABLE DDYEONG -->
+      <map code="0xb5ee" name="1em"/><!-- HANGUL SYLLABLE DDYEOJ -->
+      <map code="0xb5ef" name="1em"/><!-- HANGUL SYLLABLE DDYEOC -->
+      <map code="0xb5f0" name="1em"/><!-- HANGUL SYLLABLE DDYEOK -->
+      <map code="0xb5f1" name="1em"/><!-- HANGUL SYLLABLE DDYEOT -->
+      <map code="0xb5f2" name="1em"/><!-- HANGUL SYLLABLE DDYEOP -->
+      <map code="0xb5f3" name="1em"/><!-- HANGUL SYLLABLE DDYEOH -->
+      <map code="0xb5f4" name="1em"/><!-- HANGUL SYLLABLE DDYE -->
+      <map code="0xb5f5" name="1em"/><!-- HANGUL SYLLABLE DDYEG -->
+      <map code="0xb5f6" name="1em"/><!-- HANGUL SYLLABLE DDYEGG -->
+      <map code="0xb5f7" name="1em"/><!-- HANGUL SYLLABLE DDYEGS -->
+      <map code="0xb5f8" name="1em"/><!-- HANGUL SYLLABLE DDYEN -->
+      <map code="0xb5f9" name="1em"/><!-- HANGUL SYLLABLE DDYENJ -->
+      <map code="0xb5fa" name="1em"/><!-- HANGUL SYLLABLE DDYENH -->
+      <map code="0xb5fb" name="1em"/><!-- HANGUL SYLLABLE DDYED -->
+      <map code="0xb5fc" name="1em"/><!-- HANGUL SYLLABLE DDYEL -->
+      <map code="0xb5fd" name="1em"/><!-- HANGUL SYLLABLE DDYELG -->
+      <map code="0xb5fe" name="1em"/><!-- HANGUL SYLLABLE DDYELM -->
+      <map code="0xb5ff" name="1em"/><!-- HANGUL SYLLABLE DDYELB -->
+      <map code="0xb600" name="1em"/><!-- HANGUL SYLLABLE DDYELS -->
+      <map code="0xb601" name="1em"/><!-- HANGUL SYLLABLE DDYELT -->
+      <map code="0xb602" name="1em"/><!-- HANGUL SYLLABLE DDYELP -->
+      <map code="0xb603" name="1em"/><!-- HANGUL SYLLABLE DDYELH -->
+      <map code="0xb604" name="1em"/><!-- HANGUL SYLLABLE DDYEM -->
+      <map code="0xb605" name="1em"/><!-- HANGUL SYLLABLE DDYEB -->
+      <map code="0xb606" name="1em"/><!-- HANGUL SYLLABLE DDYEBS -->
+      <map code="0xb607" name="1em"/><!-- HANGUL SYLLABLE DDYES -->
+      <map code="0xb608" name="1em"/><!-- HANGUL SYLLABLE DDYESS -->
+      <map code="0xb609" name="1em"/><!-- HANGUL SYLLABLE DDYENG -->
+      <map code="0xb60a" name="1em"/><!-- HANGUL SYLLABLE DDYEJ -->
+      <map code="0xb60b" name="1em"/><!-- HANGUL SYLLABLE DDYEC -->
+      <map code="0xb60c" name="1em"/><!-- HANGUL SYLLABLE DDYEK -->
+      <map code="0xb60d" name="1em"/><!-- HANGUL SYLLABLE DDYET -->
+      <map code="0xb60e" name="1em"/><!-- HANGUL SYLLABLE DDYEP -->
+      <map code="0xb60f" name="1em"/><!-- HANGUL SYLLABLE DDYEH -->
+      <map code="0xb610" name="1em"/><!-- HANGUL SYLLABLE DDO -->
+      <map code="0xb611" name="1em"/><!-- HANGUL SYLLABLE DDOG -->
+      <map code="0xb612" name="1em"/><!-- HANGUL SYLLABLE DDOGG -->
+      <map code="0xb613" name="1em"/><!-- HANGUL SYLLABLE DDOGS -->
+      <map code="0xb614" name="1em"/><!-- HANGUL SYLLABLE DDON -->
+      <map code="0xb615" name="1em"/><!-- HANGUL SYLLABLE DDONJ -->
+      <map code="0xb616" name="1em"/><!-- HANGUL SYLLABLE DDONH -->
+      <map code="0xb617" name="1em"/><!-- HANGUL SYLLABLE DDOD -->
+      <map code="0xb618" name="1em"/><!-- HANGUL SYLLABLE DDOL -->
+      <map code="0xb619" name="1em"/><!-- HANGUL SYLLABLE DDOLG -->
+      <map code="0xb61a" name="1em"/><!-- HANGUL SYLLABLE DDOLM -->
+      <map code="0xb61b" name="1em"/><!-- HANGUL SYLLABLE DDOLB -->
+      <map code="0xb61c" name="1em"/><!-- HANGUL SYLLABLE DDOLS -->
+      <map code="0xb61d" name="1em"/><!-- HANGUL SYLLABLE DDOLT -->
+      <map code="0xb61e" name="1em"/><!-- HANGUL SYLLABLE DDOLP -->
+      <map code="0xb61f" name="1em"/><!-- HANGUL SYLLABLE DDOLH -->
+      <map code="0xb620" name="1em"/><!-- HANGUL SYLLABLE DDOM -->
+      <map code="0xb621" name="1em"/><!-- HANGUL SYLLABLE DDOB -->
+      <map code="0xb622" name="1em"/><!-- HANGUL SYLLABLE DDOBS -->
+      <map code="0xb623" name="1em"/><!-- HANGUL SYLLABLE DDOS -->
+      <map code="0xb624" name="1em"/><!-- HANGUL SYLLABLE DDOSS -->
+      <map code="0xb625" name="1em"/><!-- HANGUL SYLLABLE DDONG -->
+      <map code="0xb626" name="1em"/><!-- HANGUL SYLLABLE DDOJ -->
+      <map code="0xb627" name="1em"/><!-- HANGUL SYLLABLE DDOC -->
+      <map code="0xb628" name="1em"/><!-- HANGUL SYLLABLE DDOK -->
+      <map code="0xb629" name="1em"/><!-- HANGUL SYLLABLE DDOT -->
+      <map code="0xb62a" name="1em"/><!-- HANGUL SYLLABLE DDOP -->
+      <map code="0xb62b" name="1em"/><!-- HANGUL SYLLABLE DDOH -->
+      <map code="0xb62c" name="1em"/><!-- HANGUL SYLLABLE DDWA -->
+      <map code="0xb62d" name="1em"/><!-- HANGUL SYLLABLE DDWAG -->
+      <map code="0xb62e" name="1em"/><!-- HANGUL SYLLABLE DDWAGG -->
+      <map code="0xb62f" name="1em"/><!-- HANGUL SYLLABLE DDWAGS -->
+      <map code="0xb630" name="1em"/><!-- HANGUL SYLLABLE DDWAN -->
+      <map code="0xb631" name="1em"/><!-- HANGUL SYLLABLE DDWANJ -->
+      <map code="0xb632" name="1em"/><!-- HANGUL SYLLABLE DDWANH -->
+      <map code="0xb633" name="1em"/><!-- HANGUL SYLLABLE DDWAD -->
+      <map code="0xb634" name="1em"/><!-- HANGUL SYLLABLE DDWAL -->
+      <map code="0xb635" name="1em"/><!-- HANGUL SYLLABLE DDWALG -->
+      <map code="0xb636" name="1em"/><!-- HANGUL SYLLABLE DDWALM -->
+      <map code="0xb637" name="1em"/><!-- HANGUL SYLLABLE DDWALB -->
+      <map code="0xb638" name="1em"/><!-- HANGUL SYLLABLE DDWALS -->
+      <map code="0xb639" name="1em"/><!-- HANGUL SYLLABLE DDWALT -->
+      <map code="0xb63a" name="1em"/><!-- HANGUL SYLLABLE DDWALP -->
+      <map code="0xb63b" name="1em"/><!-- HANGUL SYLLABLE DDWALH -->
+      <map code="0xb63c" name="1em"/><!-- HANGUL SYLLABLE DDWAM -->
+      <map code="0xb63d" name="1em"/><!-- HANGUL SYLLABLE DDWAB -->
+      <map code="0xb63e" name="1em"/><!-- HANGUL SYLLABLE DDWABS -->
+      <map code="0xb63f" name="1em"/><!-- HANGUL SYLLABLE DDWAS -->
+      <map code="0xb640" name="1em"/><!-- HANGUL SYLLABLE DDWASS -->
+      <map code="0xb641" name="1em"/><!-- HANGUL SYLLABLE DDWANG -->
+      <map code="0xb642" name="1em"/><!-- HANGUL SYLLABLE DDWAJ -->
+      <map code="0xb643" name="1em"/><!-- HANGUL SYLLABLE DDWAC -->
+      <map code="0xb644" name="1em"/><!-- HANGUL SYLLABLE DDWAK -->
+      <map code="0xb645" name="1em"/><!-- HANGUL SYLLABLE DDWAT -->
+      <map code="0xb646" name="1em"/><!-- HANGUL SYLLABLE DDWAP -->
+      <map code="0xb647" name="1em"/><!-- HANGUL SYLLABLE DDWAH -->
+      <map code="0xb648" name="1em"/><!-- HANGUL SYLLABLE DDWAE -->
+      <map code="0xb649" name="1em"/><!-- HANGUL SYLLABLE DDWAEG -->
+      <map code="0xb64a" name="1em"/><!-- HANGUL SYLLABLE DDWAEGG -->
+      <map code="0xb64b" name="1em"/><!-- HANGUL SYLLABLE DDWAEGS -->
+      <map code="0xb64c" name="1em"/><!-- HANGUL SYLLABLE DDWAEN -->
+      <map code="0xb64d" name="1em"/><!-- HANGUL SYLLABLE DDWAENJ -->
+      <map code="0xb64e" name="1em"/><!-- HANGUL SYLLABLE DDWAENH -->
+      <map code="0xb64f" name="1em"/><!-- HANGUL SYLLABLE DDWAED -->
+      <map code="0xb650" name="1em"/><!-- HANGUL SYLLABLE DDWAEL -->
+      <map code="0xb651" name="1em"/><!-- HANGUL SYLLABLE DDWAELG -->
+      <map code="0xb652" name="1em"/><!-- HANGUL SYLLABLE DDWAELM -->
+      <map code="0xb653" name="1em"/><!-- HANGUL SYLLABLE DDWAELB -->
+      <map code="0xb654" name="1em"/><!-- HANGUL SYLLABLE DDWAELS -->
+      <map code="0xb655" name="1em"/><!-- HANGUL SYLLABLE DDWAELT -->
+      <map code="0xb656" name="1em"/><!-- HANGUL SYLLABLE DDWAELP -->
+      <map code="0xb657" name="1em"/><!-- HANGUL SYLLABLE DDWAELH -->
+      <map code="0xb658" name="1em"/><!-- HANGUL SYLLABLE DDWAEM -->
+      <map code="0xb659" name="1em"/><!-- HANGUL SYLLABLE DDWAEB -->
+      <map code="0xb65a" name="1em"/><!-- HANGUL SYLLABLE DDWAEBS -->
+      <map code="0xb65b" name="1em"/><!-- HANGUL SYLLABLE DDWAES -->
+      <map code="0xb65c" name="1em"/><!-- HANGUL SYLLABLE DDWAESS -->
+      <map code="0xb65d" name="1em"/><!-- HANGUL SYLLABLE DDWAENG -->
+      <map code="0xb65e" name="1em"/><!-- HANGUL SYLLABLE DDWAEJ -->
+      <map code="0xb65f" name="1em"/><!-- HANGUL SYLLABLE DDWAEC -->
+      <map code="0xb660" name="1em"/><!-- HANGUL SYLLABLE DDWAEK -->
+      <map code="0xb661" name="1em"/><!-- HANGUL SYLLABLE DDWAET -->
+      <map code="0xb662" name="1em"/><!-- HANGUL SYLLABLE DDWAEP -->
+      <map code="0xb663" name="1em"/><!-- HANGUL SYLLABLE DDWAEH -->
+      <map code="0xb664" name="1em"/><!-- HANGUL SYLLABLE DDOE -->
+      <map code="0xb665" name="1em"/><!-- HANGUL SYLLABLE DDOEG -->
+      <map code="0xb666" name="1em"/><!-- HANGUL SYLLABLE DDOEGG -->
+      <map code="0xb667" name="1em"/><!-- HANGUL SYLLABLE DDOEGS -->
+      <map code="0xb668" name="1em"/><!-- HANGUL SYLLABLE DDOEN -->
+      <map code="0xb669" name="1em"/><!-- HANGUL SYLLABLE DDOENJ -->
+      <map code="0xb66a" name="1em"/><!-- HANGUL SYLLABLE DDOENH -->
+      <map code="0xb66b" name="1em"/><!-- HANGUL SYLLABLE DDOED -->
+      <map code="0xb66c" name="1em"/><!-- HANGUL SYLLABLE DDOEL -->
+      <map code="0xb66d" name="1em"/><!-- HANGUL SYLLABLE DDOELG -->
+      <map code="0xb66e" name="1em"/><!-- HANGUL SYLLABLE DDOELM -->
+      <map code="0xb66f" name="1em"/><!-- HANGUL SYLLABLE DDOELB -->
+      <map code="0xb670" name="1em"/><!-- HANGUL SYLLABLE DDOELS -->
+      <map code="0xb671" name="1em"/><!-- HANGUL SYLLABLE DDOELT -->
+      <map code="0xb672" name="1em"/><!-- HANGUL SYLLABLE DDOELP -->
+      <map code="0xb673" name="1em"/><!-- HANGUL SYLLABLE DDOELH -->
+      <map code="0xb674" name="1em"/><!-- HANGUL SYLLABLE DDOEM -->
+      <map code="0xb675" name="1em"/><!-- HANGUL SYLLABLE DDOEB -->
+      <map code="0xb676" name="1em"/><!-- HANGUL SYLLABLE DDOEBS -->
+      <map code="0xb677" name="1em"/><!-- HANGUL SYLLABLE DDOES -->
+      <map code="0xb678" name="1em"/><!-- HANGUL SYLLABLE DDOESS -->
+      <map code="0xb679" name="1em"/><!-- HANGUL SYLLABLE DDOENG -->
+      <map code="0xb67a" name="1em"/><!-- HANGUL SYLLABLE DDOEJ -->
+      <map code="0xb67b" name="1em"/><!-- HANGUL SYLLABLE DDOEC -->
+      <map code="0xb67c" name="1em"/><!-- HANGUL SYLLABLE DDOEK -->
+      <map code="0xb67d" name="1em"/><!-- HANGUL SYLLABLE DDOET -->
+      <map code="0xb67e" name="1em"/><!-- HANGUL SYLLABLE DDOEP -->
+      <map code="0xb67f" name="1em"/><!-- HANGUL SYLLABLE DDOEH -->
+      <map code="0xb680" name="1em"/><!-- HANGUL SYLLABLE DDYO -->
+      <map code="0xb681" name="1em"/><!-- HANGUL SYLLABLE DDYOG -->
+      <map code="0xb682" name="1em"/><!-- HANGUL SYLLABLE DDYOGG -->
+      <map code="0xb683" name="1em"/><!-- HANGUL SYLLABLE DDYOGS -->
+      <map code="0xb684" name="1em"/><!-- HANGUL SYLLABLE DDYON -->
+      <map code="0xb685" name="1em"/><!-- HANGUL SYLLABLE DDYONJ -->
+      <map code="0xb686" name="1em"/><!-- HANGUL SYLLABLE DDYONH -->
+      <map code="0xb687" name="1em"/><!-- HANGUL SYLLABLE DDYOD -->
+      <map code="0xb688" name="1em"/><!-- HANGUL SYLLABLE DDYOL -->
+      <map code="0xb689" name="1em"/><!-- HANGUL SYLLABLE DDYOLG -->
+      <map code="0xb68a" name="1em"/><!-- HANGUL SYLLABLE DDYOLM -->
+      <map code="0xb68b" name="1em"/><!-- HANGUL SYLLABLE DDYOLB -->
+      <map code="0xb68c" name="1em"/><!-- HANGUL SYLLABLE DDYOLS -->
+      <map code="0xb68d" name="1em"/><!-- HANGUL SYLLABLE DDYOLT -->
+      <map code="0xb68e" name="1em"/><!-- HANGUL SYLLABLE DDYOLP -->
+      <map code="0xb68f" name="1em"/><!-- HANGUL SYLLABLE DDYOLH -->
+      <map code="0xb690" name="1em"/><!-- HANGUL SYLLABLE DDYOM -->
+      <map code="0xb691" name="1em"/><!-- HANGUL SYLLABLE DDYOB -->
+      <map code="0xb692" name="1em"/><!-- HANGUL SYLLABLE DDYOBS -->
+      <map code="0xb693" name="1em"/><!-- HANGUL SYLLABLE DDYOS -->
+      <map code="0xb694" name="1em"/><!-- HANGUL SYLLABLE DDYOSS -->
+      <map code="0xb695" name="1em"/><!-- HANGUL SYLLABLE DDYONG -->
+      <map code="0xb696" name="1em"/><!-- HANGUL SYLLABLE DDYOJ -->
+      <map code="0xb697" name="1em"/><!-- HANGUL SYLLABLE DDYOC -->
+      <map code="0xb698" name="1em"/><!-- HANGUL SYLLABLE DDYOK -->
+      <map code="0xb699" name="1em"/><!-- HANGUL SYLLABLE DDYOT -->
+      <map code="0xb69a" name="1em"/><!-- HANGUL SYLLABLE DDYOP -->
+      <map code="0xb69b" name="1em"/><!-- HANGUL SYLLABLE DDYOH -->
+      <map code="0xb69c" name="1em"/><!-- HANGUL SYLLABLE DDU -->
+      <map code="0xb69d" name="1em"/><!-- HANGUL SYLLABLE DDUG -->
+      <map code="0xb69e" name="1em"/><!-- HANGUL SYLLABLE DDUGG -->
+      <map code="0xb69f" name="1em"/><!-- HANGUL SYLLABLE DDUGS -->
+      <map code="0xb6a0" name="1em"/><!-- HANGUL SYLLABLE DDUN -->
+      <map code="0xb6a1" name="1em"/><!-- HANGUL SYLLABLE DDUNJ -->
+      <map code="0xb6a2" name="1em"/><!-- HANGUL SYLLABLE DDUNH -->
+      <map code="0xb6a3" name="1em"/><!-- HANGUL SYLLABLE DDUD -->
+      <map code="0xb6a4" name="1em"/><!-- HANGUL SYLLABLE DDUL -->
+      <map code="0xb6a5" name="1em"/><!-- HANGUL SYLLABLE DDULG -->
+      <map code="0xb6a6" name="1em"/><!-- HANGUL SYLLABLE DDULM -->
+      <map code="0xb6a7" name="1em"/><!-- HANGUL SYLLABLE DDULB -->
+      <map code="0xb6a8" name="1em"/><!-- HANGUL SYLLABLE DDULS -->
+      <map code="0xb6a9" name="1em"/><!-- HANGUL SYLLABLE DDULT -->
+      <map code="0xb6aa" name="1em"/><!-- HANGUL SYLLABLE DDULP -->
+      <map code="0xb6ab" name="1em"/><!-- HANGUL SYLLABLE DDULH -->
+      <map code="0xb6ac" name="1em"/><!-- HANGUL SYLLABLE DDUM -->
+      <map code="0xb6ad" name="1em"/><!-- HANGUL SYLLABLE DDUB -->
+      <map code="0xb6ae" name="1em"/><!-- HANGUL SYLLABLE DDUBS -->
+      <map code="0xb6af" name="1em"/><!-- HANGUL SYLLABLE DDUS -->
+      <map code="0xb6b0" name="1em"/><!-- HANGUL SYLLABLE DDUSS -->
+      <map code="0xb6b1" name="1em"/><!-- HANGUL SYLLABLE DDUNG -->
+      <map code="0xb6b2" name="1em"/><!-- HANGUL SYLLABLE DDUJ -->
+      <map code="0xb6b3" name="1em"/><!-- HANGUL SYLLABLE DDUC -->
+      <map code="0xb6b4" name="1em"/><!-- HANGUL SYLLABLE DDUK -->
+      <map code="0xb6b5" name="1em"/><!-- HANGUL SYLLABLE DDUT -->
+      <map code="0xb6b6" name="1em"/><!-- HANGUL SYLLABLE DDUP -->
+      <map code="0xb6b7" name="1em"/><!-- HANGUL SYLLABLE DDUH -->
+      <map code="0xb6b8" name="1em"/><!-- HANGUL SYLLABLE DDWEO -->
+      <map code="0xb6b9" name="1em"/><!-- HANGUL SYLLABLE DDWEOG -->
+      <map code="0xb6ba" name="1em"/><!-- HANGUL SYLLABLE DDWEOGG -->
+      <map code="0xb6bb" name="1em"/><!-- HANGUL SYLLABLE DDWEOGS -->
+      <map code="0xb6bc" name="1em"/><!-- HANGUL SYLLABLE DDWEON -->
+      <map code="0xb6bd" name="1em"/><!-- HANGUL SYLLABLE DDWEONJ -->
+      <map code="0xb6be" name="1em"/><!-- HANGUL SYLLABLE DDWEONH -->
+      <map code="0xb6bf" name="1em"/><!-- HANGUL SYLLABLE DDWEOD -->
+      <map code="0xb6c0" name="1em"/><!-- HANGUL SYLLABLE DDWEOL -->
+      <map code="0xb6c1" name="1em"/><!-- HANGUL SYLLABLE DDWEOLG -->
+      <map code="0xb6c2" name="1em"/><!-- HANGUL SYLLABLE DDWEOLM -->
+      <map code="0xb6c3" name="1em"/><!-- HANGUL SYLLABLE DDWEOLB -->
+      <map code="0xb6c4" name="1em"/><!-- HANGUL SYLLABLE DDWEOLS -->
+      <map code="0xb6c5" name="1em"/><!-- HANGUL SYLLABLE DDWEOLT -->
+      <map code="0xb6c6" name="1em"/><!-- HANGUL SYLLABLE DDWEOLP -->
+      <map code="0xb6c7" name="1em"/><!-- HANGUL SYLLABLE DDWEOLH -->
+      <map code="0xb6c8" name="1em"/><!-- HANGUL SYLLABLE DDWEOM -->
+      <map code="0xb6c9" name="1em"/><!-- HANGUL SYLLABLE DDWEOB -->
+      <map code="0xb6ca" name="1em"/><!-- HANGUL SYLLABLE DDWEOBS -->
+      <map code="0xb6cb" name="1em"/><!-- HANGUL SYLLABLE DDWEOS -->
+      <map code="0xb6cc" name="1em"/><!-- HANGUL SYLLABLE DDWEOSS -->
+      <map code="0xb6cd" name="1em"/><!-- HANGUL SYLLABLE DDWEONG -->
+      <map code="0xb6ce" name="1em"/><!-- HANGUL SYLLABLE DDWEOJ -->
+      <map code="0xb6cf" name="1em"/><!-- HANGUL SYLLABLE DDWEOC -->
+      <map code="0xb6d0" name="1em"/><!-- HANGUL SYLLABLE DDWEOK -->
+      <map code="0xb6d1" name="1em"/><!-- HANGUL SYLLABLE DDWEOT -->
+      <map code="0xb6d2" name="1em"/><!-- HANGUL SYLLABLE DDWEOP -->
+      <map code="0xb6d3" name="1em"/><!-- HANGUL SYLLABLE DDWEOH -->
+      <map code="0xb6d4" name="1em"/><!-- HANGUL SYLLABLE DDWE -->
+      <map code="0xb6d5" name="1em"/><!-- HANGUL SYLLABLE DDWEG -->
+      <map code="0xb6d6" name="1em"/><!-- HANGUL SYLLABLE DDWEGG -->
+      <map code="0xb6d7" name="1em"/><!-- HANGUL SYLLABLE DDWEGS -->
+      <map code="0xb6d8" name="1em"/><!-- HANGUL SYLLABLE DDWEN -->
+      <map code="0xb6d9" name="1em"/><!-- HANGUL SYLLABLE DDWENJ -->
+      <map code="0xb6da" name="1em"/><!-- HANGUL SYLLABLE DDWENH -->
+      <map code="0xb6db" name="1em"/><!-- HANGUL SYLLABLE DDWED -->
+      <map code="0xb6dc" name="1em"/><!-- HANGUL SYLLABLE DDWEL -->
+      <map code="0xb6dd" name="1em"/><!-- HANGUL SYLLABLE DDWELG -->
+      <map code="0xb6de" name="1em"/><!-- HANGUL SYLLABLE DDWELM -->
+      <map code="0xb6df" name="1em"/><!-- HANGUL SYLLABLE DDWELB -->
+      <map code="0xb6e0" name="1em"/><!-- HANGUL SYLLABLE DDWELS -->
+      <map code="0xb6e1" name="1em"/><!-- HANGUL SYLLABLE DDWELT -->
+      <map code="0xb6e2" name="1em"/><!-- HANGUL SYLLABLE DDWELP -->
+      <map code="0xb6e3" name="1em"/><!-- HANGUL SYLLABLE DDWELH -->
+      <map code="0xb6e4" name="1em"/><!-- HANGUL SYLLABLE DDWEM -->
+      <map code="0xb6e5" name="1em"/><!-- HANGUL SYLLABLE DDWEB -->
+      <map code="0xb6e6" name="1em"/><!-- HANGUL SYLLABLE DDWEBS -->
+      <map code="0xb6e7" name="1em"/><!-- HANGUL SYLLABLE DDWES -->
+      <map code="0xb6e8" name="1em"/><!-- HANGUL SYLLABLE DDWESS -->
+      <map code="0xb6e9" name="1em"/><!-- HANGUL SYLLABLE DDWENG -->
+      <map code="0xb6ea" name="1em"/><!-- HANGUL SYLLABLE DDWEJ -->
+      <map code="0xb6eb" name="1em"/><!-- HANGUL SYLLABLE DDWEC -->
+      <map code="0xb6ec" name="1em"/><!-- HANGUL SYLLABLE DDWEK -->
+      <map code="0xb6ed" name="1em"/><!-- HANGUL SYLLABLE DDWET -->
+      <map code="0xb6ee" name="1em"/><!-- HANGUL SYLLABLE DDWEP -->
+      <map code="0xb6ef" name="1em"/><!-- HANGUL SYLLABLE DDWEH -->
+      <map code="0xb6f0" name="1em"/><!-- HANGUL SYLLABLE DDWI -->
+      <map code="0xb6f1" name="1em"/><!-- HANGUL SYLLABLE DDWIG -->
+      <map code="0xb6f2" name="1em"/><!-- HANGUL SYLLABLE DDWIGG -->
+      <map code="0xb6f3" name="1em"/><!-- HANGUL SYLLABLE DDWIGS -->
+      <map code="0xb6f4" name="1em"/><!-- HANGUL SYLLABLE DDWIN -->
+      <map code="0xb6f5" name="1em"/><!-- HANGUL SYLLABLE DDWINJ -->
+      <map code="0xb6f6" name="1em"/><!-- HANGUL SYLLABLE DDWINH -->
+      <map code="0xb6f7" name="1em"/><!-- HANGUL SYLLABLE DDWID -->
+      <map code="0xb6f8" name="1em"/><!-- HANGUL SYLLABLE DDWIL -->
+      <map code="0xb6f9" name="1em"/><!-- HANGUL SYLLABLE DDWILG -->
+      <map code="0xb6fa" name="1em"/><!-- HANGUL SYLLABLE DDWILM -->
+      <map code="0xb6fb" name="1em"/><!-- HANGUL SYLLABLE DDWILB -->
+      <map code="0xb6fc" name="1em"/><!-- HANGUL SYLLABLE DDWILS -->
+      <map code="0xb6fd" name="1em"/><!-- HANGUL SYLLABLE DDWILT -->
+      <map code="0xb6fe" name="1em"/><!-- HANGUL SYLLABLE DDWILP -->
+      <map code="0xb6ff" name="1em"/><!-- HANGUL SYLLABLE DDWILH -->
+      <map code="0xb700" name="1em"/><!-- HANGUL SYLLABLE DDWIM -->
+      <map code="0xb701" name="1em"/><!-- HANGUL SYLLABLE DDWIB -->
+      <map code="0xb702" name="1em"/><!-- HANGUL SYLLABLE DDWIBS -->
+      <map code="0xb703" name="1em"/><!-- HANGUL SYLLABLE DDWIS -->
+      <map code="0xb704" name="1em"/><!-- HANGUL SYLLABLE DDWISS -->
+      <map code="0xb705" name="1em"/><!-- HANGUL SYLLABLE DDWING -->
+      <map code="0xb706" name="1em"/><!-- HANGUL SYLLABLE DDWIJ -->
+      <map code="0xb707" name="1em"/><!-- HANGUL SYLLABLE DDWIC -->
+      <map code="0xb708" name="1em"/><!-- HANGUL SYLLABLE DDWIK -->
+      <map code="0xb709" name="1em"/><!-- HANGUL SYLLABLE DDWIT -->
+      <map code="0xb70a" name="1em"/><!-- HANGUL SYLLABLE DDWIP -->
+      <map code="0xb70b" name="1em"/><!-- HANGUL SYLLABLE DDWIH -->
+      <map code="0xb70c" name="1em"/><!-- HANGUL SYLLABLE DDYU -->
+      <map code="0xb70d" name="1em"/><!-- HANGUL SYLLABLE DDYUG -->
+      <map code="0xb70e" name="1em"/><!-- HANGUL SYLLABLE DDYUGG -->
+      <map code="0xb70f" name="1em"/><!-- HANGUL SYLLABLE DDYUGS -->
+      <map code="0xb710" name="1em"/><!-- HANGUL SYLLABLE DDYUN -->
+      <map code="0xb711" name="1em"/><!-- HANGUL SYLLABLE DDYUNJ -->
+      <map code="0xb712" name="1em"/><!-- HANGUL SYLLABLE DDYUNH -->
+      <map code="0xb713" name="1em"/><!-- HANGUL SYLLABLE DDYUD -->
+      <map code="0xb714" name="1em"/><!-- HANGUL SYLLABLE DDYUL -->
+      <map code="0xb715" name="1em"/><!-- HANGUL SYLLABLE DDYULG -->
+      <map code="0xb716" name="1em"/><!-- HANGUL SYLLABLE DDYULM -->
+      <map code="0xb717" name="1em"/><!-- HANGUL SYLLABLE DDYULB -->
+      <map code="0xb718" name="1em"/><!-- HANGUL SYLLABLE DDYULS -->
+      <map code="0xb719" name="1em"/><!-- HANGUL SYLLABLE DDYULT -->
+      <map code="0xb71a" name="1em"/><!-- HANGUL SYLLABLE DDYULP -->
+      <map code="0xb71b" name="1em"/><!-- HANGUL SYLLABLE DDYULH -->
+      <map code="0xb71c" name="1em"/><!-- HANGUL SYLLABLE DDYUM -->
+      <map code="0xb71d" name="1em"/><!-- HANGUL SYLLABLE DDYUB -->
+      <map code="0xb71e" name="1em"/><!-- HANGUL SYLLABLE DDYUBS -->
+      <map code="0xb71f" name="1em"/><!-- HANGUL SYLLABLE DDYUS -->
+      <map code="0xb720" name="1em"/><!-- HANGUL SYLLABLE DDYUSS -->
+      <map code="0xb721" name="1em"/><!-- HANGUL SYLLABLE DDYUNG -->
+      <map code="0xb722" name="1em"/><!-- HANGUL SYLLABLE DDYUJ -->
+      <map code="0xb723" name="1em"/><!-- HANGUL SYLLABLE DDYUC -->
+      <map code="0xb724" name="1em"/><!-- HANGUL SYLLABLE DDYUK -->
+      <map code="0xb725" name="1em"/><!-- HANGUL SYLLABLE DDYUT -->
+      <map code="0xb726" name="1em"/><!-- HANGUL SYLLABLE DDYUP -->
+      <map code="0xb727" name="1em"/><!-- HANGUL SYLLABLE DDYUH -->
+      <map code="0xb728" name="1em"/><!-- HANGUL SYLLABLE DDEU -->
+      <map code="0xb729" name="1em"/><!-- HANGUL SYLLABLE DDEUG -->
+      <map code="0xb72a" name="1em"/><!-- HANGUL SYLLABLE DDEUGG -->
+      <map code="0xb72b" name="1em"/><!-- HANGUL SYLLABLE DDEUGS -->
+      <map code="0xb72c" name="1em"/><!-- HANGUL SYLLABLE DDEUN -->
+      <map code="0xb72d" name="1em"/><!-- HANGUL SYLLABLE DDEUNJ -->
+      <map code="0xb72e" name="1em"/><!-- HANGUL SYLLABLE DDEUNH -->
+      <map code="0xb72f" name="1em"/><!-- HANGUL SYLLABLE DDEUD -->
+      <map code="0xb730" name="1em"/><!-- HANGUL SYLLABLE DDEUL -->
+      <map code="0xb731" name="1em"/><!-- HANGUL SYLLABLE DDEULG -->
+      <map code="0xb732" name="1em"/><!-- HANGUL SYLLABLE DDEULM -->
+      <map code="0xb733" name="1em"/><!-- HANGUL SYLLABLE DDEULB -->
+      <map code="0xb734" name="1em"/><!-- HANGUL SYLLABLE DDEULS -->
+      <map code="0xb735" name="1em"/><!-- HANGUL SYLLABLE DDEULT -->
+      <map code="0xb736" name="1em"/><!-- HANGUL SYLLABLE DDEULP -->
+      <map code="0xb737" name="1em"/><!-- HANGUL SYLLABLE DDEULH -->
+      <map code="0xb738" name="1em"/><!-- HANGUL SYLLABLE DDEUM -->
+      <map code="0xb739" name="1em"/><!-- HANGUL SYLLABLE DDEUB -->
+      <map code="0xb73a" name="1em"/><!-- HANGUL SYLLABLE DDEUBS -->
+      <map code="0xb73b" name="1em"/><!-- HANGUL SYLLABLE DDEUS -->
+      <map code="0xb73c" name="1em"/><!-- HANGUL SYLLABLE DDEUSS -->
+      <map code="0xb73d" name="1em"/><!-- HANGUL SYLLABLE DDEUNG -->
+      <map code="0xb73e" name="1em"/><!-- HANGUL SYLLABLE DDEUJ -->
+      <map code="0xb73f" name="1em"/><!-- HANGUL SYLLABLE DDEUC -->
+      <map code="0xb740" name="1em"/><!-- HANGUL SYLLABLE DDEUK -->
+      <map code="0xb741" name="1em"/><!-- HANGUL SYLLABLE DDEUT -->
+      <map code="0xb742" name="1em"/><!-- HANGUL SYLLABLE DDEUP -->
+      <map code="0xb743" name="1em"/><!-- HANGUL SYLLABLE DDEUH -->
+      <map code="0xb744" name="1em"/><!-- HANGUL SYLLABLE DDYI -->
+      <map code="0xb745" name="1em"/><!-- HANGUL SYLLABLE DDYIG -->
+      <map code="0xb746" name="1em"/><!-- HANGUL SYLLABLE DDYIGG -->
+      <map code="0xb747" name="1em"/><!-- HANGUL SYLLABLE DDYIGS -->
+      <map code="0xb748" name="1em"/><!-- HANGUL SYLLABLE DDYIN -->
+      <map code="0xb749" name="1em"/><!-- HANGUL SYLLABLE DDYINJ -->
+      <map code="0xb74a" name="1em"/><!-- HANGUL SYLLABLE DDYINH -->
+      <map code="0xb74b" name="1em"/><!-- HANGUL SYLLABLE DDYID -->
+      <map code="0xb74c" name="1em"/><!-- HANGUL SYLLABLE DDYIL -->
+      <map code="0xb74d" name="1em"/><!-- HANGUL SYLLABLE DDYILG -->
+      <map code="0xb74e" name="1em"/><!-- HANGUL SYLLABLE DDYILM -->
+      <map code="0xb74f" name="1em"/><!-- HANGUL SYLLABLE DDYILB -->
+      <map code="0xb750" name="1em"/><!-- HANGUL SYLLABLE DDYILS -->
+      <map code="0xb751" name="1em"/><!-- HANGUL SYLLABLE DDYILT -->
+      <map code="0xb752" name="1em"/><!-- HANGUL SYLLABLE DDYILP -->
+      <map code="0xb753" name="1em"/><!-- HANGUL SYLLABLE DDYILH -->
+      <map code="0xb754" name="1em"/><!-- HANGUL SYLLABLE DDYIM -->
+      <map code="0xb755" name="1em"/><!-- HANGUL SYLLABLE DDYIB -->
+      <map code="0xb756" name="1em"/><!-- HANGUL SYLLABLE DDYIBS -->
+      <map code="0xb757" name="1em"/><!-- HANGUL SYLLABLE DDYIS -->
+      <map code="0xb758" name="1em"/><!-- HANGUL SYLLABLE DDYISS -->
+      <map code="0xb759" name="1em"/><!-- HANGUL SYLLABLE DDYING -->
+      <map code="0xb75a" name="1em"/><!-- HANGUL SYLLABLE DDYIJ -->
+      <map code="0xb75b" name="1em"/><!-- HANGUL SYLLABLE DDYIC -->
+      <map code="0xb75c" name="1em"/><!-- HANGUL SYLLABLE DDYIK -->
+      <map code="0xb75d" name="1em"/><!-- HANGUL SYLLABLE DDYIT -->
+      <map code="0xb75e" name="1em"/><!-- HANGUL SYLLABLE DDYIP -->
+      <map code="0xb75f" name="1em"/><!-- HANGUL SYLLABLE DDYIH -->
+      <map code="0xb760" name="1em"/><!-- HANGUL SYLLABLE DDI -->
+      <map code="0xb761" name="1em"/><!-- HANGUL SYLLABLE DDIG -->
+      <map code="0xb762" name="1em"/><!-- HANGUL SYLLABLE DDIGG -->
+      <map code="0xb763" name="1em"/><!-- HANGUL SYLLABLE DDIGS -->
+      <map code="0xb764" name="1em"/><!-- HANGUL SYLLABLE DDIN -->
+      <map code="0xb765" name="1em"/><!-- HANGUL SYLLABLE DDINJ -->
+      <map code="0xb766" name="1em"/><!-- HANGUL SYLLABLE DDINH -->
+      <map code="0xb767" name="1em"/><!-- HANGUL SYLLABLE DDID -->
+      <map code="0xb768" name="1em"/><!-- HANGUL SYLLABLE DDIL -->
+      <map code="0xb769" name="1em"/><!-- HANGUL SYLLABLE DDILG -->
+      <map code="0xb76a" name="1em"/><!-- HANGUL SYLLABLE DDILM -->
+      <map code="0xb76b" name="1em"/><!-- HANGUL SYLLABLE DDILB -->
+      <map code="0xb76c" name="1em"/><!-- HANGUL SYLLABLE DDILS -->
+      <map code="0xb76d" name="1em"/><!-- HANGUL SYLLABLE DDILT -->
+      <map code="0xb76e" name="1em"/><!-- HANGUL SYLLABLE DDILP -->
+      <map code="0xb76f" name="1em"/><!-- HANGUL SYLLABLE DDILH -->
+      <map code="0xb770" name="1em"/><!-- HANGUL SYLLABLE DDIM -->
+      <map code="0xb771" name="1em"/><!-- HANGUL SYLLABLE DDIB -->
+      <map code="0xb772" name="1em"/><!-- HANGUL SYLLABLE DDIBS -->
+      <map code="0xb773" name="1em"/><!-- HANGUL SYLLABLE DDIS -->
+      <map code="0xb774" name="1em"/><!-- HANGUL SYLLABLE DDISS -->
+      <map code="0xb775" name="1em"/><!-- HANGUL SYLLABLE DDING -->
+      <map code="0xb776" name="1em"/><!-- HANGUL SYLLABLE DDIJ -->
+      <map code="0xb777" name="1em"/><!-- HANGUL SYLLABLE DDIC -->
+      <map code="0xb778" name="1em"/><!-- HANGUL SYLLABLE DDIK -->
+      <map code="0xb779" name="1em"/><!-- HANGUL SYLLABLE DDIT -->
+      <map code="0xb77a" name="1em"/><!-- HANGUL SYLLABLE DDIP -->
+      <map code="0xb77b" name="1em"/><!-- HANGUL SYLLABLE DDIH -->
+      <map code="0xb77c" name="1em"/><!-- HANGUL SYLLABLE RA -->
+      <map code="0xb77d" name="1em"/><!-- HANGUL SYLLABLE RAG -->
+      <map code="0xb77e" name="1em"/><!-- HANGUL SYLLABLE RAGG -->
+      <map code="0xb77f" name="1em"/><!-- HANGUL SYLLABLE RAGS -->
+      <map code="0xb780" name="1em"/><!-- HANGUL SYLLABLE RAN -->
+      <map code="0xb781" name="1em"/><!-- HANGUL SYLLABLE RANJ -->
+      <map code="0xb782" name="1em"/><!-- HANGUL SYLLABLE RANH -->
+      <map code="0xb783" name="1em"/><!-- HANGUL SYLLABLE RAD -->
+      <map code="0xb784" name="1em"/><!-- HANGUL SYLLABLE RAL -->
+      <map code="0xb785" name="1em"/><!-- HANGUL SYLLABLE RALG -->
+      <map code="0xb786" name="1em"/><!-- HANGUL SYLLABLE RALM -->
+      <map code="0xb787" name="1em"/><!-- HANGUL SYLLABLE RALB -->
+      <map code="0xb788" name="1em"/><!-- HANGUL SYLLABLE RALS -->
+      <map code="0xb789" name="1em"/><!-- HANGUL SYLLABLE RALT -->
+      <map code="0xb78a" name="1em"/><!-- HANGUL SYLLABLE RALP -->
+      <map code="0xb78b" name="1em"/><!-- HANGUL SYLLABLE RALH -->
+      <map code="0xb78c" name="1em"/><!-- HANGUL SYLLABLE RAM -->
+      <map code="0xb78d" name="1em"/><!-- HANGUL SYLLABLE RAB -->
+      <map code="0xb78e" name="1em"/><!-- HANGUL SYLLABLE RABS -->
+      <map code="0xb78f" name="1em"/><!-- HANGUL SYLLABLE RAS -->
+      <map code="0xb790" name="1em"/><!-- HANGUL SYLLABLE RASS -->
+      <map code="0xb791" name="1em"/><!-- HANGUL SYLLABLE RANG -->
+      <map code="0xb792" name="1em"/><!-- HANGUL SYLLABLE RAJ -->
+      <map code="0xb793" name="1em"/><!-- HANGUL SYLLABLE RAC -->
+      <map code="0xb794" name="1em"/><!-- HANGUL SYLLABLE RAK -->
+      <map code="0xb795" name="1em"/><!-- HANGUL SYLLABLE RAT -->
+      <map code="0xb796" name="1em"/><!-- HANGUL SYLLABLE RAP -->
+      <map code="0xb797" name="1em"/><!-- HANGUL SYLLABLE RAH -->
+      <map code="0xb798" name="1em"/><!-- HANGUL SYLLABLE RAE -->
+      <map code="0xb799" name="1em"/><!-- HANGUL SYLLABLE RAEG -->
+      <map code="0xb79a" name="1em"/><!-- HANGUL SYLLABLE RAEGG -->
+      <map code="0xb79b" name="1em"/><!-- HANGUL SYLLABLE RAEGS -->
+      <map code="0xb79c" name="1em"/><!-- HANGUL SYLLABLE RAEN -->
+      <map code="0xb79d" name="1em"/><!-- HANGUL SYLLABLE RAENJ -->
+      <map code="0xb79e" name="1em"/><!-- HANGUL SYLLABLE RAENH -->
+      <map code="0xb79f" name="1em"/><!-- HANGUL SYLLABLE RAED -->
+      <map code="0xb7a0" name="1em"/><!-- HANGUL SYLLABLE RAEL -->
+      <map code="0xb7a1" name="1em"/><!-- HANGUL SYLLABLE RAELG -->
+      <map code="0xb7a2" name="1em"/><!-- HANGUL SYLLABLE RAELM -->
+      <map code="0xb7a3" name="1em"/><!-- HANGUL SYLLABLE RAELB -->
+      <map code="0xb7a4" name="1em"/><!-- HANGUL SYLLABLE RAELS -->
+      <map code="0xb7a5" name="1em"/><!-- HANGUL SYLLABLE RAELT -->
+      <map code="0xb7a6" name="1em"/><!-- HANGUL SYLLABLE RAELP -->
+      <map code="0xb7a7" name="1em"/><!-- HANGUL SYLLABLE RAELH -->
+      <map code="0xb7a8" name="1em"/><!-- HANGUL SYLLABLE RAEM -->
+      <map code="0xb7a9" name="1em"/><!-- HANGUL SYLLABLE RAEB -->
+      <map code="0xb7aa" name="1em"/><!-- HANGUL SYLLABLE RAEBS -->
+      <map code="0xb7ab" name="1em"/><!-- HANGUL SYLLABLE RAES -->
+      <map code="0xb7ac" name="1em"/><!-- HANGUL SYLLABLE RAESS -->
+      <map code="0xb7ad" name="1em"/><!-- HANGUL SYLLABLE RAENG -->
+      <map code="0xb7ae" name="1em"/><!-- HANGUL SYLLABLE RAEJ -->
+      <map code="0xb7af" name="1em"/><!-- HANGUL SYLLABLE RAEC -->
+      <map code="0xb7b0" name="1em"/><!-- HANGUL SYLLABLE RAEK -->
+      <map code="0xb7b1" name="1em"/><!-- HANGUL SYLLABLE RAET -->
+      <map code="0xb7b2" name="1em"/><!-- HANGUL SYLLABLE RAEP -->
+      <map code="0xb7b3" name="1em"/><!-- HANGUL SYLLABLE RAEH -->
+      <map code="0xb7b4" name="1em"/><!-- HANGUL SYLLABLE RYA -->
+      <map code="0xb7b5" name="1em"/><!-- HANGUL SYLLABLE RYAG -->
+      <map code="0xb7b6" name="1em"/><!-- HANGUL SYLLABLE RYAGG -->
+      <map code="0xb7b7" name="1em"/><!-- HANGUL SYLLABLE RYAGS -->
+      <map code="0xb7b8" name="1em"/><!-- HANGUL SYLLABLE RYAN -->
+      <map code="0xb7b9" name="1em"/><!-- HANGUL SYLLABLE RYANJ -->
+      <map code="0xb7ba" name="1em"/><!-- HANGUL SYLLABLE RYANH -->
+      <map code="0xb7bb" name="1em"/><!-- HANGUL SYLLABLE RYAD -->
+      <map code="0xb7bc" name="1em"/><!-- HANGUL SYLLABLE RYAL -->
+      <map code="0xb7bd" name="1em"/><!-- HANGUL SYLLABLE RYALG -->
+      <map code="0xb7be" name="1em"/><!-- HANGUL SYLLABLE RYALM -->
+      <map code="0xb7bf" name="1em"/><!-- HANGUL SYLLABLE RYALB -->
+      <map code="0xb7c0" name="1em"/><!-- HANGUL SYLLABLE RYALS -->
+      <map code="0xb7c1" name="1em"/><!-- HANGUL SYLLABLE RYALT -->
+      <map code="0xb7c2" name="1em"/><!-- HANGUL SYLLABLE RYALP -->
+      <map code="0xb7c3" name="1em"/><!-- HANGUL SYLLABLE RYALH -->
+      <map code="0xb7c4" name="1em"/><!-- HANGUL SYLLABLE RYAM -->
+      <map code="0xb7c5" name="1em"/><!-- HANGUL SYLLABLE RYAB -->
+      <map code="0xb7c6" name="1em"/><!-- HANGUL SYLLABLE RYABS -->
+      <map code="0xb7c7" name="1em"/><!-- HANGUL SYLLABLE RYAS -->
+      <map code="0xb7c8" name="1em"/><!-- HANGUL SYLLABLE RYASS -->
+      <map code="0xb7c9" name="1em"/><!-- HANGUL SYLLABLE RYANG -->
+      <map code="0xb7ca" name="1em"/><!-- HANGUL SYLLABLE RYAJ -->
+      <map code="0xb7cb" name="1em"/><!-- HANGUL SYLLABLE RYAC -->
+      <map code="0xb7cc" name="1em"/><!-- HANGUL SYLLABLE RYAK -->
+      <map code="0xb7cd" name="1em"/><!-- HANGUL SYLLABLE RYAT -->
+      <map code="0xb7ce" name="1em"/><!-- HANGUL SYLLABLE RYAP -->
+      <map code="0xb7cf" name="1em"/><!-- HANGUL SYLLABLE RYAH -->
+      <map code="0xb7d0" name="1em"/><!-- HANGUL SYLLABLE RYAE -->
+      <map code="0xb7d1" name="1em"/><!-- HANGUL SYLLABLE RYAEG -->
+      <map code="0xb7d2" name="1em"/><!-- HANGUL SYLLABLE RYAEGG -->
+      <map code="0xb7d3" name="1em"/><!-- HANGUL SYLLABLE RYAEGS -->
+      <map code="0xb7d4" name="1em"/><!-- HANGUL SYLLABLE RYAEN -->
+      <map code="0xb7d5" name="1em"/><!-- HANGUL SYLLABLE RYAENJ -->
+      <map code="0xb7d6" name="1em"/><!-- HANGUL SYLLABLE RYAENH -->
+      <map code="0xb7d7" name="1em"/><!-- HANGUL SYLLABLE RYAED -->
+      <map code="0xb7d8" name="1em"/><!-- HANGUL SYLLABLE RYAEL -->
+      <map code="0xb7d9" name="1em"/><!-- HANGUL SYLLABLE RYAELG -->
+      <map code="0xb7da" name="1em"/><!-- HANGUL SYLLABLE RYAELM -->
+      <map code="0xb7db" name="1em"/><!-- HANGUL SYLLABLE RYAELB -->
+      <map code="0xb7dc" name="1em"/><!-- HANGUL SYLLABLE RYAELS -->
+      <map code="0xb7dd" name="1em"/><!-- HANGUL SYLLABLE RYAELT -->
+      <map code="0xb7de" name="1em"/><!-- HANGUL SYLLABLE RYAELP -->
+      <map code="0xb7df" name="1em"/><!-- HANGUL SYLLABLE RYAELH -->
+      <map code="0xb7e0" name="1em"/><!-- HANGUL SYLLABLE RYAEM -->
+      <map code="0xb7e1" name="1em"/><!-- HANGUL SYLLABLE RYAEB -->
+      <map code="0xb7e2" name="1em"/><!-- HANGUL SYLLABLE RYAEBS -->
+      <map code="0xb7e3" name="1em"/><!-- HANGUL SYLLABLE RYAES -->
+      <map code="0xb7e4" name="1em"/><!-- HANGUL SYLLABLE RYAESS -->
+      <map code="0xb7e5" name="1em"/><!-- HANGUL SYLLABLE RYAENG -->
+      <map code="0xb7e6" name="1em"/><!-- HANGUL SYLLABLE RYAEJ -->
+      <map code="0xb7e7" name="1em"/><!-- HANGUL SYLLABLE RYAEC -->
+      <map code="0xb7e8" name="1em"/><!-- HANGUL SYLLABLE RYAEK -->
+      <map code="0xb7e9" name="1em"/><!-- HANGUL SYLLABLE RYAET -->
+      <map code="0xb7ea" name="1em"/><!-- HANGUL SYLLABLE RYAEP -->
+      <map code="0xb7eb" name="1em"/><!-- HANGUL SYLLABLE RYAEH -->
+      <map code="0xb7ec" name="1em"/><!-- HANGUL SYLLABLE REO -->
+      <map code="0xb7ed" name="1em"/><!-- HANGUL SYLLABLE REOG -->
+      <map code="0xb7ee" name="1em"/><!-- HANGUL SYLLABLE REOGG -->
+      <map code="0xb7ef" name="1em"/><!-- HANGUL SYLLABLE REOGS -->
+      <map code="0xb7f0" name="1em"/><!-- HANGUL SYLLABLE REON -->
+      <map code="0xb7f1" name="1em"/><!-- HANGUL SYLLABLE REONJ -->
+      <map code="0xb7f2" name="1em"/><!-- HANGUL SYLLABLE REONH -->
+      <map code="0xb7f3" name="1em"/><!-- HANGUL SYLLABLE REOD -->
+      <map code="0xb7f4" name="1em"/><!-- HANGUL SYLLABLE REOL -->
+      <map code="0xb7f5" name="1em"/><!-- HANGUL SYLLABLE REOLG -->
+      <map code="0xb7f6" name="1em"/><!-- HANGUL SYLLABLE REOLM -->
+      <map code="0xb7f7" name="1em"/><!-- HANGUL SYLLABLE REOLB -->
+      <map code="0xb7f8" name="1em"/><!-- HANGUL SYLLABLE REOLS -->
+      <map code="0xb7f9" name="1em"/><!-- HANGUL SYLLABLE REOLT -->
+      <map code="0xb7fa" name="1em"/><!-- HANGUL SYLLABLE REOLP -->
+      <map code="0xb7fb" name="1em"/><!-- HANGUL SYLLABLE REOLH -->
+      <map code="0xb7fc" name="1em"/><!-- HANGUL SYLLABLE REOM -->
+      <map code="0xb7fd" name="1em"/><!-- HANGUL SYLLABLE REOB -->
+      <map code="0xb7fe" name="1em"/><!-- HANGUL SYLLABLE REOBS -->
+      <map code="0xb7ff" name="1em"/><!-- HANGUL SYLLABLE REOS -->
+      <map code="0xb800" name="1em"/><!-- HANGUL SYLLABLE REOSS -->
+      <map code="0xb801" name="1em"/><!-- HANGUL SYLLABLE REONG -->
+      <map code="0xb802" name="1em"/><!-- HANGUL SYLLABLE REOJ -->
+      <map code="0xb803" name="1em"/><!-- HANGUL SYLLABLE REOC -->
+      <map code="0xb804" name="1em"/><!-- HANGUL SYLLABLE REOK -->
+      <map code="0xb805" name="1em"/><!-- HANGUL SYLLABLE REOT -->
+      <map code="0xb806" name="1em"/><!-- HANGUL SYLLABLE REOP -->
+      <map code="0xb807" name="1em"/><!-- HANGUL SYLLABLE REOH -->
+      <map code="0xb808" name="1em"/><!-- HANGUL SYLLABLE RE -->
+      <map code="0xb809" name="1em"/><!-- HANGUL SYLLABLE REG -->
+      <map code="0xb80a" name="1em"/><!-- HANGUL SYLLABLE REGG -->
+      <map code="0xb80b" name="1em"/><!-- HANGUL SYLLABLE REGS -->
+      <map code="0xb80c" name="1em"/><!-- HANGUL SYLLABLE REN -->
+      <map code="0xb80d" name="1em"/><!-- HANGUL SYLLABLE RENJ -->
+      <map code="0xb80e" name="1em"/><!-- HANGUL SYLLABLE RENH -->
+      <map code="0xb80f" name="1em"/><!-- HANGUL SYLLABLE RED -->
+      <map code="0xb810" name="1em"/><!-- HANGUL SYLLABLE REL -->
+      <map code="0xb811" name="1em"/><!-- HANGUL SYLLABLE RELG -->
+      <map code="0xb812" name="1em"/><!-- HANGUL SYLLABLE RELM -->
+      <map code="0xb813" name="1em"/><!-- HANGUL SYLLABLE RELB -->
+      <map code="0xb814" name="1em"/><!-- HANGUL SYLLABLE RELS -->
+      <map code="0xb815" name="1em"/><!-- HANGUL SYLLABLE RELT -->
+      <map code="0xb816" name="1em"/><!-- HANGUL SYLLABLE RELP -->
+      <map code="0xb817" name="1em"/><!-- HANGUL SYLLABLE RELH -->
+      <map code="0xb818" name="1em"/><!-- HANGUL SYLLABLE REM -->
+      <map code="0xb819" name="1em"/><!-- HANGUL SYLLABLE REB -->
+      <map code="0xb81a" name="1em"/><!-- HANGUL SYLLABLE REBS -->
+      <map code="0xb81b" name="1em"/><!-- HANGUL SYLLABLE RES -->
+      <map code="0xb81c" name="1em"/><!-- HANGUL SYLLABLE RESS -->
+      <map code="0xb81d" name="1em"/><!-- HANGUL SYLLABLE RENG -->
+      <map code="0xb81e" name="1em"/><!-- HANGUL SYLLABLE REJ -->
+      <map code="0xb81f" name="1em"/><!-- HANGUL SYLLABLE REC -->
+      <map code="0xb820" name="1em"/><!-- HANGUL SYLLABLE REK -->
+      <map code="0xb821" name="1em"/><!-- HANGUL SYLLABLE RET -->
+      <map code="0xb822" name="1em"/><!-- HANGUL SYLLABLE REP -->
+      <map code="0xb823" name="1em"/><!-- HANGUL SYLLABLE REH -->
+      <map code="0xb824" name="1em"/><!-- HANGUL SYLLABLE RYEO -->
+      <map code="0xb825" name="1em"/><!-- HANGUL SYLLABLE RYEOG -->
+      <map code="0xb826" name="1em"/><!-- HANGUL SYLLABLE RYEOGG -->
+      <map code="0xb827" name="1em"/><!-- HANGUL SYLLABLE RYEOGS -->
+      <map code="0xb828" name="1em"/><!-- HANGUL SYLLABLE RYEON -->
+      <map code="0xb829" name="1em"/><!-- HANGUL SYLLABLE RYEONJ -->
+      <map code="0xb82a" name="1em"/><!-- HANGUL SYLLABLE RYEONH -->
+      <map code="0xb82b" name="1em"/><!-- HANGUL SYLLABLE RYEOD -->
+      <map code="0xb82c" name="1em"/><!-- HANGUL SYLLABLE RYEOL -->
+      <map code="0xb82d" name="1em"/><!-- HANGUL SYLLABLE RYEOLG -->
+      <map code="0xb82e" name="1em"/><!-- HANGUL SYLLABLE RYEOLM -->
+      <map code="0xb82f" name="1em"/><!-- HANGUL SYLLABLE RYEOLB -->
+      <map code="0xb830" name="1em"/><!-- HANGUL SYLLABLE RYEOLS -->
+      <map code="0xb831" name="1em"/><!-- HANGUL SYLLABLE RYEOLT -->
+      <map code="0xb832" name="1em"/><!-- HANGUL SYLLABLE RYEOLP -->
+      <map code="0xb833" name="1em"/><!-- HANGUL SYLLABLE RYEOLH -->
+      <map code="0xb834" name="1em"/><!-- HANGUL SYLLABLE RYEOM -->
+      <map code="0xb835" name="1em"/><!-- HANGUL SYLLABLE RYEOB -->
+      <map code="0xb836" name="1em"/><!-- HANGUL SYLLABLE RYEOBS -->
+      <map code="0xb837" name="1em"/><!-- HANGUL SYLLABLE RYEOS -->
+      <map code="0xb838" name="1em"/><!-- HANGUL SYLLABLE RYEOSS -->
+      <map code="0xb839" name="1em"/><!-- HANGUL SYLLABLE RYEONG -->
+      <map code="0xb83a" name="1em"/><!-- HANGUL SYLLABLE RYEOJ -->
+      <map code="0xb83b" name="1em"/><!-- HANGUL SYLLABLE RYEOC -->
+      <map code="0xb83c" name="1em"/><!-- HANGUL SYLLABLE RYEOK -->
+      <map code="0xb83d" name="1em"/><!-- HANGUL SYLLABLE RYEOT -->
+      <map code="0xb83e" name="1em"/><!-- HANGUL SYLLABLE RYEOP -->
+      <map code="0xb83f" name="1em"/><!-- HANGUL SYLLABLE RYEOH -->
+      <map code="0xb840" name="1em"/><!-- HANGUL SYLLABLE RYE -->
+      <map code="0xb841" name="1em"/><!-- HANGUL SYLLABLE RYEG -->
+      <map code="0xb842" name="1em"/><!-- HANGUL SYLLABLE RYEGG -->
+      <map code="0xb843" name="1em"/><!-- HANGUL SYLLABLE RYEGS -->
+      <map code="0xb844" name="1em"/><!-- HANGUL SYLLABLE RYEN -->
+      <map code="0xb845" name="1em"/><!-- HANGUL SYLLABLE RYENJ -->
+      <map code="0xb846" name="1em"/><!-- HANGUL SYLLABLE RYENH -->
+      <map code="0xb847" name="1em"/><!-- HANGUL SYLLABLE RYED -->
+      <map code="0xb848" name="1em"/><!-- HANGUL SYLLABLE RYEL -->
+      <map code="0xb849" name="1em"/><!-- HANGUL SYLLABLE RYELG -->
+      <map code="0xb84a" name="1em"/><!-- HANGUL SYLLABLE RYELM -->
+      <map code="0xb84b" name="1em"/><!-- HANGUL SYLLABLE RYELB -->
+      <map code="0xb84c" name="1em"/><!-- HANGUL SYLLABLE RYELS -->
+      <map code="0xb84d" name="1em"/><!-- HANGUL SYLLABLE RYELT -->
+      <map code="0xb84e" name="1em"/><!-- HANGUL SYLLABLE RYELP -->
+      <map code="0xb84f" name="1em"/><!-- HANGUL SYLLABLE RYELH -->
+      <map code="0xb850" name="1em"/><!-- HANGUL SYLLABLE RYEM -->
+      <map code="0xb851" name="1em"/><!-- HANGUL SYLLABLE RYEB -->
+      <map code="0xb852" name="1em"/><!-- HANGUL SYLLABLE RYEBS -->
+      <map code="0xb853" name="1em"/><!-- HANGUL SYLLABLE RYES -->
+      <map code="0xb854" name="1em"/><!-- HANGUL SYLLABLE RYESS -->
+      <map code="0xb855" name="1em"/><!-- HANGUL SYLLABLE RYENG -->
+      <map code="0xb856" name="1em"/><!-- HANGUL SYLLABLE RYEJ -->
+      <map code="0xb857" name="1em"/><!-- HANGUL SYLLABLE RYEC -->
+      <map code="0xb858" name="1em"/><!-- HANGUL SYLLABLE RYEK -->
+      <map code="0xb859" name="1em"/><!-- HANGUL SYLLABLE RYET -->
+      <map code="0xb85a" name="1em"/><!-- HANGUL SYLLABLE RYEP -->
+      <map code="0xb85b" name="1em"/><!-- HANGUL SYLLABLE RYEH -->
+      <map code="0xb85c" name="1em"/><!-- HANGUL SYLLABLE RO -->
+      <map code="0xb85d" name="1em"/><!-- HANGUL SYLLABLE ROG -->
+      <map code="0xb85e" name="1em"/><!-- HANGUL SYLLABLE ROGG -->
+      <map code="0xb85f" name="1em"/><!-- HANGUL SYLLABLE ROGS -->
+      <map code="0xb860" name="1em"/><!-- HANGUL SYLLABLE RON -->
+      <map code="0xb861" name="1em"/><!-- HANGUL SYLLABLE RONJ -->
+      <map code="0xb862" name="1em"/><!-- HANGUL SYLLABLE RONH -->
+      <map code="0xb863" name="1em"/><!-- HANGUL SYLLABLE ROD -->
+      <map code="0xb864" name="1em"/><!-- HANGUL SYLLABLE ROL -->
+      <map code="0xb865" name="1em"/><!-- HANGUL SYLLABLE ROLG -->
+      <map code="0xb866" name="1em"/><!-- HANGUL SYLLABLE ROLM -->
+      <map code="0xb867" name="1em"/><!-- HANGUL SYLLABLE ROLB -->
+      <map code="0xb868" name="1em"/><!-- HANGUL SYLLABLE ROLS -->
+      <map code="0xb869" name="1em"/><!-- HANGUL SYLLABLE ROLT -->
+      <map code="0xb86a" name="1em"/><!-- HANGUL SYLLABLE ROLP -->
+      <map code="0xb86b" name="1em"/><!-- HANGUL SYLLABLE ROLH -->
+      <map code="0xb86c" name="1em"/><!-- HANGUL SYLLABLE ROM -->
+      <map code="0xb86d" name="1em"/><!-- HANGUL SYLLABLE ROB -->
+      <map code="0xb86e" name="1em"/><!-- HANGUL SYLLABLE ROBS -->
+      <map code="0xb86f" name="1em"/><!-- HANGUL SYLLABLE ROS -->
+      <map code="0xb870" name="1em"/><!-- HANGUL SYLLABLE ROSS -->
+      <map code="0xb871" name="1em"/><!-- HANGUL SYLLABLE RONG -->
+      <map code="0xb872" name="1em"/><!-- HANGUL SYLLABLE ROJ -->
+      <map code="0xb873" name="1em"/><!-- HANGUL SYLLABLE ROC -->
+      <map code="0xb874" name="1em"/><!-- HANGUL SYLLABLE ROK -->
+      <map code="0xb875" name="1em"/><!-- HANGUL SYLLABLE ROT -->
+      <map code="0xb876" name="1em"/><!-- HANGUL SYLLABLE ROP -->
+      <map code="0xb877" name="1em"/><!-- HANGUL SYLLABLE ROH -->
+      <map code="0xb878" name="1em"/><!-- HANGUL SYLLABLE RWA -->
+      <map code="0xb879" name="1em"/><!-- HANGUL SYLLABLE RWAG -->
+      <map code="0xb87a" name="1em"/><!-- HANGUL SYLLABLE RWAGG -->
+      <map code="0xb87b" name="1em"/><!-- HANGUL SYLLABLE RWAGS -->
+      <map code="0xb87c" name="1em"/><!-- HANGUL SYLLABLE RWAN -->
+      <map code="0xb87d" name="1em"/><!-- HANGUL SYLLABLE RWANJ -->
+      <map code="0xb87e" name="1em"/><!-- HANGUL SYLLABLE RWANH -->
+      <map code="0xb87f" name="1em"/><!-- HANGUL SYLLABLE RWAD -->
+      <map code="0xb880" name="1em"/><!-- HANGUL SYLLABLE RWAL -->
+      <map code="0xb881" name="1em"/><!-- HANGUL SYLLABLE RWALG -->
+      <map code="0xb882" name="1em"/><!-- HANGUL SYLLABLE RWALM -->
+      <map code="0xb883" name="1em"/><!-- HANGUL SYLLABLE RWALB -->
+      <map code="0xb884" name="1em"/><!-- HANGUL SYLLABLE RWALS -->
+      <map code="0xb885" name="1em"/><!-- HANGUL SYLLABLE RWALT -->
+      <map code="0xb886" name="1em"/><!-- HANGUL SYLLABLE RWALP -->
+      <map code="0xb887" name="1em"/><!-- HANGUL SYLLABLE RWALH -->
+      <map code="0xb888" name="1em"/><!-- HANGUL SYLLABLE RWAM -->
+      <map code="0xb889" name="1em"/><!-- HANGUL SYLLABLE RWAB -->
+      <map code="0xb88a" name="1em"/><!-- HANGUL SYLLABLE RWABS -->
+      <map code="0xb88b" name="1em"/><!-- HANGUL SYLLABLE RWAS -->
+      <map code="0xb88c" name="1em"/><!-- HANGUL SYLLABLE RWASS -->
+      <map code="0xb88d" name="1em"/><!-- HANGUL SYLLABLE RWANG -->
+      <map code="0xb88e" name="1em"/><!-- HANGUL SYLLABLE RWAJ -->
+      <map code="0xb88f" name="1em"/><!-- HANGUL SYLLABLE RWAC -->
+      <map code="0xb890" name="1em"/><!-- HANGUL SYLLABLE RWAK -->
+      <map code="0xb891" name="1em"/><!-- HANGUL SYLLABLE RWAT -->
+      <map code="0xb892" name="1em"/><!-- HANGUL SYLLABLE RWAP -->
+      <map code="0xb893" name="1em"/><!-- HANGUL SYLLABLE RWAH -->
+      <map code="0xb894" name="1em"/><!-- HANGUL SYLLABLE RWAE -->
+      <map code="0xb895" name="1em"/><!-- HANGUL SYLLABLE RWAEG -->
+      <map code="0xb896" name="1em"/><!-- HANGUL SYLLABLE RWAEGG -->
+      <map code="0xb897" name="1em"/><!-- HANGUL SYLLABLE RWAEGS -->
+      <map code="0xb898" name="1em"/><!-- HANGUL SYLLABLE RWAEN -->
+      <map code="0xb899" name="1em"/><!-- HANGUL SYLLABLE RWAENJ -->
+      <map code="0xb89a" name="1em"/><!-- HANGUL SYLLABLE RWAENH -->
+      <map code="0xb89b" name="1em"/><!-- HANGUL SYLLABLE RWAED -->
+      <map code="0xb89c" name="1em"/><!-- HANGUL SYLLABLE RWAEL -->
+      <map code="0xb89d" name="1em"/><!-- HANGUL SYLLABLE RWAELG -->
+      <map code="0xb89e" name="1em"/><!-- HANGUL SYLLABLE RWAELM -->
+      <map code="0xb89f" name="1em"/><!-- HANGUL SYLLABLE RWAELB -->
+      <map code="0xb8a0" name="1em"/><!-- HANGUL SYLLABLE RWAELS -->
+      <map code="0xb8a1" name="1em"/><!-- HANGUL SYLLABLE RWAELT -->
+      <map code="0xb8a2" name="1em"/><!-- HANGUL SYLLABLE RWAELP -->
+      <map code="0xb8a3" name="1em"/><!-- HANGUL SYLLABLE RWAELH -->
+      <map code="0xb8a4" name="1em"/><!-- HANGUL SYLLABLE RWAEM -->
+      <map code="0xb8a5" name="1em"/><!-- HANGUL SYLLABLE RWAEB -->
+      <map code="0xb8a6" name="1em"/><!-- HANGUL SYLLABLE RWAEBS -->
+      <map code="0xb8a7" name="1em"/><!-- HANGUL SYLLABLE RWAES -->
+      <map code="0xb8a8" name="1em"/><!-- HANGUL SYLLABLE RWAESS -->
+      <map code="0xb8a9" name="1em"/><!-- HANGUL SYLLABLE RWAENG -->
+      <map code="0xb8aa" name="1em"/><!-- HANGUL SYLLABLE RWAEJ -->
+      <map code="0xb8ab" name="1em"/><!-- HANGUL SYLLABLE RWAEC -->
+      <map code="0xb8ac" name="1em"/><!-- HANGUL SYLLABLE RWAEK -->
+      <map code="0xb8ad" name="1em"/><!-- HANGUL SYLLABLE RWAET -->
+      <map code="0xb8ae" name="1em"/><!-- HANGUL SYLLABLE RWAEP -->
+      <map code="0xb8af" name="1em"/><!-- HANGUL SYLLABLE RWAEH -->
+      <map code="0xb8b0" name="1em"/><!-- HANGUL SYLLABLE ROE -->
+      <map code="0xb8b1" name="1em"/><!-- HANGUL SYLLABLE ROEG -->
+      <map code="0xb8b2" name="1em"/><!-- HANGUL SYLLABLE ROEGG -->
+      <map code="0xb8b3" name="1em"/><!-- HANGUL SYLLABLE ROEGS -->
+      <map code="0xb8b4" name="1em"/><!-- HANGUL SYLLABLE ROEN -->
+      <map code="0xb8b5" name="1em"/><!-- HANGUL SYLLABLE ROENJ -->
+      <map code="0xb8b6" name="1em"/><!-- HANGUL SYLLABLE ROENH -->
+      <map code="0xb8b7" name="1em"/><!-- HANGUL SYLLABLE ROED -->
+      <map code="0xb8b8" name="1em"/><!-- HANGUL SYLLABLE ROEL -->
+      <map code="0xb8b9" name="1em"/><!-- HANGUL SYLLABLE ROELG -->
+      <map code="0xb8ba" name="1em"/><!-- HANGUL SYLLABLE ROELM -->
+      <map code="0xb8bb" name="1em"/><!-- HANGUL SYLLABLE ROELB -->
+      <map code="0xb8bc" name="1em"/><!-- HANGUL SYLLABLE ROELS -->
+      <map code="0xb8bd" name="1em"/><!-- HANGUL SYLLABLE ROELT -->
+      <map code="0xb8be" name="1em"/><!-- HANGUL SYLLABLE ROELP -->
+      <map code="0xb8bf" name="1em"/><!-- HANGUL SYLLABLE ROELH -->
+      <map code="0xb8c0" name="1em"/><!-- HANGUL SYLLABLE ROEM -->
+      <map code="0xb8c1" name="1em"/><!-- HANGUL SYLLABLE ROEB -->
+      <map code="0xb8c2" name="1em"/><!-- HANGUL SYLLABLE ROEBS -->
+      <map code="0xb8c3" name="1em"/><!-- HANGUL SYLLABLE ROES -->
+      <map code="0xb8c4" name="1em"/><!-- HANGUL SYLLABLE ROESS -->
+      <map code="0xb8c5" name="1em"/><!-- HANGUL SYLLABLE ROENG -->
+      <map code="0xb8c6" name="1em"/><!-- HANGUL SYLLABLE ROEJ -->
+      <map code="0xb8c7" name="1em"/><!-- HANGUL SYLLABLE ROEC -->
+      <map code="0xb8c8" name="1em"/><!-- HANGUL SYLLABLE ROEK -->
+      <map code="0xb8c9" name="1em"/><!-- HANGUL SYLLABLE ROET -->
+      <map code="0xb8ca" name="1em"/><!-- HANGUL SYLLABLE ROEP -->
+      <map code="0xb8cb" name="1em"/><!-- HANGUL SYLLABLE ROEH -->
+      <map code="0xb8cc" name="1em"/><!-- HANGUL SYLLABLE RYO -->
+      <map code="0xb8cd" name="1em"/><!-- HANGUL SYLLABLE RYOG -->
+      <map code="0xb8ce" name="1em"/><!-- HANGUL SYLLABLE RYOGG -->
+      <map code="0xb8cf" name="1em"/><!-- HANGUL SYLLABLE RYOGS -->
+      <map code="0xb8d0" name="1em"/><!-- HANGUL SYLLABLE RYON -->
+      <map code="0xb8d1" name="1em"/><!-- HANGUL SYLLABLE RYONJ -->
+      <map code="0xb8d2" name="1em"/><!-- HANGUL SYLLABLE RYONH -->
+      <map code="0xb8d3" name="1em"/><!-- HANGUL SYLLABLE RYOD -->
+      <map code="0xb8d4" name="1em"/><!-- HANGUL SYLLABLE RYOL -->
+      <map code="0xb8d5" name="1em"/><!-- HANGUL SYLLABLE RYOLG -->
+      <map code="0xb8d6" name="1em"/><!-- HANGUL SYLLABLE RYOLM -->
+      <map code="0xb8d7" name="1em"/><!-- HANGUL SYLLABLE RYOLB -->
+      <map code="0xb8d8" name="1em"/><!-- HANGUL SYLLABLE RYOLS -->
+      <map code="0xb8d9" name="1em"/><!-- HANGUL SYLLABLE RYOLT -->
+      <map code="0xb8da" name="1em"/><!-- HANGUL SYLLABLE RYOLP -->
+      <map code="0xb8db" name="1em"/><!-- HANGUL SYLLABLE RYOLH -->
+      <map code="0xb8dc" name="1em"/><!-- HANGUL SYLLABLE RYOM -->
+      <map code="0xb8dd" name="1em"/><!-- HANGUL SYLLABLE RYOB -->
+      <map code="0xb8de" name="1em"/><!-- HANGUL SYLLABLE RYOBS -->
+      <map code="0xb8df" name="1em"/><!-- HANGUL SYLLABLE RYOS -->
+      <map code="0xb8e0" name="1em"/><!-- HANGUL SYLLABLE RYOSS -->
+      <map code="0xb8e1" name="1em"/><!-- HANGUL SYLLABLE RYONG -->
+      <map code="0xb8e2" name="1em"/><!-- HANGUL SYLLABLE RYOJ -->
+      <map code="0xb8e3" name="1em"/><!-- HANGUL SYLLABLE RYOC -->
+      <map code="0xb8e4" name="1em"/><!-- HANGUL SYLLABLE RYOK -->
+      <map code="0xb8e5" name="1em"/><!-- HANGUL SYLLABLE RYOT -->
+      <map code="0xb8e6" name="1em"/><!-- HANGUL SYLLABLE RYOP -->
+      <map code="0xb8e7" name="1em"/><!-- HANGUL SYLLABLE RYOH -->
+      <map code="0xb8e8" name="1em"/><!-- HANGUL SYLLABLE RU -->
+      <map code="0xb8e9" name="1em"/><!-- HANGUL SYLLABLE RUG -->
+      <map code="0xb8ea" name="1em"/><!-- HANGUL SYLLABLE RUGG -->
+      <map code="0xb8eb" name="1em"/><!-- HANGUL SYLLABLE RUGS -->
+      <map code="0xb8ec" name="1em"/><!-- HANGUL SYLLABLE RUN -->
+      <map code="0xb8ed" name="1em"/><!-- HANGUL SYLLABLE RUNJ -->
+      <map code="0xb8ee" name="1em"/><!-- HANGUL SYLLABLE RUNH -->
+      <map code="0xb8ef" name="1em"/><!-- HANGUL SYLLABLE RUD -->
+      <map code="0xb8f0" name="1em"/><!-- HANGUL SYLLABLE RUL -->
+      <map code="0xb8f1" name="1em"/><!-- HANGUL SYLLABLE RULG -->
+      <map code="0xb8f2" name="1em"/><!-- HANGUL SYLLABLE RULM -->
+      <map code="0xb8f3" name="1em"/><!-- HANGUL SYLLABLE RULB -->
+      <map code="0xb8f4" name="1em"/><!-- HANGUL SYLLABLE RULS -->
+      <map code="0xb8f5" name="1em"/><!-- HANGUL SYLLABLE RULT -->
+      <map code="0xb8f6" name="1em"/><!-- HANGUL SYLLABLE RULP -->
+      <map code="0xb8f7" name="1em"/><!-- HANGUL SYLLABLE RULH -->
+      <map code="0xb8f8" name="1em"/><!-- HANGUL SYLLABLE RUM -->
+      <map code="0xb8f9" name="1em"/><!-- HANGUL SYLLABLE RUB -->
+      <map code="0xb8fa" name="1em"/><!-- HANGUL SYLLABLE RUBS -->
+      <map code="0xb8fb" name="1em"/><!-- HANGUL SYLLABLE RUS -->
+      <map code="0xb8fc" name="1em"/><!-- HANGUL SYLLABLE RUSS -->
+      <map code="0xb8fd" name="1em"/><!-- HANGUL SYLLABLE RUNG -->
+      <map code="0xb8fe" name="1em"/><!-- HANGUL SYLLABLE RUJ -->
+      <map code="0xb8ff" name="1em"/><!-- HANGUL SYLLABLE RUC -->
+      <map code="0xb900" name="1em"/><!-- HANGUL SYLLABLE RUK -->
+      <map code="0xb901" name="1em"/><!-- HANGUL SYLLABLE RUT -->
+      <map code="0xb902" name="1em"/><!-- HANGUL SYLLABLE RUP -->
+      <map code="0xb903" name="1em"/><!-- HANGUL SYLLABLE RUH -->
+      <map code="0xb904" name="1em"/><!-- HANGUL SYLLABLE RWEO -->
+      <map code="0xb905" name="1em"/><!-- HANGUL SYLLABLE RWEOG -->
+      <map code="0xb906" name="1em"/><!-- HANGUL SYLLABLE RWEOGG -->
+      <map code="0xb907" name="1em"/><!-- HANGUL SYLLABLE RWEOGS -->
+      <map code="0xb908" name="1em"/><!-- HANGUL SYLLABLE RWEON -->
+      <map code="0xb909" name="1em"/><!-- HANGUL SYLLABLE RWEONJ -->
+      <map code="0xb90a" name="1em"/><!-- HANGUL SYLLABLE RWEONH -->
+      <map code="0xb90b" name="1em"/><!-- HANGUL SYLLABLE RWEOD -->
+      <map code="0xb90c" name="1em"/><!-- HANGUL SYLLABLE RWEOL -->
+      <map code="0xb90d" name="1em"/><!-- HANGUL SYLLABLE RWEOLG -->
+      <map code="0xb90e" name="1em"/><!-- HANGUL SYLLABLE RWEOLM -->
+      <map code="0xb90f" name="1em"/><!-- HANGUL SYLLABLE RWEOLB -->
+      <map code="0xb910" name="1em"/><!-- HANGUL SYLLABLE RWEOLS -->
+      <map code="0xb911" name="1em"/><!-- HANGUL SYLLABLE RWEOLT -->
+      <map code="0xb912" name="1em"/><!-- HANGUL SYLLABLE RWEOLP -->
+      <map code="0xb913" name="1em"/><!-- HANGUL SYLLABLE RWEOLH -->
+      <map code="0xb914" name="1em"/><!-- HANGUL SYLLABLE RWEOM -->
+      <map code="0xb915" name="1em"/><!-- HANGUL SYLLABLE RWEOB -->
+      <map code="0xb916" name="1em"/><!-- HANGUL SYLLABLE RWEOBS -->
+      <map code="0xb917" name="1em"/><!-- HANGUL SYLLABLE RWEOS -->
+      <map code="0xb918" name="1em"/><!-- HANGUL SYLLABLE RWEOSS -->
+      <map code="0xb919" name="1em"/><!-- HANGUL SYLLABLE RWEONG -->
+      <map code="0xb91a" name="1em"/><!-- HANGUL SYLLABLE RWEOJ -->
+      <map code="0xb91b" name="1em"/><!-- HANGUL SYLLABLE RWEOC -->
+      <map code="0xb91c" name="1em"/><!-- HANGUL SYLLABLE RWEOK -->
+      <map code="0xb91d" name="1em"/><!-- HANGUL SYLLABLE RWEOT -->
+      <map code="0xb91e" name="1em"/><!-- HANGUL SYLLABLE RWEOP -->
+      <map code="0xb91f" name="1em"/><!-- HANGUL SYLLABLE RWEOH -->
+      <map code="0xb920" name="1em"/><!-- HANGUL SYLLABLE RWE -->
+      <map code="0xb921" name="1em"/><!-- HANGUL SYLLABLE RWEG -->
+      <map code="0xb922" name="1em"/><!-- HANGUL SYLLABLE RWEGG -->
+      <map code="0xb923" name="1em"/><!-- HANGUL SYLLABLE RWEGS -->
+      <map code="0xb924" name="1em"/><!-- HANGUL SYLLABLE RWEN -->
+      <map code="0xb925" name="1em"/><!-- HANGUL SYLLABLE RWENJ -->
+      <map code="0xb926" name="1em"/><!-- HANGUL SYLLABLE RWENH -->
+      <map code="0xb927" name="1em"/><!-- HANGUL SYLLABLE RWED -->
+      <map code="0xb928" name="1em"/><!-- HANGUL SYLLABLE RWEL -->
+      <map code="0xb929" name="1em"/><!-- HANGUL SYLLABLE RWELG -->
+      <map code="0xb92a" name="1em"/><!-- HANGUL SYLLABLE RWELM -->
+      <map code="0xb92b" name="1em"/><!-- HANGUL SYLLABLE RWELB -->
+      <map code="0xb92c" name="1em"/><!-- HANGUL SYLLABLE RWELS -->
+      <map code="0xb92d" name="1em"/><!-- HANGUL SYLLABLE RWELT -->
+      <map code="0xb92e" name="1em"/><!-- HANGUL SYLLABLE RWELP -->
+      <map code="0xb92f" name="1em"/><!-- HANGUL SYLLABLE RWELH -->
+      <map code="0xb930" name="1em"/><!-- HANGUL SYLLABLE RWEM -->
+      <map code="0xb931" name="1em"/><!-- HANGUL SYLLABLE RWEB -->
+      <map code="0xb932" name="1em"/><!-- HANGUL SYLLABLE RWEBS -->
+      <map code="0xb933" name="1em"/><!-- HANGUL SYLLABLE RWES -->
+      <map code="0xb934" name="1em"/><!-- HANGUL SYLLABLE RWESS -->
+      <map code="0xb935" name="1em"/><!-- HANGUL SYLLABLE RWENG -->
+      <map code="0xb936" name="1em"/><!-- HANGUL SYLLABLE RWEJ -->
+      <map code="0xb937" name="1em"/><!-- HANGUL SYLLABLE RWEC -->
+      <map code="0xb938" name="1em"/><!-- HANGUL SYLLABLE RWEK -->
+      <map code="0xb939" name="1em"/><!-- HANGUL SYLLABLE RWET -->
+      <map code="0xb93a" name="1em"/><!-- HANGUL SYLLABLE RWEP -->
+      <map code="0xb93b" name="1em"/><!-- HANGUL SYLLABLE RWEH -->
+      <map code="0xb93c" name="1em"/><!-- HANGUL SYLLABLE RWI -->
+      <map code="0xb93d" name="1em"/><!-- HANGUL SYLLABLE RWIG -->
+      <map code="0xb93e" name="1em"/><!-- HANGUL SYLLABLE RWIGG -->
+      <map code="0xb93f" name="1em"/><!-- HANGUL SYLLABLE RWIGS -->
+      <map code="0xb940" name="1em"/><!-- HANGUL SYLLABLE RWIN -->
+      <map code="0xb941" name="1em"/><!-- HANGUL SYLLABLE RWINJ -->
+      <map code="0xb942" name="1em"/><!-- HANGUL SYLLABLE RWINH -->
+      <map code="0xb943" name="1em"/><!-- HANGUL SYLLABLE RWID -->
+      <map code="0xb944" name="1em"/><!-- HANGUL SYLLABLE RWIL -->
+      <map code="0xb945" name="1em"/><!-- HANGUL SYLLABLE RWILG -->
+      <map code="0xb946" name="1em"/><!-- HANGUL SYLLABLE RWILM -->
+      <map code="0xb947" name="1em"/><!-- HANGUL SYLLABLE RWILB -->
+      <map code="0xb948" name="1em"/><!-- HANGUL SYLLABLE RWILS -->
+      <map code="0xb949" name="1em"/><!-- HANGUL SYLLABLE RWILT -->
+      <map code="0xb94a" name="1em"/><!-- HANGUL SYLLABLE RWILP -->
+      <map code="0xb94b" name="1em"/><!-- HANGUL SYLLABLE RWILH -->
+      <map code="0xb94c" name="1em"/><!-- HANGUL SYLLABLE RWIM -->
+      <map code="0xb94d" name="1em"/><!-- HANGUL SYLLABLE RWIB -->
+      <map code="0xb94e" name="1em"/><!-- HANGUL SYLLABLE RWIBS -->
+      <map code="0xb94f" name="1em"/><!-- HANGUL SYLLABLE RWIS -->
+      <map code="0xb950" name="1em"/><!-- HANGUL SYLLABLE RWISS -->
+      <map code="0xb951" name="1em"/><!-- HANGUL SYLLABLE RWING -->
+      <map code="0xb952" name="1em"/><!-- HANGUL SYLLABLE RWIJ -->
+      <map code="0xb953" name="1em"/><!-- HANGUL SYLLABLE RWIC -->
+      <map code="0xb954" name="1em"/><!-- HANGUL SYLLABLE RWIK -->
+      <map code="0xb955" name="1em"/><!-- HANGUL SYLLABLE RWIT -->
+      <map code="0xb956" name="1em"/><!-- HANGUL SYLLABLE RWIP -->
+      <map code="0xb957" name="1em"/><!-- HANGUL SYLLABLE RWIH -->
+      <map code="0xb958" name="1em"/><!-- HANGUL SYLLABLE RYU -->
+      <map code="0xb959" name="1em"/><!-- HANGUL SYLLABLE RYUG -->
+      <map code="0xb95a" name="1em"/><!-- HANGUL SYLLABLE RYUGG -->
+      <map code="0xb95b" name="1em"/><!-- HANGUL SYLLABLE RYUGS -->
+      <map code="0xb95c" name="1em"/><!-- HANGUL SYLLABLE RYUN -->
+      <map code="0xb95d" name="1em"/><!-- HANGUL SYLLABLE RYUNJ -->
+      <map code="0xb95e" name="1em"/><!-- HANGUL SYLLABLE RYUNH -->
+      <map code="0xb95f" name="1em"/><!-- HANGUL SYLLABLE RYUD -->
+      <map code="0xb960" name="1em"/><!-- HANGUL SYLLABLE RYUL -->
+      <map code="0xb961" name="1em"/><!-- HANGUL SYLLABLE RYULG -->
+      <map code="0xb962" name="1em"/><!-- HANGUL SYLLABLE RYULM -->
+      <map code="0xb963" name="1em"/><!-- HANGUL SYLLABLE RYULB -->
+      <map code="0xb964" name="1em"/><!-- HANGUL SYLLABLE RYULS -->
+      <map code="0xb965" name="1em"/><!-- HANGUL SYLLABLE RYULT -->
+      <map code="0xb966" name="1em"/><!-- HANGUL SYLLABLE RYULP -->
+      <map code="0xb967" name="1em"/><!-- HANGUL SYLLABLE RYULH -->
+      <map code="0xb968" name="1em"/><!-- HANGUL SYLLABLE RYUM -->
+      <map code="0xb969" name="1em"/><!-- HANGUL SYLLABLE RYUB -->
+      <map code="0xb96a" name="1em"/><!-- HANGUL SYLLABLE RYUBS -->
+      <map code="0xb96b" name="1em"/><!-- HANGUL SYLLABLE RYUS -->
+      <map code="0xb96c" name="1em"/><!-- HANGUL SYLLABLE RYUSS -->
+      <map code="0xb96d" name="1em"/><!-- HANGUL SYLLABLE RYUNG -->
+      <map code="0xb96e" name="1em"/><!-- HANGUL SYLLABLE RYUJ -->
+      <map code="0xb96f" name="1em"/><!-- HANGUL SYLLABLE RYUC -->
+      <map code="0xb970" name="1em"/><!-- HANGUL SYLLABLE RYUK -->
+      <map code="0xb971" name="1em"/><!-- HANGUL SYLLABLE RYUT -->
+      <map code="0xb972" name="1em"/><!-- HANGUL SYLLABLE RYUP -->
+      <map code="0xb973" name="1em"/><!-- HANGUL SYLLABLE RYUH -->
+      <map code="0xb974" name="1em"/><!-- HANGUL SYLLABLE REU -->
+      <map code="0xb975" name="1em"/><!-- HANGUL SYLLABLE REUG -->
+      <map code="0xb976" name="1em"/><!-- HANGUL SYLLABLE REUGG -->
+      <map code="0xb977" name="1em"/><!-- HANGUL SYLLABLE REUGS -->
+      <map code="0xb978" name="1em"/><!-- HANGUL SYLLABLE REUN -->
+      <map code="0xb979" name="1em"/><!-- HANGUL SYLLABLE REUNJ -->
+      <map code="0xb97a" name="1em"/><!-- HANGUL SYLLABLE REUNH -->
+      <map code="0xb97b" name="1em"/><!-- HANGUL SYLLABLE REUD -->
+      <map code="0xb97c" name="1em"/><!-- HANGUL SYLLABLE REUL -->
+      <map code="0xb97d" name="1em"/><!-- HANGUL SYLLABLE REULG -->
+      <map code="0xb97e" name="1em"/><!-- HANGUL SYLLABLE REULM -->
+      <map code="0xb97f" name="1em"/><!-- HANGUL SYLLABLE REULB -->
+      <map code="0xb980" name="1em"/><!-- HANGUL SYLLABLE REULS -->
+      <map code="0xb981" name="1em"/><!-- HANGUL SYLLABLE REULT -->
+      <map code="0xb982" name="1em"/><!-- HANGUL SYLLABLE REULP -->
+      <map code="0xb983" name="1em"/><!-- HANGUL SYLLABLE REULH -->
+      <map code="0xb984" name="1em"/><!-- HANGUL SYLLABLE REUM -->
+      <map code="0xb985" name="1em"/><!-- HANGUL SYLLABLE REUB -->
+      <map code="0xb986" name="1em"/><!-- HANGUL SYLLABLE REUBS -->
+      <map code="0xb987" name="1em"/><!-- HANGUL SYLLABLE REUS -->
+      <map code="0xb988" name="1em"/><!-- HANGUL SYLLABLE REUSS -->
+      <map code="0xb989" name="1em"/><!-- HANGUL SYLLABLE REUNG -->
+      <map code="0xb98a" name="1em"/><!-- HANGUL SYLLABLE REUJ -->
+      <map code="0xb98b" name="1em"/><!-- HANGUL SYLLABLE REUC -->
+      <map code="0xb98c" name="1em"/><!-- HANGUL SYLLABLE REUK -->
+      <map code="0xb98d" name="1em"/><!-- HANGUL SYLLABLE REUT -->
+      <map code="0xb98e" name="1em"/><!-- HANGUL SYLLABLE REUP -->
+      <map code="0xb98f" name="1em"/><!-- HANGUL SYLLABLE REUH -->
+      <map code="0xb990" name="1em"/><!-- HANGUL SYLLABLE RYI -->
+      <map code="0xb991" name="1em"/><!-- HANGUL SYLLABLE RYIG -->
+      <map code="0xb992" name="1em"/><!-- HANGUL SYLLABLE RYIGG -->
+      <map code="0xb993" name="1em"/><!-- HANGUL SYLLABLE RYIGS -->
+      <map code="0xb994" name="1em"/><!-- HANGUL SYLLABLE RYIN -->
+      <map code="0xb995" name="1em"/><!-- HANGUL SYLLABLE RYINJ -->
+      <map code="0xb996" name="1em"/><!-- HANGUL SYLLABLE RYINH -->
+      <map code="0xb997" name="1em"/><!-- HANGUL SYLLABLE RYID -->
+      <map code="0xb998" name="1em"/><!-- HANGUL SYLLABLE RYIL -->
+      <map code="0xb999" name="1em"/><!-- HANGUL SYLLABLE RYILG -->
+      <map code="0xb99a" name="1em"/><!-- HANGUL SYLLABLE RYILM -->
+      <map code="0xb99b" name="1em"/><!-- HANGUL SYLLABLE RYILB -->
+      <map code="0xb99c" name="1em"/><!-- HANGUL SYLLABLE RYILS -->
+      <map code="0xb99d" name="1em"/><!-- HANGUL SYLLABLE RYILT -->
+      <map code="0xb99e" name="1em"/><!-- HANGUL SYLLABLE RYILP -->
+      <map code="0xb99f" name="1em"/><!-- HANGUL SYLLABLE RYILH -->
+      <map code="0xb9a0" name="1em"/><!-- HANGUL SYLLABLE RYIM -->
+      <map code="0xb9a1" name="1em"/><!-- HANGUL SYLLABLE RYIB -->
+      <map code="0xb9a2" name="1em"/><!-- HANGUL SYLLABLE RYIBS -->
+      <map code="0xb9a3" name="1em"/><!-- HANGUL SYLLABLE RYIS -->
+      <map code="0xb9a4" name="1em"/><!-- HANGUL SYLLABLE RYISS -->
+      <map code="0xb9a5" name="1em"/><!-- HANGUL SYLLABLE RYING -->
+      <map code="0xb9a6" name="1em"/><!-- HANGUL SYLLABLE RYIJ -->
+      <map code="0xb9a7" name="1em"/><!-- HANGUL SYLLABLE RYIC -->
+      <map code="0xb9a8" name="1em"/><!-- HANGUL SYLLABLE RYIK -->
+      <map code="0xb9a9" name="1em"/><!-- HANGUL SYLLABLE RYIT -->
+      <map code="0xb9aa" name="1em"/><!-- HANGUL SYLLABLE RYIP -->
+      <map code="0xb9ab" name="1em"/><!-- HANGUL SYLLABLE RYIH -->
+      <map code="0xb9ac" name="1em"/><!-- HANGUL SYLLABLE RI -->
+      <map code="0xb9ad" name="1em"/><!-- HANGUL SYLLABLE RIG -->
+      <map code="0xb9ae" name="1em"/><!-- HANGUL SYLLABLE RIGG -->
+      <map code="0xb9af" name="1em"/><!-- HANGUL SYLLABLE RIGS -->
+      <map code="0xb9b0" name="1em"/><!-- HANGUL SYLLABLE RIN -->
+      <map code="0xb9b1" name="1em"/><!-- HANGUL SYLLABLE RINJ -->
+      <map code="0xb9b2" name="1em"/><!-- HANGUL SYLLABLE RINH -->
+      <map code="0xb9b3" name="1em"/><!-- HANGUL SYLLABLE RID -->
+      <map code="0xb9b4" name="1em"/><!-- HANGUL SYLLABLE RIL -->
+      <map code="0xb9b5" name="1em"/><!-- HANGUL SYLLABLE RILG -->
+      <map code="0xb9b6" name="1em"/><!-- HANGUL SYLLABLE RILM -->
+      <map code="0xb9b7" name="1em"/><!-- HANGUL SYLLABLE RILB -->
+      <map code="0xb9b8" name="1em"/><!-- HANGUL SYLLABLE RILS -->
+      <map code="0xb9b9" name="1em"/><!-- HANGUL SYLLABLE RILT -->
+      <map code="0xb9ba" name="1em"/><!-- HANGUL SYLLABLE RILP -->
+      <map code="0xb9bb" name="1em"/><!-- HANGUL SYLLABLE RILH -->
+      <map code="0xb9bc" name="1em"/><!-- HANGUL SYLLABLE RIM -->
+      <map code="0xb9bd" name="1em"/><!-- HANGUL SYLLABLE RIB -->
+      <map code="0xb9be" name="1em"/><!-- HANGUL SYLLABLE RIBS -->
+      <map code="0xb9bf" name="1em"/><!-- HANGUL SYLLABLE RIS -->
+      <map code="0xb9c0" name="1em"/><!-- HANGUL SYLLABLE RISS -->
+      <map code="0xb9c1" name="1em"/><!-- HANGUL SYLLABLE RING -->
+      <map code="0xb9c2" name="1em"/><!-- HANGUL SYLLABLE RIJ -->
+      <map code="0xb9c3" name="1em"/><!-- HANGUL SYLLABLE RIC -->
+      <map code="0xb9c4" name="1em"/><!-- HANGUL SYLLABLE RIK -->
+      <map code="0xb9c5" name="1em"/><!-- HANGUL SYLLABLE RIT -->
+      <map code="0xb9c6" name="1em"/><!-- HANGUL SYLLABLE RIP -->
+      <map code="0xb9c7" name="1em"/><!-- HANGUL SYLLABLE RIH -->
+      <map code="0xb9c8" name="1em"/><!-- HANGUL SYLLABLE MA -->
+      <map code="0xb9c9" name="1em"/><!-- HANGUL SYLLABLE MAG -->
+      <map code="0xb9ca" name="1em"/><!-- HANGUL SYLLABLE MAGG -->
+      <map code="0xb9cb" name="1em"/><!-- HANGUL SYLLABLE MAGS -->
+      <map code="0xb9cc" name="1em"/><!-- HANGUL SYLLABLE MAN -->
+      <map code="0xb9cd" name="1em"/><!-- HANGUL SYLLABLE MANJ -->
+      <map code="0xb9ce" name="1em"/><!-- HANGUL SYLLABLE MANH -->
+      <map code="0xb9cf" name="1em"/><!-- HANGUL SYLLABLE MAD -->
+      <map code="0xb9d0" name="1em"/><!-- HANGUL SYLLABLE MAL -->
+      <map code="0xb9d1" name="1em"/><!-- HANGUL SYLLABLE MALG -->
+      <map code="0xb9d2" name="1em"/><!-- HANGUL SYLLABLE MALM -->
+      <map code="0xb9d3" name="1em"/><!-- HANGUL SYLLABLE MALB -->
+      <map code="0xb9d4" name="1em"/><!-- HANGUL SYLLABLE MALS -->
+      <map code="0xb9d5" name="1em"/><!-- HANGUL SYLLABLE MALT -->
+      <map code="0xb9d6" name="1em"/><!-- HANGUL SYLLABLE MALP -->
+      <map code="0xb9d7" name="1em"/><!-- HANGUL SYLLABLE MALH -->
+      <map code="0xb9d8" name="1em"/><!-- HANGUL SYLLABLE MAM -->
+      <map code="0xb9d9" name="1em"/><!-- HANGUL SYLLABLE MAB -->
+      <map code="0xb9da" name="1em"/><!-- HANGUL SYLLABLE MABS -->
+      <map code="0xb9db" name="1em"/><!-- HANGUL SYLLABLE MAS -->
+      <map code="0xb9dc" name="1em"/><!-- HANGUL SYLLABLE MASS -->
+      <map code="0xb9dd" name="1em"/><!-- HANGUL SYLLABLE MANG -->
+      <map code="0xb9de" name="1em"/><!-- HANGUL SYLLABLE MAJ -->
+      <map code="0xb9df" name="1em"/><!-- HANGUL SYLLABLE MAC -->
+      <map code="0xb9e0" name="1em"/><!-- HANGUL SYLLABLE MAK -->
+      <map code="0xb9e1" name="1em"/><!-- HANGUL SYLLABLE MAT -->
+      <map code="0xb9e2" name="1em"/><!-- HANGUL SYLLABLE MAP -->
+      <map code="0xb9e3" name="1em"/><!-- HANGUL SYLLABLE MAH -->
+      <map code="0xb9e4" name="1em"/><!-- HANGUL SYLLABLE MAE -->
+      <map code="0xb9e5" name="1em"/><!-- HANGUL SYLLABLE MAEG -->
+      <map code="0xb9e6" name="1em"/><!-- HANGUL SYLLABLE MAEGG -->
+      <map code="0xb9e7" name="1em"/><!-- HANGUL SYLLABLE MAEGS -->
+      <map code="0xb9e8" name="1em"/><!-- HANGUL SYLLABLE MAEN -->
+      <map code="0xb9e9" name="1em"/><!-- HANGUL SYLLABLE MAENJ -->
+      <map code="0xb9ea" name="1em"/><!-- HANGUL SYLLABLE MAENH -->
+      <map code="0xb9eb" name="1em"/><!-- HANGUL SYLLABLE MAED -->
+      <map code="0xb9ec" name="1em"/><!-- HANGUL SYLLABLE MAEL -->
+      <map code="0xb9ed" name="1em"/><!-- HANGUL SYLLABLE MAELG -->
+      <map code="0xb9ee" name="1em"/><!-- HANGUL SYLLABLE MAELM -->
+      <map code="0xb9ef" name="1em"/><!-- HANGUL SYLLABLE MAELB -->
+      <map code="0xb9f0" name="1em"/><!-- HANGUL SYLLABLE MAELS -->
+      <map code="0xb9f1" name="1em"/><!-- HANGUL SYLLABLE MAELT -->
+      <map code="0xb9f2" name="1em"/><!-- HANGUL SYLLABLE MAELP -->
+      <map code="0xb9f3" name="1em"/><!-- HANGUL SYLLABLE MAELH -->
+      <map code="0xb9f4" name="1em"/><!-- HANGUL SYLLABLE MAEM -->
+      <map code="0xb9f5" name="1em"/><!-- HANGUL SYLLABLE MAEB -->
+      <map code="0xb9f6" name="1em"/><!-- HANGUL SYLLABLE MAEBS -->
+      <map code="0xb9f7" name="1em"/><!-- HANGUL SYLLABLE MAES -->
+      <map code="0xb9f8" name="1em"/><!-- HANGUL SYLLABLE MAESS -->
+      <map code="0xb9f9" name="1em"/><!-- HANGUL SYLLABLE MAENG -->
+      <map code="0xb9fa" name="1em"/><!-- HANGUL SYLLABLE MAEJ -->
+      <map code="0xb9fb" name="1em"/><!-- HANGUL SYLLABLE MAEC -->
+      <map code="0xb9fc" name="1em"/><!-- HANGUL SYLLABLE MAEK -->
+      <map code="0xb9fd" name="1em"/><!-- HANGUL SYLLABLE MAET -->
+      <map code="0xb9fe" name="1em"/><!-- HANGUL SYLLABLE MAEP -->
+      <map code="0xb9ff" name="1em"/><!-- HANGUL SYLLABLE MAEH -->
+      <map code="0xba00" name="1em"/><!-- HANGUL SYLLABLE MYA -->
+      <map code="0xba01" name="1em"/><!-- HANGUL SYLLABLE MYAG -->
+      <map code="0xba02" name="1em"/><!-- HANGUL SYLLABLE MYAGG -->
+      <map code="0xba03" name="1em"/><!-- HANGUL SYLLABLE MYAGS -->
+      <map code="0xba04" name="1em"/><!-- HANGUL SYLLABLE MYAN -->
+      <map code="0xba05" name="1em"/><!-- HANGUL SYLLABLE MYANJ -->
+      <map code="0xba06" name="1em"/><!-- HANGUL SYLLABLE MYANH -->
+      <map code="0xba07" name="1em"/><!-- HANGUL SYLLABLE MYAD -->
+      <map code="0xba08" name="1em"/><!-- HANGUL SYLLABLE MYAL -->
+      <map code="0xba09" name="1em"/><!-- HANGUL SYLLABLE MYALG -->
+      <map code="0xba0a" name="1em"/><!-- HANGUL SYLLABLE MYALM -->
+      <map code="0xba0b" name="1em"/><!-- HANGUL SYLLABLE MYALB -->
+      <map code="0xba0c" name="1em"/><!-- HANGUL SYLLABLE MYALS -->
+      <map code="0xba0d" name="1em"/><!-- HANGUL SYLLABLE MYALT -->
+      <map code="0xba0e" name="1em"/><!-- HANGUL SYLLABLE MYALP -->
+      <map code="0xba0f" name="1em"/><!-- HANGUL SYLLABLE MYALH -->
+      <map code="0xba10" name="1em"/><!-- HANGUL SYLLABLE MYAM -->
+      <map code="0xba11" name="1em"/><!-- HANGUL SYLLABLE MYAB -->
+      <map code="0xba12" name="1em"/><!-- HANGUL SYLLABLE MYABS -->
+      <map code="0xba13" name="1em"/><!-- HANGUL SYLLABLE MYAS -->
+      <map code="0xba14" name="1em"/><!-- HANGUL SYLLABLE MYASS -->
+      <map code="0xba15" name="1em"/><!-- HANGUL SYLLABLE MYANG -->
+      <map code="0xba16" name="1em"/><!-- HANGUL SYLLABLE MYAJ -->
+      <map code="0xba17" name="1em"/><!-- HANGUL SYLLABLE MYAC -->
+      <map code="0xba18" name="1em"/><!-- HANGUL SYLLABLE MYAK -->
+      <map code="0xba19" name="1em"/><!-- HANGUL SYLLABLE MYAT -->
+      <map code="0xba1a" name="1em"/><!-- HANGUL SYLLABLE MYAP -->
+      <map code="0xba1b" name="1em"/><!-- HANGUL SYLLABLE MYAH -->
+      <map code="0xba1c" name="1em"/><!-- HANGUL SYLLABLE MYAE -->
+      <map code="0xba1d" name="1em"/><!-- HANGUL SYLLABLE MYAEG -->
+      <map code="0xba1e" name="1em"/><!-- HANGUL SYLLABLE MYAEGG -->
+      <map code="0xba1f" name="1em"/><!-- HANGUL SYLLABLE MYAEGS -->
+      <map code="0xba20" name="1em"/><!-- HANGUL SYLLABLE MYAEN -->
+      <map code="0xba21" name="1em"/><!-- HANGUL SYLLABLE MYAENJ -->
+      <map code="0xba22" name="1em"/><!-- HANGUL SYLLABLE MYAENH -->
+      <map code="0xba23" name="1em"/><!-- HANGUL SYLLABLE MYAED -->
+      <map code="0xba24" name="1em"/><!-- HANGUL SYLLABLE MYAEL -->
+      <map code="0xba25" name="1em"/><!-- HANGUL SYLLABLE MYAELG -->
+      <map code="0xba26" name="1em"/><!-- HANGUL SYLLABLE MYAELM -->
+      <map code="0xba27" name="1em"/><!-- HANGUL SYLLABLE MYAELB -->
+      <map code="0xba28" name="1em"/><!-- HANGUL SYLLABLE MYAELS -->
+      <map code="0xba29" name="1em"/><!-- HANGUL SYLLABLE MYAELT -->
+      <map code="0xba2a" name="1em"/><!-- HANGUL SYLLABLE MYAELP -->
+      <map code="0xba2b" name="1em"/><!-- HANGUL SYLLABLE MYAELH -->
+      <map code="0xba2c" name="1em"/><!-- HANGUL SYLLABLE MYAEM -->
+      <map code="0xba2d" name="1em"/><!-- HANGUL SYLLABLE MYAEB -->
+      <map code="0xba2e" name="1em"/><!-- HANGUL SYLLABLE MYAEBS -->
+      <map code="0xba2f" name="1em"/><!-- HANGUL SYLLABLE MYAES -->
+      <map code="0xba30" name="1em"/><!-- HANGUL SYLLABLE MYAESS -->
+      <map code="0xba31" name="1em"/><!-- HANGUL SYLLABLE MYAENG -->
+      <map code="0xba32" name="1em"/><!-- HANGUL SYLLABLE MYAEJ -->
+      <map code="0xba33" name="1em"/><!-- HANGUL SYLLABLE MYAEC -->
+      <map code="0xba34" name="1em"/><!-- HANGUL SYLLABLE MYAEK -->
+      <map code="0xba35" name="1em"/><!-- HANGUL SYLLABLE MYAET -->
+      <map code="0xba36" name="1em"/><!-- HANGUL SYLLABLE MYAEP -->
+      <map code="0xba37" name="1em"/><!-- HANGUL SYLLABLE MYAEH -->
+      <map code="0xba38" name="1em"/><!-- HANGUL SYLLABLE MEO -->
+      <map code="0xba39" name="1em"/><!-- HANGUL SYLLABLE MEOG -->
+      <map code="0xba3a" name="1em"/><!-- HANGUL SYLLABLE MEOGG -->
+      <map code="0xba3b" name="1em"/><!-- HANGUL SYLLABLE MEOGS -->
+      <map code="0xba3c" name="1em"/><!-- HANGUL SYLLABLE MEON -->
+      <map code="0xba3d" name="1em"/><!-- HANGUL SYLLABLE MEONJ -->
+      <map code="0xba3e" name="1em"/><!-- HANGUL SYLLABLE MEONH -->
+      <map code="0xba3f" name="1em"/><!-- HANGUL SYLLABLE MEOD -->
+      <map code="0xba40" name="1em"/><!-- HANGUL SYLLABLE MEOL -->
+      <map code="0xba41" name="1em"/><!-- HANGUL SYLLABLE MEOLG -->
+      <map code="0xba42" name="1em"/><!-- HANGUL SYLLABLE MEOLM -->
+      <map code="0xba43" name="1em"/><!-- HANGUL SYLLABLE MEOLB -->
+      <map code="0xba44" name="1em"/><!-- HANGUL SYLLABLE MEOLS -->
+      <map code="0xba45" name="1em"/><!-- HANGUL SYLLABLE MEOLT -->
+      <map code="0xba46" name="1em"/><!-- HANGUL SYLLABLE MEOLP -->
+      <map code="0xba47" name="1em"/><!-- HANGUL SYLLABLE MEOLH -->
+      <map code="0xba48" name="1em"/><!-- HANGUL SYLLABLE MEOM -->
+      <map code="0xba49" name="1em"/><!-- HANGUL SYLLABLE MEOB -->
+      <map code="0xba4a" name="1em"/><!-- HANGUL SYLLABLE MEOBS -->
+      <map code="0xba4b" name="1em"/><!-- HANGUL SYLLABLE MEOS -->
+      <map code="0xba4c" name="1em"/><!-- HANGUL SYLLABLE MEOSS -->
+      <map code="0xba4d" name="1em"/><!-- HANGUL SYLLABLE MEONG -->
+      <map code="0xba4e" name="1em"/><!-- HANGUL SYLLABLE MEOJ -->
+      <map code="0xba4f" name="1em"/><!-- HANGUL SYLLABLE MEOC -->
+      <map code="0xba50" name="1em"/><!-- HANGUL SYLLABLE MEOK -->
+      <map code="0xba51" name="1em"/><!-- HANGUL SYLLABLE MEOT -->
+      <map code="0xba52" name="1em"/><!-- HANGUL SYLLABLE MEOP -->
+      <map code="0xba53" name="1em"/><!-- HANGUL SYLLABLE MEOH -->
+      <map code="0xba54" name="1em"/><!-- HANGUL SYLLABLE ME -->
+      <map code="0xba55" name="1em"/><!-- HANGUL SYLLABLE MEG -->
+      <map code="0xba56" name="1em"/><!-- HANGUL SYLLABLE MEGG -->
+      <map code="0xba57" name="1em"/><!-- HANGUL SYLLABLE MEGS -->
+      <map code="0xba58" name="1em"/><!-- HANGUL SYLLABLE MEN -->
+      <map code="0xba59" name="1em"/><!-- HANGUL SYLLABLE MENJ -->
+      <map code="0xba5a" name="1em"/><!-- HANGUL SYLLABLE MENH -->
+      <map code="0xba5b" name="1em"/><!-- HANGUL SYLLABLE MED -->
+      <map code="0xba5c" name="1em"/><!-- HANGUL SYLLABLE MEL -->
+      <map code="0xba5d" name="1em"/><!-- HANGUL SYLLABLE MELG -->
+      <map code="0xba5e" name="1em"/><!-- HANGUL SYLLABLE MELM -->
+      <map code="0xba5f" name="1em"/><!-- HANGUL SYLLABLE MELB -->
+      <map code="0xba60" name="1em"/><!-- HANGUL SYLLABLE MELS -->
+      <map code="0xba61" name="1em"/><!-- HANGUL SYLLABLE MELT -->
+      <map code="0xba62" name="1em"/><!-- HANGUL SYLLABLE MELP -->
+      <map code="0xba63" name="1em"/><!-- HANGUL SYLLABLE MELH -->
+      <map code="0xba64" name="1em"/><!-- HANGUL SYLLABLE MEM -->
+      <map code="0xba65" name="1em"/><!-- HANGUL SYLLABLE MEB -->
+      <map code="0xba66" name="1em"/><!-- HANGUL SYLLABLE MEBS -->
+      <map code="0xba67" name="1em"/><!-- HANGUL SYLLABLE MES -->
+      <map code="0xba68" name="1em"/><!-- HANGUL SYLLABLE MESS -->
+      <map code="0xba69" name="1em"/><!-- HANGUL SYLLABLE MENG -->
+      <map code="0xba6a" name="1em"/><!-- HANGUL SYLLABLE MEJ -->
+      <map code="0xba6b" name="1em"/><!-- HANGUL SYLLABLE MEC -->
+      <map code="0xba6c" name="1em"/><!-- HANGUL SYLLABLE MEK -->
+      <map code="0xba6d" name="1em"/><!-- HANGUL SYLLABLE MET -->
+      <map code="0xba6e" name="1em"/><!-- HANGUL SYLLABLE MEP -->
+      <map code="0xba6f" name="1em"/><!-- HANGUL SYLLABLE MEH -->
+      <map code="0xba70" name="1em"/><!-- HANGUL SYLLABLE MYEO -->
+      <map code="0xba71" name="1em"/><!-- HANGUL SYLLABLE MYEOG -->
+      <map code="0xba72" name="1em"/><!-- HANGUL SYLLABLE MYEOGG -->
+      <map code="0xba73" name="1em"/><!-- HANGUL SYLLABLE MYEOGS -->
+      <map code="0xba74" name="1em"/><!-- HANGUL SYLLABLE MYEON -->
+      <map code="0xba75" name="1em"/><!-- HANGUL SYLLABLE MYEONJ -->
+      <map code="0xba76" name="1em"/><!-- HANGUL SYLLABLE MYEONH -->
+      <map code="0xba77" name="1em"/><!-- HANGUL SYLLABLE MYEOD -->
+      <map code="0xba78" name="1em"/><!-- HANGUL SYLLABLE MYEOL -->
+      <map code="0xba79" name="1em"/><!-- HANGUL SYLLABLE MYEOLG -->
+      <map code="0xba7a" name="1em"/><!-- HANGUL SYLLABLE MYEOLM -->
+      <map code="0xba7b" name="1em"/><!-- HANGUL SYLLABLE MYEOLB -->
+      <map code="0xba7c" name="1em"/><!-- HANGUL SYLLABLE MYEOLS -->
+      <map code="0xba7d" name="1em"/><!-- HANGUL SYLLABLE MYEOLT -->
+      <map code="0xba7e" name="1em"/><!-- HANGUL SYLLABLE MYEOLP -->
+      <map code="0xba7f" name="1em"/><!-- HANGUL SYLLABLE MYEOLH -->
+      <map code="0xba80" name="1em"/><!-- HANGUL SYLLABLE MYEOM -->
+      <map code="0xba81" name="1em"/><!-- HANGUL SYLLABLE MYEOB -->
+      <map code="0xba82" name="1em"/><!-- HANGUL SYLLABLE MYEOBS -->
+      <map code="0xba83" name="1em"/><!-- HANGUL SYLLABLE MYEOS -->
+      <map code="0xba84" name="1em"/><!-- HANGUL SYLLABLE MYEOSS -->
+      <map code="0xba85" name="1em"/><!-- HANGUL SYLLABLE MYEONG -->
+      <map code="0xba86" name="1em"/><!-- HANGUL SYLLABLE MYEOJ -->
+      <map code="0xba87" name="1em"/><!-- HANGUL SYLLABLE MYEOC -->
+      <map code="0xba88" name="1em"/><!-- HANGUL SYLLABLE MYEOK -->
+      <map code="0xba89" name="1em"/><!-- HANGUL SYLLABLE MYEOT -->
+      <map code="0xba8a" name="1em"/><!-- HANGUL SYLLABLE MYEOP -->
+      <map code="0xba8b" name="1em"/><!-- HANGUL SYLLABLE MYEOH -->
+      <map code="0xba8c" name="1em"/><!-- HANGUL SYLLABLE MYE -->
+      <map code="0xba8d" name="1em"/><!-- HANGUL SYLLABLE MYEG -->
+      <map code="0xba8e" name="1em"/><!-- HANGUL SYLLABLE MYEGG -->
+      <map code="0xba8f" name="1em"/><!-- HANGUL SYLLABLE MYEGS -->
+      <map code="0xba90" name="1em"/><!-- HANGUL SYLLABLE MYEN -->
+      <map code="0xba91" name="1em"/><!-- HANGUL SYLLABLE MYENJ -->
+      <map code="0xba92" name="1em"/><!-- HANGUL SYLLABLE MYENH -->
+      <map code="0xba93" name="1em"/><!-- HANGUL SYLLABLE MYED -->
+      <map code="0xba94" name="1em"/><!-- HANGUL SYLLABLE MYEL -->
+      <map code="0xba95" name="1em"/><!-- HANGUL SYLLABLE MYELG -->
+      <map code="0xba96" name="1em"/><!-- HANGUL SYLLABLE MYELM -->
+      <map code="0xba97" name="1em"/><!-- HANGUL SYLLABLE MYELB -->
+      <map code="0xba98" name="1em"/><!-- HANGUL SYLLABLE MYELS -->
+      <map code="0xba99" name="1em"/><!-- HANGUL SYLLABLE MYELT -->
+      <map code="0xba9a" name="1em"/><!-- HANGUL SYLLABLE MYELP -->
+      <map code="0xba9b" name="1em"/><!-- HANGUL SYLLABLE MYELH -->
+      <map code="0xba9c" name="1em"/><!-- HANGUL SYLLABLE MYEM -->
+      <map code="0xba9d" name="1em"/><!-- HANGUL SYLLABLE MYEB -->
+      <map code="0xba9e" name="1em"/><!-- HANGUL SYLLABLE MYEBS -->
+      <map code="0xba9f" name="1em"/><!-- HANGUL SYLLABLE MYES -->
+      <map code="0xbaa0" name="1em"/><!-- HANGUL SYLLABLE MYESS -->
+      <map code="0xbaa1" name="1em"/><!-- HANGUL SYLLABLE MYENG -->
+      <map code="0xbaa2" name="1em"/><!-- HANGUL SYLLABLE MYEJ -->
+      <map code="0xbaa3" name="1em"/><!-- HANGUL SYLLABLE MYEC -->
+      <map code="0xbaa4" name="1em"/><!-- HANGUL SYLLABLE MYEK -->
+      <map code="0xbaa5" name="1em"/><!-- HANGUL SYLLABLE MYET -->
+      <map code="0xbaa6" name="1em"/><!-- HANGUL SYLLABLE MYEP -->
+      <map code="0xbaa7" name="1em"/><!-- HANGUL SYLLABLE MYEH -->
+      <map code="0xbaa8" name="1em"/><!-- HANGUL SYLLABLE MO -->
+      <map code="0xbaa9" name="1em"/><!-- HANGUL SYLLABLE MOG -->
+      <map code="0xbaaa" name="1em"/><!-- HANGUL SYLLABLE MOGG -->
+      <map code="0xbaab" name="1em"/><!-- HANGUL SYLLABLE MOGS -->
+      <map code="0xbaac" name="1em"/><!-- HANGUL SYLLABLE MON -->
+      <map code="0xbaad" name="1em"/><!-- HANGUL SYLLABLE MONJ -->
+      <map code="0xbaae" name="1em"/><!-- HANGUL SYLLABLE MONH -->
+      <map code="0xbaaf" name="1em"/><!-- HANGUL SYLLABLE MOD -->
+      <map code="0xbab0" name="1em"/><!-- HANGUL SYLLABLE MOL -->
+      <map code="0xbab1" name="1em"/><!-- HANGUL SYLLABLE MOLG -->
+      <map code="0xbab2" name="1em"/><!-- HANGUL SYLLABLE MOLM -->
+      <map code="0xbab3" name="1em"/><!-- HANGUL SYLLABLE MOLB -->
+      <map code="0xbab4" name="1em"/><!-- HANGUL SYLLABLE MOLS -->
+      <map code="0xbab5" name="1em"/><!-- HANGUL SYLLABLE MOLT -->
+      <map code="0xbab6" name="1em"/><!-- HANGUL SYLLABLE MOLP -->
+      <map code="0xbab7" name="1em"/><!-- HANGUL SYLLABLE MOLH -->
+      <map code="0xbab8" name="1em"/><!-- HANGUL SYLLABLE MOM -->
+      <map code="0xbab9" name="1em"/><!-- HANGUL SYLLABLE MOB -->
+      <map code="0xbaba" name="1em"/><!-- HANGUL SYLLABLE MOBS -->
+      <map code="0xbabb" name="1em"/><!-- HANGUL SYLLABLE MOS -->
+      <map code="0xbabc" name="1em"/><!-- HANGUL SYLLABLE MOSS -->
+      <map code="0xbabd" name="1em"/><!-- HANGUL SYLLABLE MONG -->
+      <map code="0xbabe" name="1em"/><!-- HANGUL SYLLABLE MOJ -->
+      <map code="0xbabf" name="1em"/><!-- HANGUL SYLLABLE MOC -->
+      <map code="0xbac0" name="1em"/><!-- HANGUL SYLLABLE MOK -->
+      <map code="0xbac1" name="1em"/><!-- HANGUL SYLLABLE MOT -->
+      <map code="0xbac2" name="1em"/><!-- HANGUL SYLLABLE MOP -->
+      <map code="0xbac3" name="1em"/><!-- HANGUL SYLLABLE MOH -->
+      <map code="0xbac4" name="1em"/><!-- HANGUL SYLLABLE MWA -->
+      <map code="0xbac5" name="1em"/><!-- HANGUL SYLLABLE MWAG -->
+      <map code="0xbac6" name="1em"/><!-- HANGUL SYLLABLE MWAGG -->
+      <map code="0xbac7" name="1em"/><!-- HANGUL SYLLABLE MWAGS -->
+      <map code="0xbac8" name="1em"/><!-- HANGUL SYLLABLE MWAN -->
+      <map code="0xbac9" name="1em"/><!-- HANGUL SYLLABLE MWANJ -->
+      <map code="0xbaca" name="1em"/><!-- HANGUL SYLLABLE MWANH -->
+      <map code="0xbacb" name="1em"/><!-- HANGUL SYLLABLE MWAD -->
+      <map code="0xbacc" name="1em"/><!-- HANGUL SYLLABLE MWAL -->
+      <map code="0xbacd" name="1em"/><!-- HANGUL SYLLABLE MWALG -->
+      <map code="0xbace" name="1em"/><!-- HANGUL SYLLABLE MWALM -->
+      <map code="0xbacf" name="1em"/><!-- HANGUL SYLLABLE MWALB -->
+      <map code="0xbad0" name="1em"/><!-- HANGUL SYLLABLE MWALS -->
+      <map code="0xbad1" name="1em"/><!-- HANGUL SYLLABLE MWALT -->
+      <map code="0xbad2" name="1em"/><!-- HANGUL SYLLABLE MWALP -->
+      <map code="0xbad3" name="1em"/><!-- HANGUL SYLLABLE MWALH -->
+      <map code="0xbad4" name="1em"/><!-- HANGUL SYLLABLE MWAM -->
+      <map code="0xbad5" name="1em"/><!-- HANGUL SYLLABLE MWAB -->
+      <map code="0xbad6" name="1em"/><!-- HANGUL SYLLABLE MWABS -->
+      <map code="0xbad7" name="1em"/><!-- HANGUL SYLLABLE MWAS -->
+      <map code="0xbad8" name="1em"/><!-- HANGUL SYLLABLE MWASS -->
+      <map code="0xbad9" name="1em"/><!-- HANGUL SYLLABLE MWANG -->
+      <map code="0xbada" name="1em"/><!-- HANGUL SYLLABLE MWAJ -->
+      <map code="0xbadb" name="1em"/><!-- HANGUL SYLLABLE MWAC -->
+      <map code="0xbadc" name="1em"/><!-- HANGUL SYLLABLE MWAK -->
+      <map code="0xbadd" name="1em"/><!-- HANGUL SYLLABLE MWAT -->
+      <map code="0xbade" name="1em"/><!-- HANGUL SYLLABLE MWAP -->
+      <map code="0xbadf" name="1em"/><!-- HANGUL SYLLABLE MWAH -->
+      <map code="0xbae0" name="1em"/><!-- HANGUL SYLLABLE MWAE -->
+      <map code="0xbae1" name="1em"/><!-- HANGUL SYLLABLE MWAEG -->
+      <map code="0xbae2" name="1em"/><!-- HANGUL SYLLABLE MWAEGG -->
+      <map code="0xbae3" name="1em"/><!-- HANGUL SYLLABLE MWAEGS -->
+      <map code="0xbae4" name="1em"/><!-- HANGUL SYLLABLE MWAEN -->
+      <map code="0xbae5" name="1em"/><!-- HANGUL SYLLABLE MWAENJ -->
+      <map code="0xbae6" name="1em"/><!-- HANGUL SYLLABLE MWAENH -->
+      <map code="0xbae7" name="1em"/><!-- HANGUL SYLLABLE MWAED -->
+      <map code="0xbae8" name="1em"/><!-- HANGUL SYLLABLE MWAEL -->
+      <map code="0xbae9" name="1em"/><!-- HANGUL SYLLABLE MWAELG -->
+      <map code="0xbaea" name="1em"/><!-- HANGUL SYLLABLE MWAELM -->
+      <map code="0xbaeb" name="1em"/><!-- HANGUL SYLLABLE MWAELB -->
+      <map code="0xbaec" name="1em"/><!-- HANGUL SYLLABLE MWAELS -->
+      <map code="0xbaed" name="1em"/><!-- HANGUL SYLLABLE MWAELT -->
+      <map code="0xbaee" name="1em"/><!-- HANGUL SYLLABLE MWAELP -->
+      <map code="0xbaef" name="1em"/><!-- HANGUL SYLLABLE MWAELH -->
+      <map code="0xbaf0" name="1em"/><!-- HANGUL SYLLABLE MWAEM -->
+      <map code="0xbaf1" name="1em"/><!-- HANGUL SYLLABLE MWAEB -->
+      <map code="0xbaf2" name="1em"/><!-- HANGUL SYLLABLE MWAEBS -->
+      <map code="0xbaf3" name="1em"/><!-- HANGUL SYLLABLE MWAES -->
+      <map code="0xbaf4" name="1em"/><!-- HANGUL SYLLABLE MWAESS -->
+      <map code="0xbaf5" name="1em"/><!-- HANGUL SYLLABLE MWAENG -->
+      <map code="0xbaf6" name="1em"/><!-- HANGUL SYLLABLE MWAEJ -->
+      <map code="0xbaf7" name="1em"/><!-- HANGUL SYLLABLE MWAEC -->
+      <map code="0xbaf8" name="1em"/><!-- HANGUL SYLLABLE MWAEK -->
+      <map code="0xbaf9" name="1em"/><!-- HANGUL SYLLABLE MWAET -->
+      <map code="0xbafa" name="1em"/><!-- HANGUL SYLLABLE MWAEP -->
+      <map code="0xbafb" name="1em"/><!-- HANGUL SYLLABLE MWAEH -->
+      <map code="0xbafc" name="1em"/><!-- HANGUL SYLLABLE MOE -->
+      <map code="0xbafd" name="1em"/><!-- HANGUL SYLLABLE MOEG -->
+      <map code="0xbafe" name="1em"/><!-- HANGUL SYLLABLE MOEGG -->
+      <map code="0xbaff" name="1em"/><!-- HANGUL SYLLABLE MOEGS -->
+      <map code="0xbb00" name="1em"/><!-- HANGUL SYLLABLE MOEN -->
+      <map code="0xbb01" name="1em"/><!-- HANGUL SYLLABLE MOENJ -->
+      <map code="0xbb02" name="1em"/><!-- HANGUL SYLLABLE MOENH -->
+      <map code="0xbb03" name="1em"/><!-- HANGUL SYLLABLE MOED -->
+      <map code="0xbb04" name="1em"/><!-- HANGUL SYLLABLE MOEL -->
+      <map code="0xbb05" name="1em"/><!-- HANGUL SYLLABLE MOELG -->
+      <map code="0xbb06" name="1em"/><!-- HANGUL SYLLABLE MOELM -->
+      <map code="0xbb07" name="1em"/><!-- HANGUL SYLLABLE MOELB -->
+      <map code="0xbb08" name="1em"/><!-- HANGUL SYLLABLE MOELS -->
+      <map code="0xbb09" name="1em"/><!-- HANGUL SYLLABLE MOELT -->
+      <map code="0xbb0a" name="1em"/><!-- HANGUL SYLLABLE MOELP -->
+      <map code="0xbb0b" name="1em"/><!-- HANGUL SYLLABLE MOELH -->
+      <map code="0xbb0c" name="1em"/><!-- HANGUL SYLLABLE MOEM -->
+      <map code="0xbb0d" name="1em"/><!-- HANGUL SYLLABLE MOEB -->
+      <map code="0xbb0e" name="1em"/><!-- HANGUL SYLLABLE MOEBS -->
+      <map code="0xbb0f" name="1em"/><!-- HANGUL SYLLABLE MOES -->
+      <map code="0xbb10" name="1em"/><!-- HANGUL SYLLABLE MOESS -->
+      <map code="0xbb11" name="1em"/><!-- HANGUL SYLLABLE MOENG -->
+      <map code="0xbb12" name="1em"/><!-- HANGUL SYLLABLE MOEJ -->
+      <map code="0xbb13" name="1em"/><!-- HANGUL SYLLABLE MOEC -->
+      <map code="0xbb14" name="1em"/><!-- HANGUL SYLLABLE MOEK -->
+      <map code="0xbb15" name="1em"/><!-- HANGUL SYLLABLE MOET -->
+      <map code="0xbb16" name="1em"/><!-- HANGUL SYLLABLE MOEP -->
+      <map code="0xbb17" name="1em"/><!-- HANGUL SYLLABLE MOEH -->
+      <map code="0xbb18" name="1em"/><!-- HANGUL SYLLABLE MYO -->
+      <map code="0xbb19" name="1em"/><!-- HANGUL SYLLABLE MYOG -->
+      <map code="0xbb1a" name="1em"/><!-- HANGUL SYLLABLE MYOGG -->
+      <map code="0xbb1b" name="1em"/><!-- HANGUL SYLLABLE MYOGS -->
+      <map code="0xbb1c" name="1em"/><!-- HANGUL SYLLABLE MYON -->
+      <map code="0xbb1d" name="1em"/><!-- HANGUL SYLLABLE MYONJ -->
+      <map code="0xbb1e" name="1em"/><!-- HANGUL SYLLABLE MYONH -->
+      <map code="0xbb1f" name="1em"/><!-- HANGUL SYLLABLE MYOD -->
+      <map code="0xbb20" name="1em"/><!-- HANGUL SYLLABLE MYOL -->
+      <map code="0xbb21" name="1em"/><!-- HANGUL SYLLABLE MYOLG -->
+      <map code="0xbb22" name="1em"/><!-- HANGUL SYLLABLE MYOLM -->
+      <map code="0xbb23" name="1em"/><!-- HANGUL SYLLABLE MYOLB -->
+      <map code="0xbb24" name="1em"/><!-- HANGUL SYLLABLE MYOLS -->
+      <map code="0xbb25" name="1em"/><!-- HANGUL SYLLABLE MYOLT -->
+      <map code="0xbb26" name="1em"/><!-- HANGUL SYLLABLE MYOLP -->
+      <map code="0xbb27" name="1em"/><!-- HANGUL SYLLABLE MYOLH -->
+      <map code="0xbb28" name="1em"/><!-- HANGUL SYLLABLE MYOM -->
+      <map code="0xbb29" name="1em"/><!-- HANGUL SYLLABLE MYOB -->
+      <map code="0xbb2a" name="1em"/><!-- HANGUL SYLLABLE MYOBS -->
+      <map code="0xbb2b" name="1em"/><!-- HANGUL SYLLABLE MYOS -->
+      <map code="0xbb2c" name="1em"/><!-- HANGUL SYLLABLE MYOSS -->
+      <map code="0xbb2d" name="1em"/><!-- HANGUL SYLLABLE MYONG -->
+      <map code="0xbb2e" name="1em"/><!-- HANGUL SYLLABLE MYOJ -->
+      <map code="0xbb2f" name="1em"/><!-- HANGUL SYLLABLE MYOC -->
+      <map code="0xbb30" name="1em"/><!-- HANGUL SYLLABLE MYOK -->
+      <map code="0xbb31" name="1em"/><!-- HANGUL SYLLABLE MYOT -->
+      <map code="0xbb32" name="1em"/><!-- HANGUL SYLLABLE MYOP -->
+      <map code="0xbb33" name="1em"/><!-- HANGUL SYLLABLE MYOH -->
+      <map code="0xbb34" name="1em"/><!-- HANGUL SYLLABLE MU -->
+      <map code="0xbb35" name="1em"/><!-- HANGUL SYLLABLE MUG -->
+      <map code="0xbb36" name="1em"/><!-- HANGUL SYLLABLE MUGG -->
+      <map code="0xbb37" name="1em"/><!-- HANGUL SYLLABLE MUGS -->
+      <map code="0xbb38" name="1em"/><!-- HANGUL SYLLABLE MUN -->
+      <map code="0xbb39" name="1em"/><!-- HANGUL SYLLABLE MUNJ -->
+      <map code="0xbb3a" name="1em"/><!-- HANGUL SYLLABLE MUNH -->
+      <map code="0xbb3b" name="1em"/><!-- HANGUL SYLLABLE MUD -->
+      <map code="0xbb3c" name="1em"/><!-- HANGUL SYLLABLE MUL -->
+      <map code="0xbb3d" name="1em"/><!-- HANGUL SYLLABLE MULG -->
+      <map code="0xbb3e" name="1em"/><!-- HANGUL SYLLABLE MULM -->
+      <map code="0xbb3f" name="1em"/><!-- HANGUL SYLLABLE MULB -->
+      <map code="0xbb40" name="1em"/><!-- HANGUL SYLLABLE MULS -->
+      <map code="0xbb41" name="1em"/><!-- HANGUL SYLLABLE MULT -->
+      <map code="0xbb42" name="1em"/><!-- HANGUL SYLLABLE MULP -->
+      <map code="0xbb43" name="1em"/><!-- HANGUL SYLLABLE MULH -->
+      <map code="0xbb44" name="1em"/><!-- HANGUL SYLLABLE MUM -->
+      <map code="0xbb45" name="1em"/><!-- HANGUL SYLLABLE MUB -->
+      <map code="0xbb46" name="1em"/><!-- HANGUL SYLLABLE MUBS -->
+      <map code="0xbb47" name="1em"/><!-- HANGUL SYLLABLE MUS -->
+      <map code="0xbb48" name="1em"/><!-- HANGUL SYLLABLE MUSS -->
+      <map code="0xbb49" name="1em"/><!-- HANGUL SYLLABLE MUNG -->
+      <map code="0xbb4a" name="1em"/><!-- HANGUL SYLLABLE MUJ -->
+      <map code="0xbb4b" name="1em"/><!-- HANGUL SYLLABLE MUC -->
+      <map code="0xbb4c" name="1em"/><!-- HANGUL SYLLABLE MUK -->
+      <map code="0xbb4d" name="1em"/><!-- HANGUL SYLLABLE MUT -->
+      <map code="0xbb4e" name="1em"/><!-- HANGUL SYLLABLE MUP -->
+      <map code="0xbb4f" name="1em"/><!-- HANGUL SYLLABLE MUH -->
+      <map code="0xbb50" name="1em"/><!-- HANGUL SYLLABLE MWEO -->
+      <map code="0xbb51" name="1em"/><!-- HANGUL SYLLABLE MWEOG -->
+      <map code="0xbb52" name="1em"/><!-- HANGUL SYLLABLE MWEOGG -->
+      <map code="0xbb53" name="1em"/><!-- HANGUL SYLLABLE MWEOGS -->
+      <map code="0xbb54" name="1em"/><!-- HANGUL SYLLABLE MWEON -->
+      <map code="0xbb55" name="1em"/><!-- HANGUL SYLLABLE MWEONJ -->
+      <map code="0xbb56" name="1em"/><!-- HANGUL SYLLABLE MWEONH -->
+      <map code="0xbb57" name="1em"/><!-- HANGUL SYLLABLE MWEOD -->
+      <map code="0xbb58" name="1em"/><!-- HANGUL SYLLABLE MWEOL -->
+      <map code="0xbb59" name="1em"/><!-- HANGUL SYLLABLE MWEOLG -->
+      <map code="0xbb5a" name="1em"/><!-- HANGUL SYLLABLE MWEOLM -->
+      <map code="0xbb5b" name="1em"/><!-- HANGUL SYLLABLE MWEOLB -->
+      <map code="0xbb5c" name="1em"/><!-- HANGUL SYLLABLE MWEOLS -->
+      <map code="0xbb5d" name="1em"/><!-- HANGUL SYLLABLE MWEOLT -->
+      <map code="0xbb5e" name="1em"/><!-- HANGUL SYLLABLE MWEOLP -->
+      <map code="0xbb5f" name="1em"/><!-- HANGUL SYLLABLE MWEOLH -->
+      <map code="0xbb60" name="1em"/><!-- HANGUL SYLLABLE MWEOM -->
+      <map code="0xbb61" name="1em"/><!-- HANGUL SYLLABLE MWEOB -->
+      <map code="0xbb62" name="1em"/><!-- HANGUL SYLLABLE MWEOBS -->
+      <map code="0xbb63" name="1em"/><!-- HANGUL SYLLABLE MWEOS -->
+      <map code="0xbb64" name="1em"/><!-- HANGUL SYLLABLE MWEOSS -->
+      <map code="0xbb65" name="1em"/><!-- HANGUL SYLLABLE MWEONG -->
+      <map code="0xbb66" name="1em"/><!-- HANGUL SYLLABLE MWEOJ -->
+      <map code="0xbb67" name="1em"/><!-- HANGUL SYLLABLE MWEOC -->
+      <map code="0xbb68" name="1em"/><!-- HANGUL SYLLABLE MWEOK -->
+      <map code="0xbb69" name="1em"/><!-- HANGUL SYLLABLE MWEOT -->
+      <map code="0xbb6a" name="1em"/><!-- HANGUL SYLLABLE MWEOP -->
+      <map code="0xbb6b" name="1em"/><!-- HANGUL SYLLABLE MWEOH -->
+      <map code="0xbb6c" name="1em"/><!-- HANGUL SYLLABLE MWE -->
+      <map code="0xbb6d" name="1em"/><!-- HANGUL SYLLABLE MWEG -->
+      <map code="0xbb6e" name="1em"/><!-- HANGUL SYLLABLE MWEGG -->
+      <map code="0xbb6f" name="1em"/><!-- HANGUL SYLLABLE MWEGS -->
+      <map code="0xbb70" name="1em"/><!-- HANGUL SYLLABLE MWEN -->
+      <map code="0xbb71" name="1em"/><!-- HANGUL SYLLABLE MWENJ -->
+      <map code="0xbb72" name="1em"/><!-- HANGUL SYLLABLE MWENH -->
+      <map code="0xbb73" name="1em"/><!-- HANGUL SYLLABLE MWED -->
+      <map code="0xbb74" name="1em"/><!-- HANGUL SYLLABLE MWEL -->
+      <map code="0xbb75" name="1em"/><!-- HANGUL SYLLABLE MWELG -->
+      <map code="0xbb76" name="1em"/><!-- HANGUL SYLLABLE MWELM -->
+      <map code="0xbb77" name="1em"/><!-- HANGUL SYLLABLE MWELB -->
+      <map code="0xbb78" name="1em"/><!-- HANGUL SYLLABLE MWELS -->
+      <map code="0xbb79" name="1em"/><!-- HANGUL SYLLABLE MWELT -->
+      <map code="0xbb7a" name="1em"/><!-- HANGUL SYLLABLE MWELP -->
+      <map code="0xbb7b" name="1em"/><!-- HANGUL SYLLABLE MWELH -->
+      <map code="0xbb7c" name="1em"/><!-- HANGUL SYLLABLE MWEM -->
+      <map code="0xbb7d" name="1em"/><!-- HANGUL SYLLABLE MWEB -->
+      <map code="0xbb7e" name="1em"/><!-- HANGUL SYLLABLE MWEBS -->
+      <map code="0xbb7f" name="1em"/><!-- HANGUL SYLLABLE MWES -->
+      <map code="0xbb80" name="1em"/><!-- HANGUL SYLLABLE MWESS -->
+      <map code="0xbb81" name="1em"/><!-- HANGUL SYLLABLE MWENG -->
+      <map code="0xbb82" name="1em"/><!-- HANGUL SYLLABLE MWEJ -->
+      <map code="0xbb83" name="1em"/><!-- HANGUL SYLLABLE MWEC -->
+      <map code="0xbb84" name="1em"/><!-- HANGUL SYLLABLE MWEK -->
+      <map code="0xbb85" name="1em"/><!-- HANGUL SYLLABLE MWET -->
+      <map code="0xbb86" name="1em"/><!-- HANGUL SYLLABLE MWEP -->
+      <map code="0xbb87" name="1em"/><!-- HANGUL SYLLABLE MWEH -->
+      <map code="0xbb88" name="1em"/><!-- HANGUL SYLLABLE MWI -->
+      <map code="0xbb89" name="1em"/><!-- HANGUL SYLLABLE MWIG -->
+      <map code="0xbb8a" name="1em"/><!-- HANGUL SYLLABLE MWIGG -->
+      <map code="0xbb8b" name="1em"/><!-- HANGUL SYLLABLE MWIGS -->
+      <map code="0xbb8c" name="1em"/><!-- HANGUL SYLLABLE MWIN -->
+      <map code="0xbb8d" name="1em"/><!-- HANGUL SYLLABLE MWINJ -->
+      <map code="0xbb8e" name="1em"/><!-- HANGUL SYLLABLE MWINH -->
+      <map code="0xbb8f" name="1em"/><!-- HANGUL SYLLABLE MWID -->
+      <map code="0xbb90" name="1em"/><!-- HANGUL SYLLABLE MWIL -->
+      <map code="0xbb91" name="1em"/><!-- HANGUL SYLLABLE MWILG -->
+      <map code="0xbb92" name="1em"/><!-- HANGUL SYLLABLE MWILM -->
+      <map code="0xbb93" name="1em"/><!-- HANGUL SYLLABLE MWILB -->
+      <map code="0xbb94" name="1em"/><!-- HANGUL SYLLABLE MWILS -->
+      <map code="0xbb95" name="1em"/><!-- HANGUL SYLLABLE MWILT -->
+      <map code="0xbb96" name="1em"/><!-- HANGUL SYLLABLE MWILP -->
+      <map code="0xbb97" name="1em"/><!-- HANGUL SYLLABLE MWILH -->
+      <map code="0xbb98" name="1em"/><!-- HANGUL SYLLABLE MWIM -->
+      <map code="0xbb99" name="1em"/><!-- HANGUL SYLLABLE MWIB -->
+      <map code="0xbb9a" name="1em"/><!-- HANGUL SYLLABLE MWIBS -->
+      <map code="0xbb9b" name="1em"/><!-- HANGUL SYLLABLE MWIS -->
+      <map code="0xbb9c" name="1em"/><!-- HANGUL SYLLABLE MWISS -->
+      <map code="0xbb9d" name="1em"/><!-- HANGUL SYLLABLE MWING -->
+      <map code="0xbb9e" name="1em"/><!-- HANGUL SYLLABLE MWIJ -->
+      <map code="0xbb9f" name="1em"/><!-- HANGUL SYLLABLE MWIC -->
+      <map code="0xbba0" name="1em"/><!-- HANGUL SYLLABLE MWIK -->
+      <map code="0xbba1" name="1em"/><!-- HANGUL SYLLABLE MWIT -->
+      <map code="0xbba2" name="1em"/><!-- HANGUL SYLLABLE MWIP -->
+      <map code="0xbba3" name="1em"/><!-- HANGUL SYLLABLE MWIH -->
+      <map code="0xbba4" name="1em"/><!-- HANGUL SYLLABLE MYU -->
+      <map code="0xbba5" name="1em"/><!-- HANGUL SYLLABLE MYUG -->
+      <map code="0xbba6" name="1em"/><!-- HANGUL SYLLABLE MYUGG -->
+      <map code="0xbba7" name="1em"/><!-- HANGUL SYLLABLE MYUGS -->
+      <map code="0xbba8" name="1em"/><!-- HANGUL SYLLABLE MYUN -->
+      <map code="0xbba9" name="1em"/><!-- HANGUL SYLLABLE MYUNJ -->
+      <map code="0xbbaa" name="1em"/><!-- HANGUL SYLLABLE MYUNH -->
+      <map code="0xbbab" name="1em"/><!-- HANGUL SYLLABLE MYUD -->
+      <map code="0xbbac" name="1em"/><!-- HANGUL SYLLABLE MYUL -->
+      <map code="0xbbad" name="1em"/><!-- HANGUL SYLLABLE MYULG -->
+      <map code="0xbbae" name="1em"/><!-- HANGUL SYLLABLE MYULM -->
+      <map code="0xbbaf" name="1em"/><!-- HANGUL SYLLABLE MYULB -->
+      <map code="0xbbb0" name="1em"/><!-- HANGUL SYLLABLE MYULS -->
+      <map code="0xbbb1" name="1em"/><!-- HANGUL SYLLABLE MYULT -->
+      <map code="0xbbb2" name="1em"/><!-- HANGUL SYLLABLE MYULP -->
+      <map code="0xbbb3" name="1em"/><!-- HANGUL SYLLABLE MYULH -->
+      <map code="0xbbb4" name="1em"/><!-- HANGUL SYLLABLE MYUM -->
+      <map code="0xbbb5" name="1em"/><!-- HANGUL SYLLABLE MYUB -->
+      <map code="0xbbb6" name="1em"/><!-- HANGUL SYLLABLE MYUBS -->
+      <map code="0xbbb7" name="1em"/><!-- HANGUL SYLLABLE MYUS -->
+      <map code="0xbbb8" name="1em"/><!-- HANGUL SYLLABLE MYUSS -->
+      <map code="0xbbb9" name="1em"/><!-- HANGUL SYLLABLE MYUNG -->
+      <map code="0xbbba" name="1em"/><!-- HANGUL SYLLABLE MYUJ -->
+      <map code="0xbbbb" name="1em"/><!-- HANGUL SYLLABLE MYUC -->
+      <map code="0xbbbc" name="1em"/><!-- HANGUL SYLLABLE MYUK -->
+      <map code="0xbbbd" name="1em"/><!-- HANGUL SYLLABLE MYUT -->
+      <map code="0xbbbe" name="1em"/><!-- HANGUL SYLLABLE MYUP -->
+      <map code="0xbbbf" name="1em"/><!-- HANGUL SYLLABLE MYUH -->
+      <map code="0xbbc0" name="1em"/><!-- HANGUL SYLLABLE MEU -->
+      <map code="0xbbc1" name="1em"/><!-- HANGUL SYLLABLE MEUG -->
+      <map code="0xbbc2" name="1em"/><!-- HANGUL SYLLABLE MEUGG -->
+      <map code="0xbbc3" name="1em"/><!-- HANGUL SYLLABLE MEUGS -->
+      <map code="0xbbc4" name="1em"/><!-- HANGUL SYLLABLE MEUN -->
+      <map code="0xbbc5" name="1em"/><!-- HANGUL SYLLABLE MEUNJ -->
+      <map code="0xbbc6" name="1em"/><!-- HANGUL SYLLABLE MEUNH -->
+      <map code="0xbbc7" name="1em"/><!-- HANGUL SYLLABLE MEUD -->
+      <map code="0xbbc8" name="1em"/><!-- HANGUL SYLLABLE MEUL -->
+      <map code="0xbbc9" name="1em"/><!-- HANGUL SYLLABLE MEULG -->
+      <map code="0xbbca" name="1em"/><!-- HANGUL SYLLABLE MEULM -->
+      <map code="0xbbcb" name="1em"/><!-- HANGUL SYLLABLE MEULB -->
+      <map code="0xbbcc" name="1em"/><!-- HANGUL SYLLABLE MEULS -->
+      <map code="0xbbcd" name="1em"/><!-- HANGUL SYLLABLE MEULT -->
+      <map code="0xbbce" name="1em"/><!-- HANGUL SYLLABLE MEULP -->
+      <map code="0xbbcf" name="1em"/><!-- HANGUL SYLLABLE MEULH -->
+      <map code="0xbbd0" name="1em"/><!-- HANGUL SYLLABLE MEUM -->
+      <map code="0xbbd1" name="1em"/><!-- HANGUL SYLLABLE MEUB -->
+      <map code="0xbbd2" name="1em"/><!-- HANGUL SYLLABLE MEUBS -->
+      <map code="0xbbd3" name="1em"/><!-- HANGUL SYLLABLE MEUS -->
+      <map code="0xbbd4" name="1em"/><!-- HANGUL SYLLABLE MEUSS -->
+      <map code="0xbbd5" name="1em"/><!-- HANGUL SYLLABLE MEUNG -->
+      <map code="0xbbd6" name="1em"/><!-- HANGUL SYLLABLE MEUJ -->
+      <map code="0xbbd7" name="1em"/><!-- HANGUL SYLLABLE MEUC -->
+      <map code="0xbbd8" name="1em"/><!-- HANGUL SYLLABLE MEUK -->
+      <map code="0xbbd9" name="1em"/><!-- HANGUL SYLLABLE MEUT -->
+      <map code="0xbbda" name="1em"/><!-- HANGUL SYLLABLE MEUP -->
+      <map code="0xbbdb" name="1em"/><!-- HANGUL SYLLABLE MEUH -->
+      <map code="0xbbdc" name="1em"/><!-- HANGUL SYLLABLE MYI -->
+      <map code="0xbbdd" name="1em"/><!-- HANGUL SYLLABLE MYIG -->
+      <map code="0xbbde" name="1em"/><!-- HANGUL SYLLABLE MYIGG -->
+      <map code="0xbbdf" name="1em"/><!-- HANGUL SYLLABLE MYIGS -->
+      <map code="0xbbe0" name="1em"/><!-- HANGUL SYLLABLE MYIN -->
+      <map code="0xbbe1" name="1em"/><!-- HANGUL SYLLABLE MYINJ -->
+      <map code="0xbbe2" name="1em"/><!-- HANGUL SYLLABLE MYINH -->
+      <map code="0xbbe3" name="1em"/><!-- HANGUL SYLLABLE MYID -->
+      <map code="0xbbe4" name="1em"/><!-- HANGUL SYLLABLE MYIL -->
+      <map code="0xbbe5" name="1em"/><!-- HANGUL SYLLABLE MYILG -->
+      <map code="0xbbe6" name="1em"/><!-- HANGUL SYLLABLE MYILM -->
+      <map code="0xbbe7" name="1em"/><!-- HANGUL SYLLABLE MYILB -->
+      <map code="0xbbe8" name="1em"/><!-- HANGUL SYLLABLE MYILS -->
+      <map code="0xbbe9" name="1em"/><!-- HANGUL SYLLABLE MYILT -->
+      <map code="0xbbea" name="1em"/><!-- HANGUL SYLLABLE MYILP -->
+      <map code="0xbbeb" name="1em"/><!-- HANGUL SYLLABLE MYILH -->
+      <map code="0xbbec" name="1em"/><!-- HANGUL SYLLABLE MYIM -->
+      <map code="0xbbed" name="1em"/><!-- HANGUL SYLLABLE MYIB -->
+      <map code="0xbbee" name="1em"/><!-- HANGUL SYLLABLE MYIBS -->
+      <map code="0xbbef" name="1em"/><!-- HANGUL SYLLABLE MYIS -->
+      <map code="0xbbf0" name="1em"/><!-- HANGUL SYLLABLE MYISS -->
+      <map code="0xbbf1" name="1em"/><!-- HANGUL SYLLABLE MYING -->
+      <map code="0xbbf2" name="1em"/><!-- HANGUL SYLLABLE MYIJ -->
+      <map code="0xbbf3" name="1em"/><!-- HANGUL SYLLABLE MYIC -->
+      <map code="0xbbf4" name="1em"/><!-- HANGUL SYLLABLE MYIK -->
+      <map code="0xbbf5" name="1em"/><!-- HANGUL SYLLABLE MYIT -->
+      <map code="0xbbf6" name="1em"/><!-- HANGUL SYLLABLE MYIP -->
+      <map code="0xbbf7" name="1em"/><!-- HANGUL SYLLABLE MYIH -->
+      <map code="0xbbf8" name="1em"/><!-- HANGUL SYLLABLE MI -->
+      <map code="0xbbf9" name="1em"/><!-- HANGUL SYLLABLE MIG -->
+      <map code="0xbbfa" name="1em"/><!-- HANGUL SYLLABLE MIGG -->
+      <map code="0xbbfb" name="1em"/><!-- HANGUL SYLLABLE MIGS -->
+      <map code="0xbbfc" name="1em"/><!-- HANGUL SYLLABLE MIN -->
+      <map code="0xbbfd" name="1em"/><!-- HANGUL SYLLABLE MINJ -->
+      <map code="0xbbfe" name="1em"/><!-- HANGUL SYLLABLE MINH -->
+      <map code="0xbbff" name="1em"/><!-- HANGUL SYLLABLE MID -->
+      <map code="0xbc00" name="1em"/><!-- HANGUL SYLLABLE MIL -->
+      <map code="0xbc01" name="1em"/><!-- HANGUL SYLLABLE MILG -->
+      <map code="0xbc02" name="1em"/><!-- HANGUL SYLLABLE MILM -->
+      <map code="0xbc03" name="1em"/><!-- HANGUL SYLLABLE MILB -->
+      <map code="0xbc04" name="1em"/><!-- HANGUL SYLLABLE MILS -->
+      <map code="0xbc05" name="1em"/><!-- HANGUL SYLLABLE MILT -->
+      <map code="0xbc06" name="1em"/><!-- HANGUL SYLLABLE MILP -->
+      <map code="0xbc07" name="1em"/><!-- HANGUL SYLLABLE MILH -->
+      <map code="0xbc08" name="1em"/><!-- HANGUL SYLLABLE MIM -->
+      <map code="0xbc09" name="1em"/><!-- HANGUL SYLLABLE MIB -->
+      <map code="0xbc0a" name="1em"/><!-- HANGUL SYLLABLE MIBS -->
+      <map code="0xbc0b" name="1em"/><!-- HANGUL SYLLABLE MIS -->
+      <map code="0xbc0c" name="1em"/><!-- HANGUL SYLLABLE MISS -->
+      <map code="0xbc0d" name="1em"/><!-- HANGUL SYLLABLE MING -->
+      <map code="0xbc0e" name="1em"/><!-- HANGUL SYLLABLE MIJ -->
+      <map code="0xbc0f" name="1em"/><!-- HANGUL SYLLABLE MIC -->
+      <map code="0xbc10" name="1em"/><!-- HANGUL SYLLABLE MIK -->
+      <map code="0xbc11" name="1em"/><!-- HANGUL SYLLABLE MIT -->
+      <map code="0xbc12" name="1em"/><!-- HANGUL SYLLABLE MIP -->
+      <map code="0xbc13" name="1em"/><!-- HANGUL SYLLABLE MIH -->
+      <map code="0xbc14" name="1em"/><!-- HANGUL SYLLABLE BA -->
+      <map code="0xbc15" name="1em"/><!-- HANGUL SYLLABLE BAG -->
+      <map code="0xbc16" name="1em"/><!-- HANGUL SYLLABLE BAGG -->
+      <map code="0xbc17" name="1em"/><!-- HANGUL SYLLABLE BAGS -->
+      <map code="0xbc18" name="1em"/><!-- HANGUL SYLLABLE BAN -->
+      <map code="0xbc19" name="1em"/><!-- HANGUL SYLLABLE BANJ -->
+      <map code="0xbc1a" name="1em"/><!-- HANGUL SYLLABLE BANH -->
+      <map code="0xbc1b" name="1em"/><!-- HANGUL SYLLABLE BAD -->
+      <map code="0xbc1c" name="1em"/><!-- HANGUL SYLLABLE BAL -->
+      <map code="0xbc1d" name="1em"/><!-- HANGUL SYLLABLE BALG -->
+      <map code="0xbc1e" name="1em"/><!-- HANGUL SYLLABLE BALM -->
+      <map code="0xbc1f" name="1em"/><!-- HANGUL SYLLABLE BALB -->
+      <map code="0xbc20" name="1em"/><!-- HANGUL SYLLABLE BALS -->
+      <map code="0xbc21" name="1em"/><!-- HANGUL SYLLABLE BALT -->
+      <map code="0xbc22" name="1em"/><!-- HANGUL SYLLABLE BALP -->
+      <map code="0xbc23" name="1em"/><!-- HANGUL SYLLABLE BALH -->
+      <map code="0xbc24" name="1em"/><!-- HANGUL SYLLABLE BAM -->
+      <map code="0xbc25" name="1em"/><!-- HANGUL SYLLABLE BAB -->
+      <map code="0xbc26" name="1em"/><!-- HANGUL SYLLABLE BABS -->
+      <map code="0xbc27" name="1em"/><!-- HANGUL SYLLABLE BAS -->
+      <map code="0xbc28" name="1em"/><!-- HANGUL SYLLABLE BASS -->
+      <map code="0xbc29" name="1em"/><!-- HANGUL SYLLABLE BANG -->
+      <map code="0xbc2a" name="1em"/><!-- HANGUL SYLLABLE BAJ -->
+      <map code="0xbc2b" name="1em"/><!-- HANGUL SYLLABLE BAC -->
+      <map code="0xbc2c" name="1em"/><!-- HANGUL SYLLABLE BAK -->
+      <map code="0xbc2d" name="1em"/><!-- HANGUL SYLLABLE BAT -->
+      <map code="0xbc2e" name="1em"/><!-- HANGUL SYLLABLE BAP -->
+      <map code="0xbc2f" name="1em"/><!-- HANGUL SYLLABLE BAH -->
+      <map code="0xbc30" name="1em"/><!-- HANGUL SYLLABLE BAE -->
+      <map code="0xbc31" name="1em"/><!-- HANGUL SYLLABLE BAEG -->
+      <map code="0xbc32" name="1em"/><!-- HANGUL SYLLABLE BAEGG -->
+      <map code="0xbc33" name="1em"/><!-- HANGUL SYLLABLE BAEGS -->
+      <map code="0xbc34" name="1em"/><!-- HANGUL SYLLABLE BAEN -->
+      <map code="0xbc35" name="1em"/><!-- HANGUL SYLLABLE BAENJ -->
+      <map code="0xbc36" name="1em"/><!-- HANGUL SYLLABLE BAENH -->
+      <map code="0xbc37" name="1em"/><!-- HANGUL SYLLABLE BAED -->
+      <map code="0xbc38" name="1em"/><!-- HANGUL SYLLABLE BAEL -->
+      <map code="0xbc39" name="1em"/><!-- HANGUL SYLLABLE BAELG -->
+      <map code="0xbc3a" name="1em"/><!-- HANGUL SYLLABLE BAELM -->
+      <map code="0xbc3b" name="1em"/><!-- HANGUL SYLLABLE BAELB -->
+      <map code="0xbc3c" name="1em"/><!-- HANGUL SYLLABLE BAELS -->
+      <map code="0xbc3d" name="1em"/><!-- HANGUL SYLLABLE BAELT -->
+      <map code="0xbc3e" name="1em"/><!-- HANGUL SYLLABLE BAELP -->
+      <map code="0xbc3f" name="1em"/><!-- HANGUL SYLLABLE BAELH -->
+      <map code="0xbc40" name="1em"/><!-- HANGUL SYLLABLE BAEM -->
+      <map code="0xbc41" name="1em"/><!-- HANGUL SYLLABLE BAEB -->
+      <map code="0xbc42" name="1em"/><!-- HANGUL SYLLABLE BAEBS -->
+      <map code="0xbc43" name="1em"/><!-- HANGUL SYLLABLE BAES -->
+      <map code="0xbc44" name="1em"/><!-- HANGUL SYLLABLE BAESS -->
+      <map code="0xbc45" name="1em"/><!-- HANGUL SYLLABLE BAENG -->
+      <map code="0xbc46" name="1em"/><!-- HANGUL SYLLABLE BAEJ -->
+      <map code="0xbc47" name="1em"/><!-- HANGUL SYLLABLE BAEC -->
+      <map code="0xbc48" name="1em"/><!-- HANGUL SYLLABLE BAEK -->
+      <map code="0xbc49" name="1em"/><!-- HANGUL SYLLABLE BAET -->
+      <map code="0xbc4a" name="1em"/><!-- HANGUL SYLLABLE BAEP -->
+      <map code="0xbc4b" name="1em"/><!-- HANGUL SYLLABLE BAEH -->
+      <map code="0xbc4c" name="1em"/><!-- HANGUL SYLLABLE BYA -->
+      <map code="0xbc4d" name="1em"/><!-- HANGUL SYLLABLE BYAG -->
+      <map code="0xbc4e" name="1em"/><!-- HANGUL SYLLABLE BYAGG -->
+      <map code="0xbc4f" name="1em"/><!-- HANGUL SYLLABLE BYAGS -->
+      <map code="0xbc50" name="1em"/><!-- HANGUL SYLLABLE BYAN -->
+      <map code="0xbc51" name="1em"/><!-- HANGUL SYLLABLE BYANJ -->
+      <map code="0xbc52" name="1em"/><!-- HANGUL SYLLABLE BYANH -->
+      <map code="0xbc53" name="1em"/><!-- HANGUL SYLLABLE BYAD -->
+      <map code="0xbc54" name="1em"/><!-- HANGUL SYLLABLE BYAL -->
+      <map code="0xbc55" name="1em"/><!-- HANGUL SYLLABLE BYALG -->
+      <map code="0xbc56" name="1em"/><!-- HANGUL SYLLABLE BYALM -->
+      <map code="0xbc57" name="1em"/><!-- HANGUL SYLLABLE BYALB -->
+      <map code="0xbc58" name="1em"/><!-- HANGUL SYLLABLE BYALS -->
+      <map code="0xbc59" name="1em"/><!-- HANGUL SYLLABLE BYALT -->
+      <map code="0xbc5a" name="1em"/><!-- HANGUL SYLLABLE BYALP -->
+      <map code="0xbc5b" name="1em"/><!-- HANGUL SYLLABLE BYALH -->
+      <map code="0xbc5c" name="1em"/><!-- HANGUL SYLLABLE BYAM -->
+      <map code="0xbc5d" name="1em"/><!-- HANGUL SYLLABLE BYAB -->
+      <map code="0xbc5e" name="1em"/><!-- HANGUL SYLLABLE BYABS -->
+      <map code="0xbc5f" name="1em"/><!-- HANGUL SYLLABLE BYAS -->
+      <map code="0xbc60" name="1em"/><!-- HANGUL SYLLABLE BYASS -->
+      <map code="0xbc61" name="1em"/><!-- HANGUL SYLLABLE BYANG -->
+      <map code="0xbc62" name="1em"/><!-- HANGUL SYLLABLE BYAJ -->
+      <map code="0xbc63" name="1em"/><!-- HANGUL SYLLABLE BYAC -->
+      <map code="0xbc64" name="1em"/><!-- HANGUL SYLLABLE BYAK -->
+      <map code="0xbc65" name="1em"/><!-- HANGUL SYLLABLE BYAT -->
+      <map code="0xbc66" name="1em"/><!-- HANGUL SYLLABLE BYAP -->
+      <map code="0xbc67" name="1em"/><!-- HANGUL SYLLABLE BYAH -->
+      <map code="0xbc68" name="1em"/><!-- HANGUL SYLLABLE BYAE -->
+      <map code="0xbc69" name="1em"/><!-- HANGUL SYLLABLE BYAEG -->
+      <map code="0xbc6a" name="1em"/><!-- HANGUL SYLLABLE BYAEGG -->
+      <map code="0xbc6b" name="1em"/><!-- HANGUL SYLLABLE BYAEGS -->
+      <map code="0xbc6c" name="1em"/><!-- HANGUL SYLLABLE BYAEN -->
+      <map code="0xbc6d" name="1em"/><!-- HANGUL SYLLABLE BYAENJ -->
+      <map code="0xbc6e" name="1em"/><!-- HANGUL SYLLABLE BYAENH -->
+      <map code="0xbc6f" name="1em"/><!-- HANGUL SYLLABLE BYAED -->
+      <map code="0xbc70" name="1em"/><!-- HANGUL SYLLABLE BYAEL -->
+      <map code="0xbc71" name="1em"/><!-- HANGUL SYLLABLE BYAELG -->
+      <map code="0xbc72" name="1em"/><!-- HANGUL SYLLABLE BYAELM -->
+      <map code="0xbc73" name="1em"/><!-- HANGUL SYLLABLE BYAELB -->
+      <map code="0xbc74" name="1em"/><!-- HANGUL SYLLABLE BYAELS -->
+      <map code="0xbc75" name="1em"/><!-- HANGUL SYLLABLE BYAELT -->
+      <map code="0xbc76" name="1em"/><!-- HANGUL SYLLABLE BYAELP -->
+      <map code="0xbc77" name="1em"/><!-- HANGUL SYLLABLE BYAELH -->
+      <map code="0xbc78" name="1em"/><!-- HANGUL SYLLABLE BYAEM -->
+      <map code="0xbc79" name="1em"/><!-- HANGUL SYLLABLE BYAEB -->
+      <map code="0xbc7a" name="1em"/><!-- HANGUL SYLLABLE BYAEBS -->
+      <map code="0xbc7b" name="1em"/><!-- HANGUL SYLLABLE BYAES -->
+      <map code="0xbc7c" name="1em"/><!-- HANGUL SYLLABLE BYAESS -->
+      <map code="0xbc7d" name="1em"/><!-- HANGUL SYLLABLE BYAENG -->
+      <map code="0xbc7e" name="1em"/><!-- HANGUL SYLLABLE BYAEJ -->
+      <map code="0xbc7f" name="1em"/><!-- HANGUL SYLLABLE BYAEC -->
+      <map code="0xbc80" name="1em"/><!-- HANGUL SYLLABLE BYAEK -->
+      <map code="0xbc81" name="1em"/><!-- HANGUL SYLLABLE BYAET -->
+      <map code="0xbc82" name="1em"/><!-- HANGUL SYLLABLE BYAEP -->
+      <map code="0xbc83" name="1em"/><!-- HANGUL SYLLABLE BYAEH -->
+      <map code="0xbc84" name="1em"/><!-- HANGUL SYLLABLE BEO -->
+      <map code="0xbc85" name="1em"/><!-- HANGUL SYLLABLE BEOG -->
+      <map code="0xbc86" name="1em"/><!-- HANGUL SYLLABLE BEOGG -->
+      <map code="0xbc87" name="1em"/><!-- HANGUL SYLLABLE BEOGS -->
+      <map code="0xbc88" name="1em"/><!-- HANGUL SYLLABLE BEON -->
+      <map code="0xbc89" name="1em"/><!-- HANGUL SYLLABLE BEONJ -->
+      <map code="0xbc8a" name="1em"/><!-- HANGUL SYLLABLE BEONH -->
+      <map code="0xbc8b" name="1em"/><!-- HANGUL SYLLABLE BEOD -->
+      <map code="0xbc8c" name="1em"/><!-- HANGUL SYLLABLE BEOL -->
+      <map code="0xbc8d" name="1em"/><!-- HANGUL SYLLABLE BEOLG -->
+      <map code="0xbc8e" name="1em"/><!-- HANGUL SYLLABLE BEOLM -->
+      <map code="0xbc8f" name="1em"/><!-- HANGUL SYLLABLE BEOLB -->
+      <map code="0xbc90" name="1em"/><!-- HANGUL SYLLABLE BEOLS -->
+      <map code="0xbc91" name="1em"/><!-- HANGUL SYLLABLE BEOLT -->
+      <map code="0xbc92" name="1em"/><!-- HANGUL SYLLABLE BEOLP -->
+      <map code="0xbc93" name="1em"/><!-- HANGUL SYLLABLE BEOLH -->
+      <map code="0xbc94" name="1em"/><!-- HANGUL SYLLABLE BEOM -->
+      <map code="0xbc95" name="1em"/><!-- HANGUL SYLLABLE BEOB -->
+      <map code="0xbc96" name="1em"/><!-- HANGUL SYLLABLE BEOBS -->
+      <map code="0xbc97" name="1em"/><!-- HANGUL SYLLABLE BEOS -->
+      <map code="0xbc98" name="1em"/><!-- HANGUL SYLLABLE BEOSS -->
+      <map code="0xbc99" name="1em"/><!-- HANGUL SYLLABLE BEONG -->
+      <map code="0xbc9a" name="1em"/><!-- HANGUL SYLLABLE BEOJ -->
+      <map code="0xbc9b" name="1em"/><!-- HANGUL SYLLABLE BEOC -->
+      <map code="0xbc9c" name="1em"/><!-- HANGUL SYLLABLE BEOK -->
+      <map code="0xbc9d" name="1em"/><!-- HANGUL SYLLABLE BEOT -->
+      <map code="0xbc9e" name="1em"/><!-- HANGUL SYLLABLE BEOP -->
+      <map code="0xbc9f" name="1em"/><!-- HANGUL SYLLABLE BEOH -->
+      <map code="0xbca0" name="1em"/><!-- HANGUL SYLLABLE BE -->
+      <map code="0xbca1" name="1em"/><!-- HANGUL SYLLABLE BEG -->
+      <map code="0xbca2" name="1em"/><!-- HANGUL SYLLABLE BEGG -->
+      <map code="0xbca3" name="1em"/><!-- HANGUL SYLLABLE BEGS -->
+      <map code="0xbca4" name="1em"/><!-- HANGUL SYLLABLE BEN -->
+      <map code="0xbca5" name="1em"/><!-- HANGUL SYLLABLE BENJ -->
+      <map code="0xbca6" name="1em"/><!-- HANGUL SYLLABLE BENH -->
+      <map code="0xbca7" name="1em"/><!-- HANGUL SYLLABLE BED -->
+      <map code="0xbca8" name="1em"/><!-- HANGUL SYLLABLE BEL -->
+      <map code="0xbca9" name="1em"/><!-- HANGUL SYLLABLE BELG -->
+      <map code="0xbcaa" name="1em"/><!-- HANGUL SYLLABLE BELM -->
+      <map code="0xbcab" name="1em"/><!-- HANGUL SYLLABLE BELB -->
+      <map code="0xbcac" name="1em"/><!-- HANGUL SYLLABLE BELS -->
+      <map code="0xbcad" name="1em"/><!-- HANGUL SYLLABLE BELT -->
+      <map code="0xbcae" name="1em"/><!-- HANGUL SYLLABLE BELP -->
+      <map code="0xbcaf" name="1em"/><!-- HANGUL SYLLABLE BELH -->
+      <map code="0xbcb0" name="1em"/><!-- HANGUL SYLLABLE BEM -->
+      <map code="0xbcb1" name="1em"/><!-- HANGUL SYLLABLE BEB -->
+      <map code="0xbcb2" name="1em"/><!-- HANGUL SYLLABLE BEBS -->
+      <map code="0xbcb3" name="1em"/><!-- HANGUL SYLLABLE BES -->
+      <map code="0xbcb4" name="1em"/><!-- HANGUL SYLLABLE BESS -->
+      <map code="0xbcb5" name="1em"/><!-- HANGUL SYLLABLE BENG -->
+      <map code="0xbcb6" name="1em"/><!-- HANGUL SYLLABLE BEJ -->
+      <map code="0xbcb7" name="1em"/><!-- HANGUL SYLLABLE BEC -->
+      <map code="0xbcb8" name="1em"/><!-- HANGUL SYLLABLE BEK -->
+      <map code="0xbcb9" name="1em"/><!-- HANGUL SYLLABLE BET -->
+      <map code="0xbcba" name="1em"/><!-- HANGUL SYLLABLE BEP -->
+      <map code="0xbcbb" name="1em"/><!-- HANGUL SYLLABLE BEH -->
+      <map code="0xbcbc" name="1em"/><!-- HANGUL SYLLABLE BYEO -->
+      <map code="0xbcbd" name="1em"/><!-- HANGUL SYLLABLE BYEOG -->
+      <map code="0xbcbe" name="1em"/><!-- HANGUL SYLLABLE BYEOGG -->
+      <map code="0xbcbf" name="1em"/><!-- HANGUL SYLLABLE BYEOGS -->
+      <map code="0xbcc0" name="1em"/><!-- HANGUL SYLLABLE BYEON -->
+      <map code="0xbcc1" name="1em"/><!-- HANGUL SYLLABLE BYEONJ -->
+      <map code="0xbcc2" name="1em"/><!-- HANGUL SYLLABLE BYEONH -->
+      <map code="0xbcc3" name="1em"/><!-- HANGUL SYLLABLE BYEOD -->
+      <map code="0xbcc4" name="1em"/><!-- HANGUL SYLLABLE BYEOL -->
+      <map code="0xbcc5" name="1em"/><!-- HANGUL SYLLABLE BYEOLG -->
+      <map code="0xbcc6" name="1em"/><!-- HANGUL SYLLABLE BYEOLM -->
+      <map code="0xbcc7" name="1em"/><!-- HANGUL SYLLABLE BYEOLB -->
+      <map code="0xbcc8" name="1em"/><!-- HANGUL SYLLABLE BYEOLS -->
+      <map code="0xbcc9" name="1em"/><!-- HANGUL SYLLABLE BYEOLT -->
+      <map code="0xbcca" name="1em"/><!-- HANGUL SYLLABLE BYEOLP -->
+      <map code="0xbccb" name="1em"/><!-- HANGUL SYLLABLE BYEOLH -->
+      <map code="0xbccc" name="1em"/><!-- HANGUL SYLLABLE BYEOM -->
+      <map code="0xbccd" name="1em"/><!-- HANGUL SYLLABLE BYEOB -->
+      <map code="0xbcce" name="1em"/><!-- HANGUL SYLLABLE BYEOBS -->
+      <map code="0xbccf" name="1em"/><!-- HANGUL SYLLABLE BYEOS -->
+      <map code="0xbcd0" name="1em"/><!-- HANGUL SYLLABLE BYEOSS -->
+      <map code="0xbcd1" name="1em"/><!-- HANGUL SYLLABLE BYEONG -->
+      <map code="0xbcd2" name="1em"/><!-- HANGUL SYLLABLE BYEOJ -->
+      <map code="0xbcd3" name="1em"/><!-- HANGUL SYLLABLE BYEOC -->
+      <map code="0xbcd4" name="1em"/><!-- HANGUL SYLLABLE BYEOK -->
+      <map code="0xbcd5" name="1em"/><!-- HANGUL SYLLABLE BYEOT -->
+      <map code="0xbcd6" name="1em"/><!-- HANGUL SYLLABLE BYEOP -->
+      <map code="0xbcd7" name="1em"/><!-- HANGUL SYLLABLE BYEOH -->
+      <map code="0xbcd8" name="1em"/><!-- HANGUL SYLLABLE BYE -->
+      <map code="0xbcd9" name="1em"/><!-- HANGUL SYLLABLE BYEG -->
+      <map code="0xbcda" name="1em"/><!-- HANGUL SYLLABLE BYEGG -->
+      <map code="0xbcdb" name="1em"/><!-- HANGUL SYLLABLE BYEGS -->
+      <map code="0xbcdc" name="1em"/><!-- HANGUL SYLLABLE BYEN -->
+      <map code="0xbcdd" name="1em"/><!-- HANGUL SYLLABLE BYENJ -->
+      <map code="0xbcde" name="1em"/><!-- HANGUL SYLLABLE BYENH -->
+      <map code="0xbcdf" name="1em"/><!-- HANGUL SYLLABLE BYED -->
+      <map code="0xbce0" name="1em"/><!-- HANGUL SYLLABLE BYEL -->
+      <map code="0xbce1" name="1em"/><!-- HANGUL SYLLABLE BYELG -->
+      <map code="0xbce2" name="1em"/><!-- HANGUL SYLLABLE BYELM -->
+      <map code="0xbce3" name="1em"/><!-- HANGUL SYLLABLE BYELB -->
+      <map code="0xbce4" name="1em"/><!-- HANGUL SYLLABLE BYELS -->
+      <map code="0xbce5" name="1em"/><!-- HANGUL SYLLABLE BYELT -->
+      <map code="0xbce6" name="1em"/><!-- HANGUL SYLLABLE BYELP -->
+      <map code="0xbce7" name="1em"/><!-- HANGUL SYLLABLE BYELH -->
+      <map code="0xbce8" name="1em"/><!-- HANGUL SYLLABLE BYEM -->
+      <map code="0xbce9" name="1em"/><!-- HANGUL SYLLABLE BYEB -->
+      <map code="0xbcea" name="1em"/><!-- HANGUL SYLLABLE BYEBS -->
+      <map code="0xbceb" name="1em"/><!-- HANGUL SYLLABLE BYES -->
+      <map code="0xbcec" name="1em"/><!-- HANGUL SYLLABLE BYESS -->
+      <map code="0xbced" name="1em"/><!-- HANGUL SYLLABLE BYENG -->
+      <map code="0xbcee" name="1em"/><!-- HANGUL SYLLABLE BYEJ -->
+      <map code="0xbcef" name="1em"/><!-- HANGUL SYLLABLE BYEC -->
+      <map code="0xbcf0" name="1em"/><!-- HANGUL SYLLABLE BYEK -->
+      <map code="0xbcf1" name="1em"/><!-- HANGUL SYLLABLE BYET -->
+      <map code="0xbcf2" name="1em"/><!-- HANGUL SYLLABLE BYEP -->
+      <map code="0xbcf3" name="1em"/><!-- HANGUL SYLLABLE BYEH -->
+      <map code="0xbcf4" name="1em"/><!-- HANGUL SYLLABLE BO -->
+      <map code="0xbcf5" name="1em"/><!-- HANGUL SYLLABLE BOG -->
+      <map code="0xbcf6" name="1em"/><!-- HANGUL SYLLABLE BOGG -->
+      <map code="0xbcf7" name="1em"/><!-- HANGUL SYLLABLE BOGS -->
+      <map code="0xbcf8" name="1em"/><!-- HANGUL SYLLABLE BON -->
+      <map code="0xbcf9" name="1em"/><!-- HANGUL SYLLABLE BONJ -->
+      <map code="0xbcfa" name="1em"/><!-- HANGUL SYLLABLE BONH -->
+      <map code="0xbcfb" name="1em"/><!-- HANGUL SYLLABLE BOD -->
+      <map code="0xbcfc" name="1em"/><!-- HANGUL SYLLABLE BOL -->
+      <map code="0xbcfd" name="1em"/><!-- HANGUL SYLLABLE BOLG -->
+      <map code="0xbcfe" name="1em"/><!-- HANGUL SYLLABLE BOLM -->
+      <map code="0xbcff" name="1em"/><!-- HANGUL SYLLABLE BOLB -->
+      <map code="0xbd00" name="1em"/><!-- HANGUL SYLLABLE BOLS -->
+      <map code="0xbd01" name="1em"/><!-- HANGUL SYLLABLE BOLT -->
+      <map code="0xbd02" name="1em"/><!-- HANGUL SYLLABLE BOLP -->
+      <map code="0xbd03" name="1em"/><!-- HANGUL SYLLABLE BOLH -->
+      <map code="0xbd04" name="1em"/><!-- HANGUL SYLLABLE BOM -->
+      <map code="0xbd05" name="1em"/><!-- HANGUL SYLLABLE BOB -->
+      <map code="0xbd06" name="1em"/><!-- HANGUL SYLLABLE BOBS -->
+      <map code="0xbd07" name="1em"/><!-- HANGUL SYLLABLE BOS -->
+      <map code="0xbd08" name="1em"/><!-- HANGUL SYLLABLE BOSS -->
+      <map code="0xbd09" name="1em"/><!-- HANGUL SYLLABLE BONG -->
+      <map code="0xbd0a" name="1em"/><!-- HANGUL SYLLABLE BOJ -->
+      <map code="0xbd0b" name="1em"/><!-- HANGUL SYLLABLE BOC -->
+      <map code="0xbd0c" name="1em"/><!-- HANGUL SYLLABLE BOK -->
+      <map code="0xbd0d" name="1em"/><!-- HANGUL SYLLABLE BOT -->
+      <map code="0xbd0e" name="1em"/><!-- HANGUL SYLLABLE BOP -->
+      <map code="0xbd0f" name="1em"/><!-- HANGUL SYLLABLE BOH -->
+      <map code="0xbd10" name="1em"/><!-- HANGUL SYLLABLE BWA -->
+      <map code="0xbd11" name="1em"/><!-- HANGUL SYLLABLE BWAG -->
+      <map code="0xbd12" name="1em"/><!-- HANGUL SYLLABLE BWAGG -->
+      <map code="0xbd13" name="1em"/><!-- HANGUL SYLLABLE BWAGS -->
+      <map code="0xbd14" name="1em"/><!-- HANGUL SYLLABLE BWAN -->
+      <map code="0xbd15" name="1em"/><!-- HANGUL SYLLABLE BWANJ -->
+      <map code="0xbd16" name="1em"/><!-- HANGUL SYLLABLE BWANH -->
+      <map code="0xbd17" name="1em"/><!-- HANGUL SYLLABLE BWAD -->
+      <map code="0xbd18" name="1em"/><!-- HANGUL SYLLABLE BWAL -->
+      <map code="0xbd19" name="1em"/><!-- HANGUL SYLLABLE BWALG -->
+      <map code="0xbd1a" name="1em"/><!-- HANGUL SYLLABLE BWALM -->
+      <map code="0xbd1b" name="1em"/><!-- HANGUL SYLLABLE BWALB -->
+      <map code="0xbd1c" name="1em"/><!-- HANGUL SYLLABLE BWALS -->
+      <map code="0xbd1d" name="1em"/><!-- HANGUL SYLLABLE BWALT -->
+      <map code="0xbd1e" name="1em"/><!-- HANGUL SYLLABLE BWALP -->
+      <map code="0xbd1f" name="1em"/><!-- HANGUL SYLLABLE BWALH -->
+      <map code="0xbd20" name="1em"/><!-- HANGUL SYLLABLE BWAM -->
+      <map code="0xbd21" name="1em"/><!-- HANGUL SYLLABLE BWAB -->
+      <map code="0xbd22" name="1em"/><!-- HANGUL SYLLABLE BWABS -->
+      <map code="0xbd23" name="1em"/><!-- HANGUL SYLLABLE BWAS -->
+      <map code="0xbd24" name="1em"/><!-- HANGUL SYLLABLE BWASS -->
+      <map code="0xbd25" name="1em"/><!-- HANGUL SYLLABLE BWANG -->
+      <map code="0xbd26" name="1em"/><!-- HANGUL SYLLABLE BWAJ -->
+      <map code="0xbd27" name="1em"/><!-- HANGUL SYLLABLE BWAC -->
+      <map code="0xbd28" name="1em"/><!-- HANGUL SYLLABLE BWAK -->
+      <map code="0xbd29" name="1em"/><!-- HANGUL SYLLABLE BWAT -->
+      <map code="0xbd2a" name="1em"/><!-- HANGUL SYLLABLE BWAP -->
+      <map code="0xbd2b" name="1em"/><!-- HANGUL SYLLABLE BWAH -->
+      <map code="0xbd2c" name="1em"/><!-- HANGUL SYLLABLE BWAE -->
+      <map code="0xbd2d" name="1em"/><!-- HANGUL SYLLABLE BWAEG -->
+      <map code="0xbd2e" name="1em"/><!-- HANGUL SYLLABLE BWAEGG -->
+      <map code="0xbd2f" name="1em"/><!-- HANGUL SYLLABLE BWAEGS -->
+      <map code="0xbd30" name="1em"/><!-- HANGUL SYLLABLE BWAEN -->
+      <map code="0xbd31" name="1em"/><!-- HANGUL SYLLABLE BWAENJ -->
+      <map code="0xbd32" name="1em"/><!-- HANGUL SYLLABLE BWAENH -->
+      <map code="0xbd33" name="1em"/><!-- HANGUL SYLLABLE BWAED -->
+      <map code="0xbd34" name="1em"/><!-- HANGUL SYLLABLE BWAEL -->
+      <map code="0xbd35" name="1em"/><!-- HANGUL SYLLABLE BWAELG -->
+      <map code="0xbd36" name="1em"/><!-- HANGUL SYLLABLE BWAELM -->
+      <map code="0xbd37" name="1em"/><!-- HANGUL SYLLABLE BWAELB -->
+      <map code="0xbd38" name="1em"/><!-- HANGUL SYLLABLE BWAELS -->
+      <map code="0xbd39" name="1em"/><!-- HANGUL SYLLABLE BWAELT -->
+      <map code="0xbd3a" name="1em"/><!-- HANGUL SYLLABLE BWAELP -->
+      <map code="0xbd3b" name="1em"/><!-- HANGUL SYLLABLE BWAELH -->
+      <map code="0xbd3c" name="1em"/><!-- HANGUL SYLLABLE BWAEM -->
+      <map code="0xbd3d" name="1em"/><!-- HANGUL SYLLABLE BWAEB -->
+      <map code="0xbd3e" name="1em"/><!-- HANGUL SYLLABLE BWAEBS -->
+      <map code="0xbd3f" name="1em"/><!-- HANGUL SYLLABLE BWAES -->
+      <map code="0xbd40" name="1em"/><!-- HANGUL SYLLABLE BWAESS -->
+      <map code="0xbd41" name="1em"/><!-- HANGUL SYLLABLE BWAENG -->
+      <map code="0xbd42" name="1em"/><!-- HANGUL SYLLABLE BWAEJ -->
+      <map code="0xbd43" name="1em"/><!-- HANGUL SYLLABLE BWAEC -->
+      <map code="0xbd44" name="1em"/><!-- HANGUL SYLLABLE BWAEK -->
+      <map code="0xbd45" name="1em"/><!-- HANGUL SYLLABLE BWAET -->
+      <map code="0xbd46" name="1em"/><!-- HANGUL SYLLABLE BWAEP -->
+      <map code="0xbd47" name="1em"/><!-- HANGUL SYLLABLE BWAEH -->
+      <map code="0xbd48" name="1em"/><!-- HANGUL SYLLABLE BOE -->
+      <map code="0xbd49" name="1em"/><!-- HANGUL SYLLABLE BOEG -->
+      <map code="0xbd4a" name="1em"/><!-- HANGUL SYLLABLE BOEGG -->
+      <map code="0xbd4b" name="1em"/><!-- HANGUL SYLLABLE BOEGS -->
+      <map code="0xbd4c" name="1em"/><!-- HANGUL SYLLABLE BOEN -->
+      <map code="0xbd4d" name="1em"/><!-- HANGUL SYLLABLE BOENJ -->
+      <map code="0xbd4e" name="1em"/><!-- HANGUL SYLLABLE BOENH -->
+      <map code="0xbd4f" name="1em"/><!-- HANGUL SYLLABLE BOED -->
+      <map code="0xbd50" name="1em"/><!-- HANGUL SYLLABLE BOEL -->
+      <map code="0xbd51" name="1em"/><!-- HANGUL SYLLABLE BOELG -->
+      <map code="0xbd52" name="1em"/><!-- HANGUL SYLLABLE BOELM -->
+      <map code="0xbd53" name="1em"/><!-- HANGUL SYLLABLE BOELB -->
+      <map code="0xbd54" name="1em"/><!-- HANGUL SYLLABLE BOELS -->
+      <map code="0xbd55" name="1em"/><!-- HANGUL SYLLABLE BOELT -->
+      <map code="0xbd56" name="1em"/><!-- HANGUL SYLLABLE BOELP -->
+      <map code="0xbd57" name="1em"/><!-- HANGUL SYLLABLE BOELH -->
+      <map code="0xbd58" name="1em"/><!-- HANGUL SYLLABLE BOEM -->
+      <map code="0xbd59" name="1em"/><!-- HANGUL SYLLABLE BOEB -->
+      <map code="0xbd5a" name="1em"/><!-- HANGUL SYLLABLE BOEBS -->
+      <map code="0xbd5b" name="1em"/><!-- HANGUL SYLLABLE BOES -->
+      <map code="0xbd5c" name="1em"/><!-- HANGUL SYLLABLE BOESS -->
+      <map code="0xbd5d" name="1em"/><!-- HANGUL SYLLABLE BOENG -->
+      <map code="0xbd5e" name="1em"/><!-- HANGUL SYLLABLE BOEJ -->
+      <map code="0xbd5f" name="1em"/><!-- HANGUL SYLLABLE BOEC -->
+      <map code="0xbd60" name="1em"/><!-- HANGUL SYLLABLE BOEK -->
+      <map code="0xbd61" name="1em"/><!-- HANGUL SYLLABLE BOET -->
+      <map code="0xbd62" name="1em"/><!-- HANGUL SYLLABLE BOEP -->
+      <map code="0xbd63" name="1em"/><!-- HANGUL SYLLABLE BOEH -->
+      <map code="0xbd64" name="1em"/><!-- HANGUL SYLLABLE BYO -->
+      <map code="0xbd65" name="1em"/><!-- HANGUL SYLLABLE BYOG -->
+      <map code="0xbd66" name="1em"/><!-- HANGUL SYLLABLE BYOGG -->
+      <map code="0xbd67" name="1em"/><!-- HANGUL SYLLABLE BYOGS -->
+      <map code="0xbd68" name="1em"/><!-- HANGUL SYLLABLE BYON -->
+      <map code="0xbd69" name="1em"/><!-- HANGUL SYLLABLE BYONJ -->
+      <map code="0xbd6a" name="1em"/><!-- HANGUL SYLLABLE BYONH -->
+      <map code="0xbd6b" name="1em"/><!-- HANGUL SYLLABLE BYOD -->
+      <map code="0xbd6c" name="1em"/><!-- HANGUL SYLLABLE BYOL -->
+      <map code="0xbd6d" name="1em"/><!-- HANGUL SYLLABLE BYOLG -->
+      <map code="0xbd6e" name="1em"/><!-- HANGUL SYLLABLE BYOLM -->
+      <map code="0xbd6f" name="1em"/><!-- HANGUL SYLLABLE BYOLB -->
+      <map code="0xbd70" name="1em"/><!-- HANGUL SYLLABLE BYOLS -->
+      <map code="0xbd71" name="1em"/><!-- HANGUL SYLLABLE BYOLT -->
+      <map code="0xbd72" name="1em"/><!-- HANGUL SYLLABLE BYOLP -->
+      <map code="0xbd73" name="1em"/><!-- HANGUL SYLLABLE BYOLH -->
+      <map code="0xbd74" name="1em"/><!-- HANGUL SYLLABLE BYOM -->
+      <map code="0xbd75" name="1em"/><!-- HANGUL SYLLABLE BYOB -->
+      <map code="0xbd76" name="1em"/><!-- HANGUL SYLLABLE BYOBS -->
+      <map code="0xbd77" name="1em"/><!-- HANGUL SYLLABLE BYOS -->
+      <map code="0xbd78" name="1em"/><!-- HANGUL SYLLABLE BYOSS -->
+      <map code="0xbd79" name="1em"/><!-- HANGUL SYLLABLE BYONG -->
+      <map code="0xbd7a" name="1em"/><!-- HANGUL SYLLABLE BYOJ -->
+      <map code="0xbd7b" name="1em"/><!-- HANGUL SYLLABLE BYOC -->
+      <map code="0xbd7c" name="1em"/><!-- HANGUL SYLLABLE BYOK -->
+      <map code="0xbd7d" name="1em"/><!-- HANGUL SYLLABLE BYOT -->
+      <map code="0xbd7e" name="1em"/><!-- HANGUL SYLLABLE BYOP -->
+      <map code="0xbd7f" name="1em"/><!-- HANGUL SYLLABLE BYOH -->
+      <map code="0xbd80" name="1em"/><!-- HANGUL SYLLABLE BU -->
+      <map code="0xbd81" name="1em"/><!-- HANGUL SYLLABLE BUG -->
+      <map code="0xbd82" name="1em"/><!-- HANGUL SYLLABLE BUGG -->
+      <map code="0xbd83" name="1em"/><!-- HANGUL SYLLABLE BUGS -->
+      <map code="0xbd84" name="1em"/><!-- HANGUL SYLLABLE BUN -->
+      <map code="0xbd85" name="1em"/><!-- HANGUL SYLLABLE BUNJ -->
+      <map code="0xbd86" name="1em"/><!-- HANGUL SYLLABLE BUNH -->
+      <map code="0xbd87" name="1em"/><!-- HANGUL SYLLABLE BUD -->
+      <map code="0xbd88" name="1em"/><!-- HANGUL SYLLABLE BUL -->
+      <map code="0xbd89" name="1em"/><!-- HANGUL SYLLABLE BULG -->
+      <map code="0xbd8a" name="1em"/><!-- HANGUL SYLLABLE BULM -->
+      <map code="0xbd8b" name="1em"/><!-- HANGUL SYLLABLE BULB -->
+      <map code="0xbd8c" name="1em"/><!-- HANGUL SYLLABLE BULS -->
+      <map code="0xbd8d" name="1em"/><!-- HANGUL SYLLABLE BULT -->
+      <map code="0xbd8e" name="1em"/><!-- HANGUL SYLLABLE BULP -->
+      <map code="0xbd8f" name="1em"/><!-- HANGUL SYLLABLE BULH -->
+      <map code="0xbd90" name="1em"/><!-- HANGUL SYLLABLE BUM -->
+      <map code="0xbd91" name="1em"/><!-- HANGUL SYLLABLE BUB -->
+      <map code="0xbd92" name="1em"/><!-- HANGUL SYLLABLE BUBS -->
+      <map code="0xbd93" name="1em"/><!-- HANGUL SYLLABLE BUS -->
+      <map code="0xbd94" name="1em"/><!-- HANGUL SYLLABLE BUSS -->
+      <map code="0xbd95" name="1em"/><!-- HANGUL SYLLABLE BUNG -->
+      <map code="0xbd96" name="1em"/><!-- HANGUL SYLLABLE BUJ -->
+      <map code="0xbd97" name="1em"/><!-- HANGUL SYLLABLE BUC -->
+      <map code="0xbd98" name="1em"/><!-- HANGUL SYLLABLE BUK -->
+      <map code="0xbd99" name="1em"/><!-- HANGUL SYLLABLE BUT -->
+      <map code="0xbd9a" name="1em"/><!-- HANGUL SYLLABLE BUP -->
+      <map code="0xbd9b" name="1em"/><!-- HANGUL SYLLABLE BUH -->
+      <map code="0xbd9c" name="1em"/><!-- HANGUL SYLLABLE BWEO -->
+      <map code="0xbd9d" name="1em"/><!-- HANGUL SYLLABLE BWEOG -->
+      <map code="0xbd9e" name="1em"/><!-- HANGUL SYLLABLE BWEOGG -->
+      <map code="0xbd9f" name="1em"/><!-- HANGUL SYLLABLE BWEOGS -->
+      <map code="0xbda0" name="1em"/><!-- HANGUL SYLLABLE BWEON -->
+      <map code="0xbda1" name="1em"/><!-- HANGUL SYLLABLE BWEONJ -->
+      <map code="0xbda2" name="1em"/><!-- HANGUL SYLLABLE BWEONH -->
+      <map code="0xbda3" name="1em"/><!-- HANGUL SYLLABLE BWEOD -->
+      <map code="0xbda4" name="1em"/><!-- HANGUL SYLLABLE BWEOL -->
+      <map code="0xbda5" name="1em"/><!-- HANGUL SYLLABLE BWEOLG -->
+      <map code="0xbda6" name="1em"/><!-- HANGUL SYLLABLE BWEOLM -->
+      <map code="0xbda7" name="1em"/><!-- HANGUL SYLLABLE BWEOLB -->
+      <map code="0xbda8" name="1em"/><!-- HANGUL SYLLABLE BWEOLS -->
+      <map code="0xbda9" name="1em"/><!-- HANGUL SYLLABLE BWEOLT -->
+      <map code="0xbdaa" name="1em"/><!-- HANGUL SYLLABLE BWEOLP -->
+      <map code="0xbdab" name="1em"/><!-- HANGUL SYLLABLE BWEOLH -->
+      <map code="0xbdac" name="1em"/><!-- HANGUL SYLLABLE BWEOM -->
+      <map code="0xbdad" name="1em"/><!-- HANGUL SYLLABLE BWEOB -->
+      <map code="0xbdae" name="1em"/><!-- HANGUL SYLLABLE BWEOBS -->
+      <map code="0xbdaf" name="1em"/><!-- HANGUL SYLLABLE BWEOS -->
+      <map code="0xbdb0" name="1em"/><!-- HANGUL SYLLABLE BWEOSS -->
+      <map code="0xbdb1" name="1em"/><!-- HANGUL SYLLABLE BWEONG -->
+      <map code="0xbdb2" name="1em"/><!-- HANGUL SYLLABLE BWEOJ -->
+      <map code="0xbdb3" name="1em"/><!-- HANGUL SYLLABLE BWEOC -->
+      <map code="0xbdb4" name="1em"/><!-- HANGUL SYLLABLE BWEOK -->
+      <map code="0xbdb5" name="1em"/><!-- HANGUL SYLLABLE BWEOT -->
+      <map code="0xbdb6" name="1em"/><!-- HANGUL SYLLABLE BWEOP -->
+      <map code="0xbdb7" name="1em"/><!-- HANGUL SYLLABLE BWEOH -->
+      <map code="0xbdb8" name="1em"/><!-- HANGUL SYLLABLE BWE -->
+      <map code="0xbdb9" name="1em"/><!-- HANGUL SYLLABLE BWEG -->
+      <map code="0xbdba" name="1em"/><!-- HANGUL SYLLABLE BWEGG -->
+      <map code="0xbdbb" name="1em"/><!-- HANGUL SYLLABLE BWEGS -->
+      <map code="0xbdbc" name="1em"/><!-- HANGUL SYLLABLE BWEN -->
+      <map code="0xbdbd" name="1em"/><!-- HANGUL SYLLABLE BWENJ -->
+      <map code="0xbdbe" name="1em"/><!-- HANGUL SYLLABLE BWENH -->
+      <map code="0xbdbf" name="1em"/><!-- HANGUL SYLLABLE BWED -->
+      <map code="0xbdc0" name="1em"/><!-- HANGUL SYLLABLE BWEL -->
+      <map code="0xbdc1" name="1em"/><!-- HANGUL SYLLABLE BWELG -->
+      <map code="0xbdc2" name="1em"/><!-- HANGUL SYLLABLE BWELM -->
+      <map code="0xbdc3" name="1em"/><!-- HANGUL SYLLABLE BWELB -->
+      <map code="0xbdc4" name="1em"/><!-- HANGUL SYLLABLE BWELS -->
+      <map code="0xbdc5" name="1em"/><!-- HANGUL SYLLABLE BWELT -->
+      <map code="0xbdc6" name="1em"/><!-- HANGUL SYLLABLE BWELP -->
+      <map code="0xbdc7" name="1em"/><!-- HANGUL SYLLABLE BWELH -->
+      <map code="0xbdc8" name="1em"/><!-- HANGUL SYLLABLE BWEM -->
+      <map code="0xbdc9" name="1em"/><!-- HANGUL SYLLABLE BWEB -->
+      <map code="0xbdca" name="1em"/><!-- HANGUL SYLLABLE BWEBS -->
+      <map code="0xbdcb" name="1em"/><!-- HANGUL SYLLABLE BWES -->
+      <map code="0xbdcc" name="1em"/><!-- HANGUL SYLLABLE BWESS -->
+      <map code="0xbdcd" name="1em"/><!-- HANGUL SYLLABLE BWENG -->
+      <map code="0xbdce" name="1em"/><!-- HANGUL SYLLABLE BWEJ -->
+      <map code="0xbdcf" name="1em"/><!-- HANGUL SYLLABLE BWEC -->
+      <map code="0xbdd0" name="1em"/><!-- HANGUL SYLLABLE BWEK -->
+      <map code="0xbdd1" name="1em"/><!-- HANGUL SYLLABLE BWET -->
+      <map code="0xbdd2" name="1em"/><!-- HANGUL SYLLABLE BWEP -->
+      <map code="0xbdd3" name="1em"/><!-- HANGUL SYLLABLE BWEH -->
+      <map code="0xbdd4" name="1em"/><!-- HANGUL SYLLABLE BWI -->
+      <map code="0xbdd5" name="1em"/><!-- HANGUL SYLLABLE BWIG -->
+      <map code="0xbdd6" name="1em"/><!-- HANGUL SYLLABLE BWIGG -->
+      <map code="0xbdd7" name="1em"/><!-- HANGUL SYLLABLE BWIGS -->
+      <map code="0xbdd8" name="1em"/><!-- HANGUL SYLLABLE BWIN -->
+      <map code="0xbdd9" name="1em"/><!-- HANGUL SYLLABLE BWINJ -->
+      <map code="0xbdda" name="1em"/><!-- HANGUL SYLLABLE BWINH -->
+      <map code="0xbddb" name="1em"/><!-- HANGUL SYLLABLE BWID -->
+      <map code="0xbddc" name="1em"/><!-- HANGUL SYLLABLE BWIL -->
+      <map code="0xbddd" name="1em"/><!-- HANGUL SYLLABLE BWILG -->
+      <map code="0xbdde" name="1em"/><!-- HANGUL SYLLABLE BWILM -->
+      <map code="0xbddf" name="1em"/><!-- HANGUL SYLLABLE BWILB -->
+      <map code="0xbde0" name="1em"/><!-- HANGUL SYLLABLE BWILS -->
+      <map code="0xbde1" name="1em"/><!-- HANGUL SYLLABLE BWILT -->
+      <map code="0xbde2" name="1em"/><!-- HANGUL SYLLABLE BWILP -->
+      <map code="0xbde3" name="1em"/><!-- HANGUL SYLLABLE BWILH -->
+      <map code="0xbde4" name="1em"/><!-- HANGUL SYLLABLE BWIM -->
+      <map code="0xbde5" name="1em"/><!-- HANGUL SYLLABLE BWIB -->
+      <map code="0xbde6" name="1em"/><!-- HANGUL SYLLABLE BWIBS -->
+      <map code="0xbde7" name="1em"/><!-- HANGUL SYLLABLE BWIS -->
+      <map code="0xbde8" name="1em"/><!-- HANGUL SYLLABLE BWISS -->
+      <map code="0xbde9" name="1em"/><!-- HANGUL SYLLABLE BWING -->
+      <map code="0xbdea" name="1em"/><!-- HANGUL SYLLABLE BWIJ -->
+      <map code="0xbdeb" name="1em"/><!-- HANGUL SYLLABLE BWIC -->
+      <map code="0xbdec" name="1em"/><!-- HANGUL SYLLABLE BWIK -->
+      <map code="0xbded" name="1em"/><!-- HANGUL SYLLABLE BWIT -->
+      <map code="0xbdee" name="1em"/><!-- HANGUL SYLLABLE BWIP -->
+      <map code="0xbdef" name="1em"/><!-- HANGUL SYLLABLE BWIH -->
+      <map code="0xbdf0" name="1em"/><!-- HANGUL SYLLABLE BYU -->
+      <map code="0xbdf1" name="1em"/><!-- HANGUL SYLLABLE BYUG -->
+      <map code="0xbdf2" name="1em"/><!-- HANGUL SYLLABLE BYUGG -->
+      <map code="0xbdf3" name="1em"/><!-- HANGUL SYLLABLE BYUGS -->
+      <map code="0xbdf4" name="1em"/><!-- HANGUL SYLLABLE BYUN -->
+      <map code="0xbdf5" name="1em"/><!-- HANGUL SYLLABLE BYUNJ -->
+      <map code="0xbdf6" name="1em"/><!-- HANGUL SYLLABLE BYUNH -->
+      <map code="0xbdf7" name="1em"/><!-- HANGUL SYLLABLE BYUD -->
+      <map code="0xbdf8" name="1em"/><!-- HANGUL SYLLABLE BYUL -->
+      <map code="0xbdf9" name="1em"/><!-- HANGUL SYLLABLE BYULG -->
+      <map code="0xbdfa" name="1em"/><!-- HANGUL SYLLABLE BYULM -->
+      <map code="0xbdfb" name="1em"/><!-- HANGUL SYLLABLE BYULB -->
+      <map code="0xbdfc" name="1em"/><!-- HANGUL SYLLABLE BYULS -->
+      <map code="0xbdfd" name="1em"/><!-- HANGUL SYLLABLE BYULT -->
+      <map code="0xbdfe" name="1em"/><!-- HANGUL SYLLABLE BYULP -->
+      <map code="0xbdff" name="1em"/><!-- HANGUL SYLLABLE BYULH -->
+      <map code="0xbe00" name="1em"/><!-- HANGUL SYLLABLE BYUM -->
+      <map code="0xbe01" name="1em"/><!-- HANGUL SYLLABLE BYUB -->
+      <map code="0xbe02" name="1em"/><!-- HANGUL SYLLABLE BYUBS -->
+      <map code="0xbe03" name="1em"/><!-- HANGUL SYLLABLE BYUS -->
+      <map code="0xbe04" name="1em"/><!-- HANGUL SYLLABLE BYUSS -->
+      <map code="0xbe05" name="1em"/><!-- HANGUL SYLLABLE BYUNG -->
+      <map code="0xbe06" name="1em"/><!-- HANGUL SYLLABLE BYUJ -->
+      <map code="0xbe07" name="1em"/><!-- HANGUL SYLLABLE BYUC -->
+      <map code="0xbe08" name="1em"/><!-- HANGUL SYLLABLE BYUK -->
+      <map code="0xbe09" name="1em"/><!-- HANGUL SYLLABLE BYUT -->
+      <map code="0xbe0a" name="1em"/><!-- HANGUL SYLLABLE BYUP -->
+      <map code="0xbe0b" name="1em"/><!-- HANGUL SYLLABLE BYUH -->
+      <map code="0xbe0c" name="1em"/><!-- HANGUL SYLLABLE BEU -->
+      <map code="0xbe0d" name="1em"/><!-- HANGUL SYLLABLE BEUG -->
+      <map code="0xbe0e" name="1em"/><!-- HANGUL SYLLABLE BEUGG -->
+      <map code="0xbe0f" name="1em"/><!-- HANGUL SYLLABLE BEUGS -->
+      <map code="0xbe10" name="1em"/><!-- HANGUL SYLLABLE BEUN -->
+      <map code="0xbe11" name="1em"/><!-- HANGUL SYLLABLE BEUNJ -->
+      <map code="0xbe12" name="1em"/><!-- HANGUL SYLLABLE BEUNH -->
+      <map code="0xbe13" name="1em"/><!-- HANGUL SYLLABLE BEUD -->
+      <map code="0xbe14" name="1em"/><!-- HANGUL SYLLABLE BEUL -->
+      <map code="0xbe15" name="1em"/><!-- HANGUL SYLLABLE BEULG -->
+      <map code="0xbe16" name="1em"/><!-- HANGUL SYLLABLE BEULM -->
+      <map code="0xbe17" name="1em"/><!-- HANGUL SYLLABLE BEULB -->
+      <map code="0xbe18" name="1em"/><!-- HANGUL SYLLABLE BEULS -->
+      <map code="0xbe19" name="1em"/><!-- HANGUL SYLLABLE BEULT -->
+      <map code="0xbe1a" name="1em"/><!-- HANGUL SYLLABLE BEULP -->
+      <map code="0xbe1b" name="1em"/><!-- HANGUL SYLLABLE BEULH -->
+      <map code="0xbe1c" name="1em"/><!-- HANGUL SYLLABLE BEUM -->
+      <map code="0xbe1d" name="1em"/><!-- HANGUL SYLLABLE BEUB -->
+      <map code="0xbe1e" name="1em"/><!-- HANGUL SYLLABLE BEUBS -->
+      <map code="0xbe1f" name="1em"/><!-- HANGUL SYLLABLE BEUS -->
+      <map code="0xbe20" name="1em"/><!-- HANGUL SYLLABLE BEUSS -->
+      <map code="0xbe21" name="1em"/><!-- HANGUL SYLLABLE BEUNG -->
+      <map code="0xbe22" name="1em"/><!-- HANGUL SYLLABLE BEUJ -->
+      <map code="0xbe23" name="1em"/><!-- HANGUL SYLLABLE BEUC -->
+      <map code="0xbe24" name="1em"/><!-- HANGUL SYLLABLE BEUK -->
+      <map code="0xbe25" name="1em"/><!-- HANGUL SYLLABLE BEUT -->
+      <map code="0xbe26" name="1em"/><!-- HANGUL SYLLABLE BEUP -->
+      <map code="0xbe27" name="1em"/><!-- HANGUL SYLLABLE BEUH -->
+      <map code="0xbe28" name="1em"/><!-- HANGUL SYLLABLE BYI -->
+      <map code="0xbe29" name="1em"/><!-- HANGUL SYLLABLE BYIG -->
+      <map code="0xbe2a" name="1em"/><!-- HANGUL SYLLABLE BYIGG -->
+      <map code="0xbe2b" name="1em"/><!-- HANGUL SYLLABLE BYIGS -->
+      <map code="0xbe2c" name="1em"/><!-- HANGUL SYLLABLE BYIN -->
+      <map code="0xbe2d" name="1em"/><!-- HANGUL SYLLABLE BYINJ -->
+      <map code="0xbe2e" name="1em"/><!-- HANGUL SYLLABLE BYINH -->
+      <map code="0xbe2f" name="1em"/><!-- HANGUL SYLLABLE BYID -->
+      <map code="0xbe30" name="1em"/><!-- HANGUL SYLLABLE BYIL -->
+      <map code="0xbe31" name="1em"/><!-- HANGUL SYLLABLE BYILG -->
+      <map code="0xbe32" name="1em"/><!-- HANGUL SYLLABLE BYILM -->
+      <map code="0xbe33" name="1em"/><!-- HANGUL SYLLABLE BYILB -->
+      <map code="0xbe34" name="1em"/><!-- HANGUL SYLLABLE BYILS -->
+      <map code="0xbe35" name="1em"/><!-- HANGUL SYLLABLE BYILT -->
+      <map code="0xbe36" name="1em"/><!-- HANGUL SYLLABLE BYILP -->
+      <map code="0xbe37" name="1em"/><!-- HANGUL SYLLABLE BYILH -->
+      <map code="0xbe38" name="1em"/><!-- HANGUL SYLLABLE BYIM -->
+      <map code="0xbe39" name="1em"/><!-- HANGUL SYLLABLE BYIB -->
+      <map code="0xbe3a" name="1em"/><!-- HANGUL SYLLABLE BYIBS -->
+      <map code="0xbe3b" name="1em"/><!-- HANGUL SYLLABLE BYIS -->
+      <map code="0xbe3c" name="1em"/><!-- HANGUL SYLLABLE BYISS -->
+      <map code="0xbe3d" name="1em"/><!-- HANGUL SYLLABLE BYING -->
+      <map code="0xbe3e" name="1em"/><!-- HANGUL SYLLABLE BYIJ -->
+      <map code="0xbe3f" name="1em"/><!-- HANGUL SYLLABLE BYIC -->
+      <map code="0xbe40" name="1em"/><!-- HANGUL SYLLABLE BYIK -->
+      <map code="0xbe41" name="1em"/><!-- HANGUL SYLLABLE BYIT -->
+      <map code="0xbe42" name="1em"/><!-- HANGUL SYLLABLE BYIP -->
+      <map code="0xbe43" name="1em"/><!-- HANGUL SYLLABLE BYIH -->
+      <map code="0xbe44" name="1em"/><!-- HANGUL SYLLABLE BI -->
+      <map code="0xbe45" name="1em"/><!-- HANGUL SYLLABLE BIG -->
+      <map code="0xbe46" name="1em"/><!-- HANGUL SYLLABLE BIGG -->
+      <map code="0xbe47" name="1em"/><!-- HANGUL SYLLABLE BIGS -->
+      <map code="0xbe48" name="1em"/><!-- HANGUL SYLLABLE BIN -->
+      <map code="0xbe49" name="1em"/><!-- HANGUL SYLLABLE BINJ -->
+      <map code="0xbe4a" name="1em"/><!-- HANGUL SYLLABLE BINH -->
+      <map code="0xbe4b" name="1em"/><!-- HANGUL SYLLABLE BID -->
+      <map code="0xbe4c" name="1em"/><!-- HANGUL SYLLABLE BIL -->
+      <map code="0xbe4d" name="1em"/><!-- HANGUL SYLLABLE BILG -->
+      <map code="0xbe4e" name="1em"/><!-- HANGUL SYLLABLE BILM -->
+      <map code="0xbe4f" name="1em"/><!-- HANGUL SYLLABLE BILB -->
+      <map code="0xbe50" name="1em"/><!-- HANGUL SYLLABLE BILS -->
+      <map code="0xbe51" name="1em"/><!-- HANGUL SYLLABLE BILT -->
+      <map code="0xbe52" name="1em"/><!-- HANGUL SYLLABLE BILP -->
+      <map code="0xbe53" name="1em"/><!-- HANGUL SYLLABLE BILH -->
+      <map code="0xbe54" name="1em"/><!-- HANGUL SYLLABLE BIM -->
+      <map code="0xbe55" name="1em"/><!-- HANGUL SYLLABLE BIB -->
+      <map code="0xbe56" name="1em"/><!-- HANGUL SYLLABLE BIBS -->
+      <map code="0xbe57" name="1em"/><!-- HANGUL SYLLABLE BIS -->
+      <map code="0xbe58" name="1em"/><!-- HANGUL SYLLABLE BISS -->
+      <map code="0xbe59" name="1em"/><!-- HANGUL SYLLABLE BING -->
+      <map code="0xbe5a" name="1em"/><!-- HANGUL SYLLABLE BIJ -->
+      <map code="0xbe5b" name="1em"/><!-- HANGUL SYLLABLE BIC -->
+      <map code="0xbe5c" name="1em"/><!-- HANGUL SYLLABLE BIK -->
+      <map code="0xbe5d" name="1em"/><!-- HANGUL SYLLABLE BIT -->
+      <map code="0xbe5e" name="1em"/><!-- HANGUL SYLLABLE BIP -->
+      <map code="0xbe5f" name="1em"/><!-- HANGUL SYLLABLE BIH -->
+      <map code="0xbe60" name="1em"/><!-- HANGUL SYLLABLE BBA -->
+      <map code="0xbe61" name="1em"/><!-- HANGUL SYLLABLE BBAG -->
+      <map code="0xbe62" name="1em"/><!-- HANGUL SYLLABLE BBAGG -->
+      <map code="0xbe63" name="1em"/><!-- HANGUL SYLLABLE BBAGS -->
+      <map code="0xbe64" name="1em"/><!-- HANGUL SYLLABLE BBAN -->
+      <map code="0xbe65" name="1em"/><!-- HANGUL SYLLABLE BBANJ -->
+      <map code="0xbe66" name="1em"/><!-- HANGUL SYLLABLE BBANH -->
+      <map code="0xbe67" name="1em"/><!-- HANGUL SYLLABLE BBAD -->
+      <map code="0xbe68" name="1em"/><!-- HANGUL SYLLABLE BBAL -->
+      <map code="0xbe69" name="1em"/><!-- HANGUL SYLLABLE BBALG -->
+      <map code="0xbe6a" name="1em"/><!-- HANGUL SYLLABLE BBALM -->
+      <map code="0xbe6b" name="1em"/><!-- HANGUL SYLLABLE BBALB -->
+      <map code="0xbe6c" name="1em"/><!-- HANGUL SYLLABLE BBALS -->
+      <map code="0xbe6d" name="1em"/><!-- HANGUL SYLLABLE BBALT -->
+      <map code="0xbe6e" name="1em"/><!-- HANGUL SYLLABLE BBALP -->
+      <map code="0xbe6f" name="1em"/><!-- HANGUL SYLLABLE BBALH -->
+      <map code="0xbe70" name="1em"/><!-- HANGUL SYLLABLE BBAM -->
+      <map code="0xbe71" name="1em"/><!-- HANGUL SYLLABLE BBAB -->
+      <map code="0xbe72" name="1em"/><!-- HANGUL SYLLABLE BBABS -->
+      <map code="0xbe73" name="1em"/><!-- HANGUL SYLLABLE BBAS -->
+      <map code="0xbe74" name="1em"/><!-- HANGUL SYLLABLE BBASS -->
+      <map code="0xbe75" name="1em"/><!-- HANGUL SYLLABLE BBANG -->
+      <map code="0xbe76" name="1em"/><!-- HANGUL SYLLABLE BBAJ -->
+      <map code="0xbe77" name="1em"/><!-- HANGUL SYLLABLE BBAC -->
+      <map code="0xbe78" name="1em"/><!-- HANGUL SYLLABLE BBAK -->
+      <map code="0xbe79" name="1em"/><!-- HANGUL SYLLABLE BBAT -->
+      <map code="0xbe7a" name="1em"/><!-- HANGUL SYLLABLE BBAP -->
+      <map code="0xbe7b" name="1em"/><!-- HANGUL SYLLABLE BBAH -->
+      <map code="0xbe7c" name="1em"/><!-- HANGUL SYLLABLE BBAE -->
+      <map code="0xbe7d" name="1em"/><!-- HANGUL SYLLABLE BBAEG -->
+      <map code="0xbe7e" name="1em"/><!-- HANGUL SYLLABLE BBAEGG -->
+      <map code="0xbe7f" name="1em"/><!-- HANGUL SYLLABLE BBAEGS -->
+      <map code="0xbe80" name="1em"/><!-- HANGUL SYLLABLE BBAEN -->
+      <map code="0xbe81" name="1em"/><!-- HANGUL SYLLABLE BBAENJ -->
+      <map code="0xbe82" name="1em"/><!-- HANGUL SYLLABLE BBAENH -->
+      <map code="0xbe83" name="1em"/><!-- HANGUL SYLLABLE BBAED -->
+      <map code="0xbe84" name="1em"/><!-- HANGUL SYLLABLE BBAEL -->
+      <map code="0xbe85" name="1em"/><!-- HANGUL SYLLABLE BBAELG -->
+      <map code="0xbe86" name="1em"/><!-- HANGUL SYLLABLE BBAELM -->
+      <map code="0xbe87" name="1em"/><!-- HANGUL SYLLABLE BBAELB -->
+      <map code="0xbe88" name="1em"/><!-- HANGUL SYLLABLE BBAELS -->
+      <map code="0xbe89" name="1em"/><!-- HANGUL SYLLABLE BBAELT -->
+      <map code="0xbe8a" name="1em"/><!-- HANGUL SYLLABLE BBAELP -->
+      <map code="0xbe8b" name="1em"/><!-- HANGUL SYLLABLE BBAELH -->
+      <map code="0xbe8c" name="1em"/><!-- HANGUL SYLLABLE BBAEM -->
+      <map code="0xbe8d" name="1em"/><!-- HANGUL SYLLABLE BBAEB -->
+      <map code="0xbe8e" name="1em"/><!-- HANGUL SYLLABLE BBAEBS -->
+      <map code="0xbe8f" name="1em"/><!-- HANGUL SYLLABLE BBAES -->
+      <map code="0xbe90" name="1em"/><!-- HANGUL SYLLABLE BBAESS -->
+      <map code="0xbe91" name="1em"/><!-- HANGUL SYLLABLE BBAENG -->
+      <map code="0xbe92" name="1em"/><!-- HANGUL SYLLABLE BBAEJ -->
+      <map code="0xbe93" name="1em"/><!-- HANGUL SYLLABLE BBAEC -->
+      <map code="0xbe94" name="1em"/><!-- HANGUL SYLLABLE BBAEK -->
+      <map code="0xbe95" name="1em"/><!-- HANGUL SYLLABLE BBAET -->
+      <map code="0xbe96" name="1em"/><!-- HANGUL SYLLABLE BBAEP -->
+      <map code="0xbe97" name="1em"/><!-- HANGUL SYLLABLE BBAEH -->
+      <map code="0xbe98" name="1em"/><!-- HANGUL SYLLABLE BBYA -->
+      <map code="0xbe99" name="1em"/><!-- HANGUL SYLLABLE BBYAG -->
+      <map code="0xbe9a" name="1em"/><!-- HANGUL SYLLABLE BBYAGG -->
+      <map code="0xbe9b" name="1em"/><!-- HANGUL SYLLABLE BBYAGS -->
+      <map code="0xbe9c" name="1em"/><!-- HANGUL SYLLABLE BBYAN -->
+      <map code="0xbe9d" name="1em"/><!-- HANGUL SYLLABLE BBYANJ -->
+      <map code="0xbe9e" name="1em"/><!-- HANGUL SYLLABLE BBYANH -->
+      <map code="0xbe9f" name="1em"/><!-- HANGUL SYLLABLE BBYAD -->
+      <map code="0xbea0" name="1em"/><!-- HANGUL SYLLABLE BBYAL -->
+      <map code="0xbea1" name="1em"/><!-- HANGUL SYLLABLE BBYALG -->
+      <map code="0xbea2" name="1em"/><!-- HANGUL SYLLABLE BBYALM -->
+      <map code="0xbea3" name="1em"/><!-- HANGUL SYLLABLE BBYALB -->
+      <map code="0xbea4" name="1em"/><!-- HANGUL SYLLABLE BBYALS -->
+      <map code="0xbea5" name="1em"/><!-- HANGUL SYLLABLE BBYALT -->
+      <map code="0xbea6" name="1em"/><!-- HANGUL SYLLABLE BBYALP -->
+      <map code="0xbea7" name="1em"/><!-- HANGUL SYLLABLE BBYALH -->
+      <map code="0xbea8" name="1em"/><!-- HANGUL SYLLABLE BBYAM -->
+      <map code="0xbea9" name="1em"/><!-- HANGUL SYLLABLE BBYAB -->
+      <map code="0xbeaa" name="1em"/><!-- HANGUL SYLLABLE BBYABS -->
+      <map code="0xbeab" name="1em"/><!-- HANGUL SYLLABLE BBYAS -->
+      <map code="0xbeac" name="1em"/><!-- HANGUL SYLLABLE BBYASS -->
+      <map code="0xbead" name="1em"/><!-- HANGUL SYLLABLE BBYANG -->
+      <map code="0xbeae" name="1em"/><!-- HANGUL SYLLABLE BBYAJ -->
+      <map code="0xbeaf" name="1em"/><!-- HANGUL SYLLABLE BBYAC -->
+      <map code="0xbeb0" name="1em"/><!-- HANGUL SYLLABLE BBYAK -->
+      <map code="0xbeb1" name="1em"/><!-- HANGUL SYLLABLE BBYAT -->
+      <map code="0xbeb2" name="1em"/><!-- HANGUL SYLLABLE BBYAP -->
+      <map code="0xbeb3" name="1em"/><!-- HANGUL SYLLABLE BBYAH -->
+      <map code="0xbeb4" name="1em"/><!-- HANGUL SYLLABLE BBYAE -->
+      <map code="0xbeb5" name="1em"/><!-- HANGUL SYLLABLE BBYAEG -->
+      <map code="0xbeb6" name="1em"/><!-- HANGUL SYLLABLE BBYAEGG -->
+      <map code="0xbeb7" name="1em"/><!-- HANGUL SYLLABLE BBYAEGS -->
+      <map code="0xbeb8" name="1em"/><!-- HANGUL SYLLABLE BBYAEN -->
+      <map code="0xbeb9" name="1em"/><!-- HANGUL SYLLABLE BBYAENJ -->
+      <map code="0xbeba" name="1em"/><!-- HANGUL SYLLABLE BBYAENH -->
+      <map code="0xbebb" name="1em"/><!-- HANGUL SYLLABLE BBYAED -->
+      <map code="0xbebc" name="1em"/><!-- HANGUL SYLLABLE BBYAEL -->
+      <map code="0xbebd" name="1em"/><!-- HANGUL SYLLABLE BBYAELG -->
+      <map code="0xbebe" name="1em"/><!-- HANGUL SYLLABLE BBYAELM -->
+      <map code="0xbebf" name="1em"/><!-- HANGUL SYLLABLE BBYAELB -->
+      <map code="0xbec0" name="1em"/><!-- HANGUL SYLLABLE BBYAELS -->
+      <map code="0xbec1" name="1em"/><!-- HANGUL SYLLABLE BBYAELT -->
+      <map code="0xbec2" name="1em"/><!-- HANGUL SYLLABLE BBYAELP -->
+      <map code="0xbec3" name="1em"/><!-- HANGUL SYLLABLE BBYAELH -->
+      <map code="0xbec4" name="1em"/><!-- HANGUL SYLLABLE BBYAEM -->
+      <map code="0xbec5" name="1em"/><!-- HANGUL SYLLABLE BBYAEB -->
+      <map code="0xbec6" name="1em"/><!-- HANGUL SYLLABLE BBYAEBS -->
+      <map code="0xbec7" name="1em"/><!-- HANGUL SYLLABLE BBYAES -->
+      <map code="0xbec8" name="1em"/><!-- HANGUL SYLLABLE BBYAESS -->
+      <map code="0xbec9" name="1em"/><!-- HANGUL SYLLABLE BBYAENG -->
+      <map code="0xbeca" name="1em"/><!-- HANGUL SYLLABLE BBYAEJ -->
+      <map code="0xbecb" name="1em"/><!-- HANGUL SYLLABLE BBYAEC -->
+      <map code="0xbecc" name="1em"/><!-- HANGUL SYLLABLE BBYAEK -->
+      <map code="0xbecd" name="1em"/><!-- HANGUL SYLLABLE BBYAET -->
+      <map code="0xbece" name="1em"/><!-- HANGUL SYLLABLE BBYAEP -->
+      <map code="0xbecf" name="1em"/><!-- HANGUL SYLLABLE BBYAEH -->
+      <map code="0xbed0" name="1em"/><!-- HANGUL SYLLABLE BBEO -->
+      <map code="0xbed1" name="1em"/><!-- HANGUL SYLLABLE BBEOG -->
+      <map code="0xbed2" name="1em"/><!-- HANGUL SYLLABLE BBEOGG -->
+      <map code="0xbed3" name="1em"/><!-- HANGUL SYLLABLE BBEOGS -->
+      <map code="0xbed4" name="1em"/><!-- HANGUL SYLLABLE BBEON -->
+      <map code="0xbed5" name="1em"/><!-- HANGUL SYLLABLE BBEONJ -->
+      <map code="0xbed6" name="1em"/><!-- HANGUL SYLLABLE BBEONH -->
+      <map code="0xbed7" name="1em"/><!-- HANGUL SYLLABLE BBEOD -->
+      <map code="0xbed8" name="1em"/><!-- HANGUL SYLLABLE BBEOL -->
+      <map code="0xbed9" name="1em"/><!-- HANGUL SYLLABLE BBEOLG -->
+      <map code="0xbeda" name="1em"/><!-- HANGUL SYLLABLE BBEOLM -->
+      <map code="0xbedb" name="1em"/><!-- HANGUL SYLLABLE BBEOLB -->
+      <map code="0xbedc" name="1em"/><!-- HANGUL SYLLABLE BBEOLS -->
+      <map code="0xbedd" name="1em"/><!-- HANGUL SYLLABLE BBEOLT -->
+      <map code="0xbede" name="1em"/><!-- HANGUL SYLLABLE BBEOLP -->
+      <map code="0xbedf" name="1em"/><!-- HANGUL SYLLABLE BBEOLH -->
+      <map code="0xbee0" name="1em"/><!-- HANGUL SYLLABLE BBEOM -->
+      <map code="0xbee1" name="1em"/><!-- HANGUL SYLLABLE BBEOB -->
+      <map code="0xbee2" name="1em"/><!-- HANGUL SYLLABLE BBEOBS -->
+      <map code="0xbee3" name="1em"/><!-- HANGUL SYLLABLE BBEOS -->
+      <map code="0xbee4" name="1em"/><!-- HANGUL SYLLABLE BBEOSS -->
+      <map code="0xbee5" name="1em"/><!-- HANGUL SYLLABLE BBEONG -->
+      <map code="0xbee6" name="1em"/><!-- HANGUL SYLLABLE BBEOJ -->
+      <map code="0xbee7" name="1em"/><!-- HANGUL SYLLABLE BBEOC -->
+      <map code="0xbee8" name="1em"/><!-- HANGUL SYLLABLE BBEOK -->
+      <map code="0xbee9" name="1em"/><!-- HANGUL SYLLABLE BBEOT -->
+      <map code="0xbeea" name="1em"/><!-- HANGUL SYLLABLE BBEOP -->
+      <map code="0xbeeb" name="1em"/><!-- HANGUL SYLLABLE BBEOH -->
+      <map code="0xbeec" name="1em"/><!-- HANGUL SYLLABLE BBE -->
+      <map code="0xbeed" name="1em"/><!-- HANGUL SYLLABLE BBEG -->
+      <map code="0xbeee" name="1em"/><!-- HANGUL SYLLABLE BBEGG -->
+      <map code="0xbeef" name="1em"/><!-- HANGUL SYLLABLE BBEGS -->
+      <map code="0xbef0" name="1em"/><!-- HANGUL SYLLABLE BBEN -->
+      <map code="0xbef1" name="1em"/><!-- HANGUL SYLLABLE BBENJ -->
+      <map code="0xbef2" name="1em"/><!-- HANGUL SYLLABLE BBENH -->
+      <map code="0xbef3" name="1em"/><!-- HANGUL SYLLABLE BBED -->
+      <map code="0xbef4" name="1em"/><!-- HANGUL SYLLABLE BBEL -->
+      <map code="0xbef5" name="1em"/><!-- HANGUL SYLLABLE BBELG -->
+      <map code="0xbef6" name="1em"/><!-- HANGUL SYLLABLE BBELM -->
+      <map code="0xbef7" name="1em"/><!-- HANGUL SYLLABLE BBELB -->
+      <map code="0xbef8" name="1em"/><!-- HANGUL SYLLABLE BBELS -->
+      <map code="0xbef9" name="1em"/><!-- HANGUL SYLLABLE BBELT -->
+      <map code="0xbefa" name="1em"/><!-- HANGUL SYLLABLE BBELP -->
+      <map code="0xbefb" name="1em"/><!-- HANGUL SYLLABLE BBELH -->
+      <map code="0xbefc" name="1em"/><!-- HANGUL SYLLABLE BBEM -->
+      <map code="0xbefd" name="1em"/><!-- HANGUL SYLLABLE BBEB -->
+      <map code="0xbefe" name="1em"/><!-- HANGUL SYLLABLE BBEBS -->
+      <map code="0xbeff" name="1em"/><!-- HANGUL SYLLABLE BBES -->
+      <map code="0xbf00" name="1em"/><!-- HANGUL SYLLABLE BBESS -->
+      <map code="0xbf01" name="1em"/><!-- HANGUL SYLLABLE BBENG -->
+      <map code="0xbf02" name="1em"/><!-- HANGUL SYLLABLE BBEJ -->
+      <map code="0xbf03" name="1em"/><!-- HANGUL SYLLABLE BBEC -->
+      <map code="0xbf04" name="1em"/><!-- HANGUL SYLLABLE BBEK -->
+      <map code="0xbf05" name="1em"/><!-- HANGUL SYLLABLE BBET -->
+      <map code="0xbf06" name="1em"/><!-- HANGUL SYLLABLE BBEP -->
+      <map code="0xbf07" name="1em"/><!-- HANGUL SYLLABLE BBEH -->
+      <map code="0xbf08" name="1em"/><!-- HANGUL SYLLABLE BBYEO -->
+      <map code="0xbf09" name="1em"/><!-- HANGUL SYLLABLE BBYEOG -->
+      <map code="0xbf0a" name="1em"/><!-- HANGUL SYLLABLE BBYEOGG -->
+      <map code="0xbf0b" name="1em"/><!-- HANGUL SYLLABLE BBYEOGS -->
+      <map code="0xbf0c" name="1em"/><!-- HANGUL SYLLABLE BBYEON -->
+      <map code="0xbf0d" name="1em"/><!-- HANGUL SYLLABLE BBYEONJ -->
+      <map code="0xbf0e" name="1em"/><!-- HANGUL SYLLABLE BBYEONH -->
+      <map code="0xbf0f" name="1em"/><!-- HANGUL SYLLABLE BBYEOD -->
+      <map code="0xbf10" name="1em"/><!-- HANGUL SYLLABLE BBYEOL -->
+      <map code="0xbf11" name="1em"/><!-- HANGUL SYLLABLE BBYEOLG -->
+      <map code="0xbf12" name="1em"/><!-- HANGUL SYLLABLE BBYEOLM -->
+      <map code="0xbf13" name="1em"/><!-- HANGUL SYLLABLE BBYEOLB -->
+      <map code="0xbf14" name="1em"/><!-- HANGUL SYLLABLE BBYEOLS -->
+      <map code="0xbf15" name="1em"/><!-- HANGUL SYLLABLE BBYEOLT -->
+      <map code="0xbf16" name="1em"/><!-- HANGUL SYLLABLE BBYEOLP -->
+      <map code="0xbf17" name="1em"/><!-- HANGUL SYLLABLE BBYEOLH -->
+      <map code="0xbf18" name="1em"/><!-- HANGUL SYLLABLE BBYEOM -->
+      <map code="0xbf19" name="1em"/><!-- HANGUL SYLLABLE BBYEOB -->
+      <map code="0xbf1a" name="1em"/><!-- HANGUL SYLLABLE BBYEOBS -->
+      <map code="0xbf1b" name="1em"/><!-- HANGUL SYLLABLE BBYEOS -->
+      <map code="0xbf1c" name="1em"/><!-- HANGUL SYLLABLE BBYEOSS -->
+      <map code="0xbf1d" name="1em"/><!-- HANGUL SYLLABLE BBYEONG -->
+      <map code="0xbf1e" name="1em"/><!-- HANGUL SYLLABLE BBYEOJ -->
+      <map code="0xbf1f" name="1em"/><!-- HANGUL SYLLABLE BBYEOC -->
+      <map code="0xbf20" name="1em"/><!-- HANGUL SYLLABLE BBYEOK -->
+      <map code="0xbf21" name="1em"/><!-- HANGUL SYLLABLE BBYEOT -->
+      <map code="0xbf22" name="1em"/><!-- HANGUL SYLLABLE BBYEOP -->
+      <map code="0xbf23" name="1em"/><!-- HANGUL SYLLABLE BBYEOH -->
+      <map code="0xbf24" name="1em"/><!-- HANGUL SYLLABLE BBYE -->
+      <map code="0xbf25" name="1em"/><!-- HANGUL SYLLABLE BBYEG -->
+      <map code="0xbf26" name="1em"/><!-- HANGUL SYLLABLE BBYEGG -->
+      <map code="0xbf27" name="1em"/><!-- HANGUL SYLLABLE BBYEGS -->
+      <map code="0xbf28" name="1em"/><!-- HANGUL SYLLABLE BBYEN -->
+      <map code="0xbf29" name="1em"/><!-- HANGUL SYLLABLE BBYENJ -->
+      <map code="0xbf2a" name="1em"/><!-- HANGUL SYLLABLE BBYENH -->
+      <map code="0xbf2b" name="1em"/><!-- HANGUL SYLLABLE BBYED -->
+      <map code="0xbf2c" name="1em"/><!-- HANGUL SYLLABLE BBYEL -->
+      <map code="0xbf2d" name="1em"/><!-- HANGUL SYLLABLE BBYELG -->
+      <map code="0xbf2e" name="1em"/><!-- HANGUL SYLLABLE BBYELM -->
+      <map code="0xbf2f" name="1em"/><!-- HANGUL SYLLABLE BBYELB -->
+      <map code="0xbf30" name="1em"/><!-- HANGUL SYLLABLE BBYELS -->
+      <map code="0xbf31" name="1em"/><!-- HANGUL SYLLABLE BBYELT -->
+      <map code="0xbf32" name="1em"/><!-- HANGUL SYLLABLE BBYELP -->
+      <map code="0xbf33" name="1em"/><!-- HANGUL SYLLABLE BBYELH -->
+      <map code="0xbf34" name="1em"/><!-- HANGUL SYLLABLE BBYEM -->
+      <map code="0xbf35" name="1em"/><!-- HANGUL SYLLABLE BBYEB -->
+      <map code="0xbf36" name="1em"/><!-- HANGUL SYLLABLE BBYEBS -->
+      <map code="0xbf37" name="1em"/><!-- HANGUL SYLLABLE BBYES -->
+      <map code="0xbf38" name="1em"/><!-- HANGUL SYLLABLE BBYESS -->
+      <map code="0xbf39" name="1em"/><!-- HANGUL SYLLABLE BBYENG -->
+      <map code="0xbf3a" name="1em"/><!-- HANGUL SYLLABLE BBYEJ -->
+      <map code="0xbf3b" name="1em"/><!-- HANGUL SYLLABLE BBYEC -->
+      <map code="0xbf3c" name="1em"/><!-- HANGUL SYLLABLE BBYEK -->
+      <map code="0xbf3d" name="1em"/><!-- HANGUL SYLLABLE BBYET -->
+      <map code="0xbf3e" name="1em"/><!-- HANGUL SYLLABLE BBYEP -->
+      <map code="0xbf3f" name="1em"/><!-- HANGUL SYLLABLE BBYEH -->
+      <map code="0xbf40" name="1em"/><!-- HANGUL SYLLABLE BBO -->
+      <map code="0xbf41" name="1em"/><!-- HANGUL SYLLABLE BBOG -->
+      <map code="0xbf42" name="1em"/><!-- HANGUL SYLLABLE BBOGG -->
+      <map code="0xbf43" name="1em"/><!-- HANGUL SYLLABLE BBOGS -->
+      <map code="0xbf44" name="1em"/><!-- HANGUL SYLLABLE BBON -->
+      <map code="0xbf45" name="1em"/><!-- HANGUL SYLLABLE BBONJ -->
+      <map code="0xbf46" name="1em"/><!-- HANGUL SYLLABLE BBONH -->
+      <map code="0xbf47" name="1em"/><!-- HANGUL SYLLABLE BBOD -->
+      <map code="0xbf48" name="1em"/><!-- HANGUL SYLLABLE BBOL -->
+      <map code="0xbf49" name="1em"/><!-- HANGUL SYLLABLE BBOLG -->
+      <map code="0xbf4a" name="1em"/><!-- HANGUL SYLLABLE BBOLM -->
+      <map code="0xbf4b" name="1em"/><!-- HANGUL SYLLABLE BBOLB -->
+      <map code="0xbf4c" name="1em"/><!-- HANGUL SYLLABLE BBOLS -->
+      <map code="0xbf4d" name="1em"/><!-- HANGUL SYLLABLE BBOLT -->
+      <map code="0xbf4e" name="1em"/><!-- HANGUL SYLLABLE BBOLP -->
+      <map code="0xbf4f" name="1em"/><!-- HANGUL SYLLABLE BBOLH -->
+      <map code="0xbf50" name="1em"/><!-- HANGUL SYLLABLE BBOM -->
+      <map code="0xbf51" name="1em"/><!-- HANGUL SYLLABLE BBOB -->
+      <map code="0xbf52" name="1em"/><!-- HANGUL SYLLABLE BBOBS -->
+      <map code="0xbf53" name="1em"/><!-- HANGUL SYLLABLE BBOS -->
+      <map code="0xbf54" name="1em"/><!-- HANGUL SYLLABLE BBOSS -->
+      <map code="0xbf55" name="1em"/><!-- HANGUL SYLLABLE BBONG -->
+      <map code="0xbf56" name="1em"/><!-- HANGUL SYLLABLE BBOJ -->
+      <map code="0xbf57" name="1em"/><!-- HANGUL SYLLABLE BBOC -->
+      <map code="0xbf58" name="1em"/><!-- HANGUL SYLLABLE BBOK -->
+      <map code="0xbf59" name="1em"/><!-- HANGUL SYLLABLE BBOT -->
+      <map code="0xbf5a" name="1em"/><!-- HANGUL SYLLABLE BBOP -->
+      <map code="0xbf5b" name="1em"/><!-- HANGUL SYLLABLE BBOH -->
+      <map code="0xbf5c" name="1em"/><!-- HANGUL SYLLABLE BBWA -->
+      <map code="0xbf5d" name="1em"/><!-- HANGUL SYLLABLE BBWAG -->
+      <map code="0xbf5e" name="1em"/><!-- HANGUL SYLLABLE BBWAGG -->
+      <map code="0xbf5f" name="1em"/><!-- HANGUL SYLLABLE BBWAGS -->
+      <map code="0xbf60" name="1em"/><!-- HANGUL SYLLABLE BBWAN -->
+      <map code="0xbf61" name="1em"/><!-- HANGUL SYLLABLE BBWANJ -->
+      <map code="0xbf62" name="1em"/><!-- HANGUL SYLLABLE BBWANH -->
+      <map code="0xbf63" name="1em"/><!-- HANGUL SYLLABLE BBWAD -->
+      <map code="0xbf64" name="1em"/><!-- HANGUL SYLLABLE BBWAL -->
+      <map code="0xbf65" name="1em"/><!-- HANGUL SYLLABLE BBWALG -->
+      <map code="0xbf66" name="1em"/><!-- HANGUL SYLLABLE BBWALM -->
+      <map code="0xbf67" name="1em"/><!-- HANGUL SYLLABLE BBWALB -->
+      <map code="0xbf68" name="1em"/><!-- HANGUL SYLLABLE BBWALS -->
+      <map code="0xbf69" name="1em"/><!-- HANGUL SYLLABLE BBWALT -->
+      <map code="0xbf6a" name="1em"/><!-- HANGUL SYLLABLE BBWALP -->
+      <map code="0xbf6b" name="1em"/><!-- HANGUL SYLLABLE BBWALH -->
+      <map code="0xbf6c" name="1em"/><!-- HANGUL SYLLABLE BBWAM -->
+      <map code="0xbf6d" name="1em"/><!-- HANGUL SYLLABLE BBWAB -->
+      <map code="0xbf6e" name="1em"/><!-- HANGUL SYLLABLE BBWABS -->
+      <map code="0xbf6f" name="1em"/><!-- HANGUL SYLLABLE BBWAS -->
+      <map code="0xbf70" name="1em"/><!-- HANGUL SYLLABLE BBWASS -->
+      <map code="0xbf71" name="1em"/><!-- HANGUL SYLLABLE BBWANG -->
+      <map code="0xbf72" name="1em"/><!-- HANGUL SYLLABLE BBWAJ -->
+      <map code="0xbf73" name="1em"/><!-- HANGUL SYLLABLE BBWAC -->
+      <map code="0xbf74" name="1em"/><!-- HANGUL SYLLABLE BBWAK -->
+      <map code="0xbf75" name="1em"/><!-- HANGUL SYLLABLE BBWAT -->
+      <map code="0xbf76" name="1em"/><!-- HANGUL SYLLABLE BBWAP -->
+      <map code="0xbf77" name="1em"/><!-- HANGUL SYLLABLE BBWAH -->
+      <map code="0xbf78" name="1em"/><!-- HANGUL SYLLABLE BBWAE -->
+      <map code="0xbf79" name="1em"/><!-- HANGUL SYLLABLE BBWAEG -->
+      <map code="0xbf7a" name="1em"/><!-- HANGUL SYLLABLE BBWAEGG -->
+      <map code="0xbf7b" name="1em"/><!-- HANGUL SYLLABLE BBWAEGS -->
+      <map code="0xbf7c" name="1em"/><!-- HANGUL SYLLABLE BBWAEN -->
+      <map code="0xbf7d" name="1em"/><!-- HANGUL SYLLABLE BBWAENJ -->
+      <map code="0xbf7e" name="1em"/><!-- HANGUL SYLLABLE BBWAENH -->
+      <map code="0xbf7f" name="1em"/><!-- HANGUL SYLLABLE BBWAED -->
+      <map code="0xbf80" name="1em"/><!-- HANGUL SYLLABLE BBWAEL -->
+      <map code="0xbf81" name="1em"/><!-- HANGUL SYLLABLE BBWAELG -->
+      <map code="0xbf82" name="1em"/><!-- HANGUL SYLLABLE BBWAELM -->
+      <map code="0xbf83" name="1em"/><!-- HANGUL SYLLABLE BBWAELB -->
+      <map code="0xbf84" name="1em"/><!-- HANGUL SYLLABLE BBWAELS -->
+      <map code="0xbf85" name="1em"/><!-- HANGUL SYLLABLE BBWAELT -->
+      <map code="0xbf86" name="1em"/><!-- HANGUL SYLLABLE BBWAELP -->
+      <map code="0xbf87" name="1em"/><!-- HANGUL SYLLABLE BBWAELH -->
+      <map code="0xbf88" name="1em"/><!-- HANGUL SYLLABLE BBWAEM -->
+      <map code="0xbf89" name="1em"/><!-- HANGUL SYLLABLE BBWAEB -->
+      <map code="0xbf8a" name="1em"/><!-- HANGUL SYLLABLE BBWAEBS -->
+      <map code="0xbf8b" name="1em"/><!-- HANGUL SYLLABLE BBWAES -->
+      <map code="0xbf8c" name="1em"/><!-- HANGUL SYLLABLE BBWAESS -->
+      <map code="0xbf8d" name="1em"/><!-- HANGUL SYLLABLE BBWAENG -->
+      <map code="0xbf8e" name="1em"/><!-- HANGUL SYLLABLE BBWAEJ -->
+      <map code="0xbf8f" name="1em"/><!-- HANGUL SYLLABLE BBWAEC -->
+      <map code="0xbf90" name="1em"/><!-- HANGUL SYLLABLE BBWAEK -->
+      <map code="0xbf91" name="1em"/><!-- HANGUL SYLLABLE BBWAET -->
+      <map code="0xbf92" name="1em"/><!-- HANGUL SYLLABLE BBWAEP -->
+      <map code="0xbf93" name="1em"/><!-- HANGUL SYLLABLE BBWAEH -->
+      <map code="0xbf94" name="1em"/><!-- HANGUL SYLLABLE BBOE -->
+      <map code="0xbf95" name="1em"/><!-- HANGUL SYLLABLE BBOEG -->
+      <map code="0xbf96" name="1em"/><!-- HANGUL SYLLABLE BBOEGG -->
+      <map code="0xbf97" name="1em"/><!-- HANGUL SYLLABLE BBOEGS -->
+      <map code="0xbf98" name="1em"/><!-- HANGUL SYLLABLE BBOEN -->
+      <map code="0xbf99" name="1em"/><!-- HANGUL SYLLABLE BBOENJ -->
+      <map code="0xbf9a" name="1em"/><!-- HANGUL SYLLABLE BBOENH -->
+      <map code="0xbf9b" name="1em"/><!-- HANGUL SYLLABLE BBOED -->
+      <map code="0xbf9c" name="1em"/><!-- HANGUL SYLLABLE BBOEL -->
+      <map code="0xbf9d" name="1em"/><!-- HANGUL SYLLABLE BBOELG -->
+      <map code="0xbf9e" name="1em"/><!-- HANGUL SYLLABLE BBOELM -->
+      <map code="0xbf9f" name="1em"/><!-- HANGUL SYLLABLE BBOELB -->
+      <map code="0xbfa0" name="1em"/><!-- HANGUL SYLLABLE BBOELS -->
+      <map code="0xbfa1" name="1em"/><!-- HANGUL SYLLABLE BBOELT -->
+      <map code="0xbfa2" name="1em"/><!-- HANGUL SYLLABLE BBOELP -->
+      <map code="0xbfa3" name="1em"/><!-- HANGUL SYLLABLE BBOELH -->
+      <map code="0xbfa4" name="1em"/><!-- HANGUL SYLLABLE BBOEM -->
+      <map code="0xbfa5" name="1em"/><!-- HANGUL SYLLABLE BBOEB -->
+      <map code="0xbfa6" name="1em"/><!-- HANGUL SYLLABLE BBOEBS -->
+      <map code="0xbfa7" name="1em"/><!-- HANGUL SYLLABLE BBOES -->
+      <map code="0xbfa8" name="1em"/><!-- HANGUL SYLLABLE BBOESS -->
+      <map code="0xbfa9" name="1em"/><!-- HANGUL SYLLABLE BBOENG -->
+      <map code="0xbfaa" name="1em"/><!-- HANGUL SYLLABLE BBOEJ -->
+      <map code="0xbfab" name="1em"/><!-- HANGUL SYLLABLE BBOEC -->
+      <map code="0xbfac" name="1em"/><!-- HANGUL SYLLABLE BBOEK -->
+      <map code="0xbfad" name="1em"/><!-- HANGUL SYLLABLE BBOET -->
+      <map code="0xbfae" name="1em"/><!-- HANGUL SYLLABLE BBOEP -->
+      <map code="0xbfaf" name="1em"/><!-- HANGUL SYLLABLE BBOEH -->
+      <map code="0xbfb0" name="1em"/><!-- HANGUL SYLLABLE BBYO -->
+      <map code="0xbfb1" name="1em"/><!-- HANGUL SYLLABLE BBYOG -->
+      <map code="0xbfb2" name="1em"/><!-- HANGUL SYLLABLE BBYOGG -->
+      <map code="0xbfb3" name="1em"/><!-- HANGUL SYLLABLE BBYOGS -->
+      <map code="0xbfb4" name="1em"/><!-- HANGUL SYLLABLE BBYON -->
+      <map code="0xbfb5" name="1em"/><!-- HANGUL SYLLABLE BBYONJ -->
+      <map code="0xbfb6" name="1em"/><!-- HANGUL SYLLABLE BBYONH -->
+      <map code="0xbfb7" name="1em"/><!-- HANGUL SYLLABLE BBYOD -->
+      <map code="0xbfb8" name="1em"/><!-- HANGUL SYLLABLE BBYOL -->
+      <map code="0xbfb9" name="1em"/><!-- HANGUL SYLLABLE BBYOLG -->
+      <map code="0xbfba" name="1em"/><!-- HANGUL SYLLABLE BBYOLM -->
+      <map code="0xbfbb" name="1em"/><!-- HANGUL SYLLABLE BBYOLB -->
+      <map code="0xbfbc" name="1em"/><!-- HANGUL SYLLABLE BBYOLS -->
+      <map code="0xbfbd" name="1em"/><!-- HANGUL SYLLABLE BBYOLT -->
+      <map code="0xbfbe" name="1em"/><!-- HANGUL SYLLABLE BBYOLP -->
+      <map code="0xbfbf" name="1em"/><!-- HANGUL SYLLABLE BBYOLH -->
+      <map code="0xbfc0" name="1em"/><!-- HANGUL SYLLABLE BBYOM -->
+      <map code="0xbfc1" name="1em"/><!-- HANGUL SYLLABLE BBYOB -->
+      <map code="0xbfc2" name="1em"/><!-- HANGUL SYLLABLE BBYOBS -->
+      <map code="0xbfc3" name="1em"/><!-- HANGUL SYLLABLE BBYOS -->
+      <map code="0xbfc4" name="1em"/><!-- HANGUL SYLLABLE BBYOSS -->
+      <map code="0xbfc5" name="1em"/><!-- HANGUL SYLLABLE BBYONG -->
+      <map code="0xbfc6" name="1em"/><!-- HANGUL SYLLABLE BBYOJ -->
+      <map code="0xbfc7" name="1em"/><!-- HANGUL SYLLABLE BBYOC -->
+      <map code="0xbfc8" name="1em"/><!-- HANGUL SYLLABLE BBYOK -->
+      <map code="0xbfc9" name="1em"/><!-- HANGUL SYLLABLE BBYOT -->
+      <map code="0xbfca" name="1em"/><!-- HANGUL SYLLABLE BBYOP -->
+      <map code="0xbfcb" name="1em"/><!-- HANGUL SYLLABLE BBYOH -->
+      <map code="0xbfcc" name="1em"/><!-- HANGUL SYLLABLE BBU -->
+      <map code="0xbfcd" name="1em"/><!-- HANGUL SYLLABLE BBUG -->
+      <map code="0xbfce" name="1em"/><!-- HANGUL SYLLABLE BBUGG -->
+      <map code="0xbfcf" name="1em"/><!-- HANGUL SYLLABLE BBUGS -->
+      <map code="0xbfd0" name="1em"/><!-- HANGUL SYLLABLE BBUN -->
+      <map code="0xbfd1" name="1em"/><!-- HANGUL SYLLABLE BBUNJ -->
+      <map code="0xbfd2" name="1em"/><!-- HANGUL SYLLABLE BBUNH -->
+      <map code="0xbfd3" name="1em"/><!-- HANGUL SYLLABLE BBUD -->
+      <map code="0xbfd4" name="1em"/><!-- HANGUL SYLLABLE BBUL -->
+      <map code="0xbfd5" name="1em"/><!-- HANGUL SYLLABLE BBULG -->
+      <map code="0xbfd6" name="1em"/><!-- HANGUL SYLLABLE BBULM -->
+      <map code="0xbfd7" name="1em"/><!-- HANGUL SYLLABLE BBULB -->
+      <map code="0xbfd8" name="1em"/><!-- HANGUL SYLLABLE BBULS -->
+      <map code="0xbfd9" name="1em"/><!-- HANGUL SYLLABLE BBULT -->
+      <map code="0xbfda" name="1em"/><!-- HANGUL SYLLABLE BBULP -->
+      <map code="0xbfdb" name="1em"/><!-- HANGUL SYLLABLE BBULH -->
+      <map code="0xbfdc" name="1em"/><!-- HANGUL SYLLABLE BBUM -->
+      <map code="0xbfdd" name="1em"/><!-- HANGUL SYLLABLE BBUB -->
+      <map code="0xbfde" name="1em"/><!-- HANGUL SYLLABLE BBUBS -->
+      <map code="0xbfdf" name="1em"/><!-- HANGUL SYLLABLE BBUS -->
+      <map code="0xbfe0" name="1em"/><!-- HANGUL SYLLABLE BBUSS -->
+      <map code="0xbfe1" name="1em"/><!-- HANGUL SYLLABLE BBUNG -->
+      <map code="0xbfe2" name="1em"/><!-- HANGUL SYLLABLE BBUJ -->
+      <map code="0xbfe3" name="1em"/><!-- HANGUL SYLLABLE BBUC -->
+      <map code="0xbfe4" name="1em"/><!-- HANGUL SYLLABLE BBUK -->
+      <map code="0xbfe5" name="1em"/><!-- HANGUL SYLLABLE BBUT -->
+      <map code="0xbfe6" name="1em"/><!-- HANGUL SYLLABLE BBUP -->
+      <map code="0xbfe7" name="1em"/><!-- HANGUL SYLLABLE BBUH -->
+      <map code="0xbfe8" name="1em"/><!-- HANGUL SYLLABLE BBWEO -->
+      <map code="0xbfe9" name="1em"/><!-- HANGUL SYLLABLE BBWEOG -->
+      <map code="0xbfea" name="1em"/><!-- HANGUL SYLLABLE BBWEOGG -->
+      <map code="0xbfeb" name="1em"/><!-- HANGUL SYLLABLE BBWEOGS -->
+      <map code="0xbfec" name="1em"/><!-- HANGUL SYLLABLE BBWEON -->
+      <map code="0xbfed" name="1em"/><!-- HANGUL SYLLABLE BBWEONJ -->
+      <map code="0xbfee" name="1em"/><!-- HANGUL SYLLABLE BBWEONH -->
+      <map code="0xbfef" name="1em"/><!-- HANGUL SYLLABLE BBWEOD -->
+      <map code="0xbff0" name="1em"/><!-- HANGUL SYLLABLE BBWEOL -->
+      <map code="0xbff1" name="1em"/><!-- HANGUL SYLLABLE BBWEOLG -->
+      <map code="0xbff2" name="1em"/><!-- HANGUL SYLLABLE BBWEOLM -->
+      <map code="0xbff3" name="1em"/><!-- HANGUL SYLLABLE BBWEOLB -->
+      <map code="0xbff4" name="1em"/><!-- HANGUL SYLLABLE BBWEOLS -->
+      <map code="0xbff5" name="1em"/><!-- HANGUL SYLLABLE BBWEOLT -->
+      <map code="0xbff6" name="1em"/><!-- HANGUL SYLLABLE BBWEOLP -->
+      <map code="0xbff7" name="1em"/><!-- HANGUL SYLLABLE BBWEOLH -->
+      <map code="0xbff8" name="1em"/><!-- HANGUL SYLLABLE BBWEOM -->
+      <map code="0xbff9" name="1em"/><!-- HANGUL SYLLABLE BBWEOB -->
+      <map code="0xbffa" name="1em"/><!-- HANGUL SYLLABLE BBWEOBS -->
+      <map code="0xbffb" name="1em"/><!-- HANGUL SYLLABLE BBWEOS -->
+      <map code="0xbffc" name="1em"/><!-- HANGUL SYLLABLE BBWEOSS -->
+      <map code="0xbffd" name="1em"/><!-- HANGUL SYLLABLE BBWEONG -->
+      <map code="0xbffe" name="1em"/><!-- HANGUL SYLLABLE BBWEOJ -->
+      <map code="0xbfff" name="1em"/><!-- HANGUL SYLLABLE BBWEOC -->
+      <map code="0xc000" name="1em"/><!-- HANGUL SYLLABLE BBWEOK -->
+      <map code="0xc001" name="1em"/><!-- HANGUL SYLLABLE BBWEOT -->
+      <map code="0xc002" name="1em"/><!-- HANGUL SYLLABLE BBWEOP -->
+      <map code="0xc003" name="1em"/><!-- HANGUL SYLLABLE BBWEOH -->
+      <map code="0xc004" name="1em"/><!-- HANGUL SYLLABLE BBWE -->
+      <map code="0xc005" name="1em"/><!-- HANGUL SYLLABLE BBWEG -->
+      <map code="0xc006" name="1em"/><!-- HANGUL SYLLABLE BBWEGG -->
+      <map code="0xc007" name="1em"/><!-- HANGUL SYLLABLE BBWEGS -->
+      <map code="0xc008" name="1em"/><!-- HANGUL SYLLABLE BBWEN -->
+      <map code="0xc009" name="1em"/><!-- HANGUL SYLLABLE BBWENJ -->
+      <map code="0xc00a" name="1em"/><!-- HANGUL SYLLABLE BBWENH -->
+      <map code="0xc00b" name="1em"/><!-- HANGUL SYLLABLE BBWED -->
+      <map code="0xc00c" name="1em"/><!-- HANGUL SYLLABLE BBWEL -->
+      <map code="0xc00d" name="1em"/><!-- HANGUL SYLLABLE BBWELG -->
+      <map code="0xc00e" name="1em"/><!-- HANGUL SYLLABLE BBWELM -->
+      <map code="0xc00f" name="1em"/><!-- HANGUL SYLLABLE BBWELB -->
+      <map code="0xc010" name="1em"/><!-- HANGUL SYLLABLE BBWELS -->
+      <map code="0xc011" name="1em"/><!-- HANGUL SYLLABLE BBWELT -->
+      <map code="0xc012" name="1em"/><!-- HANGUL SYLLABLE BBWELP -->
+      <map code="0xc013" name="1em"/><!-- HANGUL SYLLABLE BBWELH -->
+      <map code="0xc014" name="1em"/><!-- HANGUL SYLLABLE BBWEM -->
+      <map code="0xc015" name="1em"/><!-- HANGUL SYLLABLE BBWEB -->
+      <map code="0xc016" name="1em"/><!-- HANGUL SYLLABLE BBWEBS -->
+      <map code="0xc017" name="1em"/><!-- HANGUL SYLLABLE BBWES -->
+      <map code="0xc018" name="1em"/><!-- HANGUL SYLLABLE BBWESS -->
+      <map code="0xc019" name="1em"/><!-- HANGUL SYLLABLE BBWENG -->
+      <map code="0xc01a" name="1em"/><!-- HANGUL SYLLABLE BBWEJ -->
+      <map code="0xc01b" name="1em"/><!-- HANGUL SYLLABLE BBWEC -->
+      <map code="0xc01c" name="1em"/><!-- HANGUL SYLLABLE BBWEK -->
+      <map code="0xc01d" name="1em"/><!-- HANGUL SYLLABLE BBWET -->
+      <map code="0xc01e" name="1em"/><!-- HANGUL SYLLABLE BBWEP -->
+      <map code="0xc01f" name="1em"/><!-- HANGUL SYLLABLE BBWEH -->
+      <map code="0xc020" name="1em"/><!-- HANGUL SYLLABLE BBWI -->
+      <map code="0xc021" name="1em"/><!-- HANGUL SYLLABLE BBWIG -->
+      <map code="0xc022" name="1em"/><!-- HANGUL SYLLABLE BBWIGG -->
+      <map code="0xc023" name="1em"/><!-- HANGUL SYLLABLE BBWIGS -->
+      <map code="0xc024" name="1em"/><!-- HANGUL SYLLABLE BBWIN -->
+      <map code="0xc025" name="1em"/><!-- HANGUL SYLLABLE BBWINJ -->
+      <map code="0xc026" name="1em"/><!-- HANGUL SYLLABLE BBWINH -->
+      <map code="0xc027" name="1em"/><!-- HANGUL SYLLABLE BBWID -->
+      <map code="0xc028" name="1em"/><!-- HANGUL SYLLABLE BBWIL -->
+      <map code="0xc029" name="1em"/><!-- HANGUL SYLLABLE BBWILG -->
+      <map code="0xc02a" name="1em"/><!-- HANGUL SYLLABLE BBWILM -->
+      <map code="0xc02b" name="1em"/><!-- HANGUL SYLLABLE BBWILB -->
+      <map code="0xc02c" name="1em"/><!-- HANGUL SYLLABLE BBWILS -->
+      <map code="0xc02d" name="1em"/><!-- HANGUL SYLLABLE BBWILT -->
+      <map code="0xc02e" name="1em"/><!-- HANGUL SYLLABLE BBWILP -->
+      <map code="0xc02f" name="1em"/><!-- HANGUL SYLLABLE BBWILH -->
+      <map code="0xc030" name="1em"/><!-- HANGUL SYLLABLE BBWIM -->
+      <map code="0xc031" name="1em"/><!-- HANGUL SYLLABLE BBWIB -->
+      <map code="0xc032" name="1em"/><!-- HANGUL SYLLABLE BBWIBS -->
+      <map code="0xc033" name="1em"/><!-- HANGUL SYLLABLE BBWIS -->
+      <map code="0xc034" name="1em"/><!-- HANGUL SYLLABLE BBWISS -->
+      <map code="0xc035" name="1em"/><!-- HANGUL SYLLABLE BBWING -->
+      <map code="0xc036" name="1em"/><!-- HANGUL SYLLABLE BBWIJ -->
+      <map code="0xc037" name="1em"/><!-- HANGUL SYLLABLE BBWIC -->
+      <map code="0xc038" name="1em"/><!-- HANGUL SYLLABLE BBWIK -->
+      <map code="0xc039" name="1em"/><!-- HANGUL SYLLABLE BBWIT -->
+      <map code="0xc03a" name="1em"/><!-- HANGUL SYLLABLE BBWIP -->
+      <map code="0xc03b" name="1em"/><!-- HANGUL SYLLABLE BBWIH -->
+      <map code="0xc03c" name="1em"/><!-- HANGUL SYLLABLE BBYU -->
+      <map code="0xc03d" name="1em"/><!-- HANGUL SYLLABLE BBYUG -->
+      <map code="0xc03e" name="1em"/><!-- HANGUL SYLLABLE BBYUGG -->
+      <map code="0xc03f" name="1em"/><!-- HANGUL SYLLABLE BBYUGS -->
+      <map code="0xc040" name="1em"/><!-- HANGUL SYLLABLE BBYUN -->
+      <map code="0xc041" name="1em"/><!-- HANGUL SYLLABLE BBYUNJ -->
+      <map code="0xc042" name="1em"/><!-- HANGUL SYLLABLE BBYUNH -->
+      <map code="0xc043" name="1em"/><!-- HANGUL SYLLABLE BBYUD -->
+      <map code="0xc044" name="1em"/><!-- HANGUL SYLLABLE BBYUL -->
+      <map code="0xc045" name="1em"/><!-- HANGUL SYLLABLE BBYULG -->
+      <map code="0xc046" name="1em"/><!-- HANGUL SYLLABLE BBYULM -->
+      <map code="0xc047" name="1em"/><!-- HANGUL SYLLABLE BBYULB -->
+      <map code="0xc048" name="1em"/><!-- HANGUL SYLLABLE BBYULS -->
+      <map code="0xc049" name="1em"/><!-- HANGUL SYLLABLE BBYULT -->
+      <map code="0xc04a" name="1em"/><!-- HANGUL SYLLABLE BBYULP -->
+      <map code="0xc04b" name="1em"/><!-- HANGUL SYLLABLE BBYULH -->
+      <map code="0xc04c" name="1em"/><!-- HANGUL SYLLABLE BBYUM -->
+      <map code="0xc04d" name="1em"/><!-- HANGUL SYLLABLE BBYUB -->
+      <map code="0xc04e" name="1em"/><!-- HANGUL SYLLABLE BBYUBS -->
+      <map code="0xc04f" name="1em"/><!-- HANGUL SYLLABLE BBYUS -->
+      <map code="0xc050" name="1em"/><!-- HANGUL SYLLABLE BBYUSS -->
+      <map code="0xc051" name="1em"/><!-- HANGUL SYLLABLE BBYUNG -->
+      <map code="0xc052" name="1em"/><!-- HANGUL SYLLABLE BBYUJ -->
+      <map code="0xc053" name="1em"/><!-- HANGUL SYLLABLE BBYUC -->
+      <map code="0xc054" name="1em"/><!-- HANGUL SYLLABLE BBYUK -->
+      <map code="0xc055" name="1em"/><!-- HANGUL SYLLABLE BBYUT -->
+      <map code="0xc056" name="1em"/><!-- HANGUL SYLLABLE BBYUP -->
+      <map code="0xc057" name="1em"/><!-- HANGUL SYLLABLE BBYUH -->
+      <map code="0xc058" name="1em"/><!-- HANGUL SYLLABLE BBEU -->
+      <map code="0xc059" name="1em"/><!-- HANGUL SYLLABLE BBEUG -->
+      <map code="0xc05a" name="1em"/><!-- HANGUL SYLLABLE BBEUGG -->
+      <map code="0xc05b" name="1em"/><!-- HANGUL SYLLABLE BBEUGS -->
+      <map code="0xc05c" name="1em"/><!-- HANGUL SYLLABLE BBEUN -->
+      <map code="0xc05d" name="1em"/><!-- HANGUL SYLLABLE BBEUNJ -->
+      <map code="0xc05e" name="1em"/><!-- HANGUL SYLLABLE BBEUNH -->
+      <map code="0xc05f" name="1em"/><!-- HANGUL SYLLABLE BBEUD -->
+      <map code="0xc060" name="1em"/><!-- HANGUL SYLLABLE BBEUL -->
+      <map code="0xc061" name="1em"/><!-- HANGUL SYLLABLE BBEULG -->
+      <map code="0xc062" name="1em"/><!-- HANGUL SYLLABLE BBEULM -->
+      <map code="0xc063" name="1em"/><!-- HANGUL SYLLABLE BBEULB -->
+      <map code="0xc064" name="1em"/><!-- HANGUL SYLLABLE BBEULS -->
+      <map code="0xc065" name="1em"/><!-- HANGUL SYLLABLE BBEULT -->
+      <map code="0xc066" name="1em"/><!-- HANGUL SYLLABLE BBEULP -->
+      <map code="0xc067" name="1em"/><!-- HANGUL SYLLABLE BBEULH -->
+      <map code="0xc068" name="1em"/><!-- HANGUL SYLLABLE BBEUM -->
+      <map code="0xc069" name="1em"/><!-- HANGUL SYLLABLE BBEUB -->
+      <map code="0xc06a" name="1em"/><!-- HANGUL SYLLABLE BBEUBS -->
+      <map code="0xc06b" name="1em"/><!-- HANGUL SYLLABLE BBEUS -->
+      <map code="0xc06c" name="1em"/><!-- HANGUL SYLLABLE BBEUSS -->
+      <map code="0xc06d" name="1em"/><!-- HANGUL SYLLABLE BBEUNG -->
+      <map code="0xc06e" name="1em"/><!-- HANGUL SYLLABLE BBEUJ -->
+      <map code="0xc06f" name="1em"/><!-- HANGUL SYLLABLE BBEUC -->
+      <map code="0xc070" name="1em"/><!-- HANGUL SYLLABLE BBEUK -->
+      <map code="0xc071" name="1em"/><!-- HANGUL SYLLABLE BBEUT -->
+      <map code="0xc072" name="1em"/><!-- HANGUL SYLLABLE BBEUP -->
+      <map code="0xc073" name="1em"/><!-- HANGUL SYLLABLE BBEUH -->
+      <map code="0xc074" name="1em"/><!-- HANGUL SYLLABLE BBYI -->
+      <map code="0xc075" name="1em"/><!-- HANGUL SYLLABLE BBYIG -->
+      <map code="0xc076" name="1em"/><!-- HANGUL SYLLABLE BBYIGG -->
+      <map code="0xc077" name="1em"/><!-- HANGUL SYLLABLE BBYIGS -->
+      <map code="0xc078" name="1em"/><!-- HANGUL SYLLABLE BBYIN -->
+      <map code="0xc079" name="1em"/><!-- HANGUL SYLLABLE BBYINJ -->
+      <map code="0xc07a" name="1em"/><!-- HANGUL SYLLABLE BBYINH -->
+      <map code="0xc07b" name="1em"/><!-- HANGUL SYLLABLE BBYID -->
+      <map code="0xc07c" name="1em"/><!-- HANGUL SYLLABLE BBYIL -->
+      <map code="0xc07d" name="1em"/><!-- HANGUL SYLLABLE BBYILG -->
+      <map code="0xc07e" name="1em"/><!-- HANGUL SYLLABLE BBYILM -->
+      <map code="0xc07f" name="1em"/><!-- HANGUL SYLLABLE BBYILB -->
+      <map code="0xc080" name="1em"/><!-- HANGUL SYLLABLE BBYILS -->
+      <map code="0xc081" name="1em"/><!-- HANGUL SYLLABLE BBYILT -->
+      <map code="0xc082" name="1em"/><!-- HANGUL SYLLABLE BBYILP -->
+      <map code="0xc083" name="1em"/><!-- HANGUL SYLLABLE BBYILH -->
+      <map code="0xc084" name="1em"/><!-- HANGUL SYLLABLE BBYIM -->
+      <map code="0xc085" name="1em"/><!-- HANGUL SYLLABLE BBYIB -->
+      <map code="0xc086" name="1em"/><!-- HANGUL SYLLABLE BBYIBS -->
+      <map code="0xc087" name="1em"/><!-- HANGUL SYLLABLE BBYIS -->
+      <map code="0xc088" name="1em"/><!-- HANGUL SYLLABLE BBYISS -->
+      <map code="0xc089" name="1em"/><!-- HANGUL SYLLABLE BBYING -->
+      <map code="0xc08a" name="1em"/><!-- HANGUL SYLLABLE BBYIJ -->
+      <map code="0xc08b" name="1em"/><!-- HANGUL SYLLABLE BBYIC -->
+      <map code="0xc08c" name="1em"/><!-- HANGUL SYLLABLE BBYIK -->
+      <map code="0xc08d" name="1em"/><!-- HANGUL SYLLABLE BBYIT -->
+      <map code="0xc08e" name="1em"/><!-- HANGUL SYLLABLE BBYIP -->
+      <map code="0xc08f" name="1em"/><!-- HANGUL SYLLABLE BBYIH -->
+      <map code="0xc090" name="1em"/><!-- HANGUL SYLLABLE BBI -->
+      <map code="0xc091" name="1em"/><!-- HANGUL SYLLABLE BBIG -->
+      <map code="0xc092" name="1em"/><!-- HANGUL SYLLABLE BBIGG -->
+      <map code="0xc093" name="1em"/><!-- HANGUL SYLLABLE BBIGS -->
+      <map code="0xc094" name="1em"/><!-- HANGUL SYLLABLE BBIN -->
+      <map code="0xc095" name="1em"/><!-- HANGUL SYLLABLE BBINJ -->
+      <map code="0xc096" name="1em"/><!-- HANGUL SYLLABLE BBINH -->
+      <map code="0xc097" name="1em"/><!-- HANGUL SYLLABLE BBID -->
+      <map code="0xc098" name="1em"/><!-- HANGUL SYLLABLE BBIL -->
+      <map code="0xc099" name="1em"/><!-- HANGUL SYLLABLE BBILG -->
+      <map code="0xc09a" name="1em"/><!-- HANGUL SYLLABLE BBILM -->
+      <map code="0xc09b" name="1em"/><!-- HANGUL SYLLABLE BBILB -->
+      <map code="0xc09c" name="1em"/><!-- HANGUL SYLLABLE BBILS -->
+      <map code="0xc09d" name="1em"/><!-- HANGUL SYLLABLE BBILT -->
+      <map code="0xc09e" name="1em"/><!-- HANGUL SYLLABLE BBILP -->
+      <map code="0xc09f" name="1em"/><!-- HANGUL SYLLABLE BBILH -->
+      <map code="0xc0a0" name="1em"/><!-- HANGUL SYLLABLE BBIM -->
+      <map code="0xc0a1" name="1em"/><!-- HANGUL SYLLABLE BBIB -->
+      <map code="0xc0a2" name="1em"/><!-- HANGUL SYLLABLE BBIBS -->
+      <map code="0xc0a3" name="1em"/><!-- HANGUL SYLLABLE BBIS -->
+      <map code="0xc0a4" name="1em"/><!-- HANGUL SYLLABLE BBISS -->
+      <map code="0xc0a5" name="1em"/><!-- HANGUL SYLLABLE BBING -->
+      <map code="0xc0a6" name="1em"/><!-- HANGUL SYLLABLE BBIJ -->
+      <map code="0xc0a7" name="1em"/><!-- HANGUL SYLLABLE BBIC -->
+      <map code="0xc0a8" name="1em"/><!-- HANGUL SYLLABLE BBIK -->
+      <map code="0xc0a9" name="1em"/><!-- HANGUL SYLLABLE BBIT -->
+      <map code="0xc0aa" name="1em"/><!-- HANGUL SYLLABLE BBIP -->
+      <map code="0xc0ab" name="1em"/><!-- HANGUL SYLLABLE BBIH -->
+      <map code="0xc0ac" name="1em"/><!-- HANGUL SYLLABLE SA -->
+      <map code="0xc0ad" name="1em"/><!-- HANGUL SYLLABLE SAG -->
+      <map code="0xc0ae" name="1em"/><!-- HANGUL SYLLABLE SAGG -->
+      <map code="0xc0af" name="1em"/><!-- HANGUL SYLLABLE SAGS -->
+      <map code="0xc0b0" name="1em"/><!-- HANGUL SYLLABLE SAN -->
+      <map code="0xc0b1" name="1em"/><!-- HANGUL SYLLABLE SANJ -->
+      <map code="0xc0b2" name="1em"/><!-- HANGUL SYLLABLE SANH -->
+      <map code="0xc0b3" name="1em"/><!-- HANGUL SYLLABLE SAD -->
+      <map code="0xc0b4" name="1em"/><!-- HANGUL SYLLABLE SAL -->
+      <map code="0xc0b5" name="1em"/><!-- HANGUL SYLLABLE SALG -->
+      <map code="0xc0b6" name="1em"/><!-- HANGUL SYLLABLE SALM -->
+      <map code="0xc0b7" name="1em"/><!-- HANGUL SYLLABLE SALB -->
+      <map code="0xc0b8" name="1em"/><!-- HANGUL SYLLABLE SALS -->
+      <map code="0xc0b9" name="1em"/><!-- HANGUL SYLLABLE SALT -->
+      <map code="0xc0ba" name="1em"/><!-- HANGUL SYLLABLE SALP -->
+      <map code="0xc0bb" name="1em"/><!-- HANGUL SYLLABLE SALH -->
+      <map code="0xc0bc" name="1em"/><!-- HANGUL SYLLABLE SAM -->
+      <map code="0xc0bd" name="1em"/><!-- HANGUL SYLLABLE SAB -->
+      <map code="0xc0be" name="1em"/><!-- HANGUL SYLLABLE SABS -->
+      <map code="0xc0bf" name="1em"/><!-- HANGUL SYLLABLE SAS -->
+      <map code="0xc0c0" name="1em"/><!-- HANGUL SYLLABLE SASS -->
+      <map code="0xc0c1" name="1em"/><!-- HANGUL SYLLABLE SANG -->
+      <map code="0xc0c2" name="1em"/><!-- HANGUL SYLLABLE SAJ -->
+      <map code="0xc0c3" name="1em"/><!-- HANGUL SYLLABLE SAC -->
+      <map code="0xc0c4" name="1em"/><!-- HANGUL SYLLABLE SAK -->
+      <map code="0xc0c5" name="1em"/><!-- HANGUL SYLLABLE SAT -->
+      <map code="0xc0c6" name="1em"/><!-- HANGUL SYLLABLE SAP -->
+      <map code="0xc0c7" name="1em"/><!-- HANGUL SYLLABLE SAH -->
+      <map code="0xc0c8" name="1em"/><!-- HANGUL SYLLABLE SAE -->
+      <map code="0xc0c9" name="1em"/><!-- HANGUL SYLLABLE SAEG -->
+      <map code="0xc0ca" name="1em"/><!-- HANGUL SYLLABLE SAEGG -->
+      <map code="0xc0cb" name="1em"/><!-- HANGUL SYLLABLE SAEGS -->
+      <map code="0xc0cc" name="1em"/><!-- HANGUL SYLLABLE SAEN -->
+      <map code="0xc0cd" name="1em"/><!-- HANGUL SYLLABLE SAENJ -->
+      <map code="0xc0ce" name="1em"/><!-- HANGUL SYLLABLE SAENH -->
+      <map code="0xc0cf" name="1em"/><!-- HANGUL SYLLABLE SAED -->
+      <map code="0xc0d0" name="1em"/><!-- HANGUL SYLLABLE SAEL -->
+      <map code="0xc0d1" name="1em"/><!-- HANGUL SYLLABLE SAELG -->
+      <map code="0xc0d2" name="1em"/><!-- HANGUL SYLLABLE SAELM -->
+      <map code="0xc0d3" name="1em"/><!-- HANGUL SYLLABLE SAELB -->
+      <map code="0xc0d4" name="1em"/><!-- HANGUL SYLLABLE SAELS -->
+      <map code="0xc0d5" name="1em"/><!-- HANGUL SYLLABLE SAELT -->
+      <map code="0xc0d6" name="1em"/><!-- HANGUL SYLLABLE SAELP -->
+      <map code="0xc0d7" name="1em"/><!-- HANGUL SYLLABLE SAELH -->
+      <map code="0xc0d8" name="1em"/><!-- HANGUL SYLLABLE SAEM -->
+      <map code="0xc0d9" name="1em"/><!-- HANGUL SYLLABLE SAEB -->
+      <map code="0xc0da" name="1em"/><!-- HANGUL SYLLABLE SAEBS -->
+      <map code="0xc0db" name="1em"/><!-- HANGUL SYLLABLE SAES -->
+      <map code="0xc0dc" name="1em"/><!-- HANGUL SYLLABLE SAESS -->
+      <map code="0xc0dd" name="1em"/><!-- HANGUL SYLLABLE SAENG -->
+      <map code="0xc0de" name="1em"/><!-- HANGUL SYLLABLE SAEJ -->
+      <map code="0xc0df" name="1em"/><!-- HANGUL SYLLABLE SAEC -->
+      <map code="0xc0e0" name="1em"/><!-- HANGUL SYLLABLE SAEK -->
+      <map code="0xc0e1" name="1em"/><!-- HANGUL SYLLABLE SAET -->
+      <map code="0xc0e2" name="1em"/><!-- HANGUL SYLLABLE SAEP -->
+      <map code="0xc0e3" name="1em"/><!-- HANGUL SYLLABLE SAEH -->
+      <map code="0xc0e4" name="1em"/><!-- HANGUL SYLLABLE SYA -->
+      <map code="0xc0e5" name="1em"/><!-- HANGUL SYLLABLE SYAG -->
+      <map code="0xc0e6" name="1em"/><!-- HANGUL SYLLABLE SYAGG -->
+      <map code="0xc0e7" name="1em"/><!-- HANGUL SYLLABLE SYAGS -->
+      <map code="0xc0e8" name="1em"/><!-- HANGUL SYLLABLE SYAN -->
+      <map code="0xc0e9" name="1em"/><!-- HANGUL SYLLABLE SYANJ -->
+      <map code="0xc0ea" name="1em"/><!-- HANGUL SYLLABLE SYANH -->
+      <map code="0xc0eb" name="1em"/><!-- HANGUL SYLLABLE SYAD -->
+      <map code="0xc0ec" name="1em"/><!-- HANGUL SYLLABLE SYAL -->
+      <map code="0xc0ed" name="1em"/><!-- HANGUL SYLLABLE SYALG -->
+      <map code="0xc0ee" name="1em"/><!-- HANGUL SYLLABLE SYALM -->
+      <map code="0xc0ef" name="1em"/><!-- HANGUL SYLLABLE SYALB -->
+      <map code="0xc0f0" name="1em"/><!-- HANGUL SYLLABLE SYALS -->
+      <map code="0xc0f1" name="1em"/><!-- HANGUL SYLLABLE SYALT -->
+      <map code="0xc0f2" name="1em"/><!-- HANGUL SYLLABLE SYALP -->
+      <map code="0xc0f3" name="1em"/><!-- HANGUL SYLLABLE SYALH -->
+      <map code="0xc0f4" name="1em"/><!-- HANGUL SYLLABLE SYAM -->
+      <map code="0xc0f5" name="1em"/><!-- HANGUL SYLLABLE SYAB -->
+      <map code="0xc0f6" name="1em"/><!-- HANGUL SYLLABLE SYABS -->
+      <map code="0xc0f7" name="1em"/><!-- HANGUL SYLLABLE SYAS -->
+      <map code="0xc0f8" name="1em"/><!-- HANGUL SYLLABLE SYASS -->
+      <map code="0xc0f9" name="1em"/><!-- HANGUL SYLLABLE SYANG -->
+      <map code="0xc0fa" name="1em"/><!-- HANGUL SYLLABLE SYAJ -->
+      <map code="0xc0fb" name="1em"/><!-- HANGUL SYLLABLE SYAC -->
+      <map code="0xc0fc" name="1em"/><!-- HANGUL SYLLABLE SYAK -->
+      <map code="0xc0fd" name="1em"/><!-- HANGUL SYLLABLE SYAT -->
+      <map code="0xc0fe" name="1em"/><!-- HANGUL SYLLABLE SYAP -->
+      <map code="0xc0ff" name="1em"/><!-- HANGUL SYLLABLE SYAH -->
+      <map code="0xc100" name="1em"/><!-- HANGUL SYLLABLE SYAE -->
+      <map code="0xc101" name="1em"/><!-- HANGUL SYLLABLE SYAEG -->
+      <map code="0xc102" name="1em"/><!-- HANGUL SYLLABLE SYAEGG -->
+      <map code="0xc103" name="1em"/><!-- HANGUL SYLLABLE SYAEGS -->
+      <map code="0xc104" name="1em"/><!-- HANGUL SYLLABLE SYAEN -->
+      <map code="0xc105" name="1em"/><!-- HANGUL SYLLABLE SYAENJ -->
+      <map code="0xc106" name="1em"/><!-- HANGUL SYLLABLE SYAENH -->
+      <map code="0xc107" name="1em"/><!-- HANGUL SYLLABLE SYAED -->
+      <map code="0xc108" name="1em"/><!-- HANGUL SYLLABLE SYAEL -->
+      <map code="0xc109" name="1em"/><!-- HANGUL SYLLABLE SYAELG -->
+      <map code="0xc10a" name="1em"/><!-- HANGUL SYLLABLE SYAELM -->
+      <map code="0xc10b" name="1em"/><!-- HANGUL SYLLABLE SYAELB -->
+      <map code="0xc10c" name="1em"/><!-- HANGUL SYLLABLE SYAELS -->
+      <map code="0xc10d" name="1em"/><!-- HANGUL SYLLABLE SYAELT -->
+      <map code="0xc10e" name="1em"/><!-- HANGUL SYLLABLE SYAELP -->
+      <map code="0xc10f" name="1em"/><!-- HANGUL SYLLABLE SYAELH -->
+      <map code="0xc110" name="1em"/><!-- HANGUL SYLLABLE SYAEM -->
+      <map code="0xc111" name="1em"/><!-- HANGUL SYLLABLE SYAEB -->
+      <map code="0xc112" name="1em"/><!-- HANGUL SYLLABLE SYAEBS -->
+      <map code="0xc113" name="1em"/><!-- HANGUL SYLLABLE SYAES -->
+      <map code="0xc114" name="1em"/><!-- HANGUL SYLLABLE SYAESS -->
+      <map code="0xc115" name="1em"/><!-- HANGUL SYLLABLE SYAENG -->
+      <map code="0xc116" name="1em"/><!-- HANGUL SYLLABLE SYAEJ -->
+      <map code="0xc117" name="1em"/><!-- HANGUL SYLLABLE SYAEC -->
+      <map code="0xc118" name="1em"/><!-- HANGUL SYLLABLE SYAEK -->
+      <map code="0xc119" name="1em"/><!-- HANGUL SYLLABLE SYAET -->
+      <map code="0xc11a" name="1em"/><!-- HANGUL SYLLABLE SYAEP -->
+      <map code="0xc11b" name="1em"/><!-- HANGUL SYLLABLE SYAEH -->
+      <map code="0xc11c" name="1em"/><!-- HANGUL SYLLABLE SEO -->
+      <map code="0xc11d" name="1em"/><!-- HANGUL SYLLABLE SEOG -->
+      <map code="0xc11e" name="1em"/><!-- HANGUL SYLLABLE SEOGG -->
+      <map code="0xc11f" name="1em"/><!-- HANGUL SYLLABLE SEOGS -->
+      <map code="0xc120" name="1em"/><!-- HANGUL SYLLABLE SEON -->
+      <map code="0xc121" name="1em"/><!-- HANGUL SYLLABLE SEONJ -->
+      <map code="0xc122" name="1em"/><!-- HANGUL SYLLABLE SEONH -->
+      <map code="0xc123" name="1em"/><!-- HANGUL SYLLABLE SEOD -->
+      <map code="0xc124" name="1em"/><!-- HANGUL SYLLABLE SEOL -->
+      <map code="0xc125" name="1em"/><!-- HANGUL SYLLABLE SEOLG -->
+      <map code="0xc126" name="1em"/><!-- HANGUL SYLLABLE SEOLM -->
+      <map code="0xc127" name="1em"/><!-- HANGUL SYLLABLE SEOLB -->
+      <map code="0xc128" name="1em"/><!-- HANGUL SYLLABLE SEOLS -->
+      <map code="0xc129" name="1em"/><!-- HANGUL SYLLABLE SEOLT -->
+      <map code="0xc12a" name="1em"/><!-- HANGUL SYLLABLE SEOLP -->
+      <map code="0xc12b" name="1em"/><!-- HANGUL SYLLABLE SEOLH -->
+      <map code="0xc12c" name="1em"/><!-- HANGUL SYLLABLE SEOM -->
+      <map code="0xc12d" name="1em"/><!-- HANGUL SYLLABLE SEOB -->
+      <map code="0xc12e" name="1em"/><!-- HANGUL SYLLABLE SEOBS -->
+      <map code="0xc12f" name="1em"/><!-- HANGUL SYLLABLE SEOS -->
+      <map code="0xc130" name="1em"/><!-- HANGUL SYLLABLE SEOSS -->
+      <map code="0xc131" name="1em"/><!-- HANGUL SYLLABLE SEONG -->
+      <map code="0xc132" name="1em"/><!-- HANGUL SYLLABLE SEOJ -->
+      <map code="0xc133" name="1em"/><!-- HANGUL SYLLABLE SEOC -->
+      <map code="0xc134" name="1em"/><!-- HANGUL SYLLABLE SEOK -->
+      <map code="0xc135" name="1em"/><!-- HANGUL SYLLABLE SEOT -->
+      <map code="0xc136" name="1em"/><!-- HANGUL SYLLABLE SEOP -->
+      <map code="0xc137" name="1em"/><!-- HANGUL SYLLABLE SEOH -->
+      <map code="0xc138" name="1em"/><!-- HANGUL SYLLABLE SE -->
+      <map code="0xc139" name="1em"/><!-- HANGUL SYLLABLE SEG -->
+      <map code="0xc13a" name="1em"/><!-- HANGUL SYLLABLE SEGG -->
+      <map code="0xc13b" name="1em"/><!-- HANGUL SYLLABLE SEGS -->
+      <map code="0xc13c" name="1em"/><!-- HANGUL SYLLABLE SEN -->
+      <map code="0xc13d" name="1em"/><!-- HANGUL SYLLABLE SENJ -->
+      <map code="0xc13e" name="1em"/><!-- HANGUL SYLLABLE SENH -->
+      <map code="0xc13f" name="1em"/><!-- HANGUL SYLLABLE SED -->
+      <map code="0xc140" name="1em"/><!-- HANGUL SYLLABLE SEL -->
+      <map code="0xc141" name="1em"/><!-- HANGUL SYLLABLE SELG -->
+      <map code="0xc142" name="1em"/><!-- HANGUL SYLLABLE SELM -->
+      <map code="0xc143" name="1em"/><!-- HANGUL SYLLABLE SELB -->
+      <map code="0xc144" name="1em"/><!-- HANGUL SYLLABLE SELS -->
+      <map code="0xc145" name="1em"/><!-- HANGUL SYLLABLE SELT -->
+      <map code="0xc146" name="1em"/><!-- HANGUL SYLLABLE SELP -->
+      <map code="0xc147" name="1em"/><!-- HANGUL SYLLABLE SELH -->
+      <map code="0xc148" name="1em"/><!-- HANGUL SYLLABLE SEM -->
+      <map code="0xc149" name="1em"/><!-- HANGUL SYLLABLE SEB -->
+      <map code="0xc14a" name="1em"/><!-- HANGUL SYLLABLE SEBS -->
+      <map code="0xc14b" name="1em"/><!-- HANGUL SYLLABLE SES -->
+      <map code="0xc14c" name="1em"/><!-- HANGUL SYLLABLE SESS -->
+      <map code="0xc14d" name="1em"/><!-- HANGUL SYLLABLE SENG -->
+      <map code="0xc14e" name="1em"/><!-- HANGUL SYLLABLE SEJ -->
+      <map code="0xc14f" name="1em"/><!-- HANGUL SYLLABLE SEC -->
+      <map code="0xc150" name="1em"/><!-- HANGUL SYLLABLE SEK -->
+      <map code="0xc151" name="1em"/><!-- HANGUL SYLLABLE SET -->
+      <map code="0xc152" name="1em"/><!-- HANGUL SYLLABLE SEP -->
+      <map code="0xc153" name="1em"/><!-- HANGUL SYLLABLE SEH -->
+      <map code="0xc154" name="1em"/><!-- HANGUL SYLLABLE SYEO -->
+      <map code="0xc155" name="1em"/><!-- HANGUL SYLLABLE SYEOG -->
+      <map code="0xc156" name="1em"/><!-- HANGUL SYLLABLE SYEOGG -->
+      <map code="0xc157" name="1em"/><!-- HANGUL SYLLABLE SYEOGS -->
+      <map code="0xc158" name="1em"/><!-- HANGUL SYLLABLE SYEON -->
+      <map code="0xc159" name="1em"/><!-- HANGUL SYLLABLE SYEONJ -->
+      <map code="0xc15a" name="1em"/><!-- HANGUL SYLLABLE SYEONH -->
+      <map code="0xc15b" name="1em"/><!-- HANGUL SYLLABLE SYEOD -->
+      <map code="0xc15c" name="1em"/><!-- HANGUL SYLLABLE SYEOL -->
+      <map code="0xc15d" name="1em"/><!-- HANGUL SYLLABLE SYEOLG -->
+      <map code="0xc15e" name="1em"/><!-- HANGUL SYLLABLE SYEOLM -->
+      <map code="0xc15f" name="1em"/><!-- HANGUL SYLLABLE SYEOLB -->
+      <map code="0xc160" name="1em"/><!-- HANGUL SYLLABLE SYEOLS -->
+      <map code="0xc161" name="1em"/><!-- HANGUL SYLLABLE SYEOLT -->
+      <map code="0xc162" name="1em"/><!-- HANGUL SYLLABLE SYEOLP -->
+      <map code="0xc163" name="1em"/><!-- HANGUL SYLLABLE SYEOLH -->
+      <map code="0xc164" name="1em"/><!-- HANGUL SYLLABLE SYEOM -->
+      <map code="0xc165" name="1em"/><!-- HANGUL SYLLABLE SYEOB -->
+      <map code="0xc166" name="1em"/><!-- HANGUL SYLLABLE SYEOBS -->
+      <map code="0xc167" name="1em"/><!-- HANGUL SYLLABLE SYEOS -->
+      <map code="0xc168" name="1em"/><!-- HANGUL SYLLABLE SYEOSS -->
+      <map code="0xc169" name="1em"/><!-- HANGUL SYLLABLE SYEONG -->
+      <map code="0xc16a" name="1em"/><!-- HANGUL SYLLABLE SYEOJ -->
+      <map code="0xc16b" name="1em"/><!-- HANGUL SYLLABLE SYEOC -->
+      <map code="0xc16c" name="1em"/><!-- HANGUL SYLLABLE SYEOK -->
+      <map code="0xc16d" name="1em"/><!-- HANGUL SYLLABLE SYEOT -->
+      <map code="0xc16e" name="1em"/><!-- HANGUL SYLLABLE SYEOP -->
+      <map code="0xc16f" name="1em"/><!-- HANGUL SYLLABLE SYEOH -->
+      <map code="0xc170" name="1em"/><!-- HANGUL SYLLABLE SYE -->
+      <map code="0xc171" name="1em"/><!-- HANGUL SYLLABLE SYEG -->
+      <map code="0xc172" name="1em"/><!-- HANGUL SYLLABLE SYEGG -->
+      <map code="0xc173" name="1em"/><!-- HANGUL SYLLABLE SYEGS -->
+      <map code="0xc174" name="1em"/><!-- HANGUL SYLLABLE SYEN -->
+      <map code="0xc175" name="1em"/><!-- HANGUL SYLLABLE SYENJ -->
+      <map code="0xc176" name="1em"/><!-- HANGUL SYLLABLE SYENH -->
+      <map code="0xc177" name="1em"/><!-- HANGUL SYLLABLE SYED -->
+      <map code="0xc178" name="1em"/><!-- HANGUL SYLLABLE SYEL -->
+      <map code="0xc179" name="1em"/><!-- HANGUL SYLLABLE SYELG -->
+      <map code="0xc17a" name="1em"/><!-- HANGUL SYLLABLE SYELM -->
+      <map code="0xc17b" name="1em"/><!-- HANGUL SYLLABLE SYELB -->
+      <map code="0xc17c" name="1em"/><!-- HANGUL SYLLABLE SYELS -->
+      <map code="0xc17d" name="1em"/><!-- HANGUL SYLLABLE SYELT -->
+      <map code="0xc17e" name="1em"/><!-- HANGUL SYLLABLE SYELP -->
+      <map code="0xc17f" name="1em"/><!-- HANGUL SYLLABLE SYELH -->
+      <map code="0xc180" name="1em"/><!-- HANGUL SYLLABLE SYEM -->
+      <map code="0xc181" name="1em"/><!-- HANGUL SYLLABLE SYEB -->
+      <map code="0xc182" name="1em"/><!-- HANGUL SYLLABLE SYEBS -->
+      <map code="0xc183" name="1em"/><!-- HANGUL SYLLABLE SYES -->
+      <map code="0xc184" name="1em"/><!-- HANGUL SYLLABLE SYESS -->
+      <map code="0xc185" name="1em"/><!-- HANGUL SYLLABLE SYENG -->
+      <map code="0xc186" name="1em"/><!-- HANGUL SYLLABLE SYEJ -->
+      <map code="0xc187" name="1em"/><!-- HANGUL SYLLABLE SYEC -->
+      <map code="0xc188" name="1em"/><!-- HANGUL SYLLABLE SYEK -->
+      <map code="0xc189" name="1em"/><!-- HANGUL SYLLABLE SYET -->
+      <map code="0xc18a" name="1em"/><!-- HANGUL SYLLABLE SYEP -->
+      <map code="0xc18b" name="1em"/><!-- HANGUL SYLLABLE SYEH -->
+      <map code="0xc18c" name="1em"/><!-- HANGUL SYLLABLE SO -->
+      <map code="0xc18d" name="1em"/><!-- HANGUL SYLLABLE SOG -->
+      <map code="0xc18e" name="1em"/><!-- HANGUL SYLLABLE SOGG -->
+      <map code="0xc18f" name="1em"/><!-- HANGUL SYLLABLE SOGS -->
+      <map code="0xc190" name="1em"/><!-- HANGUL SYLLABLE SON -->
+      <map code="0xc191" name="1em"/><!-- HANGUL SYLLABLE SONJ -->
+      <map code="0xc192" name="1em"/><!-- HANGUL SYLLABLE SONH -->
+      <map code="0xc193" name="1em"/><!-- HANGUL SYLLABLE SOD -->
+      <map code="0xc194" name="1em"/><!-- HANGUL SYLLABLE SOL -->
+      <map code="0xc195" name="1em"/><!-- HANGUL SYLLABLE SOLG -->
+      <map code="0xc196" name="1em"/><!-- HANGUL SYLLABLE SOLM -->
+      <map code="0xc197" name="1em"/><!-- HANGUL SYLLABLE SOLB -->
+      <map code="0xc198" name="1em"/><!-- HANGUL SYLLABLE SOLS -->
+      <map code="0xc199" name="1em"/><!-- HANGUL SYLLABLE SOLT -->
+      <map code="0xc19a" name="1em"/><!-- HANGUL SYLLABLE SOLP -->
+      <map code="0xc19b" name="1em"/><!-- HANGUL SYLLABLE SOLH -->
+      <map code="0xc19c" name="1em"/><!-- HANGUL SYLLABLE SOM -->
+      <map code="0xc19d" name="1em"/><!-- HANGUL SYLLABLE SOB -->
+      <map code="0xc19e" name="1em"/><!-- HANGUL SYLLABLE SOBS -->
+      <map code="0xc19f" name="1em"/><!-- HANGUL SYLLABLE SOS -->
+      <map code="0xc1a0" name="1em"/><!-- HANGUL SYLLABLE SOSS -->
+      <map code="0xc1a1" name="1em"/><!-- HANGUL SYLLABLE SONG -->
+      <map code="0xc1a2" name="1em"/><!-- HANGUL SYLLABLE SOJ -->
+      <map code="0xc1a3" name="1em"/><!-- HANGUL SYLLABLE SOC -->
+      <map code="0xc1a4" name="1em"/><!-- HANGUL SYLLABLE SOK -->
+      <map code="0xc1a5" name="1em"/><!-- HANGUL SYLLABLE SOT -->
+      <map code="0xc1a6" name="1em"/><!-- HANGUL SYLLABLE SOP -->
+      <map code="0xc1a7" name="1em"/><!-- HANGUL SYLLABLE SOH -->
+      <map code="0xc1a8" name="1em"/><!-- HANGUL SYLLABLE SWA -->
+      <map code="0xc1a9" name="1em"/><!-- HANGUL SYLLABLE SWAG -->
+      <map code="0xc1aa" name="1em"/><!-- HANGUL SYLLABLE SWAGG -->
+      <map code="0xc1ab" name="1em"/><!-- HANGUL SYLLABLE SWAGS -->
+      <map code="0xc1ac" name="1em"/><!-- HANGUL SYLLABLE SWAN -->
+      <map code="0xc1ad" name="1em"/><!-- HANGUL SYLLABLE SWANJ -->
+      <map code="0xc1ae" name="1em"/><!-- HANGUL SYLLABLE SWANH -->
+      <map code="0xc1af" name="1em"/><!-- HANGUL SYLLABLE SWAD -->
+      <map code="0xc1b0" name="1em"/><!-- HANGUL SYLLABLE SWAL -->
+      <map code="0xc1b1" name="1em"/><!-- HANGUL SYLLABLE SWALG -->
+      <map code="0xc1b2" name="1em"/><!-- HANGUL SYLLABLE SWALM -->
+      <map code="0xc1b3" name="1em"/><!-- HANGUL SYLLABLE SWALB -->
+      <map code="0xc1b4" name="1em"/><!-- HANGUL SYLLABLE SWALS -->
+      <map code="0xc1b5" name="1em"/><!-- HANGUL SYLLABLE SWALT -->
+      <map code="0xc1b6" name="1em"/><!-- HANGUL SYLLABLE SWALP -->
+      <map code="0xc1b7" name="1em"/><!-- HANGUL SYLLABLE SWALH -->
+      <map code="0xc1b8" name="1em"/><!-- HANGUL SYLLABLE SWAM -->
+      <map code="0xc1b9" name="1em"/><!-- HANGUL SYLLABLE SWAB -->
+      <map code="0xc1ba" name="1em"/><!-- HANGUL SYLLABLE SWABS -->
+      <map code="0xc1bb" name="1em"/><!-- HANGUL SYLLABLE SWAS -->
+      <map code="0xc1bc" name="1em"/><!-- HANGUL SYLLABLE SWASS -->
+      <map code="0xc1bd" name="1em"/><!-- HANGUL SYLLABLE SWANG -->
+      <map code="0xc1be" name="1em"/><!-- HANGUL SYLLABLE SWAJ -->
+      <map code="0xc1bf" name="1em"/><!-- HANGUL SYLLABLE SWAC -->
+      <map code="0xc1c0" name="1em"/><!-- HANGUL SYLLABLE SWAK -->
+      <map code="0xc1c1" name="1em"/><!-- HANGUL SYLLABLE SWAT -->
+      <map code="0xc1c2" name="1em"/><!-- HANGUL SYLLABLE SWAP -->
+      <map code="0xc1c3" name="1em"/><!-- HANGUL SYLLABLE SWAH -->
+      <map code="0xc1c4" name="1em"/><!-- HANGUL SYLLABLE SWAE -->
+      <map code="0xc1c5" name="1em"/><!-- HANGUL SYLLABLE SWAEG -->
+      <map code="0xc1c6" name="1em"/><!-- HANGUL SYLLABLE SWAEGG -->
+      <map code="0xc1c7" name="1em"/><!-- HANGUL SYLLABLE SWAEGS -->
+      <map code="0xc1c8" name="1em"/><!-- HANGUL SYLLABLE SWAEN -->
+      <map code="0xc1c9" name="1em"/><!-- HANGUL SYLLABLE SWAENJ -->
+      <map code="0xc1ca" name="1em"/><!-- HANGUL SYLLABLE SWAENH -->
+      <map code="0xc1cb" name="1em"/><!-- HANGUL SYLLABLE SWAED -->
+      <map code="0xc1cc" name="1em"/><!-- HANGUL SYLLABLE SWAEL -->
+      <map code="0xc1cd" name="1em"/><!-- HANGUL SYLLABLE SWAELG -->
+      <map code="0xc1ce" name="1em"/><!-- HANGUL SYLLABLE SWAELM -->
+      <map code="0xc1cf" name="1em"/><!-- HANGUL SYLLABLE SWAELB -->
+      <map code="0xc1d0" name="1em"/><!-- HANGUL SYLLABLE SWAELS -->
+      <map code="0xc1d1" name="1em"/><!-- HANGUL SYLLABLE SWAELT -->
+      <map code="0xc1d2" name="1em"/><!-- HANGUL SYLLABLE SWAELP -->
+      <map code="0xc1d3" name="1em"/><!-- HANGUL SYLLABLE SWAELH -->
+      <map code="0xc1d4" name="1em"/><!-- HANGUL SYLLABLE SWAEM -->
+      <map code="0xc1d5" name="1em"/><!-- HANGUL SYLLABLE SWAEB -->
+      <map code="0xc1d6" name="1em"/><!-- HANGUL SYLLABLE SWAEBS -->
+      <map code="0xc1d7" name="1em"/><!-- HANGUL SYLLABLE SWAES -->
+      <map code="0xc1d8" name="1em"/><!-- HANGUL SYLLABLE SWAESS -->
+      <map code="0xc1d9" name="1em"/><!-- HANGUL SYLLABLE SWAENG -->
+      <map code="0xc1da" name="1em"/><!-- HANGUL SYLLABLE SWAEJ -->
+      <map code="0xc1db" name="1em"/><!-- HANGUL SYLLABLE SWAEC -->
+      <map code="0xc1dc" name="1em"/><!-- HANGUL SYLLABLE SWAEK -->
+      <map code="0xc1dd" name="1em"/><!-- HANGUL SYLLABLE SWAET -->
+      <map code="0xc1de" name="1em"/><!-- HANGUL SYLLABLE SWAEP -->
+      <map code="0xc1df" name="1em"/><!-- HANGUL SYLLABLE SWAEH -->
+      <map code="0xc1e0" name="1em"/><!-- HANGUL SYLLABLE SOE -->
+      <map code="0xc1e1" name="1em"/><!-- HANGUL SYLLABLE SOEG -->
+      <map code="0xc1e2" name="1em"/><!-- HANGUL SYLLABLE SOEGG -->
+      <map code="0xc1e3" name="1em"/><!-- HANGUL SYLLABLE SOEGS -->
+      <map code="0xc1e4" name="1em"/><!-- HANGUL SYLLABLE SOEN -->
+      <map code="0xc1e5" name="1em"/><!-- HANGUL SYLLABLE SOENJ -->
+      <map code="0xc1e6" name="1em"/><!-- HANGUL SYLLABLE SOENH -->
+      <map code="0xc1e7" name="1em"/><!-- HANGUL SYLLABLE SOED -->
+      <map code="0xc1e8" name="1em"/><!-- HANGUL SYLLABLE SOEL -->
+      <map code="0xc1e9" name="1em"/><!-- HANGUL SYLLABLE SOELG -->
+      <map code="0xc1ea" name="1em"/><!-- HANGUL SYLLABLE SOELM -->
+      <map code="0xc1eb" name="1em"/><!-- HANGUL SYLLABLE SOELB -->
+      <map code="0xc1ec" name="1em"/><!-- HANGUL SYLLABLE SOELS -->
+      <map code="0xc1ed" name="1em"/><!-- HANGUL SYLLABLE SOELT -->
+      <map code="0xc1ee" name="1em"/><!-- HANGUL SYLLABLE SOELP -->
+      <map code="0xc1ef" name="1em"/><!-- HANGUL SYLLABLE SOELH -->
+      <map code="0xc1f0" name="1em"/><!-- HANGUL SYLLABLE SOEM -->
+      <map code="0xc1f1" name="1em"/><!-- HANGUL SYLLABLE SOEB -->
+      <map code="0xc1f2" name="1em"/><!-- HANGUL SYLLABLE SOEBS -->
+      <map code="0xc1f3" name="1em"/><!-- HANGUL SYLLABLE SOES -->
+      <map code="0xc1f4" name="1em"/><!-- HANGUL SYLLABLE SOESS -->
+      <map code="0xc1f5" name="1em"/><!-- HANGUL SYLLABLE SOENG -->
+      <map code="0xc1f6" name="1em"/><!-- HANGUL SYLLABLE SOEJ -->
+      <map code="0xc1f7" name="1em"/><!-- HANGUL SYLLABLE SOEC -->
+      <map code="0xc1f8" name="1em"/><!-- HANGUL SYLLABLE SOEK -->
+      <map code="0xc1f9" name="1em"/><!-- HANGUL SYLLABLE SOET -->
+      <map code="0xc1fa" name="1em"/><!-- HANGUL SYLLABLE SOEP -->
+      <map code="0xc1fb" name="1em"/><!-- HANGUL SYLLABLE SOEH -->
+      <map code="0xc1fc" name="1em"/><!-- HANGUL SYLLABLE SYO -->
+      <map code="0xc1fd" name="1em"/><!-- HANGUL SYLLABLE SYOG -->
+      <map code="0xc1fe" name="1em"/><!-- HANGUL SYLLABLE SYOGG -->
+      <map code="0xc1ff" name="1em"/><!-- HANGUL SYLLABLE SYOGS -->
+      <map code="0xc200" name="1em"/><!-- HANGUL SYLLABLE SYON -->
+      <map code="0xc201" name="1em"/><!-- HANGUL SYLLABLE SYONJ -->
+      <map code="0xc202" name="1em"/><!-- HANGUL SYLLABLE SYONH -->
+      <map code="0xc203" name="1em"/><!-- HANGUL SYLLABLE SYOD -->
+      <map code="0xc204" name="1em"/><!-- HANGUL SYLLABLE SYOL -->
+      <map code="0xc205" name="1em"/><!-- HANGUL SYLLABLE SYOLG -->
+      <map code="0xc206" name="1em"/><!-- HANGUL SYLLABLE SYOLM -->
+      <map code="0xc207" name="1em"/><!-- HANGUL SYLLABLE SYOLB -->
+      <map code="0xc208" name="1em"/><!-- HANGUL SYLLABLE SYOLS -->
+      <map code="0xc209" name="1em"/><!-- HANGUL SYLLABLE SYOLT -->
+      <map code="0xc20a" name="1em"/><!-- HANGUL SYLLABLE SYOLP -->
+      <map code="0xc20b" name="1em"/><!-- HANGUL SYLLABLE SYOLH -->
+      <map code="0xc20c" name="1em"/><!-- HANGUL SYLLABLE SYOM -->
+      <map code="0xc20d" name="1em"/><!-- HANGUL SYLLABLE SYOB -->
+      <map code="0xc20e" name="1em"/><!-- HANGUL SYLLABLE SYOBS -->
+      <map code="0xc20f" name="1em"/><!-- HANGUL SYLLABLE SYOS -->
+      <map code="0xc210" name="1em"/><!-- HANGUL SYLLABLE SYOSS -->
+      <map code="0xc211" name="1em"/><!-- HANGUL SYLLABLE SYONG -->
+      <map code="0xc212" name="1em"/><!-- HANGUL SYLLABLE SYOJ -->
+      <map code="0xc213" name="1em"/><!-- HANGUL SYLLABLE SYOC -->
+      <map code="0xc214" name="1em"/><!-- HANGUL SYLLABLE SYOK -->
+      <map code="0xc215" name="1em"/><!-- HANGUL SYLLABLE SYOT -->
+      <map code="0xc216" name="1em"/><!-- HANGUL SYLLABLE SYOP -->
+      <map code="0xc217" name="1em"/><!-- HANGUL SYLLABLE SYOH -->
+      <map code="0xc218" name="1em"/><!-- HANGUL SYLLABLE SU -->
+      <map code="0xc219" name="1em"/><!-- HANGUL SYLLABLE SUG -->
+      <map code="0xc21a" name="1em"/><!-- HANGUL SYLLABLE SUGG -->
+      <map code="0xc21b" name="1em"/><!-- HANGUL SYLLABLE SUGS -->
+      <map code="0xc21c" name="1em"/><!-- HANGUL SYLLABLE SUN -->
+      <map code="0xc21d" name="1em"/><!-- HANGUL SYLLABLE SUNJ -->
+      <map code="0xc21e" name="1em"/><!-- HANGUL SYLLABLE SUNH -->
+      <map code="0xc21f" name="1em"/><!-- HANGUL SYLLABLE SUD -->
+      <map code="0xc220" name="1em"/><!-- HANGUL SYLLABLE SUL -->
+      <map code="0xc221" name="1em"/><!-- HANGUL SYLLABLE SULG -->
+      <map code="0xc222" name="1em"/><!-- HANGUL SYLLABLE SULM -->
+      <map code="0xc223" name="1em"/><!-- HANGUL SYLLABLE SULB -->
+      <map code="0xc224" name="1em"/><!-- HANGUL SYLLABLE SULS -->
+      <map code="0xc225" name="1em"/><!-- HANGUL SYLLABLE SULT -->
+      <map code="0xc226" name="1em"/><!-- HANGUL SYLLABLE SULP -->
+      <map code="0xc227" name="1em"/><!-- HANGUL SYLLABLE SULH -->
+      <map code="0xc228" name="1em"/><!-- HANGUL SYLLABLE SUM -->
+      <map code="0xc229" name="1em"/><!-- HANGUL SYLLABLE SUB -->
+      <map code="0xc22a" name="1em"/><!-- HANGUL SYLLABLE SUBS -->
+      <map code="0xc22b" name="1em"/><!-- HANGUL SYLLABLE SUS -->
+      <map code="0xc22c" name="1em"/><!-- HANGUL SYLLABLE SUSS -->
+      <map code="0xc22d" name="1em"/><!-- HANGUL SYLLABLE SUNG -->
+      <map code="0xc22e" name="1em"/><!-- HANGUL SYLLABLE SUJ -->
+      <map code="0xc22f" name="1em"/><!-- HANGUL SYLLABLE SUC -->
+      <map code="0xc230" name="1em"/><!-- HANGUL SYLLABLE SUK -->
+      <map code="0xc231" name="1em"/><!-- HANGUL SYLLABLE SUT -->
+      <map code="0xc232" name="1em"/><!-- HANGUL SYLLABLE SUP -->
+      <map code="0xc233" name="1em"/><!-- HANGUL SYLLABLE SUH -->
+      <map code="0xc234" name="1em"/><!-- HANGUL SYLLABLE SWEO -->
+      <map code="0xc235" name="1em"/><!-- HANGUL SYLLABLE SWEOG -->
+      <map code="0xc236" name="1em"/><!-- HANGUL SYLLABLE SWEOGG -->
+      <map code="0xc237" name="1em"/><!-- HANGUL SYLLABLE SWEOGS -->
+      <map code="0xc238" name="1em"/><!-- HANGUL SYLLABLE SWEON -->
+      <map code="0xc239" name="1em"/><!-- HANGUL SYLLABLE SWEONJ -->
+      <map code="0xc23a" name="1em"/><!-- HANGUL SYLLABLE SWEONH -->
+      <map code="0xc23b" name="1em"/><!-- HANGUL SYLLABLE SWEOD -->
+      <map code="0xc23c" name="1em"/><!-- HANGUL SYLLABLE SWEOL -->
+      <map code="0xc23d" name="1em"/><!-- HANGUL SYLLABLE SWEOLG -->
+      <map code="0xc23e" name="1em"/><!-- HANGUL SYLLABLE SWEOLM -->
+      <map code="0xc23f" name="1em"/><!-- HANGUL SYLLABLE SWEOLB -->
+      <map code="0xc240" name="1em"/><!-- HANGUL SYLLABLE SWEOLS -->
+      <map code="0xc241" name="1em"/><!-- HANGUL SYLLABLE SWEOLT -->
+      <map code="0xc242" name="1em"/><!-- HANGUL SYLLABLE SWEOLP -->
+      <map code="0xc243" name="1em"/><!-- HANGUL SYLLABLE SWEOLH -->
+      <map code="0xc244" name="1em"/><!-- HANGUL SYLLABLE SWEOM -->
+      <map code="0xc245" name="1em"/><!-- HANGUL SYLLABLE SWEOB -->
+      <map code="0xc246" name="1em"/><!-- HANGUL SYLLABLE SWEOBS -->
+      <map code="0xc247" name="1em"/><!-- HANGUL SYLLABLE SWEOS -->
+      <map code="0xc248" name="1em"/><!-- HANGUL SYLLABLE SWEOSS -->
+      <map code="0xc249" name="1em"/><!-- HANGUL SYLLABLE SWEONG -->
+      <map code="0xc24a" name="1em"/><!-- HANGUL SYLLABLE SWEOJ -->
+      <map code="0xc24b" name="1em"/><!-- HANGUL SYLLABLE SWEOC -->
+      <map code="0xc24c" name="1em"/><!-- HANGUL SYLLABLE SWEOK -->
+      <map code="0xc24d" name="1em"/><!-- HANGUL SYLLABLE SWEOT -->
+      <map code="0xc24e" name="1em"/><!-- HANGUL SYLLABLE SWEOP -->
+      <map code="0xc24f" name="1em"/><!-- HANGUL SYLLABLE SWEOH -->
+      <map code="0xc250" name="1em"/><!-- HANGUL SYLLABLE SWE -->
+      <map code="0xc251" name="1em"/><!-- HANGUL SYLLABLE SWEG -->
+      <map code="0xc252" name="1em"/><!-- HANGUL SYLLABLE SWEGG -->
+      <map code="0xc253" name="1em"/><!-- HANGUL SYLLABLE SWEGS -->
+      <map code="0xc254" name="1em"/><!-- HANGUL SYLLABLE SWEN -->
+      <map code="0xc255" name="1em"/><!-- HANGUL SYLLABLE SWENJ -->
+      <map code="0xc256" name="1em"/><!-- HANGUL SYLLABLE SWENH -->
+      <map code="0xc257" name="1em"/><!-- HANGUL SYLLABLE SWED -->
+      <map code="0xc258" name="1em"/><!-- HANGUL SYLLABLE SWEL -->
+      <map code="0xc259" name="1em"/><!-- HANGUL SYLLABLE SWELG -->
+      <map code="0xc25a" name="1em"/><!-- HANGUL SYLLABLE SWELM -->
+      <map code="0xc25b" name="1em"/><!-- HANGUL SYLLABLE SWELB -->
+      <map code="0xc25c" name="1em"/><!-- HANGUL SYLLABLE SWELS -->
+      <map code="0xc25d" name="1em"/><!-- HANGUL SYLLABLE SWELT -->
+      <map code="0xc25e" name="1em"/><!-- HANGUL SYLLABLE SWELP -->
+      <map code="0xc25f" name="1em"/><!-- HANGUL SYLLABLE SWELH -->
+      <map code="0xc260" name="1em"/><!-- HANGUL SYLLABLE SWEM -->
+      <map code="0xc261" name="1em"/><!-- HANGUL SYLLABLE SWEB -->
+      <map code="0xc262" name="1em"/><!-- HANGUL SYLLABLE SWEBS -->
+      <map code="0xc263" name="1em"/><!-- HANGUL SYLLABLE SWES -->
+      <map code="0xc264" name="1em"/><!-- HANGUL SYLLABLE SWESS -->
+      <map code="0xc265" name="1em"/><!-- HANGUL SYLLABLE SWENG -->
+      <map code="0xc266" name="1em"/><!-- HANGUL SYLLABLE SWEJ -->
+      <map code="0xc267" name="1em"/><!-- HANGUL SYLLABLE SWEC -->
+      <map code="0xc268" name="1em"/><!-- HANGUL SYLLABLE SWEK -->
+      <map code="0xc269" name="1em"/><!-- HANGUL SYLLABLE SWET -->
+      <map code="0xc26a" name="1em"/><!-- HANGUL SYLLABLE SWEP -->
+      <map code="0xc26b" name="1em"/><!-- HANGUL SYLLABLE SWEH -->
+      <map code="0xc26c" name="1em"/><!-- HANGUL SYLLABLE SWI -->
+      <map code="0xc26d" name="1em"/><!-- HANGUL SYLLABLE SWIG -->
+      <map code="0xc26e" name="1em"/><!-- HANGUL SYLLABLE SWIGG -->
+      <map code="0xc26f" name="1em"/><!-- HANGUL SYLLABLE SWIGS -->
+      <map code="0xc270" name="1em"/><!-- HANGUL SYLLABLE SWIN -->
+      <map code="0xc271" name="1em"/><!-- HANGUL SYLLABLE SWINJ -->
+      <map code="0xc272" name="1em"/><!-- HANGUL SYLLABLE SWINH -->
+      <map code="0xc273" name="1em"/><!-- HANGUL SYLLABLE SWID -->
+      <map code="0xc274" name="1em"/><!-- HANGUL SYLLABLE SWIL -->
+      <map code="0xc275" name="1em"/><!-- HANGUL SYLLABLE SWILG -->
+      <map code="0xc276" name="1em"/><!-- HANGUL SYLLABLE SWILM -->
+      <map code="0xc277" name="1em"/><!-- HANGUL SYLLABLE SWILB -->
+      <map code="0xc278" name="1em"/><!-- HANGUL SYLLABLE SWILS -->
+      <map code="0xc279" name="1em"/><!-- HANGUL SYLLABLE SWILT -->
+      <map code="0xc27a" name="1em"/><!-- HANGUL SYLLABLE SWILP -->
+      <map code="0xc27b" name="1em"/><!-- HANGUL SYLLABLE SWILH -->
+      <map code="0xc27c" name="1em"/><!-- HANGUL SYLLABLE SWIM -->
+      <map code="0xc27d" name="1em"/><!-- HANGUL SYLLABLE SWIB -->
+      <map code="0xc27e" name="1em"/><!-- HANGUL SYLLABLE SWIBS -->
+      <map code="0xc27f" name="1em"/><!-- HANGUL SYLLABLE SWIS -->
+      <map code="0xc280" name="1em"/><!-- HANGUL SYLLABLE SWISS -->
+      <map code="0xc281" name="1em"/><!-- HANGUL SYLLABLE SWING -->
+      <map code="0xc282" name="1em"/><!-- HANGUL SYLLABLE SWIJ -->
+      <map code="0xc283" name="1em"/><!-- HANGUL SYLLABLE SWIC -->
+      <map code="0xc284" name="1em"/><!-- HANGUL SYLLABLE SWIK -->
+      <map code="0xc285" name="1em"/><!-- HANGUL SYLLABLE SWIT -->
+      <map code="0xc286" name="1em"/><!-- HANGUL SYLLABLE SWIP -->
+      <map code="0xc287" name="1em"/><!-- HANGUL SYLLABLE SWIH -->
+      <map code="0xc288" name="1em"/><!-- HANGUL SYLLABLE SYU -->
+      <map code="0xc289" name="1em"/><!-- HANGUL SYLLABLE SYUG -->
+      <map code="0xc28a" name="1em"/><!-- HANGUL SYLLABLE SYUGG -->
+      <map code="0xc28b" name="1em"/><!-- HANGUL SYLLABLE SYUGS -->
+      <map code="0xc28c" name="1em"/><!-- HANGUL SYLLABLE SYUN -->
+      <map code="0xc28d" name="1em"/><!-- HANGUL SYLLABLE SYUNJ -->
+      <map code="0xc28e" name="1em"/><!-- HANGUL SYLLABLE SYUNH -->
+      <map code="0xc28f" name="1em"/><!-- HANGUL SYLLABLE SYUD -->
+      <map code="0xc290" name="1em"/><!-- HANGUL SYLLABLE SYUL -->
+      <map code="0xc291" name="1em"/><!-- HANGUL SYLLABLE SYULG -->
+      <map code="0xc292" name="1em"/><!-- HANGUL SYLLABLE SYULM -->
+      <map code="0xc293" name="1em"/><!-- HANGUL SYLLABLE SYULB -->
+      <map code="0xc294" name="1em"/><!-- HANGUL SYLLABLE SYULS -->
+      <map code="0xc295" name="1em"/><!-- HANGUL SYLLABLE SYULT -->
+      <map code="0xc296" name="1em"/><!-- HANGUL SYLLABLE SYULP -->
+      <map code="0xc297" name="1em"/><!-- HANGUL SYLLABLE SYULH -->
+      <map code="0xc298" name="1em"/><!-- HANGUL SYLLABLE SYUM -->
+      <map code="0xc299" name="1em"/><!-- HANGUL SYLLABLE SYUB -->
+      <map code="0xc29a" name="1em"/><!-- HANGUL SYLLABLE SYUBS -->
+      <map code="0xc29b" name="1em"/><!-- HANGUL SYLLABLE SYUS -->
+      <map code="0xc29c" name="1em"/><!-- HANGUL SYLLABLE SYUSS -->
+      <map code="0xc29d" name="1em"/><!-- HANGUL SYLLABLE SYUNG -->
+      <map code="0xc29e" name="1em"/><!-- HANGUL SYLLABLE SYUJ -->
+      <map code="0xc29f" name="1em"/><!-- HANGUL SYLLABLE SYUC -->
+      <map code="0xc2a0" name="1em"/><!-- HANGUL SYLLABLE SYUK -->
+      <map code="0xc2a1" name="1em"/><!-- HANGUL SYLLABLE SYUT -->
+      <map code="0xc2a2" name="1em"/><!-- HANGUL SYLLABLE SYUP -->
+      <map code="0xc2a3" name="1em"/><!-- HANGUL SYLLABLE SYUH -->
+      <map code="0xc2a4" name="1em"/><!-- HANGUL SYLLABLE SEU -->
+      <map code="0xc2a5" name="1em"/><!-- HANGUL SYLLABLE SEUG -->
+      <map code="0xc2a6" name="1em"/><!-- HANGUL SYLLABLE SEUGG -->
+      <map code="0xc2a7" name="1em"/><!-- HANGUL SYLLABLE SEUGS -->
+      <map code="0xc2a8" name="1em"/><!-- HANGUL SYLLABLE SEUN -->
+      <map code="0xc2a9" name="1em"/><!-- HANGUL SYLLABLE SEUNJ -->
+      <map code="0xc2aa" name="1em"/><!-- HANGUL SYLLABLE SEUNH -->
+      <map code="0xc2ab" name="1em"/><!-- HANGUL SYLLABLE SEUD -->
+      <map code="0xc2ac" name="1em"/><!-- HANGUL SYLLABLE SEUL -->
+      <map code="0xc2ad" name="1em"/><!-- HANGUL SYLLABLE SEULG -->
+      <map code="0xc2ae" name="1em"/><!-- HANGUL SYLLABLE SEULM -->
+      <map code="0xc2af" name="1em"/><!-- HANGUL SYLLABLE SEULB -->
+      <map code="0xc2b0" name="1em"/><!-- HANGUL SYLLABLE SEULS -->
+      <map code="0xc2b1" name="1em"/><!-- HANGUL SYLLABLE SEULT -->
+      <map code="0xc2b2" name="1em"/><!-- HANGUL SYLLABLE SEULP -->
+      <map code="0xc2b3" name="1em"/><!-- HANGUL SYLLABLE SEULH -->
+      <map code="0xc2b4" name="1em"/><!-- HANGUL SYLLABLE SEUM -->
+      <map code="0xc2b5" name="1em"/><!-- HANGUL SYLLABLE SEUB -->
+      <map code="0xc2b6" name="1em"/><!-- HANGUL SYLLABLE SEUBS -->
+      <map code="0xc2b7" name="1em"/><!-- HANGUL SYLLABLE SEUS -->
+      <map code="0xc2b8" name="1em"/><!-- HANGUL SYLLABLE SEUSS -->
+      <map code="0xc2b9" name="1em"/><!-- HANGUL SYLLABLE SEUNG -->
+      <map code="0xc2ba" name="1em"/><!-- HANGUL SYLLABLE SEUJ -->
+      <map code="0xc2bb" name="1em"/><!-- HANGUL SYLLABLE SEUC -->
+      <map code="0xc2bc" name="1em"/><!-- HANGUL SYLLABLE SEUK -->
+      <map code="0xc2bd" name="1em"/><!-- HANGUL SYLLABLE SEUT -->
+      <map code="0xc2be" name="1em"/><!-- HANGUL SYLLABLE SEUP -->
+      <map code="0xc2bf" name="1em"/><!-- HANGUL SYLLABLE SEUH -->
+      <map code="0xc2c0" name="1em"/><!-- HANGUL SYLLABLE SYI -->
+      <map code="0xc2c1" name="1em"/><!-- HANGUL SYLLABLE SYIG -->
+      <map code="0xc2c2" name="1em"/><!-- HANGUL SYLLABLE SYIGG -->
+      <map code="0xc2c3" name="1em"/><!-- HANGUL SYLLABLE SYIGS -->
+      <map code="0xc2c4" name="1em"/><!-- HANGUL SYLLABLE SYIN -->
+      <map code="0xc2c5" name="1em"/><!-- HANGUL SYLLABLE SYINJ -->
+      <map code="0xc2c6" name="1em"/><!-- HANGUL SYLLABLE SYINH -->
+      <map code="0xc2c7" name="1em"/><!-- HANGUL SYLLABLE SYID -->
+      <map code="0xc2c8" name="1em"/><!-- HANGUL SYLLABLE SYIL -->
+      <map code="0xc2c9" name="1em"/><!-- HANGUL SYLLABLE SYILG -->
+      <map code="0xc2ca" name="1em"/><!-- HANGUL SYLLABLE SYILM -->
+      <map code="0xc2cb" name="1em"/><!-- HANGUL SYLLABLE SYILB -->
+      <map code="0xc2cc" name="1em"/><!-- HANGUL SYLLABLE SYILS -->
+      <map code="0xc2cd" name="1em"/><!-- HANGUL SYLLABLE SYILT -->
+      <map code="0xc2ce" name="1em"/><!-- HANGUL SYLLABLE SYILP -->
+      <map code="0xc2cf" name="1em"/><!-- HANGUL SYLLABLE SYILH -->
+      <map code="0xc2d0" name="1em"/><!-- HANGUL SYLLABLE SYIM -->
+      <map code="0xc2d1" name="1em"/><!-- HANGUL SYLLABLE SYIB -->
+      <map code="0xc2d2" name="1em"/><!-- HANGUL SYLLABLE SYIBS -->
+      <map code="0xc2d3" name="1em"/><!-- HANGUL SYLLABLE SYIS -->
+      <map code="0xc2d4" name="1em"/><!-- HANGUL SYLLABLE SYISS -->
+      <map code="0xc2d5" name="1em"/><!-- HANGUL SYLLABLE SYING -->
+      <map code="0xc2d6" name="1em"/><!-- HANGUL SYLLABLE SYIJ -->
+      <map code="0xc2d7" name="1em"/><!-- HANGUL SYLLABLE SYIC -->
+      <map code="0xc2d8" name="1em"/><!-- HANGUL SYLLABLE SYIK -->
+      <map code="0xc2d9" name="1em"/><!-- HANGUL SYLLABLE SYIT -->
+      <map code="0xc2da" name="1em"/><!-- HANGUL SYLLABLE SYIP -->
+      <map code="0xc2db" name="1em"/><!-- HANGUL SYLLABLE SYIH -->
+      <map code="0xc2dc" name="1em"/><!-- HANGUL SYLLABLE SI -->
+      <map code="0xc2dd" name="1em"/><!-- HANGUL SYLLABLE SIG -->
+      <map code="0xc2de" name="1em"/><!-- HANGUL SYLLABLE SIGG -->
+      <map code="0xc2df" name="1em"/><!-- HANGUL SYLLABLE SIGS -->
+      <map code="0xc2e0" name="1em"/><!-- HANGUL SYLLABLE SIN -->
+      <map code="0xc2e1" name="1em"/><!-- HANGUL SYLLABLE SINJ -->
+      <map code="0xc2e2" name="1em"/><!-- HANGUL SYLLABLE SINH -->
+      <map code="0xc2e3" name="1em"/><!-- HANGUL SYLLABLE SID -->
+      <map code="0xc2e4" name="1em"/><!-- HANGUL SYLLABLE SIL -->
+      <map code="0xc2e5" name="1em"/><!-- HANGUL SYLLABLE SILG -->
+      <map code="0xc2e6" name="1em"/><!-- HANGUL SYLLABLE SILM -->
+      <map code="0xc2e7" name="1em"/><!-- HANGUL SYLLABLE SILB -->
+      <map code="0xc2e8" name="1em"/><!-- HANGUL SYLLABLE SILS -->
+      <map code="0xc2e9" name="1em"/><!-- HANGUL SYLLABLE SILT -->
+      <map code="0xc2ea" name="1em"/><!-- HANGUL SYLLABLE SILP -->
+      <map code="0xc2eb" name="1em"/><!-- HANGUL SYLLABLE SILH -->
+      <map code="0xc2ec" name="1em"/><!-- HANGUL SYLLABLE SIM -->
+      <map code="0xc2ed" name="1em"/><!-- HANGUL SYLLABLE SIB -->
+      <map code="0xc2ee" name="1em"/><!-- HANGUL SYLLABLE SIBS -->
+      <map code="0xc2ef" name="1em"/><!-- HANGUL SYLLABLE SIS -->
+      <map code="0xc2f0" name="1em"/><!-- HANGUL SYLLABLE SISS -->
+      <map code="0xc2f1" name="1em"/><!-- HANGUL SYLLABLE SING -->
+      <map code="0xc2f2" name="1em"/><!-- HANGUL SYLLABLE SIJ -->
+      <map code="0xc2f3" name="1em"/><!-- HANGUL SYLLABLE SIC -->
+      <map code="0xc2f4" name="1em"/><!-- HANGUL SYLLABLE SIK -->
+      <map code="0xc2f5" name="1em"/><!-- HANGUL SYLLABLE SIT -->
+      <map code="0xc2f6" name="1em"/><!-- HANGUL SYLLABLE SIP -->
+      <map code="0xc2f7" name="1em"/><!-- HANGUL SYLLABLE SIH -->
+      <map code="0xc2f8" name="1em"/><!-- HANGUL SYLLABLE SSA -->
+      <map code="0xc2f9" name="1em"/><!-- HANGUL SYLLABLE SSAG -->
+      <map code="0xc2fa" name="1em"/><!-- HANGUL SYLLABLE SSAGG -->
+      <map code="0xc2fb" name="1em"/><!-- HANGUL SYLLABLE SSAGS -->
+      <map code="0xc2fc" name="1em"/><!-- HANGUL SYLLABLE SSAN -->
+      <map code="0xc2fd" name="1em"/><!-- HANGUL SYLLABLE SSANJ -->
+      <map code="0xc2fe" name="1em"/><!-- HANGUL SYLLABLE SSANH -->
+      <map code="0xc2ff" name="1em"/><!-- HANGUL SYLLABLE SSAD -->
+      <map code="0xc300" name="1em"/><!-- HANGUL SYLLABLE SSAL -->
+      <map code="0xc301" name="1em"/><!-- HANGUL SYLLABLE SSALG -->
+      <map code="0xc302" name="1em"/><!-- HANGUL SYLLABLE SSALM -->
+      <map code="0xc303" name="1em"/><!-- HANGUL SYLLABLE SSALB -->
+      <map code="0xc304" name="1em"/><!-- HANGUL SYLLABLE SSALS -->
+      <map code="0xc305" name="1em"/><!-- HANGUL SYLLABLE SSALT -->
+      <map code="0xc306" name="1em"/><!-- HANGUL SYLLABLE SSALP -->
+      <map code="0xc307" name="1em"/><!-- HANGUL SYLLABLE SSALH -->
+      <map code="0xc308" name="1em"/><!-- HANGUL SYLLABLE SSAM -->
+      <map code="0xc309" name="1em"/><!-- HANGUL SYLLABLE SSAB -->
+      <map code="0xc30a" name="1em"/><!-- HANGUL SYLLABLE SSABS -->
+      <map code="0xc30b" name="1em"/><!-- HANGUL SYLLABLE SSAS -->
+      <map code="0xc30c" name="1em"/><!-- HANGUL SYLLABLE SSASS -->
+      <map code="0xc30d" name="1em"/><!-- HANGUL SYLLABLE SSANG -->
+      <map code="0xc30e" name="1em"/><!-- HANGUL SYLLABLE SSAJ -->
+      <map code="0xc30f" name="1em"/><!-- HANGUL SYLLABLE SSAC -->
+      <map code="0xc310" name="1em"/><!-- HANGUL SYLLABLE SSAK -->
+      <map code="0xc311" name="1em"/><!-- HANGUL SYLLABLE SSAT -->
+      <map code="0xc312" name="1em"/><!-- HANGUL SYLLABLE SSAP -->
+      <map code="0xc313" name="1em"/><!-- HANGUL SYLLABLE SSAH -->
+      <map code="0xc314" name="1em"/><!-- HANGUL SYLLABLE SSAE -->
+      <map code="0xc315" name="1em"/><!-- HANGUL SYLLABLE SSAEG -->
+      <map code="0xc316" name="1em"/><!-- HANGUL SYLLABLE SSAEGG -->
+      <map code="0xc317" name="1em"/><!-- HANGUL SYLLABLE SSAEGS -->
+      <map code="0xc318" name="1em"/><!-- HANGUL SYLLABLE SSAEN -->
+      <map code="0xc319" name="1em"/><!-- HANGUL SYLLABLE SSAENJ -->
+      <map code="0xc31a" name="1em"/><!-- HANGUL SYLLABLE SSAENH -->
+      <map code="0xc31b" name="1em"/><!-- HANGUL SYLLABLE SSAED -->
+      <map code="0xc31c" name="1em"/><!-- HANGUL SYLLABLE SSAEL -->
+      <map code="0xc31d" name="1em"/><!-- HANGUL SYLLABLE SSAELG -->
+      <map code="0xc31e" name="1em"/><!-- HANGUL SYLLABLE SSAELM -->
+      <map code="0xc31f" name="1em"/><!-- HANGUL SYLLABLE SSAELB -->
+      <map code="0xc320" name="1em"/><!-- HANGUL SYLLABLE SSAELS -->
+      <map code="0xc321" name="1em"/><!-- HANGUL SYLLABLE SSAELT -->
+      <map code="0xc322" name="1em"/><!-- HANGUL SYLLABLE SSAELP -->
+      <map code="0xc323" name="1em"/><!-- HANGUL SYLLABLE SSAELH -->
+      <map code="0xc324" name="1em"/><!-- HANGUL SYLLABLE SSAEM -->
+      <map code="0xc325" name="1em"/><!-- HANGUL SYLLABLE SSAEB -->
+      <map code="0xc326" name="1em"/><!-- HANGUL SYLLABLE SSAEBS -->
+      <map code="0xc327" name="1em"/><!-- HANGUL SYLLABLE SSAES -->
+      <map code="0xc328" name="1em"/><!-- HANGUL SYLLABLE SSAESS -->
+      <map code="0xc329" name="1em"/><!-- HANGUL SYLLABLE SSAENG -->
+      <map code="0xc32a" name="1em"/><!-- HANGUL SYLLABLE SSAEJ -->
+      <map code="0xc32b" name="1em"/><!-- HANGUL SYLLABLE SSAEC -->
+      <map code="0xc32c" name="1em"/><!-- HANGUL SYLLABLE SSAEK -->
+      <map code="0xc32d" name="1em"/><!-- HANGUL SYLLABLE SSAET -->
+      <map code="0xc32e" name="1em"/><!-- HANGUL SYLLABLE SSAEP -->
+      <map code="0xc32f" name="1em"/><!-- HANGUL SYLLABLE SSAEH -->
+      <map code="0xc330" name="1em"/><!-- HANGUL SYLLABLE SSYA -->
+      <map code="0xc331" name="1em"/><!-- HANGUL SYLLABLE SSYAG -->
+      <map code="0xc332" name="1em"/><!-- HANGUL SYLLABLE SSYAGG -->
+      <map code="0xc333" name="1em"/><!-- HANGUL SYLLABLE SSYAGS -->
+      <map code="0xc334" name="1em"/><!-- HANGUL SYLLABLE SSYAN -->
+      <map code="0xc335" name="1em"/><!-- HANGUL SYLLABLE SSYANJ -->
+      <map code="0xc336" name="1em"/><!-- HANGUL SYLLABLE SSYANH -->
+      <map code="0xc337" name="1em"/><!-- HANGUL SYLLABLE SSYAD -->
+      <map code="0xc338" name="1em"/><!-- HANGUL SYLLABLE SSYAL -->
+      <map code="0xc339" name="1em"/><!-- HANGUL SYLLABLE SSYALG -->
+      <map code="0xc33a" name="1em"/><!-- HANGUL SYLLABLE SSYALM -->
+      <map code="0xc33b" name="1em"/><!-- HANGUL SYLLABLE SSYALB -->
+      <map code="0xc33c" name="1em"/><!-- HANGUL SYLLABLE SSYALS -->
+      <map code="0xc33d" name="1em"/><!-- HANGUL SYLLABLE SSYALT -->
+      <map code="0xc33e" name="1em"/><!-- HANGUL SYLLABLE SSYALP -->
+      <map code="0xc33f" name="1em"/><!-- HANGUL SYLLABLE SSYALH -->
+      <map code="0xc340" name="1em"/><!-- HANGUL SYLLABLE SSYAM -->
+      <map code="0xc341" name="1em"/><!-- HANGUL SYLLABLE SSYAB -->
+      <map code="0xc342" name="1em"/><!-- HANGUL SYLLABLE SSYABS -->
+      <map code="0xc343" name="1em"/><!-- HANGUL SYLLABLE SSYAS -->
+      <map code="0xc344" name="1em"/><!-- HANGUL SYLLABLE SSYASS -->
+      <map code="0xc345" name="1em"/><!-- HANGUL SYLLABLE SSYANG -->
+      <map code="0xc346" name="1em"/><!-- HANGUL SYLLABLE SSYAJ -->
+      <map code="0xc347" name="1em"/><!-- HANGUL SYLLABLE SSYAC -->
+      <map code="0xc348" name="1em"/><!-- HANGUL SYLLABLE SSYAK -->
+      <map code="0xc349" name="1em"/><!-- HANGUL SYLLABLE SSYAT -->
+      <map code="0xc34a" name="1em"/><!-- HANGUL SYLLABLE SSYAP -->
+      <map code="0xc34b" name="1em"/><!-- HANGUL SYLLABLE SSYAH -->
+      <map code="0xc34c" name="1em"/><!-- HANGUL SYLLABLE SSYAE -->
+      <map code="0xc34d" name="1em"/><!-- HANGUL SYLLABLE SSYAEG -->
+      <map code="0xc34e" name="1em"/><!-- HANGUL SYLLABLE SSYAEGG -->
+      <map code="0xc34f" name="1em"/><!-- HANGUL SYLLABLE SSYAEGS -->
+      <map code="0xc350" name="1em"/><!-- HANGUL SYLLABLE SSYAEN -->
+      <map code="0xc351" name="1em"/><!-- HANGUL SYLLABLE SSYAENJ -->
+      <map code="0xc352" name="1em"/><!-- HANGUL SYLLABLE SSYAENH -->
+      <map code="0xc353" name="1em"/><!-- HANGUL SYLLABLE SSYAED -->
+      <map code="0xc354" name="1em"/><!-- HANGUL SYLLABLE SSYAEL -->
+      <map code="0xc355" name="1em"/><!-- HANGUL SYLLABLE SSYAELG -->
+      <map code="0xc356" name="1em"/><!-- HANGUL SYLLABLE SSYAELM -->
+      <map code="0xc357" name="1em"/><!-- HANGUL SYLLABLE SSYAELB -->
+      <map code="0xc358" name="1em"/><!-- HANGUL SYLLABLE SSYAELS -->
+      <map code="0xc359" name="1em"/><!-- HANGUL SYLLABLE SSYAELT -->
+      <map code="0xc35a" name="1em"/><!-- HANGUL SYLLABLE SSYAELP -->
+      <map code="0xc35b" name="1em"/><!-- HANGUL SYLLABLE SSYAELH -->
+      <map code="0xc35c" name="1em"/><!-- HANGUL SYLLABLE SSYAEM -->
+      <map code="0xc35d" name="1em"/><!-- HANGUL SYLLABLE SSYAEB -->
+      <map code="0xc35e" name="1em"/><!-- HANGUL SYLLABLE SSYAEBS -->
+      <map code="0xc35f" name="1em"/><!-- HANGUL SYLLABLE SSYAES -->
+      <map code="0xc360" name="1em"/><!-- HANGUL SYLLABLE SSYAESS -->
+      <map code="0xc361" name="1em"/><!-- HANGUL SYLLABLE SSYAENG -->
+      <map code="0xc362" name="1em"/><!-- HANGUL SYLLABLE SSYAEJ -->
+      <map code="0xc363" name="1em"/><!-- HANGUL SYLLABLE SSYAEC -->
+      <map code="0xc364" name="1em"/><!-- HANGUL SYLLABLE SSYAEK -->
+      <map code="0xc365" name="1em"/><!-- HANGUL SYLLABLE SSYAET -->
+      <map code="0xc366" name="1em"/><!-- HANGUL SYLLABLE SSYAEP -->
+      <map code="0xc367" name="1em"/><!-- HANGUL SYLLABLE SSYAEH -->
+      <map code="0xc368" name="1em"/><!-- HANGUL SYLLABLE SSEO -->
+      <map code="0xc369" name="1em"/><!-- HANGUL SYLLABLE SSEOG -->
+      <map code="0xc36a" name="1em"/><!-- HANGUL SYLLABLE SSEOGG -->
+      <map code="0xc36b" name="1em"/><!-- HANGUL SYLLABLE SSEOGS -->
+      <map code="0xc36c" name="1em"/><!-- HANGUL SYLLABLE SSEON -->
+      <map code="0xc36d" name="1em"/><!-- HANGUL SYLLABLE SSEONJ -->
+      <map code="0xc36e" name="1em"/><!-- HANGUL SYLLABLE SSEONH -->
+      <map code="0xc36f" name="1em"/><!-- HANGUL SYLLABLE SSEOD -->
+      <map code="0xc370" name="1em"/><!-- HANGUL SYLLABLE SSEOL -->
+      <map code="0xc371" name="1em"/><!-- HANGUL SYLLABLE SSEOLG -->
+      <map code="0xc372" name="1em"/><!-- HANGUL SYLLABLE SSEOLM -->
+      <map code="0xc373" name="1em"/><!-- HANGUL SYLLABLE SSEOLB -->
+      <map code="0xc374" name="1em"/><!-- HANGUL SYLLABLE SSEOLS -->
+      <map code="0xc375" name="1em"/><!-- HANGUL SYLLABLE SSEOLT -->
+      <map code="0xc376" name="1em"/><!-- HANGUL SYLLABLE SSEOLP -->
+      <map code="0xc377" name="1em"/><!-- HANGUL SYLLABLE SSEOLH -->
+      <map code="0xc378" name="1em"/><!-- HANGUL SYLLABLE SSEOM -->
+      <map code="0xc379" name="1em"/><!-- HANGUL SYLLABLE SSEOB -->
+      <map code="0xc37a" name="1em"/><!-- HANGUL SYLLABLE SSEOBS -->
+      <map code="0xc37b" name="1em"/><!-- HANGUL SYLLABLE SSEOS -->
+      <map code="0xc37c" name="1em"/><!-- HANGUL SYLLABLE SSEOSS -->
+      <map code="0xc37d" name="1em"/><!-- HANGUL SYLLABLE SSEONG -->
+      <map code="0xc37e" name="1em"/><!-- HANGUL SYLLABLE SSEOJ -->
+      <map code="0xc37f" name="1em"/><!-- HANGUL SYLLABLE SSEOC -->
+      <map code="0xc380" name="1em"/><!-- HANGUL SYLLABLE SSEOK -->
+      <map code="0xc381" name="1em"/><!-- HANGUL SYLLABLE SSEOT -->
+      <map code="0xc382" name="1em"/><!-- HANGUL SYLLABLE SSEOP -->
+      <map code="0xc383" name="1em"/><!-- HANGUL SYLLABLE SSEOH -->
+      <map code="0xc384" name="1em"/><!-- HANGUL SYLLABLE SSE -->
+      <map code="0xc385" name="1em"/><!-- HANGUL SYLLABLE SSEG -->
+      <map code="0xc386" name="1em"/><!-- HANGUL SYLLABLE SSEGG -->
+      <map code="0xc387" name="1em"/><!-- HANGUL SYLLABLE SSEGS -->
+      <map code="0xc388" name="1em"/><!-- HANGUL SYLLABLE SSEN -->
+      <map code="0xc389" name="1em"/><!-- HANGUL SYLLABLE SSENJ -->
+      <map code="0xc38a" name="1em"/><!-- HANGUL SYLLABLE SSENH -->
+      <map code="0xc38b" name="1em"/><!-- HANGUL SYLLABLE SSED -->
+      <map code="0xc38c" name="1em"/><!-- HANGUL SYLLABLE SSEL -->
+      <map code="0xc38d" name="1em"/><!-- HANGUL SYLLABLE SSELG -->
+      <map code="0xc38e" name="1em"/><!-- HANGUL SYLLABLE SSELM -->
+      <map code="0xc38f" name="1em"/><!-- HANGUL SYLLABLE SSELB -->
+      <map code="0xc390" name="1em"/><!-- HANGUL SYLLABLE SSELS -->
+      <map code="0xc391" name="1em"/><!-- HANGUL SYLLABLE SSELT -->
+      <map code="0xc392" name="1em"/><!-- HANGUL SYLLABLE SSELP -->
+      <map code="0xc393" name="1em"/><!-- HANGUL SYLLABLE SSELH -->
+      <map code="0xc394" name="1em"/><!-- HANGUL SYLLABLE SSEM -->
+      <map code="0xc395" name="1em"/><!-- HANGUL SYLLABLE SSEB -->
+      <map code="0xc396" name="1em"/><!-- HANGUL SYLLABLE SSEBS -->
+      <map code="0xc397" name="1em"/><!-- HANGUL SYLLABLE SSES -->
+      <map code="0xc398" name="1em"/><!-- HANGUL SYLLABLE SSESS -->
+      <map code="0xc399" name="1em"/><!-- HANGUL SYLLABLE SSENG -->
+      <map code="0xc39a" name="1em"/><!-- HANGUL SYLLABLE SSEJ -->
+      <map code="0xc39b" name="1em"/><!-- HANGUL SYLLABLE SSEC -->
+      <map code="0xc39c" name="1em"/><!-- HANGUL SYLLABLE SSEK -->
+      <map code="0xc39d" name="1em"/><!-- HANGUL SYLLABLE SSET -->
+      <map code="0xc39e" name="1em"/><!-- HANGUL SYLLABLE SSEP -->
+      <map code="0xc39f" name="1em"/><!-- HANGUL SYLLABLE SSEH -->
+      <map code="0xc3a0" name="1em"/><!-- HANGUL SYLLABLE SSYEO -->
+      <map code="0xc3a1" name="1em"/><!-- HANGUL SYLLABLE SSYEOG -->
+      <map code="0xc3a2" name="1em"/><!-- HANGUL SYLLABLE SSYEOGG -->
+      <map code="0xc3a3" name="1em"/><!-- HANGUL SYLLABLE SSYEOGS -->
+      <map code="0xc3a4" name="1em"/><!-- HANGUL SYLLABLE SSYEON -->
+      <map code="0xc3a5" name="1em"/><!-- HANGUL SYLLABLE SSYEONJ -->
+      <map code="0xc3a6" name="1em"/><!-- HANGUL SYLLABLE SSYEONH -->
+      <map code="0xc3a7" name="1em"/><!-- HANGUL SYLLABLE SSYEOD -->
+      <map code="0xc3a8" name="1em"/><!-- HANGUL SYLLABLE SSYEOL -->
+      <map code="0xc3a9" name="1em"/><!-- HANGUL SYLLABLE SSYEOLG -->
+      <map code="0xc3aa" name="1em"/><!-- HANGUL SYLLABLE SSYEOLM -->
+      <map code="0xc3ab" name="1em"/><!-- HANGUL SYLLABLE SSYEOLB -->
+      <map code="0xc3ac" name="1em"/><!-- HANGUL SYLLABLE SSYEOLS -->
+      <map code="0xc3ad" name="1em"/><!-- HANGUL SYLLABLE SSYEOLT -->
+      <map code="0xc3ae" name="1em"/><!-- HANGUL SYLLABLE SSYEOLP -->
+      <map code="0xc3af" name="1em"/><!-- HANGUL SYLLABLE SSYEOLH -->
+      <map code="0xc3b0" name="1em"/><!-- HANGUL SYLLABLE SSYEOM -->
+      <map code="0xc3b1" name="1em"/><!-- HANGUL SYLLABLE SSYEOB -->
+      <map code="0xc3b2" name="1em"/><!-- HANGUL SYLLABLE SSYEOBS -->
+      <map code="0xc3b3" name="1em"/><!-- HANGUL SYLLABLE SSYEOS -->
+      <map code="0xc3b4" name="1em"/><!-- HANGUL SYLLABLE SSYEOSS -->
+      <map code="0xc3b5" name="1em"/><!-- HANGUL SYLLABLE SSYEONG -->
+      <map code="0xc3b6" name="1em"/><!-- HANGUL SYLLABLE SSYEOJ -->
+      <map code="0xc3b7" name="1em"/><!-- HANGUL SYLLABLE SSYEOC -->
+      <map code="0xc3b8" name="1em"/><!-- HANGUL SYLLABLE SSYEOK -->
+      <map code="0xc3b9" name="1em"/><!-- HANGUL SYLLABLE SSYEOT -->
+      <map code="0xc3ba" name="1em"/><!-- HANGUL SYLLABLE SSYEOP -->
+      <map code="0xc3bb" name="1em"/><!-- HANGUL SYLLABLE SSYEOH -->
+      <map code="0xc3bc" name="1em"/><!-- HANGUL SYLLABLE SSYE -->
+      <map code="0xc3bd" name="1em"/><!-- HANGUL SYLLABLE SSYEG -->
+      <map code="0xc3be" name="1em"/><!-- HANGUL SYLLABLE SSYEGG -->
+      <map code="0xc3bf" name="1em"/><!-- HANGUL SYLLABLE SSYEGS -->
+      <map code="0xc3c0" name="1em"/><!-- HANGUL SYLLABLE SSYEN -->
+      <map code="0xc3c1" name="1em"/><!-- HANGUL SYLLABLE SSYENJ -->
+      <map code="0xc3c2" name="1em"/><!-- HANGUL SYLLABLE SSYENH -->
+      <map code="0xc3c3" name="1em"/><!-- HANGUL SYLLABLE SSYED -->
+      <map code="0xc3c4" name="1em"/><!-- HANGUL SYLLABLE SSYEL -->
+      <map code="0xc3c5" name="1em"/><!-- HANGUL SYLLABLE SSYELG -->
+      <map code="0xc3c6" name="1em"/><!-- HANGUL SYLLABLE SSYELM -->
+      <map code="0xc3c7" name="1em"/><!-- HANGUL SYLLABLE SSYELB -->
+      <map code="0xc3c8" name="1em"/><!-- HANGUL SYLLABLE SSYELS -->
+      <map code="0xc3c9" name="1em"/><!-- HANGUL SYLLABLE SSYELT -->
+      <map code="0xc3ca" name="1em"/><!-- HANGUL SYLLABLE SSYELP -->
+      <map code="0xc3cb" name="1em"/><!-- HANGUL SYLLABLE SSYELH -->
+      <map code="0xc3cc" name="1em"/><!-- HANGUL SYLLABLE SSYEM -->
+      <map code="0xc3cd" name="1em"/><!-- HANGUL SYLLABLE SSYEB -->
+      <map code="0xc3ce" name="1em"/><!-- HANGUL SYLLABLE SSYEBS -->
+      <map code="0xc3cf" name="1em"/><!-- HANGUL SYLLABLE SSYES -->
+      <map code="0xc3d0" name="1em"/><!-- HANGUL SYLLABLE SSYESS -->
+      <map code="0xc3d1" name="1em"/><!-- HANGUL SYLLABLE SSYENG -->
+      <map code="0xc3d2" name="1em"/><!-- HANGUL SYLLABLE SSYEJ -->
+      <map code="0xc3d3" name="1em"/><!-- HANGUL SYLLABLE SSYEC -->
+      <map code="0xc3d4" name="1em"/><!-- HANGUL SYLLABLE SSYEK -->
+      <map code="0xc3d5" name="1em"/><!-- HANGUL SYLLABLE SSYET -->
+      <map code="0xc3d6" name="1em"/><!-- HANGUL SYLLABLE SSYEP -->
+      <map code="0xc3d7" name="1em"/><!-- HANGUL SYLLABLE SSYEH -->
+      <map code="0xc3d8" name="1em"/><!-- HANGUL SYLLABLE SSO -->
+      <map code="0xc3d9" name="1em"/><!-- HANGUL SYLLABLE SSOG -->
+      <map code="0xc3da" name="1em"/><!-- HANGUL SYLLABLE SSOGG -->
+      <map code="0xc3db" name="1em"/><!-- HANGUL SYLLABLE SSOGS -->
+      <map code="0xc3dc" name="1em"/><!-- HANGUL SYLLABLE SSON -->
+      <map code="0xc3dd" name="1em"/><!-- HANGUL SYLLABLE SSONJ -->
+      <map code="0xc3de" name="1em"/><!-- HANGUL SYLLABLE SSONH -->
+      <map code="0xc3df" name="1em"/><!-- HANGUL SYLLABLE SSOD -->
+      <map code="0xc3e0" name="1em"/><!-- HANGUL SYLLABLE SSOL -->
+      <map code="0xc3e1" name="1em"/><!-- HANGUL SYLLABLE SSOLG -->
+      <map code="0xc3e2" name="1em"/><!-- HANGUL SYLLABLE SSOLM -->
+      <map code="0xc3e3" name="1em"/><!-- HANGUL SYLLABLE SSOLB -->
+      <map code="0xc3e4" name="1em"/><!-- HANGUL SYLLABLE SSOLS -->
+      <map code="0xc3e5" name="1em"/><!-- HANGUL SYLLABLE SSOLT -->
+      <map code="0xc3e6" name="1em"/><!-- HANGUL SYLLABLE SSOLP -->
+      <map code="0xc3e7" name="1em"/><!-- HANGUL SYLLABLE SSOLH -->
+      <map code="0xc3e8" name="1em"/><!-- HANGUL SYLLABLE SSOM -->
+      <map code="0xc3e9" name="1em"/><!-- HANGUL SYLLABLE SSOB -->
+      <map code="0xc3ea" name="1em"/><!-- HANGUL SYLLABLE SSOBS -->
+      <map code="0xc3eb" name="1em"/><!-- HANGUL SYLLABLE SSOS -->
+      <map code="0xc3ec" name="1em"/><!-- HANGUL SYLLABLE SSOSS -->
+      <map code="0xc3ed" name="1em"/><!-- HANGUL SYLLABLE SSONG -->
+      <map code="0xc3ee" name="1em"/><!-- HANGUL SYLLABLE SSOJ -->
+      <map code="0xc3ef" name="1em"/><!-- HANGUL SYLLABLE SSOC -->
+      <map code="0xc3f0" name="1em"/><!-- HANGUL SYLLABLE SSOK -->
+      <map code="0xc3f1" name="1em"/><!-- HANGUL SYLLABLE SSOT -->
+      <map code="0xc3f2" name="1em"/><!-- HANGUL SYLLABLE SSOP -->
+      <map code="0xc3f3" name="1em"/><!-- HANGUL SYLLABLE SSOH -->
+      <map code="0xc3f4" name="1em"/><!-- HANGUL SYLLABLE SSWA -->
+      <map code="0xc3f5" name="1em"/><!-- HANGUL SYLLABLE SSWAG -->
+      <map code="0xc3f6" name="1em"/><!-- HANGUL SYLLABLE SSWAGG -->
+      <map code="0xc3f7" name="1em"/><!-- HANGUL SYLLABLE SSWAGS -->
+      <map code="0xc3f8" name="1em"/><!-- HANGUL SYLLABLE SSWAN -->
+      <map code="0xc3f9" name="1em"/><!-- HANGUL SYLLABLE SSWANJ -->
+      <map code="0xc3fa" name="1em"/><!-- HANGUL SYLLABLE SSWANH -->
+      <map code="0xc3fb" name="1em"/><!-- HANGUL SYLLABLE SSWAD -->
+      <map code="0xc3fc" name="1em"/><!-- HANGUL SYLLABLE SSWAL -->
+      <map code="0xc3fd" name="1em"/><!-- HANGUL SYLLABLE SSWALG -->
+      <map code="0xc3fe" name="1em"/><!-- HANGUL SYLLABLE SSWALM -->
+      <map code="0xc3ff" name="1em"/><!-- HANGUL SYLLABLE SSWALB -->
+      <map code="0xc400" name="1em"/><!-- HANGUL SYLLABLE SSWALS -->
+      <map code="0xc401" name="1em"/><!-- HANGUL SYLLABLE SSWALT -->
+      <map code="0xc402" name="1em"/><!-- HANGUL SYLLABLE SSWALP -->
+      <map code="0xc403" name="1em"/><!-- HANGUL SYLLABLE SSWALH -->
+      <map code="0xc404" name="1em"/><!-- HANGUL SYLLABLE SSWAM -->
+      <map code="0xc405" name="1em"/><!-- HANGUL SYLLABLE SSWAB -->
+      <map code="0xc406" name="1em"/><!-- HANGUL SYLLABLE SSWABS -->
+      <map code="0xc407" name="1em"/><!-- HANGUL SYLLABLE SSWAS -->
+      <map code="0xc408" name="1em"/><!-- HANGUL SYLLABLE SSWASS -->
+      <map code="0xc409" name="1em"/><!-- HANGUL SYLLABLE SSWANG -->
+      <map code="0xc40a" name="1em"/><!-- HANGUL SYLLABLE SSWAJ -->
+      <map code="0xc40b" name="1em"/><!-- HANGUL SYLLABLE SSWAC -->
+      <map code="0xc40c" name="1em"/><!-- HANGUL SYLLABLE SSWAK -->
+      <map code="0xc40d" name="1em"/><!-- HANGUL SYLLABLE SSWAT -->
+      <map code="0xc40e" name="1em"/><!-- HANGUL SYLLABLE SSWAP -->
+      <map code="0xc40f" name="1em"/><!-- HANGUL SYLLABLE SSWAH -->
+      <map code="0xc410" name="1em"/><!-- HANGUL SYLLABLE SSWAE -->
+      <map code="0xc411" name="1em"/><!-- HANGUL SYLLABLE SSWAEG -->
+      <map code="0xc412" name="1em"/><!-- HANGUL SYLLABLE SSWAEGG -->
+      <map code="0xc413" name="1em"/><!-- HANGUL SYLLABLE SSWAEGS -->
+      <map code="0xc414" name="1em"/><!-- HANGUL SYLLABLE SSWAEN -->
+      <map code="0xc415" name="1em"/><!-- HANGUL SYLLABLE SSWAENJ -->
+      <map code="0xc416" name="1em"/><!-- HANGUL SYLLABLE SSWAENH -->
+      <map code="0xc417" name="1em"/><!-- HANGUL SYLLABLE SSWAED -->
+      <map code="0xc418" name="1em"/><!-- HANGUL SYLLABLE SSWAEL -->
+      <map code="0xc419" name="1em"/><!-- HANGUL SYLLABLE SSWAELG -->
+      <map code="0xc41a" name="1em"/><!-- HANGUL SYLLABLE SSWAELM -->
+      <map code="0xc41b" name="1em"/><!-- HANGUL SYLLABLE SSWAELB -->
+      <map code="0xc41c" name="1em"/><!-- HANGUL SYLLABLE SSWAELS -->
+      <map code="0xc41d" name="1em"/><!-- HANGUL SYLLABLE SSWAELT -->
+      <map code="0xc41e" name="1em"/><!-- HANGUL SYLLABLE SSWAELP -->
+      <map code="0xc41f" name="1em"/><!-- HANGUL SYLLABLE SSWAELH -->
+      <map code="0xc420" name="1em"/><!-- HANGUL SYLLABLE SSWAEM -->
+      <map code="0xc421" name="1em"/><!-- HANGUL SYLLABLE SSWAEB -->
+      <map code="0xc422" name="1em"/><!-- HANGUL SYLLABLE SSWAEBS -->
+      <map code="0xc423" name="1em"/><!-- HANGUL SYLLABLE SSWAES -->
+      <map code="0xc424" name="1em"/><!-- HANGUL SYLLABLE SSWAESS -->
+      <map code="0xc425" name="1em"/><!-- HANGUL SYLLABLE SSWAENG -->
+      <map code="0xc426" name="1em"/><!-- HANGUL SYLLABLE SSWAEJ -->
+      <map code="0xc427" name="1em"/><!-- HANGUL SYLLABLE SSWAEC -->
+      <map code="0xc428" name="1em"/><!-- HANGUL SYLLABLE SSWAEK -->
+      <map code="0xc429" name="1em"/><!-- HANGUL SYLLABLE SSWAET -->
+      <map code="0xc42a" name="1em"/><!-- HANGUL SYLLABLE SSWAEP -->
+      <map code="0xc42b" name="1em"/><!-- HANGUL SYLLABLE SSWAEH -->
+      <map code="0xc42c" name="1em"/><!-- HANGUL SYLLABLE SSOE -->
+      <map code="0xc42d" name="1em"/><!-- HANGUL SYLLABLE SSOEG -->
+      <map code="0xc42e" name="1em"/><!-- HANGUL SYLLABLE SSOEGG -->
+      <map code="0xc42f" name="1em"/><!-- HANGUL SYLLABLE SSOEGS -->
+      <map code="0xc430" name="1em"/><!-- HANGUL SYLLABLE SSOEN -->
+      <map code="0xc431" name="1em"/><!-- HANGUL SYLLABLE SSOENJ -->
+      <map code="0xc432" name="1em"/><!-- HANGUL SYLLABLE SSOENH -->
+      <map code="0xc433" name="1em"/><!-- HANGUL SYLLABLE SSOED -->
+      <map code="0xc434" name="1em"/><!-- HANGUL SYLLABLE SSOEL -->
+      <map code="0xc435" name="1em"/><!-- HANGUL SYLLABLE SSOELG -->
+      <map code="0xc436" name="1em"/><!-- HANGUL SYLLABLE SSOELM -->
+      <map code="0xc437" name="1em"/><!-- HANGUL SYLLABLE SSOELB -->
+      <map code="0xc438" name="1em"/><!-- HANGUL SYLLABLE SSOELS -->
+      <map code="0xc439" name="1em"/><!-- HANGUL SYLLABLE SSOELT -->
+      <map code="0xc43a" name="1em"/><!-- HANGUL SYLLABLE SSOELP -->
+      <map code="0xc43b" name="1em"/><!-- HANGUL SYLLABLE SSOELH -->
+      <map code="0xc43c" name="1em"/><!-- HANGUL SYLLABLE SSOEM -->
+      <map code="0xc43d" name="1em"/><!-- HANGUL SYLLABLE SSOEB -->
+      <map code="0xc43e" name="1em"/><!-- HANGUL SYLLABLE SSOEBS -->
+      <map code="0xc43f" name="1em"/><!-- HANGUL SYLLABLE SSOES -->
+      <map code="0xc440" name="1em"/><!-- HANGUL SYLLABLE SSOESS -->
+      <map code="0xc441" name="1em"/><!-- HANGUL SYLLABLE SSOENG -->
+      <map code="0xc442" name="1em"/><!-- HANGUL SYLLABLE SSOEJ -->
+      <map code="0xc443" name="1em"/><!-- HANGUL SYLLABLE SSOEC -->
+      <map code="0xc444" name="1em"/><!-- HANGUL SYLLABLE SSOEK -->
+      <map code="0xc445" name="1em"/><!-- HANGUL SYLLABLE SSOET -->
+      <map code="0xc446" name="1em"/><!-- HANGUL SYLLABLE SSOEP -->
+      <map code="0xc447" name="1em"/><!-- HANGUL SYLLABLE SSOEH -->
+      <map code="0xc448" name="1em"/><!-- HANGUL SYLLABLE SSYO -->
+      <map code="0xc449" name="1em"/><!-- HANGUL SYLLABLE SSYOG -->
+      <map code="0xc44a" name="1em"/><!-- HANGUL SYLLABLE SSYOGG -->
+      <map code="0xc44b" name="1em"/><!-- HANGUL SYLLABLE SSYOGS -->
+      <map code="0xc44c" name="1em"/><!-- HANGUL SYLLABLE SSYON -->
+      <map code="0xc44d" name="1em"/><!-- HANGUL SYLLABLE SSYONJ -->
+      <map code="0xc44e" name="1em"/><!-- HANGUL SYLLABLE SSYONH -->
+      <map code="0xc44f" name="1em"/><!-- HANGUL SYLLABLE SSYOD -->
+      <map code="0xc450" name="1em"/><!-- HANGUL SYLLABLE SSYOL -->
+      <map code="0xc451" name="1em"/><!-- HANGUL SYLLABLE SSYOLG -->
+      <map code="0xc452" name="1em"/><!-- HANGUL SYLLABLE SSYOLM -->
+      <map code="0xc453" name="1em"/><!-- HANGUL SYLLABLE SSYOLB -->
+      <map code="0xc454" name="1em"/><!-- HANGUL SYLLABLE SSYOLS -->
+      <map code="0xc455" name="1em"/><!-- HANGUL SYLLABLE SSYOLT -->
+      <map code="0xc456" name="1em"/><!-- HANGUL SYLLABLE SSYOLP -->
+      <map code="0xc457" name="1em"/><!-- HANGUL SYLLABLE SSYOLH -->
+      <map code="0xc458" name="1em"/><!-- HANGUL SYLLABLE SSYOM -->
+      <map code="0xc459" name="1em"/><!-- HANGUL SYLLABLE SSYOB -->
+      <map code="0xc45a" name="1em"/><!-- HANGUL SYLLABLE SSYOBS -->
+      <map code="0xc45b" name="1em"/><!-- HANGUL SYLLABLE SSYOS -->
+      <map code="0xc45c" name="1em"/><!-- HANGUL SYLLABLE SSYOSS -->
+      <map code="0xc45d" name="1em"/><!-- HANGUL SYLLABLE SSYONG -->
+      <map code="0xc45e" name="1em"/><!-- HANGUL SYLLABLE SSYOJ -->
+      <map code="0xc45f" name="1em"/><!-- HANGUL SYLLABLE SSYOC -->
+      <map code="0xc460" name="1em"/><!-- HANGUL SYLLABLE SSYOK -->
+      <map code="0xc461" name="1em"/><!-- HANGUL SYLLABLE SSYOT -->
+      <map code="0xc462" name="1em"/><!-- HANGUL SYLLABLE SSYOP -->
+      <map code="0xc463" name="1em"/><!-- HANGUL SYLLABLE SSYOH -->
+      <map code="0xc464" name="1em"/><!-- HANGUL SYLLABLE SSU -->
+      <map code="0xc465" name="1em"/><!-- HANGUL SYLLABLE SSUG -->
+      <map code="0xc466" name="1em"/><!-- HANGUL SYLLABLE SSUGG -->
+      <map code="0xc467" name="1em"/><!-- HANGUL SYLLABLE SSUGS -->
+      <map code="0xc468" name="1em"/><!-- HANGUL SYLLABLE SSUN -->
+      <map code="0xc469" name="1em"/><!-- HANGUL SYLLABLE SSUNJ -->
+      <map code="0xc46a" name="1em"/><!-- HANGUL SYLLABLE SSUNH -->
+      <map code="0xc46b" name="1em"/><!-- HANGUL SYLLABLE SSUD -->
+      <map code="0xc46c" name="1em"/><!-- HANGUL SYLLABLE SSUL -->
+      <map code="0xc46d" name="1em"/><!-- HANGUL SYLLABLE SSULG -->
+      <map code="0xc46e" name="1em"/><!-- HANGUL SYLLABLE SSULM -->
+      <map code="0xc46f" name="1em"/><!-- HANGUL SYLLABLE SSULB -->
+      <map code="0xc470" name="1em"/><!-- HANGUL SYLLABLE SSULS -->
+      <map code="0xc471" name="1em"/><!-- HANGUL SYLLABLE SSULT -->
+      <map code="0xc472" name="1em"/><!-- HANGUL SYLLABLE SSULP -->
+      <map code="0xc473" name="1em"/><!-- HANGUL SYLLABLE SSULH -->
+      <map code="0xc474" name="1em"/><!-- HANGUL SYLLABLE SSUM -->
+      <map code="0xc475" name="1em"/><!-- HANGUL SYLLABLE SSUB -->
+      <map code="0xc476" name="1em"/><!-- HANGUL SYLLABLE SSUBS -->
+      <map code="0xc477" name="1em"/><!-- HANGUL SYLLABLE SSUS -->
+      <map code="0xc478" name="1em"/><!-- HANGUL SYLLABLE SSUSS -->
+      <map code="0xc479" name="1em"/><!-- HANGUL SYLLABLE SSUNG -->
+      <map code="0xc47a" name="1em"/><!-- HANGUL SYLLABLE SSUJ -->
+      <map code="0xc47b" name="1em"/><!-- HANGUL SYLLABLE SSUC -->
+      <map code="0xc47c" name="1em"/><!-- HANGUL SYLLABLE SSUK -->
+      <map code="0xc47d" name="1em"/><!-- HANGUL SYLLABLE SSUT -->
+      <map code="0xc47e" name="1em"/><!-- HANGUL SYLLABLE SSUP -->
+      <map code="0xc47f" name="1em"/><!-- HANGUL SYLLABLE SSUH -->
+      <map code="0xc480" name="1em"/><!-- HANGUL SYLLABLE SSWEO -->
+      <map code="0xc481" name="1em"/><!-- HANGUL SYLLABLE SSWEOG -->
+      <map code="0xc482" name="1em"/><!-- HANGUL SYLLABLE SSWEOGG -->
+      <map code="0xc483" name="1em"/><!-- HANGUL SYLLABLE SSWEOGS -->
+      <map code="0xc484" name="1em"/><!-- HANGUL SYLLABLE SSWEON -->
+      <map code="0xc485" name="1em"/><!-- HANGUL SYLLABLE SSWEONJ -->
+      <map code="0xc486" name="1em"/><!-- HANGUL SYLLABLE SSWEONH -->
+      <map code="0xc487" name="1em"/><!-- HANGUL SYLLABLE SSWEOD -->
+      <map code="0xc488" name="1em"/><!-- HANGUL SYLLABLE SSWEOL -->
+      <map code="0xc489" name="1em"/><!-- HANGUL SYLLABLE SSWEOLG -->
+      <map code="0xc48a" name="1em"/><!-- HANGUL SYLLABLE SSWEOLM -->
+      <map code="0xc48b" name="1em"/><!-- HANGUL SYLLABLE SSWEOLB -->
+      <map code="0xc48c" name="1em"/><!-- HANGUL SYLLABLE SSWEOLS -->
+      <map code="0xc48d" name="1em"/><!-- HANGUL SYLLABLE SSWEOLT -->
+      <map code="0xc48e" name="1em"/><!-- HANGUL SYLLABLE SSWEOLP -->
+      <map code="0xc48f" name="1em"/><!-- HANGUL SYLLABLE SSWEOLH -->
+      <map code="0xc490" name="1em"/><!-- HANGUL SYLLABLE SSWEOM -->
+      <map code="0xc491" name="1em"/><!-- HANGUL SYLLABLE SSWEOB -->
+      <map code="0xc492" name="1em"/><!-- HANGUL SYLLABLE SSWEOBS -->
+      <map code="0xc493" name="1em"/><!-- HANGUL SYLLABLE SSWEOS -->
+      <map code="0xc494" name="1em"/><!-- HANGUL SYLLABLE SSWEOSS -->
+      <map code="0xc495" name="1em"/><!-- HANGUL SYLLABLE SSWEONG -->
+      <map code="0xc496" name="1em"/><!-- HANGUL SYLLABLE SSWEOJ -->
+      <map code="0xc497" name="1em"/><!-- HANGUL SYLLABLE SSWEOC -->
+      <map code="0xc498" name="1em"/><!-- HANGUL SYLLABLE SSWEOK -->
+      <map code="0xc499" name="1em"/><!-- HANGUL SYLLABLE SSWEOT -->
+      <map code="0xc49a" name="1em"/><!-- HANGUL SYLLABLE SSWEOP -->
+      <map code="0xc49b" name="1em"/><!-- HANGUL SYLLABLE SSWEOH -->
+      <map code="0xc49c" name="1em"/><!-- HANGUL SYLLABLE SSWE -->
+      <map code="0xc49d" name="1em"/><!-- HANGUL SYLLABLE SSWEG -->
+      <map code="0xc49e" name="1em"/><!-- HANGUL SYLLABLE SSWEGG -->
+      <map code="0xc49f" name="1em"/><!-- HANGUL SYLLABLE SSWEGS -->
+      <map code="0xc4a0" name="1em"/><!-- HANGUL SYLLABLE SSWEN -->
+      <map code="0xc4a1" name="1em"/><!-- HANGUL SYLLABLE SSWENJ -->
+      <map code="0xc4a2" name="1em"/><!-- HANGUL SYLLABLE SSWENH -->
+      <map code="0xc4a3" name="1em"/><!-- HANGUL SYLLABLE SSWED -->
+      <map code="0xc4a4" name="1em"/><!-- HANGUL SYLLABLE SSWEL -->
+      <map code="0xc4a5" name="1em"/><!-- HANGUL SYLLABLE SSWELG -->
+      <map code="0xc4a6" name="1em"/><!-- HANGUL SYLLABLE SSWELM -->
+      <map code="0xc4a7" name="1em"/><!-- HANGUL SYLLABLE SSWELB -->
+      <map code="0xc4a8" name="1em"/><!-- HANGUL SYLLABLE SSWELS -->
+      <map code="0xc4a9" name="1em"/><!-- HANGUL SYLLABLE SSWELT -->
+      <map code="0xc4aa" name="1em"/><!-- HANGUL SYLLABLE SSWELP -->
+      <map code="0xc4ab" name="1em"/><!-- HANGUL SYLLABLE SSWELH -->
+      <map code="0xc4ac" name="1em"/><!-- HANGUL SYLLABLE SSWEM -->
+      <map code="0xc4ad" name="1em"/><!-- HANGUL SYLLABLE SSWEB -->
+      <map code="0xc4ae" name="1em"/><!-- HANGUL SYLLABLE SSWEBS -->
+      <map code="0xc4af" name="1em"/><!-- HANGUL SYLLABLE SSWES -->
+      <map code="0xc4b0" name="1em"/><!-- HANGUL SYLLABLE SSWESS -->
+      <map code="0xc4b1" name="1em"/><!-- HANGUL SYLLABLE SSWENG -->
+      <map code="0xc4b2" name="1em"/><!-- HANGUL SYLLABLE SSWEJ -->
+      <map code="0xc4b3" name="1em"/><!-- HANGUL SYLLABLE SSWEC -->
+      <map code="0xc4b4" name="1em"/><!-- HANGUL SYLLABLE SSWEK -->
+      <map code="0xc4b5" name="1em"/><!-- HANGUL SYLLABLE SSWET -->
+      <map code="0xc4b6" name="1em"/><!-- HANGUL SYLLABLE SSWEP -->
+      <map code="0xc4b7" name="1em"/><!-- HANGUL SYLLABLE SSWEH -->
+      <map code="0xc4b8" name="1em"/><!-- HANGUL SYLLABLE SSWI -->
+      <map code="0xc4b9" name="1em"/><!-- HANGUL SYLLABLE SSWIG -->
+      <map code="0xc4ba" name="1em"/><!-- HANGUL SYLLABLE SSWIGG -->
+      <map code="0xc4bb" name="1em"/><!-- HANGUL SYLLABLE SSWIGS -->
+      <map code="0xc4bc" name="1em"/><!-- HANGUL SYLLABLE SSWIN -->
+      <map code="0xc4bd" name="1em"/><!-- HANGUL SYLLABLE SSWINJ -->
+      <map code="0xc4be" name="1em"/><!-- HANGUL SYLLABLE SSWINH -->
+      <map code="0xc4bf" name="1em"/><!-- HANGUL SYLLABLE SSWID -->
+      <map code="0xc4c0" name="1em"/><!-- HANGUL SYLLABLE SSWIL -->
+      <map code="0xc4c1" name="1em"/><!-- HANGUL SYLLABLE SSWILG -->
+      <map code="0xc4c2" name="1em"/><!-- HANGUL SYLLABLE SSWILM -->
+      <map code="0xc4c3" name="1em"/><!-- HANGUL SYLLABLE SSWILB -->
+      <map code="0xc4c4" name="1em"/><!-- HANGUL SYLLABLE SSWILS -->
+      <map code="0xc4c5" name="1em"/><!-- HANGUL SYLLABLE SSWILT -->
+      <map code="0xc4c6" name="1em"/><!-- HANGUL SYLLABLE SSWILP -->
+      <map code="0xc4c7" name="1em"/><!-- HANGUL SYLLABLE SSWILH -->
+      <map code="0xc4c8" name="1em"/><!-- HANGUL SYLLABLE SSWIM -->
+      <map code="0xc4c9" name="1em"/><!-- HANGUL SYLLABLE SSWIB -->
+      <map code="0xc4ca" name="1em"/><!-- HANGUL SYLLABLE SSWIBS -->
+      <map code="0xc4cb" name="1em"/><!-- HANGUL SYLLABLE SSWIS -->
+      <map code="0xc4cc" name="1em"/><!-- HANGUL SYLLABLE SSWISS -->
+      <map code="0xc4cd" name="1em"/><!-- HANGUL SYLLABLE SSWING -->
+      <map code="0xc4ce" name="1em"/><!-- HANGUL SYLLABLE SSWIJ -->
+      <map code="0xc4cf" name="1em"/><!-- HANGUL SYLLABLE SSWIC -->
+      <map code="0xc4d0" name="1em"/><!-- HANGUL SYLLABLE SSWIK -->
+      <map code="0xc4d1" name="1em"/><!-- HANGUL SYLLABLE SSWIT -->
+      <map code="0xc4d2" name="1em"/><!-- HANGUL SYLLABLE SSWIP -->
+      <map code="0xc4d3" name="1em"/><!-- HANGUL SYLLABLE SSWIH -->
+      <map code="0xc4d4" name="1em"/><!-- HANGUL SYLLABLE SSYU -->
+      <map code="0xc4d5" name="1em"/><!-- HANGUL SYLLABLE SSYUG -->
+      <map code="0xc4d6" name="1em"/><!-- HANGUL SYLLABLE SSYUGG -->
+      <map code="0xc4d7" name="1em"/><!-- HANGUL SYLLABLE SSYUGS -->
+      <map code="0xc4d8" name="1em"/><!-- HANGUL SYLLABLE SSYUN -->
+      <map code="0xc4d9" name="1em"/><!-- HANGUL SYLLABLE SSYUNJ -->
+      <map code="0xc4da" name="1em"/><!-- HANGUL SYLLABLE SSYUNH -->
+      <map code="0xc4db" name="1em"/><!-- HANGUL SYLLABLE SSYUD -->
+      <map code="0xc4dc" name="1em"/><!-- HANGUL SYLLABLE SSYUL -->
+      <map code="0xc4dd" name="1em"/><!-- HANGUL SYLLABLE SSYULG -->
+      <map code="0xc4de" name="1em"/><!-- HANGUL SYLLABLE SSYULM -->
+      <map code="0xc4df" name="1em"/><!-- HANGUL SYLLABLE SSYULB -->
+      <map code="0xc4e0" name="1em"/><!-- HANGUL SYLLABLE SSYULS -->
+      <map code="0xc4e1" name="1em"/><!-- HANGUL SYLLABLE SSYULT -->
+      <map code="0xc4e2" name="1em"/><!-- HANGUL SYLLABLE SSYULP -->
+      <map code="0xc4e3" name="1em"/><!-- HANGUL SYLLABLE SSYULH -->
+      <map code="0xc4e4" name="1em"/><!-- HANGUL SYLLABLE SSYUM -->
+      <map code="0xc4e5" name="1em"/><!-- HANGUL SYLLABLE SSYUB -->
+      <map code="0xc4e6" name="1em"/><!-- HANGUL SYLLABLE SSYUBS -->
+      <map code="0xc4e7" name="1em"/><!-- HANGUL SYLLABLE SSYUS -->
+      <map code="0xc4e8" name="1em"/><!-- HANGUL SYLLABLE SSYUSS -->
+      <map code="0xc4e9" name="1em"/><!-- HANGUL SYLLABLE SSYUNG -->
+      <map code="0xc4ea" name="1em"/><!-- HANGUL SYLLABLE SSYUJ -->
+      <map code="0xc4eb" name="1em"/><!-- HANGUL SYLLABLE SSYUC -->
+      <map code="0xc4ec" name="1em"/><!-- HANGUL SYLLABLE SSYUK -->
+      <map code="0xc4ed" name="1em"/><!-- HANGUL SYLLABLE SSYUT -->
+      <map code="0xc4ee" name="1em"/><!-- HANGUL SYLLABLE SSYUP -->
+      <map code="0xc4ef" name="1em"/><!-- HANGUL SYLLABLE SSYUH -->
+      <map code="0xc4f0" name="1em"/><!-- HANGUL SYLLABLE SSEU -->
+      <map code="0xc4f1" name="1em"/><!-- HANGUL SYLLABLE SSEUG -->
+      <map code="0xc4f2" name="1em"/><!-- HANGUL SYLLABLE SSEUGG -->
+      <map code="0xc4f3" name="1em"/><!-- HANGUL SYLLABLE SSEUGS -->
+      <map code="0xc4f4" name="1em"/><!-- HANGUL SYLLABLE SSEUN -->
+      <map code="0xc4f5" name="1em"/><!-- HANGUL SYLLABLE SSEUNJ -->
+      <map code="0xc4f6" name="1em"/><!-- HANGUL SYLLABLE SSEUNH -->
+      <map code="0xc4f7" name="1em"/><!-- HANGUL SYLLABLE SSEUD -->
+      <map code="0xc4f8" name="1em"/><!-- HANGUL SYLLABLE SSEUL -->
+      <map code="0xc4f9" name="1em"/><!-- HANGUL SYLLABLE SSEULG -->
+      <map code="0xc4fa" name="1em"/><!-- HANGUL SYLLABLE SSEULM -->
+      <map code="0xc4fb" name="1em"/><!-- HANGUL SYLLABLE SSEULB -->
+      <map code="0xc4fc" name="1em"/><!-- HANGUL SYLLABLE SSEULS -->
+      <map code="0xc4fd" name="1em"/><!-- HANGUL SYLLABLE SSEULT -->
+      <map code="0xc4fe" name="1em"/><!-- HANGUL SYLLABLE SSEULP -->
+      <map code="0xc4ff" name="1em"/><!-- HANGUL SYLLABLE SSEULH -->
+      <map code="0xc500" name="1em"/><!-- HANGUL SYLLABLE SSEUM -->
+      <map code="0xc501" name="1em"/><!-- HANGUL SYLLABLE SSEUB -->
+      <map code="0xc502" name="1em"/><!-- HANGUL SYLLABLE SSEUBS -->
+      <map code="0xc503" name="1em"/><!-- HANGUL SYLLABLE SSEUS -->
+      <map code="0xc504" name="1em"/><!-- HANGUL SYLLABLE SSEUSS -->
+      <map code="0xc505" name="1em"/><!-- HANGUL SYLLABLE SSEUNG -->
+      <map code="0xc506" name="1em"/><!-- HANGUL SYLLABLE SSEUJ -->
+      <map code="0xc507" name="1em"/><!-- HANGUL SYLLABLE SSEUC -->
+      <map code="0xc508" name="1em"/><!-- HANGUL SYLLABLE SSEUK -->
+      <map code="0xc509" name="1em"/><!-- HANGUL SYLLABLE SSEUT -->
+      <map code="0xc50a" name="1em"/><!-- HANGUL SYLLABLE SSEUP -->
+      <map code="0xc50b" name="1em"/><!-- HANGUL SYLLABLE SSEUH -->
+      <map code="0xc50c" name="1em"/><!-- HANGUL SYLLABLE SSYI -->
+      <map code="0xc50d" name="1em"/><!-- HANGUL SYLLABLE SSYIG -->
+      <map code="0xc50e" name="1em"/><!-- HANGUL SYLLABLE SSYIGG -->
+      <map code="0xc50f" name="1em"/><!-- HANGUL SYLLABLE SSYIGS -->
+      <map code="0xc510" name="1em"/><!-- HANGUL SYLLABLE SSYIN -->
+      <map code="0xc511" name="1em"/><!-- HANGUL SYLLABLE SSYINJ -->
+      <map code="0xc512" name="1em"/><!-- HANGUL SYLLABLE SSYINH -->
+      <map code="0xc513" name="1em"/><!-- HANGUL SYLLABLE SSYID -->
+      <map code="0xc514" name="1em"/><!-- HANGUL SYLLABLE SSYIL -->
+      <map code="0xc515" name="1em"/><!-- HANGUL SYLLABLE SSYILG -->
+      <map code="0xc516" name="1em"/><!-- HANGUL SYLLABLE SSYILM -->
+      <map code="0xc517" name="1em"/><!-- HANGUL SYLLABLE SSYILB -->
+      <map code="0xc518" name="1em"/><!-- HANGUL SYLLABLE SSYILS -->
+      <map code="0xc519" name="1em"/><!-- HANGUL SYLLABLE SSYILT -->
+      <map code="0xc51a" name="1em"/><!-- HANGUL SYLLABLE SSYILP -->
+      <map code="0xc51b" name="1em"/><!-- HANGUL SYLLABLE SSYILH -->
+      <map code="0xc51c" name="1em"/><!-- HANGUL SYLLABLE SSYIM -->
+      <map code="0xc51d" name="1em"/><!-- HANGUL SYLLABLE SSYIB -->
+      <map code="0xc51e" name="1em"/><!-- HANGUL SYLLABLE SSYIBS -->
+      <map code="0xc51f" name="1em"/><!-- HANGUL SYLLABLE SSYIS -->
+      <map code="0xc520" name="1em"/><!-- HANGUL SYLLABLE SSYISS -->
+      <map code="0xc521" name="1em"/><!-- HANGUL SYLLABLE SSYING -->
+      <map code="0xc522" name="1em"/><!-- HANGUL SYLLABLE SSYIJ -->
+      <map code="0xc523" name="1em"/><!-- HANGUL SYLLABLE SSYIC -->
+      <map code="0xc524" name="1em"/><!-- HANGUL SYLLABLE SSYIK -->
+      <map code="0xc525" name="1em"/><!-- HANGUL SYLLABLE SSYIT -->
+      <map code="0xc526" name="1em"/><!-- HANGUL SYLLABLE SSYIP -->
+      <map code="0xc527" name="1em"/><!-- HANGUL SYLLABLE SSYIH -->
+      <map code="0xc528" name="1em"/><!-- HANGUL SYLLABLE SSI -->
+      <map code="0xc529" name="1em"/><!-- HANGUL SYLLABLE SSIG -->
+      <map code="0xc52a" name="1em"/><!-- HANGUL SYLLABLE SSIGG -->
+      <map code="0xc52b" name="1em"/><!-- HANGUL SYLLABLE SSIGS -->
+      <map code="0xc52c" name="1em"/><!-- HANGUL SYLLABLE SSIN -->
+      <map code="0xc52d" name="1em"/><!-- HANGUL SYLLABLE SSINJ -->
+      <map code="0xc52e" name="1em"/><!-- HANGUL SYLLABLE SSINH -->
+      <map code="0xc52f" name="1em"/><!-- HANGUL SYLLABLE SSID -->
+      <map code="0xc530" name="1em"/><!-- HANGUL SYLLABLE SSIL -->
+      <map code="0xc531" name="1em"/><!-- HANGUL SYLLABLE SSILG -->
+      <map code="0xc532" name="1em"/><!-- HANGUL SYLLABLE SSILM -->
+      <map code="0xc533" name="1em"/><!-- HANGUL SYLLABLE SSILB -->
+      <map code="0xc534" name="1em"/><!-- HANGUL SYLLABLE SSILS -->
+      <map code="0xc535" name="1em"/><!-- HANGUL SYLLABLE SSILT -->
+      <map code="0xc536" name="1em"/><!-- HANGUL SYLLABLE SSILP -->
+      <map code="0xc537" name="1em"/><!-- HANGUL SYLLABLE SSILH -->
+      <map code="0xc538" name="1em"/><!-- HANGUL SYLLABLE SSIM -->
+      <map code="0xc539" name="1em"/><!-- HANGUL SYLLABLE SSIB -->
+      <map code="0xc53a" name="1em"/><!-- HANGUL SYLLABLE SSIBS -->
+      <map code="0xc53b" name="1em"/><!-- HANGUL SYLLABLE SSIS -->
+      <map code="0xc53c" name="1em"/><!-- HANGUL SYLLABLE SSISS -->
+      <map code="0xc53d" name="1em"/><!-- HANGUL SYLLABLE SSING -->
+      <map code="0xc53e" name="1em"/><!-- HANGUL SYLLABLE SSIJ -->
+      <map code="0xc53f" name="1em"/><!-- HANGUL SYLLABLE SSIC -->
+      <map code="0xc540" name="1em"/><!-- HANGUL SYLLABLE SSIK -->
+      <map code="0xc541" name="1em"/><!-- HANGUL SYLLABLE SSIT -->
+      <map code="0xc542" name="1em"/><!-- HANGUL SYLLABLE SSIP -->
+      <map code="0xc543" name="1em"/><!-- HANGUL SYLLABLE SSIH -->
+      <map code="0xc544" name="1em"/><!-- HANGUL SYLLABLE A -->
+      <map code="0xc545" name="1em"/><!-- HANGUL SYLLABLE AG -->
+      <map code="0xc546" name="1em"/><!-- HANGUL SYLLABLE AGG -->
+      <map code="0xc547" name="1em"/><!-- HANGUL SYLLABLE AGS -->
+      <map code="0xc548" name="1em"/><!-- HANGUL SYLLABLE AN -->
+      <map code="0xc549" name="1em"/><!-- HANGUL SYLLABLE ANJ -->
+      <map code="0xc54a" name="1em"/><!-- HANGUL SYLLABLE ANH -->
+      <map code="0xc54b" name="1em"/><!-- HANGUL SYLLABLE AD -->
+      <map code="0xc54c" name="1em"/><!-- HANGUL SYLLABLE AL -->
+      <map code="0xc54d" name="1em"/><!-- HANGUL SYLLABLE ALG -->
+      <map code="0xc54e" name="1em"/><!-- HANGUL SYLLABLE ALM -->
+      <map code="0xc54f" name="1em"/><!-- HANGUL SYLLABLE ALB -->
+      <map code="0xc550" name="1em"/><!-- HANGUL SYLLABLE ALS -->
+      <map code="0xc551" name="1em"/><!-- HANGUL SYLLABLE ALT -->
+      <map code="0xc552" name="1em"/><!-- HANGUL SYLLABLE ALP -->
+      <map code="0xc553" name="1em"/><!-- HANGUL SYLLABLE ALH -->
+      <map code="0xc554" name="1em"/><!-- HANGUL SYLLABLE AM -->
+      <map code="0xc555" name="1em"/><!-- HANGUL SYLLABLE AB -->
+      <map code="0xc556" name="1em"/><!-- HANGUL SYLLABLE ABS -->
+      <map code="0xc557" name="1em"/><!-- HANGUL SYLLABLE AS -->
+      <map code="0xc558" name="1em"/><!-- HANGUL SYLLABLE ASS -->
+      <map code="0xc559" name="1em"/><!-- HANGUL SYLLABLE ANG -->
+      <map code="0xc55a" name="1em"/><!-- HANGUL SYLLABLE AJ -->
+      <map code="0xc55b" name="1em"/><!-- HANGUL SYLLABLE AC -->
+      <map code="0xc55c" name="1em"/><!-- HANGUL SYLLABLE AK -->
+      <map code="0xc55d" name="1em"/><!-- HANGUL SYLLABLE AT -->
+      <map code="0xc55e" name="1em"/><!-- HANGUL SYLLABLE AP -->
+      <map code="0xc55f" name="1em"/><!-- HANGUL SYLLABLE AH -->
+      <map code="0xc560" name="1em"/><!-- HANGUL SYLLABLE AE -->
+      <map code="0xc561" name="1em"/><!-- HANGUL SYLLABLE AEG -->
+      <map code="0xc562" name="1em"/><!-- HANGUL SYLLABLE AEGG -->
+      <map code="0xc563" name="1em"/><!-- HANGUL SYLLABLE AEGS -->
+      <map code="0xc564" name="1em"/><!-- HANGUL SYLLABLE AEN -->
+      <map code="0xc565" name="1em"/><!-- HANGUL SYLLABLE AENJ -->
+      <map code="0xc566" name="1em"/><!-- HANGUL SYLLABLE AENH -->
+      <map code="0xc567" name="1em"/><!-- HANGUL SYLLABLE AED -->
+      <map code="0xc568" name="1em"/><!-- HANGUL SYLLABLE AEL -->
+      <map code="0xc569" name="1em"/><!-- HANGUL SYLLABLE AELG -->
+      <map code="0xc56a" name="1em"/><!-- HANGUL SYLLABLE AELM -->
+      <map code="0xc56b" name="1em"/><!-- HANGUL SYLLABLE AELB -->
+      <map code="0xc56c" name="1em"/><!-- HANGUL SYLLABLE AELS -->
+      <map code="0xc56d" name="1em"/><!-- HANGUL SYLLABLE AELT -->
+      <map code="0xc56e" name="1em"/><!-- HANGUL SYLLABLE AELP -->
+      <map code="0xc56f" name="1em"/><!-- HANGUL SYLLABLE AELH -->
+      <map code="0xc570" name="1em"/><!-- HANGUL SYLLABLE AEM -->
+      <map code="0xc571" name="1em"/><!-- HANGUL SYLLABLE AEB -->
+      <map code="0xc572" name="1em"/><!-- HANGUL SYLLABLE AEBS -->
+      <map code="0xc573" name="1em"/><!-- HANGUL SYLLABLE AES -->
+      <map code="0xc574" name="1em"/><!-- HANGUL SYLLABLE AESS -->
+      <map code="0xc575" name="1em"/><!-- HANGUL SYLLABLE AENG -->
+      <map code="0xc576" name="1em"/><!-- HANGUL SYLLABLE AEJ -->
+      <map code="0xc577" name="1em"/><!-- HANGUL SYLLABLE AEC -->
+      <map code="0xc578" name="1em"/><!-- HANGUL SYLLABLE AEK -->
+      <map code="0xc579" name="1em"/><!-- HANGUL SYLLABLE AET -->
+      <map code="0xc57a" name="1em"/><!-- HANGUL SYLLABLE AEP -->
+      <map code="0xc57b" name="1em"/><!-- HANGUL SYLLABLE AEH -->
+      <map code="0xc57c" name="1em"/><!-- HANGUL SYLLABLE YA -->
+      <map code="0xc57d" name="1em"/><!-- HANGUL SYLLABLE YAG -->
+      <map code="0xc57e" name="1em"/><!-- HANGUL SYLLABLE YAGG -->
+      <map code="0xc57f" name="1em"/><!-- HANGUL SYLLABLE YAGS -->
+      <map code="0xc580" name="1em"/><!-- HANGUL SYLLABLE YAN -->
+      <map code="0xc581" name="1em"/><!-- HANGUL SYLLABLE YANJ -->
+      <map code="0xc582" name="1em"/><!-- HANGUL SYLLABLE YANH -->
+      <map code="0xc583" name="1em"/><!-- HANGUL SYLLABLE YAD -->
+      <map code="0xc584" name="1em"/><!-- HANGUL SYLLABLE YAL -->
+      <map code="0xc585" name="1em"/><!-- HANGUL SYLLABLE YALG -->
+      <map code="0xc586" name="1em"/><!-- HANGUL SYLLABLE YALM -->
+      <map code="0xc587" name="1em"/><!-- HANGUL SYLLABLE YALB -->
+      <map code="0xc588" name="1em"/><!-- HANGUL SYLLABLE YALS -->
+      <map code="0xc589" name="1em"/><!-- HANGUL SYLLABLE YALT -->
+      <map code="0xc58a" name="1em"/><!-- HANGUL SYLLABLE YALP -->
+      <map code="0xc58b" name="1em"/><!-- HANGUL SYLLABLE YALH -->
+      <map code="0xc58c" name="1em"/><!-- HANGUL SYLLABLE YAM -->
+      <map code="0xc58d" name="1em"/><!-- HANGUL SYLLABLE YAB -->
+      <map code="0xc58e" name="1em"/><!-- HANGUL SYLLABLE YABS -->
+      <map code="0xc58f" name="1em"/><!-- HANGUL SYLLABLE YAS -->
+      <map code="0xc590" name="1em"/><!-- HANGUL SYLLABLE YASS -->
+      <map code="0xc591" name="1em"/><!-- HANGUL SYLLABLE YANG -->
+      <map code="0xc592" name="1em"/><!-- HANGUL SYLLABLE YAJ -->
+      <map code="0xc593" name="1em"/><!-- HANGUL SYLLABLE YAC -->
+      <map code="0xc594" name="1em"/><!-- HANGUL SYLLABLE YAK -->
+      <map code="0xc595" name="1em"/><!-- HANGUL SYLLABLE YAT -->
+      <map code="0xc596" name="1em"/><!-- HANGUL SYLLABLE YAP -->
+      <map code="0xc597" name="1em"/><!-- HANGUL SYLLABLE YAH -->
+      <map code="0xc598" name="1em"/><!-- HANGUL SYLLABLE YAE -->
+      <map code="0xc599" name="1em"/><!-- HANGUL SYLLABLE YAEG -->
+      <map code="0xc59a" name="1em"/><!-- HANGUL SYLLABLE YAEGG -->
+      <map code="0xc59b" name="1em"/><!-- HANGUL SYLLABLE YAEGS -->
+      <map code="0xc59c" name="1em"/><!-- HANGUL SYLLABLE YAEN -->
+      <map code="0xc59d" name="1em"/><!-- HANGUL SYLLABLE YAENJ -->
+      <map code="0xc59e" name="1em"/><!-- HANGUL SYLLABLE YAENH -->
+      <map code="0xc59f" name="1em"/><!-- HANGUL SYLLABLE YAED -->
+      <map code="0xc5a0" name="1em"/><!-- HANGUL SYLLABLE YAEL -->
+      <map code="0xc5a1" name="1em"/><!-- HANGUL SYLLABLE YAELG -->
+      <map code="0xc5a2" name="1em"/><!-- HANGUL SYLLABLE YAELM -->
+      <map code="0xc5a3" name="1em"/><!-- HANGUL SYLLABLE YAELB -->
+      <map code="0xc5a4" name="1em"/><!-- HANGUL SYLLABLE YAELS -->
+      <map code="0xc5a5" name="1em"/><!-- HANGUL SYLLABLE YAELT -->
+      <map code="0xc5a6" name="1em"/><!-- HANGUL SYLLABLE YAELP -->
+      <map code="0xc5a7" name="1em"/><!-- HANGUL SYLLABLE YAELH -->
+      <map code="0xc5a8" name="1em"/><!-- HANGUL SYLLABLE YAEM -->
+      <map code="0xc5a9" name="1em"/><!-- HANGUL SYLLABLE YAEB -->
+      <map code="0xc5aa" name="1em"/><!-- HANGUL SYLLABLE YAEBS -->
+      <map code="0xc5ab" name="1em"/><!-- HANGUL SYLLABLE YAES -->
+      <map code="0xc5ac" name="1em"/><!-- HANGUL SYLLABLE YAESS -->
+      <map code="0xc5ad" name="1em"/><!-- HANGUL SYLLABLE YAENG -->
+      <map code="0xc5ae" name="1em"/><!-- HANGUL SYLLABLE YAEJ -->
+      <map code="0xc5af" name="1em"/><!-- HANGUL SYLLABLE YAEC -->
+      <map code="0xc5b0" name="1em"/><!-- HANGUL SYLLABLE YAEK -->
+      <map code="0xc5b1" name="1em"/><!-- HANGUL SYLLABLE YAET -->
+      <map code="0xc5b2" name="1em"/><!-- HANGUL SYLLABLE YAEP -->
+      <map code="0xc5b3" name="1em"/><!-- HANGUL SYLLABLE YAEH -->
+      <map code="0xc5b4" name="1em"/><!-- HANGUL SYLLABLE EO -->
+      <map code="0xc5b5" name="1em"/><!-- HANGUL SYLLABLE EOG -->
+      <map code="0xc5b6" name="1em"/><!-- HANGUL SYLLABLE EOGG -->
+      <map code="0xc5b7" name="1em"/><!-- HANGUL SYLLABLE EOGS -->
+      <map code="0xc5b8" name="1em"/><!-- HANGUL SYLLABLE EON -->
+      <map code="0xc5b9" name="1em"/><!-- HANGUL SYLLABLE EONJ -->
+      <map code="0xc5ba" name="1em"/><!-- HANGUL SYLLABLE EONH -->
+      <map code="0xc5bb" name="1em"/><!-- HANGUL SYLLABLE EOD -->
+      <map code="0xc5bc" name="1em"/><!-- HANGUL SYLLABLE EOL -->
+      <map code="0xc5bd" name="1em"/><!-- HANGUL SYLLABLE EOLG -->
+      <map code="0xc5be" name="1em"/><!-- HANGUL SYLLABLE EOLM -->
+      <map code="0xc5bf" name="1em"/><!-- HANGUL SYLLABLE EOLB -->
+      <map code="0xc5c0" name="1em"/><!-- HANGUL SYLLABLE EOLS -->
+      <map code="0xc5c1" name="1em"/><!-- HANGUL SYLLABLE EOLT -->
+      <map code="0xc5c2" name="1em"/><!-- HANGUL SYLLABLE EOLP -->
+      <map code="0xc5c3" name="1em"/><!-- HANGUL SYLLABLE EOLH -->
+      <map code="0xc5c4" name="1em"/><!-- HANGUL SYLLABLE EOM -->
+      <map code="0xc5c5" name="1em"/><!-- HANGUL SYLLABLE EOB -->
+      <map code="0xc5c6" name="1em"/><!-- HANGUL SYLLABLE EOBS -->
+      <map code="0xc5c7" name="1em"/><!-- HANGUL SYLLABLE EOS -->
+      <map code="0xc5c8" name="1em"/><!-- HANGUL SYLLABLE EOSS -->
+      <map code="0xc5c9" name="1em"/><!-- HANGUL SYLLABLE EONG -->
+      <map code="0xc5ca" name="1em"/><!-- HANGUL SYLLABLE EOJ -->
+      <map code="0xc5cb" name="1em"/><!-- HANGUL SYLLABLE EOC -->
+      <map code="0xc5cc" name="1em"/><!-- HANGUL SYLLABLE EOK -->
+      <map code="0xc5cd" name="1em"/><!-- HANGUL SYLLABLE EOT -->
+      <map code="0xc5ce" name="1em"/><!-- HANGUL SYLLABLE EOP -->
+      <map code="0xc5cf" name="1em"/><!-- HANGUL SYLLABLE EOH -->
+      <map code="0xc5d0" name="1em"/><!-- HANGUL SYLLABLE E -->
+      <map code="0xc5d1" name="1em"/><!-- HANGUL SYLLABLE EG -->
+      <map code="0xc5d2" name="1em"/><!-- HANGUL SYLLABLE EGG -->
+      <map code="0xc5d3" name="1em"/><!-- HANGUL SYLLABLE EGS -->
+      <map code="0xc5d4" name="1em"/><!-- HANGUL SYLLABLE EN -->
+      <map code="0xc5d5" name="1em"/><!-- HANGUL SYLLABLE ENJ -->
+      <map code="0xc5d6" name="1em"/><!-- HANGUL SYLLABLE ENH -->
+      <map code="0xc5d7" name="1em"/><!-- HANGUL SYLLABLE ED -->
+      <map code="0xc5d8" name="1em"/><!-- HANGUL SYLLABLE EL -->
+      <map code="0xc5d9" name="1em"/><!-- HANGUL SYLLABLE ELG -->
+      <map code="0xc5da" name="1em"/><!-- HANGUL SYLLABLE ELM -->
+      <map code="0xc5db" name="1em"/><!-- HANGUL SYLLABLE ELB -->
+      <map code="0xc5dc" name="1em"/><!-- HANGUL SYLLABLE ELS -->
+      <map code="0xc5dd" name="1em"/><!-- HANGUL SYLLABLE ELT -->
+      <map code="0xc5de" name="1em"/><!-- HANGUL SYLLABLE ELP -->
+      <map code="0xc5df" name="1em"/><!-- HANGUL SYLLABLE ELH -->
+      <map code="0xc5e0" name="1em"/><!-- HANGUL SYLLABLE EM -->
+      <map code="0xc5e1" name="1em"/><!-- HANGUL SYLLABLE EB -->
+      <map code="0xc5e2" name="1em"/><!-- HANGUL SYLLABLE EBS -->
+      <map code="0xc5e3" name="1em"/><!-- HANGUL SYLLABLE ES -->
+      <map code="0xc5e4" name="1em"/><!-- HANGUL SYLLABLE ESS -->
+      <map code="0xc5e5" name="1em"/><!-- HANGUL SYLLABLE ENG -->
+      <map code="0xc5e6" name="1em"/><!-- HANGUL SYLLABLE EJ -->
+      <map code="0xc5e7" name="1em"/><!-- HANGUL SYLLABLE EC -->
+      <map code="0xc5e8" name="1em"/><!-- HANGUL SYLLABLE EK -->
+      <map code="0xc5e9" name="1em"/><!-- HANGUL SYLLABLE ET -->
+      <map code="0xc5ea" name="1em"/><!-- HANGUL SYLLABLE EP -->
+      <map code="0xc5eb" name="1em"/><!-- HANGUL SYLLABLE EH -->
+      <map code="0xc5ec" name="1em"/><!-- HANGUL SYLLABLE YEO -->
+      <map code="0xc5ed" name="1em"/><!-- HANGUL SYLLABLE YEOG -->
+      <map code="0xc5ee" name="1em"/><!-- HANGUL SYLLABLE YEOGG -->
+      <map code="0xc5ef" name="1em"/><!-- HANGUL SYLLABLE YEOGS -->
+      <map code="0xc5f0" name="1em"/><!-- HANGUL SYLLABLE YEON -->
+      <map code="0xc5f1" name="1em"/><!-- HANGUL SYLLABLE YEONJ -->
+      <map code="0xc5f2" name="1em"/><!-- HANGUL SYLLABLE YEONH -->
+      <map code="0xc5f3" name="1em"/><!-- HANGUL SYLLABLE YEOD -->
+      <map code="0xc5f4" name="1em"/><!-- HANGUL SYLLABLE YEOL -->
+      <map code="0xc5f5" name="1em"/><!-- HANGUL SYLLABLE YEOLG -->
+      <map code="0xc5f6" name="1em"/><!-- HANGUL SYLLABLE YEOLM -->
+      <map code="0xc5f7" name="1em"/><!-- HANGUL SYLLABLE YEOLB -->
+      <map code="0xc5f8" name="1em"/><!-- HANGUL SYLLABLE YEOLS -->
+      <map code="0xc5f9" name="1em"/><!-- HANGUL SYLLABLE YEOLT -->
+      <map code="0xc5fa" name="1em"/><!-- HANGUL SYLLABLE YEOLP -->
+      <map code="0xc5fb" name="1em"/><!-- HANGUL SYLLABLE YEOLH -->
+      <map code="0xc5fc" name="1em"/><!-- HANGUL SYLLABLE YEOM -->
+      <map code="0xc5fd" name="1em"/><!-- HANGUL SYLLABLE YEOB -->
+      <map code="0xc5fe" name="1em"/><!-- HANGUL SYLLABLE YEOBS -->
+      <map code="0xc5ff" name="1em"/><!-- HANGUL SYLLABLE YEOS -->
+      <map code="0xc600" name="1em"/><!-- HANGUL SYLLABLE YEOSS -->
+      <map code="0xc601" name="1em"/><!-- HANGUL SYLLABLE YEONG -->
+      <map code="0xc602" name="1em"/><!-- HANGUL SYLLABLE YEOJ -->
+      <map code="0xc603" name="1em"/><!-- HANGUL SYLLABLE YEOC -->
+      <map code="0xc604" name="1em"/><!-- HANGUL SYLLABLE YEOK -->
+      <map code="0xc605" name="1em"/><!-- HANGUL SYLLABLE YEOT -->
+      <map code="0xc606" name="1em"/><!-- HANGUL SYLLABLE YEOP -->
+      <map code="0xc607" name="1em"/><!-- HANGUL SYLLABLE YEOH -->
+      <map code="0xc608" name="1em"/><!-- HANGUL SYLLABLE YE -->
+      <map code="0xc609" name="1em"/><!-- HANGUL SYLLABLE YEG -->
+      <map code="0xc60a" name="1em"/><!-- HANGUL SYLLABLE YEGG -->
+      <map code="0xc60b" name="1em"/><!-- HANGUL SYLLABLE YEGS -->
+      <map code="0xc60c" name="1em"/><!-- HANGUL SYLLABLE YEN -->
+      <map code="0xc60d" name="1em"/><!-- HANGUL SYLLABLE YENJ -->
+      <map code="0xc60e" name="1em"/><!-- HANGUL SYLLABLE YENH -->
+      <map code="0xc60f" name="1em"/><!-- HANGUL SYLLABLE YED -->
+      <map code="0xc610" name="1em"/><!-- HANGUL SYLLABLE YEL -->
+      <map code="0xc611" name="1em"/><!-- HANGUL SYLLABLE YELG -->
+      <map code="0xc612" name="1em"/><!-- HANGUL SYLLABLE YELM -->
+      <map code="0xc613" name="1em"/><!-- HANGUL SYLLABLE YELB -->
+      <map code="0xc614" name="1em"/><!-- HANGUL SYLLABLE YELS -->
+      <map code="0xc615" name="1em"/><!-- HANGUL SYLLABLE YELT -->
+      <map code="0xc616" name="1em"/><!-- HANGUL SYLLABLE YELP -->
+      <map code="0xc617" name="1em"/><!-- HANGUL SYLLABLE YELH -->
+      <map code="0xc618" name="1em"/><!-- HANGUL SYLLABLE YEM -->
+      <map code="0xc619" name="1em"/><!-- HANGUL SYLLABLE YEB -->
+      <map code="0xc61a" name="1em"/><!-- HANGUL SYLLABLE YEBS -->
+      <map code="0xc61b" name="1em"/><!-- HANGUL SYLLABLE YES -->
+      <map code="0xc61c" name="1em"/><!-- HANGUL SYLLABLE YESS -->
+      <map code="0xc61d" name="1em"/><!-- HANGUL SYLLABLE YENG -->
+      <map code="0xc61e" name="1em"/><!-- HANGUL SYLLABLE YEJ -->
+      <map code="0xc61f" name="1em"/><!-- HANGUL SYLLABLE YEC -->
+      <map code="0xc620" name="1em"/><!-- HANGUL SYLLABLE YEK -->
+      <map code="0xc621" name="1em"/><!-- HANGUL SYLLABLE YET -->
+      <map code="0xc622" name="1em"/><!-- HANGUL SYLLABLE YEP -->
+      <map code="0xc623" name="1em"/><!-- HANGUL SYLLABLE YEH -->
+      <map code="0xc624" name="1em"/><!-- HANGUL SYLLABLE O -->
+      <map code="0xc625" name="1em"/><!-- HANGUL SYLLABLE OG -->
+      <map code="0xc626" name="1em"/><!-- HANGUL SYLLABLE OGG -->
+      <map code="0xc627" name="1em"/><!-- HANGUL SYLLABLE OGS -->
+      <map code="0xc628" name="1em"/><!-- HANGUL SYLLABLE ON -->
+      <map code="0xc629" name="1em"/><!-- HANGUL SYLLABLE ONJ -->
+      <map code="0xc62a" name="1em"/><!-- HANGUL SYLLABLE ONH -->
+      <map code="0xc62b" name="1em"/><!-- HANGUL SYLLABLE OD -->
+      <map code="0xc62c" name="1em"/><!-- HANGUL SYLLABLE OL -->
+      <map code="0xc62d" name="1em"/><!-- HANGUL SYLLABLE OLG -->
+      <map code="0xc62e" name="1em"/><!-- HANGUL SYLLABLE OLM -->
+      <map code="0xc62f" name="1em"/><!-- HANGUL SYLLABLE OLB -->
+      <map code="0xc630" name="1em"/><!-- HANGUL SYLLABLE OLS -->
+      <map code="0xc631" name="1em"/><!-- HANGUL SYLLABLE OLT -->
+      <map code="0xc632" name="1em"/><!-- HANGUL SYLLABLE OLP -->
+      <map code="0xc633" name="1em"/><!-- HANGUL SYLLABLE OLH -->
+      <map code="0xc634" name="1em"/><!-- HANGUL SYLLABLE OM -->
+      <map code="0xc635" name="1em"/><!-- HANGUL SYLLABLE OB -->
+      <map code="0xc636" name="1em"/><!-- HANGUL SYLLABLE OBS -->
+      <map code="0xc637" name="1em"/><!-- HANGUL SYLLABLE OS -->
+      <map code="0xc638" name="1em"/><!-- HANGUL SYLLABLE OSS -->
+      <map code="0xc639" name="1em"/><!-- HANGUL SYLLABLE ONG -->
+      <map code="0xc63a" name="1em"/><!-- HANGUL SYLLABLE OJ -->
+      <map code="0xc63b" name="1em"/><!-- HANGUL SYLLABLE OC -->
+      <map code="0xc63c" name="1em"/><!-- HANGUL SYLLABLE OK -->
+      <map code="0xc63d" name="1em"/><!-- HANGUL SYLLABLE OT -->
+      <map code="0xc63e" name="1em"/><!-- HANGUL SYLLABLE OP -->
+      <map code="0xc63f" name="1em"/><!-- HANGUL SYLLABLE OH -->
+      <map code="0xc640" name="1em"/><!-- HANGUL SYLLABLE WA -->
+      <map code="0xc641" name="1em"/><!-- HANGUL SYLLABLE WAG -->
+      <map code="0xc642" name="1em"/><!-- HANGUL SYLLABLE WAGG -->
+      <map code="0xc643" name="1em"/><!-- HANGUL SYLLABLE WAGS -->
+      <map code="0xc644" name="1em"/><!-- HANGUL SYLLABLE WAN -->
+      <map code="0xc645" name="1em"/><!-- HANGUL SYLLABLE WANJ -->
+      <map code="0xc646" name="1em"/><!-- HANGUL SYLLABLE WANH -->
+      <map code="0xc647" name="1em"/><!-- HANGUL SYLLABLE WAD -->
+      <map code="0xc648" name="1em"/><!-- HANGUL SYLLABLE WAL -->
+      <map code="0xc649" name="1em"/><!-- HANGUL SYLLABLE WALG -->
+      <map code="0xc64a" name="1em"/><!-- HANGUL SYLLABLE WALM -->
+      <map code="0xc64b" name="1em"/><!-- HANGUL SYLLABLE WALB -->
+      <map code="0xc64c" name="1em"/><!-- HANGUL SYLLABLE WALS -->
+      <map code="0xc64d" name="1em"/><!-- HANGUL SYLLABLE WALT -->
+      <map code="0xc64e" name="1em"/><!-- HANGUL SYLLABLE WALP -->
+      <map code="0xc64f" name="1em"/><!-- HANGUL SYLLABLE WALH -->
+      <map code="0xc650" name="1em"/><!-- HANGUL SYLLABLE WAM -->
+      <map code="0xc651" name="1em"/><!-- HANGUL SYLLABLE WAB -->
+      <map code="0xc652" name="1em"/><!-- HANGUL SYLLABLE WABS -->
+      <map code="0xc653" name="1em"/><!-- HANGUL SYLLABLE WAS -->
+      <map code="0xc654" name="1em"/><!-- HANGUL SYLLABLE WASS -->
+      <map code="0xc655" name="1em"/><!-- HANGUL SYLLABLE WANG -->
+      <map code="0xc656" name="1em"/><!-- HANGUL SYLLABLE WAJ -->
+      <map code="0xc657" name="1em"/><!-- HANGUL SYLLABLE WAC -->
+      <map code="0xc658" name="1em"/><!-- HANGUL SYLLABLE WAK -->
+      <map code="0xc659" name="1em"/><!-- HANGUL SYLLABLE WAT -->
+      <map code="0xc65a" name="1em"/><!-- HANGUL SYLLABLE WAP -->
+      <map code="0xc65b" name="1em"/><!-- HANGUL SYLLABLE WAH -->
+      <map code="0xc65c" name="1em"/><!-- HANGUL SYLLABLE WAE -->
+      <map code="0xc65d" name="1em"/><!-- HANGUL SYLLABLE WAEG -->
+      <map code="0xc65e" name="1em"/><!-- HANGUL SYLLABLE WAEGG -->
+      <map code="0xc65f" name="1em"/><!-- HANGUL SYLLABLE WAEGS -->
+      <map code="0xc660" name="1em"/><!-- HANGUL SYLLABLE WAEN -->
+      <map code="0xc661" name="1em"/><!-- HANGUL SYLLABLE WAENJ -->
+      <map code="0xc662" name="1em"/><!-- HANGUL SYLLABLE WAENH -->
+      <map code="0xc663" name="1em"/><!-- HANGUL SYLLABLE WAED -->
+      <map code="0xc664" name="1em"/><!-- HANGUL SYLLABLE WAEL -->
+      <map code="0xc665" name="1em"/><!-- HANGUL SYLLABLE WAELG -->
+      <map code="0xc666" name="1em"/><!-- HANGUL SYLLABLE WAELM -->
+      <map code="0xc667" name="1em"/><!-- HANGUL SYLLABLE WAELB -->
+      <map code="0xc668" name="1em"/><!-- HANGUL SYLLABLE WAELS -->
+      <map code="0xc669" name="1em"/><!-- HANGUL SYLLABLE WAELT -->
+      <map code="0xc66a" name="1em"/><!-- HANGUL SYLLABLE WAELP -->
+      <map code="0xc66b" name="1em"/><!-- HANGUL SYLLABLE WAELH -->
+      <map code="0xc66c" name="1em"/><!-- HANGUL SYLLABLE WAEM -->
+      <map code="0xc66d" name="1em"/><!-- HANGUL SYLLABLE WAEB -->
+      <map code="0xc66e" name="1em"/><!-- HANGUL SYLLABLE WAEBS -->
+      <map code="0xc66f" name="1em"/><!-- HANGUL SYLLABLE WAES -->
+      <map code="0xc670" name="1em"/><!-- HANGUL SYLLABLE WAESS -->
+      <map code="0xc671" name="1em"/><!-- HANGUL SYLLABLE WAENG -->
+      <map code="0xc672" name="1em"/><!-- HANGUL SYLLABLE WAEJ -->
+      <map code="0xc673" name="1em"/><!-- HANGUL SYLLABLE WAEC -->
+      <map code="0xc674" name="1em"/><!-- HANGUL SYLLABLE WAEK -->
+      <map code="0xc675" name="1em"/><!-- HANGUL SYLLABLE WAET -->
+      <map code="0xc676" name="1em"/><!-- HANGUL SYLLABLE WAEP -->
+      <map code="0xc677" name="1em"/><!-- HANGUL SYLLABLE WAEH -->
+      <map code="0xc678" name="1em"/><!-- HANGUL SYLLABLE OE -->
+      <map code="0xc679" name="1em"/><!-- HANGUL SYLLABLE OEG -->
+      <map code="0xc67a" name="1em"/><!-- HANGUL SYLLABLE OEGG -->
+      <map code="0xc67b" name="1em"/><!-- HANGUL SYLLABLE OEGS -->
+      <map code="0xc67c" name="1em"/><!-- HANGUL SYLLABLE OEN -->
+      <map code="0xc67d" name="1em"/><!-- HANGUL SYLLABLE OENJ -->
+      <map code="0xc67e" name="1em"/><!-- HANGUL SYLLABLE OENH -->
+      <map code="0xc67f" name="1em"/><!-- HANGUL SYLLABLE OED -->
+      <map code="0xc680" name="1em"/><!-- HANGUL SYLLABLE OEL -->
+      <map code="0xc681" name="1em"/><!-- HANGUL SYLLABLE OELG -->
+      <map code="0xc682" name="1em"/><!-- HANGUL SYLLABLE OELM -->
+      <map code="0xc683" name="1em"/><!-- HANGUL SYLLABLE OELB -->
+      <map code="0xc684" name="1em"/><!-- HANGUL SYLLABLE OELS -->
+      <map code="0xc685" name="1em"/><!-- HANGUL SYLLABLE OELT -->
+      <map code="0xc686" name="1em"/><!-- HANGUL SYLLABLE OELP -->
+      <map code="0xc687" name="1em"/><!-- HANGUL SYLLABLE OELH -->
+      <map code="0xc688" name="1em"/><!-- HANGUL SYLLABLE OEM -->
+      <map code="0xc689" name="1em"/><!-- HANGUL SYLLABLE OEB -->
+      <map code="0xc68a" name="1em"/><!-- HANGUL SYLLABLE OEBS -->
+      <map code="0xc68b" name="1em"/><!-- HANGUL SYLLABLE OES -->
+      <map code="0xc68c" name="1em"/><!-- HANGUL SYLLABLE OESS -->
+      <map code="0xc68d" name="1em"/><!-- HANGUL SYLLABLE OENG -->
+      <map code="0xc68e" name="1em"/><!-- HANGUL SYLLABLE OEJ -->
+      <map code="0xc68f" name="1em"/><!-- HANGUL SYLLABLE OEC -->
+      <map code="0xc690" name="1em"/><!-- HANGUL SYLLABLE OEK -->
+      <map code="0xc691" name="1em"/><!-- HANGUL SYLLABLE OET -->
+      <map code="0xc692" name="1em"/><!-- HANGUL SYLLABLE OEP -->
+      <map code="0xc693" name="1em"/><!-- HANGUL SYLLABLE OEH -->
+      <map code="0xc694" name="1em"/><!-- HANGUL SYLLABLE YO -->
+      <map code="0xc695" name="1em"/><!-- HANGUL SYLLABLE YOG -->
+      <map code="0xc696" name="1em"/><!-- HANGUL SYLLABLE YOGG -->
+      <map code="0xc697" name="1em"/><!-- HANGUL SYLLABLE YOGS -->
+      <map code="0xc698" name="1em"/><!-- HANGUL SYLLABLE YON -->
+      <map code="0xc699" name="1em"/><!-- HANGUL SYLLABLE YONJ -->
+      <map code="0xc69a" name="1em"/><!-- HANGUL SYLLABLE YONH -->
+      <map code="0xc69b" name="1em"/><!-- HANGUL SYLLABLE YOD -->
+      <map code="0xc69c" name="1em"/><!-- HANGUL SYLLABLE YOL -->
+      <map code="0xc69d" name="1em"/><!-- HANGUL SYLLABLE YOLG -->
+      <map code="0xc69e" name="1em"/><!-- HANGUL SYLLABLE YOLM -->
+      <map code="0xc69f" name="1em"/><!-- HANGUL SYLLABLE YOLB -->
+      <map code="0xc6a0" name="1em"/><!-- HANGUL SYLLABLE YOLS -->
+      <map code="0xc6a1" name="1em"/><!-- HANGUL SYLLABLE YOLT -->
+      <map code="0xc6a2" name="1em"/><!-- HANGUL SYLLABLE YOLP -->
+      <map code="0xc6a3" name="1em"/><!-- HANGUL SYLLABLE YOLH -->
+      <map code="0xc6a4" name="1em"/><!-- HANGUL SYLLABLE YOM -->
+      <map code="0xc6a5" name="1em"/><!-- HANGUL SYLLABLE YOB -->
+      <map code="0xc6a6" name="1em"/><!-- HANGUL SYLLABLE YOBS -->
+      <map code="0xc6a7" name="1em"/><!-- HANGUL SYLLABLE YOS -->
+      <map code="0xc6a8" name="1em"/><!-- HANGUL SYLLABLE YOSS -->
+      <map code="0xc6a9" name="1em"/><!-- HANGUL SYLLABLE YONG -->
+      <map code="0xc6aa" name="1em"/><!-- HANGUL SYLLABLE YOJ -->
+      <map code="0xc6ab" name="1em"/><!-- HANGUL SYLLABLE YOC -->
+      <map code="0xc6ac" name="1em"/><!-- HANGUL SYLLABLE YOK -->
+      <map code="0xc6ad" name="1em"/><!-- HANGUL SYLLABLE YOT -->
+      <map code="0xc6ae" name="1em"/><!-- HANGUL SYLLABLE YOP -->
+      <map code="0xc6af" name="1em"/><!-- HANGUL SYLLABLE YOH -->
+      <map code="0xc6b0" name="1em"/><!-- HANGUL SYLLABLE U -->
+      <map code="0xc6b1" name="1em"/><!-- HANGUL SYLLABLE UG -->
+      <map code="0xc6b2" name="1em"/><!-- HANGUL SYLLABLE UGG -->
+      <map code="0xc6b3" name="1em"/><!-- HANGUL SYLLABLE UGS -->
+      <map code="0xc6b4" name="1em"/><!-- HANGUL SYLLABLE UN -->
+      <map code="0xc6b5" name="1em"/><!-- HANGUL SYLLABLE UNJ -->
+      <map code="0xc6b6" name="1em"/><!-- HANGUL SYLLABLE UNH -->
+      <map code="0xc6b7" name="1em"/><!-- HANGUL SYLLABLE UD -->
+      <map code="0xc6b8" name="1em"/><!-- HANGUL SYLLABLE UL -->
+      <map code="0xc6b9" name="1em"/><!-- HANGUL SYLLABLE ULG -->
+      <map code="0xc6ba" name="1em"/><!-- HANGUL SYLLABLE ULM -->
+      <map code="0xc6bb" name="1em"/><!-- HANGUL SYLLABLE ULB -->
+      <map code="0xc6bc" name="1em"/><!-- HANGUL SYLLABLE ULS -->
+      <map code="0xc6bd" name="1em"/><!-- HANGUL SYLLABLE ULT -->
+      <map code="0xc6be" name="1em"/><!-- HANGUL SYLLABLE ULP -->
+      <map code="0xc6bf" name="1em"/><!-- HANGUL SYLLABLE ULH -->
+      <map code="0xc6c0" name="1em"/><!-- HANGUL SYLLABLE UM -->
+      <map code="0xc6c1" name="1em"/><!-- HANGUL SYLLABLE UB -->
+      <map code="0xc6c2" name="1em"/><!-- HANGUL SYLLABLE UBS -->
+      <map code="0xc6c3" name="1em"/><!-- HANGUL SYLLABLE US -->
+      <map code="0xc6c4" name="1em"/><!-- HANGUL SYLLABLE USS -->
+      <map code="0xc6c5" name="1em"/><!-- HANGUL SYLLABLE UNG -->
+      <map code="0xc6c6" name="1em"/><!-- HANGUL SYLLABLE UJ -->
+      <map code="0xc6c7" name="1em"/><!-- HANGUL SYLLABLE UC -->
+      <map code="0xc6c8" name="1em"/><!-- HANGUL SYLLABLE UK -->
+      <map code="0xc6c9" name="1em"/><!-- HANGUL SYLLABLE UT -->
+      <map code="0xc6ca" name="1em"/><!-- HANGUL SYLLABLE UP -->
+      <map code="0xc6cb" name="1em"/><!-- HANGUL SYLLABLE UH -->
+      <map code="0xc6cc" name="1em"/><!-- HANGUL SYLLABLE WEO -->
+      <map code="0xc6cd" name="1em"/><!-- HANGUL SYLLABLE WEOG -->
+      <map code="0xc6ce" name="1em"/><!-- HANGUL SYLLABLE WEOGG -->
+      <map code="0xc6cf" name="1em"/><!-- HANGUL SYLLABLE WEOGS -->
+      <map code="0xc6d0" name="1em"/><!-- HANGUL SYLLABLE WEON -->
+      <map code="0xc6d1" name="1em"/><!-- HANGUL SYLLABLE WEONJ -->
+      <map code="0xc6d2" name="1em"/><!-- HANGUL SYLLABLE WEONH -->
+      <map code="0xc6d3" name="1em"/><!-- HANGUL SYLLABLE WEOD -->
+      <map code="0xc6d4" name="1em"/><!-- HANGUL SYLLABLE WEOL -->
+      <map code="0xc6d5" name="1em"/><!-- HANGUL SYLLABLE WEOLG -->
+      <map code="0xc6d6" name="1em"/><!-- HANGUL SYLLABLE WEOLM -->
+      <map code="0xc6d7" name="1em"/><!-- HANGUL SYLLABLE WEOLB -->
+      <map code="0xc6d8" name="1em"/><!-- HANGUL SYLLABLE WEOLS -->
+      <map code="0xc6d9" name="1em"/><!-- HANGUL SYLLABLE WEOLT -->
+      <map code="0xc6da" name="1em"/><!-- HANGUL SYLLABLE WEOLP -->
+      <map code="0xc6db" name="1em"/><!-- HANGUL SYLLABLE WEOLH -->
+      <map code="0xc6dc" name="1em"/><!-- HANGUL SYLLABLE WEOM -->
+      <map code="0xc6dd" name="1em"/><!-- HANGUL SYLLABLE WEOB -->
+      <map code="0xc6de" name="1em"/><!-- HANGUL SYLLABLE WEOBS -->
+      <map code="0xc6df" name="1em"/><!-- HANGUL SYLLABLE WEOS -->
+      <map code="0xc6e0" name="1em"/><!-- HANGUL SYLLABLE WEOSS -->
+      <map code="0xc6e1" name="1em"/><!-- HANGUL SYLLABLE WEONG -->
+      <map code="0xc6e2" name="1em"/><!-- HANGUL SYLLABLE WEOJ -->
+      <map code="0xc6e3" name="1em"/><!-- HANGUL SYLLABLE WEOC -->
+      <map code="0xc6e4" name="1em"/><!-- HANGUL SYLLABLE WEOK -->
+      <map code="0xc6e5" name="1em"/><!-- HANGUL SYLLABLE WEOT -->
+      <map code="0xc6e6" name="1em"/><!-- HANGUL SYLLABLE WEOP -->
+      <map code="0xc6e7" name="1em"/><!-- HANGUL SYLLABLE WEOH -->
+      <map code="0xc6e8" name="1em"/><!-- HANGUL SYLLABLE WE -->
+      <map code="0xc6e9" name="1em"/><!-- HANGUL SYLLABLE WEG -->
+      <map code="0xc6ea" name="1em"/><!-- HANGUL SYLLABLE WEGG -->
+      <map code="0xc6eb" name="1em"/><!-- HANGUL SYLLABLE WEGS -->
+      <map code="0xc6ec" name="1em"/><!-- HANGUL SYLLABLE WEN -->
+      <map code="0xc6ed" name="1em"/><!-- HANGUL SYLLABLE WENJ -->
+      <map code="0xc6ee" name="1em"/><!-- HANGUL SYLLABLE WENH -->
+      <map code="0xc6ef" name="1em"/><!-- HANGUL SYLLABLE WED -->
+      <map code="0xc6f0" name="1em"/><!-- HANGUL SYLLABLE WEL -->
+      <map code="0xc6f1" name="1em"/><!-- HANGUL SYLLABLE WELG -->
+      <map code="0xc6f2" name="1em"/><!-- HANGUL SYLLABLE WELM -->
+      <map code="0xc6f3" name="1em"/><!-- HANGUL SYLLABLE WELB -->
+      <map code="0xc6f4" name="1em"/><!-- HANGUL SYLLABLE WELS -->
+      <map code="0xc6f5" name="1em"/><!-- HANGUL SYLLABLE WELT -->
+      <map code="0xc6f6" name="1em"/><!-- HANGUL SYLLABLE WELP -->
+      <map code="0xc6f7" name="1em"/><!-- HANGUL SYLLABLE WELH -->
+      <map code="0xc6f8" name="1em"/><!-- HANGUL SYLLABLE WEM -->
+      <map code="0xc6f9" name="1em"/><!-- HANGUL SYLLABLE WEB -->
+      <map code="0xc6fa" name="1em"/><!-- HANGUL SYLLABLE WEBS -->
+      <map code="0xc6fb" name="1em"/><!-- HANGUL SYLLABLE WES -->
+      <map code="0xc6fc" name="1em"/><!-- HANGUL SYLLABLE WESS -->
+      <map code="0xc6fd" name="1em"/><!-- HANGUL SYLLABLE WENG -->
+      <map code="0xc6fe" name="1em"/><!-- HANGUL SYLLABLE WEJ -->
+      <map code="0xc6ff" name="1em"/><!-- HANGUL SYLLABLE WEC -->
+      <map code="0xc700" name="1em"/><!-- HANGUL SYLLABLE WEK -->
+      <map code="0xc701" name="1em"/><!-- HANGUL SYLLABLE WET -->
+      <map code="0xc702" name="1em"/><!-- HANGUL SYLLABLE WEP -->
+      <map code="0xc703" name="1em"/><!-- HANGUL SYLLABLE WEH -->
+      <map code="0xc704" name="1em"/><!-- HANGUL SYLLABLE WI -->
+      <map code="0xc705" name="1em"/><!-- HANGUL SYLLABLE WIG -->
+      <map code="0xc706" name="1em"/><!-- HANGUL SYLLABLE WIGG -->
+      <map code="0xc707" name="1em"/><!-- HANGUL SYLLABLE WIGS -->
+      <map code="0xc708" name="1em"/><!-- HANGUL SYLLABLE WIN -->
+      <map code="0xc709" name="1em"/><!-- HANGUL SYLLABLE WINJ -->
+      <map code="0xc70a" name="1em"/><!-- HANGUL SYLLABLE WINH -->
+      <map code="0xc70b" name="1em"/><!-- HANGUL SYLLABLE WID -->
+      <map code="0xc70c" name="1em"/><!-- HANGUL SYLLABLE WIL -->
+      <map code="0xc70d" name="1em"/><!-- HANGUL SYLLABLE WILG -->
+      <map code="0xc70e" name="1em"/><!-- HANGUL SYLLABLE WILM -->
+      <map code="0xc70f" name="1em"/><!-- HANGUL SYLLABLE WILB -->
+      <map code="0xc710" name="1em"/><!-- HANGUL SYLLABLE WILS -->
+      <map code="0xc711" name="1em"/><!-- HANGUL SYLLABLE WILT -->
+      <map code="0xc712" name="1em"/><!-- HANGUL SYLLABLE WILP -->
+      <map code="0xc713" name="1em"/><!-- HANGUL SYLLABLE WILH -->
+      <map code="0xc714" name="1em"/><!-- HANGUL SYLLABLE WIM -->
+      <map code="0xc715" name="1em"/><!-- HANGUL SYLLABLE WIB -->
+      <map code="0xc716" name="1em"/><!-- HANGUL SYLLABLE WIBS -->
+      <map code="0xc717" name="1em"/><!-- HANGUL SYLLABLE WIS -->
+      <map code="0xc718" name="1em"/><!-- HANGUL SYLLABLE WISS -->
+      <map code="0xc719" name="1em"/><!-- HANGUL SYLLABLE WING -->
+      <map code="0xc71a" name="1em"/><!-- HANGUL SYLLABLE WIJ -->
+      <map code="0xc71b" name="1em"/><!-- HANGUL SYLLABLE WIC -->
+      <map code="0xc71c" name="1em"/><!-- HANGUL SYLLABLE WIK -->
+      <map code="0xc71d" name="1em"/><!-- HANGUL SYLLABLE WIT -->
+      <map code="0xc71e" name="1em"/><!-- HANGUL SYLLABLE WIP -->
+      <map code="0xc71f" name="1em"/><!-- HANGUL SYLLABLE WIH -->
+      <map code="0xc720" name="1em"/><!-- HANGUL SYLLABLE YU -->
+      <map code="0xc721" name="1em"/><!-- HANGUL SYLLABLE YUG -->
+      <map code="0xc722" name="1em"/><!-- HANGUL SYLLABLE YUGG -->
+      <map code="0xc723" name="1em"/><!-- HANGUL SYLLABLE YUGS -->
+      <map code="0xc724" name="1em"/><!-- HANGUL SYLLABLE YUN -->
+      <map code="0xc725" name="1em"/><!-- HANGUL SYLLABLE YUNJ -->
+      <map code="0xc726" name="1em"/><!-- HANGUL SYLLABLE YUNH -->
+      <map code="0xc727" name="1em"/><!-- HANGUL SYLLABLE YUD -->
+      <map code="0xc728" name="1em"/><!-- HANGUL SYLLABLE YUL -->
+      <map code="0xc729" name="1em"/><!-- HANGUL SYLLABLE YULG -->
+      <map code="0xc72a" name="1em"/><!-- HANGUL SYLLABLE YULM -->
+      <map code="0xc72b" name="1em"/><!-- HANGUL SYLLABLE YULB -->
+      <map code="0xc72c" name="1em"/><!-- HANGUL SYLLABLE YULS -->
+      <map code="0xc72d" name="1em"/><!-- HANGUL SYLLABLE YULT -->
+      <map code="0xc72e" name="1em"/><!-- HANGUL SYLLABLE YULP -->
+      <map code="0xc72f" name="1em"/><!-- HANGUL SYLLABLE YULH -->
+      <map code="0xc730" name="1em"/><!-- HANGUL SYLLABLE YUM -->
+      <map code="0xc731" name="1em"/><!-- HANGUL SYLLABLE YUB -->
+      <map code="0xc732" name="1em"/><!-- HANGUL SYLLABLE YUBS -->
+      <map code="0xc733" name="1em"/><!-- HANGUL SYLLABLE YUS -->
+      <map code="0xc734" name="1em"/><!-- HANGUL SYLLABLE YUSS -->
+      <map code="0xc735" name="1em"/><!-- HANGUL SYLLABLE YUNG -->
+      <map code="0xc736" name="1em"/><!-- HANGUL SYLLABLE YUJ -->
+      <map code="0xc737" name="1em"/><!-- HANGUL SYLLABLE YUC -->
+      <map code="0xc738" name="1em"/><!-- HANGUL SYLLABLE YUK -->
+      <map code="0xc739" name="1em"/><!-- HANGUL SYLLABLE YUT -->
+      <map code="0xc73a" name="1em"/><!-- HANGUL SYLLABLE YUP -->
+      <map code="0xc73b" name="1em"/><!-- HANGUL SYLLABLE YUH -->
+      <map code="0xc73c" name="1em"/><!-- HANGUL SYLLABLE EU -->
+      <map code="0xc73d" name="1em"/><!-- HANGUL SYLLABLE EUG -->
+      <map code="0xc73e" name="1em"/><!-- HANGUL SYLLABLE EUGG -->
+      <map code="0xc73f" name="1em"/><!-- HANGUL SYLLABLE EUGS -->
+      <map code="0xc740" name="1em"/><!-- HANGUL SYLLABLE EUN -->
+      <map code="0xc741" name="1em"/><!-- HANGUL SYLLABLE EUNJ -->
+      <map code="0xc742" name="1em"/><!-- HANGUL SYLLABLE EUNH -->
+      <map code="0xc743" name="1em"/><!-- HANGUL SYLLABLE EUD -->
+      <map code="0xc744" name="1em"/><!-- HANGUL SYLLABLE EUL -->
+      <map code="0xc745" name="1em"/><!-- HANGUL SYLLABLE EULG -->
+      <map code="0xc746" name="1em"/><!-- HANGUL SYLLABLE EULM -->
+      <map code="0xc747" name="1em"/><!-- HANGUL SYLLABLE EULB -->
+      <map code="0xc748" name="1em"/><!-- HANGUL SYLLABLE EULS -->
+      <map code="0xc749" name="1em"/><!-- HANGUL SYLLABLE EULT -->
+      <map code="0xc74a" name="1em"/><!-- HANGUL SYLLABLE EULP -->
+      <map code="0xc74b" name="1em"/><!-- HANGUL SYLLABLE EULH -->
+      <map code="0xc74c" name="1em"/><!-- HANGUL SYLLABLE EUM -->
+      <map code="0xc74d" name="1em"/><!-- HANGUL SYLLABLE EUB -->
+      <map code="0xc74e" name="1em"/><!-- HANGUL SYLLABLE EUBS -->
+      <map code="0xc74f" name="1em"/><!-- HANGUL SYLLABLE EUS -->
+      <map code="0xc750" name="1em"/><!-- HANGUL SYLLABLE EUSS -->
+      <map code="0xc751" name="1em"/><!-- HANGUL SYLLABLE EUNG -->
+      <map code="0xc752" name="1em"/><!-- HANGUL SYLLABLE EUJ -->
+      <map code="0xc753" name="1em"/><!-- HANGUL SYLLABLE EUC -->
+      <map code="0xc754" name="1em"/><!-- HANGUL SYLLABLE EUK -->
+      <map code="0xc755" name="1em"/><!-- HANGUL SYLLABLE EUT -->
+      <map code="0xc756" name="1em"/><!-- HANGUL SYLLABLE EUP -->
+      <map code="0xc757" name="1em"/><!-- HANGUL SYLLABLE EUH -->
+      <map code="0xc758" name="1em"/><!-- HANGUL SYLLABLE YI -->
+      <map code="0xc759" name="1em"/><!-- HANGUL SYLLABLE YIG -->
+      <map code="0xc75a" name="1em"/><!-- HANGUL SYLLABLE YIGG -->
+      <map code="0xc75b" name="1em"/><!-- HANGUL SYLLABLE YIGS -->
+      <map code="0xc75c" name="1em"/><!-- HANGUL SYLLABLE YIN -->
+      <map code="0xc75d" name="1em"/><!-- HANGUL SYLLABLE YINJ -->
+      <map code="0xc75e" name="1em"/><!-- HANGUL SYLLABLE YINH -->
+      <map code="0xc75f" name="1em"/><!-- HANGUL SYLLABLE YID -->
+      <map code="0xc760" name="1em"/><!-- HANGUL SYLLABLE YIL -->
+      <map code="0xc761" name="1em"/><!-- HANGUL SYLLABLE YILG -->
+      <map code="0xc762" name="1em"/><!-- HANGUL SYLLABLE YILM -->
+      <map code="0xc763" name="1em"/><!-- HANGUL SYLLABLE YILB -->
+      <map code="0xc764" name="1em"/><!-- HANGUL SYLLABLE YILS -->
+      <map code="0xc765" name="1em"/><!-- HANGUL SYLLABLE YILT -->
+      <map code="0xc766" name="1em"/><!-- HANGUL SYLLABLE YILP -->
+      <map code="0xc767" name="1em"/><!-- HANGUL SYLLABLE YILH -->
+      <map code="0xc768" name="1em"/><!-- HANGUL SYLLABLE YIM -->
+      <map code="0xc769" name="1em"/><!-- HANGUL SYLLABLE YIB -->
+      <map code="0xc76a" name="1em"/><!-- HANGUL SYLLABLE YIBS -->
+      <map code="0xc76b" name="1em"/><!-- HANGUL SYLLABLE YIS -->
+      <map code="0xc76c" name="1em"/><!-- HANGUL SYLLABLE YISS -->
+      <map code="0xc76d" name="1em"/><!-- HANGUL SYLLABLE YING -->
+      <map code="0xc76e" name="1em"/><!-- HANGUL SYLLABLE YIJ -->
+      <map code="0xc76f" name="1em"/><!-- HANGUL SYLLABLE YIC -->
+      <map code="0xc770" name="1em"/><!-- HANGUL SYLLABLE YIK -->
+      <map code="0xc771" name="1em"/><!-- HANGUL SYLLABLE YIT -->
+      <map code="0xc772" name="1em"/><!-- HANGUL SYLLABLE YIP -->
+      <map code="0xc773" name="1em"/><!-- HANGUL SYLLABLE YIH -->
+      <map code="0xc774" name="1em"/><!-- HANGUL SYLLABLE I -->
+      <map code="0xc775" name="1em"/><!-- HANGUL SYLLABLE IG -->
+      <map code="0xc776" name="1em"/><!-- HANGUL SYLLABLE IGG -->
+      <map code="0xc777" name="1em"/><!-- HANGUL SYLLABLE IGS -->
+      <map code="0xc778" name="1em"/><!-- HANGUL SYLLABLE IN -->
+      <map code="0xc779" name="1em"/><!-- HANGUL SYLLABLE INJ -->
+      <map code="0xc77a" name="1em"/><!-- HANGUL SYLLABLE INH -->
+      <map code="0xc77b" name="1em"/><!-- HANGUL SYLLABLE ID -->
+      <map code="0xc77c" name="1em"/><!-- HANGUL SYLLABLE IL -->
+      <map code="0xc77d" name="1em"/><!-- HANGUL SYLLABLE ILG -->
+      <map code="0xc77e" name="1em"/><!-- HANGUL SYLLABLE ILM -->
+      <map code="0xc77f" name="1em"/><!-- HANGUL SYLLABLE ILB -->
+      <map code="0xc780" name="1em"/><!-- HANGUL SYLLABLE ILS -->
+      <map code="0xc781" name="1em"/><!-- HANGUL SYLLABLE ILT -->
+      <map code="0xc782" name="1em"/><!-- HANGUL SYLLABLE ILP -->
+      <map code="0xc783" name="1em"/><!-- HANGUL SYLLABLE ILH -->
+      <map code="0xc784" name="1em"/><!-- HANGUL SYLLABLE IM -->
+      <map code="0xc785" name="1em"/><!-- HANGUL SYLLABLE IB -->
+      <map code="0xc786" name="1em"/><!-- HANGUL SYLLABLE IBS -->
+      <map code="0xc787" name="1em"/><!-- HANGUL SYLLABLE IS -->
+      <map code="0xc788" name="1em"/><!-- HANGUL SYLLABLE ISS -->
+      <map code="0xc789" name="1em"/><!-- HANGUL SYLLABLE ING -->
+      <map code="0xc78a" name="1em"/><!-- HANGUL SYLLABLE IJ -->
+      <map code="0xc78b" name="1em"/><!-- HANGUL SYLLABLE IC -->
+      <map code="0xc78c" name="1em"/><!-- HANGUL SYLLABLE IK -->
+      <map code="0xc78d" name="1em"/><!-- HANGUL SYLLABLE IT -->
+      <map code="0xc78e" name="1em"/><!-- HANGUL SYLLABLE IP -->
+      <map code="0xc78f" name="1em"/><!-- HANGUL SYLLABLE IH -->
+      <map code="0xc790" name="1em"/><!-- HANGUL SYLLABLE JA -->
+      <map code="0xc791" name="1em"/><!-- HANGUL SYLLABLE JAG -->
+      <map code="0xc792" name="1em"/><!-- HANGUL SYLLABLE JAGG -->
+      <map code="0xc793" name="1em"/><!-- HANGUL SYLLABLE JAGS -->
+      <map code="0xc794" name="1em"/><!-- HANGUL SYLLABLE JAN -->
+      <map code="0xc795" name="1em"/><!-- HANGUL SYLLABLE JANJ -->
+      <map code="0xc796" name="1em"/><!-- HANGUL SYLLABLE JANH -->
+      <map code="0xc797" name="1em"/><!-- HANGUL SYLLABLE JAD -->
+      <map code="0xc798" name="1em"/><!-- HANGUL SYLLABLE JAL -->
+      <map code="0xc799" name="1em"/><!-- HANGUL SYLLABLE JALG -->
+      <map code="0xc79a" name="1em"/><!-- HANGUL SYLLABLE JALM -->
+      <map code="0xc79b" name="1em"/><!-- HANGUL SYLLABLE JALB -->
+      <map code="0xc79c" name="1em"/><!-- HANGUL SYLLABLE JALS -->
+      <map code="0xc79d" name="1em"/><!-- HANGUL SYLLABLE JALT -->
+      <map code="0xc79e" name="1em"/><!-- HANGUL SYLLABLE JALP -->
+      <map code="0xc79f" name="1em"/><!-- HANGUL SYLLABLE JALH -->
+      <map code="0xc7a0" name="1em"/><!-- HANGUL SYLLABLE JAM -->
+      <map code="0xc7a1" name="1em"/><!-- HANGUL SYLLABLE JAB -->
+      <map code="0xc7a2" name="1em"/><!-- HANGUL SYLLABLE JABS -->
+      <map code="0xc7a3" name="1em"/><!-- HANGUL SYLLABLE JAS -->
+      <map code="0xc7a4" name="1em"/><!-- HANGUL SYLLABLE JASS -->
+      <map code="0xc7a5" name="1em"/><!-- HANGUL SYLLABLE JANG -->
+      <map code="0xc7a6" name="1em"/><!-- HANGUL SYLLABLE JAJ -->
+      <map code="0xc7a7" name="1em"/><!-- HANGUL SYLLABLE JAC -->
+      <map code="0xc7a8" name="1em"/><!-- HANGUL SYLLABLE JAK -->
+      <map code="0xc7a9" name="1em"/><!-- HANGUL SYLLABLE JAT -->
+      <map code="0xc7aa" name="1em"/><!-- HANGUL SYLLABLE JAP -->
+      <map code="0xc7ab" name="1em"/><!-- HANGUL SYLLABLE JAH -->
+      <map code="0xc7ac" name="1em"/><!-- HANGUL SYLLABLE JAE -->
+      <map code="0xc7ad" name="1em"/><!-- HANGUL SYLLABLE JAEG -->
+      <map code="0xc7ae" name="1em"/><!-- HANGUL SYLLABLE JAEGG -->
+      <map code="0xc7af" name="1em"/><!-- HANGUL SYLLABLE JAEGS -->
+      <map code="0xc7b0" name="1em"/><!-- HANGUL SYLLABLE JAEN -->
+      <map code="0xc7b1" name="1em"/><!-- HANGUL SYLLABLE JAENJ -->
+      <map code="0xc7b2" name="1em"/><!-- HANGUL SYLLABLE JAENH -->
+      <map code="0xc7b3" name="1em"/><!-- HANGUL SYLLABLE JAED -->
+      <map code="0xc7b4" name="1em"/><!-- HANGUL SYLLABLE JAEL -->
+      <map code="0xc7b5" name="1em"/><!-- HANGUL SYLLABLE JAELG -->
+      <map code="0xc7b6" name="1em"/><!-- HANGUL SYLLABLE JAELM -->
+      <map code="0xc7b7" name="1em"/><!-- HANGUL SYLLABLE JAELB -->
+      <map code="0xc7b8" name="1em"/><!-- HANGUL SYLLABLE JAELS -->
+      <map code="0xc7b9" name="1em"/><!-- HANGUL SYLLABLE JAELT -->
+      <map code="0xc7ba" name="1em"/><!-- HANGUL SYLLABLE JAELP -->
+      <map code="0xc7bb" name="1em"/><!-- HANGUL SYLLABLE JAELH -->
+      <map code="0xc7bc" name="1em"/><!-- HANGUL SYLLABLE JAEM -->
+      <map code="0xc7bd" name="1em"/><!-- HANGUL SYLLABLE JAEB -->
+      <map code="0xc7be" name="1em"/><!-- HANGUL SYLLABLE JAEBS -->
+      <map code="0xc7bf" name="1em"/><!-- HANGUL SYLLABLE JAES -->
+      <map code="0xc7c0" name="1em"/><!-- HANGUL SYLLABLE JAESS -->
+      <map code="0xc7c1" name="1em"/><!-- HANGUL SYLLABLE JAENG -->
+      <map code="0xc7c2" name="1em"/><!-- HANGUL SYLLABLE JAEJ -->
+      <map code="0xc7c3" name="1em"/><!-- HANGUL SYLLABLE JAEC -->
+      <map code="0xc7c4" name="1em"/><!-- HANGUL SYLLABLE JAEK -->
+      <map code="0xc7c5" name="1em"/><!-- HANGUL SYLLABLE JAET -->
+      <map code="0xc7c6" name="1em"/><!-- HANGUL SYLLABLE JAEP -->
+      <map code="0xc7c7" name="1em"/><!-- HANGUL SYLLABLE JAEH -->
+      <map code="0xc7c8" name="1em"/><!-- HANGUL SYLLABLE JYA -->
+      <map code="0xc7c9" name="1em"/><!-- HANGUL SYLLABLE JYAG -->
+      <map code="0xc7ca" name="1em"/><!-- HANGUL SYLLABLE JYAGG -->
+      <map code="0xc7cb" name="1em"/><!-- HANGUL SYLLABLE JYAGS -->
+      <map code="0xc7cc" name="1em"/><!-- HANGUL SYLLABLE JYAN -->
+      <map code="0xc7cd" name="1em"/><!-- HANGUL SYLLABLE JYANJ -->
+      <map code="0xc7ce" name="1em"/><!-- HANGUL SYLLABLE JYANH -->
+      <map code="0xc7cf" name="1em"/><!-- HANGUL SYLLABLE JYAD -->
+      <map code="0xc7d0" name="1em"/><!-- HANGUL SYLLABLE JYAL -->
+      <map code="0xc7d1" name="1em"/><!-- HANGUL SYLLABLE JYALG -->
+      <map code="0xc7d2" name="1em"/><!-- HANGUL SYLLABLE JYALM -->
+      <map code="0xc7d3" name="1em"/><!-- HANGUL SYLLABLE JYALB -->
+      <map code="0xc7d4" name="1em"/><!-- HANGUL SYLLABLE JYALS -->
+      <map code="0xc7d5" name="1em"/><!-- HANGUL SYLLABLE JYALT -->
+      <map code="0xc7d6" name="1em"/><!-- HANGUL SYLLABLE JYALP -->
+      <map code="0xc7d7" name="1em"/><!-- HANGUL SYLLABLE JYALH -->
+      <map code="0xc7d8" name="1em"/><!-- HANGUL SYLLABLE JYAM -->
+      <map code="0xc7d9" name="1em"/><!-- HANGUL SYLLABLE JYAB -->
+      <map code="0xc7da" name="1em"/><!-- HANGUL SYLLABLE JYABS -->
+      <map code="0xc7db" name="1em"/><!-- HANGUL SYLLABLE JYAS -->
+      <map code="0xc7dc" name="1em"/><!-- HANGUL SYLLABLE JYASS -->
+      <map code="0xc7dd" name="1em"/><!-- HANGUL SYLLABLE JYANG -->
+      <map code="0xc7de" name="1em"/><!-- HANGUL SYLLABLE JYAJ -->
+      <map code="0xc7df" name="1em"/><!-- HANGUL SYLLABLE JYAC -->
+      <map code="0xc7e0" name="1em"/><!-- HANGUL SYLLABLE JYAK -->
+      <map code="0xc7e1" name="1em"/><!-- HANGUL SYLLABLE JYAT -->
+      <map code="0xc7e2" name="1em"/><!-- HANGUL SYLLABLE JYAP -->
+      <map code="0xc7e3" name="1em"/><!-- HANGUL SYLLABLE JYAH -->
+      <map code="0xc7e4" name="1em"/><!-- HANGUL SYLLABLE JYAE -->
+      <map code="0xc7e5" name="1em"/><!-- HANGUL SYLLABLE JYAEG -->
+      <map code="0xc7e6" name="1em"/><!-- HANGUL SYLLABLE JYAEGG -->
+      <map code="0xc7e7" name="1em"/><!-- HANGUL SYLLABLE JYAEGS -->
+      <map code="0xc7e8" name="1em"/><!-- HANGUL SYLLABLE JYAEN -->
+      <map code="0xc7e9" name="1em"/><!-- HANGUL SYLLABLE JYAENJ -->
+      <map code="0xc7ea" name="1em"/><!-- HANGUL SYLLABLE JYAENH -->
+      <map code="0xc7eb" name="1em"/><!-- HANGUL SYLLABLE JYAED -->
+      <map code="0xc7ec" name="1em"/><!-- HANGUL SYLLABLE JYAEL -->
+      <map code="0xc7ed" name="1em"/><!-- HANGUL SYLLABLE JYAELG -->
+      <map code="0xc7ee" name="1em"/><!-- HANGUL SYLLABLE JYAELM -->
+      <map code="0xc7ef" name="1em"/><!-- HANGUL SYLLABLE JYAELB -->
+      <map code="0xc7f0" name="1em"/><!-- HANGUL SYLLABLE JYAELS -->
+      <map code="0xc7f1" name="1em"/><!-- HANGUL SYLLABLE JYAELT -->
+      <map code="0xc7f2" name="1em"/><!-- HANGUL SYLLABLE JYAELP -->
+      <map code="0xc7f3" name="1em"/><!-- HANGUL SYLLABLE JYAELH -->
+      <map code="0xc7f4" name="1em"/><!-- HANGUL SYLLABLE JYAEM -->
+      <map code="0xc7f5" name="1em"/><!-- HANGUL SYLLABLE JYAEB -->
+      <map code="0xc7f6" name="1em"/><!-- HANGUL SYLLABLE JYAEBS -->
+      <map code="0xc7f7" name="1em"/><!-- HANGUL SYLLABLE JYAES -->
+      <map code="0xc7f8" name="1em"/><!-- HANGUL SYLLABLE JYAESS -->
+      <map code="0xc7f9" name="1em"/><!-- HANGUL SYLLABLE JYAENG -->
+      <map code="0xc7fa" name="1em"/><!-- HANGUL SYLLABLE JYAEJ -->
+      <map code="0xc7fb" name="1em"/><!-- HANGUL SYLLABLE JYAEC -->
+      <map code="0xc7fc" name="1em"/><!-- HANGUL SYLLABLE JYAEK -->
+      <map code="0xc7fd" name="1em"/><!-- HANGUL SYLLABLE JYAET -->
+      <map code="0xc7fe" name="1em"/><!-- HANGUL SYLLABLE JYAEP -->
+      <map code="0xc7ff" name="1em"/><!-- HANGUL SYLLABLE JYAEH -->
+      <map code="0xc800" name="1em"/><!-- HANGUL SYLLABLE JEO -->
+      <map code="0xc801" name="1em"/><!-- HANGUL SYLLABLE JEOG -->
+      <map code="0xc802" name="1em"/><!-- HANGUL SYLLABLE JEOGG -->
+      <map code="0xc803" name="1em"/><!-- HANGUL SYLLABLE JEOGS -->
+      <map code="0xc804" name="1em"/><!-- HANGUL SYLLABLE JEON -->
+      <map code="0xc805" name="1em"/><!-- HANGUL SYLLABLE JEONJ -->
+      <map code="0xc806" name="1em"/><!-- HANGUL SYLLABLE JEONH -->
+      <map code="0xc807" name="1em"/><!-- HANGUL SYLLABLE JEOD -->
+      <map code="0xc808" name="1em"/><!-- HANGUL SYLLABLE JEOL -->
+      <map code="0xc809" name="1em"/><!-- HANGUL SYLLABLE JEOLG -->
+      <map code="0xc80a" name="1em"/><!-- HANGUL SYLLABLE JEOLM -->
+      <map code="0xc80b" name="1em"/><!-- HANGUL SYLLABLE JEOLB -->
+      <map code="0xc80c" name="1em"/><!-- HANGUL SYLLABLE JEOLS -->
+      <map code="0xc80d" name="1em"/><!-- HANGUL SYLLABLE JEOLT -->
+      <map code="0xc80e" name="1em"/><!-- HANGUL SYLLABLE JEOLP -->
+      <map code="0xc80f" name="1em"/><!-- HANGUL SYLLABLE JEOLH -->
+      <map code="0xc810" name="1em"/><!-- HANGUL SYLLABLE JEOM -->
+      <map code="0xc811" name="1em"/><!-- HANGUL SYLLABLE JEOB -->
+      <map code="0xc812" name="1em"/><!-- HANGUL SYLLABLE JEOBS -->
+      <map code="0xc813" name="1em"/><!-- HANGUL SYLLABLE JEOS -->
+      <map code="0xc814" name="1em"/><!-- HANGUL SYLLABLE JEOSS -->
+      <map code="0xc815" name="1em"/><!-- HANGUL SYLLABLE JEONG -->
+      <map code="0xc816" name="1em"/><!-- HANGUL SYLLABLE JEOJ -->
+      <map code="0xc817" name="1em"/><!-- HANGUL SYLLABLE JEOC -->
+      <map code="0xc818" name="1em"/><!-- HANGUL SYLLABLE JEOK -->
+      <map code="0xc819" name="1em"/><!-- HANGUL SYLLABLE JEOT -->
+      <map code="0xc81a" name="1em"/><!-- HANGUL SYLLABLE JEOP -->
+      <map code="0xc81b" name="1em"/><!-- HANGUL SYLLABLE JEOH -->
+      <map code="0xc81c" name="1em"/><!-- HANGUL SYLLABLE JE -->
+      <map code="0xc81d" name="1em"/><!-- HANGUL SYLLABLE JEG -->
+      <map code="0xc81e" name="1em"/><!-- HANGUL SYLLABLE JEGG -->
+      <map code="0xc81f" name="1em"/><!-- HANGUL SYLLABLE JEGS -->
+      <map code="0xc820" name="1em"/><!-- HANGUL SYLLABLE JEN -->
+      <map code="0xc821" name="1em"/><!-- HANGUL SYLLABLE JENJ -->
+      <map code="0xc822" name="1em"/><!-- HANGUL SYLLABLE JENH -->
+      <map code="0xc823" name="1em"/><!-- HANGUL SYLLABLE JED -->
+      <map code="0xc824" name="1em"/><!-- HANGUL SYLLABLE JEL -->
+      <map code="0xc825" name="1em"/><!-- HANGUL SYLLABLE JELG -->
+      <map code="0xc826" name="1em"/><!-- HANGUL SYLLABLE JELM -->
+      <map code="0xc827" name="1em"/><!-- HANGUL SYLLABLE JELB -->
+      <map code="0xc828" name="1em"/><!-- HANGUL SYLLABLE JELS -->
+      <map code="0xc829" name="1em"/><!-- HANGUL SYLLABLE JELT -->
+      <map code="0xc82a" name="1em"/><!-- HANGUL SYLLABLE JELP -->
+      <map code="0xc82b" name="1em"/><!-- HANGUL SYLLABLE JELH -->
+      <map code="0xc82c" name="1em"/><!-- HANGUL SYLLABLE JEM -->
+      <map code="0xc82d" name="1em"/><!-- HANGUL SYLLABLE JEB -->
+      <map code="0xc82e" name="1em"/><!-- HANGUL SYLLABLE JEBS -->
+      <map code="0xc82f" name="1em"/><!-- HANGUL SYLLABLE JES -->
+      <map code="0xc830" name="1em"/><!-- HANGUL SYLLABLE JESS -->
+      <map code="0xc831" name="1em"/><!-- HANGUL SYLLABLE JENG -->
+      <map code="0xc832" name="1em"/><!-- HANGUL SYLLABLE JEJ -->
+      <map code="0xc833" name="1em"/><!-- HANGUL SYLLABLE JEC -->
+      <map code="0xc834" name="1em"/><!-- HANGUL SYLLABLE JEK -->
+      <map code="0xc835" name="1em"/><!-- HANGUL SYLLABLE JET -->
+      <map code="0xc836" name="1em"/><!-- HANGUL SYLLABLE JEP -->
+      <map code="0xc837" name="1em"/><!-- HANGUL SYLLABLE JEH -->
+      <map code="0xc838" name="1em"/><!-- HANGUL SYLLABLE JYEO -->
+      <map code="0xc839" name="1em"/><!-- HANGUL SYLLABLE JYEOG -->
+      <map code="0xc83a" name="1em"/><!-- HANGUL SYLLABLE JYEOGG -->
+      <map code="0xc83b" name="1em"/><!-- HANGUL SYLLABLE JYEOGS -->
+      <map code="0xc83c" name="1em"/><!-- HANGUL SYLLABLE JYEON -->
+      <map code="0xc83d" name="1em"/><!-- HANGUL SYLLABLE JYEONJ -->
+      <map code="0xc83e" name="1em"/><!-- HANGUL SYLLABLE JYEONH -->
+      <map code="0xc83f" name="1em"/><!-- HANGUL SYLLABLE JYEOD -->
+      <map code="0xc840" name="1em"/><!-- HANGUL SYLLABLE JYEOL -->
+      <map code="0xc841" name="1em"/><!-- HANGUL SYLLABLE JYEOLG -->
+      <map code="0xc842" name="1em"/><!-- HANGUL SYLLABLE JYEOLM -->
+      <map code="0xc843" name="1em"/><!-- HANGUL SYLLABLE JYEOLB -->
+      <map code="0xc844" name="1em"/><!-- HANGUL SYLLABLE JYEOLS -->
+      <map code="0xc845" name="1em"/><!-- HANGUL SYLLABLE JYEOLT -->
+      <map code="0xc846" name="1em"/><!-- HANGUL SYLLABLE JYEOLP -->
+      <map code="0xc847" name="1em"/><!-- HANGUL SYLLABLE JYEOLH -->
+      <map code="0xc848" name="1em"/><!-- HANGUL SYLLABLE JYEOM -->
+      <map code="0xc849" name="1em"/><!-- HANGUL SYLLABLE JYEOB -->
+      <map code="0xc84a" name="1em"/><!-- HANGUL SYLLABLE JYEOBS -->
+      <map code="0xc84b" name="1em"/><!-- HANGUL SYLLABLE JYEOS -->
+      <map code="0xc84c" name="1em"/><!-- HANGUL SYLLABLE JYEOSS -->
+      <map code="0xc84d" name="1em"/><!-- HANGUL SYLLABLE JYEONG -->
+      <map code="0xc84e" name="1em"/><!-- HANGUL SYLLABLE JYEOJ -->
+      <map code="0xc84f" name="1em"/><!-- HANGUL SYLLABLE JYEOC -->
+      <map code="0xc850" name="1em"/><!-- HANGUL SYLLABLE JYEOK -->
+      <map code="0xc851" name="1em"/><!-- HANGUL SYLLABLE JYEOT -->
+      <map code="0xc852" name="1em"/><!-- HANGUL SYLLABLE JYEOP -->
+      <map code="0xc853" name="1em"/><!-- HANGUL SYLLABLE JYEOH -->
+      <map code="0xc854" name="1em"/><!-- HANGUL SYLLABLE JYE -->
+      <map code="0xc855" name="1em"/><!-- HANGUL SYLLABLE JYEG -->
+      <map code="0xc856" name="1em"/><!-- HANGUL SYLLABLE JYEGG -->
+      <map code="0xc857" name="1em"/><!-- HANGUL SYLLABLE JYEGS -->
+      <map code="0xc858" name="1em"/><!-- HANGUL SYLLABLE JYEN -->
+      <map code="0xc859" name="1em"/><!-- HANGUL SYLLABLE JYENJ -->
+      <map code="0xc85a" name="1em"/><!-- HANGUL SYLLABLE JYENH -->
+      <map code="0xc85b" name="1em"/><!-- HANGUL SYLLABLE JYED -->
+      <map code="0xc85c" name="1em"/><!-- HANGUL SYLLABLE JYEL -->
+      <map code="0xc85d" name="1em"/><!-- HANGUL SYLLABLE JYELG -->
+      <map code="0xc85e" name="1em"/><!-- HANGUL SYLLABLE JYELM -->
+      <map code="0xc85f" name="1em"/><!-- HANGUL SYLLABLE JYELB -->
+      <map code="0xc860" name="1em"/><!-- HANGUL SYLLABLE JYELS -->
+      <map code="0xc861" name="1em"/><!-- HANGUL SYLLABLE JYELT -->
+      <map code="0xc862" name="1em"/><!-- HANGUL SYLLABLE JYELP -->
+      <map code="0xc863" name="1em"/><!-- HANGUL SYLLABLE JYELH -->
+      <map code="0xc864" name="1em"/><!-- HANGUL SYLLABLE JYEM -->
+      <map code="0xc865" name="1em"/><!-- HANGUL SYLLABLE JYEB -->
+      <map code="0xc866" name="1em"/><!-- HANGUL SYLLABLE JYEBS -->
+      <map code="0xc867" name="1em"/><!-- HANGUL SYLLABLE JYES -->
+      <map code="0xc868" name="1em"/><!-- HANGUL SYLLABLE JYESS -->
+      <map code="0xc869" name="1em"/><!-- HANGUL SYLLABLE JYENG -->
+      <map code="0xc86a" name="1em"/><!-- HANGUL SYLLABLE JYEJ -->
+      <map code="0xc86b" name="1em"/><!-- HANGUL SYLLABLE JYEC -->
+      <map code="0xc86c" name="1em"/><!-- HANGUL SYLLABLE JYEK -->
+      <map code="0xc86d" name="1em"/><!-- HANGUL SYLLABLE JYET -->
+      <map code="0xc86e" name="1em"/><!-- HANGUL SYLLABLE JYEP -->
+      <map code="0xc86f" name="1em"/><!-- HANGUL SYLLABLE JYEH -->
+      <map code="0xc870" name="1em"/><!-- HANGUL SYLLABLE JO -->
+      <map code="0xc871" name="1em"/><!-- HANGUL SYLLABLE JOG -->
+      <map code="0xc872" name="1em"/><!-- HANGUL SYLLABLE JOGG -->
+      <map code="0xc873" name="1em"/><!-- HANGUL SYLLABLE JOGS -->
+      <map code="0xc874" name="1em"/><!-- HANGUL SYLLABLE JON -->
+      <map code="0xc875" name="1em"/><!-- HANGUL SYLLABLE JONJ -->
+      <map code="0xc876" name="1em"/><!-- HANGUL SYLLABLE JONH -->
+      <map code="0xc877" name="1em"/><!-- HANGUL SYLLABLE JOD -->
+      <map code="0xc878" name="1em"/><!-- HANGUL SYLLABLE JOL -->
+      <map code="0xc879" name="1em"/><!-- HANGUL SYLLABLE JOLG -->
+      <map code="0xc87a" name="1em"/><!-- HANGUL SYLLABLE JOLM -->
+      <map code="0xc87b" name="1em"/><!-- HANGUL SYLLABLE JOLB -->
+      <map code="0xc87c" name="1em"/><!-- HANGUL SYLLABLE JOLS -->
+      <map code="0xc87d" name="1em"/><!-- HANGUL SYLLABLE JOLT -->
+      <map code="0xc87e" name="1em"/><!-- HANGUL SYLLABLE JOLP -->
+      <map code="0xc87f" name="1em"/><!-- HANGUL SYLLABLE JOLH -->
+      <map code="0xc880" name="1em"/><!-- HANGUL SYLLABLE JOM -->
+      <map code="0xc881" name="1em"/><!-- HANGUL SYLLABLE JOB -->
+      <map code="0xc882" name="1em"/><!-- HANGUL SYLLABLE JOBS -->
+      <map code="0xc883" name="1em"/><!-- HANGUL SYLLABLE JOS -->
+      <map code="0xc884" name="1em"/><!-- HANGUL SYLLABLE JOSS -->
+      <map code="0xc885" name="1em"/><!-- HANGUL SYLLABLE JONG -->
+      <map code="0xc886" name="1em"/><!-- HANGUL SYLLABLE JOJ -->
+      <map code="0xc887" name="1em"/><!-- HANGUL SYLLABLE JOC -->
+      <map code="0xc888" name="1em"/><!-- HANGUL SYLLABLE JOK -->
+      <map code="0xc889" name="1em"/><!-- HANGUL SYLLABLE JOT -->
+      <map code="0xc88a" name="1em"/><!-- HANGUL SYLLABLE JOP -->
+      <map code="0xc88b" name="1em"/><!-- HANGUL SYLLABLE JOH -->
+      <map code="0xc88c" name="1em"/><!-- HANGUL SYLLABLE JWA -->
+      <map code="0xc88d" name="1em"/><!-- HANGUL SYLLABLE JWAG -->
+      <map code="0xc88e" name="1em"/><!-- HANGUL SYLLABLE JWAGG -->
+      <map code="0xc88f" name="1em"/><!-- HANGUL SYLLABLE JWAGS -->
+      <map code="0xc890" name="1em"/><!-- HANGUL SYLLABLE JWAN -->
+      <map code="0xc891" name="1em"/><!-- HANGUL SYLLABLE JWANJ -->
+      <map code="0xc892" name="1em"/><!-- HANGUL SYLLABLE JWANH -->
+      <map code="0xc893" name="1em"/><!-- HANGUL SYLLABLE JWAD -->
+      <map code="0xc894" name="1em"/><!-- HANGUL SYLLABLE JWAL -->
+      <map code="0xc895" name="1em"/><!-- HANGUL SYLLABLE JWALG -->
+      <map code="0xc896" name="1em"/><!-- HANGUL SYLLABLE JWALM -->
+      <map code="0xc897" name="1em"/><!-- HANGUL SYLLABLE JWALB -->
+      <map code="0xc898" name="1em"/><!-- HANGUL SYLLABLE JWALS -->
+      <map code="0xc899" name="1em"/><!-- HANGUL SYLLABLE JWALT -->
+      <map code="0xc89a" name="1em"/><!-- HANGUL SYLLABLE JWALP -->
+      <map code="0xc89b" name="1em"/><!-- HANGUL SYLLABLE JWALH -->
+      <map code="0xc89c" name="1em"/><!-- HANGUL SYLLABLE JWAM -->
+      <map code="0xc89d" name="1em"/><!-- HANGUL SYLLABLE JWAB -->
+      <map code="0xc89e" name="1em"/><!-- HANGUL SYLLABLE JWABS -->
+      <map code="0xc89f" name="1em"/><!-- HANGUL SYLLABLE JWAS -->
+      <map code="0xc8a0" name="1em"/><!-- HANGUL SYLLABLE JWASS -->
+      <map code="0xc8a1" name="1em"/><!-- HANGUL SYLLABLE JWANG -->
+      <map code="0xc8a2" name="1em"/><!-- HANGUL SYLLABLE JWAJ -->
+      <map code="0xc8a3" name="1em"/><!-- HANGUL SYLLABLE JWAC -->
+      <map code="0xc8a4" name="1em"/><!-- HANGUL SYLLABLE JWAK -->
+      <map code="0xc8a5" name="1em"/><!-- HANGUL SYLLABLE JWAT -->
+      <map code="0xc8a6" name="1em"/><!-- HANGUL SYLLABLE JWAP -->
+      <map code="0xc8a7" name="1em"/><!-- HANGUL SYLLABLE JWAH -->
+      <map code="0xc8a8" name="1em"/><!-- HANGUL SYLLABLE JWAE -->
+      <map code="0xc8a9" name="1em"/><!-- HANGUL SYLLABLE JWAEG -->
+      <map code="0xc8aa" name="1em"/><!-- HANGUL SYLLABLE JWAEGG -->
+      <map code="0xc8ab" name="1em"/><!-- HANGUL SYLLABLE JWAEGS -->
+      <map code="0xc8ac" name="1em"/><!-- HANGUL SYLLABLE JWAEN -->
+      <map code="0xc8ad" name="1em"/><!-- HANGUL SYLLABLE JWAENJ -->
+      <map code="0xc8ae" name="1em"/><!-- HANGUL SYLLABLE JWAENH -->
+      <map code="0xc8af" name="1em"/><!-- HANGUL SYLLABLE JWAED -->
+      <map code="0xc8b0" name="1em"/><!-- HANGUL SYLLABLE JWAEL -->
+      <map code="0xc8b1" name="1em"/><!-- HANGUL SYLLABLE JWAELG -->
+      <map code="0xc8b2" name="1em"/><!-- HANGUL SYLLABLE JWAELM -->
+      <map code="0xc8b3" name="1em"/><!-- HANGUL SYLLABLE JWAELB -->
+      <map code="0xc8b4" name="1em"/><!-- HANGUL SYLLABLE JWAELS -->
+      <map code="0xc8b5" name="1em"/><!-- HANGUL SYLLABLE JWAELT -->
+      <map code="0xc8b6" name="1em"/><!-- HANGUL SYLLABLE JWAELP -->
+      <map code="0xc8b7" name="1em"/><!-- HANGUL SYLLABLE JWAELH -->
+      <map code="0xc8b8" name="1em"/><!-- HANGUL SYLLABLE JWAEM -->
+      <map code="0xc8b9" name="1em"/><!-- HANGUL SYLLABLE JWAEB -->
+      <map code="0xc8ba" name="1em"/><!-- HANGUL SYLLABLE JWAEBS -->
+      <map code="0xc8bb" name="1em"/><!-- HANGUL SYLLABLE JWAES -->
+      <map code="0xc8bc" name="1em"/><!-- HANGUL SYLLABLE JWAESS -->
+      <map code="0xc8bd" name="1em"/><!-- HANGUL SYLLABLE JWAENG -->
+      <map code="0xc8be" name="1em"/><!-- HANGUL SYLLABLE JWAEJ -->
+      <map code="0xc8bf" name="1em"/><!-- HANGUL SYLLABLE JWAEC -->
+      <map code="0xc8c0" name="1em"/><!-- HANGUL SYLLABLE JWAEK -->
+      <map code="0xc8c1" name="1em"/><!-- HANGUL SYLLABLE JWAET -->
+      <map code="0xc8c2" name="1em"/><!-- HANGUL SYLLABLE JWAEP -->
+      <map code="0xc8c3" name="1em"/><!-- HANGUL SYLLABLE JWAEH -->
+      <map code="0xc8c4" name="1em"/><!-- HANGUL SYLLABLE JOE -->
+      <map code="0xc8c5" name="1em"/><!-- HANGUL SYLLABLE JOEG -->
+      <map code="0xc8c6" name="1em"/><!-- HANGUL SYLLABLE JOEGG -->
+      <map code="0xc8c7" name="1em"/><!-- HANGUL SYLLABLE JOEGS -->
+      <map code="0xc8c8" name="1em"/><!-- HANGUL SYLLABLE JOEN -->
+      <map code="0xc8c9" name="1em"/><!-- HANGUL SYLLABLE JOENJ -->
+      <map code="0xc8ca" name="1em"/><!-- HANGUL SYLLABLE JOENH -->
+      <map code="0xc8cb" name="1em"/><!-- HANGUL SYLLABLE JOED -->
+      <map code="0xc8cc" name="1em"/><!-- HANGUL SYLLABLE JOEL -->
+      <map code="0xc8cd" name="1em"/><!-- HANGUL SYLLABLE JOELG -->
+      <map code="0xc8ce" name="1em"/><!-- HANGUL SYLLABLE JOELM -->
+      <map code="0xc8cf" name="1em"/><!-- HANGUL SYLLABLE JOELB -->
+      <map code="0xc8d0" name="1em"/><!-- HANGUL SYLLABLE JOELS -->
+      <map code="0xc8d1" name="1em"/><!-- HANGUL SYLLABLE JOELT -->
+      <map code="0xc8d2" name="1em"/><!-- HANGUL SYLLABLE JOELP -->
+      <map code="0xc8d3" name="1em"/><!-- HANGUL SYLLABLE JOELH -->
+      <map code="0xc8d4" name="1em"/><!-- HANGUL SYLLABLE JOEM -->
+      <map code="0xc8d5" name="1em"/><!-- HANGUL SYLLABLE JOEB -->
+      <map code="0xc8d6" name="1em"/><!-- HANGUL SYLLABLE JOEBS -->
+      <map code="0xc8d7" name="1em"/><!-- HANGUL SYLLABLE JOES -->
+      <map code="0xc8d8" name="1em"/><!-- HANGUL SYLLABLE JOESS -->
+      <map code="0xc8d9" name="1em"/><!-- HANGUL SYLLABLE JOENG -->
+      <map code="0xc8da" name="1em"/><!-- HANGUL SYLLABLE JOEJ -->
+      <map code="0xc8db" name="1em"/><!-- HANGUL SYLLABLE JOEC -->
+      <map code="0xc8dc" name="1em"/><!-- HANGUL SYLLABLE JOEK -->
+      <map code="0xc8dd" name="1em"/><!-- HANGUL SYLLABLE JOET -->
+      <map code="0xc8de" name="1em"/><!-- HANGUL SYLLABLE JOEP -->
+      <map code="0xc8df" name="1em"/><!-- HANGUL SYLLABLE JOEH -->
+      <map code="0xc8e0" name="1em"/><!-- HANGUL SYLLABLE JYO -->
+      <map code="0xc8e1" name="1em"/><!-- HANGUL SYLLABLE JYOG -->
+      <map code="0xc8e2" name="1em"/><!-- HANGUL SYLLABLE JYOGG -->
+      <map code="0xc8e3" name="1em"/><!-- HANGUL SYLLABLE JYOGS -->
+      <map code="0xc8e4" name="1em"/><!-- HANGUL SYLLABLE JYON -->
+      <map code="0xc8e5" name="1em"/><!-- HANGUL SYLLABLE JYONJ -->
+      <map code="0xc8e6" name="1em"/><!-- HANGUL SYLLABLE JYONH -->
+      <map code="0xc8e7" name="1em"/><!-- HANGUL SYLLABLE JYOD -->
+      <map code="0xc8e8" name="1em"/><!-- HANGUL SYLLABLE JYOL -->
+      <map code="0xc8e9" name="1em"/><!-- HANGUL SYLLABLE JYOLG -->
+      <map code="0xc8ea" name="1em"/><!-- HANGUL SYLLABLE JYOLM -->
+      <map code="0xc8eb" name="1em"/><!-- HANGUL SYLLABLE JYOLB -->
+      <map code="0xc8ec" name="1em"/><!-- HANGUL SYLLABLE JYOLS -->
+      <map code="0xc8ed" name="1em"/><!-- HANGUL SYLLABLE JYOLT -->
+      <map code="0xc8ee" name="1em"/><!-- HANGUL SYLLABLE JYOLP -->
+      <map code="0xc8ef" name="1em"/><!-- HANGUL SYLLABLE JYOLH -->
+      <map code="0xc8f0" name="1em"/><!-- HANGUL SYLLABLE JYOM -->
+      <map code="0xc8f1" name="1em"/><!-- HANGUL SYLLABLE JYOB -->
+      <map code="0xc8f2" name="1em"/><!-- HANGUL SYLLABLE JYOBS -->
+      <map code="0xc8f3" name="1em"/><!-- HANGUL SYLLABLE JYOS -->
+      <map code="0xc8f4" name="1em"/><!-- HANGUL SYLLABLE JYOSS -->
+      <map code="0xc8f5" name="1em"/><!-- HANGUL SYLLABLE JYONG -->
+      <map code="0xc8f6" name="1em"/><!-- HANGUL SYLLABLE JYOJ -->
+      <map code="0xc8f7" name="1em"/><!-- HANGUL SYLLABLE JYOC -->
+      <map code="0xc8f8" name="1em"/><!-- HANGUL SYLLABLE JYOK -->
+      <map code="0xc8f9" name="1em"/><!-- HANGUL SYLLABLE JYOT -->
+      <map code="0xc8fa" name="1em"/><!-- HANGUL SYLLABLE JYOP -->
+      <map code="0xc8fb" name="1em"/><!-- HANGUL SYLLABLE JYOH -->
+      <map code="0xc8fc" name="1em"/><!-- HANGUL SYLLABLE JU -->
+      <map code="0xc8fd" name="1em"/><!-- HANGUL SYLLABLE JUG -->
+      <map code="0xc8fe" name="1em"/><!-- HANGUL SYLLABLE JUGG -->
+      <map code="0xc8ff" name="1em"/><!-- HANGUL SYLLABLE JUGS -->
+      <map code="0xc900" name="1em"/><!-- HANGUL SYLLABLE JUN -->
+      <map code="0xc901" name="1em"/><!-- HANGUL SYLLABLE JUNJ -->
+      <map code="0xc902" name="1em"/><!-- HANGUL SYLLABLE JUNH -->
+      <map code="0xc903" name="1em"/><!-- HANGUL SYLLABLE JUD -->
+      <map code="0xc904" name="1em"/><!-- HANGUL SYLLABLE JUL -->
+      <map code="0xc905" name="1em"/><!-- HANGUL SYLLABLE JULG -->
+      <map code="0xc906" name="1em"/><!-- HANGUL SYLLABLE JULM -->
+      <map code="0xc907" name="1em"/><!-- HANGUL SYLLABLE JULB -->
+      <map code="0xc908" name="1em"/><!-- HANGUL SYLLABLE JULS -->
+      <map code="0xc909" name="1em"/><!-- HANGUL SYLLABLE JULT -->
+      <map code="0xc90a" name="1em"/><!-- HANGUL SYLLABLE JULP -->
+      <map code="0xc90b" name="1em"/><!-- HANGUL SYLLABLE JULH -->
+      <map code="0xc90c" name="1em"/><!-- HANGUL SYLLABLE JUM -->
+      <map code="0xc90d" name="1em"/><!-- HANGUL SYLLABLE JUB -->
+      <map code="0xc90e" name="1em"/><!-- HANGUL SYLLABLE JUBS -->
+      <map code="0xc90f" name="1em"/><!-- HANGUL SYLLABLE JUS -->
+      <map code="0xc910" name="1em"/><!-- HANGUL SYLLABLE JUSS -->
+      <map code="0xc911" name="1em"/><!-- HANGUL SYLLABLE JUNG -->
+      <map code="0xc912" name="1em"/><!-- HANGUL SYLLABLE JUJ -->
+      <map code="0xc913" name="1em"/><!-- HANGUL SYLLABLE JUC -->
+      <map code="0xc914" name="1em"/><!-- HANGUL SYLLABLE JUK -->
+      <map code="0xc915" name="1em"/><!-- HANGUL SYLLABLE JUT -->
+      <map code="0xc916" name="1em"/><!-- HANGUL SYLLABLE JUP -->
+      <map code="0xc917" name="1em"/><!-- HANGUL SYLLABLE JUH -->
+      <map code="0xc918" name="1em"/><!-- HANGUL SYLLABLE JWEO -->
+      <map code="0xc919" name="1em"/><!-- HANGUL SYLLABLE JWEOG -->
+      <map code="0xc91a" name="1em"/><!-- HANGUL SYLLABLE JWEOGG -->
+      <map code="0xc91b" name="1em"/><!-- HANGUL SYLLABLE JWEOGS -->
+      <map code="0xc91c" name="1em"/><!-- HANGUL SYLLABLE JWEON -->
+      <map code="0xc91d" name="1em"/><!-- HANGUL SYLLABLE JWEONJ -->
+      <map code="0xc91e" name="1em"/><!-- HANGUL SYLLABLE JWEONH -->
+      <map code="0xc91f" name="1em"/><!-- HANGUL SYLLABLE JWEOD -->
+      <map code="0xc920" name="1em"/><!-- HANGUL SYLLABLE JWEOL -->
+      <map code="0xc921" name="1em"/><!-- HANGUL SYLLABLE JWEOLG -->
+      <map code="0xc922" name="1em"/><!-- HANGUL SYLLABLE JWEOLM -->
+      <map code="0xc923" name="1em"/><!-- HANGUL SYLLABLE JWEOLB -->
+      <map code="0xc924" name="1em"/><!-- HANGUL SYLLABLE JWEOLS -->
+      <map code="0xc925" name="1em"/><!-- HANGUL SYLLABLE JWEOLT -->
+      <map code="0xc926" name="1em"/><!-- HANGUL SYLLABLE JWEOLP -->
+      <map code="0xc927" name="1em"/><!-- HANGUL SYLLABLE JWEOLH -->
+      <map code="0xc928" name="1em"/><!-- HANGUL SYLLABLE JWEOM -->
+      <map code="0xc929" name="1em"/><!-- HANGUL SYLLABLE JWEOB -->
+      <map code="0xc92a" name="1em"/><!-- HANGUL SYLLABLE JWEOBS -->
+      <map code="0xc92b" name="1em"/><!-- HANGUL SYLLABLE JWEOS -->
+      <map code="0xc92c" name="1em"/><!-- HANGUL SYLLABLE JWEOSS -->
+      <map code="0xc92d" name="1em"/><!-- HANGUL SYLLABLE JWEONG -->
+      <map code="0xc92e" name="1em"/><!-- HANGUL SYLLABLE JWEOJ -->
+      <map code="0xc92f" name="1em"/><!-- HANGUL SYLLABLE JWEOC -->
+      <map code="0xc930" name="1em"/><!-- HANGUL SYLLABLE JWEOK -->
+      <map code="0xc931" name="1em"/><!-- HANGUL SYLLABLE JWEOT -->
+      <map code="0xc932" name="1em"/><!-- HANGUL SYLLABLE JWEOP -->
+      <map code="0xc933" name="1em"/><!-- HANGUL SYLLABLE JWEOH -->
+      <map code="0xc934" name="1em"/><!-- HANGUL SYLLABLE JWE -->
+      <map code="0xc935" name="1em"/><!-- HANGUL SYLLABLE JWEG -->
+      <map code="0xc936" name="1em"/><!-- HANGUL SYLLABLE JWEGG -->
+      <map code="0xc937" name="1em"/><!-- HANGUL SYLLABLE JWEGS -->
+      <map code="0xc938" name="1em"/><!-- HANGUL SYLLABLE JWEN -->
+      <map code="0xc939" name="1em"/><!-- HANGUL SYLLABLE JWENJ -->
+      <map code="0xc93a" name="1em"/><!-- HANGUL SYLLABLE JWENH -->
+      <map code="0xc93b" name="1em"/><!-- HANGUL SYLLABLE JWED -->
+      <map code="0xc93c" name="1em"/><!-- HANGUL SYLLABLE JWEL -->
+      <map code="0xc93d" name="1em"/><!-- HANGUL SYLLABLE JWELG -->
+      <map code="0xc93e" name="1em"/><!-- HANGUL SYLLABLE JWELM -->
+      <map code="0xc93f" name="1em"/><!-- HANGUL SYLLABLE JWELB -->
+      <map code="0xc940" name="1em"/><!-- HANGUL SYLLABLE JWELS -->
+      <map code="0xc941" name="1em"/><!-- HANGUL SYLLABLE JWELT -->
+      <map code="0xc942" name="1em"/><!-- HANGUL SYLLABLE JWELP -->
+      <map code="0xc943" name="1em"/><!-- HANGUL SYLLABLE JWELH -->
+      <map code="0xc944" name="1em"/><!-- HANGUL SYLLABLE JWEM -->
+      <map code="0xc945" name="1em"/><!-- HANGUL SYLLABLE JWEB -->
+      <map code="0xc946" name="1em"/><!-- HANGUL SYLLABLE JWEBS -->
+      <map code="0xc947" name="1em"/><!-- HANGUL SYLLABLE JWES -->
+      <map code="0xc948" name="1em"/><!-- HANGUL SYLLABLE JWESS -->
+      <map code="0xc949" name="1em"/><!-- HANGUL SYLLABLE JWENG -->
+      <map code="0xc94a" name="1em"/><!-- HANGUL SYLLABLE JWEJ -->
+      <map code="0xc94b" name="1em"/><!-- HANGUL SYLLABLE JWEC -->
+      <map code="0xc94c" name="1em"/><!-- HANGUL SYLLABLE JWEK -->
+      <map code="0xc94d" name="1em"/><!-- HANGUL SYLLABLE JWET -->
+      <map code="0xc94e" name="1em"/><!-- HANGUL SYLLABLE JWEP -->
+      <map code="0xc94f" name="1em"/><!-- HANGUL SYLLABLE JWEH -->
+      <map code="0xc950" name="1em"/><!-- HANGUL SYLLABLE JWI -->
+      <map code="0xc951" name="1em"/><!-- HANGUL SYLLABLE JWIG -->
+      <map code="0xc952" name="1em"/><!-- HANGUL SYLLABLE JWIGG -->
+      <map code="0xc953" name="1em"/><!-- HANGUL SYLLABLE JWIGS -->
+      <map code="0xc954" name="1em"/><!-- HANGUL SYLLABLE JWIN -->
+      <map code="0xc955" name="1em"/><!-- HANGUL SYLLABLE JWINJ -->
+      <map code="0xc956" name="1em"/><!-- HANGUL SYLLABLE JWINH -->
+      <map code="0xc957" name="1em"/><!-- HANGUL SYLLABLE JWID -->
+      <map code="0xc958" name="1em"/><!-- HANGUL SYLLABLE JWIL -->
+      <map code="0xc959" name="1em"/><!-- HANGUL SYLLABLE JWILG -->
+      <map code="0xc95a" name="1em"/><!-- HANGUL SYLLABLE JWILM -->
+      <map code="0xc95b" name="1em"/><!-- HANGUL SYLLABLE JWILB -->
+      <map code="0xc95c" name="1em"/><!-- HANGUL SYLLABLE JWILS -->
+      <map code="0xc95d" name="1em"/><!-- HANGUL SYLLABLE JWILT -->
+      <map code="0xc95e" name="1em"/><!-- HANGUL SYLLABLE JWILP -->
+      <map code="0xc95f" name="1em"/><!-- HANGUL SYLLABLE JWILH -->
+      <map code="0xc960" name="1em"/><!-- HANGUL SYLLABLE JWIM -->
+      <map code="0xc961" name="1em"/><!-- HANGUL SYLLABLE JWIB -->
+      <map code="0xc962" name="1em"/><!-- HANGUL SYLLABLE JWIBS -->
+      <map code="0xc963" name="1em"/><!-- HANGUL SYLLABLE JWIS -->
+      <map code="0xc964" name="1em"/><!-- HANGUL SYLLABLE JWISS -->
+      <map code="0xc965" name="1em"/><!-- HANGUL SYLLABLE JWING -->
+      <map code="0xc966" name="1em"/><!-- HANGUL SYLLABLE JWIJ -->
+      <map code="0xc967" name="1em"/><!-- HANGUL SYLLABLE JWIC -->
+      <map code="0xc968" name="1em"/><!-- HANGUL SYLLABLE JWIK -->
+      <map code="0xc969" name="1em"/><!-- HANGUL SYLLABLE JWIT -->
+      <map code="0xc96a" name="1em"/><!-- HANGUL SYLLABLE JWIP -->
+      <map code="0xc96b" name="1em"/><!-- HANGUL SYLLABLE JWIH -->
+      <map code="0xc96c" name="1em"/><!-- HANGUL SYLLABLE JYU -->
+      <map code="0xc96d" name="1em"/><!-- HANGUL SYLLABLE JYUG -->
+      <map code="0xc96e" name="1em"/><!-- HANGUL SYLLABLE JYUGG -->
+      <map code="0xc96f" name="1em"/><!-- HANGUL SYLLABLE JYUGS -->
+      <map code="0xc970" name="1em"/><!-- HANGUL SYLLABLE JYUN -->
+      <map code="0xc971" name="1em"/><!-- HANGUL SYLLABLE JYUNJ -->
+      <map code="0xc972" name="1em"/><!-- HANGUL SYLLABLE JYUNH -->
+      <map code="0xc973" name="1em"/><!-- HANGUL SYLLABLE JYUD -->
+      <map code="0xc974" name="1em"/><!-- HANGUL SYLLABLE JYUL -->
+      <map code="0xc975" name="1em"/><!-- HANGUL SYLLABLE JYULG -->
+      <map code="0xc976" name="1em"/><!-- HANGUL SYLLABLE JYULM -->
+      <map code="0xc977" name="1em"/><!-- HANGUL SYLLABLE JYULB -->
+      <map code="0xc978" name="1em"/><!-- HANGUL SYLLABLE JYULS -->
+      <map code="0xc979" name="1em"/><!-- HANGUL SYLLABLE JYULT -->
+      <map code="0xc97a" name="1em"/><!-- HANGUL SYLLABLE JYULP -->
+      <map code="0xc97b" name="1em"/><!-- HANGUL SYLLABLE JYULH -->
+      <map code="0xc97c" name="1em"/><!-- HANGUL SYLLABLE JYUM -->
+      <map code="0xc97d" name="1em"/><!-- HANGUL SYLLABLE JYUB -->
+      <map code="0xc97e" name="1em"/><!-- HANGUL SYLLABLE JYUBS -->
+      <map code="0xc97f" name="1em"/><!-- HANGUL SYLLABLE JYUS -->
+      <map code="0xc980" name="1em"/><!-- HANGUL SYLLABLE JYUSS -->
+      <map code="0xc981" name="1em"/><!-- HANGUL SYLLABLE JYUNG -->
+      <map code="0xc982" name="1em"/><!-- HANGUL SYLLABLE JYUJ -->
+      <map code="0xc983" name="1em"/><!-- HANGUL SYLLABLE JYUC -->
+      <map code="0xc984" name="1em"/><!-- HANGUL SYLLABLE JYUK -->
+      <map code="0xc985" name="1em"/><!-- HANGUL SYLLABLE JYUT -->
+      <map code="0xc986" name="1em"/><!-- HANGUL SYLLABLE JYUP -->
+      <map code="0xc987" name="1em"/><!-- HANGUL SYLLABLE JYUH -->
+      <map code="0xc988" name="1em"/><!-- HANGUL SYLLABLE JEU -->
+      <map code="0xc989" name="1em"/><!-- HANGUL SYLLABLE JEUG -->
+      <map code="0xc98a" name="1em"/><!-- HANGUL SYLLABLE JEUGG -->
+      <map code="0xc98b" name="1em"/><!-- HANGUL SYLLABLE JEUGS -->
+      <map code="0xc98c" name="1em"/><!-- HANGUL SYLLABLE JEUN -->
+      <map code="0xc98d" name="1em"/><!-- HANGUL SYLLABLE JEUNJ -->
+      <map code="0xc98e" name="1em"/><!-- HANGUL SYLLABLE JEUNH -->
+      <map code="0xc98f" name="1em"/><!-- HANGUL SYLLABLE JEUD -->
+      <map code="0xc990" name="1em"/><!-- HANGUL SYLLABLE JEUL -->
+      <map code="0xc991" name="1em"/><!-- HANGUL SYLLABLE JEULG -->
+      <map code="0xc992" name="1em"/><!-- HANGUL SYLLABLE JEULM -->
+      <map code="0xc993" name="1em"/><!-- HANGUL SYLLABLE JEULB -->
+      <map code="0xc994" name="1em"/><!-- HANGUL SYLLABLE JEULS -->
+      <map code="0xc995" name="1em"/><!-- HANGUL SYLLABLE JEULT -->
+      <map code="0xc996" name="1em"/><!-- HANGUL SYLLABLE JEULP -->
+      <map code="0xc997" name="1em"/><!-- HANGUL SYLLABLE JEULH -->
+      <map code="0xc998" name="1em"/><!-- HANGUL SYLLABLE JEUM -->
+      <map code="0xc999" name="1em"/><!-- HANGUL SYLLABLE JEUB -->
+      <map code="0xc99a" name="1em"/><!-- HANGUL SYLLABLE JEUBS -->
+      <map code="0xc99b" name="1em"/><!-- HANGUL SYLLABLE JEUS -->
+      <map code="0xc99c" name="1em"/><!-- HANGUL SYLLABLE JEUSS -->
+      <map code="0xc99d" name="1em"/><!-- HANGUL SYLLABLE JEUNG -->
+      <map code="0xc99e" name="1em"/><!-- HANGUL SYLLABLE JEUJ -->
+      <map code="0xc99f" name="1em"/><!-- HANGUL SYLLABLE JEUC -->
+      <map code="0xc9a0" name="1em"/><!-- HANGUL SYLLABLE JEUK -->
+      <map code="0xc9a1" name="1em"/><!-- HANGUL SYLLABLE JEUT -->
+      <map code="0xc9a2" name="1em"/><!-- HANGUL SYLLABLE JEUP -->
+      <map code="0xc9a3" name="1em"/><!-- HANGUL SYLLABLE JEUH -->
+      <map code="0xc9a4" name="1em"/><!-- HANGUL SYLLABLE JYI -->
+      <map code="0xc9a5" name="1em"/><!-- HANGUL SYLLABLE JYIG -->
+      <map code="0xc9a6" name="1em"/><!-- HANGUL SYLLABLE JYIGG -->
+      <map code="0xc9a7" name="1em"/><!-- HANGUL SYLLABLE JYIGS -->
+      <map code="0xc9a8" name="1em"/><!-- HANGUL SYLLABLE JYIN -->
+      <map code="0xc9a9" name="1em"/><!-- HANGUL SYLLABLE JYINJ -->
+      <map code="0xc9aa" name="1em"/><!-- HANGUL SYLLABLE JYINH -->
+      <map code="0xc9ab" name="1em"/><!-- HANGUL SYLLABLE JYID -->
+      <map code="0xc9ac" name="1em"/><!-- HANGUL SYLLABLE JYIL -->
+      <map code="0xc9ad" name="1em"/><!-- HANGUL SYLLABLE JYILG -->
+      <map code="0xc9ae" name="1em"/><!-- HANGUL SYLLABLE JYILM -->
+      <map code="0xc9af" name="1em"/><!-- HANGUL SYLLABLE JYILB -->
+      <map code="0xc9b0" name="1em"/><!-- HANGUL SYLLABLE JYILS -->
+      <map code="0xc9b1" name="1em"/><!-- HANGUL SYLLABLE JYILT -->
+      <map code="0xc9b2" name="1em"/><!-- HANGUL SYLLABLE JYILP -->
+      <map code="0xc9b3" name="1em"/><!-- HANGUL SYLLABLE JYILH -->
+      <map code="0xc9b4" name="1em"/><!-- HANGUL SYLLABLE JYIM -->
+      <map code="0xc9b5" name="1em"/><!-- HANGUL SYLLABLE JYIB -->
+      <map code="0xc9b6" name="1em"/><!-- HANGUL SYLLABLE JYIBS -->
+      <map code="0xc9b7" name="1em"/><!-- HANGUL SYLLABLE JYIS -->
+      <map code="0xc9b8" name="1em"/><!-- HANGUL SYLLABLE JYISS -->
+      <map code="0xc9b9" name="1em"/><!-- HANGUL SYLLABLE JYING -->
+      <map code="0xc9ba" name="1em"/><!-- HANGUL SYLLABLE JYIJ -->
+      <map code="0xc9bb" name="1em"/><!-- HANGUL SYLLABLE JYIC -->
+      <map code="0xc9bc" name="1em"/><!-- HANGUL SYLLABLE JYIK -->
+      <map code="0xc9bd" name="1em"/><!-- HANGUL SYLLABLE JYIT -->
+      <map code="0xc9be" name="1em"/><!-- HANGUL SYLLABLE JYIP -->
+      <map code="0xc9bf" name="1em"/><!-- HANGUL SYLLABLE JYIH -->
+      <map code="0xc9c0" name="1em"/><!-- HANGUL SYLLABLE JI -->
+      <map code="0xc9c1" name="1em"/><!-- HANGUL SYLLABLE JIG -->
+      <map code="0xc9c2" name="1em"/><!-- HANGUL SYLLABLE JIGG -->
+      <map code="0xc9c3" name="1em"/><!-- HANGUL SYLLABLE JIGS -->
+      <map code="0xc9c4" name="1em"/><!-- HANGUL SYLLABLE JIN -->
+      <map code="0xc9c5" name="1em"/><!-- HANGUL SYLLABLE JINJ -->
+      <map code="0xc9c6" name="1em"/><!-- HANGUL SYLLABLE JINH -->
+      <map code="0xc9c7" name="1em"/><!-- HANGUL SYLLABLE JID -->
+      <map code="0xc9c8" name="1em"/><!-- HANGUL SYLLABLE JIL -->
+      <map code="0xc9c9" name="1em"/><!-- HANGUL SYLLABLE JILG -->
+      <map code="0xc9ca" name="1em"/><!-- HANGUL SYLLABLE JILM -->
+      <map code="0xc9cb" name="1em"/><!-- HANGUL SYLLABLE JILB -->
+      <map code="0xc9cc" name="1em"/><!-- HANGUL SYLLABLE JILS -->
+      <map code="0xc9cd" name="1em"/><!-- HANGUL SYLLABLE JILT -->
+      <map code="0xc9ce" name="1em"/><!-- HANGUL SYLLABLE JILP -->
+      <map code="0xc9cf" name="1em"/><!-- HANGUL SYLLABLE JILH -->
+      <map code="0xc9d0" name="1em"/><!-- HANGUL SYLLABLE JIM -->
+      <map code="0xc9d1" name="1em"/><!-- HANGUL SYLLABLE JIB -->
+      <map code="0xc9d2" name="1em"/><!-- HANGUL SYLLABLE JIBS -->
+      <map code="0xc9d3" name="1em"/><!-- HANGUL SYLLABLE JIS -->
+      <map code="0xc9d4" name="1em"/><!-- HANGUL SYLLABLE JISS -->
+      <map code="0xc9d5" name="1em"/><!-- HANGUL SYLLABLE JING -->
+      <map code="0xc9d6" name="1em"/><!-- HANGUL SYLLABLE JIJ -->
+      <map code="0xc9d7" name="1em"/><!-- HANGUL SYLLABLE JIC -->
+      <map code="0xc9d8" name="1em"/><!-- HANGUL SYLLABLE JIK -->
+      <map code="0xc9d9" name="1em"/><!-- HANGUL SYLLABLE JIT -->
+      <map code="0xc9da" name="1em"/><!-- HANGUL SYLLABLE JIP -->
+      <map code="0xc9db" name="1em"/><!-- HANGUL SYLLABLE JIH -->
+      <map code="0xc9dc" name="1em"/><!-- HANGUL SYLLABLE JJA -->
+      <map code="0xc9dd" name="1em"/><!-- HANGUL SYLLABLE JJAG -->
+      <map code="0xc9de" name="1em"/><!-- HANGUL SYLLABLE JJAGG -->
+      <map code="0xc9df" name="1em"/><!-- HANGUL SYLLABLE JJAGS -->
+      <map code="0xc9e0" name="1em"/><!-- HANGUL SYLLABLE JJAN -->
+      <map code="0xc9e1" name="1em"/><!-- HANGUL SYLLABLE JJANJ -->
+      <map code="0xc9e2" name="1em"/><!-- HANGUL SYLLABLE JJANH -->
+      <map code="0xc9e3" name="1em"/><!-- HANGUL SYLLABLE JJAD -->
+      <map code="0xc9e4" name="1em"/><!-- HANGUL SYLLABLE JJAL -->
+      <map code="0xc9e5" name="1em"/><!-- HANGUL SYLLABLE JJALG -->
+      <map code="0xc9e6" name="1em"/><!-- HANGUL SYLLABLE JJALM -->
+      <map code="0xc9e7" name="1em"/><!-- HANGUL SYLLABLE JJALB -->
+      <map code="0xc9e8" name="1em"/><!-- HANGUL SYLLABLE JJALS -->
+      <map code="0xc9e9" name="1em"/><!-- HANGUL SYLLABLE JJALT -->
+      <map code="0xc9ea" name="1em"/><!-- HANGUL SYLLABLE JJALP -->
+      <map code="0xc9eb" name="1em"/><!-- HANGUL SYLLABLE JJALH -->
+      <map code="0xc9ec" name="1em"/><!-- HANGUL SYLLABLE JJAM -->
+      <map code="0xc9ed" name="1em"/><!-- HANGUL SYLLABLE JJAB -->
+      <map code="0xc9ee" name="1em"/><!-- HANGUL SYLLABLE JJABS -->
+      <map code="0xc9ef" name="1em"/><!-- HANGUL SYLLABLE JJAS -->
+      <map code="0xc9f0" name="1em"/><!-- HANGUL SYLLABLE JJASS -->
+      <map code="0xc9f1" name="1em"/><!-- HANGUL SYLLABLE JJANG -->
+      <map code="0xc9f2" name="1em"/><!-- HANGUL SYLLABLE JJAJ -->
+      <map code="0xc9f3" name="1em"/><!-- HANGUL SYLLABLE JJAC -->
+      <map code="0xc9f4" name="1em"/><!-- HANGUL SYLLABLE JJAK -->
+      <map code="0xc9f5" name="1em"/><!-- HANGUL SYLLABLE JJAT -->
+      <map code="0xc9f6" name="1em"/><!-- HANGUL SYLLABLE JJAP -->
+      <map code="0xc9f7" name="1em"/><!-- HANGUL SYLLABLE JJAH -->
+      <map code="0xc9f8" name="1em"/><!-- HANGUL SYLLABLE JJAE -->
+      <map code="0xc9f9" name="1em"/><!-- HANGUL SYLLABLE JJAEG -->
+      <map code="0xc9fa" name="1em"/><!-- HANGUL SYLLABLE JJAEGG -->
+      <map code="0xc9fb" name="1em"/><!-- HANGUL SYLLABLE JJAEGS -->
+      <map code="0xc9fc" name="1em"/><!-- HANGUL SYLLABLE JJAEN -->
+      <map code="0xc9fd" name="1em"/><!-- HANGUL SYLLABLE JJAENJ -->
+      <map code="0xc9fe" name="1em"/><!-- HANGUL SYLLABLE JJAENH -->
+      <map code="0xc9ff" name="1em"/><!-- HANGUL SYLLABLE JJAED -->
+      <map code="0xca00" name="1em"/><!-- HANGUL SYLLABLE JJAEL -->
+      <map code="0xca01" name="1em"/><!-- HANGUL SYLLABLE JJAELG -->
+      <map code="0xca02" name="1em"/><!-- HANGUL SYLLABLE JJAELM -->
+      <map code="0xca03" name="1em"/><!-- HANGUL SYLLABLE JJAELB -->
+      <map code="0xca04" name="1em"/><!-- HANGUL SYLLABLE JJAELS -->
+      <map code="0xca05" name="1em"/><!-- HANGUL SYLLABLE JJAELT -->
+      <map code="0xca06" name="1em"/><!-- HANGUL SYLLABLE JJAELP -->
+      <map code="0xca07" name="1em"/><!-- HANGUL SYLLABLE JJAELH -->
+      <map code="0xca08" name="1em"/><!-- HANGUL SYLLABLE JJAEM -->
+      <map code="0xca09" name="1em"/><!-- HANGUL SYLLABLE JJAEB -->
+      <map code="0xca0a" name="1em"/><!-- HANGUL SYLLABLE JJAEBS -->
+      <map code="0xca0b" name="1em"/><!-- HANGUL SYLLABLE JJAES -->
+      <map code="0xca0c" name="1em"/><!-- HANGUL SYLLABLE JJAESS -->
+      <map code="0xca0d" name="1em"/><!-- HANGUL SYLLABLE JJAENG -->
+      <map code="0xca0e" name="1em"/><!-- HANGUL SYLLABLE JJAEJ -->
+      <map code="0xca0f" name="1em"/><!-- HANGUL SYLLABLE JJAEC -->
+      <map code="0xca10" name="1em"/><!-- HANGUL SYLLABLE JJAEK -->
+      <map code="0xca11" name="1em"/><!-- HANGUL SYLLABLE JJAET -->
+      <map code="0xca12" name="1em"/><!-- HANGUL SYLLABLE JJAEP -->
+      <map code="0xca13" name="1em"/><!-- HANGUL SYLLABLE JJAEH -->
+      <map code="0xca14" name="1em"/><!-- HANGUL SYLLABLE JJYA -->
+      <map code="0xca15" name="1em"/><!-- HANGUL SYLLABLE JJYAG -->
+      <map code="0xca16" name="1em"/><!-- HANGUL SYLLABLE JJYAGG -->
+      <map code="0xca17" name="1em"/><!-- HANGUL SYLLABLE JJYAGS -->
+      <map code="0xca18" name="1em"/><!-- HANGUL SYLLABLE JJYAN -->
+      <map code="0xca19" name="1em"/><!-- HANGUL SYLLABLE JJYANJ -->
+      <map code="0xca1a" name="1em"/><!-- HANGUL SYLLABLE JJYANH -->
+      <map code="0xca1b" name="1em"/><!-- HANGUL SYLLABLE JJYAD -->
+      <map code="0xca1c" name="1em"/><!-- HANGUL SYLLABLE JJYAL -->
+      <map code="0xca1d" name="1em"/><!-- HANGUL SYLLABLE JJYALG -->
+      <map code="0xca1e" name="1em"/><!-- HANGUL SYLLABLE JJYALM -->
+      <map code="0xca1f" name="1em"/><!-- HANGUL SYLLABLE JJYALB -->
+      <map code="0xca20" name="1em"/><!-- HANGUL SYLLABLE JJYALS -->
+      <map code="0xca21" name="1em"/><!-- HANGUL SYLLABLE JJYALT -->
+      <map code="0xca22" name="1em"/><!-- HANGUL SYLLABLE JJYALP -->
+      <map code="0xca23" name="1em"/><!-- HANGUL SYLLABLE JJYALH -->
+      <map code="0xca24" name="1em"/><!-- HANGUL SYLLABLE JJYAM -->
+      <map code="0xca25" name="1em"/><!-- HANGUL SYLLABLE JJYAB -->
+      <map code="0xca26" name="1em"/><!-- HANGUL SYLLABLE JJYABS -->
+      <map code="0xca27" name="1em"/><!-- HANGUL SYLLABLE JJYAS -->
+      <map code="0xca28" name="1em"/><!-- HANGUL SYLLABLE JJYASS -->
+      <map code="0xca29" name="1em"/><!-- HANGUL SYLLABLE JJYANG -->
+      <map code="0xca2a" name="1em"/><!-- HANGUL SYLLABLE JJYAJ -->
+      <map code="0xca2b" name="1em"/><!-- HANGUL SYLLABLE JJYAC -->
+      <map code="0xca2c" name="1em"/><!-- HANGUL SYLLABLE JJYAK -->
+      <map code="0xca2d" name="1em"/><!-- HANGUL SYLLABLE JJYAT -->
+      <map code="0xca2e" name="1em"/><!-- HANGUL SYLLABLE JJYAP -->
+      <map code="0xca2f" name="1em"/><!-- HANGUL SYLLABLE JJYAH -->
+      <map code="0xca30" name="1em"/><!-- HANGUL SYLLABLE JJYAE -->
+      <map code="0xca31" name="1em"/><!-- HANGUL SYLLABLE JJYAEG -->
+      <map code="0xca32" name="1em"/><!-- HANGUL SYLLABLE JJYAEGG -->
+      <map code="0xca33" name="1em"/><!-- HANGUL SYLLABLE JJYAEGS -->
+      <map code="0xca34" name="1em"/><!-- HANGUL SYLLABLE JJYAEN -->
+      <map code="0xca35" name="1em"/><!-- HANGUL SYLLABLE JJYAENJ -->
+      <map code="0xca36" name="1em"/><!-- HANGUL SYLLABLE JJYAENH -->
+      <map code="0xca37" name="1em"/><!-- HANGUL SYLLABLE JJYAED -->
+      <map code="0xca38" name="1em"/><!-- HANGUL SYLLABLE JJYAEL -->
+      <map code="0xca39" name="1em"/><!-- HANGUL SYLLABLE JJYAELG -->
+      <map code="0xca3a" name="1em"/><!-- HANGUL SYLLABLE JJYAELM -->
+      <map code="0xca3b" name="1em"/><!-- HANGUL SYLLABLE JJYAELB -->
+      <map code="0xca3c" name="1em"/><!-- HANGUL SYLLABLE JJYAELS -->
+      <map code="0xca3d" name="1em"/><!-- HANGUL SYLLABLE JJYAELT -->
+      <map code="0xca3e" name="1em"/><!-- HANGUL SYLLABLE JJYAELP -->
+      <map code="0xca3f" name="1em"/><!-- HANGUL SYLLABLE JJYAELH -->
+      <map code="0xca40" name="1em"/><!-- HANGUL SYLLABLE JJYAEM -->
+      <map code="0xca41" name="1em"/><!-- HANGUL SYLLABLE JJYAEB -->
+      <map code="0xca42" name="1em"/><!-- HANGUL SYLLABLE JJYAEBS -->
+      <map code="0xca43" name="1em"/><!-- HANGUL SYLLABLE JJYAES -->
+      <map code="0xca44" name="1em"/><!-- HANGUL SYLLABLE JJYAESS -->
+      <map code="0xca45" name="1em"/><!-- HANGUL SYLLABLE JJYAENG -->
+      <map code="0xca46" name="1em"/><!-- HANGUL SYLLABLE JJYAEJ -->
+      <map code="0xca47" name="1em"/><!-- HANGUL SYLLABLE JJYAEC -->
+      <map code="0xca48" name="1em"/><!-- HANGUL SYLLABLE JJYAEK -->
+      <map code="0xca49" name="1em"/><!-- HANGUL SYLLABLE JJYAET -->
+      <map code="0xca4a" name="1em"/><!-- HANGUL SYLLABLE JJYAEP -->
+      <map code="0xca4b" name="1em"/><!-- HANGUL SYLLABLE JJYAEH -->
+      <map code="0xca4c" name="1em"/><!-- HANGUL SYLLABLE JJEO -->
+      <map code="0xca4d" name="1em"/><!-- HANGUL SYLLABLE JJEOG -->
+      <map code="0xca4e" name="1em"/><!-- HANGUL SYLLABLE JJEOGG -->
+      <map code="0xca4f" name="1em"/><!-- HANGUL SYLLABLE JJEOGS -->
+      <map code="0xca50" name="1em"/><!-- HANGUL SYLLABLE JJEON -->
+      <map code="0xca51" name="1em"/><!-- HANGUL SYLLABLE JJEONJ -->
+      <map code="0xca52" name="1em"/><!-- HANGUL SYLLABLE JJEONH -->
+      <map code="0xca53" name="1em"/><!-- HANGUL SYLLABLE JJEOD -->
+      <map code="0xca54" name="1em"/><!-- HANGUL SYLLABLE JJEOL -->
+      <map code="0xca55" name="1em"/><!-- HANGUL SYLLABLE JJEOLG -->
+      <map code="0xca56" name="1em"/><!-- HANGUL SYLLABLE JJEOLM -->
+      <map code="0xca57" name="1em"/><!-- HANGUL SYLLABLE JJEOLB -->
+      <map code="0xca58" name="1em"/><!-- HANGUL SYLLABLE JJEOLS -->
+      <map code="0xca59" name="1em"/><!-- HANGUL SYLLABLE JJEOLT -->
+      <map code="0xca5a" name="1em"/><!-- HANGUL SYLLABLE JJEOLP -->
+      <map code="0xca5b" name="1em"/><!-- HANGUL SYLLABLE JJEOLH -->
+      <map code="0xca5c" name="1em"/><!-- HANGUL SYLLABLE JJEOM -->
+      <map code="0xca5d" name="1em"/><!-- HANGUL SYLLABLE JJEOB -->
+      <map code="0xca5e" name="1em"/><!-- HANGUL SYLLABLE JJEOBS -->
+      <map code="0xca5f" name="1em"/><!-- HANGUL SYLLABLE JJEOS -->
+      <map code="0xca60" name="1em"/><!-- HANGUL SYLLABLE JJEOSS -->
+      <map code="0xca61" name="1em"/><!-- HANGUL SYLLABLE JJEONG -->
+      <map code="0xca62" name="1em"/><!-- HANGUL SYLLABLE JJEOJ -->
+      <map code="0xca63" name="1em"/><!-- HANGUL SYLLABLE JJEOC -->
+      <map code="0xca64" name="1em"/><!-- HANGUL SYLLABLE JJEOK -->
+      <map code="0xca65" name="1em"/><!-- HANGUL SYLLABLE JJEOT -->
+      <map code="0xca66" name="1em"/><!-- HANGUL SYLLABLE JJEOP -->
+      <map code="0xca67" name="1em"/><!-- HANGUL SYLLABLE JJEOH -->
+      <map code="0xca68" name="1em"/><!-- HANGUL SYLLABLE JJE -->
+      <map code="0xca69" name="1em"/><!-- HANGUL SYLLABLE JJEG -->
+      <map code="0xca6a" name="1em"/><!-- HANGUL SYLLABLE JJEGG -->
+      <map code="0xca6b" name="1em"/><!-- HANGUL SYLLABLE JJEGS -->
+      <map code="0xca6c" name="1em"/><!-- HANGUL SYLLABLE JJEN -->
+      <map code="0xca6d" name="1em"/><!-- HANGUL SYLLABLE JJENJ -->
+      <map code="0xca6e" name="1em"/><!-- HANGUL SYLLABLE JJENH -->
+      <map code="0xca6f" name="1em"/><!-- HANGUL SYLLABLE JJED -->
+      <map code="0xca70" name="1em"/><!-- HANGUL SYLLABLE JJEL -->
+      <map code="0xca71" name="1em"/><!-- HANGUL SYLLABLE JJELG -->
+      <map code="0xca72" name="1em"/><!-- HANGUL SYLLABLE JJELM -->
+      <map code="0xca73" name="1em"/><!-- HANGUL SYLLABLE JJELB -->
+      <map code="0xca74" name="1em"/><!-- HANGUL SYLLABLE JJELS -->
+      <map code="0xca75" name="1em"/><!-- HANGUL SYLLABLE JJELT -->
+      <map code="0xca76" name="1em"/><!-- HANGUL SYLLABLE JJELP -->
+      <map code="0xca77" name="1em"/><!-- HANGUL SYLLABLE JJELH -->
+      <map code="0xca78" name="1em"/><!-- HANGUL SYLLABLE JJEM -->
+      <map code="0xca79" name="1em"/><!-- HANGUL SYLLABLE JJEB -->
+      <map code="0xca7a" name="1em"/><!-- HANGUL SYLLABLE JJEBS -->
+      <map code="0xca7b" name="1em"/><!-- HANGUL SYLLABLE JJES -->
+      <map code="0xca7c" name="1em"/><!-- HANGUL SYLLABLE JJESS -->
+      <map code="0xca7d" name="1em"/><!-- HANGUL SYLLABLE JJENG -->
+      <map code="0xca7e" name="1em"/><!-- HANGUL SYLLABLE JJEJ -->
+      <map code="0xca7f" name="1em"/><!-- HANGUL SYLLABLE JJEC -->
+      <map code="0xca80" name="1em"/><!-- HANGUL SYLLABLE JJEK -->
+      <map code="0xca81" name="1em"/><!-- HANGUL SYLLABLE JJET -->
+      <map code="0xca82" name="1em"/><!-- HANGUL SYLLABLE JJEP -->
+      <map code="0xca83" name="1em"/><!-- HANGUL SYLLABLE JJEH -->
+      <map code="0xca84" name="1em"/><!-- HANGUL SYLLABLE JJYEO -->
+      <map code="0xca85" name="1em"/><!-- HANGUL SYLLABLE JJYEOG -->
+      <map code="0xca86" name="1em"/><!-- HANGUL SYLLABLE JJYEOGG -->
+      <map code="0xca87" name="1em"/><!-- HANGUL SYLLABLE JJYEOGS -->
+      <map code="0xca88" name="1em"/><!-- HANGUL SYLLABLE JJYEON -->
+      <map code="0xca89" name="1em"/><!-- HANGUL SYLLABLE JJYEONJ -->
+      <map code="0xca8a" name="1em"/><!-- HANGUL SYLLABLE JJYEONH -->
+      <map code="0xca8b" name="1em"/><!-- HANGUL SYLLABLE JJYEOD -->
+      <map code="0xca8c" name="1em"/><!-- HANGUL SYLLABLE JJYEOL -->
+      <map code="0xca8d" name="1em"/><!-- HANGUL SYLLABLE JJYEOLG -->
+      <map code="0xca8e" name="1em"/><!-- HANGUL SYLLABLE JJYEOLM -->
+      <map code="0xca8f" name="1em"/><!-- HANGUL SYLLABLE JJYEOLB -->
+      <map code="0xca90" name="1em"/><!-- HANGUL SYLLABLE JJYEOLS -->
+      <map code="0xca91" name="1em"/><!-- HANGUL SYLLABLE JJYEOLT -->
+      <map code="0xca92" name="1em"/><!-- HANGUL SYLLABLE JJYEOLP -->
+      <map code="0xca93" name="1em"/><!-- HANGUL SYLLABLE JJYEOLH -->
+      <map code="0xca94" name="1em"/><!-- HANGUL SYLLABLE JJYEOM -->
+      <map code="0xca95" name="1em"/><!-- HANGUL SYLLABLE JJYEOB -->
+      <map code="0xca96" name="1em"/><!-- HANGUL SYLLABLE JJYEOBS -->
+      <map code="0xca97" name="1em"/><!-- HANGUL SYLLABLE JJYEOS -->
+      <map code="0xca98" name="1em"/><!-- HANGUL SYLLABLE JJYEOSS -->
+      <map code="0xca99" name="1em"/><!-- HANGUL SYLLABLE JJYEONG -->
+      <map code="0xca9a" name="1em"/><!-- HANGUL SYLLABLE JJYEOJ -->
+      <map code="0xca9b" name="1em"/><!-- HANGUL SYLLABLE JJYEOC -->
+      <map code="0xca9c" name="1em"/><!-- HANGUL SYLLABLE JJYEOK -->
+      <map code="0xca9d" name="1em"/><!-- HANGUL SYLLABLE JJYEOT -->
+      <map code="0xca9e" name="1em"/><!-- HANGUL SYLLABLE JJYEOP -->
+      <map code="0xca9f" name="1em"/><!-- HANGUL SYLLABLE JJYEOH -->
+      <map code="0xcaa0" name="1em"/><!-- HANGUL SYLLABLE JJYE -->
+      <map code="0xcaa1" name="1em"/><!-- HANGUL SYLLABLE JJYEG -->
+      <map code="0xcaa2" name="1em"/><!-- HANGUL SYLLABLE JJYEGG -->
+      <map code="0xcaa3" name="1em"/><!-- HANGUL SYLLABLE JJYEGS -->
+      <map code="0xcaa4" name="1em"/><!-- HANGUL SYLLABLE JJYEN -->
+      <map code="0xcaa5" name="1em"/><!-- HANGUL SYLLABLE JJYENJ -->
+      <map code="0xcaa6" name="1em"/><!-- HANGUL SYLLABLE JJYENH -->
+      <map code="0xcaa7" name="1em"/><!-- HANGUL SYLLABLE JJYED -->
+      <map code="0xcaa8" name="1em"/><!-- HANGUL SYLLABLE JJYEL -->
+      <map code="0xcaa9" name="1em"/><!-- HANGUL SYLLABLE JJYELG -->
+      <map code="0xcaaa" name="1em"/><!-- HANGUL SYLLABLE JJYELM -->
+      <map code="0xcaab" name="1em"/><!-- HANGUL SYLLABLE JJYELB -->
+      <map code="0xcaac" name="1em"/><!-- HANGUL SYLLABLE JJYELS -->
+      <map code="0xcaad" name="1em"/><!-- HANGUL SYLLABLE JJYELT -->
+      <map code="0xcaae" name="1em"/><!-- HANGUL SYLLABLE JJYELP -->
+      <map code="0xcaaf" name="1em"/><!-- HANGUL SYLLABLE JJYELH -->
+      <map code="0xcab0" name="1em"/><!-- HANGUL SYLLABLE JJYEM -->
+      <map code="0xcab1" name="1em"/><!-- HANGUL SYLLABLE JJYEB -->
+      <map code="0xcab2" name="1em"/><!-- HANGUL SYLLABLE JJYEBS -->
+      <map code="0xcab3" name="1em"/><!-- HANGUL SYLLABLE JJYES -->
+      <map code="0xcab4" name="1em"/><!-- HANGUL SYLLABLE JJYESS -->
+      <map code="0xcab5" name="1em"/><!-- HANGUL SYLLABLE JJYENG -->
+      <map code="0xcab6" name="1em"/><!-- HANGUL SYLLABLE JJYEJ -->
+      <map code="0xcab7" name="1em"/><!-- HANGUL SYLLABLE JJYEC -->
+      <map code="0xcab8" name="1em"/><!-- HANGUL SYLLABLE JJYEK -->
+      <map code="0xcab9" name="1em"/><!-- HANGUL SYLLABLE JJYET -->
+      <map code="0xcaba" name="1em"/><!-- HANGUL SYLLABLE JJYEP -->
+      <map code="0xcabb" name="1em"/><!-- HANGUL SYLLABLE JJYEH -->
+      <map code="0xcabc" name="1em"/><!-- HANGUL SYLLABLE JJO -->
+      <map code="0xcabd" name="1em"/><!-- HANGUL SYLLABLE JJOG -->
+      <map code="0xcabe" name="1em"/><!-- HANGUL SYLLABLE JJOGG -->
+      <map code="0xcabf" name="1em"/><!-- HANGUL SYLLABLE JJOGS -->
+      <map code="0xcac0" name="1em"/><!-- HANGUL SYLLABLE JJON -->
+      <map code="0xcac1" name="1em"/><!-- HANGUL SYLLABLE JJONJ -->
+      <map code="0xcac2" name="1em"/><!-- HANGUL SYLLABLE JJONH -->
+      <map code="0xcac3" name="1em"/><!-- HANGUL SYLLABLE JJOD -->
+      <map code="0xcac4" name="1em"/><!-- HANGUL SYLLABLE JJOL -->
+      <map code="0xcac5" name="1em"/><!-- HANGUL SYLLABLE JJOLG -->
+      <map code="0xcac6" name="1em"/><!-- HANGUL SYLLABLE JJOLM -->
+      <map code="0xcac7" name="1em"/><!-- HANGUL SYLLABLE JJOLB -->
+      <map code="0xcac8" name="1em"/><!-- HANGUL SYLLABLE JJOLS -->
+      <map code="0xcac9" name="1em"/><!-- HANGUL SYLLABLE JJOLT -->
+      <map code="0xcaca" name="1em"/><!-- HANGUL SYLLABLE JJOLP -->
+      <map code="0xcacb" name="1em"/><!-- HANGUL SYLLABLE JJOLH -->
+      <map code="0xcacc" name="1em"/><!-- HANGUL SYLLABLE JJOM -->
+      <map code="0xcacd" name="1em"/><!-- HANGUL SYLLABLE JJOB -->
+      <map code="0xcace" name="1em"/><!-- HANGUL SYLLABLE JJOBS -->
+      <map code="0xcacf" name="1em"/><!-- HANGUL SYLLABLE JJOS -->
+      <map code="0xcad0" name="1em"/><!-- HANGUL SYLLABLE JJOSS -->
+      <map code="0xcad1" name="1em"/><!-- HANGUL SYLLABLE JJONG -->
+      <map code="0xcad2" name="1em"/><!-- HANGUL SYLLABLE JJOJ -->
+      <map code="0xcad3" name="1em"/><!-- HANGUL SYLLABLE JJOC -->
+      <map code="0xcad4" name="1em"/><!-- HANGUL SYLLABLE JJOK -->
+      <map code="0xcad5" name="1em"/><!-- HANGUL SYLLABLE JJOT -->
+      <map code="0xcad6" name="1em"/><!-- HANGUL SYLLABLE JJOP -->
+      <map code="0xcad7" name="1em"/><!-- HANGUL SYLLABLE JJOH -->
+      <map code="0xcad8" name="1em"/><!-- HANGUL SYLLABLE JJWA -->
+      <map code="0xcad9" name="1em"/><!-- HANGUL SYLLABLE JJWAG -->
+      <map code="0xcada" name="1em"/><!-- HANGUL SYLLABLE JJWAGG -->
+      <map code="0xcadb" name="1em"/><!-- HANGUL SYLLABLE JJWAGS -->
+      <map code="0xcadc" name="1em"/><!-- HANGUL SYLLABLE JJWAN -->
+      <map code="0xcadd" name="1em"/><!-- HANGUL SYLLABLE JJWANJ -->
+      <map code="0xcade" name="1em"/><!-- HANGUL SYLLABLE JJWANH -->
+      <map code="0xcadf" name="1em"/><!-- HANGUL SYLLABLE JJWAD -->
+      <map code="0xcae0" name="1em"/><!-- HANGUL SYLLABLE JJWAL -->
+      <map code="0xcae1" name="1em"/><!-- HANGUL SYLLABLE JJWALG -->
+      <map code="0xcae2" name="1em"/><!-- HANGUL SYLLABLE JJWALM -->
+      <map code="0xcae3" name="1em"/><!-- HANGUL SYLLABLE JJWALB -->
+      <map code="0xcae4" name="1em"/><!-- HANGUL SYLLABLE JJWALS -->
+      <map code="0xcae5" name="1em"/><!-- HANGUL SYLLABLE JJWALT -->
+      <map code="0xcae6" name="1em"/><!-- HANGUL SYLLABLE JJWALP -->
+      <map code="0xcae7" name="1em"/><!-- HANGUL SYLLABLE JJWALH -->
+      <map code="0xcae8" name="1em"/><!-- HANGUL SYLLABLE JJWAM -->
+      <map code="0xcae9" name="1em"/><!-- HANGUL SYLLABLE JJWAB -->
+      <map code="0xcaea" name="1em"/><!-- HANGUL SYLLABLE JJWABS -->
+      <map code="0xcaeb" name="1em"/><!-- HANGUL SYLLABLE JJWAS -->
+      <map code="0xcaec" name="1em"/><!-- HANGUL SYLLABLE JJWASS -->
+      <map code="0xcaed" name="1em"/><!-- HANGUL SYLLABLE JJWANG -->
+      <map code="0xcaee" name="1em"/><!-- HANGUL SYLLABLE JJWAJ -->
+      <map code="0xcaef" name="1em"/><!-- HANGUL SYLLABLE JJWAC -->
+      <map code="0xcaf0" name="1em"/><!-- HANGUL SYLLABLE JJWAK -->
+      <map code="0xcaf1" name="1em"/><!-- HANGUL SYLLABLE JJWAT -->
+      <map code="0xcaf2" name="1em"/><!-- HANGUL SYLLABLE JJWAP -->
+      <map code="0xcaf3" name="1em"/><!-- HANGUL SYLLABLE JJWAH -->
+      <map code="0xcaf4" name="1em"/><!-- HANGUL SYLLABLE JJWAE -->
+      <map code="0xcaf5" name="1em"/><!-- HANGUL SYLLABLE JJWAEG -->
+      <map code="0xcaf6" name="1em"/><!-- HANGUL SYLLABLE JJWAEGG -->
+      <map code="0xcaf7" name="1em"/><!-- HANGUL SYLLABLE JJWAEGS -->
+      <map code="0xcaf8" name="1em"/><!-- HANGUL SYLLABLE JJWAEN -->
+      <map code="0xcaf9" name="1em"/><!-- HANGUL SYLLABLE JJWAENJ -->
+      <map code="0xcafa" name="1em"/><!-- HANGUL SYLLABLE JJWAENH -->
+      <map code="0xcafb" name="1em"/><!-- HANGUL SYLLABLE JJWAED -->
+      <map code="0xcafc" name="1em"/><!-- HANGUL SYLLABLE JJWAEL -->
+      <map code="0xcafd" name="1em"/><!-- HANGUL SYLLABLE JJWAELG -->
+      <map code="0xcafe" name="1em"/><!-- HANGUL SYLLABLE JJWAELM -->
+      <map code="0xcaff" name="1em"/><!-- HANGUL SYLLABLE JJWAELB -->
+      <map code="0xcb00" name="1em"/><!-- HANGUL SYLLABLE JJWAELS -->
+      <map code="0xcb01" name="1em"/><!-- HANGUL SYLLABLE JJWAELT -->
+      <map code="0xcb02" name="1em"/><!-- HANGUL SYLLABLE JJWAELP -->
+      <map code="0xcb03" name="1em"/><!-- HANGUL SYLLABLE JJWAELH -->
+      <map code="0xcb04" name="1em"/><!-- HANGUL SYLLABLE JJWAEM -->
+      <map code="0xcb05" name="1em"/><!-- HANGUL SYLLABLE JJWAEB -->
+      <map code="0xcb06" name="1em"/><!-- HANGUL SYLLABLE JJWAEBS -->
+      <map code="0xcb07" name="1em"/><!-- HANGUL SYLLABLE JJWAES -->
+      <map code="0xcb08" name="1em"/><!-- HANGUL SYLLABLE JJWAESS -->
+      <map code="0xcb09" name="1em"/><!-- HANGUL SYLLABLE JJWAENG -->
+      <map code="0xcb0a" name="1em"/><!-- HANGUL SYLLABLE JJWAEJ -->
+      <map code="0xcb0b" name="1em"/><!-- HANGUL SYLLABLE JJWAEC -->
+      <map code="0xcb0c" name="1em"/><!-- HANGUL SYLLABLE JJWAEK -->
+      <map code="0xcb0d" name="1em"/><!-- HANGUL SYLLABLE JJWAET -->
+      <map code="0xcb0e" name="1em"/><!-- HANGUL SYLLABLE JJWAEP -->
+      <map code="0xcb0f" name="1em"/><!-- HANGUL SYLLABLE JJWAEH -->
+      <map code="0xcb10" name="1em"/><!-- HANGUL SYLLABLE JJOE -->
+      <map code="0xcb11" name="1em"/><!-- HANGUL SYLLABLE JJOEG -->
+      <map code="0xcb12" name="1em"/><!-- HANGUL SYLLABLE JJOEGG -->
+      <map code="0xcb13" name="1em"/><!-- HANGUL SYLLABLE JJOEGS -->
+      <map code="0xcb14" name="1em"/><!-- HANGUL SYLLABLE JJOEN -->
+      <map code="0xcb15" name="1em"/><!-- HANGUL SYLLABLE JJOENJ -->
+      <map code="0xcb16" name="1em"/><!-- HANGUL SYLLABLE JJOENH -->
+      <map code="0xcb17" name="1em"/><!-- HANGUL SYLLABLE JJOED -->
+      <map code="0xcb18" name="1em"/><!-- HANGUL SYLLABLE JJOEL -->
+      <map code="0xcb19" name="1em"/><!-- HANGUL SYLLABLE JJOELG -->
+      <map code="0xcb1a" name="1em"/><!-- HANGUL SYLLABLE JJOELM -->
+      <map code="0xcb1b" name="1em"/><!-- HANGUL SYLLABLE JJOELB -->
+      <map code="0xcb1c" name="1em"/><!-- HANGUL SYLLABLE JJOELS -->
+      <map code="0xcb1d" name="1em"/><!-- HANGUL SYLLABLE JJOELT -->
+      <map code="0xcb1e" name="1em"/><!-- HANGUL SYLLABLE JJOELP -->
+      <map code="0xcb1f" name="1em"/><!-- HANGUL SYLLABLE JJOELH -->
+      <map code="0xcb20" name="1em"/><!-- HANGUL SYLLABLE JJOEM -->
+      <map code="0xcb21" name="1em"/><!-- HANGUL SYLLABLE JJOEB -->
+      <map code="0xcb22" name="1em"/><!-- HANGUL SYLLABLE JJOEBS -->
+      <map code="0xcb23" name="1em"/><!-- HANGUL SYLLABLE JJOES -->
+      <map code="0xcb24" name="1em"/><!-- HANGUL SYLLABLE JJOESS -->
+      <map code="0xcb25" name="1em"/><!-- HANGUL SYLLABLE JJOENG -->
+      <map code="0xcb26" name="1em"/><!-- HANGUL SYLLABLE JJOEJ -->
+      <map code="0xcb27" name="1em"/><!-- HANGUL SYLLABLE JJOEC -->
+      <map code="0xcb28" name="1em"/><!-- HANGUL SYLLABLE JJOEK -->
+      <map code="0xcb29" name="1em"/><!-- HANGUL SYLLABLE JJOET -->
+      <map code="0xcb2a" name="1em"/><!-- HANGUL SYLLABLE JJOEP -->
+      <map code="0xcb2b" name="1em"/><!-- HANGUL SYLLABLE JJOEH -->
+      <map code="0xcb2c" name="1em"/><!-- HANGUL SYLLABLE JJYO -->
+      <map code="0xcb2d" name="1em"/><!-- HANGUL SYLLABLE JJYOG -->
+      <map code="0xcb2e" name="1em"/><!-- HANGUL SYLLABLE JJYOGG -->
+      <map code="0xcb2f" name="1em"/><!-- HANGUL SYLLABLE JJYOGS -->
+      <map code="0xcb30" name="1em"/><!-- HANGUL SYLLABLE JJYON -->
+      <map code="0xcb31" name="1em"/><!-- HANGUL SYLLABLE JJYONJ -->
+      <map code="0xcb32" name="1em"/><!-- HANGUL SYLLABLE JJYONH -->
+      <map code="0xcb33" name="1em"/><!-- HANGUL SYLLABLE JJYOD -->
+      <map code="0xcb34" name="1em"/><!-- HANGUL SYLLABLE JJYOL -->
+      <map code="0xcb35" name="1em"/><!-- HANGUL SYLLABLE JJYOLG -->
+      <map code="0xcb36" name="1em"/><!-- HANGUL SYLLABLE JJYOLM -->
+      <map code="0xcb37" name="1em"/><!-- HANGUL SYLLABLE JJYOLB -->
+      <map code="0xcb38" name="1em"/><!-- HANGUL SYLLABLE JJYOLS -->
+      <map code="0xcb39" name="1em"/><!-- HANGUL SYLLABLE JJYOLT -->
+      <map code="0xcb3a" name="1em"/><!-- HANGUL SYLLABLE JJYOLP -->
+      <map code="0xcb3b" name="1em"/><!-- HANGUL SYLLABLE JJYOLH -->
+      <map code="0xcb3c" name="1em"/><!-- HANGUL SYLLABLE JJYOM -->
+      <map code="0xcb3d" name="1em"/><!-- HANGUL SYLLABLE JJYOB -->
+      <map code="0xcb3e" name="1em"/><!-- HANGUL SYLLABLE JJYOBS -->
+      <map code="0xcb3f" name="1em"/><!-- HANGUL SYLLABLE JJYOS -->
+      <map code="0xcb40" name="1em"/><!-- HANGUL SYLLABLE JJYOSS -->
+      <map code="0xcb41" name="1em"/><!-- HANGUL SYLLABLE JJYONG -->
+      <map code="0xcb42" name="1em"/><!-- HANGUL SYLLABLE JJYOJ -->
+      <map code="0xcb43" name="1em"/><!-- HANGUL SYLLABLE JJYOC -->
+      <map code="0xcb44" name="1em"/><!-- HANGUL SYLLABLE JJYOK -->
+      <map code="0xcb45" name="1em"/><!-- HANGUL SYLLABLE JJYOT -->
+      <map code="0xcb46" name="1em"/><!-- HANGUL SYLLABLE JJYOP -->
+      <map code="0xcb47" name="1em"/><!-- HANGUL SYLLABLE JJYOH -->
+      <map code="0xcb48" name="1em"/><!-- HANGUL SYLLABLE JJU -->
+      <map code="0xcb49" name="1em"/><!-- HANGUL SYLLABLE JJUG -->
+      <map code="0xcb4a" name="1em"/><!-- HANGUL SYLLABLE JJUGG -->
+      <map code="0xcb4b" name="1em"/><!-- HANGUL SYLLABLE JJUGS -->
+      <map code="0xcb4c" name="1em"/><!-- HANGUL SYLLABLE JJUN -->
+      <map code="0xcb4d" name="1em"/><!-- HANGUL SYLLABLE JJUNJ -->
+      <map code="0xcb4e" name="1em"/><!-- HANGUL SYLLABLE JJUNH -->
+      <map code="0xcb4f" name="1em"/><!-- HANGUL SYLLABLE JJUD -->
+      <map code="0xcb50" name="1em"/><!-- HANGUL SYLLABLE JJUL -->
+      <map code="0xcb51" name="1em"/><!-- HANGUL SYLLABLE JJULG -->
+      <map code="0xcb52" name="1em"/><!-- HANGUL SYLLABLE JJULM -->
+      <map code="0xcb53" name="1em"/><!-- HANGUL SYLLABLE JJULB -->
+      <map code="0xcb54" name="1em"/><!-- HANGUL SYLLABLE JJULS -->
+      <map code="0xcb55" name="1em"/><!-- HANGUL SYLLABLE JJULT -->
+      <map code="0xcb56" name="1em"/><!-- HANGUL SYLLABLE JJULP -->
+      <map code="0xcb57" name="1em"/><!-- HANGUL SYLLABLE JJULH -->
+      <map code="0xcb58" name="1em"/><!-- HANGUL SYLLABLE JJUM -->
+      <map code="0xcb59" name="1em"/><!-- HANGUL SYLLABLE JJUB -->
+      <map code="0xcb5a" name="1em"/><!-- HANGUL SYLLABLE JJUBS -->
+      <map code="0xcb5b" name="1em"/><!-- HANGUL SYLLABLE JJUS -->
+      <map code="0xcb5c" name="1em"/><!-- HANGUL SYLLABLE JJUSS -->
+      <map code="0xcb5d" name="1em"/><!-- HANGUL SYLLABLE JJUNG -->
+      <map code="0xcb5e" name="1em"/><!-- HANGUL SYLLABLE JJUJ -->
+      <map code="0xcb5f" name="1em"/><!-- HANGUL SYLLABLE JJUC -->
+      <map code="0xcb60" name="1em"/><!-- HANGUL SYLLABLE JJUK -->
+      <map code="0xcb61" name="1em"/><!-- HANGUL SYLLABLE JJUT -->
+      <map code="0xcb62" name="1em"/><!-- HANGUL SYLLABLE JJUP -->
+      <map code="0xcb63" name="1em"/><!-- HANGUL SYLLABLE JJUH -->
+      <map code="0xcb64" name="1em"/><!-- HANGUL SYLLABLE JJWEO -->
+      <map code="0xcb65" name="1em"/><!-- HANGUL SYLLABLE JJWEOG -->
+      <map code="0xcb66" name="1em"/><!-- HANGUL SYLLABLE JJWEOGG -->
+      <map code="0xcb67" name="1em"/><!-- HANGUL SYLLABLE JJWEOGS -->
+      <map code="0xcb68" name="1em"/><!-- HANGUL SYLLABLE JJWEON -->
+      <map code="0xcb69" name="1em"/><!-- HANGUL SYLLABLE JJWEONJ -->
+      <map code="0xcb6a" name="1em"/><!-- HANGUL SYLLABLE JJWEONH -->
+      <map code="0xcb6b" name="1em"/><!-- HANGUL SYLLABLE JJWEOD -->
+      <map code="0xcb6c" name="1em"/><!-- HANGUL SYLLABLE JJWEOL -->
+      <map code="0xcb6d" name="1em"/><!-- HANGUL SYLLABLE JJWEOLG -->
+      <map code="0xcb6e" name="1em"/><!-- HANGUL SYLLABLE JJWEOLM -->
+      <map code="0xcb6f" name="1em"/><!-- HANGUL SYLLABLE JJWEOLB -->
+      <map code="0xcb70" name="1em"/><!-- HANGUL SYLLABLE JJWEOLS -->
+      <map code="0xcb71" name="1em"/><!-- HANGUL SYLLABLE JJWEOLT -->
+      <map code="0xcb72" name="1em"/><!-- HANGUL SYLLABLE JJWEOLP -->
+      <map code="0xcb73" name="1em"/><!-- HANGUL SYLLABLE JJWEOLH -->
+      <map code="0xcb74" name="1em"/><!-- HANGUL SYLLABLE JJWEOM -->
+      <map code="0xcb75" name="1em"/><!-- HANGUL SYLLABLE JJWEOB -->
+      <map code="0xcb76" name="1em"/><!-- HANGUL SYLLABLE JJWEOBS -->
+      <map code="0xcb77" name="1em"/><!-- HANGUL SYLLABLE JJWEOS -->
+      <map code="0xcb78" name="1em"/><!-- HANGUL SYLLABLE JJWEOSS -->
+      <map code="0xcb79" name="1em"/><!-- HANGUL SYLLABLE JJWEONG -->
+      <map code="0xcb7a" name="1em"/><!-- HANGUL SYLLABLE JJWEOJ -->
+      <map code="0xcb7b" name="1em"/><!-- HANGUL SYLLABLE JJWEOC -->
+      <map code="0xcb7c" name="1em"/><!-- HANGUL SYLLABLE JJWEOK -->
+      <map code="0xcb7d" name="1em"/><!-- HANGUL SYLLABLE JJWEOT -->
+      <map code="0xcb7e" name="1em"/><!-- HANGUL SYLLABLE JJWEOP -->
+      <map code="0xcb7f" name="1em"/><!-- HANGUL SYLLABLE JJWEOH -->
+      <map code="0xcb80" name="1em"/><!-- HANGUL SYLLABLE JJWE -->
+      <map code="0xcb81" name="1em"/><!-- HANGUL SYLLABLE JJWEG -->
+      <map code="0xcb82" name="1em"/><!-- HANGUL SYLLABLE JJWEGG -->
+      <map code="0xcb83" name="1em"/><!-- HANGUL SYLLABLE JJWEGS -->
+      <map code="0xcb84" name="1em"/><!-- HANGUL SYLLABLE JJWEN -->
+      <map code="0xcb85" name="1em"/><!-- HANGUL SYLLABLE JJWENJ -->
+      <map code="0xcb86" name="1em"/><!-- HANGUL SYLLABLE JJWENH -->
+      <map code="0xcb87" name="1em"/><!-- HANGUL SYLLABLE JJWED -->
+      <map code="0xcb88" name="1em"/><!-- HANGUL SYLLABLE JJWEL -->
+      <map code="0xcb89" name="1em"/><!-- HANGUL SYLLABLE JJWELG -->
+      <map code="0xcb8a" name="1em"/><!-- HANGUL SYLLABLE JJWELM -->
+      <map code="0xcb8b" name="1em"/><!-- HANGUL SYLLABLE JJWELB -->
+      <map code="0xcb8c" name="1em"/><!-- HANGUL SYLLABLE JJWELS -->
+      <map code="0xcb8d" name="1em"/><!-- HANGUL SYLLABLE JJWELT -->
+      <map code="0xcb8e" name="1em"/><!-- HANGUL SYLLABLE JJWELP -->
+      <map code="0xcb8f" name="1em"/><!-- HANGUL SYLLABLE JJWELH -->
+      <map code="0xcb90" name="1em"/><!-- HANGUL SYLLABLE JJWEM -->
+      <map code="0xcb91" name="1em"/><!-- HANGUL SYLLABLE JJWEB -->
+      <map code="0xcb92" name="1em"/><!-- HANGUL SYLLABLE JJWEBS -->
+      <map code="0xcb93" name="1em"/><!-- HANGUL SYLLABLE JJWES -->
+      <map code="0xcb94" name="1em"/><!-- HANGUL SYLLABLE JJWESS -->
+      <map code="0xcb95" name="1em"/><!-- HANGUL SYLLABLE JJWENG -->
+      <map code="0xcb96" name="1em"/><!-- HANGUL SYLLABLE JJWEJ -->
+      <map code="0xcb97" name="1em"/><!-- HANGUL SYLLABLE JJWEC -->
+      <map code="0xcb98" name="1em"/><!-- HANGUL SYLLABLE JJWEK -->
+      <map code="0xcb99" name="1em"/><!-- HANGUL SYLLABLE JJWET -->
+      <map code="0xcb9a" name="1em"/><!-- HANGUL SYLLABLE JJWEP -->
+      <map code="0xcb9b" name="1em"/><!-- HANGUL SYLLABLE JJWEH -->
+      <map code="0xcb9c" name="1em"/><!-- HANGUL SYLLABLE JJWI -->
+      <map code="0xcb9d" name="1em"/><!-- HANGUL SYLLABLE JJWIG -->
+      <map code="0xcb9e" name="1em"/><!-- HANGUL SYLLABLE JJWIGG -->
+      <map code="0xcb9f" name="1em"/><!-- HANGUL SYLLABLE JJWIGS -->
+      <map code="0xcba0" name="1em"/><!-- HANGUL SYLLABLE JJWIN -->
+      <map code="0xcba1" name="1em"/><!-- HANGUL SYLLABLE JJWINJ -->
+      <map code="0xcba2" name="1em"/><!-- HANGUL SYLLABLE JJWINH -->
+      <map code="0xcba3" name="1em"/><!-- HANGUL SYLLABLE JJWID -->
+      <map code="0xcba4" name="1em"/><!-- HANGUL SYLLABLE JJWIL -->
+      <map code="0xcba5" name="1em"/><!-- HANGUL SYLLABLE JJWILG -->
+      <map code="0xcba6" name="1em"/><!-- HANGUL SYLLABLE JJWILM -->
+      <map code="0xcba7" name="1em"/><!-- HANGUL SYLLABLE JJWILB -->
+      <map code="0xcba8" name="1em"/><!-- HANGUL SYLLABLE JJWILS -->
+      <map code="0xcba9" name="1em"/><!-- HANGUL SYLLABLE JJWILT -->
+      <map code="0xcbaa" name="1em"/><!-- HANGUL SYLLABLE JJWILP -->
+      <map code="0xcbab" name="1em"/><!-- HANGUL SYLLABLE JJWILH -->
+      <map code="0xcbac" name="1em"/><!-- HANGUL SYLLABLE JJWIM -->
+      <map code="0xcbad" name="1em"/><!-- HANGUL SYLLABLE JJWIB -->
+      <map code="0xcbae" name="1em"/><!-- HANGUL SYLLABLE JJWIBS -->
+      <map code="0xcbaf" name="1em"/><!-- HANGUL SYLLABLE JJWIS -->
+      <map code="0xcbb0" name="1em"/><!-- HANGUL SYLLABLE JJWISS -->
+      <map code="0xcbb1" name="1em"/><!-- HANGUL SYLLABLE JJWING -->
+      <map code="0xcbb2" name="1em"/><!-- HANGUL SYLLABLE JJWIJ -->
+      <map code="0xcbb3" name="1em"/><!-- HANGUL SYLLABLE JJWIC -->
+      <map code="0xcbb4" name="1em"/><!-- HANGUL SYLLABLE JJWIK -->
+      <map code="0xcbb5" name="1em"/><!-- HANGUL SYLLABLE JJWIT -->
+      <map code="0xcbb6" name="1em"/><!-- HANGUL SYLLABLE JJWIP -->
+      <map code="0xcbb7" name="1em"/><!-- HANGUL SYLLABLE JJWIH -->
+      <map code="0xcbb8" name="1em"/><!-- HANGUL SYLLABLE JJYU -->
+      <map code="0xcbb9" name="1em"/><!-- HANGUL SYLLABLE JJYUG -->
+      <map code="0xcbba" name="1em"/><!-- HANGUL SYLLABLE JJYUGG -->
+      <map code="0xcbbb" name="1em"/><!-- HANGUL SYLLABLE JJYUGS -->
+      <map code="0xcbbc" name="1em"/><!-- HANGUL SYLLABLE JJYUN -->
+      <map code="0xcbbd" name="1em"/><!-- HANGUL SYLLABLE JJYUNJ -->
+      <map code="0xcbbe" name="1em"/><!-- HANGUL SYLLABLE JJYUNH -->
+      <map code="0xcbbf" name="1em"/><!-- HANGUL SYLLABLE JJYUD -->
+      <map code="0xcbc0" name="1em"/><!-- HANGUL SYLLABLE JJYUL -->
+      <map code="0xcbc1" name="1em"/><!-- HANGUL SYLLABLE JJYULG -->
+      <map code="0xcbc2" name="1em"/><!-- HANGUL SYLLABLE JJYULM -->
+      <map code="0xcbc3" name="1em"/><!-- HANGUL SYLLABLE JJYULB -->
+      <map code="0xcbc4" name="1em"/><!-- HANGUL SYLLABLE JJYULS -->
+      <map code="0xcbc5" name="1em"/><!-- HANGUL SYLLABLE JJYULT -->
+      <map code="0xcbc6" name="1em"/><!-- HANGUL SYLLABLE JJYULP -->
+      <map code="0xcbc7" name="1em"/><!-- HANGUL SYLLABLE JJYULH -->
+      <map code="0xcbc8" name="1em"/><!-- HANGUL SYLLABLE JJYUM -->
+      <map code="0xcbc9" name="1em"/><!-- HANGUL SYLLABLE JJYUB -->
+      <map code="0xcbca" name="1em"/><!-- HANGUL SYLLABLE JJYUBS -->
+      <map code="0xcbcb" name="1em"/><!-- HANGUL SYLLABLE JJYUS -->
+      <map code="0xcbcc" name="1em"/><!-- HANGUL SYLLABLE JJYUSS -->
+      <map code="0xcbcd" name="1em"/><!-- HANGUL SYLLABLE JJYUNG -->
+      <map code="0xcbce" name="1em"/><!-- HANGUL SYLLABLE JJYUJ -->
+      <map code="0xcbcf" name="1em"/><!-- HANGUL SYLLABLE JJYUC -->
+      <map code="0xcbd0" name="1em"/><!-- HANGUL SYLLABLE JJYUK -->
+      <map code="0xcbd1" name="1em"/><!-- HANGUL SYLLABLE JJYUT -->
+      <map code="0xcbd2" name="1em"/><!-- HANGUL SYLLABLE JJYUP -->
+      <map code="0xcbd3" name="1em"/><!-- HANGUL SYLLABLE JJYUH -->
+      <map code="0xcbd4" name="1em"/><!-- HANGUL SYLLABLE JJEU -->
+      <map code="0xcbd5" name="1em"/><!-- HANGUL SYLLABLE JJEUG -->
+      <map code="0xcbd6" name="1em"/><!-- HANGUL SYLLABLE JJEUGG -->
+      <map code="0xcbd7" name="1em"/><!-- HANGUL SYLLABLE JJEUGS -->
+      <map code="0xcbd8" name="1em"/><!-- HANGUL SYLLABLE JJEUN -->
+      <map code="0xcbd9" name="1em"/><!-- HANGUL SYLLABLE JJEUNJ -->
+      <map code="0xcbda" name="1em"/><!-- HANGUL SYLLABLE JJEUNH -->
+      <map code="0xcbdb" name="1em"/><!-- HANGUL SYLLABLE JJEUD -->
+      <map code="0xcbdc" name="1em"/><!-- HANGUL SYLLABLE JJEUL -->
+      <map code="0xcbdd" name="1em"/><!-- HANGUL SYLLABLE JJEULG -->
+      <map code="0xcbde" name="1em"/><!-- HANGUL SYLLABLE JJEULM -->
+      <map code="0xcbdf" name="1em"/><!-- HANGUL SYLLABLE JJEULB -->
+      <map code="0xcbe0" name="1em"/><!-- HANGUL SYLLABLE JJEULS -->
+      <map code="0xcbe1" name="1em"/><!-- HANGUL SYLLABLE JJEULT -->
+      <map code="0xcbe2" name="1em"/><!-- HANGUL SYLLABLE JJEULP -->
+      <map code="0xcbe3" name="1em"/><!-- HANGUL SYLLABLE JJEULH -->
+      <map code="0xcbe4" name="1em"/><!-- HANGUL SYLLABLE JJEUM -->
+      <map code="0xcbe5" name="1em"/><!-- HANGUL SYLLABLE JJEUB -->
+      <map code="0xcbe6" name="1em"/><!-- HANGUL SYLLABLE JJEUBS -->
+      <map code="0xcbe7" name="1em"/><!-- HANGUL SYLLABLE JJEUS -->
+      <map code="0xcbe8" name="1em"/><!-- HANGUL SYLLABLE JJEUSS -->
+      <map code="0xcbe9" name="1em"/><!-- HANGUL SYLLABLE JJEUNG -->
+      <map code="0xcbea" name="1em"/><!-- HANGUL SYLLABLE JJEUJ -->
+      <map code="0xcbeb" name="1em"/><!-- HANGUL SYLLABLE JJEUC -->
+      <map code="0xcbec" name="1em"/><!-- HANGUL SYLLABLE JJEUK -->
+      <map code="0xcbed" name="1em"/><!-- HANGUL SYLLABLE JJEUT -->
+      <map code="0xcbee" name="1em"/><!-- HANGUL SYLLABLE JJEUP -->
+      <map code="0xcbef" name="1em"/><!-- HANGUL SYLLABLE JJEUH -->
+      <map code="0xcbf0" name="1em"/><!-- HANGUL SYLLABLE JJYI -->
+      <map code="0xcbf1" name="1em"/><!-- HANGUL SYLLABLE JJYIG -->
+      <map code="0xcbf2" name="1em"/><!-- HANGUL SYLLABLE JJYIGG -->
+      <map code="0xcbf3" name="1em"/><!-- HANGUL SYLLABLE JJYIGS -->
+      <map code="0xcbf4" name="1em"/><!-- HANGUL SYLLABLE JJYIN -->
+      <map code="0xcbf5" name="1em"/><!-- HANGUL SYLLABLE JJYINJ -->
+      <map code="0xcbf6" name="1em"/><!-- HANGUL SYLLABLE JJYINH -->
+      <map code="0xcbf7" name="1em"/><!-- HANGUL SYLLABLE JJYID -->
+      <map code="0xcbf8" name="1em"/><!-- HANGUL SYLLABLE JJYIL -->
+      <map code="0xcbf9" name="1em"/><!-- HANGUL SYLLABLE JJYILG -->
+      <map code="0xcbfa" name="1em"/><!-- HANGUL SYLLABLE JJYILM -->
+      <map code="0xcbfb" name="1em"/><!-- HANGUL SYLLABLE JJYILB -->
+      <map code="0xcbfc" name="1em"/><!-- HANGUL SYLLABLE JJYILS -->
+      <map code="0xcbfd" name="1em"/><!-- HANGUL SYLLABLE JJYILT -->
+      <map code="0xcbfe" name="1em"/><!-- HANGUL SYLLABLE JJYILP -->
+      <map code="0xcbff" name="1em"/><!-- HANGUL SYLLABLE JJYILH -->
+      <map code="0xcc00" name="1em"/><!-- HANGUL SYLLABLE JJYIM -->
+      <map code="0xcc01" name="1em"/><!-- HANGUL SYLLABLE JJYIB -->
+      <map code="0xcc02" name="1em"/><!-- HANGUL SYLLABLE JJYIBS -->
+      <map code="0xcc03" name="1em"/><!-- HANGUL SYLLABLE JJYIS -->
+      <map code="0xcc04" name="1em"/><!-- HANGUL SYLLABLE JJYISS -->
+      <map code="0xcc05" name="1em"/><!-- HANGUL SYLLABLE JJYING -->
+      <map code="0xcc06" name="1em"/><!-- HANGUL SYLLABLE JJYIJ -->
+      <map code="0xcc07" name="1em"/><!-- HANGUL SYLLABLE JJYIC -->
+      <map code="0xcc08" name="1em"/><!-- HANGUL SYLLABLE JJYIK -->
+      <map code="0xcc09" name="1em"/><!-- HANGUL SYLLABLE JJYIT -->
+      <map code="0xcc0a" name="1em"/><!-- HANGUL SYLLABLE JJYIP -->
+      <map code="0xcc0b" name="1em"/><!-- HANGUL SYLLABLE JJYIH -->
+      <map code="0xcc0c" name="1em"/><!-- HANGUL SYLLABLE JJI -->
+      <map code="0xcc0d" name="1em"/><!-- HANGUL SYLLABLE JJIG -->
+      <map code="0xcc0e" name="1em"/><!-- HANGUL SYLLABLE JJIGG -->
+      <map code="0xcc0f" name="1em"/><!-- HANGUL SYLLABLE JJIGS -->
+      <map code="0xcc10" name="1em"/><!-- HANGUL SYLLABLE JJIN -->
+      <map code="0xcc11" name="1em"/><!-- HANGUL SYLLABLE JJINJ -->
+      <map code="0xcc12" name="1em"/><!-- HANGUL SYLLABLE JJINH -->
+      <map code="0xcc13" name="1em"/><!-- HANGUL SYLLABLE JJID -->
+      <map code="0xcc14" name="1em"/><!-- HANGUL SYLLABLE JJIL -->
+      <map code="0xcc15" name="1em"/><!-- HANGUL SYLLABLE JJILG -->
+      <map code="0xcc16" name="1em"/><!-- HANGUL SYLLABLE JJILM -->
+      <map code="0xcc17" name="1em"/><!-- HANGUL SYLLABLE JJILB -->
+      <map code="0xcc18" name="1em"/><!-- HANGUL SYLLABLE JJILS -->
+      <map code="0xcc19" name="1em"/><!-- HANGUL SYLLABLE JJILT -->
+      <map code="0xcc1a" name="1em"/><!-- HANGUL SYLLABLE JJILP -->
+      <map code="0xcc1b" name="1em"/><!-- HANGUL SYLLABLE JJILH -->
+      <map code="0xcc1c" name="1em"/><!-- HANGUL SYLLABLE JJIM -->
+      <map code="0xcc1d" name="1em"/><!-- HANGUL SYLLABLE JJIB -->
+      <map code="0xcc1e" name="1em"/><!-- HANGUL SYLLABLE JJIBS -->
+      <map code="0xcc1f" name="1em"/><!-- HANGUL SYLLABLE JJIS -->
+      <map code="0xcc20" name="1em"/><!-- HANGUL SYLLABLE JJISS -->
+      <map code="0xcc21" name="1em"/><!-- HANGUL SYLLABLE JJING -->
+      <map code="0xcc22" name="1em"/><!-- HANGUL SYLLABLE JJIJ -->
+      <map code="0xcc23" name="1em"/><!-- HANGUL SYLLABLE JJIC -->
+      <map code="0xcc24" name="1em"/><!-- HANGUL SYLLABLE JJIK -->
+      <map code="0xcc25" name="1em"/><!-- HANGUL SYLLABLE JJIT -->
+      <map code="0xcc26" name="1em"/><!-- HANGUL SYLLABLE JJIP -->
+      <map code="0xcc27" name="1em"/><!-- HANGUL SYLLABLE JJIH -->
+      <map code="0xcc28" name="1em"/><!-- HANGUL SYLLABLE CA -->
+      <map code="0xcc29" name="1em"/><!-- HANGUL SYLLABLE CAG -->
+      <map code="0xcc2a" name="1em"/><!-- HANGUL SYLLABLE CAGG -->
+      <map code="0xcc2b" name="1em"/><!-- HANGUL SYLLABLE CAGS -->
+      <map code="0xcc2c" name="1em"/><!-- HANGUL SYLLABLE CAN -->
+      <map code="0xcc2d" name="1em"/><!-- HANGUL SYLLABLE CANJ -->
+      <map code="0xcc2e" name="1em"/><!-- HANGUL SYLLABLE CANH -->
+      <map code="0xcc2f" name="1em"/><!-- HANGUL SYLLABLE CAD -->
+      <map code="0xcc30" name="1em"/><!-- HANGUL SYLLABLE CAL -->
+      <map code="0xcc31" name="1em"/><!-- HANGUL SYLLABLE CALG -->
+      <map code="0xcc32" name="1em"/><!-- HANGUL SYLLABLE CALM -->
+      <map code="0xcc33" name="1em"/><!-- HANGUL SYLLABLE CALB -->
+      <map code="0xcc34" name="1em"/><!-- HANGUL SYLLABLE CALS -->
+      <map code="0xcc35" name="1em"/><!-- HANGUL SYLLABLE CALT -->
+      <map code="0xcc36" name="1em"/><!-- HANGUL SYLLABLE CALP -->
+      <map code="0xcc37" name="1em"/><!-- HANGUL SYLLABLE CALH -->
+      <map code="0xcc38" name="1em"/><!-- HANGUL SYLLABLE CAM -->
+      <map code="0xcc39" name="1em"/><!-- HANGUL SYLLABLE CAB -->
+      <map code="0xcc3a" name="1em"/><!-- HANGUL SYLLABLE CABS -->
+      <map code="0xcc3b" name="1em"/><!-- HANGUL SYLLABLE CAS -->
+      <map code="0xcc3c" name="1em"/><!-- HANGUL SYLLABLE CASS -->
+      <map code="0xcc3d" name="1em"/><!-- HANGUL SYLLABLE CANG -->
+      <map code="0xcc3e" name="1em"/><!-- HANGUL SYLLABLE CAJ -->
+      <map code="0xcc3f" name="1em"/><!-- HANGUL SYLLABLE CAC -->
+      <map code="0xcc40" name="1em"/><!-- HANGUL SYLLABLE CAK -->
+      <map code="0xcc41" name="1em"/><!-- HANGUL SYLLABLE CAT -->
+      <map code="0xcc42" name="1em"/><!-- HANGUL SYLLABLE CAP -->
+      <map code="0xcc43" name="1em"/><!-- HANGUL SYLLABLE CAH -->
+      <map code="0xcc44" name="1em"/><!-- HANGUL SYLLABLE CAE -->
+      <map code="0xcc45" name="1em"/><!-- HANGUL SYLLABLE CAEG -->
+      <map code="0xcc46" name="1em"/><!-- HANGUL SYLLABLE CAEGG -->
+      <map code="0xcc47" name="1em"/><!-- HANGUL SYLLABLE CAEGS -->
+      <map code="0xcc48" name="1em"/><!-- HANGUL SYLLABLE CAEN -->
+      <map code="0xcc49" name="1em"/><!-- HANGUL SYLLABLE CAENJ -->
+      <map code="0xcc4a" name="1em"/><!-- HANGUL SYLLABLE CAENH -->
+      <map code="0xcc4b" name="1em"/><!-- HANGUL SYLLABLE CAED -->
+      <map code="0xcc4c" name="1em"/><!-- HANGUL SYLLABLE CAEL -->
+      <map code="0xcc4d" name="1em"/><!-- HANGUL SYLLABLE CAELG -->
+      <map code="0xcc4e" name="1em"/><!-- HANGUL SYLLABLE CAELM -->
+      <map code="0xcc4f" name="1em"/><!-- HANGUL SYLLABLE CAELB -->
+      <map code="0xcc50" name="1em"/><!-- HANGUL SYLLABLE CAELS -->
+      <map code="0xcc51" name="1em"/><!-- HANGUL SYLLABLE CAELT -->
+      <map code="0xcc52" name="1em"/><!-- HANGUL SYLLABLE CAELP -->
+      <map code="0xcc53" name="1em"/><!-- HANGUL SYLLABLE CAELH -->
+      <map code="0xcc54" name="1em"/><!-- HANGUL SYLLABLE CAEM -->
+      <map code="0xcc55" name="1em"/><!-- HANGUL SYLLABLE CAEB -->
+      <map code="0xcc56" name="1em"/><!-- HANGUL SYLLABLE CAEBS -->
+      <map code="0xcc57" name="1em"/><!-- HANGUL SYLLABLE CAES -->
+      <map code="0xcc58" name="1em"/><!-- HANGUL SYLLABLE CAESS -->
+      <map code="0xcc59" name="1em"/><!-- HANGUL SYLLABLE CAENG -->
+      <map code="0xcc5a" name="1em"/><!-- HANGUL SYLLABLE CAEJ -->
+      <map code="0xcc5b" name="1em"/><!-- HANGUL SYLLABLE CAEC -->
+      <map code="0xcc5c" name="1em"/><!-- HANGUL SYLLABLE CAEK -->
+      <map code="0xcc5d" name="1em"/><!-- HANGUL SYLLABLE CAET -->
+      <map code="0xcc5e" name="1em"/><!-- HANGUL SYLLABLE CAEP -->
+      <map code="0xcc5f" name="1em"/><!-- HANGUL SYLLABLE CAEH -->
+      <map code="0xcc60" name="1em"/><!-- HANGUL SYLLABLE CYA -->
+      <map code="0xcc61" name="1em"/><!-- HANGUL SYLLABLE CYAG -->
+      <map code="0xcc62" name="1em"/><!-- HANGUL SYLLABLE CYAGG -->
+      <map code="0xcc63" name="1em"/><!-- HANGUL SYLLABLE CYAGS -->
+      <map code="0xcc64" name="1em"/><!-- HANGUL SYLLABLE CYAN -->
+      <map code="0xcc65" name="1em"/><!-- HANGUL SYLLABLE CYANJ -->
+      <map code="0xcc66" name="1em"/><!-- HANGUL SYLLABLE CYANH -->
+      <map code="0xcc67" name="1em"/><!-- HANGUL SYLLABLE CYAD -->
+      <map code="0xcc68" name="1em"/><!-- HANGUL SYLLABLE CYAL -->
+      <map code="0xcc69" name="1em"/><!-- HANGUL SYLLABLE CYALG -->
+      <map code="0xcc6a" name="1em"/><!-- HANGUL SYLLABLE CYALM -->
+      <map code="0xcc6b" name="1em"/><!-- HANGUL SYLLABLE CYALB -->
+      <map code="0xcc6c" name="1em"/><!-- HANGUL SYLLABLE CYALS -->
+      <map code="0xcc6d" name="1em"/><!-- HANGUL SYLLABLE CYALT -->
+      <map code="0xcc6e" name="1em"/><!-- HANGUL SYLLABLE CYALP -->
+      <map code="0xcc6f" name="1em"/><!-- HANGUL SYLLABLE CYALH -->
+      <map code="0xcc70" name="1em"/><!-- HANGUL SYLLABLE CYAM -->
+      <map code="0xcc71" name="1em"/><!-- HANGUL SYLLABLE CYAB -->
+      <map code="0xcc72" name="1em"/><!-- HANGUL SYLLABLE CYABS -->
+      <map code="0xcc73" name="1em"/><!-- HANGUL SYLLABLE CYAS -->
+      <map code="0xcc74" name="1em"/><!-- HANGUL SYLLABLE CYASS -->
+      <map code="0xcc75" name="1em"/><!-- HANGUL SYLLABLE CYANG -->
+      <map code="0xcc76" name="1em"/><!-- HANGUL SYLLABLE CYAJ -->
+      <map code="0xcc77" name="1em"/><!-- HANGUL SYLLABLE CYAC -->
+      <map code="0xcc78" name="1em"/><!-- HANGUL SYLLABLE CYAK -->
+      <map code="0xcc79" name="1em"/><!-- HANGUL SYLLABLE CYAT -->
+      <map code="0xcc7a" name="1em"/><!-- HANGUL SYLLABLE CYAP -->
+      <map code="0xcc7b" name="1em"/><!-- HANGUL SYLLABLE CYAH -->
+      <map code="0xcc7c" name="1em"/><!-- HANGUL SYLLABLE CYAE -->
+      <map code="0xcc7d" name="1em"/><!-- HANGUL SYLLABLE CYAEG -->
+      <map code="0xcc7e" name="1em"/><!-- HANGUL SYLLABLE CYAEGG -->
+      <map code="0xcc7f" name="1em"/><!-- HANGUL SYLLABLE CYAEGS -->
+      <map code="0xcc80" name="1em"/><!-- HANGUL SYLLABLE CYAEN -->
+      <map code="0xcc81" name="1em"/><!-- HANGUL SYLLABLE CYAENJ -->
+      <map code="0xcc82" name="1em"/><!-- HANGUL SYLLABLE CYAENH -->
+      <map code="0xcc83" name="1em"/><!-- HANGUL SYLLABLE CYAED -->
+      <map code="0xcc84" name="1em"/><!-- HANGUL SYLLABLE CYAEL -->
+      <map code="0xcc85" name="1em"/><!-- HANGUL SYLLABLE CYAELG -->
+      <map code="0xcc86" name="1em"/><!-- HANGUL SYLLABLE CYAELM -->
+      <map code="0xcc87" name="1em"/><!-- HANGUL SYLLABLE CYAELB -->
+      <map code="0xcc88" name="1em"/><!-- HANGUL SYLLABLE CYAELS -->
+      <map code="0xcc89" name="1em"/><!-- HANGUL SYLLABLE CYAELT -->
+      <map code="0xcc8a" name="1em"/><!-- HANGUL SYLLABLE CYAELP -->
+      <map code="0xcc8b" name="1em"/><!-- HANGUL SYLLABLE CYAELH -->
+      <map code="0xcc8c" name="1em"/><!-- HANGUL SYLLABLE CYAEM -->
+      <map code="0xcc8d" name="1em"/><!-- HANGUL SYLLABLE CYAEB -->
+      <map code="0xcc8e" name="1em"/><!-- HANGUL SYLLABLE CYAEBS -->
+      <map code="0xcc8f" name="1em"/><!-- HANGUL SYLLABLE CYAES -->
+      <map code="0xcc90" name="1em"/><!-- HANGUL SYLLABLE CYAESS -->
+      <map code="0xcc91" name="1em"/><!-- HANGUL SYLLABLE CYAENG -->
+      <map code="0xcc92" name="1em"/><!-- HANGUL SYLLABLE CYAEJ -->
+      <map code="0xcc93" name="1em"/><!-- HANGUL SYLLABLE CYAEC -->
+      <map code="0xcc94" name="1em"/><!-- HANGUL SYLLABLE CYAEK -->
+      <map code="0xcc95" name="1em"/><!-- HANGUL SYLLABLE CYAET -->
+      <map code="0xcc96" name="1em"/><!-- HANGUL SYLLABLE CYAEP -->
+      <map code="0xcc97" name="1em"/><!-- HANGUL SYLLABLE CYAEH -->
+      <map code="0xcc98" name="1em"/><!-- HANGUL SYLLABLE CEO -->
+      <map code="0xcc99" name="1em"/><!-- HANGUL SYLLABLE CEOG -->
+      <map code="0xcc9a" name="1em"/><!-- HANGUL SYLLABLE CEOGG -->
+      <map code="0xcc9b" name="1em"/><!-- HANGUL SYLLABLE CEOGS -->
+      <map code="0xcc9c" name="1em"/><!-- HANGUL SYLLABLE CEON -->
+      <map code="0xcc9d" name="1em"/><!-- HANGUL SYLLABLE CEONJ -->
+      <map code="0xcc9e" name="1em"/><!-- HANGUL SYLLABLE CEONH -->
+      <map code="0xcc9f" name="1em"/><!-- HANGUL SYLLABLE CEOD -->
+      <map code="0xcca0" name="1em"/><!-- HANGUL SYLLABLE CEOL -->
+      <map code="0xcca1" name="1em"/><!-- HANGUL SYLLABLE CEOLG -->
+      <map code="0xcca2" name="1em"/><!-- HANGUL SYLLABLE CEOLM -->
+      <map code="0xcca3" name="1em"/><!-- HANGUL SYLLABLE CEOLB -->
+      <map code="0xcca4" name="1em"/><!-- HANGUL SYLLABLE CEOLS -->
+      <map code="0xcca5" name="1em"/><!-- HANGUL SYLLABLE CEOLT -->
+      <map code="0xcca6" name="1em"/><!-- HANGUL SYLLABLE CEOLP -->
+      <map code="0xcca7" name="1em"/><!-- HANGUL SYLLABLE CEOLH -->
+      <map code="0xcca8" name="1em"/><!-- HANGUL SYLLABLE CEOM -->
+      <map code="0xcca9" name="1em"/><!-- HANGUL SYLLABLE CEOB -->
+      <map code="0xccaa" name="1em"/><!-- HANGUL SYLLABLE CEOBS -->
+      <map code="0xccab" name="1em"/><!-- HANGUL SYLLABLE CEOS -->
+      <map code="0xccac" name="1em"/><!-- HANGUL SYLLABLE CEOSS -->
+      <map code="0xccad" name="1em"/><!-- HANGUL SYLLABLE CEONG -->
+      <map code="0xccae" name="1em"/><!-- HANGUL SYLLABLE CEOJ -->
+      <map code="0xccaf" name="1em"/><!-- HANGUL SYLLABLE CEOC -->
+      <map code="0xccb0" name="1em"/><!-- HANGUL SYLLABLE CEOK -->
+      <map code="0xccb1" name="1em"/><!-- HANGUL SYLLABLE CEOT -->
+      <map code="0xccb2" name="1em"/><!-- HANGUL SYLLABLE CEOP -->
+      <map code="0xccb3" name="1em"/><!-- HANGUL SYLLABLE CEOH -->
+      <map code="0xccb4" name="1em"/><!-- HANGUL SYLLABLE CE -->
+      <map code="0xccb5" name="1em"/><!-- HANGUL SYLLABLE CEG -->
+      <map code="0xccb6" name="1em"/><!-- HANGUL SYLLABLE CEGG -->
+      <map code="0xccb7" name="1em"/><!-- HANGUL SYLLABLE CEGS -->
+      <map code="0xccb8" name="1em"/><!-- HANGUL SYLLABLE CEN -->
+      <map code="0xccb9" name="1em"/><!-- HANGUL SYLLABLE CENJ -->
+      <map code="0xccba" name="1em"/><!-- HANGUL SYLLABLE CENH -->
+      <map code="0xccbb" name="1em"/><!-- HANGUL SYLLABLE CED -->
+      <map code="0xccbc" name="1em"/><!-- HANGUL SYLLABLE CEL -->
+      <map code="0xccbd" name="1em"/><!-- HANGUL SYLLABLE CELG -->
+      <map code="0xccbe" name="1em"/><!-- HANGUL SYLLABLE CELM -->
+      <map code="0xccbf" name="1em"/><!-- HANGUL SYLLABLE CELB -->
+      <map code="0xccc0" name="1em"/><!-- HANGUL SYLLABLE CELS -->
+      <map code="0xccc1" name="1em"/><!-- HANGUL SYLLABLE CELT -->
+      <map code="0xccc2" name="1em"/><!-- HANGUL SYLLABLE CELP -->
+      <map code="0xccc3" name="1em"/><!-- HANGUL SYLLABLE CELH -->
+      <map code="0xccc4" name="1em"/><!-- HANGUL SYLLABLE CEM -->
+      <map code="0xccc5" name="1em"/><!-- HANGUL SYLLABLE CEB -->
+      <map code="0xccc6" name="1em"/><!-- HANGUL SYLLABLE CEBS -->
+      <map code="0xccc7" name="1em"/><!-- HANGUL SYLLABLE CES -->
+      <map code="0xccc8" name="1em"/><!-- HANGUL SYLLABLE CESS -->
+      <map code="0xccc9" name="1em"/><!-- HANGUL SYLLABLE CENG -->
+      <map code="0xccca" name="1em"/><!-- HANGUL SYLLABLE CEJ -->
+      <map code="0xcccb" name="1em"/><!-- HANGUL SYLLABLE CEC -->
+      <map code="0xcccc" name="1em"/><!-- HANGUL SYLLABLE CEK -->
+      <map code="0xcccd" name="1em"/><!-- HANGUL SYLLABLE CET -->
+      <map code="0xccce" name="1em"/><!-- HANGUL SYLLABLE CEP -->
+      <map code="0xcccf" name="1em"/><!-- HANGUL SYLLABLE CEH -->
+      <map code="0xccd0" name="1em"/><!-- HANGUL SYLLABLE CYEO -->
+      <map code="0xccd1" name="1em"/><!-- HANGUL SYLLABLE CYEOG -->
+      <map code="0xccd2" name="1em"/><!-- HANGUL SYLLABLE CYEOGG -->
+      <map code="0xccd3" name="1em"/><!-- HANGUL SYLLABLE CYEOGS -->
+      <map code="0xccd4" name="1em"/><!-- HANGUL SYLLABLE CYEON -->
+      <map code="0xccd5" name="1em"/><!-- HANGUL SYLLABLE CYEONJ -->
+      <map code="0xccd6" name="1em"/><!-- HANGUL SYLLABLE CYEONH -->
+      <map code="0xccd7" name="1em"/><!-- HANGUL SYLLABLE CYEOD -->
+      <map code="0xccd8" name="1em"/><!-- HANGUL SYLLABLE CYEOL -->
+      <map code="0xccd9" name="1em"/><!-- HANGUL SYLLABLE CYEOLG -->
+      <map code="0xccda" name="1em"/><!-- HANGUL SYLLABLE CYEOLM -->
+      <map code="0xccdb" name="1em"/><!-- HANGUL SYLLABLE CYEOLB -->
+      <map code="0xccdc" name="1em"/><!-- HANGUL SYLLABLE CYEOLS -->
+      <map code="0xccdd" name="1em"/><!-- HANGUL SYLLABLE CYEOLT -->
+      <map code="0xccde" name="1em"/><!-- HANGUL SYLLABLE CYEOLP -->
+      <map code="0xccdf" name="1em"/><!-- HANGUL SYLLABLE CYEOLH -->
+      <map code="0xcce0" name="1em"/><!-- HANGUL SYLLABLE CYEOM -->
+      <map code="0xcce1" name="1em"/><!-- HANGUL SYLLABLE CYEOB -->
+      <map code="0xcce2" name="1em"/><!-- HANGUL SYLLABLE CYEOBS -->
+      <map code="0xcce3" name="1em"/><!-- HANGUL SYLLABLE CYEOS -->
+      <map code="0xcce4" name="1em"/><!-- HANGUL SYLLABLE CYEOSS -->
+      <map code="0xcce5" name="1em"/><!-- HANGUL SYLLABLE CYEONG -->
+      <map code="0xcce6" name="1em"/><!-- HANGUL SYLLABLE CYEOJ -->
+      <map code="0xcce7" name="1em"/><!-- HANGUL SYLLABLE CYEOC -->
+      <map code="0xcce8" name="1em"/><!-- HANGUL SYLLABLE CYEOK -->
+      <map code="0xcce9" name="1em"/><!-- HANGUL SYLLABLE CYEOT -->
+      <map code="0xccea" name="1em"/><!-- HANGUL SYLLABLE CYEOP -->
+      <map code="0xcceb" name="1em"/><!-- HANGUL SYLLABLE CYEOH -->
+      <map code="0xccec" name="1em"/><!-- HANGUL SYLLABLE CYE -->
+      <map code="0xcced" name="1em"/><!-- HANGUL SYLLABLE CYEG -->
+      <map code="0xccee" name="1em"/><!-- HANGUL SYLLABLE CYEGG -->
+      <map code="0xccef" name="1em"/><!-- HANGUL SYLLABLE CYEGS -->
+      <map code="0xccf0" name="1em"/><!-- HANGUL SYLLABLE CYEN -->
+      <map code="0xccf1" name="1em"/><!-- HANGUL SYLLABLE CYENJ -->
+      <map code="0xccf2" name="1em"/><!-- HANGUL SYLLABLE CYENH -->
+      <map code="0xccf3" name="1em"/><!-- HANGUL SYLLABLE CYED -->
+      <map code="0xccf4" name="1em"/><!-- HANGUL SYLLABLE CYEL -->
+      <map code="0xccf5" name="1em"/><!-- HANGUL SYLLABLE CYELG -->
+      <map code="0xccf6" name="1em"/><!-- HANGUL SYLLABLE CYELM -->
+      <map code="0xccf7" name="1em"/><!-- HANGUL SYLLABLE CYELB -->
+      <map code="0xccf8" name="1em"/><!-- HANGUL SYLLABLE CYELS -->
+      <map code="0xccf9" name="1em"/><!-- HANGUL SYLLABLE CYELT -->
+      <map code="0xccfa" name="1em"/><!-- HANGUL SYLLABLE CYELP -->
+      <map code="0xccfb" name="1em"/><!-- HANGUL SYLLABLE CYELH -->
+      <map code="0xccfc" name="1em"/><!-- HANGUL SYLLABLE CYEM -->
+      <map code="0xccfd" name="1em"/><!-- HANGUL SYLLABLE CYEB -->
+      <map code="0xccfe" name="1em"/><!-- HANGUL SYLLABLE CYEBS -->
+      <map code="0xccff" name="1em"/><!-- HANGUL SYLLABLE CYES -->
+      <map code="0xcd00" name="1em"/><!-- HANGUL SYLLABLE CYESS -->
+      <map code="0xcd01" name="1em"/><!-- HANGUL SYLLABLE CYENG -->
+      <map code="0xcd02" name="1em"/><!-- HANGUL SYLLABLE CYEJ -->
+      <map code="0xcd03" name="1em"/><!-- HANGUL SYLLABLE CYEC -->
+      <map code="0xcd04" name="1em"/><!-- HANGUL SYLLABLE CYEK -->
+      <map code="0xcd05" name="1em"/><!-- HANGUL SYLLABLE CYET -->
+      <map code="0xcd06" name="1em"/><!-- HANGUL SYLLABLE CYEP -->
+      <map code="0xcd07" name="1em"/><!-- HANGUL SYLLABLE CYEH -->
+      <map code="0xcd08" name="1em"/><!-- HANGUL SYLLABLE CO -->
+      <map code="0xcd09" name="1em"/><!-- HANGUL SYLLABLE COG -->
+      <map code="0xcd0a" name="1em"/><!-- HANGUL SYLLABLE COGG -->
+      <map code="0xcd0b" name="1em"/><!-- HANGUL SYLLABLE COGS -->
+      <map code="0xcd0c" name="1em"/><!-- HANGUL SYLLABLE CON -->
+      <map code="0xcd0d" name="1em"/><!-- HANGUL SYLLABLE CONJ -->
+      <map code="0xcd0e" name="1em"/><!-- HANGUL SYLLABLE CONH -->
+      <map code="0xcd0f" name="1em"/><!-- HANGUL SYLLABLE COD -->
+      <map code="0xcd10" name="1em"/><!-- HANGUL SYLLABLE COL -->
+      <map code="0xcd11" name="1em"/><!-- HANGUL SYLLABLE COLG -->
+      <map code="0xcd12" name="1em"/><!-- HANGUL SYLLABLE COLM -->
+      <map code="0xcd13" name="1em"/><!-- HANGUL SYLLABLE COLB -->
+      <map code="0xcd14" name="1em"/><!-- HANGUL SYLLABLE COLS -->
+      <map code="0xcd15" name="1em"/><!-- HANGUL SYLLABLE COLT -->
+      <map code="0xcd16" name="1em"/><!-- HANGUL SYLLABLE COLP -->
+      <map code="0xcd17" name="1em"/><!-- HANGUL SYLLABLE COLH -->
+      <map code="0xcd18" name="1em"/><!-- HANGUL SYLLABLE COM -->
+      <map code="0xcd19" name="1em"/><!-- HANGUL SYLLABLE COB -->
+      <map code="0xcd1a" name="1em"/><!-- HANGUL SYLLABLE COBS -->
+      <map code="0xcd1b" name="1em"/><!-- HANGUL SYLLABLE COS -->
+      <map code="0xcd1c" name="1em"/><!-- HANGUL SYLLABLE COSS -->
+      <map code="0xcd1d" name="1em"/><!-- HANGUL SYLLABLE CONG -->
+      <map code="0xcd1e" name="1em"/><!-- HANGUL SYLLABLE COJ -->
+      <map code="0xcd1f" name="1em"/><!-- HANGUL SYLLABLE COC -->
+      <map code="0xcd20" name="1em"/><!-- HANGUL SYLLABLE COK -->
+      <map code="0xcd21" name="1em"/><!-- HANGUL SYLLABLE COT -->
+      <map code="0xcd22" name="1em"/><!-- HANGUL SYLLABLE COP -->
+      <map code="0xcd23" name="1em"/><!-- HANGUL SYLLABLE COH -->
+      <map code="0xcd24" name="1em"/><!-- HANGUL SYLLABLE CWA -->
+      <map code="0xcd25" name="1em"/><!-- HANGUL SYLLABLE CWAG -->
+      <map code="0xcd26" name="1em"/><!-- HANGUL SYLLABLE CWAGG -->
+      <map code="0xcd27" name="1em"/><!-- HANGUL SYLLABLE CWAGS -->
+      <map code="0xcd28" name="1em"/><!-- HANGUL SYLLABLE CWAN -->
+      <map code="0xcd29" name="1em"/><!-- HANGUL SYLLABLE CWANJ -->
+      <map code="0xcd2a" name="1em"/><!-- HANGUL SYLLABLE CWANH -->
+      <map code="0xcd2b" name="1em"/><!-- HANGUL SYLLABLE CWAD -->
+      <map code="0xcd2c" name="1em"/><!-- HANGUL SYLLABLE CWAL -->
+      <map code="0xcd2d" name="1em"/><!-- HANGUL SYLLABLE CWALG -->
+      <map code="0xcd2e" name="1em"/><!-- HANGUL SYLLABLE CWALM -->
+      <map code="0xcd2f" name="1em"/><!-- HANGUL SYLLABLE CWALB -->
+      <map code="0xcd30" name="1em"/><!-- HANGUL SYLLABLE CWALS -->
+      <map code="0xcd31" name="1em"/><!-- HANGUL SYLLABLE CWALT -->
+      <map code="0xcd32" name="1em"/><!-- HANGUL SYLLABLE CWALP -->
+      <map code="0xcd33" name="1em"/><!-- HANGUL SYLLABLE CWALH -->
+      <map code="0xcd34" name="1em"/><!-- HANGUL SYLLABLE CWAM -->
+      <map code="0xcd35" name="1em"/><!-- HANGUL SYLLABLE CWAB -->
+      <map code="0xcd36" name="1em"/><!-- HANGUL SYLLABLE CWABS -->
+      <map code="0xcd37" name="1em"/><!-- HANGUL SYLLABLE CWAS -->
+      <map code="0xcd38" name="1em"/><!-- HANGUL SYLLABLE CWASS -->
+      <map code="0xcd39" name="1em"/><!-- HANGUL SYLLABLE CWANG -->
+      <map code="0xcd3a" name="1em"/><!-- HANGUL SYLLABLE CWAJ -->
+      <map code="0xcd3b" name="1em"/><!-- HANGUL SYLLABLE CWAC -->
+      <map code="0xcd3c" name="1em"/><!-- HANGUL SYLLABLE CWAK -->
+      <map code="0xcd3d" name="1em"/><!-- HANGUL SYLLABLE CWAT -->
+      <map code="0xcd3e" name="1em"/><!-- HANGUL SYLLABLE CWAP -->
+      <map code="0xcd3f" name="1em"/><!-- HANGUL SYLLABLE CWAH -->
+      <map code="0xcd40" name="1em"/><!-- HANGUL SYLLABLE CWAE -->
+      <map code="0xcd41" name="1em"/><!-- HANGUL SYLLABLE CWAEG -->
+      <map code="0xcd42" name="1em"/><!-- HANGUL SYLLABLE CWAEGG -->
+      <map code="0xcd43" name="1em"/><!-- HANGUL SYLLABLE CWAEGS -->
+      <map code="0xcd44" name="1em"/><!-- HANGUL SYLLABLE CWAEN -->
+      <map code="0xcd45" name="1em"/><!-- HANGUL SYLLABLE CWAENJ -->
+      <map code="0xcd46" name="1em"/><!-- HANGUL SYLLABLE CWAENH -->
+      <map code="0xcd47" name="1em"/><!-- HANGUL SYLLABLE CWAED -->
+      <map code="0xcd48" name="1em"/><!-- HANGUL SYLLABLE CWAEL -->
+      <map code="0xcd49" name="1em"/><!-- HANGUL SYLLABLE CWAELG -->
+      <map code="0xcd4a" name="1em"/><!-- HANGUL SYLLABLE CWAELM -->
+      <map code="0xcd4b" name="1em"/><!-- HANGUL SYLLABLE CWAELB -->
+      <map code="0xcd4c" name="1em"/><!-- HANGUL SYLLABLE CWAELS -->
+      <map code="0xcd4d" name="1em"/><!-- HANGUL SYLLABLE CWAELT -->
+      <map code="0xcd4e" name="1em"/><!-- HANGUL SYLLABLE CWAELP -->
+      <map code="0xcd4f" name="1em"/><!-- HANGUL SYLLABLE CWAELH -->
+      <map code="0xcd50" name="1em"/><!-- HANGUL SYLLABLE CWAEM -->
+      <map code="0xcd51" name="1em"/><!-- HANGUL SYLLABLE CWAEB -->
+      <map code="0xcd52" name="1em"/><!-- HANGUL SYLLABLE CWAEBS -->
+      <map code="0xcd53" name="1em"/><!-- HANGUL SYLLABLE CWAES -->
+      <map code="0xcd54" name="1em"/><!-- HANGUL SYLLABLE CWAESS -->
+      <map code="0xcd55" name="1em"/><!-- HANGUL SYLLABLE CWAENG -->
+      <map code="0xcd56" name="1em"/><!-- HANGUL SYLLABLE CWAEJ -->
+      <map code="0xcd57" name="1em"/><!-- HANGUL SYLLABLE CWAEC -->
+      <map code="0xcd58" name="1em"/><!-- HANGUL SYLLABLE CWAEK -->
+      <map code="0xcd59" name="1em"/><!-- HANGUL SYLLABLE CWAET -->
+      <map code="0xcd5a" name="1em"/><!-- HANGUL SYLLABLE CWAEP -->
+      <map code="0xcd5b" name="1em"/><!-- HANGUL SYLLABLE CWAEH -->
+      <map code="0xcd5c" name="1em"/><!-- HANGUL SYLLABLE COE -->
+      <map code="0xcd5d" name="1em"/><!-- HANGUL SYLLABLE COEG -->
+      <map code="0xcd5e" name="1em"/><!-- HANGUL SYLLABLE COEGG -->
+      <map code="0xcd5f" name="1em"/><!-- HANGUL SYLLABLE COEGS -->
+      <map code="0xcd60" name="1em"/><!-- HANGUL SYLLABLE COEN -->
+      <map code="0xcd61" name="1em"/><!-- HANGUL SYLLABLE COENJ -->
+      <map code="0xcd62" name="1em"/><!-- HANGUL SYLLABLE COENH -->
+      <map code="0xcd63" name="1em"/><!-- HANGUL SYLLABLE COED -->
+      <map code="0xcd64" name="1em"/><!-- HANGUL SYLLABLE COEL -->
+      <map code="0xcd65" name="1em"/><!-- HANGUL SYLLABLE COELG -->
+      <map code="0xcd66" name="1em"/><!-- HANGUL SYLLABLE COELM -->
+      <map code="0xcd67" name="1em"/><!-- HANGUL SYLLABLE COELB -->
+      <map code="0xcd68" name="1em"/><!-- HANGUL SYLLABLE COELS -->
+      <map code="0xcd69" name="1em"/><!-- HANGUL SYLLABLE COELT -->
+      <map code="0xcd6a" name="1em"/><!-- HANGUL SYLLABLE COELP -->
+      <map code="0xcd6b" name="1em"/><!-- HANGUL SYLLABLE COELH -->
+      <map code="0xcd6c" name="1em"/><!-- HANGUL SYLLABLE COEM -->
+      <map code="0xcd6d" name="1em"/><!-- HANGUL SYLLABLE COEB -->
+      <map code="0xcd6e" name="1em"/><!-- HANGUL SYLLABLE COEBS -->
+      <map code="0xcd6f" name="1em"/><!-- HANGUL SYLLABLE COES -->
+      <map code="0xcd70" name="1em"/><!-- HANGUL SYLLABLE COESS -->
+      <map code="0xcd71" name="1em"/><!-- HANGUL SYLLABLE COENG -->
+      <map code="0xcd72" name="1em"/><!-- HANGUL SYLLABLE COEJ -->
+      <map code="0xcd73" name="1em"/><!-- HANGUL SYLLABLE COEC -->
+      <map code="0xcd74" name="1em"/><!-- HANGUL SYLLABLE COEK -->
+      <map code="0xcd75" name="1em"/><!-- HANGUL SYLLABLE COET -->
+      <map code="0xcd76" name="1em"/><!-- HANGUL SYLLABLE COEP -->
+      <map code="0xcd77" name="1em"/><!-- HANGUL SYLLABLE COEH -->
+      <map code="0xcd78" name="1em"/><!-- HANGUL SYLLABLE CYO -->
+      <map code="0xcd79" name="1em"/><!-- HANGUL SYLLABLE CYOG -->
+      <map code="0xcd7a" name="1em"/><!-- HANGUL SYLLABLE CYOGG -->
+      <map code="0xcd7b" name="1em"/><!-- HANGUL SYLLABLE CYOGS -->
+      <map code="0xcd7c" name="1em"/><!-- HANGUL SYLLABLE CYON -->
+      <map code="0xcd7d" name="1em"/><!-- HANGUL SYLLABLE CYONJ -->
+      <map code="0xcd7e" name="1em"/><!-- HANGUL SYLLABLE CYONH -->
+      <map code="0xcd7f" name="1em"/><!-- HANGUL SYLLABLE CYOD -->
+      <map code="0xcd80" name="1em"/><!-- HANGUL SYLLABLE CYOL -->
+      <map code="0xcd81" name="1em"/><!-- HANGUL SYLLABLE CYOLG -->
+      <map code="0xcd82" name="1em"/><!-- HANGUL SYLLABLE CYOLM -->
+      <map code="0xcd83" name="1em"/><!-- HANGUL SYLLABLE CYOLB -->
+      <map code="0xcd84" name="1em"/><!-- HANGUL SYLLABLE CYOLS -->
+      <map code="0xcd85" name="1em"/><!-- HANGUL SYLLABLE CYOLT -->
+      <map code="0xcd86" name="1em"/><!-- HANGUL SYLLABLE CYOLP -->
+      <map code="0xcd87" name="1em"/><!-- HANGUL SYLLABLE CYOLH -->
+      <map code="0xcd88" name="1em"/><!-- HANGUL SYLLABLE CYOM -->
+      <map code="0xcd89" name="1em"/><!-- HANGUL SYLLABLE CYOB -->
+      <map code="0xcd8a" name="1em"/><!-- HANGUL SYLLABLE CYOBS -->
+      <map code="0xcd8b" name="1em"/><!-- HANGUL SYLLABLE CYOS -->
+      <map code="0xcd8c" name="1em"/><!-- HANGUL SYLLABLE CYOSS -->
+      <map code="0xcd8d" name="1em"/><!-- HANGUL SYLLABLE CYONG -->
+      <map code="0xcd8e" name="1em"/><!-- HANGUL SYLLABLE CYOJ -->
+      <map code="0xcd8f" name="1em"/><!-- HANGUL SYLLABLE CYOC -->
+      <map code="0xcd90" name="1em"/><!-- HANGUL SYLLABLE CYOK -->
+      <map code="0xcd91" name="1em"/><!-- HANGUL SYLLABLE CYOT -->
+      <map code="0xcd92" name="1em"/><!-- HANGUL SYLLABLE CYOP -->
+      <map code="0xcd93" name="1em"/><!-- HANGUL SYLLABLE CYOH -->
+      <map code="0xcd94" name="1em"/><!-- HANGUL SYLLABLE CU -->
+      <map code="0xcd95" name="1em"/><!-- HANGUL SYLLABLE CUG -->
+      <map code="0xcd96" name="1em"/><!-- HANGUL SYLLABLE CUGG -->
+      <map code="0xcd97" name="1em"/><!-- HANGUL SYLLABLE CUGS -->
+      <map code="0xcd98" name="1em"/><!-- HANGUL SYLLABLE CUN -->
+      <map code="0xcd99" name="1em"/><!-- HANGUL SYLLABLE CUNJ -->
+      <map code="0xcd9a" name="1em"/><!-- HANGUL SYLLABLE CUNH -->
+      <map code="0xcd9b" name="1em"/><!-- HANGUL SYLLABLE CUD -->
+      <map code="0xcd9c" name="1em"/><!-- HANGUL SYLLABLE CUL -->
+      <map code="0xcd9d" name="1em"/><!-- HANGUL SYLLABLE CULG -->
+      <map code="0xcd9e" name="1em"/><!-- HANGUL SYLLABLE CULM -->
+      <map code="0xcd9f" name="1em"/><!-- HANGUL SYLLABLE CULB -->
+      <map code="0xcda0" name="1em"/><!-- HANGUL SYLLABLE CULS -->
+      <map code="0xcda1" name="1em"/><!-- HANGUL SYLLABLE CULT -->
+      <map code="0xcda2" name="1em"/><!-- HANGUL SYLLABLE CULP -->
+      <map code="0xcda3" name="1em"/><!-- HANGUL SYLLABLE CULH -->
+      <map code="0xcda4" name="1em"/><!-- HANGUL SYLLABLE CUM -->
+      <map code="0xcda5" name="1em"/><!-- HANGUL SYLLABLE CUB -->
+      <map code="0xcda6" name="1em"/><!-- HANGUL SYLLABLE CUBS -->
+      <map code="0xcda7" name="1em"/><!-- HANGUL SYLLABLE CUS -->
+      <map code="0xcda8" name="1em"/><!-- HANGUL SYLLABLE CUSS -->
+      <map code="0xcda9" name="1em"/><!-- HANGUL SYLLABLE CUNG -->
+      <map code="0xcdaa" name="1em"/><!-- HANGUL SYLLABLE CUJ -->
+      <map code="0xcdab" name="1em"/><!-- HANGUL SYLLABLE CUC -->
+      <map code="0xcdac" name="1em"/><!-- HANGUL SYLLABLE CUK -->
+      <map code="0xcdad" name="1em"/><!-- HANGUL SYLLABLE CUT -->
+      <map code="0xcdae" name="1em"/><!-- HANGUL SYLLABLE CUP -->
+      <map code="0xcdaf" name="1em"/><!-- HANGUL SYLLABLE CUH -->
+      <map code="0xcdb0" name="1em"/><!-- HANGUL SYLLABLE CWEO -->
+      <map code="0xcdb1" name="1em"/><!-- HANGUL SYLLABLE CWEOG -->
+      <map code="0xcdb2" name="1em"/><!-- HANGUL SYLLABLE CWEOGG -->
+      <map code="0xcdb3" name="1em"/><!-- HANGUL SYLLABLE CWEOGS -->
+      <map code="0xcdb4" name="1em"/><!-- HANGUL SYLLABLE CWEON -->
+      <map code="0xcdb5" name="1em"/><!-- HANGUL SYLLABLE CWEONJ -->
+      <map code="0xcdb6" name="1em"/><!-- HANGUL SYLLABLE CWEONH -->
+      <map code="0xcdb7" name="1em"/><!-- HANGUL SYLLABLE CWEOD -->
+      <map code="0xcdb8" name="1em"/><!-- HANGUL SYLLABLE CWEOL -->
+      <map code="0xcdb9" name="1em"/><!-- HANGUL SYLLABLE CWEOLG -->
+      <map code="0xcdba" name="1em"/><!-- HANGUL SYLLABLE CWEOLM -->
+      <map code="0xcdbb" name="1em"/><!-- HANGUL SYLLABLE CWEOLB -->
+      <map code="0xcdbc" name="1em"/><!-- HANGUL SYLLABLE CWEOLS -->
+      <map code="0xcdbd" name="1em"/><!-- HANGUL SYLLABLE CWEOLT -->
+      <map code="0xcdbe" name="1em"/><!-- HANGUL SYLLABLE CWEOLP -->
+      <map code="0xcdbf" name="1em"/><!-- HANGUL SYLLABLE CWEOLH -->
+      <map code="0xcdc0" name="1em"/><!-- HANGUL SYLLABLE CWEOM -->
+      <map code="0xcdc1" name="1em"/><!-- HANGUL SYLLABLE CWEOB -->
+      <map code="0xcdc2" name="1em"/><!-- HANGUL SYLLABLE CWEOBS -->
+      <map code="0xcdc3" name="1em"/><!-- HANGUL SYLLABLE CWEOS -->
+      <map code="0xcdc4" name="1em"/><!-- HANGUL SYLLABLE CWEOSS -->
+      <map code="0xcdc5" name="1em"/><!-- HANGUL SYLLABLE CWEONG -->
+      <map code="0xcdc6" name="1em"/><!-- HANGUL SYLLABLE CWEOJ -->
+      <map code="0xcdc7" name="1em"/><!-- HANGUL SYLLABLE CWEOC -->
+      <map code="0xcdc8" name="1em"/><!-- HANGUL SYLLABLE CWEOK -->
+      <map code="0xcdc9" name="1em"/><!-- HANGUL SYLLABLE CWEOT -->
+      <map code="0xcdca" name="1em"/><!-- HANGUL SYLLABLE CWEOP -->
+      <map code="0xcdcb" name="1em"/><!-- HANGUL SYLLABLE CWEOH -->
+      <map code="0xcdcc" name="1em"/><!-- HANGUL SYLLABLE CWE -->
+      <map code="0xcdcd" name="1em"/><!-- HANGUL SYLLABLE CWEG -->
+      <map code="0xcdce" name="1em"/><!-- HANGUL SYLLABLE CWEGG -->
+      <map code="0xcdcf" name="1em"/><!-- HANGUL SYLLABLE CWEGS -->
+      <map code="0xcdd0" name="1em"/><!-- HANGUL SYLLABLE CWEN -->
+      <map code="0xcdd1" name="1em"/><!-- HANGUL SYLLABLE CWENJ -->
+      <map code="0xcdd2" name="1em"/><!-- HANGUL SYLLABLE CWENH -->
+      <map code="0xcdd3" name="1em"/><!-- HANGUL SYLLABLE CWED -->
+      <map code="0xcdd4" name="1em"/><!-- HANGUL SYLLABLE CWEL -->
+      <map code="0xcdd5" name="1em"/><!-- HANGUL SYLLABLE CWELG -->
+      <map code="0xcdd6" name="1em"/><!-- HANGUL SYLLABLE CWELM -->
+      <map code="0xcdd7" name="1em"/><!-- HANGUL SYLLABLE CWELB -->
+      <map code="0xcdd8" name="1em"/><!-- HANGUL SYLLABLE CWELS -->
+      <map code="0xcdd9" name="1em"/><!-- HANGUL SYLLABLE CWELT -->
+      <map code="0xcdda" name="1em"/><!-- HANGUL SYLLABLE CWELP -->
+      <map code="0xcddb" name="1em"/><!-- HANGUL SYLLABLE CWELH -->
+      <map code="0xcddc" name="1em"/><!-- HANGUL SYLLABLE CWEM -->
+      <map code="0xcddd" name="1em"/><!-- HANGUL SYLLABLE CWEB -->
+      <map code="0xcdde" name="1em"/><!-- HANGUL SYLLABLE CWEBS -->
+      <map code="0xcddf" name="1em"/><!-- HANGUL SYLLABLE CWES -->
+      <map code="0xcde0" name="1em"/><!-- HANGUL SYLLABLE CWESS -->
+      <map code="0xcde1" name="1em"/><!-- HANGUL SYLLABLE CWENG -->
+      <map code="0xcde2" name="1em"/><!-- HANGUL SYLLABLE CWEJ -->
+      <map code="0xcde3" name="1em"/><!-- HANGUL SYLLABLE CWEC -->
+      <map code="0xcde4" name="1em"/><!-- HANGUL SYLLABLE CWEK -->
+      <map code="0xcde5" name="1em"/><!-- HANGUL SYLLABLE CWET -->
+      <map code="0xcde6" name="1em"/><!-- HANGUL SYLLABLE CWEP -->
+      <map code="0xcde7" name="1em"/><!-- HANGUL SYLLABLE CWEH -->
+      <map code="0xcde8" name="1em"/><!-- HANGUL SYLLABLE CWI -->
+      <map code="0xcde9" name="1em"/><!-- HANGUL SYLLABLE CWIG -->
+      <map code="0xcdea" name="1em"/><!-- HANGUL SYLLABLE CWIGG -->
+      <map code="0xcdeb" name="1em"/><!-- HANGUL SYLLABLE CWIGS -->
+      <map code="0xcdec" name="1em"/><!-- HANGUL SYLLABLE CWIN -->
+      <map code="0xcded" name="1em"/><!-- HANGUL SYLLABLE CWINJ -->
+      <map code="0xcdee" name="1em"/><!-- HANGUL SYLLABLE CWINH -->
+      <map code="0xcdef" name="1em"/><!-- HANGUL SYLLABLE CWID -->
+      <map code="0xcdf0" name="1em"/><!-- HANGUL SYLLABLE CWIL -->
+      <map code="0xcdf1" name="1em"/><!-- HANGUL SYLLABLE CWILG -->
+      <map code="0xcdf2" name="1em"/><!-- HANGUL SYLLABLE CWILM -->
+      <map code="0xcdf3" name="1em"/><!-- HANGUL SYLLABLE CWILB -->
+      <map code="0xcdf4" name="1em"/><!-- HANGUL SYLLABLE CWILS -->
+      <map code="0xcdf5" name="1em"/><!-- HANGUL SYLLABLE CWILT -->
+      <map code="0xcdf6" name="1em"/><!-- HANGUL SYLLABLE CWILP -->
+      <map code="0xcdf7" name="1em"/><!-- HANGUL SYLLABLE CWILH -->
+      <map code="0xcdf8" name="1em"/><!-- HANGUL SYLLABLE CWIM -->
+      <map code="0xcdf9" name="1em"/><!-- HANGUL SYLLABLE CWIB -->
+      <map code="0xcdfa" name="1em"/><!-- HANGUL SYLLABLE CWIBS -->
+      <map code="0xcdfb" name="1em"/><!-- HANGUL SYLLABLE CWIS -->
+      <map code="0xcdfc" name="1em"/><!-- HANGUL SYLLABLE CWISS -->
+      <map code="0xcdfd" name="1em"/><!-- HANGUL SYLLABLE CWING -->
+      <map code="0xcdfe" name="1em"/><!-- HANGUL SYLLABLE CWIJ -->
+      <map code="0xcdff" name="1em"/><!-- HANGUL SYLLABLE CWIC -->
+      <map code="0xce00" name="1em"/><!-- HANGUL SYLLABLE CWIK -->
+      <map code="0xce01" name="1em"/><!-- HANGUL SYLLABLE CWIT -->
+      <map code="0xce02" name="1em"/><!-- HANGUL SYLLABLE CWIP -->
+      <map code="0xce03" name="1em"/><!-- HANGUL SYLLABLE CWIH -->
+      <map code="0xce04" name="1em"/><!-- HANGUL SYLLABLE CYU -->
+      <map code="0xce05" name="1em"/><!-- HANGUL SYLLABLE CYUG -->
+      <map code="0xce06" name="1em"/><!-- HANGUL SYLLABLE CYUGG -->
+      <map code="0xce07" name="1em"/><!-- HANGUL SYLLABLE CYUGS -->
+      <map code="0xce08" name="1em"/><!-- HANGUL SYLLABLE CYUN -->
+      <map code="0xce09" name="1em"/><!-- HANGUL SYLLABLE CYUNJ -->
+      <map code="0xce0a" name="1em"/><!-- HANGUL SYLLABLE CYUNH -->
+      <map code="0xce0b" name="1em"/><!-- HANGUL SYLLABLE CYUD -->
+      <map code="0xce0c" name="1em"/><!-- HANGUL SYLLABLE CYUL -->
+      <map code="0xce0d" name="1em"/><!-- HANGUL SYLLABLE CYULG -->
+      <map code="0xce0e" name="1em"/><!-- HANGUL SYLLABLE CYULM -->
+      <map code="0xce0f" name="1em"/><!-- HANGUL SYLLABLE CYULB -->
+      <map code="0xce10" name="1em"/><!-- HANGUL SYLLABLE CYULS -->
+      <map code="0xce11" name="1em"/><!-- HANGUL SYLLABLE CYULT -->
+      <map code="0xce12" name="1em"/><!-- HANGUL SYLLABLE CYULP -->
+      <map code="0xce13" name="1em"/><!-- HANGUL SYLLABLE CYULH -->
+      <map code="0xce14" name="1em"/><!-- HANGUL SYLLABLE CYUM -->
+      <map code="0xce15" name="1em"/><!-- HANGUL SYLLABLE CYUB -->
+      <map code="0xce16" name="1em"/><!-- HANGUL SYLLABLE CYUBS -->
+      <map code="0xce17" name="1em"/><!-- HANGUL SYLLABLE CYUS -->
+      <map code="0xce18" name="1em"/><!-- HANGUL SYLLABLE CYUSS -->
+      <map code="0xce19" name="1em"/><!-- HANGUL SYLLABLE CYUNG -->
+      <map code="0xce1a" name="1em"/><!-- HANGUL SYLLABLE CYUJ -->
+      <map code="0xce1b" name="1em"/><!-- HANGUL SYLLABLE CYUC -->
+      <map code="0xce1c" name="1em"/><!-- HANGUL SYLLABLE CYUK -->
+      <map code="0xce1d" name="1em"/><!-- HANGUL SYLLABLE CYUT -->
+      <map code="0xce1e" name="1em"/><!-- HANGUL SYLLABLE CYUP -->
+      <map code="0xce1f" name="1em"/><!-- HANGUL SYLLABLE CYUH -->
+      <map code="0xce20" name="1em"/><!-- HANGUL SYLLABLE CEU -->
+      <map code="0xce21" name="1em"/><!-- HANGUL SYLLABLE CEUG -->
+      <map code="0xce22" name="1em"/><!-- HANGUL SYLLABLE CEUGG -->
+      <map code="0xce23" name="1em"/><!-- HANGUL SYLLABLE CEUGS -->
+      <map code="0xce24" name="1em"/><!-- HANGUL SYLLABLE CEUN -->
+      <map code="0xce25" name="1em"/><!-- HANGUL SYLLABLE CEUNJ -->
+      <map code="0xce26" name="1em"/><!-- HANGUL SYLLABLE CEUNH -->
+      <map code="0xce27" name="1em"/><!-- HANGUL SYLLABLE CEUD -->
+      <map code="0xce28" name="1em"/><!-- HANGUL SYLLABLE CEUL -->
+      <map code="0xce29" name="1em"/><!-- HANGUL SYLLABLE CEULG -->
+      <map code="0xce2a" name="1em"/><!-- HANGUL SYLLABLE CEULM -->
+      <map code="0xce2b" name="1em"/><!-- HANGUL SYLLABLE CEULB -->
+      <map code="0xce2c" name="1em"/><!-- HANGUL SYLLABLE CEULS -->
+      <map code="0xce2d" name="1em"/><!-- HANGUL SYLLABLE CEULT -->
+      <map code="0xce2e" name="1em"/><!-- HANGUL SYLLABLE CEULP -->
+      <map code="0xce2f" name="1em"/><!-- HANGUL SYLLABLE CEULH -->
+      <map code="0xce30" name="1em"/><!-- HANGUL SYLLABLE CEUM -->
+      <map code="0xce31" name="1em"/><!-- HANGUL SYLLABLE CEUB -->
+      <map code="0xce32" name="1em"/><!-- HANGUL SYLLABLE CEUBS -->
+      <map code="0xce33" name="1em"/><!-- HANGUL SYLLABLE CEUS -->
+      <map code="0xce34" name="1em"/><!-- HANGUL SYLLABLE CEUSS -->
+      <map code="0xce35" name="1em"/><!-- HANGUL SYLLABLE CEUNG -->
+      <map code="0xce36" name="1em"/><!-- HANGUL SYLLABLE CEUJ -->
+      <map code="0xce37" name="1em"/><!-- HANGUL SYLLABLE CEUC -->
+      <map code="0xce38" name="1em"/><!-- HANGUL SYLLABLE CEUK -->
+      <map code="0xce39" name="1em"/><!-- HANGUL SYLLABLE CEUT -->
+      <map code="0xce3a" name="1em"/><!-- HANGUL SYLLABLE CEUP -->
+      <map code="0xce3b" name="1em"/><!-- HANGUL SYLLABLE CEUH -->
+      <map code="0xce3c" name="1em"/><!-- HANGUL SYLLABLE CYI -->
+      <map code="0xce3d" name="1em"/><!-- HANGUL SYLLABLE CYIG -->
+      <map code="0xce3e" name="1em"/><!-- HANGUL SYLLABLE CYIGG -->
+      <map code="0xce3f" name="1em"/><!-- HANGUL SYLLABLE CYIGS -->
+      <map code="0xce40" name="1em"/><!-- HANGUL SYLLABLE CYIN -->
+      <map code="0xce41" name="1em"/><!-- HANGUL SYLLABLE CYINJ -->
+      <map code="0xce42" name="1em"/><!-- HANGUL SYLLABLE CYINH -->
+      <map code="0xce43" name="1em"/><!-- HANGUL SYLLABLE CYID -->
+      <map code="0xce44" name="1em"/><!-- HANGUL SYLLABLE CYIL -->
+      <map code="0xce45" name="1em"/><!-- HANGUL SYLLABLE CYILG -->
+      <map code="0xce46" name="1em"/><!-- HANGUL SYLLABLE CYILM -->
+      <map code="0xce47" name="1em"/><!-- HANGUL SYLLABLE CYILB -->
+      <map code="0xce48" name="1em"/><!-- HANGUL SYLLABLE CYILS -->
+      <map code="0xce49" name="1em"/><!-- HANGUL SYLLABLE CYILT -->
+      <map code="0xce4a" name="1em"/><!-- HANGUL SYLLABLE CYILP -->
+      <map code="0xce4b" name="1em"/><!-- HANGUL SYLLABLE CYILH -->
+      <map code="0xce4c" name="1em"/><!-- HANGUL SYLLABLE CYIM -->
+      <map code="0xce4d" name="1em"/><!-- HANGUL SYLLABLE CYIB -->
+      <map code="0xce4e" name="1em"/><!-- HANGUL SYLLABLE CYIBS -->
+      <map code="0xce4f" name="1em"/><!-- HANGUL SYLLABLE CYIS -->
+      <map code="0xce50" name="1em"/><!-- HANGUL SYLLABLE CYISS -->
+      <map code="0xce51" name="1em"/><!-- HANGUL SYLLABLE CYING -->
+      <map code="0xce52" name="1em"/><!-- HANGUL SYLLABLE CYIJ -->
+      <map code="0xce53" name="1em"/><!-- HANGUL SYLLABLE CYIC -->
+      <map code="0xce54" name="1em"/><!-- HANGUL SYLLABLE CYIK -->
+      <map code="0xce55" name="1em"/><!-- HANGUL SYLLABLE CYIT -->
+      <map code="0xce56" name="1em"/><!-- HANGUL SYLLABLE CYIP -->
+      <map code="0xce57" name="1em"/><!-- HANGUL SYLLABLE CYIH -->
+      <map code="0xce58" name="1em"/><!-- HANGUL SYLLABLE CI -->
+      <map code="0xce59" name="1em"/><!-- HANGUL SYLLABLE CIG -->
+      <map code="0xce5a" name="1em"/><!-- HANGUL SYLLABLE CIGG -->
+      <map code="0xce5b" name="1em"/><!-- HANGUL SYLLABLE CIGS -->
+      <map code="0xce5c" name="1em"/><!-- HANGUL SYLLABLE CIN -->
+      <map code="0xce5d" name="1em"/><!-- HANGUL SYLLABLE CINJ -->
+      <map code="0xce5e" name="1em"/><!-- HANGUL SYLLABLE CINH -->
+      <map code="0xce5f" name="1em"/><!-- HANGUL SYLLABLE CID -->
+      <map code="0xce60" name="1em"/><!-- HANGUL SYLLABLE CIL -->
+      <map code="0xce61" name="1em"/><!-- HANGUL SYLLABLE CILG -->
+      <map code="0xce62" name="1em"/><!-- HANGUL SYLLABLE CILM -->
+      <map code="0xce63" name="1em"/><!-- HANGUL SYLLABLE CILB -->
+      <map code="0xce64" name="1em"/><!-- HANGUL SYLLABLE CILS -->
+      <map code="0xce65" name="1em"/><!-- HANGUL SYLLABLE CILT -->
+      <map code="0xce66" name="1em"/><!-- HANGUL SYLLABLE CILP -->
+      <map code="0xce67" name="1em"/><!-- HANGUL SYLLABLE CILH -->
+      <map code="0xce68" name="1em"/><!-- HANGUL SYLLABLE CIM -->
+      <map code="0xce69" name="1em"/><!-- HANGUL SYLLABLE CIB -->
+      <map code="0xce6a" name="1em"/><!-- HANGUL SYLLABLE CIBS -->
+      <map code="0xce6b" name="1em"/><!-- HANGUL SYLLABLE CIS -->
+      <map code="0xce6c" name="1em"/><!-- HANGUL SYLLABLE CISS -->
+      <map code="0xce6d" name="1em"/><!-- HANGUL SYLLABLE CING -->
+      <map code="0xce6e" name="1em"/><!-- HANGUL SYLLABLE CIJ -->
+      <map code="0xce6f" name="1em"/><!-- HANGUL SYLLABLE CIC -->
+      <map code="0xce70" name="1em"/><!-- HANGUL SYLLABLE CIK -->
+      <map code="0xce71" name="1em"/><!-- HANGUL SYLLABLE CIT -->
+      <map code="0xce72" name="1em"/><!-- HANGUL SYLLABLE CIP -->
+      <map code="0xce73" name="1em"/><!-- HANGUL SYLLABLE CIH -->
+      <map code="0xce74" name="1em"/><!-- HANGUL SYLLABLE KA -->
+      <map code="0xce75" name="1em"/><!-- HANGUL SYLLABLE KAG -->
+      <map code="0xce76" name="1em"/><!-- HANGUL SYLLABLE KAGG -->
+      <map code="0xce77" name="1em"/><!-- HANGUL SYLLABLE KAGS -->
+      <map code="0xce78" name="1em"/><!-- HANGUL SYLLABLE KAN -->
+      <map code="0xce79" name="1em"/><!-- HANGUL SYLLABLE KANJ -->
+      <map code="0xce7a" name="1em"/><!-- HANGUL SYLLABLE KANH -->
+      <map code="0xce7b" name="1em"/><!-- HANGUL SYLLABLE KAD -->
+      <map code="0xce7c" name="1em"/><!-- HANGUL SYLLABLE KAL -->
+      <map code="0xce7d" name="1em"/><!-- HANGUL SYLLABLE KALG -->
+      <map code="0xce7e" name="1em"/><!-- HANGUL SYLLABLE KALM -->
+      <map code="0xce7f" name="1em"/><!-- HANGUL SYLLABLE KALB -->
+      <map code="0xce80" name="1em"/><!-- HANGUL SYLLABLE KALS -->
+      <map code="0xce81" name="1em"/><!-- HANGUL SYLLABLE KALT -->
+      <map code="0xce82" name="1em"/><!-- HANGUL SYLLABLE KALP -->
+      <map code="0xce83" name="1em"/><!-- HANGUL SYLLABLE KALH -->
+      <map code="0xce84" name="1em"/><!-- HANGUL SYLLABLE KAM -->
+      <map code="0xce85" name="1em"/><!-- HANGUL SYLLABLE KAB -->
+      <map code="0xce86" name="1em"/><!-- HANGUL SYLLABLE KABS -->
+      <map code="0xce87" name="1em"/><!-- HANGUL SYLLABLE KAS -->
+      <map code="0xce88" name="1em"/><!-- HANGUL SYLLABLE KASS -->
+      <map code="0xce89" name="1em"/><!-- HANGUL SYLLABLE KANG -->
+      <map code="0xce8a" name="1em"/><!-- HANGUL SYLLABLE KAJ -->
+      <map code="0xce8b" name="1em"/><!-- HANGUL SYLLABLE KAC -->
+      <map code="0xce8c" name="1em"/><!-- HANGUL SYLLABLE KAK -->
+      <map code="0xce8d" name="1em"/><!-- HANGUL SYLLABLE KAT -->
+      <map code="0xce8e" name="1em"/><!-- HANGUL SYLLABLE KAP -->
+      <map code="0xce8f" name="1em"/><!-- HANGUL SYLLABLE KAH -->
+      <map code="0xce90" name="1em"/><!-- HANGUL SYLLABLE KAE -->
+      <map code="0xce91" name="1em"/><!-- HANGUL SYLLABLE KAEG -->
+      <map code="0xce92" name="1em"/><!-- HANGUL SYLLABLE KAEGG -->
+      <map code="0xce93" name="1em"/><!-- HANGUL SYLLABLE KAEGS -->
+      <map code="0xce94" name="1em"/><!-- HANGUL SYLLABLE KAEN -->
+      <map code="0xce95" name="1em"/><!-- HANGUL SYLLABLE KAENJ -->
+      <map code="0xce96" name="1em"/><!-- HANGUL SYLLABLE KAENH -->
+      <map code="0xce97" name="1em"/><!-- HANGUL SYLLABLE KAED -->
+      <map code="0xce98" name="1em"/><!-- HANGUL SYLLABLE KAEL -->
+      <map code="0xce99" name="1em"/><!-- HANGUL SYLLABLE KAELG -->
+      <map code="0xce9a" name="1em"/><!-- HANGUL SYLLABLE KAELM -->
+      <map code="0xce9b" name="1em"/><!-- HANGUL SYLLABLE KAELB -->
+      <map code="0xce9c" name="1em"/><!-- HANGUL SYLLABLE KAELS -->
+      <map code="0xce9d" name="1em"/><!-- HANGUL SYLLABLE KAELT -->
+      <map code="0xce9e" name="1em"/><!-- HANGUL SYLLABLE KAELP -->
+      <map code="0xce9f" name="1em"/><!-- HANGUL SYLLABLE KAELH -->
+      <map code="0xcea0" name="1em"/><!-- HANGUL SYLLABLE KAEM -->
+      <map code="0xcea1" name="1em"/><!-- HANGUL SYLLABLE KAEB -->
+      <map code="0xcea2" name="1em"/><!-- HANGUL SYLLABLE KAEBS -->
+      <map code="0xcea3" name="1em"/><!-- HANGUL SYLLABLE KAES -->
+      <map code="0xcea4" name="1em"/><!-- HANGUL SYLLABLE KAESS -->
+      <map code="0xcea5" name="1em"/><!-- HANGUL SYLLABLE KAENG -->
+      <map code="0xcea6" name="1em"/><!-- HANGUL SYLLABLE KAEJ -->
+      <map code="0xcea7" name="1em"/><!-- HANGUL SYLLABLE KAEC -->
+      <map code="0xcea8" name="1em"/><!-- HANGUL SYLLABLE KAEK -->
+      <map code="0xcea9" name="1em"/><!-- HANGUL SYLLABLE KAET -->
+      <map code="0xceaa" name="1em"/><!-- HANGUL SYLLABLE KAEP -->
+      <map code="0xceab" name="1em"/><!-- HANGUL SYLLABLE KAEH -->
+      <map code="0xceac" name="1em"/><!-- HANGUL SYLLABLE KYA -->
+      <map code="0xcead" name="1em"/><!-- HANGUL SYLLABLE KYAG -->
+      <map code="0xceae" name="1em"/><!-- HANGUL SYLLABLE KYAGG -->
+      <map code="0xceaf" name="1em"/><!-- HANGUL SYLLABLE KYAGS -->
+      <map code="0xceb0" name="1em"/><!-- HANGUL SYLLABLE KYAN -->
+      <map code="0xceb1" name="1em"/><!-- HANGUL SYLLABLE KYANJ -->
+      <map code="0xceb2" name="1em"/><!-- HANGUL SYLLABLE KYANH -->
+      <map code="0xceb3" name="1em"/><!-- HANGUL SYLLABLE KYAD -->
+      <map code="0xceb4" name="1em"/><!-- HANGUL SYLLABLE KYAL -->
+      <map code="0xceb5" name="1em"/><!-- HANGUL SYLLABLE KYALG -->
+      <map code="0xceb6" name="1em"/><!-- HANGUL SYLLABLE KYALM -->
+      <map code="0xceb7" name="1em"/><!-- HANGUL SYLLABLE KYALB -->
+      <map code="0xceb8" name="1em"/><!-- HANGUL SYLLABLE KYALS -->
+      <map code="0xceb9" name="1em"/><!-- HANGUL SYLLABLE KYALT -->
+      <map code="0xceba" name="1em"/><!-- HANGUL SYLLABLE KYALP -->
+      <map code="0xcebb" name="1em"/><!-- HANGUL SYLLABLE KYALH -->
+      <map code="0xcebc" name="1em"/><!-- HANGUL SYLLABLE KYAM -->
+      <map code="0xcebd" name="1em"/><!-- HANGUL SYLLABLE KYAB -->
+      <map code="0xcebe" name="1em"/><!-- HANGUL SYLLABLE KYABS -->
+      <map code="0xcebf" name="1em"/><!-- HANGUL SYLLABLE KYAS -->
+      <map code="0xcec0" name="1em"/><!-- HANGUL SYLLABLE KYASS -->
+      <map code="0xcec1" name="1em"/><!-- HANGUL SYLLABLE KYANG -->
+      <map code="0xcec2" name="1em"/><!-- HANGUL SYLLABLE KYAJ -->
+      <map code="0xcec3" name="1em"/><!-- HANGUL SYLLABLE KYAC -->
+      <map code="0xcec4" name="1em"/><!-- HANGUL SYLLABLE KYAK -->
+      <map code="0xcec5" name="1em"/><!-- HANGUL SYLLABLE KYAT -->
+      <map code="0xcec6" name="1em"/><!-- HANGUL SYLLABLE KYAP -->
+      <map code="0xcec7" name="1em"/><!-- HANGUL SYLLABLE KYAH -->
+      <map code="0xcec8" name="1em"/><!-- HANGUL SYLLABLE KYAE -->
+      <map code="0xcec9" name="1em"/><!-- HANGUL SYLLABLE KYAEG -->
+      <map code="0xceca" name="1em"/><!-- HANGUL SYLLABLE KYAEGG -->
+      <map code="0xcecb" name="1em"/><!-- HANGUL SYLLABLE KYAEGS -->
+      <map code="0xcecc" name="1em"/><!-- HANGUL SYLLABLE KYAEN -->
+      <map code="0xcecd" name="1em"/><!-- HANGUL SYLLABLE KYAENJ -->
+      <map code="0xcece" name="1em"/><!-- HANGUL SYLLABLE KYAENH -->
+      <map code="0xcecf" name="1em"/><!-- HANGUL SYLLABLE KYAED -->
+      <map code="0xced0" name="1em"/><!-- HANGUL SYLLABLE KYAEL -->
+      <map code="0xced1" name="1em"/><!-- HANGUL SYLLABLE KYAELG -->
+      <map code="0xced2" name="1em"/><!-- HANGUL SYLLABLE KYAELM -->
+      <map code="0xced3" name="1em"/><!-- HANGUL SYLLABLE KYAELB -->
+      <map code="0xced4" name="1em"/><!-- HANGUL SYLLABLE KYAELS -->
+      <map code="0xced5" name="1em"/><!-- HANGUL SYLLABLE KYAELT -->
+      <map code="0xced6" name="1em"/><!-- HANGUL SYLLABLE KYAELP -->
+      <map code="0xced7" name="1em"/><!-- HANGUL SYLLABLE KYAELH -->
+      <map code="0xced8" name="1em"/><!-- HANGUL SYLLABLE KYAEM -->
+      <map code="0xced9" name="1em"/><!-- HANGUL SYLLABLE KYAEB -->
+      <map code="0xceda" name="1em"/><!-- HANGUL SYLLABLE KYAEBS -->
+      <map code="0xcedb" name="1em"/><!-- HANGUL SYLLABLE KYAES -->
+      <map code="0xcedc" name="1em"/><!-- HANGUL SYLLABLE KYAESS -->
+      <map code="0xcedd" name="1em"/><!-- HANGUL SYLLABLE KYAENG -->
+      <map code="0xcede" name="1em"/><!-- HANGUL SYLLABLE KYAEJ -->
+      <map code="0xcedf" name="1em"/><!-- HANGUL SYLLABLE KYAEC -->
+      <map code="0xcee0" name="1em"/><!-- HANGUL SYLLABLE KYAEK -->
+      <map code="0xcee1" name="1em"/><!-- HANGUL SYLLABLE KYAET -->
+      <map code="0xcee2" name="1em"/><!-- HANGUL SYLLABLE KYAEP -->
+      <map code="0xcee3" name="1em"/><!-- HANGUL SYLLABLE KYAEH -->
+      <map code="0xcee4" name="1em"/><!-- HANGUL SYLLABLE KEO -->
+      <map code="0xcee5" name="1em"/><!-- HANGUL SYLLABLE KEOG -->
+      <map code="0xcee6" name="1em"/><!-- HANGUL SYLLABLE KEOGG -->
+      <map code="0xcee7" name="1em"/><!-- HANGUL SYLLABLE KEOGS -->
+      <map code="0xcee8" name="1em"/><!-- HANGUL SYLLABLE KEON -->
+      <map code="0xcee9" name="1em"/><!-- HANGUL SYLLABLE KEONJ -->
+      <map code="0xceea" name="1em"/><!-- HANGUL SYLLABLE KEONH -->
+      <map code="0xceeb" name="1em"/><!-- HANGUL SYLLABLE KEOD -->
+      <map code="0xceec" name="1em"/><!-- HANGUL SYLLABLE KEOL -->
+      <map code="0xceed" name="1em"/><!-- HANGUL SYLLABLE KEOLG -->
+      <map code="0xceee" name="1em"/><!-- HANGUL SYLLABLE KEOLM -->
+      <map code="0xceef" name="1em"/><!-- HANGUL SYLLABLE KEOLB -->
+      <map code="0xcef0" name="1em"/><!-- HANGUL SYLLABLE KEOLS -->
+      <map code="0xcef1" name="1em"/><!-- HANGUL SYLLABLE KEOLT -->
+      <map code="0xcef2" name="1em"/><!-- HANGUL SYLLABLE KEOLP -->
+      <map code="0xcef3" name="1em"/><!-- HANGUL SYLLABLE KEOLH -->
+      <map code="0xcef4" name="1em"/><!-- HANGUL SYLLABLE KEOM -->
+      <map code="0xcef5" name="1em"/><!-- HANGUL SYLLABLE KEOB -->
+      <map code="0xcef6" name="1em"/><!-- HANGUL SYLLABLE KEOBS -->
+      <map code="0xcef7" name="1em"/><!-- HANGUL SYLLABLE KEOS -->
+      <map code="0xcef8" name="1em"/><!-- HANGUL SYLLABLE KEOSS -->
+      <map code="0xcef9" name="1em"/><!-- HANGUL SYLLABLE KEONG -->
+      <map code="0xcefa" name="1em"/><!-- HANGUL SYLLABLE KEOJ -->
+      <map code="0xcefb" name="1em"/><!-- HANGUL SYLLABLE KEOC -->
+      <map code="0xcefc" name="1em"/><!-- HANGUL SYLLABLE KEOK -->
+      <map code="0xcefd" name="1em"/><!-- HANGUL SYLLABLE KEOT -->
+      <map code="0xcefe" name="1em"/><!-- HANGUL SYLLABLE KEOP -->
+      <map code="0xceff" name="1em"/><!-- HANGUL SYLLABLE KEOH -->
+      <map code="0xcf00" name="1em"/><!-- HANGUL SYLLABLE KE -->
+      <map code="0xcf01" name="1em"/><!-- HANGUL SYLLABLE KEG -->
+      <map code="0xcf02" name="1em"/><!-- HANGUL SYLLABLE KEGG -->
+      <map code="0xcf03" name="1em"/><!-- HANGUL SYLLABLE KEGS -->
+      <map code="0xcf04" name="1em"/><!-- HANGUL SYLLABLE KEN -->
+      <map code="0xcf05" name="1em"/><!-- HANGUL SYLLABLE KENJ -->
+      <map code="0xcf06" name="1em"/><!-- HANGUL SYLLABLE KENH -->
+      <map code="0xcf07" name="1em"/><!-- HANGUL SYLLABLE KED -->
+      <map code="0xcf08" name="1em"/><!-- HANGUL SYLLABLE KEL -->
+      <map code="0xcf09" name="1em"/><!-- HANGUL SYLLABLE KELG -->
+      <map code="0xcf0a" name="1em"/><!-- HANGUL SYLLABLE KELM -->
+      <map code="0xcf0b" name="1em"/><!-- HANGUL SYLLABLE KELB -->
+      <map code="0xcf0c" name="1em"/><!-- HANGUL SYLLABLE KELS -->
+      <map code="0xcf0d" name="1em"/><!-- HANGUL SYLLABLE KELT -->
+      <map code="0xcf0e" name="1em"/><!-- HANGUL SYLLABLE KELP -->
+      <map code="0xcf0f" name="1em"/><!-- HANGUL SYLLABLE KELH -->
+      <map code="0xcf10" name="1em"/><!-- HANGUL SYLLABLE KEM -->
+      <map code="0xcf11" name="1em"/><!-- HANGUL SYLLABLE KEB -->
+      <map code="0xcf12" name="1em"/><!-- HANGUL SYLLABLE KEBS -->
+      <map code="0xcf13" name="1em"/><!-- HANGUL SYLLABLE KES -->
+      <map code="0xcf14" name="1em"/><!-- HANGUL SYLLABLE KESS -->
+      <map code="0xcf15" name="1em"/><!-- HANGUL SYLLABLE KENG -->
+      <map code="0xcf16" name="1em"/><!-- HANGUL SYLLABLE KEJ -->
+      <map code="0xcf17" name="1em"/><!-- HANGUL SYLLABLE KEC -->
+      <map code="0xcf18" name="1em"/><!-- HANGUL SYLLABLE KEK -->
+      <map code="0xcf19" name="1em"/><!-- HANGUL SYLLABLE KET -->
+      <map code="0xcf1a" name="1em"/><!-- HANGUL SYLLABLE KEP -->
+      <map code="0xcf1b" name="1em"/><!-- HANGUL SYLLABLE KEH -->
+      <map code="0xcf1c" name="1em"/><!-- HANGUL SYLLABLE KYEO -->
+      <map code="0xcf1d" name="1em"/><!-- HANGUL SYLLABLE KYEOG -->
+      <map code="0xcf1e" name="1em"/><!-- HANGUL SYLLABLE KYEOGG -->
+      <map code="0xcf1f" name="1em"/><!-- HANGUL SYLLABLE KYEOGS -->
+      <map code="0xcf20" name="1em"/><!-- HANGUL SYLLABLE KYEON -->
+      <map code="0xcf21" name="1em"/><!-- HANGUL SYLLABLE KYEONJ -->
+      <map code="0xcf22" name="1em"/><!-- HANGUL SYLLABLE KYEONH -->
+      <map code="0xcf23" name="1em"/><!-- HANGUL SYLLABLE KYEOD -->
+      <map code="0xcf24" name="1em"/><!-- HANGUL SYLLABLE KYEOL -->
+      <map code="0xcf25" name="1em"/><!-- HANGUL SYLLABLE KYEOLG -->
+      <map code="0xcf26" name="1em"/><!-- HANGUL SYLLABLE KYEOLM -->
+      <map code="0xcf27" name="1em"/><!-- HANGUL SYLLABLE KYEOLB -->
+      <map code="0xcf28" name="1em"/><!-- HANGUL SYLLABLE KYEOLS -->
+      <map code="0xcf29" name="1em"/><!-- HANGUL SYLLABLE KYEOLT -->
+      <map code="0xcf2a" name="1em"/><!-- HANGUL SYLLABLE KYEOLP -->
+      <map code="0xcf2b" name="1em"/><!-- HANGUL SYLLABLE KYEOLH -->
+      <map code="0xcf2c" name="1em"/><!-- HANGUL SYLLABLE KYEOM -->
+      <map code="0xcf2d" name="1em"/><!-- HANGUL SYLLABLE KYEOB -->
+      <map code="0xcf2e" name="1em"/><!-- HANGUL SYLLABLE KYEOBS -->
+      <map code="0xcf2f" name="1em"/><!-- HANGUL SYLLABLE KYEOS -->
+      <map code="0xcf30" name="1em"/><!-- HANGUL SYLLABLE KYEOSS -->
+      <map code="0xcf31" name="1em"/><!-- HANGUL SYLLABLE KYEONG -->
+      <map code="0xcf32" name="1em"/><!-- HANGUL SYLLABLE KYEOJ -->
+      <map code="0xcf33" name="1em"/><!-- HANGUL SYLLABLE KYEOC -->
+      <map code="0xcf34" name="1em"/><!-- HANGUL SYLLABLE KYEOK -->
+      <map code="0xcf35" name="1em"/><!-- HANGUL SYLLABLE KYEOT -->
+      <map code="0xcf36" name="1em"/><!-- HANGUL SYLLABLE KYEOP -->
+      <map code="0xcf37" name="1em"/><!-- HANGUL SYLLABLE KYEOH -->
+      <map code="0xcf38" name="1em"/><!-- HANGUL SYLLABLE KYE -->
+      <map code="0xcf39" name="1em"/><!-- HANGUL SYLLABLE KYEG -->
+      <map code="0xcf3a" name="1em"/><!-- HANGUL SYLLABLE KYEGG -->
+      <map code="0xcf3b" name="1em"/><!-- HANGUL SYLLABLE KYEGS -->
+      <map code="0xcf3c" name="1em"/><!-- HANGUL SYLLABLE KYEN -->
+      <map code="0xcf3d" name="1em"/><!-- HANGUL SYLLABLE KYENJ -->
+      <map code="0xcf3e" name="1em"/><!-- HANGUL SYLLABLE KYENH -->
+      <map code="0xcf3f" name="1em"/><!-- HANGUL SYLLABLE KYED -->
+      <map code="0xcf40" name="1em"/><!-- HANGUL SYLLABLE KYEL -->
+      <map code="0xcf41" name="1em"/><!-- HANGUL SYLLABLE KYELG -->
+      <map code="0xcf42" name="1em"/><!-- HANGUL SYLLABLE KYELM -->
+      <map code="0xcf43" name="1em"/><!-- HANGUL SYLLABLE KYELB -->
+      <map code="0xcf44" name="1em"/><!-- HANGUL SYLLABLE KYELS -->
+      <map code="0xcf45" name="1em"/><!-- HANGUL SYLLABLE KYELT -->
+      <map code="0xcf46" name="1em"/><!-- HANGUL SYLLABLE KYELP -->
+      <map code="0xcf47" name="1em"/><!-- HANGUL SYLLABLE KYELH -->
+      <map code="0xcf48" name="1em"/><!-- HANGUL SYLLABLE KYEM -->
+      <map code="0xcf49" name="1em"/><!-- HANGUL SYLLABLE KYEB -->
+      <map code="0xcf4a" name="1em"/><!-- HANGUL SYLLABLE KYEBS -->
+      <map code="0xcf4b" name="1em"/><!-- HANGUL SYLLABLE KYES -->
+      <map code="0xcf4c" name="1em"/><!-- HANGUL SYLLABLE KYESS -->
+      <map code="0xcf4d" name="1em"/><!-- HANGUL SYLLABLE KYENG -->
+      <map code="0xcf4e" name="1em"/><!-- HANGUL SYLLABLE KYEJ -->
+      <map code="0xcf4f" name="1em"/><!-- HANGUL SYLLABLE KYEC -->
+      <map code="0xcf50" name="1em"/><!-- HANGUL SYLLABLE KYEK -->
+      <map code="0xcf51" name="1em"/><!-- HANGUL SYLLABLE KYET -->
+      <map code="0xcf52" name="1em"/><!-- HANGUL SYLLABLE KYEP -->
+      <map code="0xcf53" name="1em"/><!-- HANGUL SYLLABLE KYEH -->
+      <map code="0xcf54" name="1em"/><!-- HANGUL SYLLABLE KO -->
+      <map code="0xcf55" name="1em"/><!-- HANGUL SYLLABLE KOG -->
+      <map code="0xcf56" name="1em"/><!-- HANGUL SYLLABLE KOGG -->
+      <map code="0xcf57" name="1em"/><!-- HANGUL SYLLABLE KOGS -->
+      <map code="0xcf58" name="1em"/><!-- HANGUL SYLLABLE KON -->
+      <map code="0xcf59" name="1em"/><!-- HANGUL SYLLABLE KONJ -->
+      <map code="0xcf5a" name="1em"/><!-- HANGUL SYLLABLE KONH -->
+      <map code="0xcf5b" name="1em"/><!-- HANGUL SYLLABLE KOD -->
+      <map code="0xcf5c" name="1em"/><!-- HANGUL SYLLABLE KOL -->
+      <map code="0xcf5d" name="1em"/><!-- HANGUL SYLLABLE KOLG -->
+      <map code="0xcf5e" name="1em"/><!-- HANGUL SYLLABLE KOLM -->
+      <map code="0xcf5f" name="1em"/><!-- HANGUL SYLLABLE KOLB -->
+      <map code="0xcf60" name="1em"/><!-- HANGUL SYLLABLE KOLS -->
+      <map code="0xcf61" name="1em"/><!-- HANGUL SYLLABLE KOLT -->
+      <map code="0xcf62" name="1em"/><!-- HANGUL SYLLABLE KOLP -->
+      <map code="0xcf63" name="1em"/><!-- HANGUL SYLLABLE KOLH -->
+      <map code="0xcf64" name="1em"/><!-- HANGUL SYLLABLE KOM -->
+      <map code="0xcf65" name="1em"/><!-- HANGUL SYLLABLE KOB -->
+      <map code="0xcf66" name="1em"/><!-- HANGUL SYLLABLE KOBS -->
+      <map code="0xcf67" name="1em"/><!-- HANGUL SYLLABLE KOS -->
+      <map code="0xcf68" name="1em"/><!-- HANGUL SYLLABLE KOSS -->
+      <map code="0xcf69" name="1em"/><!-- HANGUL SYLLABLE KONG -->
+      <map code="0xcf6a" name="1em"/><!-- HANGUL SYLLABLE KOJ -->
+      <map code="0xcf6b" name="1em"/><!-- HANGUL SYLLABLE KOC -->
+      <map code="0xcf6c" name="1em"/><!-- HANGUL SYLLABLE KOK -->
+      <map code="0xcf6d" name="1em"/><!-- HANGUL SYLLABLE KOT -->
+      <map code="0xcf6e" name="1em"/><!-- HANGUL SYLLABLE KOP -->
+      <map code="0xcf6f" name="1em"/><!-- HANGUL SYLLABLE KOH -->
+      <map code="0xcf70" name="1em"/><!-- HANGUL SYLLABLE KWA -->
+      <map code="0xcf71" name="1em"/><!-- HANGUL SYLLABLE KWAG -->
+      <map code="0xcf72" name="1em"/><!-- HANGUL SYLLABLE KWAGG -->
+      <map code="0xcf73" name="1em"/><!-- HANGUL SYLLABLE KWAGS -->
+      <map code="0xcf74" name="1em"/><!-- HANGUL SYLLABLE KWAN -->
+      <map code="0xcf75" name="1em"/><!-- HANGUL SYLLABLE KWANJ -->
+      <map code="0xcf76" name="1em"/><!-- HANGUL SYLLABLE KWANH -->
+      <map code="0xcf77" name="1em"/><!-- HANGUL SYLLABLE KWAD -->
+      <map code="0xcf78" name="1em"/><!-- HANGUL SYLLABLE KWAL -->
+      <map code="0xcf79" name="1em"/><!-- HANGUL SYLLABLE KWALG -->
+      <map code="0xcf7a" name="1em"/><!-- HANGUL SYLLABLE KWALM -->
+      <map code="0xcf7b" name="1em"/><!-- HANGUL SYLLABLE KWALB -->
+      <map code="0xcf7c" name="1em"/><!-- HANGUL SYLLABLE KWALS -->
+      <map code="0xcf7d" name="1em"/><!-- HANGUL SYLLABLE KWALT -->
+      <map code="0xcf7e" name="1em"/><!-- HANGUL SYLLABLE KWALP -->
+      <map code="0xcf7f" name="1em"/><!-- HANGUL SYLLABLE KWALH -->
+      <map code="0xcf80" name="1em"/><!-- HANGUL SYLLABLE KWAM -->
+      <map code="0xcf81" name="1em"/><!-- HANGUL SYLLABLE KWAB -->
+      <map code="0xcf82" name="1em"/><!-- HANGUL SYLLABLE KWABS -->
+      <map code="0xcf83" name="1em"/><!-- HANGUL SYLLABLE KWAS -->
+      <map code="0xcf84" name="1em"/><!-- HANGUL SYLLABLE KWASS -->
+      <map code="0xcf85" name="1em"/><!-- HANGUL SYLLABLE KWANG -->
+      <map code="0xcf86" name="1em"/><!-- HANGUL SYLLABLE KWAJ -->
+      <map code="0xcf87" name="1em"/><!-- HANGUL SYLLABLE KWAC -->
+      <map code="0xcf88" name="1em"/><!-- HANGUL SYLLABLE KWAK -->
+      <map code="0xcf89" name="1em"/><!-- HANGUL SYLLABLE KWAT -->
+      <map code="0xcf8a" name="1em"/><!-- HANGUL SYLLABLE KWAP -->
+      <map code="0xcf8b" name="1em"/><!-- HANGUL SYLLABLE KWAH -->
+      <map code="0xcf8c" name="1em"/><!-- HANGUL SYLLABLE KWAE -->
+      <map code="0xcf8d" name="1em"/><!-- HANGUL SYLLABLE KWAEG -->
+      <map code="0xcf8e" name="1em"/><!-- HANGUL SYLLABLE KWAEGG -->
+      <map code="0xcf8f" name="1em"/><!-- HANGUL SYLLABLE KWAEGS -->
+      <map code="0xcf90" name="1em"/><!-- HANGUL SYLLABLE KWAEN -->
+      <map code="0xcf91" name="1em"/><!-- HANGUL SYLLABLE KWAENJ -->
+      <map code="0xcf92" name="1em"/><!-- HANGUL SYLLABLE KWAENH -->
+      <map code="0xcf93" name="1em"/><!-- HANGUL SYLLABLE KWAED -->
+      <map code="0xcf94" name="1em"/><!-- HANGUL SYLLABLE KWAEL -->
+      <map code="0xcf95" name="1em"/><!-- HANGUL SYLLABLE KWAELG -->
+      <map code="0xcf96" name="1em"/><!-- HANGUL SYLLABLE KWAELM -->
+      <map code="0xcf97" name="1em"/><!-- HANGUL SYLLABLE KWAELB -->
+      <map code="0xcf98" name="1em"/><!-- HANGUL SYLLABLE KWAELS -->
+      <map code="0xcf99" name="1em"/><!-- HANGUL SYLLABLE KWAELT -->
+      <map code="0xcf9a" name="1em"/><!-- HANGUL SYLLABLE KWAELP -->
+      <map code="0xcf9b" name="1em"/><!-- HANGUL SYLLABLE KWAELH -->
+      <map code="0xcf9c" name="1em"/><!-- HANGUL SYLLABLE KWAEM -->
+      <map code="0xcf9d" name="1em"/><!-- HANGUL SYLLABLE KWAEB -->
+      <map code="0xcf9e" name="1em"/><!-- HANGUL SYLLABLE KWAEBS -->
+      <map code="0xcf9f" name="1em"/><!-- HANGUL SYLLABLE KWAES -->
+      <map code="0xcfa0" name="1em"/><!-- HANGUL SYLLABLE KWAESS -->
+      <map code="0xcfa1" name="1em"/><!-- HANGUL SYLLABLE KWAENG -->
+      <map code="0xcfa2" name="1em"/><!-- HANGUL SYLLABLE KWAEJ -->
+      <map code="0xcfa3" name="1em"/><!-- HANGUL SYLLABLE KWAEC -->
+      <map code="0xcfa4" name="1em"/><!-- HANGUL SYLLABLE KWAEK -->
+      <map code="0xcfa5" name="1em"/><!-- HANGUL SYLLABLE KWAET -->
+      <map code="0xcfa6" name="1em"/><!-- HANGUL SYLLABLE KWAEP -->
+      <map code="0xcfa7" name="1em"/><!-- HANGUL SYLLABLE KWAEH -->
+      <map code="0xcfa8" name="1em"/><!-- HANGUL SYLLABLE KOE -->
+      <map code="0xcfa9" name="1em"/><!-- HANGUL SYLLABLE KOEG -->
+      <map code="0xcfaa" name="1em"/><!-- HANGUL SYLLABLE KOEGG -->
+      <map code="0xcfab" name="1em"/><!-- HANGUL SYLLABLE KOEGS -->
+      <map code="0xcfac" name="1em"/><!-- HANGUL SYLLABLE KOEN -->
+      <map code="0xcfad" name="1em"/><!-- HANGUL SYLLABLE KOENJ -->
+      <map code="0xcfae" name="1em"/><!-- HANGUL SYLLABLE KOENH -->
+      <map code="0xcfaf" name="1em"/><!-- HANGUL SYLLABLE KOED -->
+      <map code="0xcfb0" name="1em"/><!-- HANGUL SYLLABLE KOEL -->
+      <map code="0xcfb1" name="1em"/><!-- HANGUL SYLLABLE KOELG -->
+      <map code="0xcfb2" name="1em"/><!-- HANGUL SYLLABLE KOELM -->
+      <map code="0xcfb3" name="1em"/><!-- HANGUL SYLLABLE KOELB -->
+      <map code="0xcfb4" name="1em"/><!-- HANGUL SYLLABLE KOELS -->
+      <map code="0xcfb5" name="1em"/><!-- HANGUL SYLLABLE KOELT -->
+      <map code="0xcfb6" name="1em"/><!-- HANGUL SYLLABLE KOELP -->
+      <map code="0xcfb7" name="1em"/><!-- HANGUL SYLLABLE KOELH -->
+      <map code="0xcfb8" name="1em"/><!-- HANGUL SYLLABLE KOEM -->
+      <map code="0xcfb9" name="1em"/><!-- HANGUL SYLLABLE KOEB -->
+      <map code="0xcfba" name="1em"/><!-- HANGUL SYLLABLE KOEBS -->
+      <map code="0xcfbb" name="1em"/><!-- HANGUL SYLLABLE KOES -->
+      <map code="0xcfbc" name="1em"/><!-- HANGUL SYLLABLE KOESS -->
+      <map code="0xcfbd" name="1em"/><!-- HANGUL SYLLABLE KOENG -->
+      <map code="0xcfbe" name="1em"/><!-- HANGUL SYLLABLE KOEJ -->
+      <map code="0xcfbf" name="1em"/><!-- HANGUL SYLLABLE KOEC -->
+      <map code="0xcfc0" name="1em"/><!-- HANGUL SYLLABLE KOEK -->
+      <map code="0xcfc1" name="1em"/><!-- HANGUL SYLLABLE KOET -->
+      <map code="0xcfc2" name="1em"/><!-- HANGUL SYLLABLE KOEP -->
+      <map code="0xcfc3" name="1em"/><!-- HANGUL SYLLABLE KOEH -->
+      <map code="0xcfc4" name="1em"/><!-- HANGUL SYLLABLE KYO -->
+      <map code="0xcfc5" name="1em"/><!-- HANGUL SYLLABLE KYOG -->
+      <map code="0xcfc6" name="1em"/><!-- HANGUL SYLLABLE KYOGG -->
+      <map code="0xcfc7" name="1em"/><!-- HANGUL SYLLABLE KYOGS -->
+      <map code="0xcfc8" name="1em"/><!-- HANGUL SYLLABLE KYON -->
+      <map code="0xcfc9" name="1em"/><!-- HANGUL SYLLABLE KYONJ -->
+      <map code="0xcfca" name="1em"/><!-- HANGUL SYLLABLE KYONH -->
+      <map code="0xcfcb" name="1em"/><!-- HANGUL SYLLABLE KYOD -->
+      <map code="0xcfcc" name="1em"/><!-- HANGUL SYLLABLE KYOL -->
+      <map code="0xcfcd" name="1em"/><!-- HANGUL SYLLABLE KYOLG -->
+      <map code="0xcfce" name="1em"/><!-- HANGUL SYLLABLE KYOLM -->
+      <map code="0xcfcf" name="1em"/><!-- HANGUL SYLLABLE KYOLB -->
+      <map code="0xcfd0" name="1em"/><!-- HANGUL SYLLABLE KYOLS -->
+      <map code="0xcfd1" name="1em"/><!-- HANGUL SYLLABLE KYOLT -->
+      <map code="0xcfd2" name="1em"/><!-- HANGUL SYLLABLE KYOLP -->
+      <map code="0xcfd3" name="1em"/><!-- HANGUL SYLLABLE KYOLH -->
+      <map code="0xcfd4" name="1em"/><!-- HANGUL SYLLABLE KYOM -->
+      <map code="0xcfd5" name="1em"/><!-- HANGUL SYLLABLE KYOB -->
+      <map code="0xcfd6" name="1em"/><!-- HANGUL SYLLABLE KYOBS -->
+      <map code="0xcfd7" name="1em"/><!-- HANGUL SYLLABLE KYOS -->
+      <map code="0xcfd8" name="1em"/><!-- HANGUL SYLLABLE KYOSS -->
+      <map code="0xcfd9" name="1em"/><!-- HANGUL SYLLABLE KYONG -->
+      <map code="0xcfda" name="1em"/><!-- HANGUL SYLLABLE KYOJ -->
+      <map code="0xcfdb" name="1em"/><!-- HANGUL SYLLABLE KYOC -->
+      <map code="0xcfdc" name="1em"/><!-- HANGUL SYLLABLE KYOK -->
+      <map code="0xcfdd" name="1em"/><!-- HANGUL SYLLABLE KYOT -->
+      <map code="0xcfde" name="1em"/><!-- HANGUL SYLLABLE KYOP -->
+      <map code="0xcfdf" name="1em"/><!-- HANGUL SYLLABLE KYOH -->
+      <map code="0xcfe0" name="1em"/><!-- HANGUL SYLLABLE KU -->
+      <map code="0xcfe1" name="1em"/><!-- HANGUL SYLLABLE KUG -->
+      <map code="0xcfe2" name="1em"/><!-- HANGUL SYLLABLE KUGG -->
+      <map code="0xcfe3" name="1em"/><!-- HANGUL SYLLABLE KUGS -->
+      <map code="0xcfe4" name="1em"/><!-- HANGUL SYLLABLE KUN -->
+      <map code="0xcfe5" name="1em"/><!-- HANGUL SYLLABLE KUNJ -->
+      <map code="0xcfe6" name="1em"/><!-- HANGUL SYLLABLE KUNH -->
+      <map code="0xcfe7" name="1em"/><!-- HANGUL SYLLABLE KUD -->
+      <map code="0xcfe8" name="1em"/><!-- HANGUL SYLLABLE KUL -->
+      <map code="0xcfe9" name="1em"/><!-- HANGUL SYLLABLE KULG -->
+      <map code="0xcfea" name="1em"/><!-- HANGUL SYLLABLE KULM -->
+      <map code="0xcfeb" name="1em"/><!-- HANGUL SYLLABLE KULB -->
+      <map code="0xcfec" name="1em"/><!-- HANGUL SYLLABLE KULS -->
+      <map code="0xcfed" name="1em"/><!-- HANGUL SYLLABLE KULT -->
+      <map code="0xcfee" name="1em"/><!-- HANGUL SYLLABLE KULP -->
+      <map code="0xcfef" name="1em"/><!-- HANGUL SYLLABLE KULH -->
+      <map code="0xcff0" name="1em"/><!-- HANGUL SYLLABLE KUM -->
+      <map code="0xcff1" name="1em"/><!-- HANGUL SYLLABLE KUB -->
+      <map code="0xcff2" name="1em"/><!-- HANGUL SYLLABLE KUBS -->
+      <map code="0xcff3" name="1em"/><!-- HANGUL SYLLABLE KUS -->
+      <map code="0xcff4" name="1em"/><!-- HANGUL SYLLABLE KUSS -->
+      <map code="0xcff5" name="1em"/><!-- HANGUL SYLLABLE KUNG -->
+      <map code="0xcff6" name="1em"/><!-- HANGUL SYLLABLE KUJ -->
+      <map code="0xcff7" name="1em"/><!-- HANGUL SYLLABLE KUC -->
+      <map code="0xcff8" name="1em"/><!-- HANGUL SYLLABLE KUK -->
+      <map code="0xcff9" name="1em"/><!-- HANGUL SYLLABLE KUT -->
+      <map code="0xcffa" name="1em"/><!-- HANGUL SYLLABLE KUP -->
+      <map code="0xcffb" name="1em"/><!-- HANGUL SYLLABLE KUH -->
+      <map code="0xcffc" name="1em"/><!-- HANGUL SYLLABLE KWEO -->
+      <map code="0xcffd" name="1em"/><!-- HANGUL SYLLABLE KWEOG -->
+      <map code="0xcffe" name="1em"/><!-- HANGUL SYLLABLE KWEOGG -->
+      <map code="0xcfff" name="1em"/><!-- HANGUL SYLLABLE KWEOGS -->
+      <map code="0xd000" name="1em"/><!-- HANGUL SYLLABLE KWEON -->
+      <map code="0xd001" name="1em"/><!-- HANGUL SYLLABLE KWEONJ -->
+      <map code="0xd002" name="1em"/><!-- HANGUL SYLLABLE KWEONH -->
+      <map code="0xd003" name="1em"/><!-- HANGUL SYLLABLE KWEOD -->
+      <map code="0xd004" name="1em"/><!-- HANGUL SYLLABLE KWEOL -->
+      <map code="0xd005" name="1em"/><!-- HANGUL SYLLABLE KWEOLG -->
+      <map code="0xd006" name="1em"/><!-- HANGUL SYLLABLE KWEOLM -->
+      <map code="0xd007" name="1em"/><!-- HANGUL SYLLABLE KWEOLB -->
+      <map code="0xd008" name="1em"/><!-- HANGUL SYLLABLE KWEOLS -->
+      <map code="0xd009" name="1em"/><!-- HANGUL SYLLABLE KWEOLT -->
+      <map code="0xd00a" name="1em"/><!-- HANGUL SYLLABLE KWEOLP -->
+      <map code="0xd00b" name="1em"/><!-- HANGUL SYLLABLE KWEOLH -->
+      <map code="0xd00c" name="1em"/><!-- HANGUL SYLLABLE KWEOM -->
+      <map code="0xd00d" name="1em"/><!-- HANGUL SYLLABLE KWEOB -->
+      <map code="0xd00e" name="1em"/><!-- HANGUL SYLLABLE KWEOBS -->
+      <map code="0xd00f" name="1em"/><!-- HANGUL SYLLABLE KWEOS -->
+      <map code="0xd010" name="1em"/><!-- HANGUL SYLLABLE KWEOSS -->
+      <map code="0xd011" name="1em"/><!-- HANGUL SYLLABLE KWEONG -->
+      <map code="0xd012" name="1em"/><!-- HANGUL SYLLABLE KWEOJ -->
+      <map code="0xd013" name="1em"/><!-- HANGUL SYLLABLE KWEOC -->
+      <map code="0xd014" name="1em"/><!-- HANGUL SYLLABLE KWEOK -->
+      <map code="0xd015" name="1em"/><!-- HANGUL SYLLABLE KWEOT -->
+      <map code="0xd016" name="1em"/><!-- HANGUL SYLLABLE KWEOP -->
+      <map code="0xd017" name="1em"/><!-- HANGUL SYLLABLE KWEOH -->
+      <map code="0xd018" name="1em"/><!-- HANGUL SYLLABLE KWE -->
+      <map code="0xd019" name="1em"/><!-- HANGUL SYLLABLE KWEG -->
+      <map code="0xd01a" name="1em"/><!-- HANGUL SYLLABLE KWEGG -->
+      <map code="0xd01b" name="1em"/><!-- HANGUL SYLLABLE KWEGS -->
+      <map code="0xd01c" name="1em"/><!-- HANGUL SYLLABLE KWEN -->
+      <map code="0xd01d" name="1em"/><!-- HANGUL SYLLABLE KWENJ -->
+      <map code="0xd01e" name="1em"/><!-- HANGUL SYLLABLE KWENH -->
+      <map code="0xd01f" name="1em"/><!-- HANGUL SYLLABLE KWED -->
+      <map code="0xd020" name="1em"/><!-- HANGUL SYLLABLE KWEL -->
+      <map code="0xd021" name="1em"/><!-- HANGUL SYLLABLE KWELG -->
+      <map code="0xd022" name="1em"/><!-- HANGUL SYLLABLE KWELM -->
+      <map code="0xd023" name="1em"/><!-- HANGUL SYLLABLE KWELB -->
+      <map code="0xd024" name="1em"/><!-- HANGUL SYLLABLE KWELS -->
+      <map code="0xd025" name="1em"/><!-- HANGUL SYLLABLE KWELT -->
+      <map code="0xd026" name="1em"/><!-- HANGUL SYLLABLE KWELP -->
+      <map code="0xd027" name="1em"/><!-- HANGUL SYLLABLE KWELH -->
+      <map code="0xd028" name="1em"/><!-- HANGUL SYLLABLE KWEM -->
+      <map code="0xd029" name="1em"/><!-- HANGUL SYLLABLE KWEB -->
+      <map code="0xd02a" name="1em"/><!-- HANGUL SYLLABLE KWEBS -->
+      <map code="0xd02b" name="1em"/><!-- HANGUL SYLLABLE KWES -->
+      <map code="0xd02c" name="1em"/><!-- HANGUL SYLLABLE KWESS -->
+      <map code="0xd02d" name="1em"/><!-- HANGUL SYLLABLE KWENG -->
+      <map code="0xd02e" name="1em"/><!-- HANGUL SYLLABLE KWEJ -->
+      <map code="0xd02f" name="1em"/><!-- HANGUL SYLLABLE KWEC -->
+      <map code="0xd030" name="1em"/><!-- HANGUL SYLLABLE KWEK -->
+      <map code="0xd031" name="1em"/><!-- HANGUL SYLLABLE KWET -->
+      <map code="0xd032" name="1em"/><!-- HANGUL SYLLABLE KWEP -->
+      <map code="0xd033" name="1em"/><!-- HANGUL SYLLABLE KWEH -->
+      <map code="0xd034" name="1em"/><!-- HANGUL SYLLABLE KWI -->
+      <map code="0xd035" name="1em"/><!-- HANGUL SYLLABLE KWIG -->
+      <map code="0xd036" name="1em"/><!-- HANGUL SYLLABLE KWIGG -->
+      <map code="0xd037" name="1em"/><!-- HANGUL SYLLABLE KWIGS -->
+      <map code="0xd038" name="1em"/><!-- HANGUL SYLLABLE KWIN -->
+      <map code="0xd039" name="1em"/><!-- HANGUL SYLLABLE KWINJ -->
+      <map code="0xd03a" name="1em"/><!-- HANGUL SYLLABLE KWINH -->
+      <map code="0xd03b" name="1em"/><!-- HANGUL SYLLABLE KWID -->
+      <map code="0xd03c" name="1em"/><!-- HANGUL SYLLABLE KWIL -->
+      <map code="0xd03d" name="1em"/><!-- HANGUL SYLLABLE KWILG -->
+      <map code="0xd03e" name="1em"/><!-- HANGUL SYLLABLE KWILM -->
+      <map code="0xd03f" name="1em"/><!-- HANGUL SYLLABLE KWILB -->
+      <map code="0xd040" name="1em"/><!-- HANGUL SYLLABLE KWILS -->
+      <map code="0xd041" name="1em"/><!-- HANGUL SYLLABLE KWILT -->
+      <map code="0xd042" name="1em"/><!-- HANGUL SYLLABLE KWILP -->
+      <map code="0xd043" name="1em"/><!-- HANGUL SYLLABLE KWILH -->
+      <map code="0xd044" name="1em"/><!-- HANGUL SYLLABLE KWIM -->
+      <map code="0xd045" name="1em"/><!-- HANGUL SYLLABLE KWIB -->
+      <map code="0xd046" name="1em"/><!-- HANGUL SYLLABLE KWIBS -->
+      <map code="0xd047" name="1em"/><!-- HANGUL SYLLABLE KWIS -->
+      <map code="0xd048" name="1em"/><!-- HANGUL SYLLABLE KWISS -->
+      <map code="0xd049" name="1em"/><!-- HANGUL SYLLABLE KWING -->
+      <map code="0xd04a" name="1em"/><!-- HANGUL SYLLABLE KWIJ -->
+      <map code="0xd04b" name="1em"/><!-- HANGUL SYLLABLE KWIC -->
+      <map code="0xd04c" name="1em"/><!-- HANGUL SYLLABLE KWIK -->
+      <map code="0xd04d" name="1em"/><!-- HANGUL SYLLABLE KWIT -->
+      <map code="0xd04e" name="1em"/><!-- HANGUL SYLLABLE KWIP -->
+      <map code="0xd04f" name="1em"/><!-- HANGUL SYLLABLE KWIH -->
+      <map code="0xd050" name="1em"/><!-- HANGUL SYLLABLE KYU -->
+      <map code="0xd051" name="1em"/><!-- HANGUL SYLLABLE KYUG -->
+      <map code="0xd052" name="1em"/><!-- HANGUL SYLLABLE KYUGG -->
+      <map code="0xd053" name="1em"/><!-- HANGUL SYLLABLE KYUGS -->
+      <map code="0xd054" name="1em"/><!-- HANGUL SYLLABLE KYUN -->
+      <map code="0xd055" name="1em"/><!-- HANGUL SYLLABLE KYUNJ -->
+      <map code="0xd056" name="1em"/><!-- HANGUL SYLLABLE KYUNH -->
+      <map code="0xd057" name="1em"/><!-- HANGUL SYLLABLE KYUD -->
+      <map code="0xd058" name="1em"/><!-- HANGUL SYLLABLE KYUL -->
+      <map code="0xd059" name="1em"/><!-- HANGUL SYLLABLE KYULG -->
+      <map code="0xd05a" name="1em"/><!-- HANGUL SYLLABLE KYULM -->
+      <map code="0xd05b" name="1em"/><!-- HANGUL SYLLABLE KYULB -->
+      <map code="0xd05c" name="1em"/><!-- HANGUL SYLLABLE KYULS -->
+      <map code="0xd05d" name="1em"/><!-- HANGUL SYLLABLE KYULT -->
+      <map code="0xd05e" name="1em"/><!-- HANGUL SYLLABLE KYULP -->
+      <map code="0xd05f" name="1em"/><!-- HANGUL SYLLABLE KYULH -->
+      <map code="0xd060" name="1em"/><!-- HANGUL SYLLABLE KYUM -->
+      <map code="0xd061" name="1em"/><!-- HANGUL SYLLABLE KYUB -->
+      <map code="0xd062" name="1em"/><!-- HANGUL SYLLABLE KYUBS -->
+      <map code="0xd063" name="1em"/><!-- HANGUL SYLLABLE KYUS -->
+      <map code="0xd064" name="1em"/><!-- HANGUL SYLLABLE KYUSS -->
+      <map code="0xd065" name="1em"/><!-- HANGUL SYLLABLE KYUNG -->
+      <map code="0xd066" name="1em"/><!-- HANGUL SYLLABLE KYUJ -->
+      <map code="0xd067" name="1em"/><!-- HANGUL SYLLABLE KYUC -->
+      <map code="0xd068" name="1em"/><!-- HANGUL SYLLABLE KYUK -->
+      <map code="0xd069" name="1em"/><!-- HANGUL SYLLABLE KYUT -->
+      <map code="0xd06a" name="1em"/><!-- HANGUL SYLLABLE KYUP -->
+      <map code="0xd06b" name="1em"/><!-- HANGUL SYLLABLE KYUH -->
+      <map code="0xd06c" name="1em"/><!-- HANGUL SYLLABLE KEU -->
+      <map code="0xd06d" name="1em"/><!-- HANGUL SYLLABLE KEUG -->
+      <map code="0xd06e" name="1em"/><!-- HANGUL SYLLABLE KEUGG -->
+      <map code="0xd06f" name="1em"/><!-- HANGUL SYLLABLE KEUGS -->
+      <map code="0xd070" name="1em"/><!-- HANGUL SYLLABLE KEUN -->
+      <map code="0xd071" name="1em"/><!-- HANGUL SYLLABLE KEUNJ -->
+      <map code="0xd072" name="1em"/><!-- HANGUL SYLLABLE KEUNH -->
+      <map code="0xd073" name="1em"/><!-- HANGUL SYLLABLE KEUD -->
+      <map code="0xd074" name="1em"/><!-- HANGUL SYLLABLE KEUL -->
+      <map code="0xd075" name="1em"/><!-- HANGUL SYLLABLE KEULG -->
+      <map code="0xd076" name="1em"/><!-- HANGUL SYLLABLE KEULM -->
+      <map code="0xd077" name="1em"/><!-- HANGUL SYLLABLE KEULB -->
+      <map code="0xd078" name="1em"/><!-- HANGUL SYLLABLE KEULS -->
+      <map code="0xd079" name="1em"/><!-- HANGUL SYLLABLE KEULT -->
+      <map code="0xd07a" name="1em"/><!-- HANGUL SYLLABLE KEULP -->
+      <map code="0xd07b" name="1em"/><!-- HANGUL SYLLABLE KEULH -->
+      <map code="0xd07c" name="1em"/><!-- HANGUL SYLLABLE KEUM -->
+      <map code="0xd07d" name="1em"/><!-- HANGUL SYLLABLE KEUB -->
+      <map code="0xd07e" name="1em"/><!-- HANGUL SYLLABLE KEUBS -->
+      <map code="0xd07f" name="1em"/><!-- HANGUL SYLLABLE KEUS -->
+      <map code="0xd080" name="1em"/><!-- HANGUL SYLLABLE KEUSS -->
+      <map code="0xd081" name="1em"/><!-- HANGUL SYLLABLE KEUNG -->
+      <map code="0xd082" name="1em"/><!-- HANGUL SYLLABLE KEUJ -->
+      <map code="0xd083" name="1em"/><!-- HANGUL SYLLABLE KEUC -->
+      <map code="0xd084" name="1em"/><!-- HANGUL SYLLABLE KEUK -->
+      <map code="0xd085" name="1em"/><!-- HANGUL SYLLABLE KEUT -->
+      <map code="0xd086" name="1em"/><!-- HANGUL SYLLABLE KEUP -->
+      <map code="0xd087" name="1em"/><!-- HANGUL SYLLABLE KEUH -->
+      <map code="0xd088" name="1em"/><!-- HANGUL SYLLABLE KYI -->
+      <map code="0xd089" name="1em"/><!-- HANGUL SYLLABLE KYIG -->
+      <map code="0xd08a" name="1em"/><!-- HANGUL SYLLABLE KYIGG -->
+      <map code="0xd08b" name="1em"/><!-- HANGUL SYLLABLE KYIGS -->
+      <map code="0xd08c" name="1em"/><!-- HANGUL SYLLABLE KYIN -->
+      <map code="0xd08d" name="1em"/><!-- HANGUL SYLLABLE KYINJ -->
+      <map code="0xd08e" name="1em"/><!-- HANGUL SYLLABLE KYINH -->
+      <map code="0xd08f" name="1em"/><!-- HANGUL SYLLABLE KYID -->
+      <map code="0xd090" name="1em"/><!-- HANGUL SYLLABLE KYIL -->
+      <map code="0xd091" name="1em"/><!-- HANGUL SYLLABLE KYILG -->
+      <map code="0xd092" name="1em"/><!-- HANGUL SYLLABLE KYILM -->
+      <map code="0xd093" name="1em"/><!-- HANGUL SYLLABLE KYILB -->
+      <map code="0xd094" name="1em"/><!-- HANGUL SYLLABLE KYILS -->
+      <map code="0xd095" name="1em"/><!-- HANGUL SYLLABLE KYILT -->
+      <map code="0xd096" name="1em"/><!-- HANGUL SYLLABLE KYILP -->
+      <map code="0xd097" name="1em"/><!-- HANGUL SYLLABLE KYILH -->
+      <map code="0xd098" name="1em"/><!-- HANGUL SYLLABLE KYIM -->
+      <map code="0xd099" name="1em"/><!-- HANGUL SYLLABLE KYIB -->
+      <map code="0xd09a" name="1em"/><!-- HANGUL SYLLABLE KYIBS -->
+      <map code="0xd09b" name="1em"/><!-- HANGUL SYLLABLE KYIS -->
+      <map code="0xd09c" name="1em"/><!-- HANGUL SYLLABLE KYISS -->
+      <map code="0xd09d" name="1em"/><!-- HANGUL SYLLABLE KYING -->
+      <map code="0xd09e" name="1em"/><!-- HANGUL SYLLABLE KYIJ -->
+      <map code="0xd09f" name="1em"/><!-- HANGUL SYLLABLE KYIC -->
+      <map code="0xd0a0" name="1em"/><!-- HANGUL SYLLABLE KYIK -->
+      <map code="0xd0a1" name="1em"/><!-- HANGUL SYLLABLE KYIT -->
+      <map code="0xd0a2" name="1em"/><!-- HANGUL SYLLABLE KYIP -->
+      <map code="0xd0a3" name="1em"/><!-- HANGUL SYLLABLE KYIH -->
+      <map code="0xd0a4" name="1em"/><!-- HANGUL SYLLABLE KI -->
+      <map code="0xd0a5" name="1em"/><!-- HANGUL SYLLABLE KIG -->
+      <map code="0xd0a6" name="1em"/><!-- HANGUL SYLLABLE KIGG -->
+      <map code="0xd0a7" name="1em"/><!-- HANGUL SYLLABLE KIGS -->
+      <map code="0xd0a8" name="1em"/><!-- HANGUL SYLLABLE KIN -->
+      <map code="0xd0a9" name="1em"/><!-- HANGUL SYLLABLE KINJ -->
+      <map code="0xd0aa" name="1em"/><!-- HANGUL SYLLABLE KINH -->
+      <map code="0xd0ab" name="1em"/><!-- HANGUL SYLLABLE KID -->
+      <map code="0xd0ac" name="1em"/><!-- HANGUL SYLLABLE KIL -->
+      <map code="0xd0ad" name="1em"/><!-- HANGUL SYLLABLE KILG -->
+      <map code="0xd0ae" name="1em"/><!-- HANGUL SYLLABLE KILM -->
+      <map code="0xd0af" name="1em"/><!-- HANGUL SYLLABLE KILB -->
+      <map code="0xd0b0" name="1em"/><!-- HANGUL SYLLABLE KILS -->
+      <map code="0xd0b1" name="1em"/><!-- HANGUL SYLLABLE KILT -->
+      <map code="0xd0b2" name="1em"/><!-- HANGUL SYLLABLE KILP -->
+      <map code="0xd0b3" name="1em"/><!-- HANGUL SYLLABLE KILH -->
+      <map code="0xd0b4" name="1em"/><!-- HANGUL SYLLABLE KIM -->
+      <map code="0xd0b5" name="1em"/><!-- HANGUL SYLLABLE KIB -->
+      <map code="0xd0b6" name="1em"/><!-- HANGUL SYLLABLE KIBS -->
+      <map code="0xd0b7" name="1em"/><!-- HANGUL SYLLABLE KIS -->
+      <map code="0xd0b8" name="1em"/><!-- HANGUL SYLLABLE KISS -->
+      <map code="0xd0b9" name="1em"/><!-- HANGUL SYLLABLE KING -->
+      <map code="0xd0ba" name="1em"/><!-- HANGUL SYLLABLE KIJ -->
+      <map code="0xd0bb" name="1em"/><!-- HANGUL SYLLABLE KIC -->
+      <map code="0xd0bc" name="1em"/><!-- HANGUL SYLLABLE KIK -->
+      <map code="0xd0bd" name="1em"/><!-- HANGUL SYLLABLE KIT -->
+      <map code="0xd0be" name="1em"/><!-- HANGUL SYLLABLE KIP -->
+      <map code="0xd0bf" name="1em"/><!-- HANGUL SYLLABLE KIH -->
+      <map code="0xd0c0" name="1em"/><!-- HANGUL SYLLABLE TA -->
+      <map code="0xd0c1" name="1em"/><!-- HANGUL SYLLABLE TAG -->
+      <map code="0xd0c2" name="1em"/><!-- HANGUL SYLLABLE TAGG -->
+      <map code="0xd0c3" name="1em"/><!-- HANGUL SYLLABLE TAGS -->
+      <map code="0xd0c4" name="1em"/><!-- HANGUL SYLLABLE TAN -->
+      <map code="0xd0c5" name="1em"/><!-- HANGUL SYLLABLE TANJ -->
+      <map code="0xd0c6" name="1em"/><!-- HANGUL SYLLABLE TANH -->
+      <map code="0xd0c7" name="1em"/><!-- HANGUL SYLLABLE TAD -->
+      <map code="0xd0c8" name="1em"/><!-- HANGUL SYLLABLE TAL -->
+      <map code="0xd0c9" name="1em"/><!-- HANGUL SYLLABLE TALG -->
+      <map code="0xd0ca" name="1em"/><!-- HANGUL SYLLABLE TALM -->
+      <map code="0xd0cb" name="1em"/><!-- HANGUL SYLLABLE TALB -->
+      <map code="0xd0cc" name="1em"/><!-- HANGUL SYLLABLE TALS -->
+      <map code="0xd0cd" name="1em"/><!-- HANGUL SYLLABLE TALT -->
+      <map code="0xd0ce" name="1em"/><!-- HANGUL SYLLABLE TALP -->
+      <map code="0xd0cf" name="1em"/><!-- HANGUL SYLLABLE TALH -->
+      <map code="0xd0d0" name="1em"/><!-- HANGUL SYLLABLE TAM -->
+      <map code="0xd0d1" name="1em"/><!-- HANGUL SYLLABLE TAB -->
+      <map code="0xd0d2" name="1em"/><!-- HANGUL SYLLABLE TABS -->
+      <map code="0xd0d3" name="1em"/><!-- HANGUL SYLLABLE TAS -->
+      <map code="0xd0d4" name="1em"/><!-- HANGUL SYLLABLE TASS -->
+      <map code="0xd0d5" name="1em"/><!-- HANGUL SYLLABLE TANG -->
+      <map code="0xd0d6" name="1em"/><!-- HANGUL SYLLABLE TAJ -->
+      <map code="0xd0d7" name="1em"/><!-- HANGUL SYLLABLE TAC -->
+      <map code="0xd0d8" name="1em"/><!-- HANGUL SYLLABLE TAK -->
+      <map code="0xd0d9" name="1em"/><!-- HANGUL SYLLABLE TAT -->
+      <map code="0xd0da" name="1em"/><!-- HANGUL SYLLABLE TAP -->
+      <map code="0xd0db" name="1em"/><!-- HANGUL SYLLABLE TAH -->
+      <map code="0xd0dc" name="1em"/><!-- HANGUL SYLLABLE TAE -->
+      <map code="0xd0dd" name="1em"/><!-- HANGUL SYLLABLE TAEG -->
+      <map code="0xd0de" name="1em"/><!-- HANGUL SYLLABLE TAEGG -->
+      <map code="0xd0df" name="1em"/><!-- HANGUL SYLLABLE TAEGS -->
+      <map code="0xd0e0" name="1em"/><!-- HANGUL SYLLABLE TAEN -->
+      <map code="0xd0e1" name="1em"/><!-- HANGUL SYLLABLE TAENJ -->
+      <map code="0xd0e2" name="1em"/><!-- HANGUL SYLLABLE TAENH -->
+      <map code="0xd0e3" name="1em"/><!-- HANGUL SYLLABLE TAED -->
+      <map code="0xd0e4" name="1em"/><!-- HANGUL SYLLABLE TAEL -->
+      <map code="0xd0e5" name="1em"/><!-- HANGUL SYLLABLE TAELG -->
+      <map code="0xd0e6" name="1em"/><!-- HANGUL SYLLABLE TAELM -->
+      <map code="0xd0e7" name="1em"/><!-- HANGUL SYLLABLE TAELB -->
+      <map code="0xd0e8" name="1em"/><!-- HANGUL SYLLABLE TAELS -->
+      <map code="0xd0e9" name="1em"/><!-- HANGUL SYLLABLE TAELT -->
+      <map code="0xd0ea" name="1em"/><!-- HANGUL SYLLABLE TAELP -->
+      <map code="0xd0eb" name="1em"/><!-- HANGUL SYLLABLE TAELH -->
+      <map code="0xd0ec" name="1em"/><!-- HANGUL SYLLABLE TAEM -->
+      <map code="0xd0ed" name="1em"/><!-- HANGUL SYLLABLE TAEB -->
+      <map code="0xd0ee" name="1em"/><!-- HANGUL SYLLABLE TAEBS -->
+      <map code="0xd0ef" name="1em"/><!-- HANGUL SYLLABLE TAES -->
+      <map code="0xd0f0" name="1em"/><!-- HANGUL SYLLABLE TAESS -->
+      <map code="0xd0f1" name="1em"/><!-- HANGUL SYLLABLE TAENG -->
+      <map code="0xd0f2" name="1em"/><!-- HANGUL SYLLABLE TAEJ -->
+      <map code="0xd0f3" name="1em"/><!-- HANGUL SYLLABLE TAEC -->
+      <map code="0xd0f4" name="1em"/><!-- HANGUL SYLLABLE TAEK -->
+      <map code="0xd0f5" name="1em"/><!-- HANGUL SYLLABLE TAET -->
+      <map code="0xd0f6" name="1em"/><!-- HANGUL SYLLABLE TAEP -->
+      <map code="0xd0f7" name="1em"/><!-- HANGUL SYLLABLE TAEH -->
+      <map code="0xd0f8" name="1em"/><!-- HANGUL SYLLABLE TYA -->
+      <map code="0xd0f9" name="1em"/><!-- HANGUL SYLLABLE TYAG -->
+      <map code="0xd0fa" name="1em"/><!-- HANGUL SYLLABLE TYAGG -->
+      <map code="0xd0fb" name="1em"/><!-- HANGUL SYLLABLE TYAGS -->
+      <map code="0xd0fc" name="1em"/><!-- HANGUL SYLLABLE TYAN -->
+      <map code="0xd0fd" name="1em"/><!-- HANGUL SYLLABLE TYANJ -->
+      <map code="0xd0fe" name="1em"/><!-- HANGUL SYLLABLE TYANH -->
+      <map code="0xd0ff" name="1em"/><!-- HANGUL SYLLABLE TYAD -->
+      <map code="0xd100" name="1em"/><!-- HANGUL SYLLABLE TYAL -->
+      <map code="0xd101" name="1em"/><!-- HANGUL SYLLABLE TYALG -->
+      <map code="0xd102" name="1em"/><!-- HANGUL SYLLABLE TYALM -->
+      <map code="0xd103" name="1em"/><!-- HANGUL SYLLABLE TYALB -->
+      <map code="0xd104" name="1em"/><!-- HANGUL SYLLABLE TYALS -->
+      <map code="0xd105" name="1em"/><!-- HANGUL SYLLABLE TYALT -->
+      <map code="0xd106" name="1em"/><!-- HANGUL SYLLABLE TYALP -->
+      <map code="0xd107" name="1em"/><!-- HANGUL SYLLABLE TYALH -->
+      <map code="0xd108" name="1em"/><!-- HANGUL SYLLABLE TYAM -->
+      <map code="0xd109" name="1em"/><!-- HANGUL SYLLABLE TYAB -->
+      <map code="0xd10a" name="1em"/><!-- HANGUL SYLLABLE TYABS -->
+      <map code="0xd10b" name="1em"/><!-- HANGUL SYLLABLE TYAS -->
+      <map code="0xd10c" name="1em"/><!-- HANGUL SYLLABLE TYASS -->
+      <map code="0xd10d" name="1em"/><!-- HANGUL SYLLABLE TYANG -->
+      <map code="0xd10e" name="1em"/><!-- HANGUL SYLLABLE TYAJ -->
+      <map code="0xd10f" name="1em"/><!-- HANGUL SYLLABLE TYAC -->
+      <map code="0xd110" name="1em"/><!-- HANGUL SYLLABLE TYAK -->
+      <map code="0xd111" name="1em"/><!-- HANGUL SYLLABLE TYAT -->
+      <map code="0xd112" name="1em"/><!-- HANGUL SYLLABLE TYAP -->
+      <map code="0xd113" name="1em"/><!-- HANGUL SYLLABLE TYAH -->
+      <map code="0xd114" name="1em"/><!-- HANGUL SYLLABLE TYAE -->
+      <map code="0xd115" name="1em"/><!-- HANGUL SYLLABLE TYAEG -->
+      <map code="0xd116" name="1em"/><!-- HANGUL SYLLABLE TYAEGG -->
+      <map code="0xd117" name="1em"/><!-- HANGUL SYLLABLE TYAEGS -->
+      <map code="0xd118" name="1em"/><!-- HANGUL SYLLABLE TYAEN -->
+      <map code="0xd119" name="1em"/><!-- HANGUL SYLLABLE TYAENJ -->
+      <map code="0xd11a" name="1em"/><!-- HANGUL SYLLABLE TYAENH -->
+      <map code="0xd11b" name="1em"/><!-- HANGUL SYLLABLE TYAED -->
+      <map code="0xd11c" name="1em"/><!-- HANGUL SYLLABLE TYAEL -->
+      <map code="0xd11d" name="1em"/><!-- HANGUL SYLLABLE TYAELG -->
+      <map code="0xd11e" name="1em"/><!-- HANGUL SYLLABLE TYAELM -->
+      <map code="0xd11f" name="1em"/><!-- HANGUL SYLLABLE TYAELB -->
+      <map code="0xd120" name="1em"/><!-- HANGUL SYLLABLE TYAELS -->
+      <map code="0xd121" name="1em"/><!-- HANGUL SYLLABLE TYAELT -->
+      <map code="0xd122" name="1em"/><!-- HANGUL SYLLABLE TYAELP -->
+      <map code="0xd123" name="1em"/><!-- HANGUL SYLLABLE TYAELH -->
+      <map code="0xd124" name="1em"/><!-- HANGUL SYLLABLE TYAEM -->
+      <map code="0xd125" name="1em"/><!-- HANGUL SYLLABLE TYAEB -->
+      <map code="0xd126" name="1em"/><!-- HANGUL SYLLABLE TYAEBS -->
+      <map code="0xd127" name="1em"/><!-- HANGUL SYLLABLE TYAES -->
+      <map code="0xd128" name="1em"/><!-- HANGUL SYLLABLE TYAESS -->
+      <map code="0xd129" name="1em"/><!-- HANGUL SYLLABLE TYAENG -->
+      <map code="0xd12a" name="1em"/><!-- HANGUL SYLLABLE TYAEJ -->
+      <map code="0xd12b" name="1em"/><!-- HANGUL SYLLABLE TYAEC -->
+      <map code="0xd12c" name="1em"/><!-- HANGUL SYLLABLE TYAEK -->
+      <map code="0xd12d" name="1em"/><!-- HANGUL SYLLABLE TYAET -->
+      <map code="0xd12e" name="1em"/><!-- HANGUL SYLLABLE TYAEP -->
+      <map code="0xd12f" name="1em"/><!-- HANGUL SYLLABLE TYAEH -->
+      <map code="0xd130" name="1em"/><!-- HANGUL SYLLABLE TEO -->
+      <map code="0xd131" name="1em"/><!-- HANGUL SYLLABLE TEOG -->
+      <map code="0xd132" name="1em"/><!-- HANGUL SYLLABLE TEOGG -->
+      <map code="0xd133" name="1em"/><!-- HANGUL SYLLABLE TEOGS -->
+      <map code="0xd134" name="1em"/><!-- HANGUL SYLLABLE TEON -->
+      <map code="0xd135" name="1em"/><!-- HANGUL SYLLABLE TEONJ -->
+      <map code="0xd136" name="1em"/><!-- HANGUL SYLLABLE TEONH -->
+      <map code="0xd137" name="1em"/><!-- HANGUL SYLLABLE TEOD -->
+      <map code="0xd138" name="1em"/><!-- HANGUL SYLLABLE TEOL -->
+      <map code="0xd139" name="1em"/><!-- HANGUL SYLLABLE TEOLG -->
+      <map code="0xd13a" name="1em"/><!-- HANGUL SYLLABLE TEOLM -->
+      <map code="0xd13b" name="1em"/><!-- HANGUL SYLLABLE TEOLB -->
+      <map code="0xd13c" name="1em"/><!-- HANGUL SYLLABLE TEOLS -->
+      <map code="0xd13d" name="1em"/><!-- HANGUL SYLLABLE TEOLT -->
+      <map code="0xd13e" name="1em"/><!-- HANGUL SYLLABLE TEOLP -->
+      <map code="0xd13f" name="1em"/><!-- HANGUL SYLLABLE TEOLH -->
+      <map code="0xd140" name="1em"/><!-- HANGUL SYLLABLE TEOM -->
+      <map code="0xd141" name="1em"/><!-- HANGUL SYLLABLE TEOB -->
+      <map code="0xd142" name="1em"/><!-- HANGUL SYLLABLE TEOBS -->
+      <map code="0xd143" name="1em"/><!-- HANGUL SYLLABLE TEOS -->
+      <map code="0xd144" name="1em"/><!-- HANGUL SYLLABLE TEOSS -->
+      <map code="0xd145" name="1em"/><!-- HANGUL SYLLABLE TEONG -->
+      <map code="0xd146" name="1em"/><!-- HANGUL SYLLABLE TEOJ -->
+      <map code="0xd147" name="1em"/><!-- HANGUL SYLLABLE TEOC -->
+      <map code="0xd148" name="1em"/><!-- HANGUL SYLLABLE TEOK -->
+      <map code="0xd149" name="1em"/><!-- HANGUL SYLLABLE TEOT -->
+      <map code="0xd14a" name="1em"/><!-- HANGUL SYLLABLE TEOP -->
+      <map code="0xd14b" name="1em"/><!-- HANGUL SYLLABLE TEOH -->
+      <map code="0xd14c" name="1em"/><!-- HANGUL SYLLABLE TE -->
+      <map code="0xd14d" name="1em"/><!-- HANGUL SYLLABLE TEG -->
+      <map code="0xd14e" name="1em"/><!-- HANGUL SYLLABLE TEGG -->
+      <map code="0xd14f" name="1em"/><!-- HANGUL SYLLABLE TEGS -->
+      <map code="0xd150" name="1em"/><!-- HANGUL SYLLABLE TEN -->
+      <map code="0xd151" name="1em"/><!-- HANGUL SYLLABLE TENJ -->
+      <map code="0xd152" name="1em"/><!-- HANGUL SYLLABLE TENH -->
+      <map code="0xd153" name="1em"/><!-- HANGUL SYLLABLE TED -->
+      <map code="0xd154" name="1em"/><!-- HANGUL SYLLABLE TEL -->
+      <map code="0xd155" name="1em"/><!-- HANGUL SYLLABLE TELG -->
+      <map code="0xd156" name="1em"/><!-- HANGUL SYLLABLE TELM -->
+      <map code="0xd157" name="1em"/><!-- HANGUL SYLLABLE TELB -->
+      <map code="0xd158" name="1em"/><!-- HANGUL SYLLABLE TELS -->
+      <map code="0xd159" name="1em"/><!-- HANGUL SYLLABLE TELT -->
+      <map code="0xd15a" name="1em"/><!-- HANGUL SYLLABLE TELP -->
+      <map code="0xd15b" name="1em"/><!-- HANGUL SYLLABLE TELH -->
+      <map code="0xd15c" name="1em"/><!-- HANGUL SYLLABLE TEM -->
+      <map code="0xd15d" name="1em"/><!-- HANGUL SYLLABLE TEB -->
+      <map code="0xd15e" name="1em"/><!-- HANGUL SYLLABLE TEBS -->
+      <map code="0xd15f" name="1em"/><!-- HANGUL SYLLABLE TES -->
+      <map code="0xd160" name="1em"/><!-- HANGUL SYLLABLE TESS -->
+      <map code="0xd161" name="1em"/><!-- HANGUL SYLLABLE TENG -->
+      <map code="0xd162" name="1em"/><!-- HANGUL SYLLABLE TEJ -->
+      <map code="0xd163" name="1em"/><!-- HANGUL SYLLABLE TEC -->
+      <map code="0xd164" name="1em"/><!-- HANGUL SYLLABLE TEK -->
+      <map code="0xd165" name="1em"/><!-- HANGUL SYLLABLE TET -->
+      <map code="0xd166" name="1em"/><!-- HANGUL SYLLABLE TEP -->
+      <map code="0xd167" name="1em"/><!-- HANGUL SYLLABLE TEH -->
+      <map code="0xd168" name="1em"/><!-- HANGUL SYLLABLE TYEO -->
+      <map code="0xd169" name="1em"/><!-- HANGUL SYLLABLE TYEOG -->
+      <map code="0xd16a" name="1em"/><!-- HANGUL SYLLABLE TYEOGG -->
+      <map code="0xd16b" name="1em"/><!-- HANGUL SYLLABLE TYEOGS -->
+      <map code="0xd16c" name="1em"/><!-- HANGUL SYLLABLE TYEON -->
+      <map code="0xd16d" name="1em"/><!-- HANGUL SYLLABLE TYEONJ -->
+      <map code="0xd16e" name="1em"/><!-- HANGUL SYLLABLE TYEONH -->
+      <map code="0xd16f" name="1em"/><!-- HANGUL SYLLABLE TYEOD -->
+      <map code="0xd170" name="1em"/><!-- HANGUL SYLLABLE TYEOL -->
+      <map code="0xd171" name="1em"/><!-- HANGUL SYLLABLE TYEOLG -->
+      <map code="0xd172" name="1em"/><!-- HANGUL SYLLABLE TYEOLM -->
+      <map code="0xd173" name="1em"/><!-- HANGUL SYLLABLE TYEOLB -->
+      <map code="0xd174" name="1em"/><!-- HANGUL SYLLABLE TYEOLS -->
+      <map code="0xd175" name="1em"/><!-- HANGUL SYLLABLE TYEOLT -->
+      <map code="0xd176" name="1em"/><!-- HANGUL SYLLABLE TYEOLP -->
+      <map code="0xd177" name="1em"/><!-- HANGUL SYLLABLE TYEOLH -->
+      <map code="0xd178" name="1em"/><!-- HANGUL SYLLABLE TYEOM -->
+      <map code="0xd179" name="1em"/><!-- HANGUL SYLLABLE TYEOB -->
+      <map code="0xd17a" name="1em"/><!-- HANGUL SYLLABLE TYEOBS -->
+      <map code="0xd17b" name="1em"/><!-- HANGUL SYLLABLE TYEOS -->
+      <map code="0xd17c" name="1em"/><!-- HANGUL SYLLABLE TYEOSS -->
+      <map code="0xd17d" name="1em"/><!-- HANGUL SYLLABLE TYEONG -->
+      <map code="0xd17e" name="1em"/><!-- HANGUL SYLLABLE TYEOJ -->
+      <map code="0xd17f" name="1em"/><!-- HANGUL SYLLABLE TYEOC -->
+      <map code="0xd180" name="1em"/><!-- HANGUL SYLLABLE TYEOK -->
+      <map code="0xd181" name="1em"/><!-- HANGUL SYLLABLE TYEOT -->
+      <map code="0xd182" name="1em"/><!-- HANGUL SYLLABLE TYEOP -->
+      <map code="0xd183" name="1em"/><!-- HANGUL SYLLABLE TYEOH -->
+      <map code="0xd184" name="1em"/><!-- HANGUL SYLLABLE TYE -->
+      <map code="0xd185" name="1em"/><!-- HANGUL SYLLABLE TYEG -->
+      <map code="0xd186" name="1em"/><!-- HANGUL SYLLABLE TYEGG -->
+      <map code="0xd187" name="1em"/><!-- HANGUL SYLLABLE TYEGS -->
+      <map code="0xd188" name="1em"/><!-- HANGUL SYLLABLE TYEN -->
+      <map code="0xd189" name="1em"/><!-- HANGUL SYLLABLE TYENJ -->
+      <map code="0xd18a" name="1em"/><!-- HANGUL SYLLABLE TYENH -->
+      <map code="0xd18b" name="1em"/><!-- HANGUL SYLLABLE TYED -->
+      <map code="0xd18c" name="1em"/><!-- HANGUL SYLLABLE TYEL -->
+      <map code="0xd18d" name="1em"/><!-- HANGUL SYLLABLE TYELG -->
+      <map code="0xd18e" name="1em"/><!-- HANGUL SYLLABLE TYELM -->
+      <map code="0xd18f" name="1em"/><!-- HANGUL SYLLABLE TYELB -->
+      <map code="0xd190" name="1em"/><!-- HANGUL SYLLABLE TYELS -->
+      <map code="0xd191" name="1em"/><!-- HANGUL SYLLABLE TYELT -->
+      <map code="0xd192" name="1em"/><!-- HANGUL SYLLABLE TYELP -->
+      <map code="0xd193" name="1em"/><!-- HANGUL SYLLABLE TYELH -->
+      <map code="0xd194" name="1em"/><!-- HANGUL SYLLABLE TYEM -->
+      <map code="0xd195" name="1em"/><!-- HANGUL SYLLABLE TYEB -->
+      <map code="0xd196" name="1em"/><!-- HANGUL SYLLABLE TYEBS -->
+      <map code="0xd197" name="1em"/><!-- HANGUL SYLLABLE TYES -->
+      <map code="0xd198" name="1em"/><!-- HANGUL SYLLABLE TYESS -->
+      <map code="0xd199" name="1em"/><!-- HANGUL SYLLABLE TYENG -->
+      <map code="0xd19a" name="1em"/><!-- HANGUL SYLLABLE TYEJ -->
+      <map code="0xd19b" name="1em"/><!-- HANGUL SYLLABLE TYEC -->
+      <map code="0xd19c" name="1em"/><!-- HANGUL SYLLABLE TYEK -->
+      <map code="0xd19d" name="1em"/><!-- HANGUL SYLLABLE TYET -->
+      <map code="0xd19e" name="1em"/><!-- HANGUL SYLLABLE TYEP -->
+      <map code="0xd19f" name="1em"/><!-- HANGUL SYLLABLE TYEH -->
+      <map code="0xd1a0" name="1em"/><!-- HANGUL SYLLABLE TO -->
+      <map code="0xd1a1" name="1em"/><!-- HANGUL SYLLABLE TOG -->
+      <map code="0xd1a2" name="1em"/><!-- HANGUL SYLLABLE TOGG -->
+      <map code="0xd1a3" name="1em"/><!-- HANGUL SYLLABLE TOGS -->
+      <map code="0xd1a4" name="1em"/><!-- HANGUL SYLLABLE TON -->
+      <map code="0xd1a5" name="1em"/><!-- HANGUL SYLLABLE TONJ -->
+      <map code="0xd1a6" name="1em"/><!-- HANGUL SYLLABLE TONH -->
+      <map code="0xd1a7" name="1em"/><!-- HANGUL SYLLABLE TOD -->
+      <map code="0xd1a8" name="1em"/><!-- HANGUL SYLLABLE TOL -->
+      <map code="0xd1a9" name="1em"/><!-- HANGUL SYLLABLE TOLG -->
+      <map code="0xd1aa" name="1em"/><!-- HANGUL SYLLABLE TOLM -->
+      <map code="0xd1ab" name="1em"/><!-- HANGUL SYLLABLE TOLB -->
+      <map code="0xd1ac" name="1em"/><!-- HANGUL SYLLABLE TOLS -->
+      <map code="0xd1ad" name="1em"/><!-- HANGUL SYLLABLE TOLT -->
+      <map code="0xd1ae" name="1em"/><!-- HANGUL SYLLABLE TOLP -->
+      <map code="0xd1af" name="1em"/><!-- HANGUL SYLLABLE TOLH -->
+      <map code="0xd1b0" name="1em"/><!-- HANGUL SYLLABLE TOM -->
+      <map code="0xd1b1" name="1em"/><!-- HANGUL SYLLABLE TOB -->
+      <map code="0xd1b2" name="1em"/><!-- HANGUL SYLLABLE TOBS -->
+      <map code="0xd1b3" name="1em"/><!-- HANGUL SYLLABLE TOS -->
+      <map code="0xd1b4" name="1em"/><!-- HANGUL SYLLABLE TOSS -->
+      <map code="0xd1b5" name="1em"/><!-- HANGUL SYLLABLE TONG -->
+      <map code="0xd1b6" name="1em"/><!-- HANGUL SYLLABLE TOJ -->
+      <map code="0xd1b7" name="1em"/><!-- HANGUL SYLLABLE TOC -->
+      <map code="0xd1b8" name="1em"/><!-- HANGUL SYLLABLE TOK -->
+      <map code="0xd1b9" name="1em"/><!-- HANGUL SYLLABLE TOT -->
+      <map code="0xd1ba" name="1em"/><!-- HANGUL SYLLABLE TOP -->
+      <map code="0xd1bb" name="1em"/><!-- HANGUL SYLLABLE TOH -->
+      <map code="0xd1bc" name="1em"/><!-- HANGUL SYLLABLE TWA -->
+      <map code="0xd1bd" name="1em"/><!-- HANGUL SYLLABLE TWAG -->
+      <map code="0xd1be" name="1em"/><!-- HANGUL SYLLABLE TWAGG -->
+      <map code="0xd1bf" name="1em"/><!-- HANGUL SYLLABLE TWAGS -->
+      <map code="0xd1c0" name="1em"/><!-- HANGUL SYLLABLE TWAN -->
+      <map code="0xd1c1" name="1em"/><!-- HANGUL SYLLABLE TWANJ -->
+      <map code="0xd1c2" name="1em"/><!-- HANGUL SYLLABLE TWANH -->
+      <map code="0xd1c3" name="1em"/><!-- HANGUL SYLLABLE TWAD -->
+      <map code="0xd1c4" name="1em"/><!-- HANGUL SYLLABLE TWAL -->
+      <map code="0xd1c5" name="1em"/><!-- HANGUL SYLLABLE TWALG -->
+      <map code="0xd1c6" name="1em"/><!-- HANGUL SYLLABLE TWALM -->
+      <map code="0xd1c7" name="1em"/><!-- HANGUL SYLLABLE TWALB -->
+      <map code="0xd1c8" name="1em"/><!-- HANGUL SYLLABLE TWALS -->
+      <map code="0xd1c9" name="1em"/><!-- HANGUL SYLLABLE TWALT -->
+      <map code="0xd1ca" name="1em"/><!-- HANGUL SYLLABLE TWALP -->
+      <map code="0xd1cb" name="1em"/><!-- HANGUL SYLLABLE TWALH -->
+      <map code="0xd1cc" name="1em"/><!-- HANGUL SYLLABLE TWAM -->
+      <map code="0xd1cd" name="1em"/><!-- HANGUL SYLLABLE TWAB -->
+      <map code="0xd1ce" name="1em"/><!-- HANGUL SYLLABLE TWABS -->
+      <map code="0xd1cf" name="1em"/><!-- HANGUL SYLLABLE TWAS -->
+      <map code="0xd1d0" name="1em"/><!-- HANGUL SYLLABLE TWASS -->
+      <map code="0xd1d1" name="1em"/><!-- HANGUL SYLLABLE TWANG -->
+      <map code="0xd1d2" name="1em"/><!-- HANGUL SYLLABLE TWAJ -->
+      <map code="0xd1d3" name="1em"/><!-- HANGUL SYLLABLE TWAC -->
+      <map code="0xd1d4" name="1em"/><!-- HANGUL SYLLABLE TWAK -->
+      <map code="0xd1d5" name="1em"/><!-- HANGUL SYLLABLE TWAT -->
+      <map code="0xd1d6" name="1em"/><!-- HANGUL SYLLABLE TWAP -->
+      <map code="0xd1d7" name="1em"/><!-- HANGUL SYLLABLE TWAH -->
+      <map code="0xd1d8" name="1em"/><!-- HANGUL SYLLABLE TWAE -->
+      <map code="0xd1d9" name="1em"/><!-- HANGUL SYLLABLE TWAEG -->
+      <map code="0xd1da" name="1em"/><!-- HANGUL SYLLABLE TWAEGG -->
+      <map code="0xd1db" name="1em"/><!-- HANGUL SYLLABLE TWAEGS -->
+      <map code="0xd1dc" name="1em"/><!-- HANGUL SYLLABLE TWAEN -->
+      <map code="0xd1dd" name="1em"/><!-- HANGUL SYLLABLE TWAENJ -->
+      <map code="0xd1de" name="1em"/><!-- HANGUL SYLLABLE TWAENH -->
+      <map code="0xd1df" name="1em"/><!-- HANGUL SYLLABLE TWAED -->
+      <map code="0xd1e0" name="1em"/><!-- HANGUL SYLLABLE TWAEL -->
+      <map code="0xd1e1" name="1em"/><!-- HANGUL SYLLABLE TWAELG -->
+      <map code="0xd1e2" name="1em"/><!-- HANGUL SYLLABLE TWAELM -->
+      <map code="0xd1e3" name="1em"/><!-- HANGUL SYLLABLE TWAELB -->
+      <map code="0xd1e4" name="1em"/><!-- HANGUL SYLLABLE TWAELS -->
+      <map code="0xd1e5" name="1em"/><!-- HANGUL SYLLABLE TWAELT -->
+      <map code="0xd1e6" name="1em"/><!-- HANGUL SYLLABLE TWAELP -->
+      <map code="0xd1e7" name="1em"/><!-- HANGUL SYLLABLE TWAELH -->
+      <map code="0xd1e8" name="1em"/><!-- HANGUL SYLLABLE TWAEM -->
+      <map code="0xd1e9" name="1em"/><!-- HANGUL SYLLABLE TWAEB -->
+      <map code="0xd1ea" name="1em"/><!-- HANGUL SYLLABLE TWAEBS -->
+      <map code="0xd1eb" name="1em"/><!-- HANGUL SYLLABLE TWAES -->
+      <map code="0xd1ec" name="1em"/><!-- HANGUL SYLLABLE TWAESS -->
+      <map code="0xd1ed" name="1em"/><!-- HANGUL SYLLABLE TWAENG -->
+      <map code="0xd1ee" name="1em"/><!-- HANGUL SYLLABLE TWAEJ -->
+      <map code="0xd1ef" name="1em"/><!-- HANGUL SYLLABLE TWAEC -->
+      <map code="0xd1f0" name="1em"/><!-- HANGUL SYLLABLE TWAEK -->
+      <map code="0xd1f1" name="1em"/><!-- HANGUL SYLLABLE TWAET -->
+      <map code="0xd1f2" name="1em"/><!-- HANGUL SYLLABLE TWAEP -->
+      <map code="0xd1f3" name="1em"/><!-- HANGUL SYLLABLE TWAEH -->
+      <map code="0xd1f4" name="1em"/><!-- HANGUL SYLLABLE TOE -->
+      <map code="0xd1f5" name="1em"/><!-- HANGUL SYLLABLE TOEG -->
+      <map code="0xd1f6" name="1em"/><!-- HANGUL SYLLABLE TOEGG -->
+      <map code="0xd1f7" name="1em"/><!-- HANGUL SYLLABLE TOEGS -->
+      <map code="0xd1f8" name="1em"/><!-- HANGUL SYLLABLE TOEN -->
+      <map code="0xd1f9" name="1em"/><!-- HANGUL SYLLABLE TOENJ -->
+      <map code="0xd1fa" name="1em"/><!-- HANGUL SYLLABLE TOENH -->
+      <map code="0xd1fb" name="1em"/><!-- HANGUL SYLLABLE TOED -->
+      <map code="0xd1fc" name="1em"/><!-- HANGUL SYLLABLE TOEL -->
+      <map code="0xd1fd" name="1em"/><!-- HANGUL SYLLABLE TOELG -->
+      <map code="0xd1fe" name="1em"/><!-- HANGUL SYLLABLE TOELM -->
+      <map code="0xd1ff" name="1em"/><!-- HANGUL SYLLABLE TOELB -->
+      <map code="0xd200" name="1em"/><!-- HANGUL SYLLABLE TOELS -->
+      <map code="0xd201" name="1em"/><!-- HANGUL SYLLABLE TOELT -->
+      <map code="0xd202" name="1em"/><!-- HANGUL SYLLABLE TOELP -->
+      <map code="0xd203" name="1em"/><!-- HANGUL SYLLABLE TOELH -->
+      <map code="0xd204" name="1em"/><!-- HANGUL SYLLABLE TOEM -->
+      <map code="0xd205" name="1em"/><!-- HANGUL SYLLABLE TOEB -->
+      <map code="0xd206" name="1em"/><!-- HANGUL SYLLABLE TOEBS -->
+      <map code="0xd207" name="1em"/><!-- HANGUL SYLLABLE TOES -->
+      <map code="0xd208" name="1em"/><!-- HANGUL SYLLABLE TOESS -->
+      <map code="0xd209" name="1em"/><!-- HANGUL SYLLABLE TOENG -->
+      <map code="0xd20a" name="1em"/><!-- HANGUL SYLLABLE TOEJ -->
+      <map code="0xd20b" name="1em"/><!-- HANGUL SYLLABLE TOEC -->
+      <map code="0xd20c" name="1em"/><!-- HANGUL SYLLABLE TOEK -->
+      <map code="0xd20d" name="1em"/><!-- HANGUL SYLLABLE TOET -->
+      <map code="0xd20e" name="1em"/><!-- HANGUL SYLLABLE TOEP -->
+      <map code="0xd20f" name="1em"/><!-- HANGUL SYLLABLE TOEH -->
+      <map code="0xd210" name="1em"/><!-- HANGUL SYLLABLE TYO -->
+      <map code="0xd211" name="1em"/><!-- HANGUL SYLLABLE TYOG -->
+      <map code="0xd212" name="1em"/><!-- HANGUL SYLLABLE TYOGG -->
+      <map code="0xd213" name="1em"/><!-- HANGUL SYLLABLE TYOGS -->
+      <map code="0xd214" name="1em"/><!-- HANGUL SYLLABLE TYON -->
+      <map code="0xd215" name="1em"/><!-- HANGUL SYLLABLE TYONJ -->
+      <map code="0xd216" name="1em"/><!-- HANGUL SYLLABLE TYONH -->
+      <map code="0xd217" name="1em"/><!-- HANGUL SYLLABLE TYOD -->
+      <map code="0xd218" name="1em"/><!-- HANGUL SYLLABLE TYOL -->
+      <map code="0xd219" name="1em"/><!-- HANGUL SYLLABLE TYOLG -->
+      <map code="0xd21a" name="1em"/><!-- HANGUL SYLLABLE TYOLM -->
+      <map code="0xd21b" name="1em"/><!-- HANGUL SYLLABLE TYOLB -->
+      <map code="0xd21c" name="1em"/><!-- HANGUL SYLLABLE TYOLS -->
+      <map code="0xd21d" name="1em"/><!-- HANGUL SYLLABLE TYOLT -->
+      <map code="0xd21e" name="1em"/><!-- HANGUL SYLLABLE TYOLP -->
+      <map code="0xd21f" name="1em"/><!-- HANGUL SYLLABLE TYOLH -->
+      <map code="0xd220" name="1em"/><!-- HANGUL SYLLABLE TYOM -->
+      <map code="0xd221" name="1em"/><!-- HANGUL SYLLABLE TYOB -->
+      <map code="0xd222" name="1em"/><!-- HANGUL SYLLABLE TYOBS -->
+      <map code="0xd223" name="1em"/><!-- HANGUL SYLLABLE TYOS -->
+      <map code="0xd224" name="1em"/><!-- HANGUL SYLLABLE TYOSS -->
+      <map code="0xd225" name="1em"/><!-- HANGUL SYLLABLE TYONG -->
+      <map code="0xd226" name="1em"/><!-- HANGUL SYLLABLE TYOJ -->
+      <map code="0xd227" name="1em"/><!-- HANGUL SYLLABLE TYOC -->
+      <map code="0xd228" name="1em"/><!-- HANGUL SYLLABLE TYOK -->
+      <map code="0xd229" name="1em"/><!-- HANGUL SYLLABLE TYOT -->
+      <map code="0xd22a" name="1em"/><!-- HANGUL SYLLABLE TYOP -->
+      <map code="0xd22b" name="1em"/><!-- HANGUL SYLLABLE TYOH -->
+      <map code="0xd22c" name="1em"/><!-- HANGUL SYLLABLE TU -->
+      <map code="0xd22d" name="1em"/><!-- HANGUL SYLLABLE TUG -->
+      <map code="0xd22e" name="1em"/><!-- HANGUL SYLLABLE TUGG -->
+      <map code="0xd22f" name="1em"/><!-- HANGUL SYLLABLE TUGS -->
+      <map code="0xd230" name="1em"/><!-- HANGUL SYLLABLE TUN -->
+      <map code="0xd231" name="1em"/><!-- HANGUL SYLLABLE TUNJ -->
+      <map code="0xd232" name="1em"/><!-- HANGUL SYLLABLE TUNH -->
+      <map code="0xd233" name="1em"/><!-- HANGUL SYLLABLE TUD -->
+      <map code="0xd234" name="1em"/><!-- HANGUL SYLLABLE TUL -->
+      <map code="0xd235" name="1em"/><!-- HANGUL SYLLABLE TULG -->
+      <map code="0xd236" name="1em"/><!-- HANGUL SYLLABLE TULM -->
+      <map code="0xd237" name="1em"/><!-- HANGUL SYLLABLE TULB -->
+      <map code="0xd238" name="1em"/><!-- HANGUL SYLLABLE TULS -->
+      <map code="0xd239" name="1em"/><!-- HANGUL SYLLABLE TULT -->
+      <map code="0xd23a" name="1em"/><!-- HANGUL SYLLABLE TULP -->
+      <map code="0xd23b" name="1em"/><!-- HANGUL SYLLABLE TULH -->
+      <map code="0xd23c" name="1em"/><!-- HANGUL SYLLABLE TUM -->
+      <map code="0xd23d" name="1em"/><!-- HANGUL SYLLABLE TUB -->
+      <map code="0xd23e" name="1em"/><!-- HANGUL SYLLABLE TUBS -->
+      <map code="0xd23f" name="1em"/><!-- HANGUL SYLLABLE TUS -->
+      <map code="0xd240" name="1em"/><!-- HANGUL SYLLABLE TUSS -->
+      <map code="0xd241" name="1em"/><!-- HANGUL SYLLABLE TUNG -->
+      <map code="0xd242" name="1em"/><!-- HANGUL SYLLABLE TUJ -->
+      <map code="0xd243" name="1em"/><!-- HANGUL SYLLABLE TUC -->
+      <map code="0xd244" name="1em"/><!-- HANGUL SYLLABLE TUK -->
+      <map code="0xd245" name="1em"/><!-- HANGUL SYLLABLE TUT -->
+      <map code="0xd246" name="1em"/><!-- HANGUL SYLLABLE TUP -->
+      <map code="0xd247" name="1em"/><!-- HANGUL SYLLABLE TUH -->
+      <map code="0xd248" name="1em"/><!-- HANGUL SYLLABLE TWEO -->
+      <map code="0xd249" name="1em"/><!-- HANGUL SYLLABLE TWEOG -->
+      <map code="0xd24a" name="1em"/><!-- HANGUL SYLLABLE TWEOGG -->
+      <map code="0xd24b" name="1em"/><!-- HANGUL SYLLABLE TWEOGS -->
+      <map code="0xd24c" name="1em"/><!-- HANGUL SYLLABLE TWEON -->
+      <map code="0xd24d" name="1em"/><!-- HANGUL SYLLABLE TWEONJ -->
+      <map code="0xd24e" name="1em"/><!-- HANGUL SYLLABLE TWEONH -->
+      <map code="0xd24f" name="1em"/><!-- HANGUL SYLLABLE TWEOD -->
+      <map code="0xd250" name="1em"/><!-- HANGUL SYLLABLE TWEOL -->
+      <map code="0xd251" name="1em"/><!-- HANGUL SYLLABLE TWEOLG -->
+      <map code="0xd252" name="1em"/><!-- HANGUL SYLLABLE TWEOLM -->
+      <map code="0xd253" name="1em"/><!-- HANGUL SYLLABLE TWEOLB -->
+      <map code="0xd254" name="1em"/><!-- HANGUL SYLLABLE TWEOLS -->
+      <map code="0xd255" name="1em"/><!-- HANGUL SYLLABLE TWEOLT -->
+      <map code="0xd256" name="1em"/><!-- HANGUL SYLLABLE TWEOLP -->
+      <map code="0xd257" name="1em"/><!-- HANGUL SYLLABLE TWEOLH -->
+      <map code="0xd258" name="1em"/><!-- HANGUL SYLLABLE TWEOM -->
+      <map code="0xd259" name="1em"/><!-- HANGUL SYLLABLE TWEOB -->
+      <map code="0xd25a" name="1em"/><!-- HANGUL SYLLABLE TWEOBS -->
+      <map code="0xd25b" name="1em"/><!-- HANGUL SYLLABLE TWEOS -->
+      <map code="0xd25c" name="1em"/><!-- HANGUL SYLLABLE TWEOSS -->
+      <map code="0xd25d" name="1em"/><!-- HANGUL SYLLABLE TWEONG -->
+      <map code="0xd25e" name="1em"/><!-- HANGUL SYLLABLE TWEOJ -->
+      <map code="0xd25f" name="1em"/><!-- HANGUL SYLLABLE TWEOC -->
+      <map code="0xd260" name="1em"/><!-- HANGUL SYLLABLE TWEOK -->
+      <map code="0xd261" name="1em"/><!-- HANGUL SYLLABLE TWEOT -->
+      <map code="0xd262" name="1em"/><!-- HANGUL SYLLABLE TWEOP -->
+      <map code="0xd263" name="1em"/><!-- HANGUL SYLLABLE TWEOH -->
+      <map code="0xd264" name="1em"/><!-- HANGUL SYLLABLE TWE -->
+      <map code="0xd265" name="1em"/><!-- HANGUL SYLLABLE TWEG -->
+      <map code="0xd266" name="1em"/><!-- HANGUL SYLLABLE TWEGG -->
+      <map code="0xd267" name="1em"/><!-- HANGUL SYLLABLE TWEGS -->
+      <map code="0xd268" name="1em"/><!-- HANGUL SYLLABLE TWEN -->
+      <map code="0xd269" name="1em"/><!-- HANGUL SYLLABLE TWENJ -->
+      <map code="0xd26a" name="1em"/><!-- HANGUL SYLLABLE TWENH -->
+      <map code="0xd26b" name="1em"/><!-- HANGUL SYLLABLE TWED -->
+      <map code="0xd26c" name="1em"/><!-- HANGUL SYLLABLE TWEL -->
+      <map code="0xd26d" name="1em"/><!-- HANGUL SYLLABLE TWELG -->
+      <map code="0xd26e" name="1em"/><!-- HANGUL SYLLABLE TWELM -->
+      <map code="0xd26f" name="1em"/><!-- HANGUL SYLLABLE TWELB -->
+      <map code="0xd270" name="1em"/><!-- HANGUL SYLLABLE TWELS -->
+      <map code="0xd271" name="1em"/><!-- HANGUL SYLLABLE TWELT -->
+      <map code="0xd272" name="1em"/><!-- HANGUL SYLLABLE TWELP -->
+      <map code="0xd273" name="1em"/><!-- HANGUL SYLLABLE TWELH -->
+      <map code="0xd274" name="1em"/><!-- HANGUL SYLLABLE TWEM -->
+      <map code="0xd275" name="1em"/><!-- HANGUL SYLLABLE TWEB -->
+      <map code="0xd276" name="1em"/><!-- HANGUL SYLLABLE TWEBS -->
+      <map code="0xd277" name="1em"/><!-- HANGUL SYLLABLE TWES -->
+      <map code="0xd278" name="1em"/><!-- HANGUL SYLLABLE TWESS -->
+      <map code="0xd279" name="1em"/><!-- HANGUL SYLLABLE TWENG -->
+      <map code="0xd27a" name="1em"/><!-- HANGUL SYLLABLE TWEJ -->
+      <map code="0xd27b" name="1em"/><!-- HANGUL SYLLABLE TWEC -->
+      <map code="0xd27c" name="1em"/><!-- HANGUL SYLLABLE TWEK -->
+      <map code="0xd27d" name="1em"/><!-- HANGUL SYLLABLE TWET -->
+      <map code="0xd27e" name="1em"/><!-- HANGUL SYLLABLE TWEP -->
+      <map code="0xd27f" name="1em"/><!-- HANGUL SYLLABLE TWEH -->
+      <map code="0xd280" name="1em"/><!-- HANGUL SYLLABLE TWI -->
+      <map code="0xd281" name="1em"/><!-- HANGUL SYLLABLE TWIG -->
+      <map code="0xd282" name="1em"/><!-- HANGUL SYLLABLE TWIGG -->
+      <map code="0xd283" name="1em"/><!-- HANGUL SYLLABLE TWIGS -->
+      <map code="0xd284" name="1em"/><!-- HANGUL SYLLABLE TWIN -->
+      <map code="0xd285" name="1em"/><!-- HANGUL SYLLABLE TWINJ -->
+      <map code="0xd286" name="1em"/><!-- HANGUL SYLLABLE TWINH -->
+      <map code="0xd287" name="1em"/><!-- HANGUL SYLLABLE TWID -->
+      <map code="0xd288" name="1em"/><!-- HANGUL SYLLABLE TWIL -->
+      <map code="0xd289" name="1em"/><!-- HANGUL SYLLABLE TWILG -->
+      <map code="0xd28a" name="1em"/><!-- HANGUL SYLLABLE TWILM -->
+      <map code="0xd28b" name="1em"/><!-- HANGUL SYLLABLE TWILB -->
+      <map code="0xd28c" name="1em"/><!-- HANGUL SYLLABLE TWILS -->
+      <map code="0xd28d" name="1em"/><!-- HANGUL SYLLABLE TWILT -->
+      <map code="0xd28e" name="1em"/><!-- HANGUL SYLLABLE TWILP -->
+      <map code="0xd28f" name="1em"/><!-- HANGUL SYLLABLE TWILH -->
+      <map code="0xd290" name="1em"/><!-- HANGUL SYLLABLE TWIM -->
+      <map code="0xd291" name="1em"/><!-- HANGUL SYLLABLE TWIB -->
+      <map code="0xd292" name="1em"/><!-- HANGUL SYLLABLE TWIBS -->
+      <map code="0xd293" name="1em"/><!-- HANGUL SYLLABLE TWIS -->
+      <map code="0xd294" name="1em"/><!-- HANGUL SYLLABLE TWISS -->
+      <map code="0xd295" name="1em"/><!-- HANGUL SYLLABLE TWING -->
+      <map code="0xd296" name="1em"/><!-- HANGUL SYLLABLE TWIJ -->
+      <map code="0xd297" name="1em"/><!-- HANGUL SYLLABLE TWIC -->
+      <map code="0xd298" name="1em"/><!-- HANGUL SYLLABLE TWIK -->
+      <map code="0xd299" name="1em"/><!-- HANGUL SYLLABLE TWIT -->
+      <map code="0xd29a" name="1em"/><!-- HANGUL SYLLABLE TWIP -->
+      <map code="0xd29b" name="1em"/><!-- HANGUL SYLLABLE TWIH -->
+      <map code="0xd29c" name="1em"/><!-- HANGUL SYLLABLE TYU -->
+      <map code="0xd29d" name="1em"/><!-- HANGUL SYLLABLE TYUG -->
+      <map code="0xd29e" name="1em"/><!-- HANGUL SYLLABLE TYUGG -->
+      <map code="0xd29f" name="1em"/><!-- HANGUL SYLLABLE TYUGS -->
+      <map code="0xd2a0" name="1em"/><!-- HANGUL SYLLABLE TYUN -->
+      <map code="0xd2a1" name="1em"/><!-- HANGUL SYLLABLE TYUNJ -->
+      <map code="0xd2a2" name="1em"/><!-- HANGUL SYLLABLE TYUNH -->
+      <map code="0xd2a3" name="1em"/><!-- HANGUL SYLLABLE TYUD -->
+      <map code="0xd2a4" name="1em"/><!-- HANGUL SYLLABLE TYUL -->
+      <map code="0xd2a5" name="1em"/><!-- HANGUL SYLLABLE TYULG -->
+      <map code="0xd2a6" name="1em"/><!-- HANGUL SYLLABLE TYULM -->
+      <map code="0xd2a7" name="1em"/><!-- HANGUL SYLLABLE TYULB -->
+      <map code="0xd2a8" name="1em"/><!-- HANGUL SYLLABLE TYULS -->
+      <map code="0xd2a9" name="1em"/><!-- HANGUL SYLLABLE TYULT -->
+      <map code="0xd2aa" name="1em"/><!-- HANGUL SYLLABLE TYULP -->
+      <map code="0xd2ab" name="1em"/><!-- HANGUL SYLLABLE TYULH -->
+      <map code="0xd2ac" name="1em"/><!-- HANGUL SYLLABLE TYUM -->
+      <map code="0xd2ad" name="1em"/><!-- HANGUL SYLLABLE TYUB -->
+      <map code="0xd2ae" name="1em"/><!-- HANGUL SYLLABLE TYUBS -->
+      <map code="0xd2af" name="1em"/><!-- HANGUL SYLLABLE TYUS -->
+      <map code="0xd2b0" name="1em"/><!-- HANGUL SYLLABLE TYUSS -->
+      <map code="0xd2b1" name="1em"/><!-- HANGUL SYLLABLE TYUNG -->
+      <map code="0xd2b2" name="1em"/><!-- HANGUL SYLLABLE TYUJ -->
+      <map code="0xd2b3" name="1em"/><!-- HANGUL SYLLABLE TYUC -->
+      <map code="0xd2b4" name="1em"/><!-- HANGUL SYLLABLE TYUK -->
+      <map code="0xd2b5" name="1em"/><!-- HANGUL SYLLABLE TYUT -->
+      <map code="0xd2b6" name="1em"/><!-- HANGUL SYLLABLE TYUP -->
+      <map code="0xd2b7" name="1em"/><!-- HANGUL SYLLABLE TYUH -->
+      <map code="0xd2b8" name="1em"/><!-- HANGUL SYLLABLE TEU -->
+      <map code="0xd2b9" name="1em"/><!-- HANGUL SYLLABLE TEUG -->
+      <map code="0xd2ba" name="1em"/><!-- HANGUL SYLLABLE TEUGG -->
+      <map code="0xd2bb" name="1em"/><!-- HANGUL SYLLABLE TEUGS -->
+      <map code="0xd2bc" name="1em"/><!-- HANGUL SYLLABLE TEUN -->
+      <map code="0xd2bd" name="1em"/><!-- HANGUL SYLLABLE TEUNJ -->
+      <map code="0xd2be" name="1em"/><!-- HANGUL SYLLABLE TEUNH -->
+      <map code="0xd2bf" name="1em"/><!-- HANGUL SYLLABLE TEUD -->
+      <map code="0xd2c0" name="1em"/><!-- HANGUL SYLLABLE TEUL -->
+      <map code="0xd2c1" name="1em"/><!-- HANGUL SYLLABLE TEULG -->
+      <map code="0xd2c2" name="1em"/><!-- HANGUL SYLLABLE TEULM -->
+      <map code="0xd2c3" name="1em"/><!-- HANGUL SYLLABLE TEULB -->
+      <map code="0xd2c4" name="1em"/><!-- HANGUL SYLLABLE TEULS -->
+      <map code="0xd2c5" name="1em"/><!-- HANGUL SYLLABLE TEULT -->
+      <map code="0xd2c6" name="1em"/><!-- HANGUL SYLLABLE TEULP -->
+      <map code="0xd2c7" name="1em"/><!-- HANGUL SYLLABLE TEULH -->
+      <map code="0xd2c8" name="1em"/><!-- HANGUL SYLLABLE TEUM -->
+      <map code="0xd2c9" name="1em"/><!-- HANGUL SYLLABLE TEUB -->
+      <map code="0xd2ca" name="1em"/><!-- HANGUL SYLLABLE TEUBS -->
+      <map code="0xd2cb" name="1em"/><!-- HANGUL SYLLABLE TEUS -->
+      <map code="0xd2cc" name="1em"/><!-- HANGUL SYLLABLE TEUSS -->
+      <map code="0xd2cd" name="1em"/><!-- HANGUL SYLLABLE TEUNG -->
+      <map code="0xd2ce" name="1em"/><!-- HANGUL SYLLABLE TEUJ -->
+      <map code="0xd2cf" name="1em"/><!-- HANGUL SYLLABLE TEUC -->
+      <map code="0xd2d0" name="1em"/><!-- HANGUL SYLLABLE TEUK -->
+      <map code="0xd2d1" name="1em"/><!-- HANGUL SYLLABLE TEUT -->
+      <map code="0xd2d2" name="1em"/><!-- HANGUL SYLLABLE TEUP -->
+      <map code="0xd2d3" name="1em"/><!-- HANGUL SYLLABLE TEUH -->
+      <map code="0xd2d4" name="1em"/><!-- HANGUL SYLLABLE TYI -->
+      <map code="0xd2d5" name="1em"/><!-- HANGUL SYLLABLE TYIG -->
+      <map code="0xd2d6" name="1em"/><!-- HANGUL SYLLABLE TYIGG -->
+      <map code="0xd2d7" name="1em"/><!-- HANGUL SYLLABLE TYIGS -->
+      <map code="0xd2d8" name="1em"/><!-- HANGUL SYLLABLE TYIN -->
+      <map code="0xd2d9" name="1em"/><!-- HANGUL SYLLABLE TYINJ -->
+      <map code="0xd2da" name="1em"/><!-- HANGUL SYLLABLE TYINH -->
+      <map code="0xd2db" name="1em"/><!-- HANGUL SYLLABLE TYID -->
+      <map code="0xd2dc" name="1em"/><!-- HANGUL SYLLABLE TYIL -->
+      <map code="0xd2dd" name="1em"/><!-- HANGUL SYLLABLE TYILG -->
+      <map code="0xd2de" name="1em"/><!-- HANGUL SYLLABLE TYILM -->
+      <map code="0xd2df" name="1em"/><!-- HANGUL SYLLABLE TYILB -->
+      <map code="0xd2e0" name="1em"/><!-- HANGUL SYLLABLE TYILS -->
+      <map code="0xd2e1" name="1em"/><!-- HANGUL SYLLABLE TYILT -->
+      <map code="0xd2e2" name="1em"/><!-- HANGUL SYLLABLE TYILP -->
+      <map code="0xd2e3" name="1em"/><!-- HANGUL SYLLABLE TYILH -->
+      <map code="0xd2e4" name="1em"/><!-- HANGUL SYLLABLE TYIM -->
+      <map code="0xd2e5" name="1em"/><!-- HANGUL SYLLABLE TYIB -->
+      <map code="0xd2e6" name="1em"/><!-- HANGUL SYLLABLE TYIBS -->
+      <map code="0xd2e7" name="1em"/><!-- HANGUL SYLLABLE TYIS -->
+      <map code="0xd2e8" name="1em"/><!-- HANGUL SYLLABLE TYISS -->
+      <map code="0xd2e9" name="1em"/><!-- HANGUL SYLLABLE TYING -->
+      <map code="0xd2ea" name="1em"/><!-- HANGUL SYLLABLE TYIJ -->
+      <map code="0xd2eb" name="1em"/><!-- HANGUL SYLLABLE TYIC -->
+      <map code="0xd2ec" name="1em"/><!-- HANGUL SYLLABLE TYIK -->
+      <map code="0xd2ed" name="1em"/><!-- HANGUL SYLLABLE TYIT -->
+      <map code="0xd2ee" name="1em"/><!-- HANGUL SYLLABLE TYIP -->
+      <map code="0xd2ef" name="1em"/><!-- HANGUL SYLLABLE TYIH -->
+      <map code="0xd2f0" name="1em"/><!-- HANGUL SYLLABLE TI -->
+      <map code="0xd2f1" name="1em"/><!-- HANGUL SYLLABLE TIG -->
+      <map code="0xd2f2" name="1em"/><!-- HANGUL SYLLABLE TIGG -->
+      <map code="0xd2f3" name="1em"/><!-- HANGUL SYLLABLE TIGS -->
+      <map code="0xd2f4" name="1em"/><!-- HANGUL SYLLABLE TIN -->
+      <map code="0xd2f5" name="1em"/><!-- HANGUL SYLLABLE TINJ -->
+      <map code="0xd2f6" name="1em"/><!-- HANGUL SYLLABLE TINH -->
+      <map code="0xd2f7" name="1em"/><!-- HANGUL SYLLABLE TID -->
+      <map code="0xd2f8" name="1em"/><!-- HANGUL SYLLABLE TIL -->
+      <map code="0xd2f9" name="1em"/><!-- HANGUL SYLLABLE TILG -->
+      <map code="0xd2fa" name="1em"/><!-- HANGUL SYLLABLE TILM -->
+      <map code="0xd2fb" name="1em"/><!-- HANGUL SYLLABLE TILB -->
+      <map code="0xd2fc" name="1em"/><!-- HANGUL SYLLABLE TILS -->
+      <map code="0xd2fd" name="1em"/><!-- HANGUL SYLLABLE TILT -->
+      <map code="0xd2fe" name="1em"/><!-- HANGUL SYLLABLE TILP -->
+      <map code="0xd2ff" name="1em"/><!-- HANGUL SYLLABLE TILH -->
+      <map code="0xd300" name="1em"/><!-- HANGUL SYLLABLE TIM -->
+      <map code="0xd301" name="1em"/><!-- HANGUL SYLLABLE TIB -->
+      <map code="0xd302" name="1em"/><!-- HANGUL SYLLABLE TIBS -->
+      <map code="0xd303" name="1em"/><!-- HANGUL SYLLABLE TIS -->
+      <map code="0xd304" name="1em"/><!-- HANGUL SYLLABLE TISS -->
+      <map code="0xd305" name="1em"/><!-- HANGUL SYLLABLE TING -->
+      <map code="0xd306" name="1em"/><!-- HANGUL SYLLABLE TIJ -->
+      <map code="0xd307" name="1em"/><!-- HANGUL SYLLABLE TIC -->
+      <map code="0xd308" name="1em"/><!-- HANGUL SYLLABLE TIK -->
+      <map code="0xd309" name="1em"/><!-- HANGUL SYLLABLE TIT -->
+      <map code="0xd30a" name="1em"/><!-- HANGUL SYLLABLE TIP -->
+      <map code="0xd30b" name="1em"/><!-- HANGUL SYLLABLE TIH -->
+      <map code="0xd30c" name="1em"/><!-- HANGUL SYLLABLE PA -->
+      <map code="0xd30d" name="1em"/><!-- HANGUL SYLLABLE PAG -->
+      <map code="0xd30e" name="1em"/><!-- HANGUL SYLLABLE PAGG -->
+      <map code="0xd30f" name="1em"/><!-- HANGUL SYLLABLE PAGS -->
+      <map code="0xd310" name="1em"/><!-- HANGUL SYLLABLE PAN -->
+      <map code="0xd311" name="1em"/><!-- HANGUL SYLLABLE PANJ -->
+      <map code="0xd312" name="1em"/><!-- HANGUL SYLLABLE PANH -->
+      <map code="0xd313" name="1em"/><!-- HANGUL SYLLABLE PAD -->
+      <map code="0xd314" name="1em"/><!-- HANGUL SYLLABLE PAL -->
+      <map code="0xd315" name="1em"/><!-- HANGUL SYLLABLE PALG -->
+      <map code="0xd316" name="1em"/><!-- HANGUL SYLLABLE PALM -->
+      <map code="0xd317" name="1em"/><!-- HANGUL SYLLABLE PALB -->
+      <map code="0xd318" name="1em"/><!-- HANGUL SYLLABLE PALS -->
+      <map code="0xd319" name="1em"/><!-- HANGUL SYLLABLE PALT -->
+      <map code="0xd31a" name="1em"/><!-- HANGUL SYLLABLE PALP -->
+      <map code="0xd31b" name="1em"/><!-- HANGUL SYLLABLE PALH -->
+      <map code="0xd31c" name="1em"/><!-- HANGUL SYLLABLE PAM -->
+      <map code="0xd31d" name="1em"/><!-- HANGUL SYLLABLE PAB -->
+      <map code="0xd31e" name="1em"/><!-- HANGUL SYLLABLE PABS -->
+      <map code="0xd31f" name="1em"/><!-- HANGUL SYLLABLE PAS -->
+      <map code="0xd320" name="1em"/><!-- HANGUL SYLLABLE PASS -->
+      <map code="0xd321" name="1em"/><!-- HANGUL SYLLABLE PANG -->
+      <map code="0xd322" name="1em"/><!-- HANGUL SYLLABLE PAJ -->
+      <map code="0xd323" name="1em"/><!-- HANGUL SYLLABLE PAC -->
+      <map code="0xd324" name="1em"/><!-- HANGUL SYLLABLE PAK -->
+      <map code="0xd325" name="1em"/><!-- HANGUL SYLLABLE PAT -->
+      <map code="0xd326" name="1em"/><!-- HANGUL SYLLABLE PAP -->
+      <map code="0xd327" name="1em"/><!-- HANGUL SYLLABLE PAH -->
+      <map code="0xd328" name="1em"/><!-- HANGUL SYLLABLE PAE -->
+      <map code="0xd329" name="1em"/><!-- HANGUL SYLLABLE PAEG -->
+      <map code="0xd32a" name="1em"/><!-- HANGUL SYLLABLE PAEGG -->
+      <map code="0xd32b" name="1em"/><!-- HANGUL SYLLABLE PAEGS -->
+      <map code="0xd32c" name="1em"/><!-- HANGUL SYLLABLE PAEN -->
+      <map code="0xd32d" name="1em"/><!-- HANGUL SYLLABLE PAENJ -->
+      <map code="0xd32e" name="1em"/><!-- HANGUL SYLLABLE PAENH -->
+      <map code="0xd32f" name="1em"/><!-- HANGUL SYLLABLE PAED -->
+      <map code="0xd330" name="1em"/><!-- HANGUL SYLLABLE PAEL -->
+      <map code="0xd331" name="1em"/><!-- HANGUL SYLLABLE PAELG -->
+      <map code="0xd332" name="1em"/><!-- HANGUL SYLLABLE PAELM -->
+      <map code="0xd333" name="1em"/><!-- HANGUL SYLLABLE PAELB -->
+      <map code="0xd334" name="1em"/><!-- HANGUL SYLLABLE PAELS -->
+      <map code="0xd335" name="1em"/><!-- HANGUL SYLLABLE PAELT -->
+      <map code="0xd336" name="1em"/><!-- HANGUL SYLLABLE PAELP -->
+      <map code="0xd337" name="1em"/><!-- HANGUL SYLLABLE PAELH -->
+      <map code="0xd338" name="1em"/><!-- HANGUL SYLLABLE PAEM -->
+      <map code="0xd339" name="1em"/><!-- HANGUL SYLLABLE PAEB -->
+      <map code="0xd33a" name="1em"/><!-- HANGUL SYLLABLE PAEBS -->
+      <map code="0xd33b" name="1em"/><!-- HANGUL SYLLABLE PAES -->
+      <map code="0xd33c" name="1em"/><!-- HANGUL SYLLABLE PAESS -->
+      <map code="0xd33d" name="1em"/><!-- HANGUL SYLLABLE PAENG -->
+      <map code="0xd33e" name="1em"/><!-- HANGUL SYLLABLE PAEJ -->
+      <map code="0xd33f" name="1em"/><!-- HANGUL SYLLABLE PAEC -->
+      <map code="0xd340" name="1em"/><!-- HANGUL SYLLABLE PAEK -->
+      <map code="0xd341" name="1em"/><!-- HANGUL SYLLABLE PAET -->
+      <map code="0xd342" name="1em"/><!-- HANGUL SYLLABLE PAEP -->
+      <map code="0xd343" name="1em"/><!-- HANGUL SYLLABLE PAEH -->
+      <map code="0xd344" name="1em"/><!-- HANGUL SYLLABLE PYA -->
+      <map code="0xd345" name="1em"/><!-- HANGUL SYLLABLE PYAG -->
+      <map code="0xd346" name="1em"/><!-- HANGUL SYLLABLE PYAGG -->
+      <map code="0xd347" name="1em"/><!-- HANGUL SYLLABLE PYAGS -->
+      <map code="0xd348" name="1em"/><!-- HANGUL SYLLABLE PYAN -->
+      <map code="0xd349" name="1em"/><!-- HANGUL SYLLABLE PYANJ -->
+      <map code="0xd34a" name="1em"/><!-- HANGUL SYLLABLE PYANH -->
+      <map code="0xd34b" name="1em"/><!-- HANGUL SYLLABLE PYAD -->
+      <map code="0xd34c" name="1em"/><!-- HANGUL SYLLABLE PYAL -->
+      <map code="0xd34d" name="1em"/><!-- HANGUL SYLLABLE PYALG -->
+      <map code="0xd34e" name="1em"/><!-- HANGUL SYLLABLE PYALM -->
+      <map code="0xd34f" name="1em"/><!-- HANGUL SYLLABLE PYALB -->
+      <map code="0xd350" name="1em"/><!-- HANGUL SYLLABLE PYALS -->
+      <map code="0xd351" name="1em"/><!-- HANGUL SYLLABLE PYALT -->
+      <map code="0xd352" name="1em"/><!-- HANGUL SYLLABLE PYALP -->
+      <map code="0xd353" name="1em"/><!-- HANGUL SYLLABLE PYALH -->
+      <map code="0xd354" name="1em"/><!-- HANGUL SYLLABLE PYAM -->
+      <map code="0xd355" name="1em"/><!-- HANGUL SYLLABLE PYAB -->
+      <map code="0xd356" name="1em"/><!-- HANGUL SYLLABLE PYABS -->
+      <map code="0xd357" name="1em"/><!-- HANGUL SYLLABLE PYAS -->
+      <map code="0xd358" name="1em"/><!-- HANGUL SYLLABLE PYASS -->
+      <map code="0xd359" name="1em"/><!-- HANGUL SYLLABLE PYANG -->
+      <map code="0xd35a" name="1em"/><!-- HANGUL SYLLABLE PYAJ -->
+      <map code="0xd35b" name="1em"/><!-- HANGUL SYLLABLE PYAC -->
+      <map code="0xd35c" name="1em"/><!-- HANGUL SYLLABLE PYAK -->
+      <map code="0xd35d" name="1em"/><!-- HANGUL SYLLABLE PYAT -->
+      <map code="0xd35e" name="1em"/><!-- HANGUL SYLLABLE PYAP -->
+      <map code="0xd35f" name="1em"/><!-- HANGUL SYLLABLE PYAH -->
+      <map code="0xd360" name="1em"/><!-- HANGUL SYLLABLE PYAE -->
+      <map code="0xd361" name="1em"/><!-- HANGUL SYLLABLE PYAEG -->
+      <map code="0xd362" name="1em"/><!-- HANGUL SYLLABLE PYAEGG -->
+      <map code="0xd363" name="1em"/><!-- HANGUL SYLLABLE PYAEGS -->
+      <map code="0xd364" name="1em"/><!-- HANGUL SYLLABLE PYAEN -->
+      <map code="0xd365" name="1em"/><!-- HANGUL SYLLABLE PYAENJ -->
+      <map code="0xd366" name="1em"/><!-- HANGUL SYLLABLE PYAENH -->
+      <map code="0xd367" name="1em"/><!-- HANGUL SYLLABLE PYAED -->
+      <map code="0xd368" name="1em"/><!-- HANGUL SYLLABLE PYAEL -->
+      <map code="0xd369" name="1em"/><!-- HANGUL SYLLABLE PYAELG -->
+      <map code="0xd36a" name="1em"/><!-- HANGUL SYLLABLE PYAELM -->
+      <map code="0xd36b" name="1em"/><!-- HANGUL SYLLABLE PYAELB -->
+      <map code="0xd36c" name="1em"/><!-- HANGUL SYLLABLE PYAELS -->
+      <map code="0xd36d" name="1em"/><!-- HANGUL SYLLABLE PYAELT -->
+      <map code="0xd36e" name="1em"/><!-- HANGUL SYLLABLE PYAELP -->
+      <map code="0xd36f" name="1em"/><!-- HANGUL SYLLABLE PYAELH -->
+      <map code="0xd370" name="1em"/><!-- HANGUL SYLLABLE PYAEM -->
+      <map code="0xd371" name="1em"/><!-- HANGUL SYLLABLE PYAEB -->
+      <map code="0xd372" name="1em"/><!-- HANGUL SYLLABLE PYAEBS -->
+      <map code="0xd373" name="1em"/><!-- HANGUL SYLLABLE PYAES -->
+      <map code="0xd374" name="1em"/><!-- HANGUL SYLLABLE PYAESS -->
+      <map code="0xd375" name="1em"/><!-- HANGUL SYLLABLE PYAENG -->
+      <map code="0xd376" name="1em"/><!-- HANGUL SYLLABLE PYAEJ -->
+      <map code="0xd377" name="1em"/><!-- HANGUL SYLLABLE PYAEC -->
+      <map code="0xd378" name="1em"/><!-- HANGUL SYLLABLE PYAEK -->
+      <map code="0xd379" name="1em"/><!-- HANGUL SYLLABLE PYAET -->
+      <map code="0xd37a" name="1em"/><!-- HANGUL SYLLABLE PYAEP -->
+      <map code="0xd37b" name="1em"/><!-- HANGUL SYLLABLE PYAEH -->
+      <map code="0xd37c" name="1em"/><!-- HANGUL SYLLABLE PEO -->
+      <map code="0xd37d" name="1em"/><!-- HANGUL SYLLABLE PEOG -->
+      <map code="0xd37e" name="1em"/><!-- HANGUL SYLLABLE PEOGG -->
+      <map code="0xd37f" name="1em"/><!-- HANGUL SYLLABLE PEOGS -->
+      <map code="0xd380" name="1em"/><!-- HANGUL SYLLABLE PEON -->
+      <map code="0xd381" name="1em"/><!-- HANGUL SYLLABLE PEONJ -->
+      <map code="0xd382" name="1em"/><!-- HANGUL SYLLABLE PEONH -->
+      <map code="0xd383" name="1em"/><!-- HANGUL SYLLABLE PEOD -->
+      <map code="0xd384" name="1em"/><!-- HANGUL SYLLABLE PEOL -->
+      <map code="0xd385" name="1em"/><!-- HANGUL SYLLABLE PEOLG -->
+      <map code="0xd386" name="1em"/><!-- HANGUL SYLLABLE PEOLM -->
+      <map code="0xd387" name="1em"/><!-- HANGUL SYLLABLE PEOLB -->
+      <map code="0xd388" name="1em"/><!-- HANGUL SYLLABLE PEOLS -->
+      <map code="0xd389" name="1em"/><!-- HANGUL SYLLABLE PEOLT -->
+      <map code="0xd38a" name="1em"/><!-- HANGUL SYLLABLE PEOLP -->
+      <map code="0xd38b" name="1em"/><!-- HANGUL SYLLABLE PEOLH -->
+      <map code="0xd38c" name="1em"/><!-- HANGUL SYLLABLE PEOM -->
+      <map code="0xd38d" name="1em"/><!-- HANGUL SYLLABLE PEOB -->
+      <map code="0xd38e" name="1em"/><!-- HANGUL SYLLABLE PEOBS -->
+      <map code="0xd38f" name="1em"/><!-- HANGUL SYLLABLE PEOS -->
+      <map code="0xd390" name="1em"/><!-- HANGUL SYLLABLE PEOSS -->
+      <map code="0xd391" name="1em"/><!-- HANGUL SYLLABLE PEONG -->
+      <map code="0xd392" name="1em"/><!-- HANGUL SYLLABLE PEOJ -->
+      <map code="0xd393" name="1em"/><!-- HANGUL SYLLABLE PEOC -->
+      <map code="0xd394" name="1em"/><!-- HANGUL SYLLABLE PEOK -->
+      <map code="0xd395" name="1em"/><!-- HANGUL SYLLABLE PEOT -->
+      <map code="0xd396" name="1em"/><!-- HANGUL SYLLABLE PEOP -->
+      <map code="0xd397" name="1em"/><!-- HANGUL SYLLABLE PEOH -->
+      <map code="0xd398" name="1em"/><!-- HANGUL SYLLABLE PE -->
+      <map code="0xd399" name="1em"/><!-- HANGUL SYLLABLE PEG -->
+      <map code="0xd39a" name="1em"/><!-- HANGUL SYLLABLE PEGG -->
+      <map code="0xd39b" name="1em"/><!-- HANGUL SYLLABLE PEGS -->
+      <map code="0xd39c" name="1em"/><!-- HANGUL SYLLABLE PEN -->
+      <map code="0xd39d" name="1em"/><!-- HANGUL SYLLABLE PENJ -->
+      <map code="0xd39e" name="1em"/><!-- HANGUL SYLLABLE PENH -->
+      <map code="0xd39f" name="1em"/><!-- HANGUL SYLLABLE PED -->
+      <map code="0xd3a0" name="1em"/><!-- HANGUL SYLLABLE PEL -->
+      <map code="0xd3a1" name="1em"/><!-- HANGUL SYLLABLE PELG -->
+      <map code="0xd3a2" name="1em"/><!-- HANGUL SYLLABLE PELM -->
+      <map code="0xd3a3" name="1em"/><!-- HANGUL SYLLABLE PELB -->
+      <map code="0xd3a4" name="1em"/><!-- HANGUL SYLLABLE PELS -->
+      <map code="0xd3a5" name="1em"/><!-- HANGUL SYLLABLE PELT -->
+      <map code="0xd3a6" name="1em"/><!-- HANGUL SYLLABLE PELP -->
+      <map code="0xd3a7" name="1em"/><!-- HANGUL SYLLABLE PELH -->
+      <map code="0xd3a8" name="1em"/><!-- HANGUL SYLLABLE PEM -->
+      <map code="0xd3a9" name="1em"/><!-- HANGUL SYLLABLE PEB -->
+      <map code="0xd3aa" name="1em"/><!-- HANGUL SYLLABLE PEBS -->
+      <map code="0xd3ab" name="1em"/><!-- HANGUL SYLLABLE PES -->
+      <map code="0xd3ac" name="1em"/><!-- HANGUL SYLLABLE PESS -->
+      <map code="0xd3ad" name="1em"/><!-- HANGUL SYLLABLE PENG -->
+      <map code="0xd3ae" name="1em"/><!-- HANGUL SYLLABLE PEJ -->
+      <map code="0xd3af" name="1em"/><!-- HANGUL SYLLABLE PEC -->
+      <map code="0xd3b0" name="1em"/><!-- HANGUL SYLLABLE PEK -->
+      <map code="0xd3b1" name="1em"/><!-- HANGUL SYLLABLE PET -->
+      <map code="0xd3b2" name="1em"/><!-- HANGUL SYLLABLE PEP -->
+      <map code="0xd3b3" name="1em"/><!-- HANGUL SYLLABLE PEH -->
+      <map code="0xd3b4" name="1em"/><!-- HANGUL SYLLABLE PYEO -->
+      <map code="0xd3b5" name="1em"/><!-- HANGUL SYLLABLE PYEOG -->
+      <map code="0xd3b6" name="1em"/><!-- HANGUL SYLLABLE PYEOGG -->
+      <map code="0xd3b7" name="1em"/><!-- HANGUL SYLLABLE PYEOGS -->
+      <map code="0xd3b8" name="1em"/><!-- HANGUL SYLLABLE PYEON -->
+      <map code="0xd3b9" name="1em"/><!-- HANGUL SYLLABLE PYEONJ -->
+      <map code="0xd3ba" name="1em"/><!-- HANGUL SYLLABLE PYEONH -->
+      <map code="0xd3bb" name="1em"/><!-- HANGUL SYLLABLE PYEOD -->
+      <map code="0xd3bc" name="1em"/><!-- HANGUL SYLLABLE PYEOL -->
+      <map code="0xd3bd" name="1em"/><!-- HANGUL SYLLABLE PYEOLG -->
+      <map code="0xd3be" name="1em"/><!-- HANGUL SYLLABLE PYEOLM -->
+      <map code="0xd3bf" name="1em"/><!-- HANGUL SYLLABLE PYEOLB -->
+      <map code="0xd3c0" name="1em"/><!-- HANGUL SYLLABLE PYEOLS -->
+      <map code="0xd3c1" name="1em"/><!-- HANGUL SYLLABLE PYEOLT -->
+      <map code="0xd3c2" name="1em"/><!-- HANGUL SYLLABLE PYEOLP -->
+      <map code="0xd3c3" name="1em"/><!-- HANGUL SYLLABLE PYEOLH -->
+      <map code="0xd3c4" name="1em"/><!-- HANGUL SYLLABLE PYEOM -->
+      <map code="0xd3c5" name="1em"/><!-- HANGUL SYLLABLE PYEOB -->
+      <map code="0xd3c6" name="1em"/><!-- HANGUL SYLLABLE PYEOBS -->
+      <map code="0xd3c7" name="1em"/><!-- HANGUL SYLLABLE PYEOS -->
+      <map code="0xd3c8" name="1em"/><!-- HANGUL SYLLABLE PYEOSS -->
+      <map code="0xd3c9" name="1em"/><!-- HANGUL SYLLABLE PYEONG -->
+      <map code="0xd3ca" name="1em"/><!-- HANGUL SYLLABLE PYEOJ -->
+      <map code="0xd3cb" name="1em"/><!-- HANGUL SYLLABLE PYEOC -->
+      <map code="0xd3cc" name="1em"/><!-- HANGUL SYLLABLE PYEOK -->
+      <map code="0xd3cd" name="1em"/><!-- HANGUL SYLLABLE PYEOT -->
+      <map code="0xd3ce" name="1em"/><!-- HANGUL SYLLABLE PYEOP -->
+      <map code="0xd3cf" name="1em"/><!-- HANGUL SYLLABLE PYEOH -->
+      <map code="0xd3d0" name="1em"/><!-- HANGUL SYLLABLE PYE -->
+      <map code="0xd3d1" name="1em"/><!-- HANGUL SYLLABLE PYEG -->
+      <map code="0xd3d2" name="1em"/><!-- HANGUL SYLLABLE PYEGG -->
+      <map code="0xd3d3" name="1em"/><!-- HANGUL SYLLABLE PYEGS -->
+      <map code="0xd3d4" name="1em"/><!-- HANGUL SYLLABLE PYEN -->
+      <map code="0xd3d5" name="1em"/><!-- HANGUL SYLLABLE PYENJ -->
+      <map code="0xd3d6" name="1em"/><!-- HANGUL SYLLABLE PYENH -->
+      <map code="0xd3d7" name="1em"/><!-- HANGUL SYLLABLE PYED -->
+      <map code="0xd3d8" name="1em"/><!-- HANGUL SYLLABLE PYEL -->
+      <map code="0xd3d9" name="1em"/><!-- HANGUL SYLLABLE PYELG -->
+      <map code="0xd3da" name="1em"/><!-- HANGUL SYLLABLE PYELM -->
+      <map code="0xd3db" name="1em"/><!-- HANGUL SYLLABLE PYELB -->
+      <map code="0xd3dc" name="1em"/><!-- HANGUL SYLLABLE PYELS -->
+      <map code="0xd3dd" name="1em"/><!-- HANGUL SYLLABLE PYELT -->
+      <map code="0xd3de" name="1em"/><!-- HANGUL SYLLABLE PYELP -->
+      <map code="0xd3df" name="1em"/><!-- HANGUL SYLLABLE PYELH -->
+      <map code="0xd3e0" name="1em"/><!-- HANGUL SYLLABLE PYEM -->
+      <map code="0xd3e1" name="1em"/><!-- HANGUL SYLLABLE PYEB -->
+      <map code="0xd3e2" name="1em"/><!-- HANGUL SYLLABLE PYEBS -->
+      <map code="0xd3e3" name="1em"/><!-- HANGUL SYLLABLE PYES -->
+      <map code="0xd3e4" name="1em"/><!-- HANGUL SYLLABLE PYESS -->
+      <map code="0xd3e5" name="1em"/><!-- HANGUL SYLLABLE PYENG -->
+      <map code="0xd3e6" name="1em"/><!-- HANGUL SYLLABLE PYEJ -->
+      <map code="0xd3e7" name="1em"/><!-- HANGUL SYLLABLE PYEC -->
+      <map code="0xd3e8" name="1em"/><!-- HANGUL SYLLABLE PYEK -->
+      <map code="0xd3e9" name="1em"/><!-- HANGUL SYLLABLE PYET -->
+      <map code="0xd3ea" name="1em"/><!-- HANGUL SYLLABLE PYEP -->
+      <map code="0xd3eb" name="1em"/><!-- HANGUL SYLLABLE PYEH -->
+      <map code="0xd3ec" name="1em"/><!-- HANGUL SYLLABLE PO -->
+      <map code="0xd3ed" name="1em"/><!-- HANGUL SYLLABLE POG -->
+      <map code="0xd3ee" name="1em"/><!-- HANGUL SYLLABLE POGG -->
+      <map code="0xd3ef" name="1em"/><!-- HANGUL SYLLABLE POGS -->
+      <map code="0xd3f0" name="1em"/><!-- HANGUL SYLLABLE PON -->
+      <map code="0xd3f1" name="1em"/><!-- HANGUL SYLLABLE PONJ -->
+      <map code="0xd3f2" name="1em"/><!-- HANGUL SYLLABLE PONH -->
+      <map code="0xd3f3" name="1em"/><!-- HANGUL SYLLABLE POD -->
+      <map code="0xd3f4" name="1em"/><!-- HANGUL SYLLABLE POL -->
+      <map code="0xd3f5" name="1em"/><!-- HANGUL SYLLABLE POLG -->
+      <map code="0xd3f6" name="1em"/><!-- HANGUL SYLLABLE POLM -->
+      <map code="0xd3f7" name="1em"/><!-- HANGUL SYLLABLE POLB -->
+      <map code="0xd3f8" name="1em"/><!-- HANGUL SYLLABLE POLS -->
+      <map code="0xd3f9" name="1em"/><!-- HANGUL SYLLABLE POLT -->
+      <map code="0xd3fa" name="1em"/><!-- HANGUL SYLLABLE POLP -->
+      <map code="0xd3fb" name="1em"/><!-- HANGUL SYLLABLE POLH -->
+      <map code="0xd3fc" name="1em"/><!-- HANGUL SYLLABLE POM -->
+      <map code="0xd3fd" name="1em"/><!-- HANGUL SYLLABLE POB -->
+      <map code="0xd3fe" name="1em"/><!-- HANGUL SYLLABLE POBS -->
+      <map code="0xd3ff" name="1em"/><!-- HANGUL SYLLABLE POS -->
+      <map code="0xd400" name="1em"/><!-- HANGUL SYLLABLE POSS -->
+      <map code="0xd401" name="1em"/><!-- HANGUL SYLLABLE PONG -->
+      <map code="0xd402" name="1em"/><!-- HANGUL SYLLABLE POJ -->
+      <map code="0xd403" name="1em"/><!-- HANGUL SYLLABLE POC -->
+      <map code="0xd404" name="1em"/><!-- HANGUL SYLLABLE POK -->
+      <map code="0xd405" name="1em"/><!-- HANGUL SYLLABLE POT -->
+      <map code="0xd406" name="1em"/><!-- HANGUL SYLLABLE POP -->
+      <map code="0xd407" name="1em"/><!-- HANGUL SYLLABLE POH -->
+      <map code="0xd408" name="1em"/><!-- HANGUL SYLLABLE PWA -->
+      <map code="0xd409" name="1em"/><!-- HANGUL SYLLABLE PWAG -->
+      <map code="0xd40a" name="1em"/><!-- HANGUL SYLLABLE PWAGG -->
+      <map code="0xd40b" name="1em"/><!-- HANGUL SYLLABLE PWAGS -->
+      <map code="0xd40c" name="1em"/><!-- HANGUL SYLLABLE PWAN -->
+      <map code="0xd40d" name="1em"/><!-- HANGUL SYLLABLE PWANJ -->
+      <map code="0xd40e" name="1em"/><!-- HANGUL SYLLABLE PWANH -->
+      <map code="0xd40f" name="1em"/><!-- HANGUL SYLLABLE PWAD -->
+      <map code="0xd410" name="1em"/><!-- HANGUL SYLLABLE PWAL -->
+      <map code="0xd411" name="1em"/><!-- HANGUL SYLLABLE PWALG -->
+      <map code="0xd412" name="1em"/><!-- HANGUL SYLLABLE PWALM -->
+      <map code="0xd413" name="1em"/><!-- HANGUL SYLLABLE PWALB -->
+      <map code="0xd414" name="1em"/><!-- HANGUL SYLLABLE PWALS -->
+      <map code="0xd415" name="1em"/><!-- HANGUL SYLLABLE PWALT -->
+      <map code="0xd416" name="1em"/><!-- HANGUL SYLLABLE PWALP -->
+      <map code="0xd417" name="1em"/><!-- HANGUL SYLLABLE PWALH -->
+      <map code="0xd418" name="1em"/><!-- HANGUL SYLLABLE PWAM -->
+      <map code="0xd419" name="1em"/><!-- HANGUL SYLLABLE PWAB -->
+      <map code="0xd41a" name="1em"/><!-- HANGUL SYLLABLE PWABS -->
+      <map code="0xd41b" name="1em"/><!-- HANGUL SYLLABLE PWAS -->
+      <map code="0xd41c" name="1em"/><!-- HANGUL SYLLABLE PWASS -->
+      <map code="0xd41d" name="1em"/><!-- HANGUL SYLLABLE PWANG -->
+      <map code="0xd41e" name="1em"/><!-- HANGUL SYLLABLE PWAJ -->
+      <map code="0xd41f" name="1em"/><!-- HANGUL SYLLABLE PWAC -->
+      <map code="0xd420" name="1em"/><!-- HANGUL SYLLABLE PWAK -->
+      <map code="0xd421" name="1em"/><!-- HANGUL SYLLABLE PWAT -->
+      <map code="0xd422" name="1em"/><!-- HANGUL SYLLABLE PWAP -->
+      <map code="0xd423" name="1em"/><!-- HANGUL SYLLABLE PWAH -->
+      <map code="0xd424" name="1em"/><!-- HANGUL SYLLABLE PWAE -->
+      <map code="0xd425" name="1em"/><!-- HANGUL SYLLABLE PWAEG -->
+      <map code="0xd426" name="1em"/><!-- HANGUL SYLLABLE PWAEGG -->
+      <map code="0xd427" name="1em"/><!-- HANGUL SYLLABLE PWAEGS -->
+      <map code="0xd428" name="1em"/><!-- HANGUL SYLLABLE PWAEN -->
+      <map code="0xd429" name="1em"/><!-- HANGUL SYLLABLE PWAENJ -->
+      <map code="0xd42a" name="1em"/><!-- HANGUL SYLLABLE PWAENH -->
+      <map code="0xd42b" name="1em"/><!-- HANGUL SYLLABLE PWAED -->
+      <map code="0xd42c" name="1em"/><!-- HANGUL SYLLABLE PWAEL -->
+      <map code="0xd42d" name="1em"/><!-- HANGUL SYLLABLE PWAELG -->
+      <map code="0xd42e" name="1em"/><!-- HANGUL SYLLABLE PWAELM -->
+      <map code="0xd42f" name="1em"/><!-- HANGUL SYLLABLE PWAELB -->
+      <map code="0xd430" name="1em"/><!-- HANGUL SYLLABLE PWAELS -->
+      <map code="0xd431" name="1em"/><!-- HANGUL SYLLABLE PWAELT -->
+      <map code="0xd432" name="1em"/><!-- HANGUL SYLLABLE PWAELP -->
+      <map code="0xd433" name="1em"/><!-- HANGUL SYLLABLE PWAELH -->
+      <map code="0xd434" name="1em"/><!-- HANGUL SYLLABLE PWAEM -->
+      <map code="0xd435" name="1em"/><!-- HANGUL SYLLABLE PWAEB -->
+      <map code="0xd436" name="1em"/><!-- HANGUL SYLLABLE PWAEBS -->
+      <map code="0xd437" name="1em"/><!-- HANGUL SYLLABLE PWAES -->
+      <map code="0xd438" name="1em"/><!-- HANGUL SYLLABLE PWAESS -->
+      <map code="0xd439" name="1em"/><!-- HANGUL SYLLABLE PWAENG -->
+      <map code="0xd43a" name="1em"/><!-- HANGUL SYLLABLE PWAEJ -->
+      <map code="0xd43b" name="1em"/><!-- HANGUL SYLLABLE PWAEC -->
+      <map code="0xd43c" name="1em"/><!-- HANGUL SYLLABLE PWAEK -->
+      <map code="0xd43d" name="1em"/><!-- HANGUL SYLLABLE PWAET -->
+      <map code="0xd43e" name="1em"/><!-- HANGUL SYLLABLE PWAEP -->
+      <map code="0xd43f" name="1em"/><!-- HANGUL SYLLABLE PWAEH -->
+      <map code="0xd440" name="1em"/><!-- HANGUL SYLLABLE POE -->
+      <map code="0xd441" name="1em"/><!-- HANGUL SYLLABLE POEG -->
+      <map code="0xd442" name="1em"/><!-- HANGUL SYLLABLE POEGG -->
+      <map code="0xd443" name="1em"/><!-- HANGUL SYLLABLE POEGS -->
+      <map code="0xd444" name="1em"/><!-- HANGUL SYLLABLE POEN -->
+      <map code="0xd445" name="1em"/><!-- HANGUL SYLLABLE POENJ -->
+      <map code="0xd446" name="1em"/><!-- HANGUL SYLLABLE POENH -->
+      <map code="0xd447" name="1em"/><!-- HANGUL SYLLABLE POED -->
+      <map code="0xd448" name="1em"/><!-- HANGUL SYLLABLE POEL -->
+      <map code="0xd449" name="1em"/><!-- HANGUL SYLLABLE POELG -->
+      <map code="0xd44a" name="1em"/><!-- HANGUL SYLLABLE POELM -->
+      <map code="0xd44b" name="1em"/><!-- HANGUL SYLLABLE POELB -->
+      <map code="0xd44c" name="1em"/><!-- HANGUL SYLLABLE POELS -->
+      <map code="0xd44d" name="1em"/><!-- HANGUL SYLLABLE POELT -->
+      <map code="0xd44e" name="1em"/><!-- HANGUL SYLLABLE POELP -->
+      <map code="0xd44f" name="1em"/><!-- HANGUL SYLLABLE POELH -->
+      <map code="0xd450" name="1em"/><!-- HANGUL SYLLABLE POEM -->
+      <map code="0xd451" name="1em"/><!-- HANGUL SYLLABLE POEB -->
+      <map code="0xd452" name="1em"/><!-- HANGUL SYLLABLE POEBS -->
+      <map code="0xd453" name="1em"/><!-- HANGUL SYLLABLE POES -->
+      <map code="0xd454" name="1em"/><!-- HANGUL SYLLABLE POESS -->
+      <map code="0xd455" name="1em"/><!-- HANGUL SYLLABLE POENG -->
+      <map code="0xd456" name="1em"/><!-- HANGUL SYLLABLE POEJ -->
+      <map code="0xd457" name="1em"/><!-- HANGUL SYLLABLE POEC -->
+      <map code="0xd458" name="1em"/><!-- HANGUL SYLLABLE POEK -->
+      <map code="0xd459" name="1em"/><!-- HANGUL SYLLABLE POET -->
+      <map code="0xd45a" name="1em"/><!-- HANGUL SYLLABLE POEP -->
+      <map code="0xd45b" name="1em"/><!-- HANGUL SYLLABLE POEH -->
+      <map code="0xd45c" name="1em"/><!-- HANGUL SYLLABLE PYO -->
+      <map code="0xd45d" name="1em"/><!-- HANGUL SYLLABLE PYOG -->
+      <map code="0xd45e" name="1em"/><!-- HANGUL SYLLABLE PYOGG -->
+      <map code="0xd45f" name="1em"/><!-- HANGUL SYLLABLE PYOGS -->
+      <map code="0xd460" name="1em"/><!-- HANGUL SYLLABLE PYON -->
+      <map code="0xd461" name="1em"/><!-- HANGUL SYLLABLE PYONJ -->
+      <map code="0xd462" name="1em"/><!-- HANGUL SYLLABLE PYONH -->
+      <map code="0xd463" name="1em"/><!-- HANGUL SYLLABLE PYOD -->
+      <map code="0xd464" name="1em"/><!-- HANGUL SYLLABLE PYOL -->
+      <map code="0xd465" name="1em"/><!-- HANGUL SYLLABLE PYOLG -->
+      <map code="0xd466" name="1em"/><!-- HANGUL SYLLABLE PYOLM -->
+      <map code="0xd467" name="1em"/><!-- HANGUL SYLLABLE PYOLB -->
+      <map code="0xd468" name="1em"/><!-- HANGUL SYLLABLE PYOLS -->
+      <map code="0xd469" name="1em"/><!-- HANGUL SYLLABLE PYOLT -->
+      <map code="0xd46a" name="1em"/><!-- HANGUL SYLLABLE PYOLP -->
+      <map code="0xd46b" name="1em"/><!-- HANGUL SYLLABLE PYOLH -->
+      <map code="0xd46c" name="1em"/><!-- HANGUL SYLLABLE PYOM -->
+      <map code="0xd46d" name="1em"/><!-- HANGUL SYLLABLE PYOB -->
+      <map code="0xd46e" name="1em"/><!-- HANGUL SYLLABLE PYOBS -->
+      <map code="0xd46f" name="1em"/><!-- HANGUL SYLLABLE PYOS -->
+      <map code="0xd470" name="1em"/><!-- HANGUL SYLLABLE PYOSS -->
+      <map code="0xd471" name="1em"/><!-- HANGUL SYLLABLE PYONG -->
+      <map code="0xd472" name="1em"/><!-- HANGUL SYLLABLE PYOJ -->
+      <map code="0xd473" name="1em"/><!-- HANGUL SYLLABLE PYOC -->
+      <map code="0xd474" name="1em"/><!-- HANGUL SYLLABLE PYOK -->
+      <map code="0xd475" name="1em"/><!-- HANGUL SYLLABLE PYOT -->
+      <map code="0xd476" name="1em"/><!-- HANGUL SYLLABLE PYOP -->
+      <map code="0xd477" name="1em"/><!-- HANGUL SYLLABLE PYOH -->
+      <map code="0xd478" name="1em"/><!-- HANGUL SYLLABLE PU -->
+      <map code="0xd479" name="1em"/><!-- HANGUL SYLLABLE PUG -->
+      <map code="0xd47a" name="1em"/><!-- HANGUL SYLLABLE PUGG -->
+      <map code="0xd47b" name="1em"/><!-- HANGUL SYLLABLE PUGS -->
+      <map code="0xd47c" name="1em"/><!-- HANGUL SYLLABLE PUN -->
+      <map code="0xd47d" name="1em"/><!-- HANGUL SYLLABLE PUNJ -->
+      <map code="0xd47e" name="1em"/><!-- HANGUL SYLLABLE PUNH -->
+      <map code="0xd47f" name="1em"/><!-- HANGUL SYLLABLE PUD -->
+      <map code="0xd480" name="1em"/><!-- HANGUL SYLLABLE PUL -->
+      <map code="0xd481" name="1em"/><!-- HANGUL SYLLABLE PULG -->
+      <map code="0xd482" name="1em"/><!-- HANGUL SYLLABLE PULM -->
+      <map code="0xd483" name="1em"/><!-- HANGUL SYLLABLE PULB -->
+      <map code="0xd484" name="1em"/><!-- HANGUL SYLLABLE PULS -->
+      <map code="0xd485" name="1em"/><!-- HANGUL SYLLABLE PULT -->
+      <map code="0xd486" name="1em"/><!-- HANGUL SYLLABLE PULP -->
+      <map code="0xd487" name="1em"/><!-- HANGUL SYLLABLE PULH -->
+      <map code="0xd488" name="1em"/><!-- HANGUL SYLLABLE PUM -->
+      <map code="0xd489" name="1em"/><!-- HANGUL SYLLABLE PUB -->
+      <map code="0xd48a" name="1em"/><!-- HANGUL SYLLABLE PUBS -->
+      <map code="0xd48b" name="1em"/><!-- HANGUL SYLLABLE PUS -->
+      <map code="0xd48c" name="1em"/><!-- HANGUL SYLLABLE PUSS -->
+      <map code="0xd48d" name="1em"/><!-- HANGUL SYLLABLE PUNG -->
+      <map code="0xd48e" name="1em"/><!-- HANGUL SYLLABLE PUJ -->
+      <map code="0xd48f" name="1em"/><!-- HANGUL SYLLABLE PUC -->
+      <map code="0xd490" name="1em"/><!-- HANGUL SYLLABLE PUK -->
+      <map code="0xd491" name="1em"/><!-- HANGUL SYLLABLE PUT -->
+      <map code="0xd492" name="1em"/><!-- HANGUL SYLLABLE PUP -->
+      <map code="0xd493" name="1em"/><!-- HANGUL SYLLABLE PUH -->
+      <map code="0xd494" name="1em"/><!-- HANGUL SYLLABLE PWEO -->
+      <map code="0xd495" name="1em"/><!-- HANGUL SYLLABLE PWEOG -->
+      <map code="0xd496" name="1em"/><!-- HANGUL SYLLABLE PWEOGG -->
+      <map code="0xd497" name="1em"/><!-- HANGUL SYLLABLE PWEOGS -->
+      <map code="0xd498" name="1em"/><!-- HANGUL SYLLABLE PWEON -->
+      <map code="0xd499" name="1em"/><!-- HANGUL SYLLABLE PWEONJ -->
+      <map code="0xd49a" name="1em"/><!-- HANGUL SYLLABLE PWEONH -->
+      <map code="0xd49b" name="1em"/><!-- HANGUL SYLLABLE PWEOD -->
+      <map code="0xd49c" name="1em"/><!-- HANGUL SYLLABLE PWEOL -->
+      <map code="0xd49d" name="1em"/><!-- HANGUL SYLLABLE PWEOLG -->
+      <map code="0xd49e" name="1em"/><!-- HANGUL SYLLABLE PWEOLM -->
+      <map code="0xd49f" name="1em"/><!-- HANGUL SYLLABLE PWEOLB -->
+      <map code="0xd4a0" name="1em"/><!-- HANGUL SYLLABLE PWEOLS -->
+      <map code="0xd4a1" name="1em"/><!-- HANGUL SYLLABLE PWEOLT -->
+      <map code="0xd4a2" name="1em"/><!-- HANGUL SYLLABLE PWEOLP -->
+      <map code="0xd4a3" name="1em"/><!-- HANGUL SYLLABLE PWEOLH -->
+      <map code="0xd4a4" name="1em"/><!-- HANGUL SYLLABLE PWEOM -->
+      <map code="0xd4a5" name="1em"/><!-- HANGUL SYLLABLE PWEOB -->
+      <map code="0xd4a6" name="1em"/><!-- HANGUL SYLLABLE PWEOBS -->
+      <map code="0xd4a7" name="1em"/><!-- HANGUL SYLLABLE PWEOS -->
+      <map code="0xd4a8" name="1em"/><!-- HANGUL SYLLABLE PWEOSS -->
+      <map code="0xd4a9" name="1em"/><!-- HANGUL SYLLABLE PWEONG -->
+      <map code="0xd4aa" name="1em"/><!-- HANGUL SYLLABLE PWEOJ -->
+      <map code="0xd4ab" name="1em"/><!-- HANGUL SYLLABLE PWEOC -->
+      <map code="0xd4ac" name="1em"/><!-- HANGUL SYLLABLE PWEOK -->
+      <map code="0xd4ad" name="1em"/><!-- HANGUL SYLLABLE PWEOT -->
+      <map code="0xd4ae" name="1em"/><!-- HANGUL SYLLABLE PWEOP -->
+      <map code="0xd4af" name="1em"/><!-- HANGUL SYLLABLE PWEOH -->
+      <map code="0xd4b0" name="1em"/><!-- HANGUL SYLLABLE PWE -->
+      <map code="0xd4b1" name="1em"/><!-- HANGUL SYLLABLE PWEG -->
+      <map code="0xd4b2" name="1em"/><!-- HANGUL SYLLABLE PWEGG -->
+      <map code="0xd4b3" name="1em"/><!-- HANGUL SYLLABLE PWEGS -->
+      <map code="0xd4b4" name="1em"/><!-- HANGUL SYLLABLE PWEN -->
+      <map code="0xd4b5" name="1em"/><!-- HANGUL SYLLABLE PWENJ -->
+      <map code="0xd4b6" name="1em"/><!-- HANGUL SYLLABLE PWENH -->
+      <map code="0xd4b7" name="1em"/><!-- HANGUL SYLLABLE PWED -->
+      <map code="0xd4b8" name="1em"/><!-- HANGUL SYLLABLE PWEL -->
+      <map code="0xd4b9" name="1em"/><!-- HANGUL SYLLABLE PWELG -->
+      <map code="0xd4ba" name="1em"/><!-- HANGUL SYLLABLE PWELM -->
+      <map code="0xd4bb" name="1em"/><!-- HANGUL SYLLABLE PWELB -->
+      <map code="0xd4bc" name="1em"/><!-- HANGUL SYLLABLE PWELS -->
+      <map code="0xd4bd" name="1em"/><!-- HANGUL SYLLABLE PWELT -->
+      <map code="0xd4be" name="1em"/><!-- HANGUL SYLLABLE PWELP -->
+      <map code="0xd4bf" name="1em"/><!-- HANGUL SYLLABLE PWELH -->
+      <map code="0xd4c0" name="1em"/><!-- HANGUL SYLLABLE PWEM -->
+      <map code="0xd4c1" name="1em"/><!-- HANGUL SYLLABLE PWEB -->
+      <map code="0xd4c2" name="1em"/><!-- HANGUL SYLLABLE PWEBS -->
+      <map code="0xd4c3" name="1em"/><!-- HANGUL SYLLABLE PWES -->
+      <map code="0xd4c4" name="1em"/><!-- HANGUL SYLLABLE PWESS -->
+      <map code="0xd4c5" name="1em"/><!-- HANGUL SYLLABLE PWENG -->
+      <map code="0xd4c6" name="1em"/><!-- HANGUL SYLLABLE PWEJ -->
+      <map code="0xd4c7" name="1em"/><!-- HANGUL SYLLABLE PWEC -->
+      <map code="0xd4c8" name="1em"/><!-- HANGUL SYLLABLE PWEK -->
+      <map code="0xd4c9" name="1em"/><!-- HANGUL SYLLABLE PWET -->
+      <map code="0xd4ca" name="1em"/><!-- HANGUL SYLLABLE PWEP -->
+      <map code="0xd4cb" name="1em"/><!-- HANGUL SYLLABLE PWEH -->
+      <map code="0xd4cc" name="1em"/><!-- HANGUL SYLLABLE PWI -->
+      <map code="0xd4cd" name="1em"/><!-- HANGUL SYLLABLE PWIG -->
+      <map code="0xd4ce" name="1em"/><!-- HANGUL SYLLABLE PWIGG -->
+      <map code="0xd4cf" name="1em"/><!-- HANGUL SYLLABLE PWIGS -->
+      <map code="0xd4d0" name="1em"/><!-- HANGUL SYLLABLE PWIN -->
+      <map code="0xd4d1" name="1em"/><!-- HANGUL SYLLABLE PWINJ -->
+      <map code="0xd4d2" name="1em"/><!-- HANGUL SYLLABLE PWINH -->
+      <map code="0xd4d3" name="1em"/><!-- HANGUL SYLLABLE PWID -->
+      <map code="0xd4d4" name="1em"/><!-- HANGUL SYLLABLE PWIL -->
+      <map code="0xd4d5" name="1em"/><!-- HANGUL SYLLABLE PWILG -->
+      <map code="0xd4d6" name="1em"/><!-- HANGUL SYLLABLE PWILM -->
+      <map code="0xd4d7" name="1em"/><!-- HANGUL SYLLABLE PWILB -->
+      <map code="0xd4d8" name="1em"/><!-- HANGUL SYLLABLE PWILS -->
+      <map code="0xd4d9" name="1em"/><!-- HANGUL SYLLABLE PWILT -->
+      <map code="0xd4da" name="1em"/><!-- HANGUL SYLLABLE PWILP -->
+      <map code="0xd4db" name="1em"/><!-- HANGUL SYLLABLE PWILH -->
+      <map code="0xd4dc" name="1em"/><!-- HANGUL SYLLABLE PWIM -->
+      <map code="0xd4dd" name="1em"/><!-- HANGUL SYLLABLE PWIB -->
+      <map code="0xd4de" name="1em"/><!-- HANGUL SYLLABLE PWIBS -->
+      <map code="0xd4df" name="1em"/><!-- HANGUL SYLLABLE PWIS -->
+      <map code="0xd4e0" name="1em"/><!-- HANGUL SYLLABLE PWISS -->
+      <map code="0xd4e1" name="1em"/><!-- HANGUL SYLLABLE PWING -->
+      <map code="0xd4e2" name="1em"/><!-- HANGUL SYLLABLE PWIJ -->
+      <map code="0xd4e3" name="1em"/><!-- HANGUL SYLLABLE PWIC -->
+      <map code="0xd4e4" name="1em"/><!-- HANGUL SYLLABLE PWIK -->
+      <map code="0xd4e5" name="1em"/><!-- HANGUL SYLLABLE PWIT -->
+      <map code="0xd4e6" name="1em"/><!-- HANGUL SYLLABLE PWIP -->
+      <map code="0xd4e7" name="1em"/><!-- HANGUL SYLLABLE PWIH -->
+      <map code="0xd4e8" name="1em"/><!-- HANGUL SYLLABLE PYU -->
+      <map code="0xd4e9" name="1em"/><!-- HANGUL SYLLABLE PYUG -->
+      <map code="0xd4ea" name="1em"/><!-- HANGUL SYLLABLE PYUGG -->
+      <map code="0xd4eb" name="1em"/><!-- HANGUL SYLLABLE PYUGS -->
+      <map code="0xd4ec" name="1em"/><!-- HANGUL SYLLABLE PYUN -->
+      <map code="0xd4ed" name="1em"/><!-- HANGUL SYLLABLE PYUNJ -->
+      <map code="0xd4ee" name="1em"/><!-- HANGUL SYLLABLE PYUNH -->
+      <map code="0xd4ef" name="1em"/><!-- HANGUL SYLLABLE PYUD -->
+      <map code="0xd4f0" name="1em"/><!-- HANGUL SYLLABLE PYUL -->
+      <map code="0xd4f1" name="1em"/><!-- HANGUL SYLLABLE PYULG -->
+      <map code="0xd4f2" name="1em"/><!-- HANGUL SYLLABLE PYULM -->
+      <map code="0xd4f3" name="1em"/><!-- HANGUL SYLLABLE PYULB -->
+      <map code="0xd4f4" name="1em"/><!-- HANGUL SYLLABLE PYULS -->
+      <map code="0xd4f5" name="1em"/><!-- HANGUL SYLLABLE PYULT -->
+      <map code="0xd4f6" name="1em"/><!-- HANGUL SYLLABLE PYULP -->
+      <map code="0xd4f7" name="1em"/><!-- HANGUL SYLLABLE PYULH -->
+      <map code="0xd4f8" name="1em"/><!-- HANGUL SYLLABLE PYUM -->
+      <map code="0xd4f9" name="1em"/><!-- HANGUL SYLLABLE PYUB -->
+      <map code="0xd4fa" name="1em"/><!-- HANGUL SYLLABLE PYUBS -->
+      <map code="0xd4fb" name="1em"/><!-- HANGUL SYLLABLE PYUS -->
+      <map code="0xd4fc" name="1em"/><!-- HANGUL SYLLABLE PYUSS -->
+      <map code="0xd4fd" name="1em"/><!-- HANGUL SYLLABLE PYUNG -->
+      <map code="0xd4fe" name="1em"/><!-- HANGUL SYLLABLE PYUJ -->
+      <map code="0xd4ff" name="1em"/><!-- HANGUL SYLLABLE PYUC -->
+      <map code="0xd500" name="1em"/><!-- HANGUL SYLLABLE PYUK -->
+      <map code="0xd501" name="1em"/><!-- HANGUL SYLLABLE PYUT -->
+      <map code="0xd502" name="1em"/><!-- HANGUL SYLLABLE PYUP -->
+      <map code="0xd503" name="1em"/><!-- HANGUL SYLLABLE PYUH -->
+      <map code="0xd504" name="1em"/><!-- HANGUL SYLLABLE PEU -->
+      <map code="0xd505" name="1em"/><!-- HANGUL SYLLABLE PEUG -->
+      <map code="0xd506" name="1em"/><!-- HANGUL SYLLABLE PEUGG -->
+      <map code="0xd507" name="1em"/><!-- HANGUL SYLLABLE PEUGS -->
+      <map code="0xd508" name="1em"/><!-- HANGUL SYLLABLE PEUN -->
+      <map code="0xd509" name="1em"/><!-- HANGUL SYLLABLE PEUNJ -->
+      <map code="0xd50a" name="1em"/><!-- HANGUL SYLLABLE PEUNH -->
+      <map code="0xd50b" name="1em"/><!-- HANGUL SYLLABLE PEUD -->
+      <map code="0xd50c" name="1em"/><!-- HANGUL SYLLABLE PEUL -->
+      <map code="0xd50d" name="1em"/><!-- HANGUL SYLLABLE PEULG -->
+      <map code="0xd50e" name="1em"/><!-- HANGUL SYLLABLE PEULM -->
+      <map code="0xd50f" name="1em"/><!-- HANGUL SYLLABLE PEULB -->
+      <map code="0xd510" name="1em"/><!-- HANGUL SYLLABLE PEULS -->
+      <map code="0xd511" name="1em"/><!-- HANGUL SYLLABLE PEULT -->
+      <map code="0xd512" name="1em"/><!-- HANGUL SYLLABLE PEULP -->
+      <map code="0xd513" name="1em"/><!-- HANGUL SYLLABLE PEULH -->
+      <map code="0xd514" name="1em"/><!-- HANGUL SYLLABLE PEUM -->
+      <map code="0xd515" name="1em"/><!-- HANGUL SYLLABLE PEUB -->
+      <map code="0xd516" name="1em"/><!-- HANGUL SYLLABLE PEUBS -->
+      <map code="0xd517" name="1em"/><!-- HANGUL SYLLABLE PEUS -->
+      <map code="0xd518" name="1em"/><!-- HANGUL SYLLABLE PEUSS -->
+      <map code="0xd519" name="1em"/><!-- HANGUL SYLLABLE PEUNG -->
+      <map code="0xd51a" name="1em"/><!-- HANGUL SYLLABLE PEUJ -->
+      <map code="0xd51b" name="1em"/><!-- HANGUL SYLLABLE PEUC -->
+      <map code="0xd51c" name="1em"/><!-- HANGUL SYLLABLE PEUK -->
+      <map code="0xd51d" name="1em"/><!-- HANGUL SYLLABLE PEUT -->
+      <map code="0xd51e" name="1em"/><!-- HANGUL SYLLABLE PEUP -->
+      <map code="0xd51f" name="1em"/><!-- HANGUL SYLLABLE PEUH -->
+      <map code="0xd520" name="1em"/><!-- HANGUL SYLLABLE PYI -->
+      <map code="0xd521" name="1em"/><!-- HANGUL SYLLABLE PYIG -->
+      <map code="0xd522" name="1em"/><!-- HANGUL SYLLABLE PYIGG -->
+      <map code="0xd523" name="1em"/><!-- HANGUL SYLLABLE PYIGS -->
+      <map code="0xd524" name="1em"/><!-- HANGUL SYLLABLE PYIN -->
+      <map code="0xd525" name="1em"/><!-- HANGUL SYLLABLE PYINJ -->
+      <map code="0xd526" name="1em"/><!-- HANGUL SYLLABLE PYINH -->
+      <map code="0xd527" name="1em"/><!-- HANGUL SYLLABLE PYID -->
+      <map code="0xd528" name="1em"/><!-- HANGUL SYLLABLE PYIL -->
+      <map code="0xd529" name="1em"/><!-- HANGUL SYLLABLE PYILG -->
+      <map code="0xd52a" name="1em"/><!-- HANGUL SYLLABLE PYILM -->
+      <map code="0xd52b" name="1em"/><!-- HANGUL SYLLABLE PYILB -->
+      <map code="0xd52c" name="1em"/><!-- HANGUL SYLLABLE PYILS -->
+      <map code="0xd52d" name="1em"/><!-- HANGUL SYLLABLE PYILT -->
+      <map code="0xd52e" name="1em"/><!-- HANGUL SYLLABLE PYILP -->
+      <map code="0xd52f" name="1em"/><!-- HANGUL SYLLABLE PYILH -->
+      <map code="0xd530" name="1em"/><!-- HANGUL SYLLABLE PYIM -->
+      <map code="0xd531" name="1em"/><!-- HANGUL SYLLABLE PYIB -->
+      <map code="0xd532" name="1em"/><!-- HANGUL SYLLABLE PYIBS -->
+      <map code="0xd533" name="1em"/><!-- HANGUL SYLLABLE PYIS -->
+      <map code="0xd534" name="1em"/><!-- HANGUL SYLLABLE PYISS -->
+      <map code="0xd535" name="1em"/><!-- HANGUL SYLLABLE PYING -->
+      <map code="0xd536" name="1em"/><!-- HANGUL SYLLABLE PYIJ -->
+      <map code="0xd537" name="1em"/><!-- HANGUL SYLLABLE PYIC -->
+      <map code="0xd538" name="1em"/><!-- HANGUL SYLLABLE PYIK -->
+      <map code="0xd539" name="1em"/><!-- HANGUL SYLLABLE PYIT -->
+      <map code="0xd53a" name="1em"/><!-- HANGUL SYLLABLE PYIP -->
+      <map code="0xd53b" name="1em"/><!-- HANGUL SYLLABLE PYIH -->
+      <map code="0xd53c" name="1em"/><!-- HANGUL SYLLABLE PI -->
+      <map code="0xd53d" name="1em"/><!-- HANGUL SYLLABLE PIG -->
+      <map code="0xd53e" name="1em"/><!-- HANGUL SYLLABLE PIGG -->
+      <map code="0xd53f" name="1em"/><!-- HANGUL SYLLABLE PIGS -->
+      <map code="0xd540" name="1em"/><!-- HANGUL SYLLABLE PIN -->
+      <map code="0xd541" name="1em"/><!-- HANGUL SYLLABLE PINJ -->
+      <map code="0xd542" name="1em"/><!-- HANGUL SYLLABLE PINH -->
+      <map code="0xd543" name="1em"/><!-- HANGUL SYLLABLE PID -->
+      <map code="0xd544" name="1em"/><!-- HANGUL SYLLABLE PIL -->
+      <map code="0xd545" name="1em"/><!-- HANGUL SYLLABLE PILG -->
+      <map code="0xd546" name="1em"/><!-- HANGUL SYLLABLE PILM -->
+      <map code="0xd547" name="1em"/><!-- HANGUL SYLLABLE PILB -->
+      <map code="0xd548" name="1em"/><!-- HANGUL SYLLABLE PILS -->
+      <map code="0xd549" name="1em"/><!-- HANGUL SYLLABLE PILT -->
+      <map code="0xd54a" name="1em"/><!-- HANGUL SYLLABLE PILP -->
+      <map code="0xd54b" name="1em"/><!-- HANGUL SYLLABLE PILH -->
+      <map code="0xd54c" name="1em"/><!-- HANGUL SYLLABLE PIM -->
+      <map code="0xd54d" name="1em"/><!-- HANGUL SYLLABLE PIB -->
+      <map code="0xd54e" name="1em"/><!-- HANGUL SYLLABLE PIBS -->
+      <map code="0xd54f" name="1em"/><!-- HANGUL SYLLABLE PIS -->
+      <map code="0xd550" name="1em"/><!-- HANGUL SYLLABLE PISS -->
+      <map code="0xd551" name="1em"/><!-- HANGUL SYLLABLE PING -->
+      <map code="0xd552" name="1em"/><!-- HANGUL SYLLABLE PIJ -->
+      <map code="0xd553" name="1em"/><!-- HANGUL SYLLABLE PIC -->
+      <map code="0xd554" name="1em"/><!-- HANGUL SYLLABLE PIK -->
+      <map code="0xd555" name="1em"/><!-- HANGUL SYLLABLE PIT -->
+      <map code="0xd556" name="1em"/><!-- HANGUL SYLLABLE PIP -->
+      <map code="0xd557" name="1em"/><!-- HANGUL SYLLABLE PIH -->
+      <map code="0xd558" name="1em"/><!-- HANGUL SYLLABLE HA -->
+      <map code="0xd559" name="1em"/><!-- HANGUL SYLLABLE HAG -->
+      <map code="0xd55a" name="1em"/><!-- HANGUL SYLLABLE HAGG -->
+      <map code="0xd55b" name="1em"/><!-- HANGUL SYLLABLE HAGS -->
+      <map code="0xd55c" name="1em"/><!-- HANGUL SYLLABLE HAN -->
+      <map code="0xd55d" name="1em"/><!-- HANGUL SYLLABLE HANJ -->
+      <map code="0xd55e" name="1em"/><!-- HANGUL SYLLABLE HANH -->
+      <map code="0xd55f" name="1em"/><!-- HANGUL SYLLABLE HAD -->
+      <map code="0xd560" name="1em"/><!-- HANGUL SYLLABLE HAL -->
+      <map code="0xd561" name="1em"/><!-- HANGUL SYLLABLE HALG -->
+      <map code="0xd562" name="1em"/><!-- HANGUL SYLLABLE HALM -->
+      <map code="0xd563" name="1em"/><!-- HANGUL SYLLABLE HALB -->
+      <map code="0xd564" name="1em"/><!-- HANGUL SYLLABLE HALS -->
+      <map code="0xd565" name="1em"/><!-- HANGUL SYLLABLE HALT -->
+      <map code="0xd566" name="1em"/><!-- HANGUL SYLLABLE HALP -->
+      <map code="0xd567" name="1em"/><!-- HANGUL SYLLABLE HALH -->
+      <map code="0xd568" name="1em"/><!-- HANGUL SYLLABLE HAM -->
+      <map code="0xd569" name="1em"/><!-- HANGUL SYLLABLE HAB -->
+      <map code="0xd56a" name="1em"/><!-- HANGUL SYLLABLE HABS -->
+      <map code="0xd56b" name="1em"/><!-- HANGUL SYLLABLE HAS -->
+      <map code="0xd56c" name="1em"/><!-- HANGUL SYLLABLE HASS -->
+      <map code="0xd56d" name="1em"/><!-- HANGUL SYLLABLE HANG -->
+      <map code="0xd56e" name="1em"/><!-- HANGUL SYLLABLE HAJ -->
+      <map code="0xd56f" name="1em"/><!-- HANGUL SYLLABLE HAC -->
+      <map code="0xd570" name="1em"/><!-- HANGUL SYLLABLE HAK -->
+      <map code="0xd571" name="1em"/><!-- HANGUL SYLLABLE HAT -->
+      <map code="0xd572" name="1em"/><!-- HANGUL SYLLABLE HAP -->
+      <map code="0xd573" name="1em"/><!-- HANGUL SYLLABLE HAH -->
+      <map code="0xd574" name="1em"/><!-- HANGUL SYLLABLE HAE -->
+      <map code="0xd575" name="1em"/><!-- HANGUL SYLLABLE HAEG -->
+      <map code="0xd576" name="1em"/><!-- HANGUL SYLLABLE HAEGG -->
+      <map code="0xd577" name="1em"/><!-- HANGUL SYLLABLE HAEGS -->
+      <map code="0xd578" name="1em"/><!-- HANGUL SYLLABLE HAEN -->
+      <map code="0xd579" name="1em"/><!-- HANGUL SYLLABLE HAENJ -->
+      <map code="0xd57a" name="1em"/><!-- HANGUL SYLLABLE HAENH -->
+      <map code="0xd57b" name="1em"/><!-- HANGUL SYLLABLE HAED -->
+      <map code="0xd57c" name="1em"/><!-- HANGUL SYLLABLE HAEL -->
+      <map code="0xd57d" name="1em"/><!-- HANGUL SYLLABLE HAELG -->
+      <map code="0xd57e" name="1em"/><!-- HANGUL SYLLABLE HAELM -->
+      <map code="0xd57f" name="1em"/><!-- HANGUL SYLLABLE HAELB -->
+      <map code="0xd580" name="1em"/><!-- HANGUL SYLLABLE HAELS -->
+      <map code="0xd581" name="1em"/><!-- HANGUL SYLLABLE HAELT -->
+      <map code="0xd582" name="1em"/><!-- HANGUL SYLLABLE HAELP -->
+      <map code="0xd583" name="1em"/><!-- HANGUL SYLLABLE HAELH -->
+      <map code="0xd584" name="1em"/><!-- HANGUL SYLLABLE HAEM -->
+      <map code="0xd585" name="1em"/><!-- HANGUL SYLLABLE HAEB -->
+      <map code="0xd586" name="1em"/><!-- HANGUL SYLLABLE HAEBS -->
+      <map code="0xd587" name="1em"/><!-- HANGUL SYLLABLE HAES -->
+      <map code="0xd588" name="1em"/><!-- HANGUL SYLLABLE HAESS -->
+      <map code="0xd589" name="1em"/><!-- HANGUL SYLLABLE HAENG -->
+      <map code="0xd58a" name="1em"/><!-- HANGUL SYLLABLE HAEJ -->
+      <map code="0xd58b" name="1em"/><!-- HANGUL SYLLABLE HAEC -->
+      <map code="0xd58c" name="1em"/><!-- HANGUL SYLLABLE HAEK -->
+      <map code="0xd58d" name="1em"/><!-- HANGUL SYLLABLE HAET -->
+      <map code="0xd58e" name="1em"/><!-- HANGUL SYLLABLE HAEP -->
+      <map code="0xd58f" name="1em"/><!-- HANGUL SYLLABLE HAEH -->
+      <map code="0xd590" name="1em"/><!-- HANGUL SYLLABLE HYA -->
+      <map code="0xd591" name="1em"/><!-- HANGUL SYLLABLE HYAG -->
+      <map code="0xd592" name="1em"/><!-- HANGUL SYLLABLE HYAGG -->
+      <map code="0xd593" name="1em"/><!-- HANGUL SYLLABLE HYAGS -->
+      <map code="0xd594" name="1em"/><!-- HANGUL SYLLABLE HYAN -->
+      <map code="0xd595" name="1em"/><!-- HANGUL SYLLABLE HYANJ -->
+      <map code="0xd596" name="1em"/><!-- HANGUL SYLLABLE HYANH -->
+      <map code="0xd597" name="1em"/><!-- HANGUL SYLLABLE HYAD -->
+      <map code="0xd598" name="1em"/><!-- HANGUL SYLLABLE HYAL -->
+      <map code="0xd599" name="1em"/><!-- HANGUL SYLLABLE HYALG -->
+      <map code="0xd59a" name="1em"/><!-- HANGUL SYLLABLE HYALM -->
+      <map code="0xd59b" name="1em"/><!-- HANGUL SYLLABLE HYALB -->
+      <map code="0xd59c" name="1em"/><!-- HANGUL SYLLABLE HYALS -->
+      <map code="0xd59d" name="1em"/><!-- HANGUL SYLLABLE HYALT -->
+      <map code="0xd59e" name="1em"/><!-- HANGUL SYLLABLE HYALP -->
+      <map code="0xd59f" name="1em"/><!-- HANGUL SYLLABLE HYALH -->
+      <map code="0xd5a0" name="1em"/><!-- HANGUL SYLLABLE HYAM -->
+      <map code="0xd5a1" name="1em"/><!-- HANGUL SYLLABLE HYAB -->
+      <map code="0xd5a2" name="1em"/><!-- HANGUL SYLLABLE HYABS -->
+      <map code="0xd5a3" name="1em"/><!-- HANGUL SYLLABLE HYAS -->
+      <map code="0xd5a4" name="1em"/><!-- HANGUL SYLLABLE HYASS -->
+      <map code="0xd5a5" name="1em"/><!-- HANGUL SYLLABLE HYANG -->
+      <map code="0xd5a6" name="1em"/><!-- HANGUL SYLLABLE HYAJ -->
+      <map code="0xd5a7" name="1em"/><!-- HANGUL SYLLABLE HYAC -->
+      <map code="0xd5a8" name="1em"/><!-- HANGUL SYLLABLE HYAK -->
+      <map code="0xd5a9" name="1em"/><!-- HANGUL SYLLABLE HYAT -->
+      <map code="0xd5aa" name="1em"/><!-- HANGUL SYLLABLE HYAP -->
+      <map code="0xd5ab" name="1em"/><!-- HANGUL SYLLABLE HYAH -->
+      <map code="0xd5ac" name="1em"/><!-- HANGUL SYLLABLE HYAE -->
+      <map code="0xd5ad" name="1em"/><!-- HANGUL SYLLABLE HYAEG -->
+      <map code="0xd5ae" name="1em"/><!-- HANGUL SYLLABLE HYAEGG -->
+      <map code="0xd5af" name="1em"/><!-- HANGUL SYLLABLE HYAEGS -->
+      <map code="0xd5b0" name="1em"/><!-- HANGUL SYLLABLE HYAEN -->
+      <map code="0xd5b1" name="1em"/><!-- HANGUL SYLLABLE HYAENJ -->
+      <map code="0xd5b2" name="1em"/><!-- HANGUL SYLLABLE HYAENH -->
+      <map code="0xd5b3" name="1em"/><!-- HANGUL SYLLABLE HYAED -->
+      <map code="0xd5b4" name="1em"/><!-- HANGUL SYLLABLE HYAEL -->
+      <map code="0xd5b5" name="1em"/><!-- HANGUL SYLLABLE HYAELG -->
+      <map code="0xd5b6" name="1em"/><!-- HANGUL SYLLABLE HYAELM -->
+      <map code="0xd5b7" name="1em"/><!-- HANGUL SYLLABLE HYAELB -->
+      <map code="0xd5b8" name="1em"/><!-- HANGUL SYLLABLE HYAELS -->
+      <map code="0xd5b9" name="1em"/><!-- HANGUL SYLLABLE HYAELT -->
+      <map code="0xd5ba" name="1em"/><!-- HANGUL SYLLABLE HYAELP -->
+      <map code="0xd5bb" name="1em"/><!-- HANGUL SYLLABLE HYAELH -->
+      <map code="0xd5bc" name="1em"/><!-- HANGUL SYLLABLE HYAEM -->
+      <map code="0xd5bd" name="1em"/><!-- HANGUL SYLLABLE HYAEB -->
+      <map code="0xd5be" name="1em"/><!-- HANGUL SYLLABLE HYAEBS -->
+      <map code="0xd5bf" name="1em"/><!-- HANGUL SYLLABLE HYAES -->
+      <map code="0xd5c0" name="1em"/><!-- HANGUL SYLLABLE HYAESS -->
+      <map code="0xd5c1" name="1em"/><!-- HANGUL SYLLABLE HYAENG -->
+      <map code="0xd5c2" name="1em"/><!-- HANGUL SYLLABLE HYAEJ -->
+      <map code="0xd5c3" name="1em"/><!-- HANGUL SYLLABLE HYAEC -->
+      <map code="0xd5c4" name="1em"/><!-- HANGUL SYLLABLE HYAEK -->
+      <map code="0xd5c5" name="1em"/><!-- HANGUL SYLLABLE HYAET -->
+      <map code="0xd5c6" name="1em"/><!-- HANGUL SYLLABLE HYAEP -->
+      <map code="0xd5c7" name="1em"/><!-- HANGUL SYLLABLE HYAEH -->
+      <map code="0xd5c8" name="1em"/><!-- HANGUL SYLLABLE HEO -->
+      <map code="0xd5c9" name="1em"/><!-- HANGUL SYLLABLE HEOG -->
+      <map code="0xd5ca" name="1em"/><!-- HANGUL SYLLABLE HEOGG -->
+      <map code="0xd5cb" name="1em"/><!-- HANGUL SYLLABLE HEOGS -->
+      <map code="0xd5cc" name="1em"/><!-- HANGUL SYLLABLE HEON -->
+      <map code="0xd5cd" name="1em"/><!-- HANGUL SYLLABLE HEONJ -->
+      <map code="0xd5ce" name="1em"/><!-- HANGUL SYLLABLE HEONH -->
+      <map code="0xd5cf" name="1em"/><!-- HANGUL SYLLABLE HEOD -->
+      <map code="0xd5d0" name="1em"/><!-- HANGUL SYLLABLE HEOL -->
+      <map code="0xd5d1" name="1em"/><!-- HANGUL SYLLABLE HEOLG -->
+      <map code="0xd5d2" name="1em"/><!-- HANGUL SYLLABLE HEOLM -->
+      <map code="0xd5d3" name="1em"/><!-- HANGUL SYLLABLE HEOLB -->
+      <map code="0xd5d4" name="1em"/><!-- HANGUL SYLLABLE HEOLS -->
+      <map code="0xd5d5" name="1em"/><!-- HANGUL SYLLABLE HEOLT -->
+      <map code="0xd5d6" name="1em"/><!-- HANGUL SYLLABLE HEOLP -->
+      <map code="0xd5d7" name="1em"/><!-- HANGUL SYLLABLE HEOLH -->
+      <map code="0xd5d8" name="1em"/><!-- HANGUL SYLLABLE HEOM -->
+      <map code="0xd5d9" name="1em"/><!-- HANGUL SYLLABLE HEOB -->
+      <map code="0xd5da" name="1em"/><!-- HANGUL SYLLABLE HEOBS -->
+      <map code="0xd5db" name="1em"/><!-- HANGUL SYLLABLE HEOS -->
+      <map code="0xd5dc" name="1em"/><!-- HANGUL SYLLABLE HEOSS -->
+      <map code="0xd5dd" name="1em"/><!-- HANGUL SYLLABLE HEONG -->
+      <map code="0xd5de" name="1em"/><!-- HANGUL SYLLABLE HEOJ -->
+      <map code="0xd5df" name="1em"/><!-- HANGUL SYLLABLE HEOC -->
+      <map code="0xd5e0" name="1em"/><!-- HANGUL SYLLABLE HEOK -->
+      <map code="0xd5e1" name="1em"/><!-- HANGUL SYLLABLE HEOT -->
+      <map code="0xd5e2" name="1em"/><!-- HANGUL SYLLABLE HEOP -->
+      <map code="0xd5e3" name="1em"/><!-- HANGUL SYLLABLE HEOH -->
+      <map code="0xd5e4" name="1em"/><!-- HANGUL SYLLABLE HE -->
+      <map code="0xd5e5" name="1em"/><!-- HANGUL SYLLABLE HEG -->
+      <map code="0xd5e6" name="1em"/><!-- HANGUL SYLLABLE HEGG -->
+      <map code="0xd5e7" name="1em"/><!-- HANGUL SYLLABLE HEGS -->
+      <map code="0xd5e8" name="1em"/><!-- HANGUL SYLLABLE HEN -->
+      <map code="0xd5e9" name="1em"/><!-- HANGUL SYLLABLE HENJ -->
+      <map code="0xd5ea" name="1em"/><!-- HANGUL SYLLABLE HENH -->
+      <map code="0xd5eb" name="1em"/><!-- HANGUL SYLLABLE HED -->
+      <map code="0xd5ec" name="1em"/><!-- HANGUL SYLLABLE HEL -->
+      <map code="0xd5ed" name="1em"/><!-- HANGUL SYLLABLE HELG -->
+      <map code="0xd5ee" name="1em"/><!-- HANGUL SYLLABLE HELM -->
+      <map code="0xd5ef" name="1em"/><!-- HANGUL SYLLABLE HELB -->
+      <map code="0xd5f0" name="1em"/><!-- HANGUL SYLLABLE HELS -->
+      <map code="0xd5f1" name="1em"/><!-- HANGUL SYLLABLE HELT -->
+      <map code="0xd5f2" name="1em"/><!-- HANGUL SYLLABLE HELP -->
+      <map code="0xd5f3" name="1em"/><!-- HANGUL SYLLABLE HELH -->
+      <map code="0xd5f4" name="1em"/><!-- HANGUL SYLLABLE HEM -->
+      <map code="0xd5f5" name="1em"/><!-- HANGUL SYLLABLE HEB -->
+      <map code="0xd5f6" name="1em"/><!-- HANGUL SYLLABLE HEBS -->
+      <map code="0xd5f7" name="1em"/><!-- HANGUL SYLLABLE HES -->
+      <map code="0xd5f8" name="1em"/><!-- HANGUL SYLLABLE HESS -->
+      <map code="0xd5f9" name="1em"/><!-- HANGUL SYLLABLE HENG -->
+      <map code="0xd5fa" name="1em"/><!-- HANGUL SYLLABLE HEJ -->
+      <map code="0xd5fb" name="1em"/><!-- HANGUL SYLLABLE HEC -->
+      <map code="0xd5fc" name="1em"/><!-- HANGUL SYLLABLE HEK -->
+      <map code="0xd5fd" name="1em"/><!-- HANGUL SYLLABLE HET -->
+      <map code="0xd5fe" name="1em"/><!-- HANGUL SYLLABLE HEP -->
+      <map code="0xd5ff" name="1em"/><!-- HANGUL SYLLABLE HEH -->
+      <map code="0xd600" name="1em"/><!-- HANGUL SYLLABLE HYEO -->
+      <map code="0xd601" name="1em"/><!-- HANGUL SYLLABLE HYEOG -->
+      <map code="0xd602" name="1em"/><!-- HANGUL SYLLABLE HYEOGG -->
+      <map code="0xd603" name="1em"/><!-- HANGUL SYLLABLE HYEOGS -->
+      <map code="0xd604" name="1em"/><!-- HANGUL SYLLABLE HYEON -->
+      <map code="0xd605" name="1em"/><!-- HANGUL SYLLABLE HYEONJ -->
+      <map code="0xd606" name="1em"/><!-- HANGUL SYLLABLE HYEONH -->
+      <map code="0xd607" name="1em"/><!-- HANGUL SYLLABLE HYEOD -->
+      <map code="0xd608" name="1em"/><!-- HANGUL SYLLABLE HYEOL -->
+      <map code="0xd609" name="1em"/><!-- HANGUL SYLLABLE HYEOLG -->
+      <map code="0xd60a" name="1em"/><!-- HANGUL SYLLABLE HYEOLM -->
+      <map code="0xd60b" name="1em"/><!-- HANGUL SYLLABLE HYEOLB -->
+      <map code="0xd60c" name="1em"/><!-- HANGUL SYLLABLE HYEOLS -->
+      <map code="0xd60d" name="1em"/><!-- HANGUL SYLLABLE HYEOLT -->
+      <map code="0xd60e" name="1em"/><!-- HANGUL SYLLABLE HYEOLP -->
+      <map code="0xd60f" name="1em"/><!-- HANGUL SYLLABLE HYEOLH -->
+      <map code="0xd610" name="1em"/><!-- HANGUL SYLLABLE HYEOM -->
+      <map code="0xd611" name="1em"/><!-- HANGUL SYLLABLE HYEOB -->
+      <map code="0xd612" name="1em"/><!-- HANGUL SYLLABLE HYEOBS -->
+      <map code="0xd613" name="1em"/><!-- HANGUL SYLLABLE HYEOS -->
+      <map code="0xd614" name="1em"/><!-- HANGUL SYLLABLE HYEOSS -->
+      <map code="0xd615" name="1em"/><!-- HANGUL SYLLABLE HYEONG -->
+      <map code="0xd616" name="1em"/><!-- HANGUL SYLLABLE HYEOJ -->
+      <map code="0xd617" name="1em"/><!-- HANGUL SYLLABLE HYEOC -->
+      <map code="0xd618" name="1em"/><!-- HANGUL SYLLABLE HYEOK -->
+      <map code="0xd619" name="1em"/><!-- HANGUL SYLLABLE HYEOT -->
+      <map code="0xd61a" name="1em"/><!-- HANGUL SYLLABLE HYEOP -->
+      <map code="0xd61b" name="1em"/><!-- HANGUL SYLLABLE HYEOH -->
+      <map code="0xd61c" name="1em"/><!-- HANGUL SYLLABLE HYE -->
+      <map code="0xd61d" name="1em"/><!-- HANGUL SYLLABLE HYEG -->
+      <map code="0xd61e" name="1em"/><!-- HANGUL SYLLABLE HYEGG -->
+      <map code="0xd61f" name="1em"/><!-- HANGUL SYLLABLE HYEGS -->
+      <map code="0xd620" name="1em"/><!-- HANGUL SYLLABLE HYEN -->
+      <map code="0xd621" name="1em"/><!-- HANGUL SYLLABLE HYENJ -->
+      <map code="0xd622" name="1em"/><!-- HANGUL SYLLABLE HYENH -->
+      <map code="0xd623" name="1em"/><!-- HANGUL SYLLABLE HYED -->
+      <map code="0xd624" name="1em"/><!-- HANGUL SYLLABLE HYEL -->
+      <map code="0xd625" name="1em"/><!-- HANGUL SYLLABLE HYELG -->
+      <map code="0xd626" name="1em"/><!-- HANGUL SYLLABLE HYELM -->
+      <map code="0xd627" name="1em"/><!-- HANGUL SYLLABLE HYELB -->
+      <map code="0xd628" name="1em"/><!-- HANGUL SYLLABLE HYELS -->
+      <map code="0xd629" name="1em"/><!-- HANGUL SYLLABLE HYELT -->
+      <map code="0xd62a" name="1em"/><!-- HANGUL SYLLABLE HYELP -->
+      <map code="0xd62b" name="1em"/><!-- HANGUL SYLLABLE HYELH -->
+      <map code="0xd62c" name="1em"/><!-- HANGUL SYLLABLE HYEM -->
+      <map code="0xd62d" name="1em"/><!-- HANGUL SYLLABLE HYEB -->
+      <map code="0xd62e" name="1em"/><!-- HANGUL SYLLABLE HYEBS -->
+      <map code="0xd62f" name="1em"/><!-- HANGUL SYLLABLE HYES -->
+      <map code="0xd630" name="1em"/><!-- HANGUL SYLLABLE HYESS -->
+      <map code="0xd631" name="1em"/><!-- HANGUL SYLLABLE HYENG -->
+      <map code="0xd632" name="1em"/><!-- HANGUL SYLLABLE HYEJ -->
+      <map code="0xd633" name="1em"/><!-- HANGUL SYLLABLE HYEC -->
+      <map code="0xd634" name="1em"/><!-- HANGUL SYLLABLE HYEK -->
+      <map code="0xd635" name="1em"/><!-- HANGUL SYLLABLE HYET -->
+      <map code="0xd636" name="1em"/><!-- HANGUL SYLLABLE HYEP -->
+      <map code="0xd637" name="1em"/><!-- HANGUL SYLLABLE HYEH -->
+      <map code="0xd638" name="1em"/><!-- HANGUL SYLLABLE HO -->
+      <map code="0xd639" name="1em"/><!-- HANGUL SYLLABLE HOG -->
+      <map code="0xd63a" name="1em"/><!-- HANGUL SYLLABLE HOGG -->
+      <map code="0xd63b" name="1em"/><!-- HANGUL SYLLABLE HOGS -->
+      <map code="0xd63c" name="1em"/><!-- HANGUL SYLLABLE HON -->
+      <map code="0xd63d" name="1em"/><!-- HANGUL SYLLABLE HONJ -->
+      <map code="0xd63e" name="1em"/><!-- HANGUL SYLLABLE HONH -->
+      <map code="0xd63f" name="1em"/><!-- HANGUL SYLLABLE HOD -->
+      <map code="0xd640" name="1em"/><!-- HANGUL SYLLABLE HOL -->
+      <map code="0xd641" name="1em"/><!-- HANGUL SYLLABLE HOLG -->
+      <map code="0xd642" name="1em"/><!-- HANGUL SYLLABLE HOLM -->
+      <map code="0xd643" name="1em"/><!-- HANGUL SYLLABLE HOLB -->
+      <map code="0xd644" name="1em"/><!-- HANGUL SYLLABLE HOLS -->
+      <map code="0xd645" name="1em"/><!-- HANGUL SYLLABLE HOLT -->
+      <map code="0xd646" name="1em"/><!-- HANGUL SYLLABLE HOLP -->
+      <map code="0xd647" name="1em"/><!-- HANGUL SYLLABLE HOLH -->
+      <map code="0xd648" name="1em"/><!-- HANGUL SYLLABLE HOM -->
+      <map code="0xd649" name="1em"/><!-- HANGUL SYLLABLE HOB -->
+      <map code="0xd64a" name="1em"/><!-- HANGUL SYLLABLE HOBS -->
+      <map code="0xd64b" name="1em"/><!-- HANGUL SYLLABLE HOS -->
+      <map code="0xd64c" name="1em"/><!-- HANGUL SYLLABLE HOSS -->
+      <map code="0xd64d" name="1em"/><!-- HANGUL SYLLABLE HONG -->
+      <map code="0xd64e" name="1em"/><!-- HANGUL SYLLABLE HOJ -->
+      <map code="0xd64f" name="1em"/><!-- HANGUL SYLLABLE HOC -->
+      <map code="0xd650" name="1em"/><!-- HANGUL SYLLABLE HOK -->
+      <map code="0xd651" name="1em"/><!-- HANGUL SYLLABLE HOT -->
+      <map code="0xd652" name="1em"/><!-- HANGUL SYLLABLE HOP -->
+      <map code="0xd653" name="1em"/><!-- HANGUL SYLLABLE HOH -->
+      <map code="0xd654" name="1em"/><!-- HANGUL SYLLABLE HWA -->
+      <map code="0xd655" name="1em"/><!-- HANGUL SYLLABLE HWAG -->
+      <map code="0xd656" name="1em"/><!-- HANGUL SYLLABLE HWAGG -->
+      <map code="0xd657" name="1em"/><!-- HANGUL SYLLABLE HWAGS -->
+      <map code="0xd658" name="1em"/><!-- HANGUL SYLLABLE HWAN -->
+      <map code="0xd659" name="1em"/><!-- HANGUL SYLLABLE HWANJ -->
+      <map code="0xd65a" name="1em"/><!-- HANGUL SYLLABLE HWANH -->
+      <map code="0xd65b" name="1em"/><!-- HANGUL SYLLABLE HWAD -->
+      <map code="0xd65c" name="1em"/><!-- HANGUL SYLLABLE HWAL -->
+      <map code="0xd65d" name="1em"/><!-- HANGUL SYLLABLE HWALG -->
+      <map code="0xd65e" name="1em"/><!-- HANGUL SYLLABLE HWALM -->
+      <map code="0xd65f" name="1em"/><!-- HANGUL SYLLABLE HWALB -->
+      <map code="0xd660" name="1em"/><!-- HANGUL SYLLABLE HWALS -->
+      <map code="0xd661" name="1em"/><!-- HANGUL SYLLABLE HWALT -->
+      <map code="0xd662" name="1em"/><!-- HANGUL SYLLABLE HWALP -->
+      <map code="0xd663" name="1em"/><!-- HANGUL SYLLABLE HWALH -->
+      <map code="0xd664" name="1em"/><!-- HANGUL SYLLABLE HWAM -->
+      <map code="0xd665" name="1em"/><!-- HANGUL SYLLABLE HWAB -->
+      <map code="0xd666" name="1em"/><!-- HANGUL SYLLABLE HWABS -->
+      <map code="0xd667" name="1em"/><!-- HANGUL SYLLABLE HWAS -->
+      <map code="0xd668" name="1em"/><!-- HANGUL SYLLABLE HWASS -->
+      <map code="0xd669" name="1em"/><!-- HANGUL SYLLABLE HWANG -->
+      <map code="0xd66a" name="1em"/><!-- HANGUL SYLLABLE HWAJ -->
+      <map code="0xd66b" name="1em"/><!-- HANGUL SYLLABLE HWAC -->
+      <map code="0xd66c" name="1em"/><!-- HANGUL SYLLABLE HWAK -->
+      <map code="0xd66d" name="1em"/><!-- HANGUL SYLLABLE HWAT -->
+      <map code="0xd66e" name="1em"/><!-- HANGUL SYLLABLE HWAP -->
+      <map code="0xd66f" name="1em"/><!-- HANGUL SYLLABLE HWAH -->
+      <map code="0xd670" name="1em"/><!-- HANGUL SYLLABLE HWAE -->
+      <map code="0xd671" name="1em"/><!-- HANGUL SYLLABLE HWAEG -->
+      <map code="0xd672" name="1em"/><!-- HANGUL SYLLABLE HWAEGG -->
+      <map code="0xd673" name="1em"/><!-- HANGUL SYLLABLE HWAEGS -->
+      <map code="0xd674" name="1em"/><!-- HANGUL SYLLABLE HWAEN -->
+      <map code="0xd675" name="1em"/><!-- HANGUL SYLLABLE HWAENJ -->
+      <map code="0xd676" name="1em"/><!-- HANGUL SYLLABLE HWAENH -->
+      <map code="0xd677" name="1em"/><!-- HANGUL SYLLABLE HWAED -->
+      <map code="0xd678" name="1em"/><!-- HANGUL SYLLABLE HWAEL -->
+      <map code="0xd679" name="1em"/><!-- HANGUL SYLLABLE HWAELG -->
+      <map code="0xd67a" name="1em"/><!-- HANGUL SYLLABLE HWAELM -->
+      <map code="0xd67b" name="1em"/><!-- HANGUL SYLLABLE HWAELB -->
+      <map code="0xd67c" name="1em"/><!-- HANGUL SYLLABLE HWAELS -->
+      <map code="0xd67d" name="1em"/><!-- HANGUL SYLLABLE HWAELT -->
+      <map code="0xd67e" name="1em"/><!-- HANGUL SYLLABLE HWAELP -->
+      <map code="0xd67f" name="1em"/><!-- HANGUL SYLLABLE HWAELH -->
+      <map code="0xd680" name="1em"/><!-- HANGUL SYLLABLE HWAEM -->
+      <map code="0xd681" name="1em"/><!-- HANGUL SYLLABLE HWAEB -->
+      <map code="0xd682" name="1em"/><!-- HANGUL SYLLABLE HWAEBS -->
+      <map code="0xd683" name="1em"/><!-- HANGUL SYLLABLE HWAES -->
+      <map code="0xd684" name="1em"/><!-- HANGUL SYLLABLE HWAESS -->
+      <map code="0xd685" name="1em"/><!-- HANGUL SYLLABLE HWAENG -->
+      <map code="0xd686" name="1em"/><!-- HANGUL SYLLABLE HWAEJ -->
+      <map code="0xd687" name="1em"/><!-- HANGUL SYLLABLE HWAEC -->
+      <map code="0xd688" name="1em"/><!-- HANGUL SYLLABLE HWAEK -->
+      <map code="0xd689" name="1em"/><!-- HANGUL SYLLABLE HWAET -->
+      <map code="0xd68a" name="1em"/><!-- HANGUL SYLLABLE HWAEP -->
+      <map code="0xd68b" name="1em"/><!-- HANGUL SYLLABLE HWAEH -->
+      <map code="0xd68c" name="1em"/><!-- HANGUL SYLLABLE HOE -->
+      <map code="0xd68d" name="1em"/><!-- HANGUL SYLLABLE HOEG -->
+      <map code="0xd68e" name="1em"/><!-- HANGUL SYLLABLE HOEGG -->
+      <map code="0xd68f" name="1em"/><!-- HANGUL SYLLABLE HOEGS -->
+      <map code="0xd690" name="1em"/><!-- HANGUL SYLLABLE HOEN -->
+      <map code="0xd691" name="1em"/><!-- HANGUL SYLLABLE HOENJ -->
+      <map code="0xd692" name="1em"/><!-- HANGUL SYLLABLE HOENH -->
+      <map code="0xd693" name="1em"/><!-- HANGUL SYLLABLE HOED -->
+      <map code="0xd694" name="1em"/><!-- HANGUL SYLLABLE HOEL -->
+      <map code="0xd695" name="1em"/><!-- HANGUL SYLLABLE HOELG -->
+      <map code="0xd696" name="1em"/><!-- HANGUL SYLLABLE HOELM -->
+      <map code="0xd697" name="1em"/><!-- HANGUL SYLLABLE HOELB -->
+      <map code="0xd698" name="1em"/><!-- HANGUL SYLLABLE HOELS -->
+      <map code="0xd699" name="1em"/><!-- HANGUL SYLLABLE HOELT -->
+      <map code="0xd69a" name="1em"/><!-- HANGUL SYLLABLE HOELP -->
+      <map code="0xd69b" name="1em"/><!-- HANGUL SYLLABLE HOELH -->
+      <map code="0xd69c" name="1em"/><!-- HANGUL SYLLABLE HOEM -->
+      <map code="0xd69d" name="1em"/><!-- HANGUL SYLLABLE HOEB -->
+      <map code="0xd69e" name="1em"/><!-- HANGUL SYLLABLE HOEBS -->
+      <map code="0xd69f" name="1em"/><!-- HANGUL SYLLABLE HOES -->
+      <map code="0xd6a0" name="1em"/><!-- HANGUL SYLLABLE HOESS -->
+      <map code="0xd6a1" name="1em"/><!-- HANGUL SYLLABLE HOENG -->
+      <map code="0xd6a2" name="1em"/><!-- HANGUL SYLLABLE HOEJ -->
+      <map code="0xd6a3" name="1em"/><!-- HANGUL SYLLABLE HOEC -->
+      <map code="0xd6a4" name="1em"/><!-- HANGUL SYLLABLE HOEK -->
+      <map code="0xd6a5" name="1em"/><!-- HANGUL SYLLABLE HOET -->
+      <map code="0xd6a6" name="1em"/><!-- HANGUL SYLLABLE HOEP -->
+      <map code="0xd6a7" name="1em"/><!-- HANGUL SYLLABLE HOEH -->
+      <map code="0xd6a8" name="1em"/><!-- HANGUL SYLLABLE HYO -->
+      <map code="0xd6a9" name="1em"/><!-- HANGUL SYLLABLE HYOG -->
+      <map code="0xd6aa" name="1em"/><!-- HANGUL SYLLABLE HYOGG -->
+      <map code="0xd6ab" name="1em"/><!-- HANGUL SYLLABLE HYOGS -->
+      <map code="0xd6ac" name="1em"/><!-- HANGUL SYLLABLE HYON -->
+      <map code="0xd6ad" name="1em"/><!-- HANGUL SYLLABLE HYONJ -->
+      <map code="0xd6ae" name="1em"/><!-- HANGUL SYLLABLE HYONH -->
+      <map code="0xd6af" name="1em"/><!-- HANGUL SYLLABLE HYOD -->
+      <map code="0xd6b0" name="1em"/><!-- HANGUL SYLLABLE HYOL -->
+      <map code="0xd6b1" name="1em"/><!-- HANGUL SYLLABLE HYOLG -->
+      <map code="0xd6b2" name="1em"/><!-- HANGUL SYLLABLE HYOLM -->
+      <map code="0xd6b3" name="1em"/><!-- HANGUL SYLLABLE HYOLB -->
+      <map code="0xd6b4" name="1em"/><!-- HANGUL SYLLABLE HYOLS -->
+      <map code="0xd6b5" name="1em"/><!-- HANGUL SYLLABLE HYOLT -->
+      <map code="0xd6b6" name="1em"/><!-- HANGUL SYLLABLE HYOLP -->
+      <map code="0xd6b7" name="1em"/><!-- HANGUL SYLLABLE HYOLH -->
+      <map code="0xd6b8" name="1em"/><!-- HANGUL SYLLABLE HYOM -->
+      <map code="0xd6b9" name="1em"/><!-- HANGUL SYLLABLE HYOB -->
+      <map code="0xd6ba" name="1em"/><!-- HANGUL SYLLABLE HYOBS -->
+      <map code="0xd6bb" name="1em"/><!-- HANGUL SYLLABLE HYOS -->
+      <map code="0xd6bc" name="1em"/><!-- HANGUL SYLLABLE HYOSS -->
+      <map code="0xd6bd" name="1em"/><!-- HANGUL SYLLABLE HYONG -->
+      <map code="0xd6be" name="1em"/><!-- HANGUL SYLLABLE HYOJ -->
+      <map code="0xd6bf" name="1em"/><!-- HANGUL SYLLABLE HYOC -->
+      <map code="0xd6c0" name="1em"/><!-- HANGUL SYLLABLE HYOK -->
+      <map code="0xd6c1" name="1em"/><!-- HANGUL SYLLABLE HYOT -->
+      <map code="0xd6c2" name="1em"/><!-- HANGUL SYLLABLE HYOP -->
+      <map code="0xd6c3" name="1em"/><!-- HANGUL SYLLABLE HYOH -->
+      <map code="0xd6c4" name="1em"/><!-- HANGUL SYLLABLE HU -->
+      <map code="0xd6c5" name="1em"/><!-- HANGUL SYLLABLE HUG -->
+      <map code="0xd6c6" name="1em"/><!-- HANGUL SYLLABLE HUGG -->
+      <map code="0xd6c7" name="1em"/><!-- HANGUL SYLLABLE HUGS -->
+      <map code="0xd6c8" name="1em"/><!-- HANGUL SYLLABLE HUN -->
+      <map code="0xd6c9" name="1em"/><!-- HANGUL SYLLABLE HUNJ -->
+      <map code="0xd6ca" name="1em"/><!-- HANGUL SYLLABLE HUNH -->
+      <map code="0xd6cb" name="1em"/><!-- HANGUL SYLLABLE HUD -->
+      <map code="0xd6cc" name="1em"/><!-- HANGUL SYLLABLE HUL -->
+      <map code="0xd6cd" name="1em"/><!-- HANGUL SYLLABLE HULG -->
+      <map code="0xd6ce" name="1em"/><!-- HANGUL SYLLABLE HULM -->
+      <map code="0xd6cf" name="1em"/><!-- HANGUL SYLLABLE HULB -->
+      <map code="0xd6d0" name="1em"/><!-- HANGUL SYLLABLE HULS -->
+      <map code="0xd6d1" name="1em"/><!-- HANGUL SYLLABLE HULT -->
+      <map code="0xd6d2" name="1em"/><!-- HANGUL SYLLABLE HULP -->
+      <map code="0xd6d3" name="1em"/><!-- HANGUL SYLLABLE HULH -->
+      <map code="0xd6d4" name="1em"/><!-- HANGUL SYLLABLE HUM -->
+      <map code="0xd6d5" name="1em"/><!-- HANGUL SYLLABLE HUB -->
+      <map code="0xd6d6" name="1em"/><!-- HANGUL SYLLABLE HUBS -->
+      <map code="0xd6d7" name="1em"/><!-- HANGUL SYLLABLE HUS -->
+      <map code="0xd6d8" name="1em"/><!-- HANGUL SYLLABLE HUSS -->
+      <map code="0xd6d9" name="1em"/><!-- HANGUL SYLLABLE HUNG -->
+      <map code="0xd6da" name="1em"/><!-- HANGUL SYLLABLE HUJ -->
+      <map code="0xd6db" name="1em"/><!-- HANGUL SYLLABLE HUC -->
+      <map code="0xd6dc" name="1em"/><!-- HANGUL SYLLABLE HUK -->
+      <map code="0xd6dd" name="1em"/><!-- HANGUL SYLLABLE HUT -->
+      <map code="0xd6de" name="1em"/><!-- HANGUL SYLLABLE HUP -->
+      <map code="0xd6df" name="1em"/><!-- HANGUL SYLLABLE HUH -->
+      <map code="0xd6e0" name="1em"/><!-- HANGUL SYLLABLE HWEO -->
+      <map code="0xd6e1" name="1em"/><!-- HANGUL SYLLABLE HWEOG -->
+      <map code="0xd6e2" name="1em"/><!-- HANGUL SYLLABLE HWEOGG -->
+      <map code="0xd6e3" name="1em"/><!-- HANGUL SYLLABLE HWEOGS -->
+      <map code="0xd6e4" name="1em"/><!-- HANGUL SYLLABLE HWEON -->
+      <map code="0xd6e5" name="1em"/><!-- HANGUL SYLLABLE HWEONJ -->
+      <map code="0xd6e6" name="1em"/><!-- HANGUL SYLLABLE HWEONH -->
+      <map code="0xd6e7" name="1em"/><!-- HANGUL SYLLABLE HWEOD -->
+      <map code="0xd6e8" name="1em"/><!-- HANGUL SYLLABLE HWEOL -->
+      <map code="0xd6e9" name="1em"/><!-- HANGUL SYLLABLE HWEOLG -->
+      <map code="0xd6ea" name="1em"/><!-- HANGUL SYLLABLE HWEOLM -->
+      <map code="0xd6eb" name="1em"/><!-- HANGUL SYLLABLE HWEOLB -->
+      <map code="0xd6ec" name="1em"/><!-- HANGUL SYLLABLE HWEOLS -->
+      <map code="0xd6ed" name="1em"/><!-- HANGUL SYLLABLE HWEOLT -->
+      <map code="0xd6ee" name="1em"/><!-- HANGUL SYLLABLE HWEOLP -->
+      <map code="0xd6ef" name="1em"/><!-- HANGUL SYLLABLE HWEOLH -->
+      <map code="0xd6f0" name="1em"/><!-- HANGUL SYLLABLE HWEOM -->
+      <map code="0xd6f1" name="1em"/><!-- HANGUL SYLLABLE HWEOB -->
+      <map code="0xd6f2" name="1em"/><!-- HANGUL SYLLABLE HWEOBS -->
+      <map code="0xd6f3" name="1em"/><!-- HANGUL SYLLABLE HWEOS -->
+      <map code="0xd6f4" name="1em"/><!-- HANGUL SYLLABLE HWEOSS -->
+      <map code="0xd6f5" name="1em"/><!-- HANGUL SYLLABLE HWEONG -->
+      <map code="0xd6f6" name="1em"/><!-- HANGUL SYLLABLE HWEOJ -->
+      <map code="0xd6f7" name="1em"/><!-- HANGUL SYLLABLE HWEOC -->
+      <map code="0xd6f8" name="1em"/><!-- HANGUL SYLLABLE HWEOK -->
+      <map code="0xd6f9" name="1em"/><!-- HANGUL SYLLABLE HWEOT -->
+      <map code="0xd6fa" name="1em"/><!-- HANGUL SYLLABLE HWEOP -->
+      <map code="0xd6fb" name="1em"/><!-- HANGUL SYLLABLE HWEOH -->
+      <map code="0xd6fc" name="1em"/><!-- HANGUL SYLLABLE HWE -->
+      <map code="0xd6fd" name="1em"/><!-- HANGUL SYLLABLE HWEG -->
+      <map code="0xd6fe" name="1em"/><!-- HANGUL SYLLABLE HWEGG -->
+      <map code="0xd6ff" name="1em"/><!-- HANGUL SYLLABLE HWEGS -->
+      <map code="0xd700" name="1em"/><!-- HANGUL SYLLABLE HWEN -->
+      <map code="0xd701" name="1em"/><!-- HANGUL SYLLABLE HWENJ -->
+      <map code="0xd702" name="1em"/><!-- HANGUL SYLLABLE HWENH -->
+      <map code="0xd703" name="1em"/><!-- HANGUL SYLLABLE HWED -->
+      <map code="0xd704" name="1em"/><!-- HANGUL SYLLABLE HWEL -->
+      <map code="0xd705" name="1em"/><!-- HANGUL SYLLABLE HWELG -->
+      <map code="0xd706" name="1em"/><!-- HANGUL SYLLABLE HWELM -->
+      <map code="0xd707" name="1em"/><!-- HANGUL SYLLABLE HWELB -->
+      <map code="0xd708" name="1em"/><!-- HANGUL SYLLABLE HWELS -->
+      <map code="0xd709" name="1em"/><!-- HANGUL SYLLABLE HWELT -->
+      <map code="0xd70a" name="1em"/><!-- HANGUL SYLLABLE HWELP -->
+      <map code="0xd70b" name="1em"/><!-- HANGUL SYLLABLE HWELH -->
+      <map code="0xd70c" name="1em"/><!-- HANGUL SYLLABLE HWEM -->
+      <map code="0xd70d" name="1em"/><!-- HANGUL SYLLABLE HWEB -->
+      <map code="0xd70e" name="1em"/><!-- HANGUL SYLLABLE HWEBS -->
+      <map code="0xd70f" name="1em"/><!-- HANGUL SYLLABLE HWES -->
+      <map code="0xd710" name="1em"/><!-- HANGUL SYLLABLE HWESS -->
+      <map code="0xd711" name="1em"/><!-- HANGUL SYLLABLE HWENG -->
+      <map code="0xd712" name="1em"/><!-- HANGUL SYLLABLE HWEJ -->
+      <map code="0xd713" name="1em"/><!-- HANGUL SYLLABLE HWEC -->
+      <map code="0xd714" name="1em"/><!-- HANGUL SYLLABLE HWEK -->
+      <map code="0xd715" name="1em"/><!-- HANGUL SYLLABLE HWET -->
+      <map code="0xd716" name="1em"/><!-- HANGUL SYLLABLE HWEP -->
+      <map code="0xd717" name="1em"/><!-- HANGUL SYLLABLE HWEH -->
+      <map code="0xd718" name="1em"/><!-- HANGUL SYLLABLE HWI -->
+      <map code="0xd719" name="1em"/><!-- HANGUL SYLLABLE HWIG -->
+      <map code="0xd71a" name="1em"/><!-- HANGUL SYLLABLE HWIGG -->
+      <map code="0xd71b" name="1em"/><!-- HANGUL SYLLABLE HWIGS -->
+      <map code="0xd71c" name="1em"/><!-- HANGUL SYLLABLE HWIN -->
+      <map code="0xd71d" name="1em"/><!-- HANGUL SYLLABLE HWINJ -->
+      <map code="0xd71e" name="1em"/><!-- HANGUL SYLLABLE HWINH -->
+      <map code="0xd71f" name="1em"/><!-- HANGUL SYLLABLE HWID -->
+      <map code="0xd720" name="1em"/><!-- HANGUL SYLLABLE HWIL -->
+      <map code="0xd721" name="1em"/><!-- HANGUL SYLLABLE HWILG -->
+      <map code="0xd722" name="1em"/><!-- HANGUL SYLLABLE HWILM -->
+      <map code="0xd723" name="1em"/><!-- HANGUL SYLLABLE HWILB -->
+      <map code="0xd724" name="1em"/><!-- HANGUL SYLLABLE HWILS -->
+      <map code="0xd725" name="1em"/><!-- HANGUL SYLLABLE HWILT -->
+      <map code="0xd726" name="1em"/><!-- HANGUL SYLLABLE HWILP -->
+      <map code="0xd727" name="1em"/><!-- HANGUL SYLLABLE HWILH -->
+      <map code="0xd728" name="1em"/><!-- HANGUL SYLLABLE HWIM -->
+      <map code="0xd729" name="1em"/><!-- HANGUL SYLLABLE HWIB -->
+      <map code="0xd72a" name="1em"/><!-- HANGUL SYLLABLE HWIBS -->
+      <map code="0xd72b" name="1em"/><!-- HANGUL SYLLABLE HWIS -->
+      <map code="0xd72c" name="1em"/><!-- HANGUL SYLLABLE HWISS -->
+      <map code="0xd72d" name="1em"/><!-- HANGUL SYLLABLE HWING -->
+      <map code="0xd72e" name="1em"/><!-- HANGUL SYLLABLE HWIJ -->
+      <map code="0xd72f" name="1em"/><!-- HANGUL SYLLABLE HWIC -->
+      <map code="0xd730" name="1em"/><!-- HANGUL SYLLABLE HWIK -->
+      <map code="0xd731" name="1em"/><!-- HANGUL SYLLABLE HWIT -->
+      <map code="0xd732" name="1em"/><!-- HANGUL SYLLABLE HWIP -->
+      <map code="0xd733" name="1em"/><!-- HANGUL SYLLABLE HWIH -->
+      <map code="0xd734" name="1em"/><!-- HANGUL SYLLABLE HYU -->
+      <map code="0xd735" name="1em"/><!-- HANGUL SYLLABLE HYUG -->
+      <map code="0xd736" name="1em"/><!-- HANGUL SYLLABLE HYUGG -->
+      <map code="0xd737" name="1em"/><!-- HANGUL SYLLABLE HYUGS -->
+      <map code="0xd738" name="1em"/><!-- HANGUL SYLLABLE HYUN -->
+      <map code="0xd739" name="1em"/><!-- HANGUL SYLLABLE HYUNJ -->
+      <map code="0xd73a" name="1em"/><!-- HANGUL SYLLABLE HYUNH -->
+      <map code="0xd73b" name="1em"/><!-- HANGUL SYLLABLE HYUD -->
+      <map code="0xd73c" name="1em"/><!-- HANGUL SYLLABLE HYUL -->
+      <map code="0xd73d" name="1em"/><!-- HANGUL SYLLABLE HYULG -->
+      <map code="0xd73e" name="1em"/><!-- HANGUL SYLLABLE HYULM -->
+      <map code="0xd73f" name="1em"/><!-- HANGUL SYLLABLE HYULB -->
+      <map code="0xd740" name="1em"/><!-- HANGUL SYLLABLE HYULS -->
+      <map code="0xd741" name="1em"/><!-- HANGUL SYLLABLE HYULT -->
+      <map code="0xd742" name="1em"/><!-- HANGUL SYLLABLE HYULP -->
+      <map code="0xd743" name="1em"/><!-- HANGUL SYLLABLE HYULH -->
+      <map code="0xd744" name="1em"/><!-- HANGUL SYLLABLE HYUM -->
+      <map code="0xd745" name="1em"/><!-- HANGUL SYLLABLE HYUB -->
+      <map code="0xd746" name="1em"/><!-- HANGUL SYLLABLE HYUBS -->
+      <map code="0xd747" name="1em"/><!-- HANGUL SYLLABLE HYUS -->
+      <map code="0xd748" name="1em"/><!-- HANGUL SYLLABLE HYUSS -->
+      <map code="0xd749" name="1em"/><!-- HANGUL SYLLABLE HYUNG -->
+      <map code="0xd74a" name="1em"/><!-- HANGUL SYLLABLE HYUJ -->
+      <map code="0xd74b" name="1em"/><!-- HANGUL SYLLABLE HYUC -->
+      <map code="0xd74c" name="1em"/><!-- HANGUL SYLLABLE HYUK -->
+      <map code="0xd74d" name="1em"/><!-- HANGUL SYLLABLE HYUT -->
+      <map code="0xd74e" name="1em"/><!-- HANGUL SYLLABLE HYUP -->
+      <map code="0xd74f" name="1em"/><!-- HANGUL SYLLABLE HYUH -->
+      <map code="0xd750" name="1em"/><!-- HANGUL SYLLABLE HEU -->
+      <map code="0xd751" name="1em"/><!-- HANGUL SYLLABLE HEUG -->
+      <map code="0xd752" name="1em"/><!-- HANGUL SYLLABLE HEUGG -->
+      <map code="0xd753" name="1em"/><!-- HANGUL SYLLABLE HEUGS -->
+      <map code="0xd754" name="1em"/><!-- HANGUL SYLLABLE HEUN -->
+      <map code="0xd755" name="1em"/><!-- HANGUL SYLLABLE HEUNJ -->
+      <map code="0xd756" name="1em"/><!-- HANGUL SYLLABLE HEUNH -->
+      <map code="0xd757" name="1em"/><!-- HANGUL SYLLABLE HEUD -->
+      <map code="0xd758" name="1em"/><!-- HANGUL SYLLABLE HEUL -->
+      <map code="0xd759" name="1em"/><!-- HANGUL SYLLABLE HEULG -->
+      <map code="0xd75a" name="1em"/><!-- HANGUL SYLLABLE HEULM -->
+      <map code="0xd75b" name="1em"/><!-- HANGUL SYLLABLE HEULB -->
+      <map code="0xd75c" name="1em"/><!-- HANGUL SYLLABLE HEULS -->
+      <map code="0xd75d" name="1em"/><!-- HANGUL SYLLABLE HEULT -->
+      <map code="0xd75e" name="1em"/><!-- HANGUL SYLLABLE HEULP -->
+      <map code="0xd75f" name="1em"/><!-- HANGUL SYLLABLE HEULH -->
+      <map code="0xd760" name="1em"/><!-- HANGUL SYLLABLE HEUM -->
+      <map code="0xd761" name="1em"/><!-- HANGUL SYLLABLE HEUB -->
+      <map code="0xd762" name="1em"/><!-- HANGUL SYLLABLE HEUBS -->
+      <map code="0xd763" name="1em"/><!-- HANGUL SYLLABLE HEUS -->
+      <map code="0xd764" name="1em"/><!-- HANGUL SYLLABLE HEUSS -->
+      <map code="0xd765" name="1em"/><!-- HANGUL SYLLABLE HEUNG -->
+      <map code="0xd766" name="1em"/><!-- HANGUL SYLLABLE HEUJ -->
+      <map code="0xd767" name="1em"/><!-- HANGUL SYLLABLE HEUC -->
+      <map code="0xd768" name="1em"/><!-- HANGUL SYLLABLE HEUK -->
+      <map code="0xd769" name="1em"/><!-- HANGUL SYLLABLE HEUT -->
+      <map code="0xd76a" name="1em"/><!-- HANGUL SYLLABLE HEUP -->
+      <map code="0xd76b" name="1em"/><!-- HANGUL SYLLABLE HEUH -->
+      <map code="0xd76c" name="1em"/><!-- HANGUL SYLLABLE HYI -->
+      <map code="0xd76d" name="1em"/><!-- HANGUL SYLLABLE HYIG -->
+      <map code="0xd76e" name="1em"/><!-- HANGUL SYLLABLE HYIGG -->
+      <map code="0xd76f" name="1em"/><!-- HANGUL SYLLABLE HYIGS -->
+      <map code="0xd770" name="1em"/><!-- HANGUL SYLLABLE HYIN -->
+      <map code="0xd771" name="1em"/><!-- HANGUL SYLLABLE HYINJ -->
+      <map code="0xd772" name="1em"/><!-- HANGUL SYLLABLE HYINH -->
+      <map code="0xd773" name="1em"/><!-- HANGUL SYLLABLE HYID -->
+      <map code="0xd774" name="1em"/><!-- HANGUL SYLLABLE HYIL -->
+      <map code="0xd775" name="1em"/><!-- HANGUL SYLLABLE HYILG -->
+      <map code="0xd776" name="1em"/><!-- HANGUL SYLLABLE HYILM -->
+      <map code="0xd777" name="1em"/><!-- HANGUL SYLLABLE HYILB -->
+      <map code="0xd778" name="1em"/><!-- HANGUL SYLLABLE HYILS -->
+      <map code="0xd779" name="1em"/><!-- HANGUL SYLLABLE HYILT -->
+      <map code="0xd77a" name="1em"/><!-- HANGUL SYLLABLE HYILP -->
+      <map code="0xd77b" name="1em"/><!-- HANGUL SYLLABLE HYILH -->
+      <map code="0xd77c" name="1em"/><!-- HANGUL SYLLABLE HYIM -->
+      <map code="0xd77d" name="1em"/><!-- HANGUL SYLLABLE HYIB -->
+      <map code="0xd77e" name="1em"/><!-- HANGUL SYLLABLE HYIBS -->
+      <map code="0xd77f" name="1em"/><!-- HANGUL SYLLABLE HYIS -->
+      <map code="0xd780" name="1em"/><!-- HANGUL SYLLABLE HYISS -->
+      <map code="0xd781" name="1em"/><!-- HANGUL SYLLABLE HYING -->
+      <map code="0xd782" name="1em"/><!-- HANGUL SYLLABLE HYIJ -->
+      <map code="0xd783" name="1em"/><!-- HANGUL SYLLABLE HYIC -->
+      <map code="0xd784" name="1em"/><!-- HANGUL SYLLABLE HYIK -->
+      <map code="0xd785" name="1em"/><!-- HANGUL SYLLABLE HYIT -->
+      <map code="0xd786" name="1em"/><!-- HANGUL SYLLABLE HYIP -->
+      <map code="0xd787" name="1em"/><!-- HANGUL SYLLABLE HYIH -->
+      <map code="0xd788" name="1em"/><!-- HANGUL SYLLABLE HI -->
+      <map code="0xd789" name="1em"/><!-- HANGUL SYLLABLE HIG -->
+      <map code="0xd78a" name="1em"/><!-- HANGUL SYLLABLE HIGG -->
+      <map code="0xd78b" name="1em"/><!-- HANGUL SYLLABLE HIGS -->
+      <map code="0xd78c" name="1em"/><!-- HANGUL SYLLABLE HIN -->
+      <map code="0xd78d" name="1em"/><!-- HANGUL SYLLABLE HINJ -->
+      <map code="0xd78e" name="1em"/><!-- HANGUL SYLLABLE HINH -->
+      <map code="0xd78f" name="1em"/><!-- HANGUL SYLLABLE HID -->
+      <map code="0xd790" name="1em"/><!-- HANGUL SYLLABLE HIL -->
+      <map code="0xd791" name="1em"/><!-- HANGUL SYLLABLE HILG -->
+      <map code="0xd792" name="1em"/><!-- HANGUL SYLLABLE HILM -->
+      <map code="0xd793" name="1em"/><!-- HANGUL SYLLABLE HILB -->
+      <map code="0xd794" name="1em"/><!-- HANGUL SYLLABLE HILS -->
+      <map code="0xd795" name="1em"/><!-- HANGUL SYLLABLE HILT -->
+      <map code="0xd796" name="1em"/><!-- HANGUL SYLLABLE HILP -->
+      <map code="0xd797" name="1em"/><!-- HANGUL SYLLABLE HILH -->
+      <map code="0xd798" name="1em"/><!-- HANGUL SYLLABLE HIM -->
+      <map code="0xd799" name="1em"/><!-- HANGUL SYLLABLE HIB -->
+      <map code="0xd79a" name="1em"/><!-- HANGUL SYLLABLE HIBS -->
+      <map code="0xd79b" name="1em"/><!-- HANGUL SYLLABLE HIS -->
+      <map code="0xd79c" name="1em"/><!-- HANGUL SYLLABLE HISS -->
+      <map code="0xd79d" name="1em"/><!-- HANGUL SYLLABLE HING -->
+      <map code="0xd79e" name="1em"/><!-- HANGUL SYLLABLE HIJ -->
+      <map code="0xd79f" name="1em"/><!-- HANGUL SYLLABLE HIC -->
+      <map code="0xd7a0" name="1em"/><!-- HANGUL SYLLABLE HIK -->
+      <map code="0xd7a1" name="1em"/><!-- HANGUL SYLLABLE HIT -->
+      <map code="0xd7a2" name="1em"/><!-- HANGUL SYLLABLE HIP -->
+      <map code="0xd7a3" name="1em"/><!-- HANGUL SYLLABLE HIH -->
+      <map code="0xd7b0" name="1em"/><!-- HANGUL JUNGSEONG O-YEO -->
+      <map code="0xd7b1" name="1em"/><!-- HANGUL JUNGSEONG O-O-I -->
+      <map code="0xd7b2" name="1em"/><!-- HANGUL JUNGSEONG YO-A -->
+      <map code="0xd7b3" name="1em"/><!-- HANGUL JUNGSEONG YO-AE -->
+      <map code="0xd7b4" name="1em"/><!-- HANGUL JUNGSEONG YO-EO -->
+      <map code="0xd7b5" name="1em"/><!-- HANGUL JUNGSEONG U-YEO -->
+      <map code="0xd7b6" name="1em"/><!-- HANGUL JUNGSEONG U-I-I -->
+      <map code="0xd7b7" name="1em"/><!-- HANGUL JUNGSEONG YU-AE -->
+      <map code="0xd7b8" name="1em"/><!-- HANGUL JUNGSEONG YU-O -->
+      <map code="0xd7b9" name="1em"/><!-- HANGUL JUNGSEONG EU-A -->
+      <map code="0xd7ba" name="1em"/><!-- HANGUL JUNGSEONG EU-EO -->
+      <map code="0xd7bb" name="1em"/><!-- HANGUL JUNGSEONG EU-E -->
+      <map code="0xd7bc" name="1em"/><!-- HANGUL JUNGSEONG EU-O -->
+      <map code="0xd7bd" name="1em"/><!-- HANGUL JUNGSEONG I-YA-O -->
+      <map code="0xd7be" name="1em"/><!-- HANGUL JUNGSEONG I-YAE -->
+      <map code="0xd7bf" name="1em"/><!-- HANGUL JUNGSEONG I-YEO -->
+      <map code="0xd7c0" name="1em"/><!-- HANGUL JUNGSEONG I-YE -->
+      <map code="0xd7c1" name="1em"/><!-- HANGUL JUNGSEONG I-O-I -->
+      <map code="0xd7c2" name="1em"/><!-- HANGUL JUNGSEONG I-YO -->
+      <map code="0xd7c3" name="1em"/><!-- HANGUL JUNGSEONG I-YU -->
+      <map code="0xd7c4" name="1em"/><!-- HANGUL JUNGSEONG I-I -->
+      <map code="0xd7c5" name="1em"/><!-- HANGUL JUNGSEONG ARAEA-A -->
+      <map code="0xd7c6" name="1em"/><!-- HANGUL JUNGSEONG ARAEA-E -->
+      <map code="0xd7cb" name="1em"/><!-- HANGUL JONGSEONG NIEUN-RIEUL -->
+      <map code="0xd7cc" name="1em"/><!-- HANGUL JONGSEONG NIEUN-CHIEUCH -->
+      <map code="0xd7cd" name="1em"/><!-- HANGUL JONGSEONG SSANGTIKEUT -->
+      <map code="0xd7ce" name="1em"/><!-- HANGUL JONGSEONG SSANGTIKEUT-PIEUP -->
+      <map code="0xd7cf" name="1em"/><!-- HANGUL JONGSEONG TIKEUT-PIEUP -->
+      <map code="0xd7d0" name="1em"/><!-- HANGUL JONGSEONG TIKEUT-SIOS -->
+      <map code="0xd7d1" name="1em"/><!-- HANGUL JONGSEONG TIKEUT-SIOS-KIYEOK -->
+      <map code="0xd7d2" name="1em"/><!-- HANGUL JONGSEONG TIKEUT-CIEUC -->
+      <map code="0xd7d3" name="1em"/><!-- HANGUL JONGSEONG TIKEUT-CHIEUCH -->
+      <map code="0xd7d4" name="1em"/><!-- HANGUL JONGSEONG TIKEUT-THIEUTH -->
+      <map code="0xd7d5" name="1em"/><!-- HANGUL JONGSEONG RIEUL-SSANGKIYEOK -->
+      <map code="0xd7d6" name="1em"/><!-- HANGUL JONGSEONG RIEUL-KIYEOK-HIEUH -->
+      <map code="0xd7d7" name="1em"/><!-- HANGUL JONGSEONG SSANGRIEUL-KHIEUKH -->
+      <map code="0xd7d8" name="1em"/><!-- HANGUL JONGSEONG RIEUL-MIEUM-HIEUH -->
+      <map code="0xd7d9" name="1em"/><!-- HANGUL JONGSEONG RIEUL-PIEUP-TIKEUT -->
+      <map code="0xd7da" name="1em"/><!-- HANGUL JONGSEONG RIEUL-PIEUP-PHIEUPH -->
+      <map code="0xd7db" name="1em"/><!-- HANGUL JONGSEONG RIEUL-YESIEUNG -->
+      <map code="0xd7dc" name="1em"/><!-- HANGUL JONGSEONG RIEUL-YEORINHIEUH-HIEUH -->
+      <map code="0xd7dd" name="1em"/><!-- HANGUL JONGSEONG KAPYEOUNRIEUL -->
+      <map code="0xd7de" name="1em"/><!-- HANGUL JONGSEONG MIEUM-NIEUN -->
+      <map code="0xd7df" name="1em"/><!-- HANGUL JONGSEONG MIEUM-SSANGNIEUN -->
+      <map code="0xd7e0" name="1em"/><!-- HANGUL JONGSEONG SSANGMIEUM -->
+      <map code="0xd7e1" name="1em"/><!-- HANGUL JONGSEONG MIEUM-PIEUP-SIOS -->
+      <map code="0xd7e2" name="1em"/><!-- HANGUL JONGSEONG MIEUM-CIEUC -->
+      <map code="0xd7e3" name="1em"/><!-- HANGUL JONGSEONG PIEUP-TIKEUT -->
+      <map code="0xd7e4" name="1em"/><!-- HANGUL JONGSEONG PIEUP-RIEUL-PHIEUPH -->
+      <map code="0xd7e5" name="1em"/><!-- HANGUL JONGSEONG PIEUP-MIEUM -->
+      <map code="0xd7e6" name="1em"/><!-- HANGUL JONGSEONG SSANGPIEUP -->
+      <map code="0xd7e7" name="1em"/><!-- HANGUL JONGSEONG PIEUP-SIOS-TIKEUT -->
+      <map code="0xd7e8" name="1em"/><!-- HANGUL JONGSEONG PIEUP-CIEUC -->
+      <map code="0xd7e9" name="1em"/><!-- HANGUL JONGSEONG PIEUP-CHIEUCH -->
+      <map code="0xd7ea" name="1em"/><!-- HANGUL JONGSEONG SIOS-MIEUM -->
+      <map code="0xd7eb" name="1em"/><!-- HANGUL JONGSEONG SIOS-KAPYEOUNPIEUP -->
+      <map code="0xd7ec" name="1em"/><!-- HANGUL JONGSEONG SSANGSIOS-KIYEOK -->
+      <map code="0xd7ed" name="1em"/><!-- HANGUL JONGSEONG SSANGSIOS-TIKEUT -->
+      <map code="0xd7ee" name="1em"/><!-- HANGUL JONGSEONG SIOS-PANSIOS -->
+      <map code="0xd7ef" name="1em"/><!-- HANGUL JONGSEONG SIOS-CIEUC -->
+      <map code="0xd7f0" name="1em"/><!-- HANGUL JONGSEONG SIOS-CHIEUCH -->
+      <map code="0xd7f1" name="1em"/><!-- HANGUL JONGSEONG SIOS-THIEUTH -->
+      <map code="0xd7f2" name="1em"/><!-- HANGUL JONGSEONG SIOS-HIEUH -->
+      <map code="0xd7f3" name="1em"/><!-- HANGUL JONGSEONG PANSIOS-PIEUP -->
+      <map code="0xd7f4" name="1em"/><!-- HANGUL JONGSEONG PANSIOS-KAPYEOUNPIEUP -->
+      <map code="0xd7f5" name="1em"/><!-- HANGUL JONGSEONG YESIEUNG-MIEUM -->
+      <map code="0xd7f6" name="1em"/><!-- HANGUL JONGSEONG YESIEUNG-HIEUH -->
+      <map code="0xd7f7" name="1em"/><!-- HANGUL JONGSEONG CIEUC-PIEUP -->
+      <map code="0xd7f8" name="1em"/><!-- HANGUL JONGSEONG CIEUC-SSANGPIEUP -->
+      <map code="0xd7f9" name="1em"/><!-- HANGUL JONGSEONG SSANGCIEUC -->
+      <map code="0xd7fa" name="1em"/><!-- HANGUL JONGSEONG PHIEUPH-SIOS -->
+      <map code="0xd7fb" name="1em"/><!-- HANGUL JONGSEONG PHIEUPH-THIEUTH -->
+
+    </cmap_format_12>
+  </cmap>
+
+  <loca>
+    <!-- The 'loca' table will be calculated by the compiler -->
+  </loca>
+
+  <glyf>
+    <TTGlyph name=".notdef" xMin="0" yMin="0" xMax="0" yMax="0" />
+    <TTGlyph name="1em" xMin="0" yMin="0" xMax="100" yMax="100">
+        <contour>
+            <pt x="0" y="0" on="1" />
+            <pt x="100" y="0" on="1" />
+            <pt x="100" y="100" on="1" />
+            <pt x="0" y="100" on="1" />
+        </contour>
+        <instructions><assembly></assembly></instructions>
+    </TTGlyph>
+  </glyf>
+
+  <name>
+    <namerecord nameID="1" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Font for Hiragana
+    </namerecord>
+    <namerecord nameID="2" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Regular
+    </namerecord>
+    <namerecord nameID="4" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Font for Hiragana
+    </namerecord>
+    <namerecord nameID="6" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      SampleFont-Regular
+    </namerecord>
+    <namerecord nameID="1" platformID="3" platEncID="1" langID="0x409">
+      Sample Font
+    </namerecord>
+    <namerecord nameID="2" platformID="3" platEncID="1" langID="0x409">
+      Regular
+    </namerecord>
+    <namerecord nameID="4" platformID="3" platEncID="1" langID="0x409">
+      Sample Font
+    </namerecord>
+    <namerecord nameID="6" platformID="3" platEncID="1" langID="0x409">
+      SampleFont-Regular
+    </namerecord>
+  </name>
+
+  <post>
+    <formatType value="3.0"/>
+    <italicAngle value="0.0"/>
+    <underlinePosition value="-75"/>
+    <underlineThickness value="50"/>
+    <isFixedPitch value="0"/>
+    <minMemType42 value="0"/>
+    <maxMemType42 value="0"/>
+    <minMemType1 value="0"/>
+    <maxMemType1 value="0"/>
+  </post>
+
+</ttFont>
diff --git a/tests/data/Japanese.ttf b/tests/data/Japanese.ttf
new file mode 100644
index 0000000..5fb9de0
--- /dev/null
+++ b/tests/data/Japanese.ttf
diff --git a/tests/data/Japanese.ttx b/tests/data/Japanese.ttx
new file mode 100644
index 0000000..c7c5416
--- /dev/null
+++ b/tests/data/Japanese.ttx
@@ -0,0 +1,388 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2023 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.0">
+
+  <GlyphOrder>
+    <GlyphID id="0" name=".notdef"/>
+    <GlyphID id="1" name="1em"/>
+  </GlyphOrder>
+
+  <head>
+    <tableVersion value="1.0"/>
+    <fontRevision value="1.0"/>
+    <checkSumAdjustment value="0x640cdb2f"/>
+    <magicNumber value="0x5f0f3cf5"/>
+    <flags value="00000000 00000011"/>
+    <unitsPerEm value="100"/>
+    <created value="Fri Mar 17 07:26:00 2017"/>
+    <macStyle value="00000000 00000000"/>
+    <lowestRecPPEM value="7"/>
+    <fontDirectionHint value="2"/>
+    <glyphDataFormat value="0"/>
+  </head>
+
+  <hhea>
+    <tableVersion value="0x00010000"/>
+    <ascent value="0"/>
+    <descent value="0"/>
+    <lineGap value="0"/>
+    <caretSlopeRise value="1"/>
+    <caretSlopeRun value="0"/>
+    <caretOffset value="0"/>
+    <reserved0 value="0"/>
+    <reserved1 value="0"/>
+    <reserved2 value="0"/>
+    <reserved3 value="0"/>
+    <metricDataFormat value="0"/>
+  </hhea>
+
+  <maxp>
+    <tableVersion value="0x10000"/>
+    <maxZones value="0"/>
+    <maxTwilightPoints value="0"/>
+    <maxStorage value="0"/>
+    <maxFunctionDefs value="0"/>
+    <maxInstructionDefs value="0"/>
+    <maxStackElements value="0"/>
+    <maxSizeOfInstructions value="0"/>
+    <maxComponentElements value="0"/>
+  </maxp>
+
+  <OS_2>
+    <!-- The fields 'usFirstCharIndex' and 'usLastCharIndex'
+         will be recalculated by the compiler -->
+    <version value="3"/>
+    <xAvgCharWidth value="594"/>
+    <usWeightClass value="400"/>
+    <usWidthClass value="5"/>
+    <fsType value="00000000 00001000"/>
+    <ySubscriptXSize value="650"/>
+    <ySubscriptYSize value="600"/>
+    <ySubscriptXOffset value="0"/>
+    <ySubscriptYOffset value="75"/>
+    <ySuperscriptXSize value="650"/>
+    <ySuperscriptYSize value="600"/>
+    <ySuperscriptXOffset value="0"/>
+    <ySuperscriptYOffset value="350"/>
+    <yStrikeoutSize value="50"/>
+    <yStrikeoutPosition value="300"/>
+    <sFamilyClass value="0"/>
+    <panose>
+      <bFamilyType value="0"/>
+      <bSerifStyle value="0"/>
+      <bWeight value="5"/>
+      <bProportion value="0"/>
+      <bContrast value="0"/>
+      <bStrokeVariation value="0"/>
+      <bArmStyle value="0"/>
+      <bLetterForm value="0"/>
+      <bMidline value="0"/>
+      <bXHeight value="0"/>
+    </panose>
+    <ulUnicodeRange1 value="00000000 00000000 00000000 00000001"/>
+    <ulUnicodeRange2 value="00000000 00000000 00000000 00000000"/>
+    <ulUnicodeRange3 value="00000000 00000000 00000000 00000000"/>
+    <ulUnicodeRange4 value="00000000 00000000 00000000 00000000"/>
+    <achVendID value="UKWN"/>
+    <fsSelection value="00000000 01000000"/>
+    <usFirstCharIndex value="32"/>
+    <usLastCharIndex value="122"/>
+    <sTypoAscender value="800"/>
+    <sTypoDescender value="-200"/>
+    <sTypoLineGap value="200"/>
+    <usWinAscent value="1000"/>
+    <usWinDescent value="200"/>
+    <ulCodePageRange1 value="00000000 00000000 00000000 00000001"/>
+    <ulCodePageRange2 value="00000000 00000000 00000000 00000000"/>
+    <sxHeight value="500"/>
+    <sCapHeight value="700"/>
+    <usDefaultChar value="0"/>
+    <usBreakChar value="32"/>
+    <usMaxContext value="0"/>
+  </OS_2>
+
+  <hmtx>
+    <mtx name=".notdef" width="50" lsb="0"/>
+    <mtx name="1em" width="100" lsb="0"/>
+  </hmtx>
+
+  <cmap>
+    <tableVersion version="0"/>
+    <cmap_format_12 format="12" reserved="0" length="6" nGroups="1" platformID="3" platEncID="10" language="0">
+      <!-- CJK Symbols -->
+      <map code="0x3000" name="1em" /> <!--  IDEOGRAPHIC SPACE -->
+      <map code="0x3001" name="1em" /> <!--  IDEOGRAPHIC COMMA -->
+      <map code="0x3002" name="1em" /> <!--  IDEOGRAPHIC FULL STOP -->
+
+      <!-- All Hiragana Ltters -->
+      <map code="0x3041" name="1em" /> <!--  HIRAGANA LETTER SMALL A -->
+      <map code="0x3042" name="1em" /> <!--  HIRAGANA LETTER A -->
+      <map code="0x3043" name="1em" /> <!--  HIRAGANA LETTER SMALL I -->
+      <map code="0x3044" name="1em" /> <!--  HIRAGANA LETTER I -->
+      <map code="0x3045" name="1em" /> <!--  HIRAGANA LETTER SMALL U -->
+      <map code="0x3046" name="1em" /> <!--  HIRAGANA LETTER U -->
+      <map code="0x3047" name="1em" /> <!--  HIRAGANA LETTER SMALL E -->
+      <map code="0x3048" name="1em" /> <!--  HIRAGANA LETTER E -->
+      <map code="0x3049" name="1em" /> <!--  HIRAGANA LETTER SMALL O -->
+      <map code="0x304A" name="1em" /> <!--  HIRAGANA LETTER O -->
+      <map code="0x304B" name="1em" /> <!--  HIRAGANA LETTER KA -->
+      <map code="0x304C" name="1em" /> <!--  HIRAGANA LETTER GA -->
+      <map code="0x304D" name="1em" /> <!--  HIRAGANA LETTER KI -->
+      <map code="0x304E" name="1em" /> <!--  HIRAGANA LETTER GI -->
+      <map code="0x304F" name="1em" /> <!--  HIRAGANA LETTER KU -->
+      <map code="0x3050" name="1em" /> <!--  HIRAGANA LETTER GU -->
+      <map code="0x3051" name="1em" /> <!--  HIRAGANA LETTER KE -->
+      <map code="0x3052" name="1em" /> <!--  HIRAGANA LETTER GE -->
+      <map code="0x3053" name="1em" /> <!--  HIRAGANA LETTER KO -->
+      <map code="0x3054" name="1em" /> <!--  HIRAGANA LETTER GO -->
+      <map code="0x3055" name="1em" /> <!--  HIRAGANA LETTER SA -->
+      <map code="0x3056" name="1em" /> <!--  HIRAGANA LETTER ZA -->
+      <map code="0x3057" name="1em" /> <!--  HIRAGANA LETTER SI -->
+      <map code="0x3058" name="1em" /> <!--  HIRAGANA LETTER ZI -->
+      <map code="0x3059" name="1em" /> <!--  HIRAGANA LETTER SU -->
+      <map code="0x305A" name="1em" /> <!--  HIRAGANA LETTER ZU -->
+      <map code="0x305B" name="1em" /> <!--  HIRAGANA LETTER SE -->
+      <map code="0x305C" name="1em" /> <!--  HIRAGANA LETTER ZE -->
+      <map code="0x305D" name="1em" /> <!--  HIRAGANA LETTER SO -->
+      <map code="0x305E" name="1em" /> <!--  HIRAGANA LETTER ZO -->
+      <map code="0x305F" name="1em" /> <!--  HIRAGANA LETTER TA -->
+      <map code="0x3060" name="1em" /> <!--  HIRAGANA LETTER DA -->
+      <map code="0x3061" name="1em" /> <!--  HIRAGANA LETTER TI -->
+      <map code="0x3062" name="1em" /> <!--  HIRAGANA LETTER DI -->
+      <map code="0x3063" name="1em" /> <!--  HIRAGANA LETTER SMALL TU -->
+      <map code="0x3064" name="1em" /> <!--  HIRAGANA LETTER TU -->
+      <map code="0x3065" name="1em" /> <!--  HIRAGANA LETTER DU -->
+      <map code="0x3066" name="1em" /> <!--  HIRAGANA LETTER TE -->
+      <map code="0x3067" name="1em" /> <!--  HIRAGANA LETTER DE -->
+      <map code="0x3068" name="1em" /> <!--  HIRAGANA LETTER TO -->
+      <map code="0x3069" name="1em" /> <!--  HIRAGANA LETTER DO -->
+      <map code="0x306A" name="1em" /> <!--  HIRAGANA LETTER NA -->
+      <map code="0x306B" name="1em" /> <!--  HIRAGANA LETTER NI -->
+      <map code="0x306C" name="1em" /> <!--  HIRAGANA LETTER NU -->
+      <map code="0x306D" name="1em" /> <!--  HIRAGANA LETTER NE -->
+      <map code="0x306E" name="1em" /> <!--  HIRAGANA LETTER NO -->
+      <map code="0x306F" name="1em" /> <!--  HIRAGANA LETTER HA -->
+      <map code="0x3070" name="1em" /> <!--  HIRAGANA LETTER BA -->
+      <map code="0x3071" name="1em" /> <!--  HIRAGANA LETTER PA -->
+      <map code="0x3072" name="1em" /> <!--  HIRAGANA LETTER HI -->
+      <map code="0x3073" name="1em" /> <!--  HIRAGANA LETTER BI -->
+      <map code="0x3074" name="1em" /> <!--  HIRAGANA LETTER PI -->
+      <map code="0x3075" name="1em" /> <!--  HIRAGANA LETTER HU -->
+      <map code="0x3076" name="1em" /> <!--  HIRAGANA LETTER BU -->
+      <map code="0x3077" name="1em" /> <!--  HIRAGANA LETTER PU -->
+      <map code="0x3078" name="1em" /> <!--  HIRAGANA LETTER HE -->
+      <map code="0x3079" name="1em" /> <!--  HIRAGANA LETTER BE -->
+      <map code="0x307A" name="1em" /> <!--  HIRAGANA LETTER PE -->
+      <map code="0x307B" name="1em" /> <!--  HIRAGANA LETTER HO -->
+      <map code="0x307C" name="1em" /> <!--  HIRAGANA LETTER BO -->
+      <map code="0x307D" name="1em" /> <!--  HIRAGANA LETTER PO -->
+      <map code="0x307E" name="1em" /> <!--  HIRAGANA LETTER MA -->
+      <map code="0x307F" name="1em" /> <!--  HIRAGANA LETTER MI -->
+      <map code="0x3080" name="1em" /> <!--  HIRAGANA LETTER MU -->
+      <map code="0x3081" name="1em" /> <!--  HIRAGANA LETTER ME -->
+      <map code="0x3082" name="1em" /> <!--  HIRAGANA LETTER MO -->
+      <map code="0x3083" name="1em" /> <!--  HIRAGANA LETTER SMALL YA -->
+      <map code="0x3084" name="1em" /> <!--  HIRAGANA LETTER YA -->
+      <map code="0x3085" name="1em" /> <!--  HIRAGANA LETTER SMALL YU -->
+      <map code="0x3086" name="1em" /> <!--  HIRAGANA LETTER YU -->
+      <map code="0x3087" name="1em" /> <!--  HIRAGANA LETTER SMALL YO -->
+      <map code="0x3088" name="1em" /> <!--  HIRAGANA LETTER YO -->
+      <map code="0x3089" name="1em" /> <!--  HIRAGANA LETTER RA -->
+      <map code="0x308A" name="1em" /> <!--  HIRAGANA LETTER RI -->
+      <map code="0x308B" name="1em" /> <!--  HIRAGANA LETTER RU -->
+      <map code="0x308C" name="1em" /> <!--  HIRAGANA LETTER RE -->
+      <map code="0x308D" name="1em" /> <!--  HIRAGANA LETTER RO -->
+      <map code="0x308E" name="1em" /> <!--  HIRAGANA LETTER SMALL WA -->
+      <map code="0x308F" name="1em" /> <!--  HIRAGANA LETTER WA -->
+      <map code="0x3090" name="1em" /> <!--  HIRAGANA LETTER WI -->
+      <map code="0x3091" name="1em" /> <!--  HIRAGANA LETTER WE -->
+      <map code="0x3092" name="1em" /> <!--  HIRAGANA LETTER WO -->
+      <map code="0x3093" name="1em" /> <!--  HIRAGANA LETTER N -->
+      <map code="0x3094" name="1em" /> <!--  HIRAGANA LETTER VU -->
+      <map code="0x3095" name="1em" /> <!--  HIRAGANA LETTER SMALL KA -->
+      <map code="0x3096" name="1em" /> <!--  HIRAGANA LETTER SMALL KE -->
+      <map code="0x3099" name="1em" /> <!--  COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK -->
+      <map code="0x309A" name="1em" /> <!--  COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK -->
+      <map code="0x309B" name="1em" /> <!--  KATAKANA-HIRAGANA VOICED SOUND MARK -->
+      <map code="0x309C" name="1em" /> <!--  KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK -->
+      <map code="0x309D" name="1em" /> <!--  HIRAGANA ITERATION MARK -->
+      <map code="0x309E" name="1em" /> <!--  HIRAGANA VOICED ITERATION MARK -->
+      <map code="0x309F" name="1em" /> <!--  HIRAGANA DIGRAPH YORI -->
+
+      <!-- All Hiragana Ltters -->
+      <map code="0x30A0" name="1em" /> <!--  KATAKANA-HIRAGANA DOUBLE HYPHEN -->
+      <map code="0x30A1" name="1em" /> <!--  KATAKANA LETTER SMALL A -->
+      <map code="0x30A2" name="1em" /> <!--  KATAKANA LETTER A -->
+      <map code="0x30A3" name="1em" /> <!--  KATAKANA LETTER SMALL I -->
+      <map code="0x30A4" name="1em" /> <!--  KATAKANA LETTER I -->
+      <map code="0x30A5" name="1em" /> <!--  KATAKANA LETTER SMALL U -->
+      <map code="0x30A6" name="1em" /> <!--  KATAKANA LETTER U -->
+      <map code="0x30A7" name="1em" /> <!--  KATAKANA LETTER SMALL E -->
+      <map code="0x30A8" name="1em" /> <!--  KATAKANA LETTER E -->
+      <map code="0x30A9" name="1em" /> <!--  KATAKANA LETTER SMALL O -->
+      <map code="0x30AA" name="1em" /> <!--  KATAKANA LETTER O -->
+      <map code="0x30AB" name="1em" /> <!--  KATAKANA LETTER KA -->
+      <map code="0x30AC" name="1em" /> <!--  KATAKANA LETTER GA -->
+      <map code="0x30AD" name="1em" /> <!--  KATAKANA LETTER KI -->
+      <map code="0x30AE" name="1em" /> <!--  KATAKANA LETTER GI -->
+      <map code="0x30AF" name="1em" /> <!--  KATAKANA LETTER KU -->
+      <map code="0x30B0" name="1em" /> <!--  KATAKANA LETTER GU -->
+      <map code="0x30B1" name="1em" /> <!--  KATAKANA LETTER KE -->
+      <map code="0x30B2" name="1em" /> <!--  KATAKANA LETTER GE -->
+      <map code="0x30B3" name="1em" /> <!--  KATAKANA LETTER KO -->
+      <map code="0x30B4" name="1em" /> <!--  KATAKANA LETTER GO -->
+      <map code="0x30B5" name="1em" /> <!--  KATAKANA LETTER SA -->
+      <map code="0x30B6" name="1em" /> <!--  KATAKANA LETTER ZA -->
+      <map code="0x30B7" name="1em" /> <!--  KATAKANA LETTER SI -->
+      <map code="0x30B8" name="1em" /> <!--  KATAKANA LETTER ZI -->
+      <map code="0x30B9" name="1em" /> <!--  KATAKANA LETTER SU -->
+      <map code="0x30BA" name="1em" /> <!--  KATAKANA LETTER ZU -->
+      <map code="0x30BB" name="1em" /> <!--  KATAKANA LETTER SE -->
+      <map code="0x30BC" name="1em" /> <!--  KATAKANA LETTER ZE -->
+      <map code="0x30BD" name="1em" /> <!--  KATAKANA LETTER SO -->
+      <map code="0x30BE" name="1em" /> <!--  KATAKANA LETTER ZO -->
+      <map code="0x30BF" name="1em" /> <!--  KATAKANA LETTER TA -->
+      <map code="0x30C0" name="1em" /> <!--  KATAKANA LETTER DA -->
+      <map code="0x30C1" name="1em" /> <!--  KATAKANA LETTER TI -->
+      <map code="0x30C2" name="1em" /> <!--  KATAKANA LETTER DI -->
+      <map code="0x30C3" name="1em" /> <!--  KATAKANA LETTER SMALL TU -->
+      <map code="0x30C4" name="1em" /> <!--  KATAKANA LETTER TU -->
+      <map code="0x30C5" name="1em" /> <!--  KATAKANA LETTER DU -->
+      <map code="0x30C6" name="1em" /> <!--  KATAKANA LETTER TE -->
+      <map code="0x30C7" name="1em" /> <!--  KATAKANA LETTER DE -->
+      <map code="0x30C8" name="1em" /> <!--  KATAKANA LETTER TO -->
+      <map code="0x30C9" name="1em" /> <!--  KATAKANA LETTER DO -->
+      <map code="0x30CA" name="1em" /> <!--  KATAKANA LETTER NA -->
+      <map code="0x30CB" name="1em" /> <!--  KATAKANA LETTER NI -->
+      <map code="0x30CC" name="1em" /> <!--  KATAKANA LETTER NU -->
+      <map code="0x30CD" name="1em" /> <!--  KATAKANA LETTER NE -->
+      <map code="0x30CE" name="1em" /> <!--  KATAKANA LETTER NO -->
+      <map code="0x30CF" name="1em" /> <!--  KATAKANA LETTER HA -->
+      <map code="0x30D0" name="1em" /> <!--  KATAKANA LETTER BA -->
+      <map code="0x30D1" name="1em" /> <!--  KATAKANA LETTER PA -->
+      <map code="0x30D2" name="1em" /> <!--  KATAKANA LETTER HI -->
+      <map code="0x30D3" name="1em" /> <!--  KATAKANA LETTER BI -->
+      <map code="0x30D4" name="1em" /> <!--  KATAKANA LETTER PI -->
+      <map code="0x30D5" name="1em" /> <!--  KATAKANA LETTER HU -->
+      <map code="0x30D6" name="1em" /> <!--  KATAKANA LETTER BU -->
+      <map code="0x30D7" name="1em" /> <!--  KATAKANA LETTER PU -->
+      <map code="0x30D8" name="1em" /> <!--  KATAKANA LETTER HE -->
+      <map code="0x30D9" name="1em" /> <!--  KATAKANA LETTER BE -->
+      <map code="0x30DA" name="1em" /> <!--  KATAKANA LETTER PE -->
+      <map code="0x30DB" name="1em" /> <!--  KATAKANA LETTER HO -->
+      <map code="0x30DC" name="1em" /> <!--  KATAKANA LETTER BO -->
+      <map code="0x30DD" name="1em" /> <!--  KATAKANA LETTER PO -->
+      <map code="0x30DE" name="1em" /> <!--  KATAKANA LETTER MA -->
+      <map code="0x30DF" name="1em" /> <!--  KATAKANA LETTER MI -->
+      <map code="0x30E0" name="1em" /> <!--  KATAKANA LETTER MU -->
+      <map code="0x30E1" name="1em" /> <!--  KATAKANA LETTER ME -->
+      <map code="0x30E2" name="1em" /> <!--  KATAKANA LETTER MO -->
+      <map code="0x30E3" name="1em" /> <!--  KATAKANA LETTER SMALL YA -->
+      <map code="0x30E4" name="1em" /> <!--  KATAKANA LETTER YA -->
+      <map code="0x30E5" name="1em" /> <!--  KATAKANA LETTER SMALL YU -->
+      <map code="0x30E6" name="1em" /> <!--  KATAKANA LETTER YU -->
+      <map code="0x30E7" name="1em" /> <!--  KATAKANA LETTER SMALL YO -->
+      <map code="0x30E8" name="1em" /> <!--  KATAKANA LETTER YO -->
+      <map code="0x30E9" name="1em" /> <!--  KATAKANA LETTER RA -->
+      <map code="0x30EA" name="1em" /> <!--  KATAKANA LETTER RI -->
+      <map code="0x30EB" name="1em" /> <!--  KATAKANA LETTER RU -->
+      <map code="0x30EC" name="1em" /> <!--  KATAKANA LETTER RE -->
+      <map code="0x30ED" name="1em" /> <!--  KATAKANA LETTER RO -->
+      <map code="0x30EE" name="1em" /> <!--  KATAKANA LETTER SMALL WA -->
+      <map code="0x30EF" name="1em" /> <!--  KATAKANA LETTER WA -->
+      <map code="0x30F0" name="1em" /> <!--  KATAKANA LETTER WI -->
+      <map code="0x30F1" name="1em" /> <!--  KATAKANA LETTER WE -->
+      <map code="0x30F2" name="1em" /> <!--  KATAKANA LETTER WO -->
+      <map code="0x30F3" name="1em" /> <!--  KATAKANA LETTER N -->
+      <map code="0x30F4" name="1em" /> <!--  KATAKANA LETTER VU -->
+      <map code="0x30F5" name="1em" /> <!--  KATAKANA LETTER SMALL KA -->
+      <map code="0x30F6" name="1em" /> <!--  KATAKANA LETTER SMALL KE -->
+      <map code="0x30F7" name="1em" /> <!--  KATAKANA LETTER VA -->
+      <map code="0x30F8" name="1em" /> <!--  KATAKANA LETTER VI -->
+      <map code="0x30F9" name="1em" /> <!--  KATAKANA LETTER VE -->
+      <map code="0x30FA" name="1em" /> <!--  KATAKANA LETTER VO -->
+      <map code="0x30FB" name="1em" /> <!--  KATAKANA MIDDLE DOT -->
+      <map code="0x30FC" name="1em" /> <!--  KATAKANA-HIRAGANA PROLONGED SOUND MARK -->
+      <map code="0x30FD" name="1em" /> <!--  KATAKANA ITERATION MARK -->
+      <map code="0x30FE" name="1em" /> <!--  KATAKANA VOICED ITERATION MARK -->
+      <map code="0x30FF" name="1em" /> <!--  KATAKANA DIGRAPH KOTO -->
+
+      <!-- Random Han characters used for testing -->
+      <map code="0x5929" name="1em" /> <!--  天 -->
+      <map code="0x65E5" name="1em" /> <!--  日 -->
+      <map code="0x6674" name="1em" /> <!--  晴 -->
+      <map code="0x672C" name="1em" /> <!--  本 -->
+
+    </cmap_format_12>
+  </cmap>
+
+  <loca>
+    <!-- The 'loca' table will be calculated by the compiler -->
+  </loca>
+
+  <glyf>
+    <TTGlyph name=".notdef" xMin="0" yMin="0" xMax="0" yMax="0" />
+    <TTGlyph name="1em" xMin="0" yMin="0" xMax="100" yMax="100">
+        <contour>
+            <pt x="0" y="0" on="1" />
+            <pt x="100" y="0" on="1" />
+            <pt x="100" y="100" on="1" />
+            <pt x="0" y="100" on="1" />
+        </contour>
+        <instructions><assembly></assembly></instructions>
+    </TTGlyph>
+  </glyf>
+
+  <name>
+    <namerecord nameID="1" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Font for Hiragana
+    </namerecord>
+    <namerecord nameID="2" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Regular
+    </namerecord>
+    <namerecord nameID="4" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Font for Hiragana
+    </namerecord>
+    <namerecord nameID="6" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      SampleFont-Regular
+    </namerecord>
+    <namerecord nameID="1" platformID="3" platEncID="1" langID="0x409">
+      Sample Font
+    </namerecord>
+    <namerecord nameID="2" platformID="3" platEncID="1" langID="0x409">
+      Regular
+    </namerecord>
+    <namerecord nameID="4" platformID="3" platEncID="1" langID="0x409">
+      Sample Font
+    </namerecord>
+    <namerecord nameID="6" platformID="3" platEncID="1" langID="0x409">
+      SampleFont-Regular
+    </namerecord>
+  </name>
+
+  <post>
+    <formatType value="3.0"/>
+    <italicAngle value="0.0"/>
+    <underlinePosition value="-75"/>
+    <underlineThickness value="50"/>
+    <isFixedPitch value="0"/>
+    <minMemType42 value="0"/>
+    <maxMemType42 value="0"/>
+    <minMemType1 value="0"/>
+    <maxMemType1 value="0"/>
+  </post>
+
+</ttFont>
diff --git a/tests/data/OvershootTest.ttf b/tests/data/OvershootTest.ttf
new file mode 100644
index 0000000..fb113c3
--- /dev/null
+++ b/tests/data/OvershootTest.ttf
diff --git a/tests/data/OvershootTest.ttx b/tests/data/OvershootTest.ttx
new file mode 100644
index 0000000..8f6c88c
--- /dev/null
+++ b/tests/data/OvershootTest.ttx
@@ -0,0 +1,257 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.0">
+
+  <GlyphOrder>
+    <GlyphID id="0" name=".notdef"/>
+    <GlyphID id="1" name="1em"/>
+    <GlyphID id="2" name="1em_right_0.5em"/>
+    <GlyphID id="3" name="1em_right_1em"/>
+    <GlyphID id="4" name="1em_right_1.5em"/>
+    <GlyphID id="5" name="1em_left_0.5em"/>
+    <GlyphID id="6" name="1em_left_1em"/>
+    <GlyphID id="7" name="1em_left_1.5em"/>
+  </GlyphOrder>
+
+  <head>
+    <tableVersion value="1.0"/>
+    <fontRevision value="1.0"/>
+    <checkSumAdjustment value="0x640cdb2f"/>
+    <magicNumber value="0x5f0f3cf5"/>
+    <flags value="00000000 00000011"/>
+    <unitsPerEm value="100"/>
+    <created value="Fri Mar 17 07:26:00 2017"/>
+    <macStyle value="00000000 00000000"/>
+    <lowestRecPPEM value="7"/>
+    <fontDirectionHint value="2"/>
+    <glyphDataFormat value="0"/>
+  </head>
+
+  <hhea>
+    <tableVersion value="0x00010000"/>
+    <ascent value="800"/>
+    <descent value="-200"/>
+    <lineGap value="0"/>
+    <caretSlopeRise value="1"/>
+    <caretSlopeRun value="0"/>
+    <caretOffset value="0"/>
+    <reserved0 value="0"/>
+    <reserved1 value="0"/>
+    <reserved2 value="0"/>
+    <reserved3 value="0"/>
+    <metricDataFormat value="0"/>
+  </hhea>
+
+  <maxp>
+    <tableVersion value="0x10000"/>
+    <maxZones value="0"/>
+    <maxTwilightPoints value="0"/>
+    <maxStorage value="0"/>
+    <maxFunctionDefs value="0"/>
+    <maxInstructionDefs value="0"/>
+    <maxStackElements value="0"/>
+    <maxSizeOfInstructions value="0"/>
+    <maxComponentElements value="0"/>
+  </maxp>
+
+  <OS_2>
+    <!-- The fields 'usFirstCharIndex' and 'usLastCharIndex'
+         will be recalculated by the compiler -->
+    <version value="3"/>
+    <xAvgCharWidth value="594"/>
+    <usWeightClass value="400"/>
+    <usWidthClass value="5"/>
+    <fsType value="00000000 00001000"/>
+    <ySubscriptXSize value="650"/>
+    <ySubscriptYSize value="600"/>
+    <ySubscriptXOffset value="0"/>
+    <ySubscriptYOffset value="75"/>
+    <ySuperscriptXSize value="650"/>
+    <ySuperscriptYSize value="600"/>
+    <ySuperscriptXOffset value="0"/>
+    <ySuperscriptYOffset value="350"/>
+    <yStrikeoutSize value="50"/>
+    <yStrikeoutPosition value="300"/>
+    <sFamilyClass value="0"/>
+    <panose>
+      <bFamilyType value="0"/>
+      <bSerifStyle value="0"/>
+      <bWeight value="5"/>
+      <bProportion value="0"/>
+      <bContrast value="0"/>
+      <bStrokeVariation value="0"/>
+      <bArmStyle value="0"/>
+      <bLetterForm value="0"/>
+      <bMidline value="0"/>
+      <bXHeight value="0"/>
+    </panose>
+    <ulUnicodeRange1 value="00000000 00000000 00000000 00000001"/>
+    <ulUnicodeRange2 value="00000000 00000000 00000000 00000000"/>
+    <ulUnicodeRange3 value="00000000 00000000 00000000 00000000"/>
+    <ulUnicodeRange4 value="00000000 00000000 00000000 00000000"/>
+    <achVendID value="UKWN"/>
+    <fsSelection value="00000000 01000000"/>
+    <usFirstCharIndex value="32"/>
+    <usLastCharIndex value="122"/>
+    <sTypoAscender value="800"/>
+    <sTypoDescender value="-200"/>
+    <sTypoLineGap value="200"/>
+    <usWinAscent value="1000"/>
+    <usWinDescent value="200"/>
+    <ulCodePageRange1 value="00000000 00000000 00000000 00000001"/>
+    <ulCodePageRange2 value="00000000 00000000 00000000 00000000"/>
+    <sxHeight value="500"/>
+    <sCapHeight value="700"/>
+    <usDefaultChar value="0"/>
+    <usBreakChar value="32"/>
+    <usMaxContext value="0"/>
+  </OS_2>
+
+  <hmtx>
+    <mtx name=".notdef" width="50" lsb="0"/>
+    <mtx name="1em" width="100" lsb="0"/>
+    <mtx name="1em_right_0.5em" width="100" lsb="0"/>
+    <mtx name="1em_right_1em" width="100" lsb="0"/>
+    <mtx name="1em_right_1.5em" width="100" lsb="0"/>
+    <mtx name="1em_left_0.5em" width="100" lsb="-50"/>
+    <mtx name="1em_left_1em" width="100" lsb="-100"/>
+    <mtx name="1em_left_1.5em" width="100" lsb="-150"/>
+  </hmtx>
+
+  <cmap>
+    <tableVersion version="0"/>
+    <cmap_format_12 format="12" reserved="0" length="6" nGroups="1" platformID="3" platEncID="10" language="0">
+      <map code="0x0061" name="1em" />              <!-- a -->
+      <map code="0x0062" name="1em_right_0.5em" />  <!-- b -->
+      <map code="0x0063" name="1em_right_1em" />    <!-- c -->
+      <map code="0x0064" name="1em_right_1.5em" />  <!-- d -->
+      <map code="0x0065" name="1em_left_0.5em" />   <!-- e -->
+      <map code="0x0066" name="1em_left_1em" />     <!-- f -->
+      <map code="0x0067" name="1em_left_1.5em" />   <!-- g -->
+    </cmap_format_12>
+  </cmap>
+
+  <loca>
+    <!-- The 'loca' table will be calculated by the compiler -->
+  </loca>
+
+  <glyf>
+    <TTGlyph name=".notdef" xMin="0" yMin="0" xMax="0" yMax="0" />
+    <TTGlyph name="1em" xMin="0" yMin="0" xMax="100" yMax="100">
+      <contour>
+        <pt x="0" y="0" on="1" />
+        <pt x="0" y="100" on="1" />
+        <pt x="100" y="100" on="1" />
+        <pt x="100" y="0" on="1" />
+      </contour>
+      <instructions />
+    </TTGlyph>
+    <TTGlyph name="1em_right_0.5em" xMin="0" yMin="0" xMax="150" yMax="100">
+      <contour>
+        <pt x="0" y="0" on="1" />
+        <pt x="0" y="100" on="1" />
+        <pt x="150" y="100" on="1" />
+        <pt x="150" y="0" on="1" />
+      </contour>
+      <instructions />
+    </TTGlyph>
+    <TTGlyph name="1em_right_1em" xMin="0" yMin="0" xMax="200" yMax="100">
+      <contour>
+        <pt x="0" y="0" on="1" />
+        <pt x="0" y="100" on="1" />
+        <pt x="200" y="100" on="1" />
+        <pt x="200" y="0" on="1" />
+      </contour>
+      <instructions />
+    </TTGlyph>
+    <TTGlyph name="1em_right_1.5em" xMin="0" yMin="0" xMax="250" yMax="100">
+      <contour>
+        <pt x="0" y="0" on="1" />
+        <pt x="0" y="100" on="1" />
+        <pt x="250" y="100" on="1" />
+        <pt x="250" y="0" on="1" />
+      </contour>
+      <instructions />
+    </TTGlyph>
+    <TTGlyph name="1em_left_0.5em" xMin="-50" yMin="0" xMax="100" yMax="100">
+      <contour>
+        <pt x="-50" y="0" on="1" />
+        <pt x="-50" y="100" on="1" />
+        <pt x="100" y="100" on="1" />
+        <pt x="100" y="0" on="1" />
+      </contour>
+      <instructions />
+    </TTGlyph>
+    <TTGlyph name="1em_left_1em" xMin="-100" yMin="0" xMax="100" yMax="100">
+      <contour>
+        <pt x="-100" y="0" on="1" />
+        <pt x="-100" y="100" on="1" />
+        <pt x="100" y="100" on="1" />
+        <pt x="100" y="0" on="1" />
+      </contour>
+      <instructions />
+    </TTGlyph>
+    <TTGlyph name="1em_left_1.5em" xMin="-150" yMin="0" xMax="100" yMax="100">
+      <contour>
+        <pt x="-150" y="0" on="1" />
+        <pt x="-150" y="100" on="1" />
+        <pt x="100" y="100" on="1" />
+        <pt x="100" y="0" on="1" />
+      </contour>
+      <instructions />
+    </TTGlyph>
+  </glyf>
+
+  <name>
+    <namerecord nameID="1" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Font for Overshoot
+    </namerecord>
+    <namerecord nameID="2" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Regular
+    </namerecord>
+    <namerecord nameID="4" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      Font for Overshoot
+    </namerecord>
+    <namerecord nameID="6" platformID="1" platEncID="0" langID="0x0" unicode="True">
+      SampleFont-Regular
+    </namerecord>
+    <namerecord nameID="1" platformID="3" platEncID="1" langID="0x409">
+      Sample Font
+    </namerecord>
+    <namerecord nameID="2" platformID="3" platEncID="1" langID="0x409">
+      Regular
+    </namerecord>
+    <namerecord nameID="4" platformID="3" platEncID="1" langID="0x409">
+      Sample Font
+    </namerecord>
+    <namerecord nameID="6" platformID="3" platEncID="1" langID="0x409">
+      SampleFont-Regular
+    </namerecord>
+  </name>
+
+  <post>
+    <formatType value="3.0"/>
+    <italicAngle value="0.0"/>
+    <underlinePosition value="-75"/>
+    <underlineThickness value="50"/>
+    <isFixedPitch value="0"/>
+    <minMemType42 value="0"/>
+    <maxMemType42 value="0"/>
+    <minMemType1 value="0"/>
+    <maxMemType1 value="0"/>
+  </post>
+
+</ttFont>
diff --git a/tests/data/WeightEqualsEmVariableFont.ttf b/tests/data/WeightEqualsEmVariableFont.ttf
new file mode 100644
index 0000000..bbbf02e
--- /dev/null
+++ b/tests/data/WeightEqualsEmVariableFont.ttf
diff --git a/tests/data/WeightEqualsEmVariableFont.ttx b/tests/data/WeightEqualsEmVariableFont.ttx
new file mode 100644
index 0000000..86d7477
--- /dev/null
+++ b/tests/data/WeightEqualsEmVariableFont.ttx
@@ -0,0 +1,282 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.0">
+
+  <GlyphOrder>
+    <GlyphID id="0" name=".notdef"/>
+    <GlyphID id="1" name="1em"/>
+  </GlyphOrder>
+
+  <head>
+    <tableVersion value="1.0"/>
+    <fontRevision value="1.0"/>
+    <checkSumAdjustment value="0x640cdb2f"/>
+    <magicNumber value="0x5f0f3cf5"/>
+    <flags value="00000000 00000011"/>
+    <unitsPerEm value="100"/>
+    <created value="Thu Feb 22 10:04:28 2018"/>
+    <macStyle value="00000000 00000000"/>
+    <lowestRecPPEM value="7"/>
+    <fontDirectionHint value="2"/>
+    <glyphDataFormat value="0"/>
+  </head>
+
+  <hhea>
+    <tableVersion value="0x00010000"/>
+    <ascent value="100"/>
+    <descent value="0"/>
+    <lineGap value="0"/>
+    <caretSlopeRise value="1"/>
+    <caretSlopeRun value="0"/>
+    <caretOffset value="0"/>
+    <reserved0 value="0"/>
+    <reserved1 value="0"/>
+    <reserved2 value="0"/>
+    <reserved3 value="0"/>
+    <metricDataFormat value="0"/>
+  </hhea>
+
+  <maxp>
+    <tableVersion value="0x10000"/>
+    <maxZones value="0"/>
+    <maxTwilightPoints value="0"/>
+    <maxStorage value="0"/>
+    <maxFunctionDefs value="0"/>
+    <maxInstructionDefs value="0"/>
+    <maxStackElements value="0"/>
+    <maxSizeOfInstructions value="0"/>
+    <maxComponentElements value="0"/>
+  </maxp>
+
+  <OS_2>
+    <!-- The fields 'usFirstCharIndex' and 'usLastCharIndex'
+         will be recalculated by the compiler -->
+    <version value="3"/>
+    <xAvgCharWidth value="594"/>
+    <usWeightClass value="100"/>
+    <usWidthClass value="5"/>
+    <fsType value="00000000 00001000"/>
+    <ySubscriptXSize value="650"/>
+    <ySubscriptYSize value="600"/>
+    <ySubscriptXOffset value="0"/>
+    <ySubscriptYOffset value="75"/>
+    <ySuperscriptXSize value="650"/>
+    <ySuperscriptYSize value="600"/>
+    <ySuperscriptXOffset value="0"/>
+    <ySuperscriptYOffset value="350"/>
+    <yStrikeoutSize value="50"/>
+    <yStrikeoutPosition value="300"/>
+    <sFamilyClass value="0"/>
+    <panose>
+      <bFamilyType value="0"/>
+      <bSerifStyle value="0"/>
+      <bWeight value="5"/>
+      <bProportion value="0"/>
+      <bContrast value="0"/>
+      <bStrokeVariation value="0"/>
+      <bArmStyle value="0"/>
+      <bLetterForm value="0"/>
+      <bMidline value="0"/>
+      <bXHeight value="0"/>
+    </panose>
+    <ulUnicodeRange1 value="00000000 00000000 00000000 00000001"/>
+    <ulUnicodeRange2 value="00000000 00000000 00000000 00000000"/>
+    <ulUnicodeRange3 value="00000000 00000000 00000000 00000000"/>
+    <ulUnicodeRange4 value="00000000 00000000 00000000 00000000"/>
+    <achVendID value="UKWN"/>
+    <fsSelection value="00000000 01000000"/>
+    <usFirstCharIndex value="32"/>
+    <usLastCharIndex value="122"/>
+    <sTypoAscender value="800"/>
+    <sTypoDescender value="-200"/>
+    <sTypoLineGap value="200"/>
+    <usWinAscent value="1000"/>
+    <usWinDescent value="200"/>
+    <ulCodePageRange1 value="00000000 00000000 00000000 00000001"/>
+    <ulCodePageRange2 value="00000000 00000000 00000000 00000000"/>
+    <sxHeight value="500"/>
+    <sCapHeight value="700"/>
+    <usDefaultChar value="0"/>
+    <usBreakChar value="32"/>
+    <usMaxContext value="0"/>
+  </OS_2>
+
+  <hmtx>
+    <mtx name=".notdef" width="50" lsb="93"/>
+    <mtx name="1em" width="0" lsb="0"/>
+  </hmtx>
+
+  <cmap>
+    <tableVersion version="0"/>
+    <cmap_format_4 platformID="0" platEncID="3" language="0">
+        <map code="0x0061" name="1em" /> <!-- a -->
+        <map code="0x0062" name="1em" /> <!-- b -->
+        <map code="0x0063" name="1em" /> <!-- c -->
+        <map code="0x0064" name="1em" /> <!-- d -->
+        <map code="0x0065" name="1em" /> <!-- e -->
+        <map code="0x0066" name="1em" /> <!-- f -->
+        <map code="0x0067" name="1em" /> <!-- g -->
+        <map code="0x0068" name="1em" /> <!-- h -->
+        <map code="0x0069" name="1em" /> <!-- i -->
+        <map code="0x006A" name="1em" /> <!-- j -->
+        <map code="0x006B" name="1em" /> <!-- k -->
+        <map code="0x006C" name="1em" /> <!-- l -->
+        <map code="0x006D" name="1em" /> <!-- m -->
+        <map code="0x006E" name="1em" /> <!-- n -->
+        <map code="0x006F" name="1em" /> <!-- o -->
+        <map code="0x0070" name="1em" /> <!-- p -->
+        <map code="0x0071" name="1em" /> <!-- q -->
+        <map code="0x0072" name="1em" /> <!-- r -->
+        <map code="0x0073" name="1em" /> <!-- s -->
+        <map code="0x0074" name="1em" /> <!-- t -->
+        <map code="0x0075" name="1em" /> <!-- u -->
+        <map code="0x0076" name="1em" /> <!-- v -->
+        <map code="0x0077" name="1em" /> <!-- w -->
+        <map code="0x0078" name="1em" /> <!-- x -->
+        <map code="0x0079" name="1em" /> <!-- y -->
+        <map code="0x007A" name="1em" /> <!-- z -->
+    </cmap_format_4>
+  </cmap>
+
+  <loca>
+    <!-- The 'loca' table will be calculated by the compiler -->
+  </loca>
+
+  <glyf>
+    <TTGlyph name=".notdef" xMin="0" yMin="0" xMax="0" yMax="0" />
+    <TTGlyph name="1em" xMin="0" yMin="0" xMax="100" yMax="100">
+      <contour>
+        <pt x="0" y="0" on="1"/>
+        <pt x="0" y="50" on="1"/>
+        <pt x="0" y="100" on="1"/>
+      </contour>
+      <instructions />
+    </TTGlyph>
+  </glyf>
+
+  <HVAR>
+    <Version value="0x00010000"/>
+    <VarStore Format="1">
+      <Format value="1" />
+      <VarRegionList>
+        <Region index="0">
+          <VarRegionAxis index="0">
+            <StartCoord value="0" />
+            <PeakCoord value="1.0" />
+            <EndCoord value="1.0" />
+          </VarRegionAxis>
+          <VarRegionAxis index="1">
+            <StartCoord value="0" />
+            <PeakCoord value="1.0" />
+            <EndCoord value="1.0" />
+          </VarRegionAxis>
+        </Region>
+      </VarRegionList>
+      <VarData index="0">
+        <NumShorts value="0" />
+        <VarRegionIndex index="0" value="0" />
+        <Item index="0" value="[100]" />
+      </VarData>
+    </VarStore>
+    <AdvWidthMap>
+      <Map glyph=".notdef" outer="0" inner="0" />
+      <Map glyph="1em" outer="0" inner="0" />
+    </AdvWidthMap>
+  </HVAR>
+
+  <fvar>
+    <Axis>
+      <AxisTag>wght</AxisTag>
+      <Flags>0x0</Flags>
+      <MinValue>0.0</MinValue>
+      <DefaultValue>400.0</DefaultValue>
+      <MaxValue>1000.0</MaxValue>
+      <AxisNameID>256</AxisNameID>
+    </Axis>
+    <Axis>
+      <AxisTag>ital</AxisTag>
+      <Flags>0x0</Flags>
+      <MinValue>0.0</MinValue>
+      <DefaultValue>0.0</DefaultValue>
+      <MaxValue>1.0</MaxValue>
+      <AxisNameID>256</AxisNameID>
+    </Axis>
+  </fvar>
+
+  <gvar>
+    <version value="1" />
+    <reserved value="0" />
+    <glyphVariations glyph="1em">
+      <tuple>
+        <coord axis="wght" value="1.0" />
+        <delta pt="0" x="0" y="0" />
+        <delta pt="1" x="100" y="0" />
+        <delta pt="2" x="0" y="0" />
+        <!-- deltas for phantom points -->
+        <delta pt="3" x="0" y="0" />  <!-- (left, 0) -->
+        <delta pt="4" x="100" y="0" />  <!-- (right, 0) -->
+        <delta pt="5" x="0" y="0" />  <!-- (0, top) -->
+        <delta pt="6" x="0" y="0" />  <!-- (0, bottom) -->
+      </tuple>
+    </glyphVariations>
+  </gvar>
+
+  <name>
+    <namerecord nameID="0" platformID="3" platEncID="1" langID="0x409">
+      Copyright (C) 2018 The Android Open Source Project
+    </namerecord>
+    <namerecord nameID="1" platformID="3" platEncID="1" langID="0x409">
+      Sample Font
+    </namerecord>
+    <namerecord nameID="2" platformID="3" platEncID="1" langID="0x409">
+      Regular
+    </namerecord>
+    <namerecord nameID="4" platformID="3" platEncID="1" langID="0x409">
+      Sample Font
+    </namerecord>
+    <namerecord nameID="6" platformID="3" platEncID="1" langID="0x409">
+      SampleFont-Regular
+    </namerecord>
+    <namerecord nameID="13" platformID="3" platEncID="1" langID="0x409">
+      Licensed under the Apache License, Version 2.0 (the "License");
+      you may not use this file except in compliance with the License.
+      Unless required by applicable law or agreed to in writing, software
+      distributed under the License is distributed on an "AS IS" BASIS
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+      See the License for the specific language governing permissions and
+      limitations under the License.
+    </namerecord>
+    <namerecord nameID="14" platformID="3" platEncID="1" langID="0x409">
+      http://www.apache.org/licenses/LICENSE-2.0
+    </namerecord>
+    <namerecord nameID="256" platformID="3" platEncID="1" langID="0x409">
+      Weight
+    </namerecord>
+  </name>
+
+  <post>
+    <formatType value="3.0"/>
+    <italicAngle value="0.0"/>
+    <underlinePosition value="-75"/>
+    <underlineThickness value="50"/>
+    <isFixedPitch value="0"/>
+    <minMemType42 value="0"/>
+    <maxMemType42 value="0"/>
+    <minMemType1 value="0"/>
+    <maxMemType1 value="0"/>
+  </post>
+
+</ttFont>
diff --git a/tests/perftests/Android.bp b/tests/perftests/Android.bp
index dcf5b98..c4260b3 100644
--- a/tests/perftests/Android.bp
+++ b/tests/perftests/Android.bp
@@ -37,6 +37,7 @@ cc_benchmark {
         "libminikin-tests-util",
         "libminikin",
         "libxml2",
+        "aconfig_text_flags_c_lib",
     ],
 
     shared_libs: [
@@ -44,6 +45,8 @@ cc_benchmark {
         "libharfbuzz_ng",
         "libicu",
         "liblog",
-
+        "libcutils",
+        "aconfig_text_flags_c_lib",
+        "server_configurable_flags",
     ],
 }
diff --git a/tests/stresstest/Android.bp b/tests/stresstest/Android.bp
index d963a09..420a4b1 100644
--- a/tests/stresstest/Android.bp
+++ b/tests/stresstest/Android.bp
@@ -28,6 +28,7 @@ cc_test {
         "libminikin-tests-util",
         "libminikin",
         "libxml2",
+        "aconfig_text_flags_c_lib",
     ],
 
     // Shared libraries which are dependencies of minikin; these are not automatically
@@ -40,6 +41,9 @@ cc_test {
         "liblog",
         "libutils",
         "libz",
+        "libcutils",
+        "aconfig_text_flags_c_lib",
+        "server_configurable_flags",
     ],
 
     srcs: [
diff --git a/tests/unittest/Android.bp b/tests/unittest/Android.bp
index 9800416..5a822cd 100644
--- a/tests/unittest/Android.bp
+++ b/tests/unittest/Android.bp
@@ -29,6 +29,8 @@ cc_test {
         "libminikin-tests-util",
         "libminikin",
         "libxml2",
+        "libflagtest",
+        "libbase_ndk",
     ],
 
     // Shared libraries which are dependencies of minikin; these are not automatically
@@ -40,13 +42,15 @@ cc_test {
         "liblog",
         "libutils",
         "libz",
+        "libcutils",
+        "aconfig_text_flags_c_lib",
+        "server_configurable_flags",
     ],
 
     srcs: [
         "AndroidLineBreakerHelperTest.cpp",
         "BidiUtilsTest.cpp",
         "BufferTest.cpp",
-        "BoundsCacheTest.cpp",
         "CmapCoverageTest.cpp",
         "EmojiTest.cpp",
         "FontTest.cpp",
@@ -71,6 +75,7 @@ cc_test {
         "MeasuredTextTest.cpp",
         "MeasurementTests.cpp",
         "OptimalLineBreakerTest.cpp",
+        "ScriptUtilsTest.cpp",
         "SparseBitSetTest.cpp",
         "StringPieceTest.cpp",
         "SystemFontsTest.cpp",
diff --git a/tests/unittest/BoundsCacheTest.cpp b/tests/unittest/BoundsCacheTest.cpp
deleted file mode 100644
index 8c727f9..0000000
--- a/tests/unittest/BoundsCacheTest.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-
-#include "minikin/BoundsCache.h"
-
-#include "FontTestUtils.h"
-#include "LocaleListCache.h"
-#include "UnicodeUtils.h"
-
-namespace minikin {
-
-class TestableBoundsCache : public BoundsCache {
-public:
-    TestableBoundsCache(uint32_t maxEntries) : BoundsCache(maxEntries) {}
-};
-
-class BoundsCapture {
-public:
-    BoundsCapture() {}
-
-    void operator()(const MinikinRect& rect, float advance) {
-        mRect = rect;
-        mAdvance = advance;
-    }
-
-    const MinikinRect& rect() const { return mRect; }
-    float advance() const { return mAdvance; }
-
-private:
-    MinikinRect mRect;
-    float mAdvance;
-};
-
-TEST(BoundsCacheTest, cacheHitTest) {
-    auto text = utf8ToUtf16("android");
-    Range range(0, text.size());
-    MinikinPaint paint(buildFontCollection("Ascii.ttf"));
-
-    TestableBoundsCache boundsCache(10);
-
-    BoundsCapture bounds1;
-    boundsCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, bounds1);
-
-    BoundsCapture bounds2;
-    boundsCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, bounds2);
-
-    EXPECT_EQ(bounds1.rect(), bounds2.rect());
-    EXPECT_EQ(bounds1.advance(), bounds2.advance());
-}
-
-TEST(BoundsCacheTest, cacheMissTest) {
-    auto text1 = utf8ToUtf16("android");
-    auto text2 = utf8ToUtf16("αβγδζ");
-    MinikinPaint paint(buildFontCollection("Ascii.ttf"));
-
-    TestableBoundsCache boundsCache(10);
-
-    BoundsCapture bounds1;
-    BoundsCapture bounds2;
-
-    {
-        SCOPED_TRACE("Different text");
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
-        boundsCache.getOrCreate(text2, Range(0, text2.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
-        EXPECT_NE(bounds1.rect(), bounds2.rect());
-        EXPECT_NE(bounds1.advance(), bounds2.advance());
-    }
-    {
-        SCOPED_TRACE("Different range");
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
-        boundsCache.getOrCreate(text1, Range(1, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
-        EXPECT_NE(bounds1.rect(), bounds2.rect());
-        EXPECT_NE(bounds1.advance(), bounds2.advance());
-    }
-    {
-        SCOPED_TRACE("Different collection");
-        MinikinPaint paint1(buildFontCollection("Ascii.ttf"));
-        paint1.size = 10.0f;
-        paint1.scaleX = 1.0f;
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
-        MinikinPaint paint2(buildFontCollection("Emoji.ttf"));
-        paint2.size = 10.0f;
-        paint2.scaleX = 1.0f;
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
-        EXPECT_NE(bounds1.rect(), bounds2.rect());
-        EXPECT_NE(bounds1.advance(), bounds2.advance());
-    }
-    {
-        SCOPED_TRACE("Different size");
-        auto collection = buildFontCollection("Ascii.ttf");
-        MinikinPaint paint1(collection);
-        paint1.size = 10.0f;
-        paint1.scaleX = 1.0f;
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
-        MinikinPaint paint2(collection);
-        paint2.size = 20.0f;
-        paint2.scaleX = 1.0f;
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
-        EXPECT_NE(bounds1.rect(), bounds2.rect());
-        EXPECT_NE(bounds1.advance(), bounds2.advance());
-    }
-    {
-        SCOPED_TRACE("Different letter spacing");
-        auto collection = buildFontCollection("Ascii.ttf");
-        MinikinPaint paint1(collection);
-        paint1.letterSpacing = 0.0f;
-        paint1.size = 10.0f;
-        paint1.scaleX = 1.0f;
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
-        MinikinPaint paint2(collection);
-        paint2.letterSpacing = 1.0f;
-        paint2.size = 10.0f;
-        paint2.scaleX = 1.0f;
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
-        EXPECT_NE(bounds1.rect(), bounds2.rect());
-        EXPECT_NE(bounds1.advance(), bounds2.advance());
-    }
-}
-
-TEST(BoundsCacheTest, cacheOverflowTest) {
-    auto text = utf8ToUtf16("android");
-    Range range(0, text.size());
-    MinikinPaint paint(buildFontCollection("Ascii.ttf"));
-
-    TestableBoundsCache boundsCache(5);
-
-    BoundsCapture bounds1;
-    boundsCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, bounds1);
-
-    for (char c = 'a'; c <= 'z'; c++) {
-        auto text1 = utf8ToUtf16(std::string(10, c));
-        BoundsCapture bounds2;
-        boundsCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
-    }
-
-    BoundsCapture bounds3;
-    boundsCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, bounds3);
-    EXPECT_EQ(bounds1.rect(), bounds3.rect());
-    EXPECT_EQ(bounds1.advance(), bounds3.advance());
-}
-
-}  // namespace minikin
diff --git a/tests/unittest/FontCollectionItemizeTest.cpp b/tests/unittest/FontCollectionItemizeTest.cpp
index 1723519..46f319d 100644
--- a/tests/unittest/FontCollectionItemizeTest.cpp
+++ b/tests/unittest/FontCollectionItemizeTest.cpp
@@ -113,7 +113,7 @@ std::vector<Run> itemize(const std::shared_ptr<FontCollection>& collection, cons
 // Utility function to obtain font path associated with run.
 std::string getFontName(const Run& run) {
     EXPECT_NE(nullptr, run.fakedFont.font.get());
-    return getBasename(run.fakedFont.font.get()->typeface()->GetFontPath());
+    return getBasename(run.fakedFont.typeface()->GetFontPath());
 }
 
 // Utility function to obtain LocaleList from string.
@@ -937,9 +937,10 @@ TEST(FontCollectionItemizeTest, itemize_LocaleScore) {
                 std::make_shared<FreeTypeMinikinFontForTest>(getTestFontPath(kNoGlyphFont));
         std::vector<std::shared_ptr<Font>> fonts;
         fonts.push_back(Font::Builder(firstFamilyMinikinFont).build());
-        auto firstFamily = FontFamily::create(registerLocaleList("und"), FamilyVariant::DEFAULT,
-                                              std::move(fonts), false /* isCustomFallback */,
-                                              false /* isDefaultFallback */);
+        auto firstFamily =
+                FontFamily::create(registerLocaleList("und"), FamilyVariant::DEFAULT,
+                                   std::move(fonts), false /* isCustomFallback */,
+                                   false /* isDefaultFallback */, VariationFamilyType::None);
         families.push_back(firstFamily);
 
         // Prepare font families
@@ -954,7 +955,8 @@ TEST(FontCollectionItemizeTest, itemize_LocaleScore) {
             fonts.push_back(Font::Builder(minikinFont).build());
             auto family = FontFamily::create(
                     registerLocaleList(testCase.fontLocales[i]), FamilyVariant::DEFAULT,
-                    std::move(fonts), false /* isCustomFallback */, false /* isDefaultFallback */);
+                    std::move(fonts), false /* isCustomFallback */, false /* isDefaultFallback */,
+                    VariationFamilyType::None);
             families.push_back(family);
             fontLocaleIdxMap.insert(std::make_pair(minikinFont.get(), i));
         }
@@ -966,11 +968,10 @@ TEST(FontCollectionItemizeTest, itemize_LocaleScore) {
 
         // First family doesn't support U+9AA8 and others support it, so the first font should not
         // be selected.
-        EXPECT_NE(firstFamilyMinikinFont.get(), runs[0].fakedFont.font.get()->typeface().get());
+        EXPECT_NE(firstFamilyMinikinFont.get(), runs[0].fakedFont.typeface().get());
 
         // Lookup used font family by MinikinFont*.
-        const int usedLocaleIndex =
-                fontLocaleIdxMap[runs[0].fakedFont.font.get()->typeface().get()];
+        const int usedLocaleIndex = fontLocaleIdxMap[runs[0].fakedFont.typeface().get()];
         EXPECT_EQ(testCase.selectedFontIndex, usedLocaleIndex);
     }
 }
@@ -1648,7 +1649,7 @@ std::vector<ItemizeResult> itemizeEmojiAndFontPostScriptNames(const std::string&
 
     std::vector<ItemizeResult> out;
     for (const auto& run : runs) {
-        auto psName = FontFileParser(run.fakedFont.font->baseFont()).getPostScriptName().value();
+        auto psName = FontFileParser(run.fakedFont.hbFont()).getPostScriptName().value();
         out.push_back({run.start, run.end, psName});
     }
     return out;
diff --git a/tests/unittest/FontCollectionTest.cpp b/tests/unittest/FontCollectionTest.cpp
index b4933ab..28e6094 100644
--- a/tests/unittest/FontCollectionTest.cpp
+++ b/tests/unittest/FontCollectionTest.cpp
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include "minikin/FontCollection.h"
-
 #include <gtest/gtest.h>
 
 #include "FontTestUtils.h"
 #include "FreeTypeMinikinFontForTest.h"
 #include "MinikinInternal.h"
+#include "minikin/Constants.h"
+#include "minikin/FontCollection.h"
 
 namespace minikin {
 
@@ -139,7 +139,7 @@ TEST(FontCollectionTest, createWithVariations) {
     }
     {
         // New instance should be used for supported variation.
-        std::vector<FontVariation> variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f}};
+        std::vector<FontVariation> variations = {{MakeTag('w', 'd', 't', 'h'), 1.0f}};
         std::shared_ptr<FontCollection> newFc(
                 multiAxisFc->createCollectionWithVariation(variations));
         EXPECT_NE(nullptr, newFc.get());
@@ -149,8 +149,8 @@ TEST(FontCollectionTest, createWithVariations) {
     }
     {
         // New instance should be used for supported variation (multiple variations case).
-        std::vector<FontVariation> variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f},
-                                                 {MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f}};
+        std::vector<FontVariation> variations = {{MakeTag('w', 'd', 't', 'h'), 1.0f},
+                                                 {MakeTag('w', 'g', 'h', 't'), 1.0f}};
         std::shared_ptr<FontCollection> newFc(
                 multiAxisFc->createCollectionWithVariation(variations));
         EXPECT_NE(nullptr, newFc.get());
@@ -160,14 +160,14 @@ TEST(FontCollectionTest, createWithVariations) {
     }
     {
         // Do not ceate new instance if none of variations are supported.
-        std::vector<FontVariation> variations = {{MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f}};
+        std::vector<FontVariation> variations = {{MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f}};
         EXPECT_EQ(nullptr, multiAxisFc->createCollectionWithVariation(variations));
         EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations));
     }
     {
         // At least one axis is supported, should create new instance.
-        std::vector<FontVariation> variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f},
-                                                 {MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f}};
+        std::vector<FontVariation> variations = {{MakeTag('w', 'd', 't', 'h'), 1.0f},
+                                                 {MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f}};
         std::shared_ptr<FontCollection> newFc(
                 multiAxisFc->createCollectionWithVariation(variations));
         EXPECT_NE(nullptr, newFc.get());
@@ -242,8 +242,8 @@ TEST(FontCollectionTest, bufferTest) {
         EXPECT_EQ(1u, copied.size());
         ASSERT_EQ(2u, copied[0]->getSupportedAxesCount());
         // mSupportedAxes must be sorted.
-        EXPECT_EQ(MinikinFont::MakeTag('w', 'd', 't', 'h'), copied[0]->getSupportedAxisAt(0));
-        EXPECT_EQ(MinikinFont::MakeTag('w', 'g', 'h', 't'), copied[0]->getSupportedAxisAt(1));
+        EXPECT_EQ(MakeTag('w', 'd', 't', 'h'), copied[0]->getSupportedAxisAt(0));
+        EXPECT_EQ(MakeTag('w', 'g', 'h', 't'), copied[0]->getSupportedAxisAt(1));
         std::vector<uint8_t> newBuffer = writeToBuffer(copied);
         EXPECT_EQ(buffer, newBuffer);
     }
diff --git a/tests/unittest/FontFamilyTest.cpp b/tests/unittest/FontFamilyTest.cpp
index 3230c27..b487c87 100644
--- a/tests/unittest/FontFamilyTest.cpp
+++ b/tests/unittest/FontFamilyTest.cpp
@@ -22,6 +22,7 @@
 #include "FreeTypeMinikinFontForTest.h"
 #include "LocaleListCache.h"
 #include "MinikinInternal.h"
+#include "minikin/Constants.h"
 #include "minikin/FontFamily.h"
 #include "minikin/LocaleList.h"
 
@@ -647,7 +648,7 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) {
     }
     {
         // New instance should be used for supported variation.
-        std::vector<FontVariation> variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f}};
+        std::vector<FontVariation> variations = {{MakeTag('w', 'd', 't', 'h'), 1.0f}};
         std::shared_ptr<FontFamily> newFamily(
                 multiAxisFamily->createFamilyWithVariation(variations));
         EXPECT_NE(nullptr, newFamily.get());
@@ -656,8 +657,8 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) {
     }
     {
         // New instance should be used for supported variation. (multiple variations case)
-        std::vector<FontVariation> variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f},
-                                                 {MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f}};
+        std::vector<FontVariation> variations = {{MakeTag('w', 'd', 't', 'h'), 1.0f},
+                                                 {MakeTag('w', 'g', 'h', 't'), 1.0f}};
         std::shared_ptr<FontFamily> newFamily(
                 multiAxisFamily->createFamilyWithVariation(variations));
         EXPECT_NE(nullptr, newFamily.get());
@@ -666,14 +667,14 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) {
     }
     {
         // Do not ceate new instance if none of variations are supported.
-        std::vector<FontVariation> variations = {{MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f}};
+        std::vector<FontVariation> variations = {{MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f}};
         EXPECT_EQ(nullptr, multiAxisFamily->createFamilyWithVariation(variations));
         EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations));
     }
     {
         // At least one axis is supported, should create new instance.
-        std::vector<FontVariation> variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f},
-                                                 {MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f}};
+        std::vector<FontVariation> variations = {{MakeTag('w', 'd', 't', 'h'), 1.0f},
+                                                 {MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f}};
         std::shared_ptr<FontFamily> newFamily(
                 multiAxisFamily->createFamilyWithVariation(variations));
         EXPECT_NE(nullptr, newFamily.get());
@@ -805,7 +806,7 @@ TEST_F(FontFamilyTest, closestMatch) {
 
         size_t idx = dummyFonts.size();
         for (size_t i = 0; i < dummyFonts.size(); i++) {
-            if (dummyFonts[i].get() == closest.font->typeface().get()) {
+            if (dummyFonts[i].get() == closest.font->baseTypeface().get()) {
                 idx = i;
                 break;
             }
diff --git a/tests/unittest/FontFeatureTest.cpp b/tests/unittest/FontFeatureTest.cpp
index 7f9cdf4..6f01842 100644
--- a/tests/unittest/FontFeatureTest.cpp
+++ b/tests/unittest/FontFeatureTest.cpp
@@ -14,10 +14,12 @@
  * limitations under the License.
  */
 
+#include <com_android_text_flags.h>
+#include <flag_macros.h>
 #include <gtest/gtest.h>
 
-#include "FontFeatureUtils.h"
 #include "FontTestUtils.h"
+#include "minikin/FontFeature.h"
 #include "minikin/MinikinPaint.h"
 
 namespace minikin {
@@ -53,7 +55,7 @@ TEST_F(DefaultFontFeatureTest, default) {
 
 TEST_F(DefaultFontFeatureTest, disable) {
     auto paint = MinikinPaint(font);
-    paint.fontFeatureSettings = "\"chws\" off";
+    paint.fontFeatureSettings = FontFeature::parse("\"chws\" off");
 
     auto f = cleanAndAddDefaultFontFeatures(paint);
     std::sort(f.begin(), f.end(), compareFeatureTag);
@@ -65,7 +67,7 @@ TEST_F(DefaultFontFeatureTest, disable) {
 
 TEST_F(DefaultFontFeatureTest, preserve) {
     auto paint = MinikinPaint(font);
-    paint.fontFeatureSettings = "\"ruby\" on";
+    paint.fontFeatureSettings = FontFeature::parse("\"ruby\" on");
 
     auto f = cleanAndAddDefaultFontFeatures(paint);
     std::sort(f.begin(), f.end(), compareFeatureTag);
@@ -95,7 +97,7 @@ TEST_F(DefaultFontFeatureTest, large_letter_spacing) {
 
 TEST_F(DefaultFontFeatureTest, halt_disable_chws) {
     auto paint = MinikinPaint(font);
-    paint.fontFeatureSettings = "\"halt\" on";
+    paint.fontFeatureSettings = FontFeature::parse("\"halt\" on");
 
     auto f = cleanAndAddDefaultFontFeatures(paint);
     EXPECT_EQ(1u, f.size());
@@ -105,7 +107,7 @@ TEST_F(DefaultFontFeatureTest, halt_disable_chws) {
 
 TEST_F(DefaultFontFeatureTest, palt_disable_chws) {
     auto paint = MinikinPaint(font);
-    paint.fontFeatureSettings = "\"palt\" on";
+    paint.fontFeatureSettings = FontFeature::parse("\"palt\" on");
 
     auto f = cleanAndAddDefaultFontFeatures(paint);
     EXPECT_EQ(1u, f.size());
@@ -116,7 +118,7 @@ TEST_F(DefaultFontFeatureTest, palt_disable_chws) {
 TEST_F(DefaultFontFeatureTest, halt_disable_chws_large_letter_spacing) {
     auto paint = MinikinPaint(font);
     paint.letterSpacing = 1.0;  // em
-    paint.fontFeatureSettings = "\"halt\" on";
+    paint.fontFeatureSettings = FontFeature::parse("\"halt\" on");
 
     auto f = cleanAndAddDefaultFontFeatures(paint);
     std::sort(f.begin(), f.end(), compareFeatureTag);
@@ -133,7 +135,7 @@ TEST_F(DefaultFontFeatureTest, halt_disable_chws_large_letter_spacing) {
 TEST_F(DefaultFontFeatureTest, palt_disable_chws_large_letter_spacing) {
     auto paint = MinikinPaint(font);
     paint.letterSpacing = 1.0;  // em
-    paint.fontFeatureSettings = "\"palt\" on";
+    paint.fontFeatureSettings = FontFeature::parse("\"palt\" on");
 
     auto f = cleanAndAddDefaultFontFeatures(paint);
     std::sort(f.begin(), f.end(), compareFeatureTag);
@@ -147,4 +149,27 @@ TEST_F(DefaultFontFeatureTest, palt_disable_chws_large_letter_spacing) {
     EXPECT_TRUE(f[2].value);
 }
 
+class FontFeatureTest : public testing::Test {
+protected:
+    std::shared_ptr<FontCollection> font;
+
+    virtual void SetUp() override { font = buildFontCollection("Ascii.ttf"); }
+};
+
+TEST_F_WITH_FLAGS(FontFeatureTest, do_not_skip_cache_if_flagEnabled,
+                  REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                      inter_character_justification))) {
+    auto paint = MinikinPaint(font);
+    paint.fontFeatureSettings = FontFeature::parse("\"palt\" on");
+    EXPECT_FALSE(paint.skipCache());
+}
+
+TEST_F_WITH_FLAGS(FontFeatureTest, do_not_skip_cache_if_flagDisabled,
+                  REQUIRES_FLAGS_DISABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                       inter_character_justification))) {
+    auto paint = MinikinPaint(font);
+    paint.fontFeatureSettings = FontFeature::parse("\"palt\" on");
+    EXPECT_TRUE(paint.skipCache());
+}
+
 }  // namespace minikin
diff --git a/tests/unittest/FontTest.cpp b/tests/unittest/FontTest.cpp
index b50ac90..7db2310 100644
--- a/tests/unittest/FontTest.cpp
+++ b/tests/unittest/FontTest.cpp
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include "minikin/Font.h"
-
 #include <gtest/gtest.h>
+#include <minikin/Constants.h>
 
 #include "BufferUtils.h"
 #include "FontTestUtils.h"
 #include "FreeTypeMinikinFontForTest.h"
+#include "minikin/Font.h"
 
 namespace minikin {
 
@@ -41,17 +41,17 @@ TEST(FontTest, BufferTest) {
 
     BufferReader reader(buffer.data());
     Font font(&reader);
-    EXPECT_EQ(minikinFont->GetFontPath(), font.typeface()->GetFontPath());
+    EXPECT_EQ(minikinFont->GetFontPath(), font.baseTypeface()->GetFontPath());
     EXPECT_EQ(original->style(), font.style());
     EXPECT_EQ(original->getLocaleListId(), font.getLocaleListId());
     // baseFont() should return the same non-null instance when called twice.
     const auto& baseFont = font.baseFont();
     EXPECT_NE(nullptr, baseFont);
     EXPECT_EQ(baseFont, font.baseFont());
-    // typeface() should return the same non-null instance when called twice.
-    const auto& typeface = font.typeface();
+    // baseTypeface() should return the same non-null instance when called twice.
+    const auto& typeface = font.baseTypeface();
     EXPECT_NE(nullptr, typeface);
-    EXPECT_EQ(typeface, font.typeface());
+    EXPECT_EQ(typeface, font.baseTypeface());
     std::vector<uint8_t> newBuffer = writeToBuffer<Font>(font);
     EXPECT_EQ(buffer, newBuffer);
 }
@@ -75,10 +75,10 @@ TEST(FontTest, MoveConstructorTest) {
     {
         BufferReader reader(buffer.data());
         Font moveFrom(&reader);
-        std::shared_ptr<MinikinFont> typeface = moveFrom.typeface();
+        std::shared_ptr<MinikinFont> typeface = moveFrom.baseTypeface();
         Font moveTo(std::move(moveFrom));
         EXPECT_EQ(nullptr, moveFrom.mExternalRefsHolder.load());
-        EXPECT_EQ(typeface, moveTo.typeface());
+        EXPECT_EQ(typeface, moveTo.baseTypeface());
     }
     EXPECT_EQ(baseHeapSize, getHeapSize());
 }
@@ -106,12 +106,12 @@ TEST(FontTest, MoveAssignmentTest) {
         // mExternalRefsHolder: non-null -> null
         BufferReader reader(buffer.data());
         Font moveFrom(&reader);
-        std::shared_ptr<MinikinFont> typeface = moveFrom.typeface();
+        std::shared_ptr<MinikinFont> typeface = moveFrom.baseTypeface();
         BufferReader reader2(buffer.data());
         Font moveTo(&reader2);
         moveTo = std::move(moveFrom);
         EXPECT_EQ(nullptr, moveFrom.mExternalRefsHolder.load());
-        EXPECT_EQ(typeface, moveTo.typeface());
+        EXPECT_EQ(typeface, moveTo.baseTypeface());
     }
     EXPECT_EQ(baseHeapSize, getHeapSize());
     {
@@ -120,7 +120,7 @@ TEST(FontTest, MoveAssignmentTest) {
         Font moveFrom(&reader);
         BufferReader reader2(buffer.data());
         Font moveTo(&reader2);
-        moveTo.typeface();
+        moveTo.baseTypeface();
         moveTo = std::move(moveFrom);
         EXPECT_EQ(nullptr, moveFrom.mExternalRefsHolder.load());
         EXPECT_EQ(nullptr, moveTo.mExternalRefsHolder.load());
@@ -130,15 +130,169 @@ TEST(FontTest, MoveAssignmentTest) {
         // mExternalRefsHolder: non-null -> non-null
         BufferReader reader(buffer.data());
         Font moveFrom(&reader);
-        std::shared_ptr<MinikinFont> typeface = moveFrom.typeface();
+        std::shared_ptr<MinikinFont> typeface = moveFrom.baseTypeface();
         BufferReader reader2(buffer.data());
         Font moveTo(&reader2);
-        moveTo.typeface();
+        moveTo.baseTypeface();
         moveTo = std::move(moveFrom);
         EXPECT_EQ(nullptr, moveFrom.mExternalRefsHolder.load());
-        EXPECT_EQ(typeface, moveTo.typeface());
+        EXPECT_EQ(typeface, moveTo.baseTypeface());
     }
     EXPECT_EQ(baseHeapSize, getHeapSize());
 }
 
+TEST(FontTest, getAdjustedFontTest) {
+    FreeTypeMinikinFontForTestFactory::init();
+    auto minikinFont = std::make_shared<FreeTypeMinikinFontForTest>(
+            getTestFontPath("WeightEqualsEmVariableFont.ttf"));
+    std::shared_ptr<Font> font = Font::Builder(minikinFont).build();
+
+    {
+        auto hbFont = font->getAdjustedFont(-1, -1);
+        EXPECT_EQ(hbFont.get(), font->baseFont().get());
+    }
+    {
+        // Set correct wight axis value.
+        auto hbFont = font->getAdjustedFont(400, -1);
+        EXPECT_EQ(hb_font_get_parent(hbFont.get()), font->baseFont().get());
+        EXPECT_NE(hbFont.get(), font->baseFont().get());
+        unsigned int length;
+        const float* coords = hb_font_get_var_coords_design(hbFont.get(), &length);
+        ASSERT_EQ(2u, length);  // The test font has 'wght', 'ital' axes in this order
+        EXPECT_EQ(400, coords[0]);
+        EXPECT_EQ(0, coords[1]);
+    }
+    {
+        // Override existing wght axis.
+        std::shared_ptr<Font> newFont = Font::Builder(font->getAdjustedTypeface(700, -1)).build();
+        auto hbFont = newFont->getAdjustedFont(500, -1);
+        EXPECT_EQ(hb_font_get_parent(hbFont.get()), newFont->baseFont().get());
+        EXPECT_NE(hbFont.get(), newFont->baseFont().get());
+        unsigned int length;
+        const float* coords = hb_font_get_var_coords_design(hbFont.get(), &length);
+        ASSERT_EQ(2u, length);  // The test font has 'wght', 'ital' axes in this order
+        EXPECT_EQ(500, coords[0]);
+        EXPECT_EQ(0, coords[1]);
+    }
+    {
+        // Set correct wight axis value.
+        auto hbFont = font->getAdjustedFont(-1, 1);
+        EXPECT_EQ(hb_font_get_parent(hbFont.get()), font->baseFont().get());
+        EXPECT_NE(hbFont.get(), font->baseFont().get());
+        unsigned int length;
+        const float* coords = hb_font_get_var_coords_design(hbFont.get(), &length);
+        ASSERT_EQ(2u, length);      // The test font has 'wght', 'ital' axes in this order
+        EXPECT_EQ(400, coords[0]);  // 400 is a default value of `wght` axis
+        EXPECT_EQ(1, coords[1]);
+    }
+    {
+        // Override existing wght axis.
+        std::shared_ptr<Font> newFont = Font::Builder(font->getAdjustedTypeface(-1, 0)).build();
+        auto hbFont = newFont->getAdjustedFont(-1, 1);
+        EXPECT_EQ(hb_font_get_parent(hbFont.get()), newFont->baseFont().get());
+        EXPECT_NE(hbFont.get(), newFont->baseFont().get());
+        unsigned int length;
+        const float* coords = hb_font_get_var_coords_design(hbFont.get(), &length);
+        ASSERT_EQ(2u, length);      // The test font has 'wght', 'ital' axes in this order
+        EXPECT_EQ(400, coords[0]);  // 400 is a default value of `wght` axis
+        EXPECT_EQ(1, coords[1]);
+    }
+    {
+        // Set correct wight axis value.
+        auto hbFont = font->getAdjustedFont(500, 1);
+        EXPECT_EQ(hb_font_get_parent(hbFont.get()), font->baseFont().get());
+        EXPECT_NE(hbFont.get(), font->baseFont().get());
+        unsigned int length;
+        const float* coords = hb_font_get_var_coords_design(hbFont.get(), &length);
+        ASSERT_EQ(2u, length);  // The test font has 'wght', 'ital' axes in this order
+        EXPECT_EQ(500, coords[0]);
+        EXPECT_EQ(1, coords[1]);
+    }
+    {
+        // Override existing wght axis.
+        std::shared_ptr<Font> newFont = Font::Builder(font->getAdjustedTypeface(500, 1)).build();
+        auto hbFont = newFont->getAdjustedFont(700, 0);
+        EXPECT_EQ(hb_font_get_parent(hbFont.get()), newFont->baseFont().get());
+        EXPECT_NE(hbFont.get(), newFont->baseFont().get());
+        unsigned int length;
+        const float* coords = hb_font_get_var_coords_design(hbFont.get(), &length);
+        ASSERT_EQ(2u, length);  // The test font has 'wght', 'ital' axes in this order
+        EXPECT_EQ(700, coords[0]);
+        EXPECT_EQ(0, coords[1]);
+    }
+}
+
+TEST(FontTest, getAdjustedTypefaceTest) {
+    FreeTypeMinikinFontForTestFactory::init();
+    auto minikinFont = std::make_shared<FreeTypeMinikinFontForTest>(
+            getTestFontPath("WeightEqualsEmVariableFont.ttf"));
+    std::shared_ptr<Font> font = Font::Builder(minikinFont).build();
+
+    {
+        auto minikinFontBase = font->getAdjustedTypeface(-1, -1);
+        EXPECT_EQ(minikinFontBase.get(), font->baseTypeface().get());
+    }
+    {
+        // Set correct wght axis value.
+        auto minikinFontBase = font->getAdjustedTypeface(400, -1);
+        EXPECT_NE(minikinFontBase.get(), font->baseTypeface().get());
+        auto axes = minikinFontBase->GetAxes();
+        ASSERT_EQ(1u, axes.size());
+        EXPECT_EQ(TAG_wght, axes[0].axisTag);
+        EXPECT_EQ(400, axes[0].value);
+    }
+    {
+        // Override existing wght axis.
+        std::shared_ptr<Font> newFont = Font::Builder(font->getAdjustedTypeface(700, -1)).build();
+        auto minikinFontBase = newFont->getAdjustedTypeface(500, -1);
+        EXPECT_NE(minikinFontBase.get(), font->baseTypeface().get());
+        auto axes = minikinFontBase->GetAxes();
+        ASSERT_EQ(1u, axes.size());
+        EXPECT_EQ(TAG_wght, axes[0].axisTag);
+        EXPECT_EQ(500, axes[0].value);
+    }
+    {
+        // Set correct wght axis value.
+        auto minikinFontBase = font->getAdjustedTypeface(-1, 1);
+        EXPECT_NE(minikinFontBase.get(), font->baseTypeface().get());
+        auto axes = minikinFontBase->GetAxes();
+        ASSERT_EQ(1u, axes.size());
+        EXPECT_EQ(TAG_ital, axes[0].axisTag);
+        EXPECT_EQ(1, axes[0].value);
+    }
+    {
+        // Override existing wght axis.
+        std::shared_ptr<Font> newFont = Font::Builder(font->getAdjustedTypeface(-1, 1)).build();
+        auto minikinFontBase = newFont->getAdjustedTypeface(-1, 0);
+        EXPECT_NE(minikinFontBase.get(), font->baseTypeface().get());
+        auto axes = minikinFontBase->GetAxes();
+        ASSERT_EQ(1u, axes.size());
+        EXPECT_EQ(TAG_ital, axes[0].axisTag);
+        EXPECT_EQ(0, axes[0].value);
+    }
+    {
+        // Set correct ital axis value.
+        auto minikinFontBase = font->getAdjustedTypeface(400, 1);
+        EXPECT_NE(minikinFontBase.get(), font->baseTypeface().get());
+        auto axes = minikinFontBase->GetAxes();
+        ASSERT_EQ(2u, axes.size());
+        EXPECT_EQ(TAG_wght, axes[0].axisTag);
+        EXPECT_EQ(TAG_ital, axes[1].axisTag);
+        EXPECT_EQ(400, axes[0].value);
+        EXPECT_EQ(1, axes[1].value);
+    }
+    {
+        // Override existing ital axis.
+        std::shared_ptr<Font> newFont = Font::Builder(font->getAdjustedTypeface(500, 0)).build();
+        auto minikinFontBase = newFont->getAdjustedTypeface(700, 1);
+        EXPECT_NE(minikinFontBase.get(), font->baseTypeface().get());
+        auto axes = minikinFontBase->GetAxes();
+        ASSERT_EQ(2u, axes.size());
+        EXPECT_EQ(TAG_wght, axes[0].axisTag);
+        EXPECT_EQ(TAG_ital, axes[1].axisTag);
+        EXPECT_EQ(700, axes[0].value);
+        EXPECT_EQ(1, axes[1].value);
+    }
+}
+
 }  // namespace minikin
diff --git a/tests/unittest/GreedyLineBreakerTest.cpp b/tests/unittest/GreedyLineBreakerTest.cpp
index e51ff83..4e1f146 100644
--- a/tests/unittest/GreedyLineBreakerTest.cpp
+++ b/tests/unittest/GreedyLineBreakerTest.cpp
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <memory>
-
+#include <com_android_text_flags.h>
+#include <flag_macros.h>
 #include <gtest/gtest.h>
 
-#include "minikin/Hyphenator.h"
+#include <memory>
 
 #include "FileUtils.h"
 #include "FontTestUtils.h"
@@ -29,6 +29,7 @@
 #include "MinikinInternal.h"
 #include "UnicodeUtils.h"
 #include "WordBreaker.h"
+#include "minikin/Hyphenator.h"
 
 namespace minikin {
 namespace {
@@ -47,6 +48,17 @@ constexpr float DESCENT = 20.0f;
 constexpr float CUSTOM_ASCENT = -160.0f;
 constexpr float CUSTOM_DESCENT = 40.0f;
 
+// A test string for Japanese. The meaning is that "Today is a sunny day."
+// The expected line break of phrase and non-phrase cases are:
+//     Phrase: | \u672C\u65E5\u306F | \u6674\u5929\u306A\u308A\u3002 |
+// Non-Phrase: | \u672C | \u65E5 | \u306F | \u6674 | \u5929 | \u306A | \u308A\u3002 |
+const char* JP_TEXT = "\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002";
+
+// A test string for Korean. The meaning is that "I want to eat breakfast."
+// The phrase based line break breaks at spaces, non-phrase based line break breaks at grapheme.
+const char* KO_TEXT =
+        "\uC544\uCE68\uBC25\uC744\u0020\uBA39\uACE0\u0020\uC2F6\uC2B5\uB2C8\uB2E4\u002E";
+
 class GreedyLineBreakerTest : public testing::Test {
 public:
     GreedyLineBreakerTest() {}
@@ -69,6 +81,48 @@ protected:
         return doLineBreak(textBuffer, doHyphenation, "en-US", lineWidth);
     }
 
+    LineBreakResult doLineBreakForJapanese(const U16StringPiece& textBuffer,
+                                           LineBreakWordStyle lbwStyle, const std::string& lang,
+                                           float lineWidth) {
+        MeasuredTextBuilder builder;
+        auto family = buildFontFamily("Japanese.ttf");
+        std::vector<std::shared_ptr<FontFamily>> families = {family};
+        auto fc = FontCollection::create(families);
+        MinikinPaint paint(fc);
+        paint.size = 10.0f;  // Make 1em=10px
+        paint.localeListId = LocaleListCache::getId(lang);
+        builder.addStyleRun(0, textBuffer.size(), std::move(paint), (int)LineBreakStyle::None,
+                            (int)lbwStyle, true, false);
+        std::unique_ptr<MeasuredText> measuredText = builder.build(
+                textBuffer, false /* compute hyphenation */, false /* compute full layout */,
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
+        RectangleLineWidth rectangleLineWidth(lineWidth);
+        TabStops tabStops(nullptr, 0, 10);
+        return breakLineGreedy(textBuffer, *measuredText, rectangleLineWidth, tabStops, false,
+                               false);
+    }
+
+    LineBreakResult doLineBreakForKorean(const U16StringPiece& textBuffer,
+                                         LineBreakWordStyle lbwStyle, const std::string& lang,
+                                         float lineWidth) {
+        MeasuredTextBuilder builder;
+        auto family = buildFontFamily("Hangul.ttf");
+        std::vector<std::shared_ptr<FontFamily>> families = {family};
+        auto fc = FontCollection::create(families);
+        MinikinPaint paint(fc);
+        paint.size = 10.0f;  // Make 1em=10px
+        paint.localeListId = LocaleListCache::getId(lang);
+        builder.addStyleRun(0, textBuffer.size(), std::move(paint), (int)LineBreakStyle::None,
+                            (int)lbwStyle, true, false);
+        std::unique_ptr<MeasuredText> measuredText = builder.build(
+                textBuffer, false /* compute hyphenation */, false /* compute full layout */,
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
+        RectangleLineWidth rectangleLineWidth(lineWidth);
+        TabStops tabStops(nullptr, 0, 10);
+        return breakLineGreedy(textBuffer, *measuredText, rectangleLineWidth, tabStops, false,
+                               false);
+    }
+
     LineBreakResult doLineBreak(const U16StringPiece& textBuffer, bool doHyphenation,
                                 const std::string& lang, float lineWidth) {
         MeasuredTextBuilder builder;
@@ -80,14 +134,74 @@ protected:
         paint.size = 10.0f;  // Make 1em=10px
         paint.localeListId = LocaleListCache::getId(lang);
         builder.addStyleRun(0, textBuffer.size(), std::move(paint), (int)LineBreakStyle::None,
-                            (int)LineBreakWordStyle::None, false);
+                            (int)LineBreakWordStyle::None, true, false);
+        std::unique_ptr<MeasuredText> measuredText = builder.build(
+                textBuffer, false /* compute hyphenation */, false /* compute full layout */,
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
+        RectangleLineWidth rectangleLineWidth(lineWidth);
+        TabStops tabStops(nullptr, 0, 10);
+        return breakLineGreedy(textBuffer, *measuredText, rectangleLineWidth, tabStops,
+                               doHyphenation, false);
+    }
+
+    LineBreakResult doLineBreakWithNoHyphenSpan(const U16StringPiece& textBuffer,
+                                                const Range& noHyphenRange, float lineWidth) {
+        MeasuredTextBuilder builder;
+        auto family1 = buildFontFamily("Ascii.ttf");
+        auto family2 = buildFontFamily("CustomExtent.ttf");
+        std::vector<std::shared_ptr<FontFamily>> families = {family1, family2};
+        auto fc = FontCollection::create(families);
+        if (noHyphenRange.getStart() != 0) {
+            MinikinPaint paint(fc);
+            paint.size = 10.0f;  // Make 1em=10px
+            paint.localeListId = LocaleListCache::getId("en-US");
+            builder.addStyleRun(0, noHyphenRange.getStart(), std::move(paint),
+                                (int)LineBreakStyle::None, (int)LineBreakWordStyle::None,
+                                true /* hyphenation */, false);
+        }
+        MinikinPaint paint(fc);
+        paint.size = 10.0f;  // Make 1em=10px
+        paint.localeListId = LocaleListCache::getId("en-US");
+        builder.addStyleRun(noHyphenRange.getStart(), noHyphenRange.getEnd(), std::move(paint),
+                            (int)LineBreakStyle::None, (int)LineBreakWordStyle::None,
+                            false /* hyphenation */, false);
+        if (noHyphenRange.getEnd() != textBuffer.size()) {
+            MinikinPaint paint(fc);
+            paint.size = 10.0f;  // Make 1em=10px
+            paint.localeListId = LocaleListCache::getId("en-US");
+            builder.addStyleRun(noHyphenRange.getEnd(), textBuffer.size(), std::move(paint),
+                                (int)LineBreakStyle::None, (int)LineBreakWordStyle::None,
+                                true /* hyphenation */, false);
+        }
+
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuffer, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(lineWidth);
         TabStops tabStops(nullptr, 0, 10);
         return breakLineGreedy(textBuffer, *measuredText, rectangleLineWidth, tabStops,
-                               doHyphenation);
+                               true /* doHyphenation */, false);
+    }
+
+    LineBreakResult doLineBreakForBounds(const U16StringPiece& textBuffer, bool doHyphenation,
+                                         float lineWidth) {
+        MeasuredTextBuilder builder;
+        auto family1 = buildFontFamily("OvershootTest.ttf");
+        auto family2 = buildFontFamily("Ascii.ttf");
+        std::vector<std::shared_ptr<FontFamily>> families = {family1, family2};
+        auto fc = FontCollection::create(families);
+        MinikinPaint paint(fc);
+        paint.size = 10.0f;  // Make 1em=10px
+        paint.localeListId = LocaleListCache::getId("en-US");
+        builder.addStyleRun(0, textBuffer.size(), std::move(paint), (int)LineBreakStyle::None,
+                            (int)LineBreakWordStyle::None, true, false);
+        std::unique_ptr<MeasuredText> measuredText = builder.build(
+                textBuffer, false /* compute hyphenation */, false /* compute full layout */,
+                true /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
+        RectangleLineWidth rectangleLineWidth(lineWidth);
+        TabStops tabStops(nullptr, 0, 10);
+        return breakLineGreedy(textBuffer, *measuredText, rectangleLineWidth, tabStops,
+                               doHyphenation, true);
     }
 
 private:
@@ -106,18 +220,19 @@ TEST_F(GreedyLineBreakerTest, roundingError) {
     paint.localeListId = LocaleListCache::getId("en-US");
     const std::vector<uint16_t> textBuffer = utf8ToUtf16("8888888888888888888");
 
-    float measured = Layout::measureText(textBuffer, Range(0, textBuffer.size()), Bidi::LTR, paint,
-                                         StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, nullptr);
+    float measured =
+            Layout::measureText(textBuffer, Range(0, textBuffer.size()), Bidi::LTR, paint,
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, nullptr, nullptr);
 
     builder.addStyleRun(0, textBuffer.size(), std::move(paint), (int)LineBreakStyle::None,
-                        (int)LineBreakWordStyle::None, false);
+                        (int)LineBreakWordStyle::None, true, false);
     std::unique_ptr<MeasuredText> measuredText = builder.build(
             textBuffer, false /* compute hyphenation */, false /* compute full layout */,
-            false /* ignore kerning */, nullptr /* no hint */);
+            false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
     RectangleLineWidth rectangleLineWidth(measured);
     TabStops tabStops(nullptr, 0, 10);
     LineBreakResult r = breakLineGreedy(textBuffer, *measuredText, rectangleLineWidth, tabStops,
-                                        false /* do hyphenation */);
+                                        false /* do hyphenation */, false /* useBoundsForWidth */);
 
     EXPECT_EQ(1u, r.breakPoints.size());
 }
@@ -707,11 +822,11 @@ TEST_F(GreedyLineBreakerTest, testZeroWidthCharacter) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(LINE_WIDTH);
         TabStops tabStops(nullptr, 0, 10);
-        const auto actual =
-                breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        const auto actual = breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops,
+                                            DO_HYPHEN, false /* useBoundsForWidth */);
         EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
                                                    << " vs " << std::endl
                                                    << toString(textBuf, actual);
@@ -727,11 +842,11 @@ TEST_F(GreedyLineBreakerTest, testZeroWidthCharacter) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(LINE_WIDTH);
         TabStops tabStops(nullptr, 0, 10);
-        const auto actual =
-                breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        const auto actual = breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops,
+                                            DO_HYPHEN, false /* useBoundsForWidth */);
         EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
                                                    << " vs " << std::endl
                                                    << toString(textBuf, actual);
@@ -758,12 +873,12 @@ TEST_F(GreedyLineBreakerTest, testLocaleSwitchTest) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(LINE_WIDTH);
         TabStops tabStops(nullptr, 0, 0);
 
-        const auto actual =
-                breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        const auto actual = breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops,
+                                            DO_HYPHEN, false /* useBoundsForWidth */);
         EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
                                                    << " vs " << std::endl
                                                    << toString(textBuf, actual);
@@ -779,12 +894,12 @@ TEST_F(GreedyLineBreakerTest, testLocaleSwitchTest) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(LINE_WIDTH);
         TabStops tabStops(nullptr, 0, 0);
 
-        const auto actual =
-                breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        const auto actual = breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops,
+                                            DO_HYPHEN, false /* useBoundsForWidth */);
         EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
                                                    << " vs " << std::endl
                                                    << toString(textBuf, actual);
@@ -843,12 +958,12 @@ TEST_F(GreedyLineBreakerTest, testLocaleSwitch_InEmailOrUrl) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(LINE_WIDTH);
         TabStops tabStops(nullptr, 0, 0);
 
-        const auto actual =
-                breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        const auto actual = breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops,
+                                            DO_HYPHEN, false /* useBoundsForWidth */);
         EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
                                                    << " vs " << std::endl
                                                    << toString(textBuf, actual);
@@ -866,12 +981,12 @@ TEST_F(GreedyLineBreakerTest, testLocaleSwitch_InEmailOrUrl) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(LINE_WIDTH);
         TabStops tabStops(nullptr, 0, 0);
 
-        const auto actual =
-                breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        const auto actual = breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops,
+                                            DO_HYPHEN, false /* useBoundsForWidth */);
         EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
                                                    << " vs " << std::endl
                                                    << toString(textBuf, actual);
@@ -897,12 +1012,12 @@ TEST_F(GreedyLineBreakerTest, CrashFix_Space_Tab) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(LINE_WIDTH);
         TabStops tabStops(nullptr, 0, CHAR_WIDTH);
 
-        const auto actual =
-                breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        const auto actual = breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops,
+                                            DO_HYPHEN, false /* useBoundsForWidth */);
         EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
                                                    << " vs " << std::endl
                                                    << toString(textBuf, actual);
@@ -1066,10 +1181,11 @@ TEST_F(GreedyLineBreakerTest, testReplacementSpanNotBreakTest_SingleChar) {
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
-        return breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        return breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN,
+                               false /* useBoundsForWidth */);
     };
 
     {
@@ -1161,10 +1277,11 @@ TEST_F(GreedyLineBreakerTest, testReplacementSpanNotBreakTest_MultipleChars) {
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
-        return breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        return breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN,
+                               false /* useBoundsForWidth */);
     };
 
     {
@@ -1249,10 +1366,11 @@ TEST_F(GreedyLineBreakerTest, testReplacementSpanNotBreakTest_CJK) {
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
-        return breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        return breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN,
+                               false /* useBoundsForWidth */);
     };
 
     {
@@ -1400,10 +1518,11 @@ TEST_F(GreedyLineBreakerTest, testReplacementSpanNotBreakTest_with_punctuation)
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
-        return breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN);
+        return breakLineGreedy(textBuf, *measuredText, rectangleLineWidth, tabStops, DO_HYPHEN,
+                               false /* useBoundsForWidth */);
     };
 
     {
@@ -1589,5 +1708,600 @@ TEST_F(GreedyLineBreakerTest, testControllCharAfterSpace) {
                                                    << toString(textBuf, actual);
     }
 }
+
+TEST_F(GreedyLineBreakerTest, testBreakWithoutBounds_trail) {
+    // The OvershootTest.ttf has following coverage, extent, width and bbox.
+    // U+0061(a): 1em, (   0, 0) - (1,   1)
+    // U+0062(b): 1em, (   0, 0) - (1.5, 1)
+    // U+0063(c): 1em, (   0, 0) - (2,   1)
+    // U+0064(d): 1em, (   0, 0) - (2.5, 1)
+    // U+0065(e): 1em, (-0.5, 0) - (1,   1)
+    // U+0066(f): 1em, (-1.0, 0) - (1,   1)
+    // U+0067(g): 1em, (-1.5, 0) - (1,   1)
+    constexpr bool NO_HYPHEN = false;  // No hyphenation in this test case.
+
+    const std::vector<uint16_t> textBuf = utf8ToUtf16("dddd dddd dddd dddd");
+    constexpr StartHyphenEdit NO_START_HYPHEN = StartHyphenEdit::NO_EDIT;
+    constexpr EndHyphenEdit NO_END_HYPHEN = EndHyphenEdit::NO_EDIT;
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        constexpr float LINE_WIDTH = 1000;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"dddd dddd dddd dddd", 190, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, NO_HYPHEN, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(0, 10, 205, 0), actual.bounds[0]);
+    }
+    {
+        constexpr float LINE_WIDTH = 110;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"dddd dddd ", 90, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"dddd dddd", 90, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, NO_HYPHEN, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(0, 10, 105, 0), actual.bounds[0]);
+        EXPECT_EQ(MinikinRect(0, 10, 105, 0), actual.bounds[1]);
+    }
+    {
+        constexpr float LINE_WIDTH = 100;
+        // Even if the total advance of "dddd dddd" is 90, the width of bounding box of "dddd dddd"
+        // is
+        // Rect(0em, 1em, 10.5em, 0em). So "dddd dddd" is broken into two lines.
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"dddd ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"dddd ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"dddd ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"dddd", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, NO_HYPHEN, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(0, 10, 55, 0), actual.bounds[0]);
+        EXPECT_EQ(MinikinRect(0, 10, 55, 0), actual.bounds[1]);
+        EXPECT_EQ(MinikinRect(0, 10, 55, 0), actual.bounds[2]);
+        EXPECT_EQ(MinikinRect(0, 10, 55, 0), actual.bounds[3]);
+    }
+}
+
+TEST_F(GreedyLineBreakerTest, testBreakWithoutBounds_preceding) {
+    // The OvershootTest.ttf has following coverage, extent, width and bbox.
+    // U+0061(a): 1em, (   0, 0) - (1,   1)
+    // U+0062(b): 1em, (   0, 0) - (1.5, 1)
+    // U+0063(c): 1em, (   0, 0) - (2,   1)
+    // U+0064(d): 1em, (   0, 0) - (2.5, 1)
+    // U+0065(e): 1em, (-0.5, 0) - (1,   1)
+    // U+0066(f): 1em, (-1.0, 0) - (1,   1)
+    // U+0067(g): 1em, (-1.5, 0) - (1,   1)
+    constexpr bool NO_HYPHEN = false;  // No hyphenation in this test case.
+
+    const std::vector<uint16_t> textBuf = utf8ToUtf16("gggg gggg gggg gggg");
+    constexpr StartHyphenEdit NO_START_HYPHEN = StartHyphenEdit::NO_EDIT;
+    constexpr EndHyphenEdit NO_END_HYPHEN = EndHyphenEdit::NO_EDIT;
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        constexpr float LINE_WIDTH = 1000;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"gggg gggg gggg gggg", 190, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, NO_HYPHEN, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(-15, 10, 190, 0), actual.bounds[0]);
+    }
+    {
+        constexpr float LINE_WIDTH = 110;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"gggg gggg ", 90, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"gggg gggg" , 90, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, NO_HYPHEN, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(-15, 10, 90, 0), actual.bounds[0]);
+        EXPECT_EQ(MinikinRect(-15, 10, 90, 0), actual.bounds[1]);
+    }
+    {
+        constexpr float LINE_WIDTH = 100;
+        // Even if the total advance of "dddd dddd" is 90, the width of bounding box of "dddd dddd"
+        // is
+        // Rect(0em, 1em, 10.5em, 0em). So "dddd dddd" is broken into two lines.
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"gggg ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"gggg ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"gggg ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"gggg" , 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, NO_HYPHEN, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(-15, 10, 40, 0), actual.bounds[0]);
+        EXPECT_EQ(MinikinRect(-15, 10, 40, 0), actual.bounds[1]);
+        EXPECT_EQ(MinikinRect(-15, 10, 40, 0), actual.bounds[2]);
+        EXPECT_EQ(MinikinRect(-15, 10, 40, 0), actual.bounds[3]);
+    }
+}
+
+TEST_F(GreedyLineBreakerTest, testBreakWithHyphenation_NoHyphenationSpan) {
+    // "hyphenation" is hyphnated to "hy-phen-a-tion".
+    const std::vector<uint16_t> textBuf = utf8ToUtf16("This is Android. Here is hyphenation.");
+    const Range noHyphenRange(25, 37);  // the range of the word "hyphenation".
+
+    constexpr StartHyphenEdit NO_START_HYPHEN = StartHyphenEdit::NO_EDIT;
+    constexpr EndHyphenEdit END_HYPHEN = EndHyphenEdit::INSERT_HYPHEN;
+    constexpr EndHyphenEdit NO_END_HYPHEN = EndHyphenEdit::NO_EDIT;
+
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                { "This is "  , 70, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                { "Android. " , 80, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                { "Here is "  , 70, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                { "hyphena-"  , 80, NO_START_HYPHEN,    END_HYPHEN, ASCENT, DESCENT },
+                { "tion."    , 50, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+        };
+        // clang-format on
+
+        const auto actual = doLineBreak(textBuf, true /* do hyphenation */, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                { "This is "   , 70, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                { "Android. "  , 80, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                { "Here is "   , 70, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                // Prevent hyphenation of "hyphenation". Fallback to desperate break.
+                { "hyphenatio" ,100, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                { "n."         , 20, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakWithNoHyphenSpan(textBuf, noHyphenRange, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+}
+
+TEST_F_WITH_FLAGS(GreedyLineBreakerTest, testPhraseBreakNone,
+                  REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                      word_style_auto))) {
+    // For short hand of writing expectation for lines.
+    auto line = [](std::string t, float w) -> LineBreakExpectation {
+        return {t, w, StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, ASCENT, DESCENT};
+    };
+
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 1));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002" , 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 2));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5" , 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002" , 60),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 3));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002", 40),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 4));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002"  , 20),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 5));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 100),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 6));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 100),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+}
+
+TEST_F_WITH_FLAGS(GreedyLineBreakerTest, testPhraseBreakPhrase,
+                  REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                      word_style_auto))) {
+    // For short hand of writing expectation for lines.
+    auto line = [](std::string t, float w) -> LineBreakExpectation {
+        return {t, w, StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, ASCENT, DESCENT};
+    };
+
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 1));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 2));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 3));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 4));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 5));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 6));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+}
+
+TEST_F_WITH_FLAGS(GreedyLineBreakerTest, testPhraseBreakAuto,
+                  REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                      word_style_auto))) {
+    // For short hand of writing expectation for lines.
+    auto line = [](std::string t, float w) -> LineBreakExpectation {
+        return {t, w, StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, ASCENT, DESCENT};
+    };
+
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 1));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 2));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 3));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 4));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    // When the line becomes more or equal to 5, the phrase based line break is disabled.
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 5));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 100),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 6));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 100),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002"  , 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+}
+
+TEST_F_WITH_FLAGS(GreedyLineBreakerTest, testPhraseBreak_Korean,
+                  REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                      word_style_auto))) {
+    // For short hand of writing expectation for lines.
+    auto line = [](std::string t, float w) -> LineBreakExpectation {
+        return {t, w, StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, ASCENT, DESCENT};
+    };
+
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        SCOPED_TRACE("LineBreakWOrdStyle::None should break with grapheme bounds");
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(KO_TEXT);
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\uC544\uCE68\uBC25\uC744\u0020\uBA39\uACE0\u0020\uC2F6\uC2B5", 100),
+                line("\uB2C8\uB2E4\u002E", 30),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForKorean(textBuf, LineBreakWordStyle::None, "ko-KR", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        SCOPED_TRACE("LineBreakWOrdStyle::Phrase should break with spaces");
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(KO_TEXT);
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\uC544\uCE68\uBC25\uC744\u0020\uBA39\uACE0\u0020", 70),
+                line("\uC2F6\uC2B5\uB2C8\uB2E4\u002E", 50),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForKorean(textBuf, LineBreakWordStyle::Phrase, "ko-KR", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        SCOPED_TRACE("LineBreakWOrdStyle::Auto should perform as phrase based line break.");
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(KO_TEXT);
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\uC544\uCE68\uBC25\uC744\u0020\uBA39\uACE0\u0020", 70),
+                line("\uC2F6\uC2B5\uB2C8\uB2E4\u002E", 50),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForKorean(textBuf, LineBreakWordStyle::Auto, "ko-KR", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+}
+
 }  // namespace
 }  // namespace minikin
diff --git a/tests/unittest/LayoutCacheTest.cpp b/tests/unittest/LayoutCacheTest.cpp
index e0dd5f3..5d20456 100644
--- a/tests/unittest/LayoutCacheTest.cpp
+++ b/tests/unittest/LayoutCacheTest.cpp
@@ -36,12 +36,18 @@ class LayoutCapture {
 public:
     LayoutCapture() {}
 
-    void operator()(const LayoutPiece& layout, const MinikinPaint& /* dir */) { mLayout = &layout; }
+    void operator()(const LayoutPiece& layout, const MinikinPaint& /* dir */,
+                    const MinikinRect& bounds) {
+        mLayout = &layout;
+        mBounds = bounds;
+    }
 
     const LayoutPiece* get() const { return mLayout; }
+    const MinikinRect& bounds() const { return mBounds; }
 
 private:
     const LayoutPiece* mLayout;
+    MinikinRect mBounds;
 };
 
 TEST(LayoutCacheTest, cacheHitTest) {
@@ -53,11 +59,11 @@ TEST(LayoutCacheTest, cacheHitTest) {
 
     LayoutCapture layout1;
     layoutCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, layout1);
+                            EndHyphenEdit::NO_EDIT, false, layout1);
 
     LayoutCapture layout2;
     layoutCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, layout2);
+                            EndHyphenEdit::NO_EDIT, false, layout2);
 
     EXPECT_EQ(layout1.get(), layout2.get());
 }
@@ -75,59 +81,61 @@ TEST(LayoutCacheTest, cacheMissTest) {
     {
         SCOPED_TRACE("Different text");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         layoutCache.getOrCreate(text2, Range(0, text2.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
         SCOPED_TRACE("Different range");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         layoutCache.getOrCreate(text1, Range(1, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
         SCOPED_TRACE("Different text");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         layoutCache.getOrCreate(text2, Range(0, text2.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
         SCOPED_TRACE("Different direction");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, true /* RTL */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
         SCOPED_TRACE("Different start hyphenation");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::INSERT_HYPHEN, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::INSERT_HYPHEN, EndHyphenEdit::NO_EDIT, false,
+                                layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
         SCOPED_TRACE("Different end hyphen");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::INSERT_HYPHEN, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::INSERT_HYPHEN, false,
+                                layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
         SCOPED_TRACE("Different collection");
         MinikinPaint paint1(buildFontCollection("Ascii.ttf"));
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(buildFontCollection("Emoji.ttf"));
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
@@ -136,11 +144,11 @@ TEST(LayoutCacheTest, cacheMissTest) {
         MinikinPaint paint1(collection);
         paint1.size = 10.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
         paint2.size = 20.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
@@ -149,11 +157,11 @@ TEST(LayoutCacheTest, cacheMissTest) {
         MinikinPaint paint1(collection);
         paint1.scaleX = 1.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
         paint2.scaleX = 2.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
@@ -162,11 +170,11 @@ TEST(LayoutCacheTest, cacheMissTest) {
         MinikinPaint paint1(collection);
         paint1.skewX = 1.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
         paint2.skewX = 2.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
@@ -175,11 +183,11 @@ TEST(LayoutCacheTest, cacheMissTest) {
         MinikinPaint paint1(collection);
         paint1.letterSpacing = 0.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
         paint2.letterSpacing = 1.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
@@ -188,11 +196,11 @@ TEST(LayoutCacheTest, cacheMissTest) {
         MinikinPaint paint1(collection);
         paint1.wordSpacing = 0.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
         paint2.wordSpacing = 1.0f;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
@@ -201,11 +209,11 @@ TEST(LayoutCacheTest, cacheMissTest) {
         MinikinPaint paint1(collection);
         paint1.fontFlags = 0;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
         paint2.fontFlags = LinearMetrics_Flag;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
@@ -214,11 +222,11 @@ TEST(LayoutCacheTest, cacheMissTest) {
         MinikinPaint paint1(collection);
         paint1.localeListId = LocaleListCache::getId("en-US");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
         paint2.localeListId = LocaleListCache::getId("ja-JP");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
@@ -227,24 +235,24 @@ TEST(LayoutCacheTest, cacheMissTest) {
         MinikinPaint paint1(collection);
         paint1.familyVariant = FamilyVariant::DEFAULT;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
         paint2.familyVariant = FamilyVariant::COMPACT;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
     {
         SCOPED_TRACE("Different font feature settings");
         auto collection = buildFontCollection("Ascii.ttf");
         MinikinPaint paint1(collection);
-        paint1.fontFeatureSettings = "";
+        paint1.fontFeatureSettings = FontFeature::parse("");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout1);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout1);
         MinikinPaint paint2(collection);
-        paint2.fontFeatureSettings = "'liga' on";
+        paint2.fontFeatureSettings = FontFeature::parse("'liga' on");
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
         EXPECT_NE(layout1.get(), layout2.get());
     }
 }
@@ -258,18 +266,18 @@ TEST(LayoutCacheTest, cacheOverflowTest) {
 
     LayoutCapture layout1;
     layoutCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, layout1);
+                            EndHyphenEdit::NO_EDIT, false, layout1);
 
     for (char c = 'a'; c <= 'z'; c++) {
         auto text1 = utf8ToUtf16(std::string(10, c));
         LayoutCapture layout2;
         layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
-                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, layout2);
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, false, layout2);
     }
 
     LayoutCapture layout3;
     layoutCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, layout3);
+                            EndHyphenEdit::NO_EDIT, false, layout3);
     EXPECT_NE(layout1.get(), layout3.get());
 }
 
@@ -282,9 +290,45 @@ TEST(LayoutCacheTest, cacheLengthLimitTest) {
 
     LayoutCapture layout;
     layoutCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
-                            EndHyphenEdit::NO_EDIT, layout);
+                            EndHyphenEdit::NO_EDIT, false, layout);
 
     EXPECT_EQ(layoutCache.getCacheSize(), 0u);
 }
 
+TEST(LayoutCacheTest, boundsCalculation) {
+    auto text1 = utf8ToUtf16("android");
+    MinikinPaint paint(buildFontCollection("Ascii.ttf"));
+
+    TestableLayoutCache layoutCache(10);
+
+    LayoutCapture layout1;
+    LayoutCapture layout2;
+
+    {
+        SCOPED_TRACE("Bounds calculation should be treated different layout cache entry");
+        layoutCache.clear();
+        layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT,
+                                false /* calculateBounds */, layout1);
+        layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT,
+                                true /* calculateBounds */, layout2);
+        EXPECT_NE(layout1.get(), layout2.get());
+        EXPECT_FALSE(layout1.bounds().isValid());
+        EXPECT_TRUE(layout2.bounds().isValid());
+    }
+    {
+        SCOPED_TRACE("Bounds calculated entry can be used for the non-bounds request.");
+        layoutCache.clear();
+        layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT,
+                                true /* calculateBounds */, layout1);
+        layoutCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
+                                StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT,
+                                false /* calculateBounds */, layout2);
+        EXPECT_EQ(layout1.get(), layout2.get());
+        EXPECT_TRUE(layout1.bounds().isValid());
+    }
+}
+
 }  // namespace minikin
diff --git a/tests/unittest/LayoutCoreTest.cpp b/tests/unittest/LayoutCoreTest.cpp
index 4edc556..264454a 100644
--- a/tests/unittest/LayoutCoreTest.cpp
+++ b/tests/unittest/LayoutCoreTest.cpp
@@ -39,11 +39,22 @@ static LayoutPiece buildLayout(const std::string& text, std::shared_ptr<FontColl
     return buildLayout(text, paint);
 }
 
+static std::pair<LayoutPiece, MinikinRect> buildLayoutAndBounds(
+        const std::string& text, std::shared_ptr<FontCollection> fc) {
+    MinikinPaint paint(fc);
+    paint.size = 10.0f;  // make 1em = 10px
+    auto utf16 = utf8ToUtf16(text);
+    LayoutPiece lp = LayoutPiece(utf16, Range(0, utf16.size()), false /* rtl */, paint,
+                                 StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
+    MinikinRect rect = LayoutPiece::calculateBounds(lp, paint);
+    return std::make_pair(lp, rect);
+}
+
 static LayoutPiece buildLayout(const std::string& text, std::shared_ptr<FontCollection> fc,
                                const std::string fontFeaturesSettings) {
     MinikinPaint paint(fc);
     paint.size = 10.0f;  // make 1em = 10px
-    paint.fontFeatureSettings = fontFeaturesSettings;
+    paint.fontFeatureSettings = FontFeature::parse(fontFeaturesSettings);
     return buildLayout(text, paint);
 }
 
@@ -250,5 +261,68 @@ TEST(LayoutPieceTest, doLayoutTest_Ligature) {
     }
 }
 
+TEST(LayoutPieceTest, doLayoutTest_Overshoot) {
+    // See doLayoutTest for the details of OvershootTest.ttf
+    // The OvershootTest.ttf has following coverage, extent, width and bbox.
+    // U+0061: 1em, (   0, 0) - (1,   1)
+    // U+0062: 1em, (   0, 0) - (1.5, 1)
+    // U+0063: 1em, (   0, 0) - (2,   1)
+    // U+0064: 1em, (   0, 0) - (2.5, 1)
+    // U+0065: 1em, (-0.5, 0) - (1,   1)
+    // U+0066: 1em, (-1.0, 0) - (1,   1)
+    // U+0067: 1em, (-1.5, 0) - (1,   1)
+    auto fc = makeFontCollection({"OvershootTest.ttf"});
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("a", fc);
+        EXPECT_EQ(1u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(0, 10, 10, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("b", fc);
+        EXPECT_EQ(1u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(0, 10, 15, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("c", fc);
+        EXPECT_EQ(1u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(0, 10, 20, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("d", fc);
+        EXPECT_EQ(1u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(0, 10, 25, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("e", fc);
+        EXPECT_EQ(1u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(-5, 10, 10, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("f", fc);
+        EXPECT_EQ(1u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(-10, 10, 10, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("g", fc);
+        EXPECT_EQ(1u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(-15, 10, 10, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("ag", fc);
+        EXPECT_EQ(2u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(-5, 10, 20, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("ga", fc);
+        EXPECT_EQ(2u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(-15, 10, 20, 0), bounds);
+    }
+    {
+        auto [layout, bounds] = buildLayoutAndBounds("dg", fc);
+        EXPECT_EQ(2u, layout.glyphCount());
+        EXPECT_EQ(MinikinRect(-5, 10, 25, 0), bounds);
+    }
+}
+
 }  // namespace
 }  // namespace minikin
diff --git a/tests/unittest/LayoutTest.cpp b/tests/unittest/LayoutTest.cpp
index 7771051..4f292b6 100644
--- a/tests/unittest/LayoutTest.cpp
+++ b/tests/unittest/LayoutTest.cpp
@@ -449,7 +449,7 @@ TEST_F(LayoutTest, measuredTextTest) {
         std::vector<float> advances(text.size());
         Range range(0, text.size());
         EXPECT_EQ(1.0f, Layout::measureText(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
-                                            EndHyphenEdit::NO_EDIT, advances.data()));
+                                            EndHyphenEdit::NO_EDIT, advances.data(), nullptr));
         ASSERT_EQ(1u, advances.size());
         EXPECT_EQ(1.0f, advances[0]);
     }
@@ -459,7 +459,7 @@ TEST_F(LayoutTest, measuredTextTest) {
         std::vector<float> advances(text.size());
         Range range(0, text.size());
         EXPECT_EQ(6.0f, Layout::measureText(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
-                                            EndHyphenEdit::NO_EDIT, advances.data()));
+                                            EndHyphenEdit::NO_EDIT, advances.data(), nullptr));
         ASSERT_EQ(2u, advances.size());
         EXPECT_EQ(1.0f, advances[0]);
         EXPECT_EQ(5.0f, advances[1]);
@@ -471,7 +471,7 @@ TEST_F(LayoutTest, measuredTextTest) {
         Range range(0, text.size());
         EXPECT_EQ(16.0f,
                   Layout::measureText(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
-                                      EndHyphenEdit::NO_EDIT, advances.data()));
+                                      EndHyphenEdit::NO_EDIT, advances.data(), nullptr));
         ASSERT_EQ(3u, advances.size());
         EXPECT_EQ(1.0f, advances[0]);
         EXPECT_EQ(5.0f, advances[1]);
diff --git a/tests/unittest/LineBreakerTestHelper.h b/tests/unittest/LineBreakerTestHelper.h
index 5a86175..cb1d161 100644
--- a/tests/unittest/LineBreakerTestHelper.h
+++ b/tests/unittest/LineBreakerTestHelper.h
@@ -53,10 +53,12 @@ public:
 
     virtual bool isRtl() const override { return false; }
     virtual bool canBreak() const override { return true; }
+    virtual bool canHyphenate() const override { return true; }
     virtual uint32_t getLocaleListId() const { return mLocaleListId; }
 
-    virtual void getMetrics(const U16StringPiece&, std::vector<float>* advances, LayoutPieces*,
-                            LayoutPieces*) const {
+    virtual void getMetrics(const U16StringPiece&, std::vector<float>* advances,
+                            std::vector<uint8_t>* /*flags*/, LayoutPieces*,
+                            bool /*boundsCalculation*/, LayoutPieces*) const {
         std::fill(advances->begin() + mRange.getStart(), advances->begin() + mRange.getEnd(),
                   mWidth);
     }
@@ -72,6 +74,12 @@ public:
         return {mAscent, mDescent};
     }
 
+    virtual LineMetrics getLineMetrics(const U16StringPiece& text, const Range& range,
+                                       const LayoutPieces& pieces) const {
+        auto [adv, rect] = getBounds(text, range, pieces);
+        return LineMetrics(getExtent(text, range, pieces), rect, adv);
+    }
+
     virtual const MinikinPaint* getPaint() const { return &mPaint; }
 
     virtual float measureHyphenPiece(const U16StringPiece&, const Range& range,
@@ -198,11 +206,13 @@ static std::string toString(const U16StringPiece& textBuf, const LineBreakResult
         if (isInsertion(endEdit)) {
             hyphenatedStr.push_back('-');
         }
-        char lineMsg[128] = {};
+        char lineMsg[256] = {};
         snprintf(lineMsg, sizeof(lineMsg),
-                 "Line %2d, Width: %5.1f, Hyphen(%hhu, %hhu), Extent(%5.1f, %5.1f), Text: \"%s\"\n",
+                 "Line %2d, Width: %5.1f, Hyphen(%hhu, %hhu), Extent(%5.1f, %5.1f), Bounds(%f, %f, "
+                 "%f, %f), Text: \"%s\"\n",
                  i, lines.widths[i], startEdit, endEdit, lines.ascents[i], lines.descents[i],
-                 hyphenatedStr.c_str());
+                 lines.bounds[i].mLeft, lines.bounds[i].mTop, lines.bounds[i].mRight,
+                 lines.bounds[i].mBottom, hyphenatedStr.c_str());
         out += lineMsg;
     }
     return out;
diff --git a/tests/unittest/MeasuredTextTest.cpp b/tests/unittest/MeasuredTextTest.cpp
index 845b5f1..b07ccf5 100644
--- a/tests/unittest/MeasuredTextTest.cpp
+++ b/tests/unittest/MeasuredTextTest.cpp
@@ -39,17 +39,19 @@ TEST(MeasuredTextTest, RunTests) {
 
     MinikinPaint paint1(font);
     paint1.size = 10.0f;  // make 1em = 10px
-    builder.addStyleRun(0, 2, std::move(paint1), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, 2, std::move(paint1), lbStyle, lbWordStyle, true /* can hyphenate */,
+                        false /* is RTL */);
     builder.addReplacementRun(2, 4, REPLACEMENT_WIDTH, 0 /* locale list id */);
     MinikinPaint paint2(font);
     paint2.size = 10.0f;  // make 1em = 10px
-    builder.addStyleRun(4, 6, std::move(paint2), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(4, 6, std::move(paint2), lbStyle, lbWordStyle, true /* can hyphenate */,
+                        false /* is RTL */);
 
     std::vector<uint16_t> text(CHAR_COUNT, 'a');
 
-    std::unique_ptr<MeasuredText> measuredText =
-            builder.build(text, true /* compute hyphenation */, false /* compute full layout */,
-                          false /* ignore kerning */, nullptr /* no hint */);
+    std::unique_ptr<MeasuredText> measuredText = builder.build(
+            text, true /* compute hyphenation */, false /* compute full layout */,
+            false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
 
     ASSERT_TRUE(measuredText);
 
@@ -69,9 +71,11 @@ TEST(MeasuredTextTest, getBoundsTest) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     EXPECT_EQ(MinikinRect(0.0f, 0.0f, 0.0f, 0.0f), mt->getBounds(text, Range(0, 0)));
     EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), mt->getBounds(text, Range(0, 1)));
@@ -89,9 +93,11 @@ TEST(MeasuredTextTest, getBoundsTest_LTR) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), mt->getBounds(text, Range(0, 1)));
 }
@@ -105,9 +111,11 @@ TEST(MeasuredTextTest, getBoundsTest_RTL) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle, true /* is RTL */);
+    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, true /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     EXPECT_EQ(MinikinRect(0.0f, 30.0f, 30.0f, 0.0f), mt->getBounds(text, Range(0, 2)));
 }
@@ -122,13 +130,15 @@ TEST(MeasuredTextTest, getBoundsTest_multiStyle) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, helloLength, std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, helloLength, std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     MinikinPaint paint2(font);
     paint2.size = 20.0f;
     builder.addStyleRun(helloLength, text.size(), std::move(paint2), lbStyle, lbWordStyle,
-                        false /* is RTL */);
+                        true /* can hyphenate */, false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     EXPECT_EQ(MinikinRect(0.0f, 0.0f, 0.0f, 0.0f), mt->getBounds(text, Range(0, 0)));
     EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), mt->getBounds(text, Range(0, 1)));
@@ -149,9 +159,11 @@ TEST(MeasuredTextTest, getExtentTest) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kernign */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kernign */,
+                            nullptr /* no hint */);
 
     EXPECT_EQ(MinikinExtent(0.0f, 0.0f), mt->getExtent(text, Range(0, 0)));
     EXPECT_EQ(MinikinExtent(-80.0f, 20.0f), mt->getExtent(text, Range(0, 1)));
@@ -170,13 +182,16 @@ TEST(MeasuredTextTest, getExtentTest_multiStyle) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, helloLength, std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, helloLength, std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     MinikinPaint paint2(font);
     paint2.size = 20.0f;
     builder.addStyleRun(helloLength, text.size(), std::move(paint2), 0 /* no line break */,
-                        0 /* no line break word style */, false /* is RTL */);
+                        0 /* no line break word style */, true /* can hyphenate */,
+                        false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     EXPECT_EQ(MinikinExtent(0.0f, 0.0f), mt->getExtent(text, Range(0, 0)));
     EXPECT_EQ(MinikinExtent(-80.0f, 20.0f), mt->getExtent(text, Range(0, 1)));
@@ -198,9 +213,11 @@ TEST(MeasuredTextTest, buildLayoutTest) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     MinikinRect rect;
     MinikinPaint samePaint(font);
@@ -280,13 +297,15 @@ TEST(MeasuredTextTest, buildLayoutTest_multiStyle) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, helloLength, std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, helloLength, std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     MinikinPaint paint2(font);
     paint2.size = 20.0f;
     builder.addStyleRun(helloLength, text.size(), std::move(paint2), lbStyle, lbWordStyle,
-                        false /* is RTL */);
+                        true /* can hyphenate */, false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     MinikinRect rect;
     MinikinPaint samePaint(font);
@@ -368,9 +387,11 @@ TEST(MeasuredTextTest, buildLayoutTest_differentPaint) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     MinikinRect rect;
     MinikinPaint differentPaint(font);
@@ -450,13 +471,15 @@ TEST(MeasuredTextTest, buildLayoutTest_multiStyle_differentPaint) {
     MeasuredTextBuilder builder;
     MinikinPaint paint(font);
     paint.size = 10.0f;
-    builder.addStyleRun(0, helloLength, std::move(paint), lbStyle, lbWordStyle, false /* is RTL */);
+    builder.addStyleRun(0, helloLength, std::move(paint), lbStyle, lbWordStyle,
+                        true /* can hyphenate */, false /* is RTL */);
     MinikinPaint paint2(font);
     paint2.size = 20.0f;
     builder.addStyleRun(helloLength, text.size(), std::move(paint2), lbStyle, lbWordStyle,
-                        false /* is RTL */);
+                        true /* can hyphenate */, false /* is RTL */);
     auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
-                            false /* ignore kerning */, nullptr /* no hint */);
+                            false /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
 
     MinikinRect rect;
     MinikinPaint differentPaint(font);
@@ -566,9 +589,11 @@ TEST(MeasuredTextTest, testLineBreakStyle_from_builder) {
 
     MeasuredTextBuilder looseStyleBuilder;
     MinikinPaint paint(font);
-    looseStyleBuilder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle, false);
+    looseStyleBuilder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                                  true /* can hyphenate */, false);
     auto mt = looseStyleBuilder.build(text, true /* hyphenation */, true /* full layout */,
-                                      false /* ignore kerning */, nullptr /* no hint */);
+                                      false /* computeBounds */, false /* ignore kerning */,
+                                      nullptr /* no hint */);
 
     EXPECT_EQ((size_t)1, mt->runs.size());
     EXPECT_EQ(LineBreakStyle::Loose, mt->runs[0]->lineBreakStyle());
@@ -578,9 +603,10 @@ TEST(MeasuredTextTest, testLineBreakStyle_from_builder) {
     MeasuredTextBuilder normalStyleBuilder;
     MinikinPaint normalStylePaint(font);
     normalStyleBuilder.addStyleRun(0, text.size(), std::move(normalStylePaint), lbStyle,
-                                   lbWordStyle, false);
+                                   lbWordStyle, true /* can hyphenate */, false);
     mt = normalStyleBuilder.build(text, true /* hyphenation */, true /* full layout */,
-                                  false /* ignore kerning */, nullptr /* no hint */);
+                                  false /* computeBounds */, false /* ignore kerning */,
+                                  nullptr /* no hint */);
 
     EXPECT_EQ((size_t)1, mt->runs.size());
     EXPECT_EQ(LineBreakStyle::Normal, mt->runs[0]->lineBreakStyle());
@@ -591,9 +617,10 @@ TEST(MeasuredTextTest, testLineBreakStyle_from_builder) {
     MeasuredTextBuilder strictStyleBuilder;
     MinikinPaint strictStylePaint(font);
     strictStyleBuilder.addStyleRun(0, text.size(), std::move(strictStylePaint), lbStyle,
-                                   lbWordStyle, false);
+                                   lbWordStyle, true /* can hyphenate */, false);
     mt = strictStyleBuilder.build(text, true /* hyphenation */, true /* full layout */,
-                                  false /* ignore kerning */, nullptr /* no hint */);
+                                  false /* computeBounds */, false /* ignore kerning */,
+                                  nullptr /* no hint */);
 
     EXPECT_EQ((size_t)1, mt->runs.size());
     EXPECT_EQ(LineBreakStyle::Strict, mt->runs[0]->lineBreakStyle());
@@ -608,7 +635,8 @@ TEST(MeasuredTextTest, testLineBreakStyle_from_run) {
     Range range(0, text.size());
     MinikinPaint paint(font);
 
-    StyleRun styleRun(range, std::move(paint), lbStyle, lbWordStyle, false /* isRtl */);
+    StyleRun styleRun(range, std::move(paint), lbStyle, lbWordStyle, true /* can hyphenate */,
+                      false /* isRtl */);
     EXPECT_EQ(LineBreakStyle::Strict, styleRun.lineBreakStyle());
     EXPECT_EQ(LineBreakWordStyle::Phrase, styleRun.lineBreakWordStyle());
 
@@ -617,4 +645,38 @@ TEST(MeasuredTextTest, testLineBreakStyle_from_run) {
     EXPECT_EQ(LineBreakWordStyle::None, replacementRun.lineBreakWordStyle());
 }
 
+TEST(MeasuredTextTest, hasOverhang_false) {
+    auto text = utf8ToUtf16("Hello, World!");
+    auto font = buildFontCollection("Ascii.ttf");
+    int lbStyle = (int)LineBreakStyle::None;
+    int lbWordStyle = (int)LineBreakWordStyle::None;
+
+    MeasuredTextBuilder builder;
+    MinikinPaint paint(font);
+    paint.size = 10.0f;
+    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                        true /* hyphenation */, false /* is RTL */);
+    auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
+                            true /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
+    EXPECT_FALSE(mt->hasOverhang(Range(0, text.size())));
+}
+
+TEST(MeasuredTextTest, hasOverhang_true) {
+    auto text = utf8ToUtf16("b");
+    auto font = buildFontCollection("OvershootTest.ttf");
+    int lbStyle = (int)LineBreakStyle::None;
+    int lbWordStyle = (int)LineBreakWordStyle::None;
+
+    MeasuredTextBuilder builder;
+    MinikinPaint paint(font);
+    paint.size = 10.0f;
+    builder.addStyleRun(0, text.size(), std::move(paint), lbStyle, lbWordStyle,
+                        true /* hyphenation */, false /* is RTL */);
+    auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
+                            true /* computeBounds */, false /* ignore kerning */,
+                            nullptr /* no hint */);
+    EXPECT_TRUE(mt->hasOverhang(Range(0, text.size())));
+}
+
 }  // namespace minikin
diff --git a/tests/unittest/OptimalLineBreakerTest.cpp b/tests/unittest/OptimalLineBreakerTest.cpp
index 18619e3..003db71 100644
--- a/tests/unittest/OptimalLineBreakerTest.cpp
+++ b/tests/unittest/OptimalLineBreakerTest.cpp
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <memory>
-
+#include <com_android_text_flags.h>
+#include <flag_macros.h>
 #include <gtest/gtest.h>
 
-#include "minikin/Hyphenator.h"
+#include <memory>
 
 #include "FileUtils.h"
 #include "FontTestUtils.h"
@@ -29,6 +29,7 @@
 #include "OptimalLineBreaker.h"
 #include "UnicodeUtils.h"
 #include "WordBreaker.h"
+#include "minikin/Hyphenator.h"
 
 namespace minikin {
 namespace {
@@ -47,6 +48,12 @@ constexpr float DESCENT = 20.0f;
 constexpr float CUSTOM_ASCENT = -160.0f;
 constexpr float CUSTOM_DESCENT = 40.0f;
 
+// A test string for Japanese. The meaning is that "Today is a sunny day."
+// The expected line break of phrase and non-phrase cases are:
+//     Phrase: | \u672C\u65E5\u306F | \u6674\u5929\u306A\u308A\u3002 |
+// Non-Phrase: | \u672C | \u65E5 | \u306F | \u6674 | \u5929 | \u306A | \u308A\u3002 |
+const char* JP_TEXT = "\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002";
+
 class OptimalLineBreakerTest : public testing::Test {
 public:
     OptimalLineBreakerTest() {}
@@ -75,20 +82,90 @@ protected:
         MinikinPaint paint(fc);
         paint.size = 10.0f;  // Make 1em=10px
         paint.localeListId = LocaleListCache::getId(lang);
-        builder.addStyleRun(0, textBuffer.size(), std::move(paint), 0, 0, false);
+        builder.addStyleRun(0, textBuffer.size(), std::move(paint), 0, 0, true, false);
         bool computeHyphen = frequency != HyphenationFrequency::None;
         std::unique_ptr<MeasuredText> measuredText =
                 builder.build(textBuffer, computeHyphen, false /* compute full layout */,
-                              ignoreKerning, nullptr /* no hint */);
+                              false /* computeBounds */, ignoreKerning, nullptr /* no hint */);
         return doLineBreak(textBuffer, *measuredText, strategy, frequency, lineWidth);
     }
 
+    LineBreakResult doLineBreakForJapanese(const U16StringPiece& textBuffer,
+                                           LineBreakWordStyle lbwStyle, const std::string& lang,
+                                           float lineWidth) {
+        MeasuredTextBuilder builder;
+        auto family1 = buildFontFamily("Japanese.ttf");
+        std::vector<std::shared_ptr<FontFamily>> families = {family1};
+        auto fc = FontCollection::create(families);
+        MinikinPaint paint(fc);
+        paint.size = 10.0f;  // Make 1em=10px
+        paint.localeListId = LocaleListCache::getId(lang);
+        builder.addStyleRun(0, textBuffer.size(), std::move(paint), 0, (int)lbwStyle, true, false);
+        std::unique_ptr<MeasuredText> measuredText = builder.build(
+                textBuffer, false /* computeHyphen */, false /* compute full layout */,
+                false /* computeBounds */, false /* ignoreKerning */, nullptr /* no hint */);
+        return doLineBreak(textBuffer, *measuredText, BreakStrategy::HighQuality,
+                           HyphenationFrequency::None, lineWidth);
+    }
+    LineBreakResult doLineBreakWithNoHyphenSpan(const U16StringPiece& textBuffer,
+                                                const Range& noHyphenRange, float lineWidth) {
+        MeasuredTextBuilder builder;
+        auto family1 = buildFontFamily("Ascii.ttf");
+        auto family2 = buildFontFamily("CustomExtent.ttf");
+        std::vector<std::shared_ptr<FontFamily>> families = {family1, family2};
+        auto fc = FontCollection::create(families);
+        if (noHyphenRange.getStart() != 0) {
+            MinikinPaint paint(fc);
+            paint.size = 10.0f;  // Make 1em=10px
+            paint.localeListId = LocaleListCache::getId("en-US");
+            builder.addStyleRun(0, noHyphenRange.getStart(), std::move(paint), 0, 0,
+                                true /* hyphenation */, false);
+        }
+        MinikinPaint paint(fc);
+        paint.size = 10.0f;  // Make 1em=10px
+        paint.localeListId = LocaleListCache::getId("en-US");
+        builder.addStyleRun(noHyphenRange.getStart(), noHyphenRange.getEnd(), std::move(paint), 0,
+                            0, false /* no hyphenation */, false);
+        if (noHyphenRange.getEnd() != textBuffer.size()) {
+            MinikinPaint paint(fc);
+            paint.size = 10.0f;  // Make 1em=10px
+            paint.localeListId = LocaleListCache::getId("en-US");
+            builder.addStyleRun(noHyphenRange.getEnd(), textBuffer.size(), std::move(paint), 0, 0,
+                                true /* hyphenation */, false);
+        }
+        std::unique_ptr<MeasuredText> measuredText = builder.build(
+                textBuffer, true /* computeHyphen */, false /* compute full layout */,
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
+        return doLineBreak(textBuffer, *measuredText, BreakStrategy::HighQuality,
+                           HyphenationFrequency::Normal, lineWidth);
+    }
+
+    LineBreakResult doLineBreakForBounds(const U16StringPiece& textBuffer, BreakStrategy strategy,
+                                         HyphenationFrequency frequency, float lineWidth) {
+        MeasuredTextBuilder builder;
+        auto family1 = buildFontFamily("OvershootTest.ttf");
+        auto family2 = buildFontFamily("Ascii.ttf");
+        std::vector<std::shared_ptr<FontFamily>> families = {family1, family2};
+        auto fc = FontCollection::create(families);
+        MinikinPaint paint(fc);
+        paint.size = 10.0f;  // Make 1em=10px
+        paint.localeListId = LocaleListCache::getId("en-US");
+        builder.addStyleRun(0, textBuffer.size(), std::move(paint), 0, 0, true, false);
+        bool computeHyphen = frequency != HyphenationFrequency::None;
+        std::unique_ptr<MeasuredText> measuredText = builder.build(
+                textBuffer, computeHyphen, false /* compute full layout */,
+                true /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
+        RectangleLineWidth rectangleLineWidth(lineWidth);
+        return breakLineOptimal(textBuffer, *measuredText, rectangleLineWidth, strategy, frequency,
+                                false /* justified */, true /* useBoundsForWidth */);
+    }
+
     LineBreakResult doLineBreak(const U16StringPiece& textBuffer, const MeasuredText& measuredText,
                                 BreakStrategy strategy, HyphenationFrequency frequency,
                                 float lineWidth) {
         RectangleLineWidth rectangleLineWidth(lineWidth);
         return breakLineOptimal(textBuffer, measuredText, rectangleLineWidth, strategy, frequency,
-                                false /* justified */);
+                                false /* justified */, false /* useBoundsForWidth */);
     }
 
     void expectBreak(const std::vector<LineBreakExpectation>& expect,
@@ -759,7 +836,7 @@ TEST_F(OptimalLineBreakerTest, testZeroWidthCharacter) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, true /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
 
         const auto actual =
                 doLineBreak(textBuf, *measuredText, HIGH_QUALITY, NORMAL_HYPHENATION, LINE_WIDTH);
@@ -778,7 +855,7 @@ TEST_F(OptimalLineBreakerTest, testZeroWidthCharacter) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, true /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
 
         const auto actual =
                 doLineBreak(textBuf, *measuredText, HIGH_QUALITY, NORMAL_HYPHENATION, LINE_WIDTH);
@@ -809,7 +886,7 @@ TEST_F(OptimalLineBreakerTest, testLocaleSwitchTest) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, true /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
 
         const auto actual =
                 doLineBreak(textBuf, *measuredText, HIGH_QUALITY, NORMAL_HYPHENATION, LINE_WIDTH);
@@ -828,7 +905,7 @@ TEST_F(OptimalLineBreakerTest, testLocaleSwitchTest) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, true /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         const auto actual =
                 doLineBreak(textBuf, *measuredText, HIGH_QUALITY, NORMAL_HYPHENATION, LINE_WIDTH);
         EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
@@ -903,7 +980,7 @@ TEST_F(OptimalLineBreakerTest, testLocaleSwitch_InEmailOrUrl) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measured = builder.build(
                 textBuf, true /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
 
         // clang-format off
         std::vector<LineBreakExpectation> expect = {
@@ -946,7 +1023,7 @@ TEST_F(OptimalLineBreakerTest, testLocaleSwitch_InEmailOrUrl) {
                                           DESCENT);
         std::unique_ptr<MeasuredText> measured = builder.build(
                 textBuf, true /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
 
         // clang-format off
         std::vector<LineBreakExpectation> expect = {
@@ -1101,12 +1178,12 @@ TEST_F(OptimalLineBreakerTest, testReplacementSpanNotBreakTest_SingleChar) {
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
         return breakLineOptimal(textBuf, *measuredText, rectangleLineWidth,
                                 BreakStrategy::HighQuality, HyphenationFrequency::None,
-                                false /* justified */);
+                                false /* justified */, false /* useBoundsForWidth */);
     };
 
     {
@@ -1194,12 +1271,12 @@ TEST_F(OptimalLineBreakerTest, testReplacementSpanNotBreakTest_MultipleChars) {
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
         return breakLineOptimal(textBuf, *measuredText, rectangleLineWidth,
                                 BreakStrategy::HighQuality, HyphenationFrequency::None,
-                                false /* justified */);
+                                false /* justified */, false /* useBoundsForWidth */);
     };
 
     {
@@ -1282,12 +1359,12 @@ TEST_F(OptimalLineBreakerTest, testReplacementSpanNotBreakTest_continuedReplacem
         builder.addReplacementRun(19, 24, 5 * CHAR_WIDTH, LocaleListCache::getId("en-US"));
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
         return breakLineOptimal(textBuf, *measuredText, rectangleLineWidth,
                                 BreakStrategy::HighQuality, HyphenationFrequency::None,
-                                false /* justified */);
+                                false /* justified */, false /* useBoundsForWidth */);
     };
 
     {
@@ -1358,12 +1435,12 @@ TEST_F(OptimalLineBreakerTest, testReplacementSpanNotBreakTest_CJK) {
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore krening */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore krening */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
         return breakLineOptimal(textBuf, *measuredText, rectangleLineWidth,
                                 BreakStrategy::HighQuality, HyphenationFrequency::None,
-                                false /* justified */);
+                                false /* justified */, false /* useBoundsForWidth */);
     };
 
     {
@@ -1515,12 +1592,12 @@ TEST_F(OptimalLineBreakerTest, testReplacementSpan_GraphemeLineBreakWithMultiple
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
         return breakLineOptimal(textBuf, *measuredText, rectangleLineWidth,
                                 BreakStrategy::HighQuality, HyphenationFrequency::None,
-                                false /* justified */);
+                                false /* justified */, false /* useBoundsForWidth */);
     };
 
     {
@@ -1650,12 +1727,12 @@ TEST_F(OptimalLineBreakerTest, testReplacementSpanNotBreakTest_with_punctuation)
 
         std::unique_ptr<MeasuredText> measuredText = builder.build(
                 textBuf, false /* compute hyphenation */, false /* compute full layout */,
-                false /* ignore kerning */, nullptr /* no hint */);
+                false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
         RectangleLineWidth rectangleLineWidth(width);
         TabStops tabStops(nullptr, 0, 0);
         return breakLineOptimal(textBuf, *measuredText, rectangleLineWidth,
                                 BreakStrategy::HighQuality, HyphenationFrequency::Normal,
-                                false /* justified */);
+                                false /* justified */, false /* useBoundsForWidth */);
     };
 
     {
@@ -1856,12 +1933,13 @@ TEST_F(OptimalLineBreakerTest, roundingError) {
     const std::vector<uint16_t> textBuffer = utf8ToUtf16("8888888888888888888");
 
     float measured = Layout::measureText(textBuffer, Range(0, textBuffer.size()), Bidi::LTR, paint,
-                                         StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, nullptr);
+                                         StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, nullptr,
+                                         nullptr /* bounds */);
 
-    builder.addStyleRun(0, textBuffer.size(), std::move(paint), 0, 0, false);
+    builder.addStyleRun(0, textBuffer.size(), std::move(paint), 0, 0, true, false);
     std::unique_ptr<MeasuredText> measuredText = builder.build(
             textBuffer, false /* compute hyphenation */, false /* compute full layout */,
-            false /* ignore kerning */, nullptr /* no hint */);
+            false /* computeBounds */, false /* ignore kerning */, nullptr /* no hint */);
     RectangleLineWidth rectangleLineWidth(measured);
     TabStops tabStops(nullptr, 0, 10);
     LineBreakResult r = doLineBreak(textBuffer, *measuredText, BreakStrategy::Balanced,
@@ -1870,5 +1948,533 @@ TEST_F(OptimalLineBreakerTest, roundingError) {
     EXPECT_EQ(1u, r.breakPoints.size());
 }
 
+TEST_F(OptimalLineBreakerTest, testBreakWithoutBounds_trailing) {
+    // The OvershootTest.ttf has following coverage, extent, width and bbox.
+    // U+0061(a): 1em, (   0, 0) - (1,   1)
+    // U+0062(b): 1em, (   0, 0) - (1.5, 1)
+    // U+0063(c): 1em, (   0, 0) - (2,   1)
+    // U+0064(d): 1em, (   0, 0) - (2.5, 1)
+    // U+0065(e): 1em, (-0.5, 0) - (1,   1)
+    // U+0066(f): 1em, (-1.0, 0) - (1,   1)
+    // U+0067(g): 1em, (-1.5, 0) - (1,   1)
+    const std::vector<uint16_t> textBuf = utf8ToUtf16("dddd dddd dddd dddd");
+    constexpr StartHyphenEdit NO_START_HYPHEN = StartHyphenEdit::NO_EDIT;
+    constexpr EndHyphenEdit NO_END_HYPHEN = EndHyphenEdit::NO_EDIT;
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        constexpr float LINE_WIDTH = 1000;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"dddd dddd dddd dddd", 190, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, BreakStrategy::HighQuality,
+                                                 HyphenationFrequency::None, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(0, 10, 205, 0), actual.bounds[0]);
+    }
+    {
+        constexpr float LINE_WIDTH = 110;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"dddd dddd ", 90, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"dddd dddd", 90, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, BreakStrategy::HighQuality,
+                                                 HyphenationFrequency::None, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(0, 10, 105, 0), actual.bounds[0]);
+        EXPECT_EQ(MinikinRect(0, 10, 105, 0), actual.bounds[1]);
+    }
+    {
+        constexpr float LINE_WIDTH = 100;
+        // Even if the total advance of "dddd dddd" is 90, the width of bounding box of "dddd dddd"
+        // is
+        // Rect(0em, 1em, 10.5em, 0em). So "dddd dddd" is broken into two lines.
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"dddd ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"dddd ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"dddd ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"dddd", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, BreakStrategy::HighQuality,
+                                                 HyphenationFrequency::None, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(0, 10, 55, 0), actual.bounds[0]);
+        EXPECT_EQ(MinikinRect(0, 10, 55, 0), actual.bounds[1]);
+        EXPECT_EQ(MinikinRect(0, 10, 55, 0), actual.bounds[2]);
+        EXPECT_EQ(MinikinRect(0, 10, 55, 0), actual.bounds[3]);
+    }
+}
+
+TEST_F(OptimalLineBreakerTest, testBreakWithoutBounds_preceding) {
+    // The OvershootTest.ttf has following coverage, extent, width and bbox.
+    // U+0061(a): 1em, (   0, 0) - (1,   1)
+    // U+0062(b): 1em, (   0, 0) - (1.5, 1)
+    // U+0063(c): 1em, (   0, 0) - (2,   1)
+    // U+0064(d): 1em, (   0, 0) - (2.5, 1)
+    // U+0065(e): 1em, (-0.5, 0) - (1,   1)
+    // U+0066(f): 1em, (-1.0, 0) - (1,   1)
+    // U+0067(g): 1em, (-1.5, 0) - (1,   1)
+    const std::vector<uint16_t> textBuf = utf8ToUtf16("gggg gggg gggg gggg");
+    constexpr StartHyphenEdit NO_START_HYPHEN = StartHyphenEdit::NO_EDIT;
+    constexpr EndHyphenEdit NO_END_HYPHEN = EndHyphenEdit::NO_EDIT;
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        constexpr float LINE_WIDTH = 1000;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"gggg gggg gggg gggg", 190, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, BreakStrategy::HighQuality,
+                                                 HyphenationFrequency::None, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(-15, 10, 190, 0), actual.bounds[0]);
+    }
+    {
+        constexpr float LINE_WIDTH = 110;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"gggg gggg ", 90, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"gggg gggg", 90, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, BreakStrategy::HighQuality,
+                                                 HyphenationFrequency::None, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(-15, 10, 90, 0), actual.bounds[0]);
+        EXPECT_EQ(MinikinRect(-15, 10, 90, 0), actual.bounds[1]);
+    }
+    {
+        constexpr float LINE_WIDTH = 100;
+        // Even if the total advance of "gggg gggg" is 90, the width of bounding box of "gggg gggg"
+        // is
+        // Rect(0em, 1em, 10.5em, 0em). So "gggg gggg" is broken into two lines.
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                {"gggg ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"gggg ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"gggg ", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+                {"gggg", 40, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT},
+        };
+        // clang-format on
+
+        const auto actual = doLineBreakForBounds(textBuf, BreakStrategy::HighQuality,
+                                                 HyphenationFrequency::None, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+        EXPECT_EQ(MinikinRect(-15, 10, 40, 0), actual.bounds[0]);
+        EXPECT_EQ(MinikinRect(-15, 10, 40, 0), actual.bounds[1]);
+        EXPECT_EQ(MinikinRect(-15, 10, 40, 0), actual.bounds[2]);
+        EXPECT_EQ(MinikinRect(-15, 10, 40, 0), actual.bounds[3]);
+    }
+}
+
+TEST_F(OptimalLineBreakerTest, testBreakWithHyphenation_NoHyphenSpan) {
+    const std::vector<uint16_t> textBuffer = utf8ToUtf16("This is Android. Here is hyphenation.");
+    const Range noHyphenRange(25, 37);  // the range of the word "hyphenation".
+
+    constexpr StartHyphenEdit NO_START_HYPHEN = StartHyphenEdit::NO_EDIT;
+    constexpr EndHyphenEdit NO_END_HYPHEN = EndHyphenEdit::NO_EDIT;
+    constexpr EndHyphenEdit END_HYPHEN = EndHyphenEdit::INSERT_HYPHEN;
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        constexpr float LINE_WIDTH = 170;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                { "This is Android. " , 160, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                { "Here is hyphena-"  , 160, NO_START_HYPHEN,    END_HYPHEN, ASCENT, DESCENT },
+                { "tion."             ,  50, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+        };
+        // clang-format on
+
+        auto actual =
+                doLineBreak(textBuffer, BreakStrategy::HighQuality, HyphenationFrequency::Normal,
+                            "en-US", LINE_WIDTH, false /* ignore kerning */);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuffer, actual);
+    }
+    {
+        constexpr float LINE_WIDTH = 170;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                { "This is An-"    , 110, NO_START_HYPHEN,    END_HYPHEN, ASCENT, DESCENT },
+                { "droid. Here is ", 140, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+                { "hyphenation."   , 120, NO_START_HYPHEN, NO_END_HYPHEN, ASCENT, DESCENT },
+        };
+        // clang-format on
+
+        auto actual = doLineBreakWithNoHyphenSpan(textBuffer, noHyphenRange, LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuffer, actual);
+    }
+}
+
+TEST_F_WITH_FLAGS(OptimalLineBreakerTest, testPhraseBreakNone,
+                  REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                      word_style_auto))) {
+    // For short hand of writing expectation for lines.
+    auto line = [](std::string t, float w) -> LineBreakExpectation {
+        return {t, w, StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, ASCENT, DESCENT};
+    };
+
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 1));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002" , 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 2));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5" , 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002" , 60),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 3));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002", 40),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 4));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002"  , 20),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 5));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 100),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 6));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 100),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::None, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+}
+
+TEST_F_WITH_FLAGS(OptimalLineBreakerTest, testPhraseBreakPhrase,
+                  REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                      word_style_auto))) {
+    // For short hand of writing expectation for lines.
+    auto line = [](std::string t, float w) -> LineBreakExpectation {
+        return {t, w, StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, ASCENT, DESCENT};
+    };
+
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 1));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 2));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 3));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 4));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 5));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 6));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Phrase, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+}
+
+TEST_F_WITH_FLAGS(OptimalLineBreakerTest, testPhraseBreakAuto,
+                  REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::text::flags,
+                                                      word_style_auto))) {
+    // For short hand of writing expectation for lines.
+    auto line = [](std::string t, float w) -> LineBreakExpectation {
+        return {t, w, StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, ASCENT, DESCENT};
+    };
+
+    // Note that disable clang-format everywhere since aligned expectation is more readable.
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 1));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 2));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 3));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 4));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    // When the line becomes more or equal to 5, the phrase based line break is disabled.
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 5));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 100),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+    {
+        const std::vector<uint16_t> textBuf = utf8ToUtf16(repeat(JP_TEXT, 6));
+        constexpr float LINE_WIDTH = 100;
+        // clang-format off
+        std::vector<LineBreakExpectation> expect = {
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5", 100),
+                line("\u306F\u6674\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674", 100),
+                line("\u5929\u306A\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A", 100),
+                line("\u308A\u3002\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002", 100),
+                line("\u672C\u65E5\u306F\u6674\u5929\u306A\u308A\u3002"  , 80),
+        };
+        // clang-format on
+
+        const auto actual =
+                doLineBreakForJapanese(textBuf, LineBreakWordStyle::Auto, "ja-JP", LINE_WIDTH);
+        EXPECT_TRUE(sameLineBreak(expect, actual)) << toString(expect) << std::endl
+                                                   << " vs " << std::endl
+                                                   << toString(textBuf, actual);
+    }
+}
 }  // namespace
 }  // namespace minikin
diff --git a/tests/unittest/ScriptUtilsTest.cpp b/tests/unittest/ScriptUtilsTest.cpp
new file mode 100644
index 0000000..cbd9a56
--- /dev/null
+++ b/tests/unittest/ScriptUtilsTest.cpp
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "ScriptUtils.h"
+#include "UnicodeUtils.h"
+
+namespace minikin {
+namespace {
+
+struct Result {
+    Result(int start, int end, hb_script_t script) : start(start), end(end), script(script) {}
+    int start;
+    int end;
+    hb_script_t script;
+};
+
+bool operator==(const Result& l, const Result& r) {
+    return l.start == r.start && l.end == r.end && l.script == r.script;
+}
+
+std::ostream& operator<<(std::ostream& os, const Result& r) {
+    char buf[5] = {};
+    buf[0] = static_cast<char>((r.script >> 24) & 0xFF);
+    buf[1] = static_cast<char>((r.script >> 16) & 0xFF);
+    buf[2] = static_cast<char>((r.script >> 8) & 0xFF);
+    buf[3] = static_cast<char>((r.script) & 0xFF);
+    return os << "(" << r.start << "," << r.end << "): " << buf;
+}
+
+std::vector<Result> splitByScript(const std::vector<uint16_t>& text, uint32_t start, uint32_t end) {
+    std::vector<Result> result;
+    for (const auto [range, script] : ScriptText(text, start, end)) {
+        result.emplace_back(range.getStart(), range.getEnd(), script);
+    }
+    return result;
+}
+
+std::vector<Result> splitByScript(const std::string& text, uint32_t start, uint32_t end) {
+    std::vector<uint16_t> utf16 = utf8ToUtf16(text);
+    return splitByScript(utf16, start, end);
+}
+
+TEST(ScriptUtilsTest, Latin) {
+    auto result = splitByScript("abcde", 0, 5);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 5, HB_SCRIPT_LATIN), result[0]);
+
+    result = splitByScript("abcde", 0, 3);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 3, HB_SCRIPT_LATIN), result[0]);
+
+    result = splitByScript("abcde", 2, 5);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(2, 5, HB_SCRIPT_LATIN), result[0]);
+
+    result = splitByScript("abcde", 2, 3);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(2, 3, HB_SCRIPT_LATIN), result[0]);
+}
+
+TEST(ScriptUtilsTest, Arabic) {
+    auto result = splitByScript("\u0645\u0631\u062D\u0628\u064B\u0627", 0, 6);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 6, HB_SCRIPT_ARABIC), result[0]);
+
+    result = splitByScript("\u0645\u0631\u062D\u0628\u064B\u0627", 0, 3);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 3, HB_SCRIPT_ARABIC), result[0]);
+
+    result = splitByScript("\u0645\u0631\u062D\u0628\u064B\u0627", 2, 5);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(2, 5, HB_SCRIPT_ARABIC), result[0]);
+
+    result = splitByScript("\u0645\u0631\u062D\u0628\u064B\u0627", 2, 3);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(2, 3, HB_SCRIPT_ARABIC), result[0]);
+}
+
+TEST(ScriptUtilsTest, Common) {
+    auto result = splitByScript("     ", 0, 5);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 5, HB_SCRIPT_COMMON), result[0]);
+
+    result = splitByScript("     ", 0, 3);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 3, HB_SCRIPT_COMMON), result[0]);
+
+    result = splitByScript("     ", 2, 5);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(2, 5, HB_SCRIPT_COMMON), result[0]);
+
+    result = splitByScript("     ", 2, 3);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(2, 3, HB_SCRIPT_COMMON), result[0]);
+}
+
+TEST(ScriptUtilsTest, InheritOrCommon) {
+    // Parens are inherit which is inherit from the previous script. If there is no character
+    // before, use the next non-inherit type of script.
+    auto result = splitByScript("(abc)", 0, 5);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 5, HB_SCRIPT_LATIN), result[0]);
+
+    result = splitByScript("[(b)]", 0, 5);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 5, HB_SCRIPT_LATIN), result[0]);
+
+    result = splitByScript("[(b)]", 0, 2);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 2, HB_SCRIPT_COMMON), result[0]);
+}
+
+TEST(ScriptUtilsTest, MultiScript_InheritOrCommon) {
+    auto result = splitByScript("a(\u0645)e", 0, 5);
+    EXPECT_EQ(Result(0, 2, HB_SCRIPT_LATIN), result[0]);
+    EXPECT_EQ(Result(2, 4, HB_SCRIPT_ARABIC), result[1]);
+    EXPECT_EQ(Result(4, 5, HB_SCRIPT_LATIN), result[2]);
+}
+
+TEST(ScriptUtilsTest, MultiScript_NoInheritOrCommon) {
+    auto result = splitByScript("a\u0645b\u0631c", 0, 5);
+    EXPECT_EQ(Result(0, 1, HB_SCRIPT_LATIN), result[0]);
+    EXPECT_EQ(Result(1, 2, HB_SCRIPT_ARABIC), result[1]);
+    EXPECT_EQ(Result(2, 3, HB_SCRIPT_LATIN), result[2]);
+    EXPECT_EQ(Result(3, 4, HB_SCRIPT_ARABIC), result[3]);
+    EXPECT_EQ(Result(4, 5, HB_SCRIPT_LATIN), result[4]);
+}
+
+TEST(ScriptUtilsTest, SurrogatePair) {
+    auto result = splitByScript(std::vector<uint16_t>({0xD83C, 0xDFF3, 0xD83C, 0xDFF3}), 0, 4);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 4, HB_SCRIPT_COMMON), result[0]);
+
+    result = splitByScript(std::vector<uint16_t>({0xD83C, 0xDFF3, 0xD83C, 0xDFF3}), 0, 3);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(0, 3, HB_SCRIPT_COMMON), result[0]);
+
+    result = splitByScript(std::vector<uint16_t>({0xD83C, 0xDFF3, 0xD83C, 0xDFF3}), 1, 4);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(1, 4, HB_SCRIPT_COMMON), result[0]);
+
+    result = splitByScript(std::vector<uint16_t>({0xD83C, 0xDFF3, 0xD83C, 0xDFF3}), 1, 3);
+    ASSERT_EQ(1u, result.size());
+    EXPECT_EQ(Result(1, 3, HB_SCRIPT_COMMON), result[0]);
+}
+}  // namespace
+}  // namespace minikin
diff --git a/tests/unittest/SystemFontsTest.cpp b/tests/unittest/SystemFontsTest.cpp
index 1bff31f..50fcc3e 100644
--- a/tests/unittest/SystemFontsTest.cpp
+++ b/tests/unittest/SystemFontsTest.cpp
@@ -105,7 +105,7 @@ TEST(SystemFontTest, getAvailableFont_dedupFonts) {
         EXPECT_EQ(3u, fonts.size());  // Ascii, Bold and BoldItalic
         std::unordered_set<std::string> fontPaths;
         for (const auto& font : fonts) {
-            fontPaths.insert(getBasename(font->typeface()->GetFontPath()));
+            fontPaths.insert(getBasename(font->baseTypeface()->GetFontPath()));
         }
 
         EXPECT_TRUE(fontPaths.find("Ascii.ttf") != fontPaths.end());
diff --git a/tests/unittest/WordBreakerTests.cpp b/tests/unittest/WordBreakerTests.cpp
index 0c20a80..fe7f953 100644
--- a/tests/unittest/WordBreakerTests.cpp
+++ b/tests/unittest/WordBreakerTests.cpp
@@ -672,7 +672,7 @@ TEST(WordBreakerTest, LineBreakerPool_acquire_with_release) {
             pool.acquire(enUS, LineBreakStyle::Loose, LineBreakWordStyle::None);
 
     uint64_t enUSBreakerLocaleId = enUSBreaker.localeId;
-    UBreakIterator* enUSBreakerPtr = enUSBreaker.breaker.get();
+    auto* enUSBreakerPtr = enUSBreaker.breaker.get();
 
     pool.release(std::move(enUSBreaker));
     EXPECT_EQ(nullptr, enUSBreaker.breaker.get());
diff --git a/tests/util/FontTestUtils.cpp b/tests/util/FontTestUtils.cpp
index 5308e0c..0d563b8 100644
--- a/tests/util/FontTestUtils.cpp
+++ b/tests/util/FontTestUtils.cpp
@@ -109,9 +109,9 @@ std::vector<std::shared_ptr<FontFamily>> getFontFamilies(const std::string& font
             family = FontFamily::create(variant, std::move(fonts));
         } else {
             uint32_t langId = registerLocaleList(std::string((const char*)lang, xmlStrlen(lang)));
-            family =
-                    FontFamily::create(langId, variant, std::move(fonts),
-                                       false /* isCustomFallback */, false /* isdefaultFallback */);
+            family = FontFamily::create(langId, variant, std::move(fonts),
+                                        false /* isCustomFallback */, false /* isdefaultFallback */,
+                                        VariationFamilyType::None);
         }
         families.push_back(family);
     }
@@ -136,7 +136,8 @@ std::shared_ptr<FontFamily> buildFontFamily(const std::string& filePath, const s
     std::vector<std::shared_ptr<Font>> fonts;
     fonts.push_back(Font::Builder(font).build());
     return FontFamily::create(LocaleListCache::getId(lang), FamilyVariant::DEFAULT,
-                              std::move(fonts), isCustomFallback, false /* isDefaultFallback */);
+                              std::move(fonts), isCustomFallback, false /* isDefaultFallback */,
+                              VariationFamilyType::None);
 }
 
 }  // namespace minikin
diff --git a/tests/util/FreeTypeMinikinFontForTest.cpp b/tests/util/FreeTypeMinikinFontForTest.cpp
index ce36ec0..146eb6b 100644
--- a/tests/util/FreeTypeMinikinFontForTest.cpp
+++ b/tests/util/FreeTypeMinikinFontForTest.cpp
@@ -59,8 +59,9 @@ void loadGlyphOrDie(uint32_t glyphId, float size, FT_Face face) {
 
 }  // namespace
 
-FreeTypeMinikinFontForTest::FreeTypeMinikinFontForTest(const std::string& font_path, int index)
-        : mFontPath(font_path), mFontIndex(index) {
+FreeTypeMinikinFontForTest::FreeTypeMinikinFontForTest(const std::string& font_path, int index,
+                                                       const std::vector<FontVariation>& axes)
+        : mFontPath(font_path), mFontIndex(index), mAxes(axes) {
     int fd = open(font_path.c_str(), O_RDONLY);
     LOG_ALWAYS_FATAL_IF(fd == -1, "Open failed: %s", font_path.c_str());
     struct stat st = {};
@@ -135,4 +136,9 @@ void FreeTypeMinikinFontForTestFactory::skip(BufferReader* reader) const {
     reader->skipString();  // fontPath
 }
 
+std::shared_ptr<MinikinFont> FreeTypeMinikinFontForTest::createFontWithVariation(
+        const std::vector<FontVariation>& axes) const {
+    return std::make_shared<FreeTypeMinikinFontForTest>(mFontPath, mFontIndex, axes);
+}
+
 }  // namespace minikin
diff --git a/tests/util/FreeTypeMinikinFontForTest.h b/tests/util/FreeTypeMinikinFontForTest.h
index 6903deb..f684ec6 100644
--- a/tests/util/FreeTypeMinikinFontForTest.h
+++ b/tests/util/FreeTypeMinikinFontForTest.h
@@ -33,9 +33,12 @@ namespace minikin {
 
 class FreeTypeMinikinFontForTest : public MinikinFont {
 public:
-    FreeTypeMinikinFontForTest(const std::string& font_path, int index);
+    FreeTypeMinikinFontForTest(const std::string& font_path, int index,
+                               const std::vector<FontVariation>& axes);
+    FreeTypeMinikinFontForTest(const std::string& font_path, int index)
+            : FreeTypeMinikinFontForTest(font_path, index, std::vector<FontVariation>()) {}
     FreeTypeMinikinFontForTest(const std::string& font_path)
-            : FreeTypeMinikinFontForTest(font_path, 0) {}
+            : FreeTypeMinikinFontForTest(font_path, 0, std::vector<FontVariation>()) {}
     virtual ~FreeTypeMinikinFontForTest();
 
     // MinikinFont overrides.
@@ -51,6 +54,7 @@ public:
     size_t GetFontSize() const { return mFontSize; }
     int GetFontIndex() const { return mFontIndex; }
     const std::vector<minikin::FontVariation>& GetAxes() const { return mAxes; }
+    std::shared_ptr<MinikinFont> createFontWithVariation(const std::vector<FontVariation>&) const;
 
 private:
     const std::string mFontPath;
diff --git a/tests/util/UnicodeUtils.cpp b/tests/util/UnicodeUtils.cpp
index 25716a7..1809dd1 100644
--- a/tests/util/UnicodeUtils.cpp
+++ b/tests/util/UnicodeUtils.cpp
@@ -14,14 +14,15 @@
  * limitations under the License.
  */
 
-#include <cstdlib>
-#include <string>
-#include <vector>
-
 #include <cutils/log.h>
 #include <unicode/utf.h>
 #include <unicode/utf8.h>
 
+#include <cstdlib>
+#include <sstream>
+#include <string>
+#include <vector>
+
 #include "minikin/U16StringPiece.h"
 
 namespace minikin {
@@ -138,4 +139,12 @@ std::string utf16ToUtf8(const U16StringPiece& u16String) {
     return out;
 }
 
+std::string repeat(const std::string& text, int count) {
+    std::stringstream ss;
+    for (int i = 0; i < count; ++i) {
+        ss << text;
+    }
+    return ss.str();
+}
+
 }  // namespace minikin
diff --git a/tests/util/UnicodeUtils.h b/tests/util/UnicodeUtils.h
index af9d056..be11f61 100644
--- a/tests/util/UnicodeUtils.h
+++ b/tests/util/UnicodeUtils.h
@@ -32,4 +32,6 @@ std::vector<uint16_t> parseUnicodeString(const std::string& in);
 std::vector<uint16_t> utf8ToUtf16(const std::string& text);
 std::string utf16ToUtf8(const U16StringPiece& u16String);
 
+std::string repeat(const std::string& text, int count);
+
 }  // namespace minikin