diff options
Diffstat (limited to 'java/openjdk6/files/icedtea/openjdk')
12 files changed, 25335 insertions, 0 deletions
diff --git a/java/openjdk6/files/icedtea/openjdk/5102804-memory_leak.patch b/java/openjdk6/files/icedtea/openjdk/5102804-memory_leak.patch new file mode 100644 index 000000000000..01dd35c1bee2 --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/5102804-memory_leak.patch @@ -0,0 +1,429 @@ +# HG changeset patch +# User andrew +# Date 1365704033 -3600 +# Node ID 06255d9f82761abc74c30f31fda00968ffef4bc3 +# Parent a939f541de9af5ccb78225c27cd46cd7dc6bcf87 +5102804: Memory leak in Introspector.getBeanInfo(Class) for custom BeanInfo: Class param (includes WeakCache from 6397609) +Reviewed-by: peterz + +diff --git a/src/share/classes/com/sun/beans/WeakCache.java b/src/share/classes/com/sun/beans/WeakCache.java +new file mode 100644 +--- /dev/null ++++ jdk/src/share/classes/com/sun/beans/WeakCache.java +@@ -0,0 +1,91 @@ ++/* ++ * Copyright 2008 Sun Microsystems, Inc. All Rights Reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Sun designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Sun in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ */ ++package com.sun.beans; ++ ++import java.lang.ref.Reference; ++import java.lang.ref.WeakReference; ++ ++import java.util.Map; ++import java.util.WeakHashMap; ++ ++/** ++ * A hashtable-based cache with weak keys and weak values. ++ * An entry in the map will be automatically removed ++ * when its key is no longer in the ordinary use. ++ * A value will be automatically removed as well ++ * when it is no longer in the ordinary use. ++ * ++ * @since 1.7 ++ * ++ * @author Sergey A. Malenkov ++ */ ++public final class WeakCache<K, V> { ++ private final Map<K, Reference<V>> map = new WeakHashMap<K, Reference<V>>(); ++ ++ /** ++ * Returns a value to which the specified {@code key} is mapped, ++ * or {@code null} if this map contains no mapping for the {@code key}. ++ * ++ * @param key the key whose associated value is returned ++ * @return a value to which the specified {@code key} is mapped ++ */ ++ public V get(K key) { ++ Reference<V> reference = this.map.get(key); ++ if (reference == null) { ++ return null; ++ } ++ V value = reference.get(); ++ if (value == null) { ++ this.map.remove(key); ++ } ++ return value; ++ } ++ ++ /** ++ * Associates the specified {@code value} with the specified {@code key}. ++ * Removes the mapping for the specified {@code key} from this cache ++ * if it is present and the specified {@code value} is {@code null}. ++ * If the cache previously contained a mapping for the {@code key}, ++ * the old value is replaced by the specified {@code value}. ++ * ++ * @param key the key with which the specified value is associated ++ * @param value the value to be associated with the specified key ++ */ ++ public void put(K key, V value) { ++ if (value != null) { ++ this.map.put(key, new WeakReference<V>(value)); ++ } ++ else { ++ this.map.remove(key); ++ } ++ } ++ ++ /** ++ * Removes all of the mappings from this cache. ++ */ ++ public void clear() { ++ this.map.clear(); ++ } ++} +diff --git a/src/share/classes/java/beans/Introspector.java b/src/share/classes/java/beans/Introspector.java +--- jdk/src/share/classes/java/beans/Introspector.java ++++ jdk/src/share/classes/java/beans/Introspector.java +@@ -25,25 +25,18 @@ + + package java.beans; + ++import com.sun.beans.WeakCache; + import com.sun.beans.finder.ClassFinder; + +-import java.lang.ref.Reference; +-import java.lang.ref.SoftReference; +- + import java.lang.reflect.Method; + import java.lang.reflect.Modifier; + +-import java.security.AccessController; +-import java.security.PrivilegedAction; +- +-import java.util.Collections; + import java.util.Map; + import java.util.ArrayList; + import java.util.HashMap; + import java.util.Iterator; + import java.util.EventListener; + import java.util.List; +-import java.util.WeakHashMap; + import java.util.TreeMap; + import sun.awt.AppContext; + import sun.reflect.misc.ReflectUtil; +@@ -110,8 +103,8 @@ + public final static int IGNORE_ALL_BEANINFO = 3; + + // Static Caches to speed up introspection. +- private static Map declaredMethodCache = +- Collections.synchronizedMap(new WeakHashMap()); ++ private static WeakCache<Class<?>, Method[]> declaredMethodCache = ++ new WeakCache<Class<?>, Method[]>(); + + private static final Object BEANINFO_CACHE = new Object(); + +@@ -177,20 +170,21 @@ + if (!ReflectUtil.isPackageAccessible(beanClass)) { + return (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo(); + } +- Map<Class<?>, BeanInfo> map; + synchronized (BEANINFO_CACHE) { +- map = (Map<Class<?>, BeanInfo>) AppContext.getAppContext().get(BEANINFO_CACHE); +- if (map == null) { +- map = Collections.synchronizedMap(new WeakHashMap<Class<?>, BeanInfo>()); +- AppContext.getAppContext().put(BEANINFO_CACHE, map); ++ WeakCache<Class<?>, BeanInfo> beanInfoCache = ++ (WeakCache<Class<?>, BeanInfo>) AppContext.getAppContext().get(BEANINFO_CACHE); ++ ++ if (beanInfoCache == null) { ++ beanInfoCache = new WeakCache<Class<?>, BeanInfo>(); ++ AppContext.getAppContext().put(BEANINFO_CACHE, beanInfoCache); + } ++ BeanInfo beanInfo = beanInfoCache.get(beanClass); ++ if (beanInfo == null) { ++ beanInfo = (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo(); ++ beanInfoCache.put(beanClass, beanInfo); ++ } ++ return beanInfo; + } +- BeanInfo bi = map.get(beanClass); +- if (bi == null) { +- bi = (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo(); +- map.put(beanClass, bi); +- } +- return bi; + } + + /** +@@ -337,11 +331,13 @@ + */ + + public static void flushCaches() { +- Map map = (Map) AppContext.getAppContext().get(BEANINFO_CACHE); +- if (map != null) { +- map.clear(); ++ synchronized (BEANINFO_CACHE) { ++ WeakCache beanInfoCache = (WeakCache) AppContext.getAppContext().get(BEANINFO_CACHE); ++ if (beanInfoCache != null) { ++ beanInfoCache.clear(); ++ } ++ declaredMethodCache.clear(); + } +- declaredMethodCache.clear(); + } + + /** +@@ -363,11 +359,13 @@ + if (clz == null) { + throw new NullPointerException(); + } +- Map map = (Map) AppContext.getAppContext().get(BEANINFO_CACHE); +- if (map != null) { +- map.remove(clz); ++ synchronized (BEANINFO_CACHE) { ++ WeakCache beanInfoCache = (WeakCache) AppContext.getAppContext().get(BEANINFO_CACHE); ++ if (beanInfoCache != null) { ++ beanInfoCache.put(clz, null); ++ } ++ declaredMethodCache.put(clz, null); + } +- declaredMethodCache.remove(clz); + } + + //====================================================================== +@@ -1306,41 +1304,26 @@ + /* + * Internal method to return *public* methods within a class. + */ +- private static synchronized Method[] getPublicDeclaredMethods(Class clz) { ++ private static Method[] getPublicDeclaredMethods(Class clz) { + // Looking up Class.getDeclaredMethods is relatively expensive, + // so we cache the results. +- Method[] result = null; + if (!ReflectUtil.isPackageAccessible(clz)) { + return new Method[0]; + } +- final Class fclz = clz; +- Reference ref = (Reference)declaredMethodCache.get(fclz); +- if (ref != null) { +- result = (Method[])ref.get(); +- if (result != null) { +- return result; ++ synchronized (BEANINFO_CACHE) { ++ Method[] result = declaredMethodCache.get(clz); ++ if (result == null) { ++ result = clz.getMethods(); ++ for (int i = 0; i < result.length; i++) { ++ Method method = result[i]; ++ if (!method.getDeclaringClass().equals(clz)) { ++ result[i] = null; ++ } ++ } ++ declaredMethodCache.put(clz, result); + } ++ return result; + } +- +- // We have to raise privilege for getDeclaredMethods +- result = (Method[]) AccessController.doPrivileged(new PrivilegedAction() { +- public Object run() { +- return fclz.getDeclaredMethods(); +- } +- }); +- +- +- // Null out any non-public methods. +- for (int i = 0; i < result.length; i++) { +- Method method = result[i]; +- int mods = method.getModifiers(); +- if (!Modifier.isPublic(mods)) { +- result[i] = null; +- } +- } +- // Add it to the cache. +- declaredMethodCache.put(fclz, new SoftReference(result)); +- return result; + } + + //====================================================================== +diff --git a/test/java/beans/Introspector/Test5102804.java b/test/java/beans/Introspector/Test5102804.java +new file mode 100644 +--- /dev/null ++++ jdk/test/java/beans/Introspector/Test5102804.java +@@ -0,0 +1,155 @@ ++/* ++ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ */ ++ ++/* ++ * @test ++ * @bug 5102804 ++ * @summary Tests memory leak ++ * @author Sergey Malenkov ++ */ ++ ++import java.beans.BeanInfo; ++import java.beans.IntrospectionException; ++import java.beans.Introspector; ++import java.beans.PropertyDescriptor; ++import java.beans.SimpleBeanInfo; ++import java.lang.ref.Reference; ++import java.lang.ref.WeakReference; ++import java.net.URL; ++import java.net.URLClassLoader; ++ ++public class Test5102804 { ++ private static final String BEAN_NAME = "Test5102804$Example"; ++ private static final String BEAN_INFO_NAME = BEAN_NAME + "BeanInfo"; ++ ++ public static void main(String[] args) { ++ if (!isCollectible(getReference())) ++ throw new Error("Reference is not collected"); ++ } ++ ++ private static Reference getReference() { ++ try { ++ ClassLoader loader = new Loader(); ++ Class type = Class.forName(BEAN_NAME, true, loader); ++ if (!type.getClassLoader().equals(loader)) { ++ throw new Error("Wrong class loader"); ++ } ++ BeanInfo info = Introspector.getBeanInfo(type); ++ if (0 != info.getDefaultPropertyIndex()) { ++ throw new Error("Wrong bean info found"); ++ } ++ return new WeakReference<Class>(type); ++ } ++ catch (IntrospectionException exception) { ++ throw new Error("Introspection Error", exception); ++ } ++ catch (ClassNotFoundException exception) { ++ throw new Error("Class Not Found", exception); ++ } ++ } ++ ++ private static boolean isCollectible(Reference reference) { ++ int[] array = new int[10]; ++ while (true) { ++ try { ++ array = new int[array.length + array.length / 3]; ++ } ++ catch (OutOfMemoryError error) { ++ return null == reference.get(); ++ } ++ } ++ } ++ ++ /** ++ * Custom class loader to load the Example class by itself. ++ * Could also load it from a different code source, but this is easier to set up. ++ */ ++ private static final class Loader extends URLClassLoader { ++ Loader() { ++ super(new URL[] { ++ Test5102804.class.getProtectionDomain().getCodeSource().getLocation() ++ }); ++ } ++ ++ @Override ++ protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException { ++ Class c = findLoadedClass(name); ++ if (c == null) { ++ if (BEAN_NAME.equals(name) || BEAN_INFO_NAME.equals(name)) { ++ c = findClass(name); ++ } ++ else try { ++ c = getParent().loadClass(name); ++ } ++ catch (ClassNotFoundException exception) { ++ c = findClass(name); ++ } ++ } ++ if (resolve) { ++ resolveClass(c); ++ } ++ return c; ++ } ++ } ++ ++ /** ++ * A simple bean to load from the Loader class, not main class loader. ++ */ ++ public static final class Example { ++ private int value; ++ ++ public int getValue() { ++ return value; ++ } ++ ++ public void setValue(int value) { ++ this.value = value; ++ } ++ } ++ ++ /** ++ * The BeanInfo for the Example class. ++ * It is also loaded from the Loader class. ++ */ ++ public static final class ExampleBeanInfo extends SimpleBeanInfo { ++ @Override ++ public int getDefaultPropertyIndex() { ++ return 0; ++ } ++ ++ @Override ++ public PropertyDescriptor[] getPropertyDescriptors() { ++ try { ++ return new PropertyDescriptor[] { ++ new PropertyDescriptor("value", Class.forName(BEAN_NAME)) ++ }; ++ } ++ catch (ClassNotFoundException exception) { ++ return null; ++ } ++ catch (IntrospectionException exception) { ++ return null; ++ } ++ } ++ } ++} diff --git a/java/openjdk6/files/icedtea/openjdk/6501644-icu_sync.patch b/java/openjdk6/files/icedtea/openjdk/6501644-icu_sync.patch new file mode 100644 index 000000000000..299a59691ef8 --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/6501644-icu_sync.patch @@ -0,0 +1,8066 @@ +# HG changeset patch +# User andrew +# Date 1365739093 -3600 +# Node ID e8ed86062291305172267be90dcec2acef7c15a8 +# Parent c7ddbf756d7f35d6e782eb91b86ce2938de44fb8 +6501644: sync LayoutEngine *code* structure to match ICU +Reviewed-by: prr + +diff --git a/make/sun/font/Makefile b/make/sun/font/Makefile +--- jdk/make/sun/font/Makefile ++++ jdk/make/sun/font/Makefile +@@ -209,3 +209,7 @@ + -I$(PLATFORM_SRC)/native/sun/java2d/d3d + endif + ++# Make the Layout Engine build standalone ++CPPFLAGS += -DLE_STANDALONE ++ ++ +diff --git a/src/share/native/sun/font/layout/AlternateSubstSubtables.cpp b/src/share/native/sun/font/layout/AlternateSubstSubtables.cpp +--- jdk/src/share/native/sun/font/layout/AlternateSubstSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/AlternateSubstSubtables.cpp +@@ -37,6 +37,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_uint32 AlternateSubstitutionSubtable::process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter) const + { + // NOTE: For now, we'll just pick the first alternative... +@@ -64,3 +66,5 @@ + + return 0; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/AlternateSubstSubtables.h b/src/share/native/sun/font/layout/AlternateSubstSubtables.h +--- jdk/src/share/native/sun/font/layout/AlternateSubstSubtables.h ++++ jdk/src/share/native/sun/font/layout/AlternateSubstSubtables.h +@@ -32,12 +32,19 @@ + #ifndef __ALTERNATESUBSTITUTIONSUBTABLES_H + #define __ALTERNATESUBSTITUTIONSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEGlyphFilter.h" + #include "OpenTypeTables.h" + #include "GlyphSubstitutionTables.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct AlternateSetTable + { + le_uint16 glyphCount; +@@ -52,4 +59,5 @@ + le_uint32 process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter = NULL) const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/AnchorTables.cpp b/src/share/native/sun/font/layout/AnchorTables.cpp +--- jdk/src/share/native/sun/font/layout/AnchorTables.cpp ++++ jdk/src/share/native/sun/font/layout/AnchorTables.cpp +@@ -35,6 +35,8 @@ + #include "AnchorTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + void AnchorTable::getAnchor(LEGlyphID glyphID, const LEFontInstance *fontInstance, + LEPoint &anchor) const + { +@@ -124,3 +126,6 @@ + + fontInstance->pixelsToUnits(pixels, anchor); + } ++ ++U_NAMESPACE_END ++ +diff --git a/src/share/native/sun/font/layout/AnchorTables.h b/src/share/native/sun/font/layout/AnchorTables.h +--- jdk/src/share/native/sun/font/layout/AnchorTables.h ++++ jdk/src/share/native/sun/font/layout/AnchorTables.h +@@ -32,10 +32,17 @@ + #ifndef __ANCHORTABLES_H + #define __ANCHORTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + struct AnchorTable + { + le_uint16 anchorFormat; +@@ -66,5 +73,7 @@ + void getAnchor(const LEFontInstance *fontInstance, LEPoint &anchor) const; + }; + ++U_NAMESPACE_END ++#endif + +-#endif ++ +diff --git a/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp b/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp +@@ -49,23 +49,25 @@ + #include "ArabicShaping.h" + #include "CanonShaping.h" + ++U_NAMESPACE_BEGIN ++ + le_bool CharSubstitutionFilter::accept(LEGlyphID glyph) const + { + return fFontInstance->canDisplay((LEUnicode) glyph); + } + +-ArabicOpenTypeLayoutEngine::ArabicOpenTypeLayoutEngine( +- const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ArabicOpenTypeLayoutEngine) ++ ++ArabicOpenTypeLayoutEngine::ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) + : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable) + { + fFeatureMap = ArabicShaping::getFeatureMap(fFeatureMapCount); + fFeatureOrder = TRUE; + } + +-ArabicOpenTypeLayoutEngine::ArabicOpenTypeLayoutEngine( +- const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) ++ArabicOpenTypeLayoutEngine::ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags) + : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags) + { + fFeatureMap = ArabicShaping::getFeatureMap(fFeatureMapCount); +@@ -86,9 +88,8 @@ + // Input: characters + // Output: characters, char indices, tags + // Returns: output character count +-le_int32 ArabicOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 ArabicOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -124,8 +125,8 @@ + return count; + } + +-void ArabicOpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++void ArabicOpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return; +@@ -137,24 +138,20 @@ + } + + if (fGPOSTable != NULL) { +- OpenTypeLayoutEngine::adjustGlyphPositions(chars, offset, count, +- reverse, glyphStorage, success); ++ OpenTypeLayoutEngine::adjustGlyphPositions(chars, offset, count, reverse, glyphStorage, success); + } else if (fGDEFTable != NULL) { + GDEFMarkFilter filter(fGDEFTable); + + adjustMarkGlyphs(glyphStorage, &filter, success); + } else { +- GlyphDefinitionTableHeader *gdefTable = +- (GlyphDefinitionTableHeader *) CanonShaping::glyphDefinitionTable; ++ GlyphDefinitionTableHeader *gdefTable = (GlyphDefinitionTableHeader *) CanonShaping::glyphDefinitionTable; + GDEFMarkFilter filter(gdefTable); + + adjustMarkGlyphs(&chars[offset], count, reverse, glyphStorage, &filter, success); + } + } + +-UnicodeArabicOpenTypeLayoutEngine::UnicodeArabicOpenTypeLayoutEngine( +- const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) ++UnicodeArabicOpenTypeLayoutEngine::UnicodeArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) + : ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags | LE_CHAR_FILTER_FEATURE_FLAG) + { + fGSUBTable = (const GlyphSubstitutionTableHeader *) CanonShaping::glyphSubstitutionTable; +@@ -168,8 +165,7 @@ + } + + // "glyphs", "indices" -> glyphs, indices +-le_int32 UnicodeArabicOpenTypeLayoutEngine::glyphPostProcessing( +- LEGlyphStorage &tempGlyphStorage, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 UnicodeArabicOpenTypeLayoutEngine::glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -192,17 +188,14 @@ + + glyphStorage.adoptCharIndicesArray(tempGlyphStorage); + +- ArabicOpenTypeLayoutEngine::mapCharsToGlyphs(tempChars, 0, tempGlyphCount, FALSE, +- TRUE, glyphStorage, success); ++ ArabicOpenTypeLayoutEngine::mapCharsToGlyphs(tempChars, 0, tempGlyphCount, FALSE, TRUE, glyphStorage, success); + + LE_DELETE_ARRAY(tempChars); + + return tempGlyphCount; + } + +-void UnicodeArabicOpenTypeLayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_bool reverse, le_bool /*mirror*/, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++void UnicodeArabicOpenTypeLayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, le_bool /*mirror*/, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return; +@@ -227,9 +220,8 @@ + } + } + +-void UnicodeArabicOpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_bool reverse, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++void UnicodeArabicOpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return; +@@ -244,3 +236,6 @@ + + adjustMarkGlyphs(&chars[offset], count, reverse, glyphStorage, &filter, success); + } ++ ++U_NAMESPACE_END ++ +diff --git a/src/share/native/sun/font/layout/ArabicLayoutEngine.h b/src/share/native/sun/font/layout/ArabicLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.h +@@ -43,6 +43,8 @@ + #include "GlyphDefinitionTables.h" + #include "GlyphPositioningTables.h" + ++U_NAMESPACE_BEGIN ++ + /** + * This class implements OpenType layout for Arabic fonts. It overrides + * the characerProcessing method to assign the correct OpenType feature +@@ -71,8 +73,8 @@ + * + * @internal + */ +- ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, +- le_int32 languageCode, le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); + + /** + * This constructor is used when the font requires a "canned" GSUB table which can't be known +@@ -87,8 +89,8 @@ + * + * @internal + */ +- ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, +- le_int32 languageCode, le_int32 typoFlags); ++ ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -97,6 +99,20 @@ + */ + virtual ~ArabicOpenTypeLayoutEngine(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + protected: + + /** +@@ -108,8 +124,7 @@ + * @param offset - the index of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - <code>TRUE</code> if the characters are in a +- * right to left directional run ++ * @param rightToLeft - <code>TRUE</code> if the characters are in a right to left directional run + * + * Output parameters: + * @param outChars - the output character arrayt +@@ -121,9 +136,8 @@ + * + * @internal + */ +- virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** + * This method applies the GPOS table if it is present, otherwise it ensures that all vowel +@@ -142,11 +156,9 @@ + * + * @internal + */ +- virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); + +- // static void adjustMarkGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, +- // le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ // static void adjustMarkGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + }; + +@@ -178,8 +190,8 @@ + * + * @internal + */ +- UnicodeArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags); ++ UnicodeArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -208,8 +220,7 @@ + * + * @internal + */ +- virtual le_int32 glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, +- LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** + * This method copies the input characters into the output glyph index array, +@@ -227,8 +238,7 @@ + * + * @internal + */ +- virtual void mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, le_bool mirror, ++ virtual void mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, le_bool mirror, + LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** +@@ -245,8 +255,9 @@ + * + * @internal + */ +- virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/ArabicShaping.cpp b/src/share/native/sun/font/layout/ArabicShaping.cpp +--- jdk/src/share/native/sun/font/layout/ArabicShaping.cpp ++++ jdk/src/share/native/sun/font/layout/ArabicShaping.cpp +@@ -35,6 +35,8 @@ + #include "LEGlyphStorage.h" + #include "ClassDefinitionTables.h" + ++U_NAMESPACE_BEGIN ++ + // This table maps Unicode joining types to + // ShapeTypes. + const ArabicShaping::ShapeType ArabicShaping::shapeTypes[] = +@@ -102,9 +104,7 @@ + #define markFeatureMask 0x00040000UL + #define mkmkFeatureMask 0x00020000UL + +-#define ISOL_FEATURES (isolFeatureMask | ligaFeatureMask | msetFeatureMask | \ +- markFeatureMask | ccmpFeatureMask | rligFeatureMask | caltFeatureMask | \ +- dligFeatureMask | cswhFeatureMask | cursFeatureMask | kernFeatureMask | mkmkFeatureMask) ++#define ISOL_FEATURES (isolFeatureMask | ligaFeatureMask | msetFeatureMask | markFeatureMask | ccmpFeatureMask | rligFeatureMask | caltFeatureMask | dligFeatureMask | cswhFeatureMask | cursFeatureMask | kernFeatureMask | mkmkFeatureMask) + + #define SHAPE_MASK 0xF0000000UL + +@@ -226,3 +226,5 @@ + adjustTags(erout, 2, glyphStorage); + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ArabicShaping.h b/src/share/native/sun/font/layout/ArabicShaping.h +--- jdk/src/share/native/sun/font/layout/ArabicShaping.h ++++ jdk/src/share/native/sun/font/layout/ArabicShaping.h +@@ -32,12 +32,19 @@ + #ifndef __ARABICSHAPING_H + #define __ARABICSHAPING_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + +-class ArabicShaping { ++class ArabicShaping /* not : public UObject because all methods are static */ { + public: + // Joining types + enum JoiningTypes +@@ -74,8 +81,8 @@ + + typedef le_int32 ShapeType; + +- static void shape(const LEUnicode *chars, le_int32 offset, le_int32 charCount, +- le_int32 charMax, le_bool rightToLeft, LEGlyphStorage &glyphStorage); ++ static void shape(const LEUnicode *chars, le_int32 offset, le_int32 charCount, le_int32 charMax, ++ le_bool rightToLeft, LEGlyphStorage &glyphStorage); + + static const FeatureMap *getFeatureMap(le_int32 &count); + +@@ -88,8 +95,8 @@ + static const le_uint8 shapingTypeTable[]; + static const ShapeType shapeTypes[]; + +- static void adjustTags(le_int32 outIndex, le_int32 shapeOffset, +- LEGlyphStorage &glyphStorage); ++ static void adjustTags(le_int32 outIndex, le_int32 shapeOffset, LEGlyphStorage &glyphStorage); + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/AttachmentPosnSubtables.h b/src/share/native/sun/font/layout/AttachmentPosnSubtables.h +--- jdk/src/share/native/sun/font/layout/AttachmentPosnSubtables.h ++++ jdk/src/share/native/sun/font/layout/AttachmentPosnSubtables.h +@@ -32,12 +32,19 @@ + #ifndef __ATTACHMENTPOSITIONINGSUBTABLES_H + #define __ATTACHMENTPOSITIONINGSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + #include "GlyphPositioningTables.h" + #include "ValueRecords.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct AttachmentPositioningSubtable : GlyphPositioningSubtable + { + Offset baseCoverageTableOffset; +@@ -55,4 +62,6 @@ + return getGlyphCoverage(baseCoverageTableOffset, baseGlyphID); + } + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/CanonData.cpp b/src/share/native/sun/font/layout/CanonData.cpp +--- jdk/src/share/native/sun/font/layout/CanonData.cpp ++++ jdk/src/share/native/sun/font/layout/CanonData.cpp +@@ -36,6 +36,8 @@ + #include "LETypes.h" + #include "CanonShaping.h" + ++U_NAMESPACE_BEGIN ++ + const le_uint8 CanonShaping::glyphSubstitutionTable[] = { + 0x00, 0x01, 0x00, 0x00, 0x00, 0x0A, 0x01, 0x58, 0x02, 0x86, 0x00, 0x12, 0x61, 0x72, 0x61, 0x62, + 0x00, 0x6E, 0x62, 0x65, 0x6E, 0x67, 0x00, 0x82, 0x63, 0x79, 0x72, 0x6C, 0x00, 0x8E, 0x64, 0x65, +@@ -3773,3 +3775,5 @@ + 0x00, 0xDC, 0xD1, 0x85, 0xD1, 0x89, 0x00, 0xE6, 0xD1, 0x8A, 0xD1, 0x8B, 0x00, 0xDC, 0xD1, 0xAA, + 0xD1, 0xAD, 0x00, 0xE6, 0xD2, 0x42, 0xD2, 0x44, 0x00, 0xE6 + }; ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/CanonShaping.cpp b/src/share/native/sun/font/layout/CanonShaping.cpp +--- jdk/src/share/native/sun/font/layout/CanonShaping.cpp ++++ jdk/src/share/native/sun/font/layout/CanonShaping.cpp +@@ -35,8 +35,9 @@ + #include "GlyphDefinitionTables.h" + #include "ClassDefinitionTables.h" + +-void CanonShaping::sortMarks(le_int32 *indices, +- const le_int32 *combiningClasses, le_int32 index, le_int32 limit) ++U_NAMESPACE_BEGIN ++ ++void CanonShaping::sortMarks(le_int32 *indices, const le_int32 *combiningClasses, le_int32 index, le_int32 limit) + { + for (le_int32 j = index + 1; j < limit; j += 1) { + le_int32 i; +@@ -55,13 +56,11 @@ + } + } + +-void CanonShaping::reorderMarks(const LEUnicode *inChars, le_int32 charCount, +- le_bool rightToLeft, LEUnicode *outChars, LEGlyphStorage &glyphStorage) ++void CanonShaping::reorderMarks(const LEUnicode *inChars, le_int32 charCount, le_bool rightToLeft, ++ LEUnicode *outChars, LEGlyphStorage &glyphStorage) + { +- const GlyphDefinitionTableHeader *gdefTable = +- (const GlyphDefinitionTableHeader *) glyphDefinitionTable; +- const ClassDefinitionTable *classTable = +- gdefTable->getMarkAttachClassDefinitionTable(); ++ const GlyphDefinitionTableHeader *gdefTable = (const GlyphDefinitionTableHeader *) glyphDefinitionTable; ++ const ClassDefinitionTable *classTable = gdefTable->getMarkAttachClassDefinitionTable(); + le_int32 *combiningClasses = LE_NEW_ARRAY(le_int32, charCount); + le_int32 *indices = LE_NEW_ARRAY(le_int32, charCount); + LEErrorCode status = LE_NO_ERROR; +@@ -103,3 +102,5 @@ + LE_DELETE_ARRAY(indices); + LE_DELETE_ARRAY(combiningClasses); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/CanonShaping.h b/src/share/native/sun/font/layout/CanonShaping.h +--- jdk/src/share/native/sun/font/layout/CanonShaping.h ++++ jdk/src/share/native/sun/font/layout/CanonShaping.h +@@ -34,20 +34,22 @@ + + #include "LETypes.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + +-class CanonShaping ++class CanonShaping /* not : public UObject because all members are static */ + { + public: + static const le_uint8 glyphSubstitutionTable[]; + static const le_uint8 glyphDefinitionTable[]; + +- static void reorderMarks(const LEUnicode *inChars, le_int32 charCount, +- le_bool rightToLeft, LEUnicode *outChars, LEGlyphStorage &glyphStorage); ++ static void reorderMarks(const LEUnicode *inChars, le_int32 charCount, le_bool rightToLeft, ++ LEUnicode *outChars, LEGlyphStorage &glyphStorage); + + private: +- static void sortMarks(le_int32 *indices, const le_int32 *combiningClasses, +- le_int32 index, le_int32 limit); ++ static void sortMarks(le_int32 *indices, const le_int32 *combiningClasses, le_int32 index, le_int32 limit); + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/CharSubstitutionFilter.h b/src/share/native/sun/font/layout/CharSubstitutionFilter.h +--- jdk/src/share/native/sun/font/layout/CharSubstitutionFilter.h ++++ jdk/src/share/native/sun/font/layout/CharSubstitutionFilter.h +@@ -35,6 +35,8 @@ + #include "LETypes.h" + #include "LEGlyphFilter.h" + ++U_NAMESPACE_BEGIN ++ + class LEFontInstance; + + /** +@@ -43,7 +45,7 @@ + * + * @internal + */ +-class CharSubstitutionFilter : public LEGlyphFilter ++class CharSubstitutionFilter : public UMemory, public LEGlyphFilter + { + private: + /** +@@ -98,4 +100,7 @@ + le_bool accept(LEGlyphID glyph) const; + }; + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/ClassDefinitionTables.cpp b/src/share/native/sun/font/layout/ClassDefinitionTables.cpp +--- jdk/src/share/native/sun/font/layout/ClassDefinitionTables.cpp ++++ jdk/src/share/native/sun/font/layout/ClassDefinitionTables.cpp +@@ -35,6 +35,8 @@ + #include "ClassDefinitionTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_int32 ClassDefinitionTable::getGlyphClass(LEGlyphID glyphID) const + { + switch(SWAPW(classFormat)) { +@@ -139,3 +141,5 @@ + + return FALSE; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ClassDefinitionTables.h b/src/share/native/sun/font/layout/ClassDefinitionTables.h +--- jdk/src/share/native/sun/font/layout/ClassDefinitionTables.h ++++ jdk/src/share/native/sun/font/layout/ClassDefinitionTables.h +@@ -32,9 +32,16 @@ + #ifndef __CLASSDEFINITIONTABLES_H + #define __CLASSDEFINITIONTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + struct ClassDefinitionTable + { + le_uint16 classFormat; +@@ -69,4 +76,5 @@ + le_bool hasGlyphClass(le_int32 glyphClass) const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/ContextualGlyphInsertion.h b/src/share/native/sun/font/layout/ContextualGlyphInsertion.h +--- jdk/src/share/native/sun/font/layout/ContextualGlyphInsertion.h ++++ jdk/src/share/native/sun/font/layout/ContextualGlyphInsertion.h +@@ -32,12 +32,19 @@ + #ifndef __CONTEXTUALGLYPHINSERTION_H + #define __CONTEXTUALGLYPHINSERTION_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + #include "StateTables.h" + #include "MorphTables.h" + #include "MorphStateTables.h" + ++U_NAMESPACE_BEGIN ++ + struct ContextualGlyphInsertionHeader : MorphStateTableHeader + { + }; +@@ -60,4 +67,5 @@ + ByteOffset markedInsertionListOffset; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/ContextualGlyphSubstProc.cpp b/src/share/native/sun/font/layout/ContextualGlyphSubstProc.cpp +--- jdk/src/share/native/sun/font/layout/ContextualGlyphSubstProc.cpp ++++ jdk/src/share/native/sun/font/layout/ContextualGlyphSubstProc.cpp +@@ -39,6 +39,10 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ContextualGlyphSubstitutionProcessor) ++ + ContextualGlyphSubstitutionProcessor::ContextualGlyphSubstitutionProcessor(const MorphSubtableHeader *morphSubtableHeader) + : StateTableProcessor(morphSubtableHeader) + { +@@ -57,8 +61,7 @@ + markGlyph = 0; + } + +-ByteOffset ContextualGlyphSubstitutionProcessor::processStateEntry(LEGlyphStorage &glyphStorage, +- le_int32 &currGlyph, EntryTableIndex index) ++ByteOffset ContextualGlyphSubstitutionProcessor::processStateEntry(LEGlyphStorage &glyphStorage, le_int32 &currGlyph, EntryTableIndex index) + { + const ContextualGlyphSubstitutionStateEntry *entry = &entryTable[index]; + ByteOffset newState = SWAPW(entry->newStateOffset); +@@ -97,3 +100,5 @@ + void ContextualGlyphSubstitutionProcessor::endStateTable() + { + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ContextualGlyphSubstProc.h b/src/share/native/sun/font/layout/ContextualGlyphSubstProc.h +--- jdk/src/share/native/sun/font/layout/ContextualGlyphSubstProc.h ++++ jdk/src/share/native/sun/font/layout/ContextualGlyphSubstProc.h +@@ -32,12 +32,19 @@ + #ifndef __CONTEXTUALGLYPHSUBSTITUTIONPROCESSOR_H + #define __CONTEXTUALGLYPHSUBSTITUTIONPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "StateTableProcessor.h" + #include "ContextualGlyphSubstitution.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class ContextualGlyphSubstitutionProcessor : public StateTableProcessor +@@ -52,6 +59,20 @@ + ContextualGlyphSubstitutionProcessor(const MorphSubtableHeader *morphSubtableHeader); + virtual ~ContextualGlyphSubstitutionProcessor(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + ContextualGlyphSubstitutionProcessor(); + +@@ -62,6 +83,8 @@ + le_int32 markGlyph; + + const ContextualGlyphSubstitutionHeader *contextualGlyphSubstitutionHeader; ++ + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/ContextualGlyphSubstitution.h b/src/share/native/sun/font/layout/ContextualGlyphSubstitution.h +--- jdk/src/share/native/sun/font/layout/ContextualGlyphSubstitution.h ++++ jdk/src/share/native/sun/font/layout/ContextualGlyphSubstitution.h +@@ -32,11 +32,18 @@ + #ifndef __CONTEXTUALGLYPHSUBSTITUTION_H + #define __CONTEXTUALGLYPHSUBSTITUTION_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + #include "StateTables.h" + #include "MorphTables.h" + ++U_NAMESPACE_BEGIN ++ + struct ContextualGlyphSubstitutionHeader : MorphStateTableHeader + { + ByteOffset substitutionTableOffset; +@@ -55,4 +62,5 @@ + WordOffset currOffset; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp b/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp +--- jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp +@@ -24,7 +24,6 @@ + */ + + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -39,6 +38,8 @@ + #include "CoverageTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + /* + NOTE: This could be optimized somewhat by keeping track + of the previous sequenceIndex in the loop and doing next() +@@ -350,7 +351,7 @@ + + // NOTE: This could be a #define, but that seems to confuse + // the Visual Studio .NET 2003 compiler on the calls to the +-// GlyphIterator constructor. It somehow can't decide if ++// GlyphIterator constructor. It somehow can't decide if + // emptyFeatureList matches an le_uint32 or an le_uint16... + static const FeatureMask emptyFeatureList = 0x00000000UL; + +@@ -542,3 +543,5 @@ + + return 0; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ContextualSubstSubtables.h b/src/share/native/sun/font/layout/ContextualSubstSubtables.h +--- jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.h ++++ jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.h +@@ -32,6 +32,11 @@ + #ifndef __CONTEXTUALSUBSTITUTIONSUBTABLES_H + #define __CONTEXTUALSUBSTITUTIONSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +@@ -39,6 +44,8 @@ + #include "GlyphIterator.h" + #include "LookupProcessor.h" + ++U_NAMESPACE_BEGIN ++ + struct SubstitutionLookupRecord + { + le_uint16 sequenceIndex; +@@ -218,4 +225,5 @@ + le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/CoverageTables.cpp b/src/share/native/sun/font/layout/CoverageTables.cpp +--- jdk/src/share/native/sun/font/layout/CoverageTables.cpp ++++ jdk/src/share/native/sun/font/layout/CoverageTables.cpp +@@ -35,6 +35,8 @@ + #include "CoverageTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_int32 CoverageTable::getGlyphCoverage(LEGlyphID glyphID) const + { + switch(SWAPW(coverageFormat)) +@@ -106,3 +108,5 @@ + + return startCoverageIndex + (ttGlyphID - firstInRange); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/CoverageTables.h b/src/share/native/sun/font/layout/CoverageTables.h +--- jdk/src/share/native/sun/font/layout/CoverageTables.h ++++ jdk/src/share/native/sun/font/layout/CoverageTables.h +@@ -32,9 +32,16 @@ + #ifndef __COVERAGETABLES_H + #define __COVERAGETABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + struct CoverageTable + { + le_uint16 coverageFormat; +@@ -58,5 +65,5 @@ + le_int32 getGlyphCoverage(LEGlyphID glyphID) const; + }; + +- ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp b/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp +--- jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp +@@ -37,6 +37,8 @@ + #include "OpenTypeUtilities.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_uint32 CursiveAttachmentSubtable::process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const + { + LEGlyphID glyphID = glyphIterator->getCurrGlyphID(); +@@ -68,3 +70,5 @@ + + return 1; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/CursiveAttachmentSubtables.h b/src/share/native/sun/font/layout/CursiveAttachmentSubtables.h +--- jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.h ++++ jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.h +@@ -32,10 +32,17 @@ + #ifndef __CURSIVEATTACHMENTSUBTABLES_H + #define __CURSIVEATTACHMENTSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + #include "GlyphPositioningTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEFontInstance; + class GlyphIterator; + +@@ -53,4 +60,7 @@ + le_uint32 process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; + }; + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/DefaultCharMapper.h b/src/share/native/sun/font/layout/DefaultCharMapper.h +--- jdk/src/share/native/sun/font/layout/DefaultCharMapper.h ++++ jdk/src/share/native/sun/font/layout/DefaultCharMapper.h +@@ -24,7 +24,6 @@ + */ + + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -32,9 +31,16 @@ + #ifndef __DEFAULTCHARMAPPER_H + #define __DEFAULTCHARMAPPER_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + ++U_NAMESPACE_BEGIN ++ + /** + * This class is an instance of LECharMapper which + * implements control character filtering and bidi +@@ -42,7 +48,7 @@ + * + * @see LECharMapper + */ +-class DefaultCharMapper : public LECharMapper ++class DefaultCharMapper : public UMemory, public LECharMapper + { + private: + le_bool fFilterControls; +@@ -77,4 +83,5 @@ + LEUnicode32 mapChar(LEUnicode32 ch) const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/DeviceTables.cpp b/src/share/native/sun/font/layout/DeviceTables.cpp +--- jdk/src/share/native/sun/font/layout/DeviceTables.cpp ++++ jdk/src/share/native/sun/font/layout/DeviceTables.cpp +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 1998 - 2005 - All Rights Reserved + * + */ +@@ -34,6 +35,8 @@ + #include "DeviceTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + const le_uint16 DeviceTable::fieldMasks[] = {0x0003, 0x000F, 0x00FF}; + const le_uint16 DeviceTable::fieldSignBits[] = {0x0002, 0x0008, 0x0080}; + const le_uint16 DeviceTable::fieldBits[] = { 2, 4, 8}; +@@ -62,3 +65,5 @@ + + return result; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/DeviceTables.h b/src/share/native/sun/font/layout/DeviceTables.h +--- jdk/src/share/native/sun/font/layout/DeviceTables.h ++++ jdk/src/share/native/sun/font/layout/DeviceTables.h +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -32,10 +33,15 @@ + #ifndef __DEVICETABLES_H + #define __DEVICETABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" +-#include "GlyphIterator.h" +-#include "GlyphPositionAdjustments.h" ++ ++U_NAMESPACE_BEGIN + + struct DeviceTable + { +@@ -52,5 +58,7 @@ + static const le_uint16 fieldBits[]; + }; + ++U_NAMESPACE_END ++#endif + +-#endif ++ +diff --git a/src/share/native/sun/font/layout/ExtensionSubtables.cpp b/src/share/native/sun/font/layout/ExtensionSubtables.cpp +--- jdk/src/share/native/sun/font/layout/ExtensionSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/ExtensionSubtables.cpp +@@ -25,7 +25,8 @@ + + /* + * +- * (C) Copyright IBM Corp. 2003 - All Rights Reserved ++ * ++ * (C) Copyright IBM Corp. 2002 - All Rights Reserved + * + */ + +@@ -37,6 +38,9 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ ++ + // FIXME: should look at the format too... maybe have a sub-class for it? + le_uint32 ExtensionSubtable::process(const LookupProcessor *lookupProcessor, le_uint16 lookupType, + GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const +@@ -52,3 +56,5 @@ + + return 0; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ExtensionSubtables.h b/src/share/native/sun/font/layout/ExtensionSubtables.h +--- jdk/src/share/native/sun/font/layout/ExtensionSubtables.h ++++ jdk/src/share/native/sun/font/layout/ExtensionSubtables.h +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 2002-2003 - All Rights Reserved + * + */ +@@ -32,12 +33,19 @@ + #ifndef __EXTENSIONSUBTABLES_H + #define __EXTENSIONSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + #include "GlyphSubstitutionTables.h" + #include "LookupProcessor.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct ExtensionSubtable //: GlyphSubstitutionSubtable + { + le_uint16 substFormat; +@@ -48,4 +56,5 @@ + GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/Features.cpp b/src/share/native/sun/font/layout/Features.cpp +--- jdk/src/share/native/sun/font/layout/Features.cpp ++++ jdk/src/share/native/sun/font/layout/Features.cpp +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved + * + */ +@@ -35,6 +36,8 @@ + #include "Features.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + const FeatureTable *FeatureListTable::getFeatureTable(le_uint16 featureIndex, LETag *featureTag) const + { + if (featureIndex >= SWAPW(featureCount)) { +@@ -79,3 +82,5 @@ + return 0; + #endif + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/Features.h b/src/share/native/sun/font/layout/Features.h +--- jdk/src/share/native/sun/font/layout/Features.h ++++ jdk/src/share/native/sun/font/layout/Features.h +@@ -32,9 +32,16 @@ + #ifndef __FEATURES_H + #define __FEATURES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + struct FeatureRecord + { + ATag featureTag; +@@ -53,9 +60,10 @@ + le_uint16 featureCount; + FeatureRecord featureRecordArray[ANY_NUMBER]; + +- const FeatureTable *getFeatureTable(le_uint16 featureIndex, LETag *featureTag) const; ++ const FeatureTable *getFeatureTable(le_uint16 featureIndex, LETag *featureTag) const; + + const FeatureTable *getFeatureTable(LETag featureTag) const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/GDEFMarkFilter.cpp b/src/share/native/sun/font/layout/GDEFMarkFilter.cpp +--- jdk/src/share/native/sun/font/layout/GDEFMarkFilter.cpp ++++ jdk/src/share/native/sun/font/layout/GDEFMarkFilter.cpp +@@ -34,6 +34,8 @@ + #include "GDEFMarkFilter.h" + #include "GlyphDefinitionTables.h" + ++U_NAMESPACE_BEGIN ++ + GDEFMarkFilter::GDEFMarkFilter(const GlyphDefinitionTableHeader *gdefTable) + { + classDefTable = gdefTable->getGlyphClassDefinitionTable(); +@@ -50,3 +52,5 @@ + + return glyphClass == gcdMarkGlyph; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GDEFMarkFilter.h b/src/share/native/sun/font/layout/GDEFMarkFilter.h +--- jdk/src/share/native/sun/font/layout/GDEFMarkFilter.h ++++ jdk/src/share/native/sun/font/layout/GDEFMarkFilter.h +@@ -32,11 +32,18 @@ + #ifndef __GDEFMARKFILTER__H + #define __GDEFMARKFILTER__H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEGlyphFilter.h" + #include "GlyphDefinitionTables.h" + +-class GDEFMarkFilter : public LEGlyphFilter ++U_NAMESPACE_BEGIN ++ ++class GDEFMarkFilter : public UMemory, public LEGlyphFilter + { + private: + const GlyphClassDefinitionTable *classDefTable; +@@ -51,5 +58,5 @@ + virtual le_bool accept(LEGlyphID glyph) const; + }; + +- ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/GXLayoutEngine.cpp b/src/share/native/sun/font/layout/GXLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/GXLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/GXLayoutEngine.cpp +@@ -23,6 +23,7 @@ + * + */ + ++ + /* + * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved +@@ -36,8 +37,11 @@ + + #include "MorphTables.h" + +-GXLayoutEngine::GXLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, +- le_int32 languageCode, const MorphTableHeader *morphTable) ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(GXLayoutEngine) ++ ++GXLayoutEngine::GXLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, const MorphTableHeader *morphTable) + : LayoutEngine(fontInstance, scriptCode, languageCode, 0), fMorphTable(morphTable) + { + // nothing else to do? +@@ -49,9 +53,7 @@ + } + + // apply 'mort' table +-le_int32 GXLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, +- LEErrorCode &success) ++le_int32 GXLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -74,9 +76,8 @@ + } + + // apply positional tables +-void GXLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_bool /*reverse*/, +- LEGlyphStorage &/*glyphStorage*/, LEErrorCode &success) ++void GXLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool /*reverse*/, ++ LEGlyphStorage &/*glyphStorage*/, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return; +@@ -89,3 +90,5 @@ + + // FIXME: no positional processing yet... + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GXLayoutEngine.h b/src/share/native/sun/font/layout/GXLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/GXLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/GXLayoutEngine.h +@@ -23,6 +23,7 @@ + * + */ + ++ + /* + * + * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved +@@ -37,6 +38,8 @@ + + #include "MorphTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEFontInstance; + class LEGlyphStorage; + +@@ -70,8 +73,7 @@ + * + * @internal + */ +- GXLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, +- le_int32 languageCode, const MorphTableHeader *morphTable); ++ GXLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, const MorphTableHeader *morphTable); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -80,6 +82,20 @@ + */ + virtual ~GXLayoutEngine(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + protected: + + /** +@@ -99,10 +115,8 @@ + * @param offset - the index of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - <code>TRUE</code> if the text is in a +- * right to left directional run +- * @param glyphStorage - the glyph storage object. The glyph +- * and char index arrays will be set. ++ * @param rightToLeft - <code>TRUE</code> if the text is in a right to left directional run ++ * @param glyphStorage - the glyph storage object. The glyph and char index arrays will be set. + * + * Output parameters: + * @param success - set to an error code if the operation fails +@@ -111,8 +125,7 @@ + * + * @internal + */ +- virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, ++ virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, + LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** +@@ -120,16 +133,18 @@ + * 'kern', 'trak', 'bsln', 'opbd' and 'just' tables. + * + * Input parameters: +- * @param glyphStorage - the object holding the glyph storage. +- * The positions will be updated as needed. ++ * @param glyphStorage - the object holding the glyph storage. The positions will be updated as needed. + * + * Output parameters: + * @param success - set to an error code if the operation fails + * + * @internal + */ +- virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/GlyphDefinitionTables.cpp b/src/share/native/sun/font/layout/GlyphDefinitionTables.cpp +--- jdk/src/share/native/sun/font/layout/GlyphDefinitionTables.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphDefinitionTables.cpp +@@ -34,6 +34,8 @@ + #include "GlyphDefinitionTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + const GlyphClassDefinitionTable *GlyphDefinitionTableHeader::getGlyphClassDefinitionTable() const + { + return (const GlyphClassDefinitionTable *) ((char *) this + SWAPW(glyphClassDefOffset)); +@@ -53,3 +55,5 @@ + { + return (const MarkAttachClassDefinitionTable *) ((char *) this + SWAPW(MarkAttachClassDefOffset)); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphDefinitionTables.h b/src/share/native/sun/font/layout/GlyphDefinitionTables.h +--- jdk/src/share/native/sun/font/layout/GlyphDefinitionTables.h ++++ jdk/src/share/native/sun/font/layout/GlyphDefinitionTables.h +@@ -32,10 +32,17 @@ + #ifndef __GLYPHDEFINITIONTABLES_H + #define __GLYPHDEFINITIONTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + #include "ClassDefinitionTables.h" + ++U_NAMESPACE_BEGIN ++ + typedef ClassDefinitionTable GlyphClassDefinitionTable; + + enum GlyphClassDefinitions +@@ -110,4 +117,5 @@ + const MarkAttachClassDefinitionTable *getMarkAttachClassDefinitionTable() const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/GlyphIterator.cpp b/src/share/native/sun/font/layout/GlyphIterator.cpp +--- jdk/src/share/native/sun/font/layout/GlyphIterator.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphIterator.cpp +@@ -38,11 +38,10 @@ + #include "Lookups.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN + +-GlyphIterator::GlyphIterator(LEGlyphStorage &theGlyphStorage, +- GlyphPositionAdjustments *theGlyphPositionAdjustments, +- le_bool rightToLeft, le_uint16 theLookupFlags, FeatureMask theFeatureMask, +- const GlyphDefinitionTableHeader *theGlyphDefinitionTableHeader) ++GlyphIterator::GlyphIterator(LEGlyphStorage &theGlyphStorage, GlyphPositionAdjustments *theGlyphPositionAdjustments, le_bool rightToLeft, le_uint16 theLookupFlags, ++ FeatureMask theFeatureMask, const GlyphDefinitionTableHeader *theGlyphDefinitionTableHeader) + : direction(1), position(-1), nextLimit(-1), prevLimit(-1), + glyphStorage(theGlyphStorage), glyphPositionAdjustments(theGlyphPositionAdjustments), + srcIndex(-1), destIndex(-1), lookupFlags(theLookupFlags), featureMask(theFeatureMask), +@@ -262,8 +261,8 @@ + glyphPositionAdjustments->setBaseOffset(position, baseOffset); + } + +-void GlyphIterator::adjustCurrGlyphPositionAdjustment(float xPlacementAdjust, +- float yPlacementAdjust, float xAdvanceAdjust, float yAdvanceAdjust) ++void GlyphIterator::adjustCurrGlyphPositionAdjustment(float xPlacementAdjust, float yPlacementAdjust, ++ float xAdvanceAdjust, float yAdvanceAdjust) + { + if (direction < 0) { + if (position <= nextLimit || position >= prevLimit) { +@@ -281,8 +280,8 @@ + glyphPositionAdjustments->adjustYAdvance(position, yAdvanceAdjust); + } + +-void GlyphIterator::setCurrGlyphPositionAdjustment(float xPlacementAdjust, +- float yPlacementAdjust, float xAdvanceAdjust, float yAdvanceAdjust) ++void GlyphIterator::setCurrGlyphPositionAdjustment(float xPlacementAdjust, float yPlacementAdjust, ++ float xAdvanceAdjust, float yAdvanceAdjust) + { + if (direction < 0) { + if (position <= nextLimit || position >= prevLimit) { +@@ -484,10 +483,11 @@ + + do { + newPosition -= direction; +- } while (newPosition != prevLimit && glyphStorage[newPosition] != 0xFFFE && +- filterGlyph(newPosition)); ++ } while (newPosition != prevLimit && glyphStorage[newPosition] != 0xFFFE && filterGlyph(newPosition)); + + position = newPosition; + + return position != prevLimit; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphIterator.h b/src/share/native/sun/font/layout/GlyphIterator.h +--- jdk/src/share/native/sun/font/layout/GlyphIterator.h ++++ jdk/src/share/native/sun/font/layout/GlyphIterator.h +@@ -32,26 +32,24 @@ + #ifndef __GLYPHITERATOR_H + #define __GLYPHITERATOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + #include "GlyphDefinitionTables.h" + +-struct InsertionRecord +-{ +- InsertionRecord *next; +- le_int32 position; +- le_int32 count; +- LEGlyphID glyphs[ANY_NUMBER]; +-}; ++U_NAMESPACE_BEGIN + + class LEGlyphStorage; + class GlyphPositionAdjustments; + +-class GlyphIterator { ++class GlyphIterator : public UMemory { + public: +- GlyphIterator(LEGlyphStorage &theGlyphStorage, GlyphPositionAdjustments *theGlyphPositionAdjustments, +- le_bool rightToLeft, le_uint16 theLookupFlags, FeatureMask theFeatureMask, +- const GlyphDefinitionTableHeader *theGlyphDefinitionTableHeader); ++ GlyphIterator(LEGlyphStorage &theGlyphStorage, GlyphPositionAdjustments *theGlyphPositionAdjustments, le_bool rightToLeft, le_uint16 theLookupFlags, ++ FeatureMask theFeatureMask, const GlyphDefinitionTableHeader *theGlyphDefinitionTableHeader); + + GlyphIterator(GlyphIterator &that); + +@@ -122,4 +120,5 @@ + GlyphIterator &operator=(const GlyphIterator &other); // forbid copying of this class + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/GlyphLookupTables.cpp b/src/share/native/sun/font/layout/GlyphLookupTables.cpp +--- jdk/src/share/native/sun/font/layout/GlyphLookupTables.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphLookupTables.cpp +@@ -35,6 +35,8 @@ + #include "GlyphLookupTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_bool GlyphLookupTableHeader::coversScript(LETag scriptTag) const + { + const ScriptListTable *scriptListTable = (const ScriptListTable *) ((char *)this + SWAPW(scriptListOffset)); +@@ -51,3 +53,5 @@ + // Note: don't have to SWAPW langSysTable->featureCount to check for non-zero. + return langSysTable != NULL && langSysTable->featureCount != 0; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphLookupTables.h b/src/share/native/sun/font/layout/GlyphLookupTables.h +--- jdk/src/share/native/sun/font/layout/GlyphLookupTables.h ++++ jdk/src/share/native/sun/font/layout/GlyphLookupTables.h +@@ -32,9 +32,16 @@ + #ifndef __GLYPHLOOKUPTABLES_H + #define __GLYPHLOOKUPTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + struct GlyphLookupTableHeader + { + fixed32 version; +@@ -46,4 +53,7 @@ + le_bool coversScriptAndLanguage(LETag scriptTag, LETag languageTag, le_bool exactMatch = FALSE) const; + }; + ++U_NAMESPACE_END ++ + #endif ++ +diff --git a/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp b/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp +--- jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp +@@ -34,6 +34,8 @@ + #include "LEGlyphStorage.h" + #include "LEFontInstance.h" + ++U_NAMESPACE_BEGIN ++ + #define CHECK_ALLOCATE_ARRAY(array, type, size) \ + if (array == NULL) { \ + array = (type *) new type[size]; \ +@@ -185,3 +187,5 @@ + + return NULL; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphPositionAdjustments.h b/src/share/native/sun/font/layout/GlyphPositionAdjustments.h +--- jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.h ++++ jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.h +@@ -32,16 +32,23 @@ + #ifndef __GLYPHPOSITIONADJUSTMENTS_H + #define __GLYPHPOSITIONADJUSTMENTS_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + class LEFontInstance; + +-class GlyphPositionAdjustments ++class GlyphPositionAdjustments : public UMemory + { + private: +- class Adjustment { ++ class Adjustment : public UMemory { + public: + + inline Adjustment(); +@@ -78,7 +85,7 @@ + // allow copying of this class because all of its fields are simple types + }; + +- class EntryExitPoint ++ class EntryExitPoint : public UMemory + { + public: + inline EntryExitPoint(); +@@ -144,14 +151,11 @@ + inline void adjustXAdvance(le_int32 index, float xAdjustment); + inline void adjustYAdvance(le_int32 index, float yAdjustment); + +- void setEntryPoint(le_int32 index, LEPoint &newEntryPoint, +- le_bool baselineIsLogicalEnd); +- void setExitPoint(le_int32 index, LEPoint &newExitPoint, +- le_bool baselineIsLogicalEnd); ++ void setEntryPoint(le_int32 index, LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd); ++ void setExitPoint(le_int32 index, LEPoint &newExitPoint, le_bool baselineIsLogicalEnd); + void setCursiveGlyph(le_int32 index, le_bool baselineIsLogicalEnd); + +- void applyCursiveAdjustments(LEGlyphStorage &glyphStorage, le_bool rightToLeft, +- const LEFontInstance *fontInstance); ++ void applyCursiveAdjustments(LEGlyphStorage &glyphStorage, le_bool rightToLeft, const LEFontInstance *fontInstance); + }; + + inline GlyphPositionAdjustments::Adjustment::Adjustment() +@@ -160,10 +164,8 @@ + // nothing else to do! + } + +-inline GlyphPositionAdjustments::Adjustment::Adjustment(float xPlace, float yPlace, +- float xAdv, float yAdv, le_int32 baseOff) +- : xPlacement(xPlace), yPlacement(yPlace), xAdvance(xAdv), yAdvance(yAdv), +- baseOffset(baseOff) ++inline GlyphPositionAdjustments::Adjustment::Adjustment(float xPlace, float yPlace, float xAdv, float yAdv, le_int32 baseOff) ++ : xPlacement(xPlace), yPlacement(yPlace), xAdvance(xAdv), yAdvance(yAdv), baseOffset(baseOff) + { + // nothing else to do! + } +@@ -246,7 +248,7 @@ + inline GlyphPositionAdjustments::EntryExitPoint::EntryExitPoint() + : fFlags(0) + { +- fEntryPoint.fX = fEntryPoint.fY = fExitPoint.fX = fEntryPoint.fY = 0; ++ fEntryPoint.fX = fEntryPoint.fY = fExitPoint.fX = fExitPoint.fY = 0; + } + + inline GlyphPositionAdjustments::EntryExitPoint::~EntryExitPoint() +@@ -264,12 +266,10 @@ + return (fFlags & EEF_BASELINE_IS_LOGICAL_END) != 0; + } + +-inline void GlyphPositionAdjustments::EntryExitPoint::setEntryPoint( +- LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd) ++inline void GlyphPositionAdjustments::EntryExitPoint::setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd) + { + if (baselineIsLogicalEnd) { +- fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH | +- EEF_BASELINE_IS_LOGICAL_END); ++ fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END); + } else { + fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH); + } +@@ -277,12 +277,10 @@ + fEntryPoint = newEntryPoint; + } + +-inline void GlyphPositionAdjustments::EntryExitPoint::setExitPoint( +- LEPoint &newExitPoint, le_bool baselineIsLogicalEnd) ++inline void GlyphPositionAdjustments::EntryExitPoint::setExitPoint(LEPoint &newExitPoint, le_bool baselineIsLogicalEnd) + { + if (baselineIsLogicalEnd) { +- fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH | +- EEF_BASELINE_IS_LOGICAL_END); ++ fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END); + } else { + fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH); + } +@@ -290,8 +288,7 @@ + fExitPoint = newExitPoint; + } + +-inline void GlyphPositionAdjustments::EntryExitPoint::setCursiveGlyph( +- le_bool baselineIsLogicalEnd) ++inline void GlyphPositionAdjustments::EntryExitPoint::setCursiveGlyph(le_bool baselineIsLogicalEnd) + { + if (baselineIsLogicalEnd) { + fFlags |= (EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END); +@@ -386,4 +383,5 @@ + return fEntryExitPoints != NULL; + } + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/GlyphPositioningTables.cpp b/src/share/native/sun/font/layout/GlyphPositioningTables.cpp +--- jdk/src/share/native/sun/font/layout/GlyphPositioningTables.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphPositioningTables.cpp +@@ -24,7 +24,6 @@ + */ + + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -40,18 +39,18 @@ + #include "LEGlyphStorage.h" + #include "GlyphPositionAdjustments.h" + +-void GlyphPositioningTableHeader::process(LEGlyphStorage &glyphStorage, +- GlyphPositionAdjustments *glyphPositionAdjustments, le_bool rightToLeft, +- LETag scriptTag, LETag languageTag, +- const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, +- const LEFontInstance *fontInstance, +- const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const ++U_NAMESPACE_BEGIN ++ ++void GlyphPositioningTableHeader::process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, le_bool rightToLeft, ++ LETag scriptTag, LETag languageTag, ++ const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, ++ const LEFontInstance *fontInstance, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const + { +- GlyphPositioningLookupProcessor processor(this, scriptTag, languageTag, featureMap, +- featureMapCount, featureOrder); ++ GlyphPositioningLookupProcessor processor(this, scriptTag, languageTag, featureMap, featureMapCount, featureOrder); + +- processor.process(glyphStorage, glyphPositionAdjustments, rightToLeft, +- glyphDefinitionTableHeader, fontInstance); ++ processor.process(glyphStorage, glyphPositionAdjustments, rightToLeft, glyphDefinitionTableHeader, fontInstance); + + glyphPositionAdjustments->applyCursiveAdjustments(glyphStorage, rightToLeft, fontInstance); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphPositioningTables.h b/src/share/native/sun/font/layout/GlyphPositioningTables.h +--- jdk/src/share/native/sun/font/layout/GlyphPositioningTables.h ++++ jdk/src/share/native/sun/font/layout/GlyphPositioningTables.h +@@ -24,7 +24,6 @@ + */ + + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -32,11 +31,18 @@ + #ifndef __GLYPHPOSITIONINGTABLES_H + #define __GLYPHPOSITIONINGTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + #include "Lookups.h" + #include "GlyphLookupTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEFontInstance; + class LEGlyphStorage; + class LEGlyphFilter; +@@ -45,12 +51,10 @@ + + struct GlyphPositioningTableHeader : public GlyphLookupTableHeader + { +- void process(LEGlyphStorage &glyphStorage, +- GlyphPositionAdjustments *glyphPositionAdjustments, ++ void process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, + le_bool rightToLeft, LETag scriptTag, LETag languageTag, + const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, +- const LEFontInstance *fontInstance, +- const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const; ++ const LEFontInstance *fontInstance, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const; + }; + + enum GlyphPositioningSubtableTypes +@@ -68,4 +72,5 @@ + + typedef LookupSubtable GlyphPositioningSubtable; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp b/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp +--- jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp +@@ -24,7 +24,6 @@ + */ + + /* +- * + * (C) Copyright IBM Corp. 1998 - 2005 - All Rights Reserved + * + */ +@@ -50,6 +49,8 @@ + #include "GlyphPosnLookupProc.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + // Aside from the names, the contextual positioning subtables are + // the same as the contextual substitution subtables. + typedef ContextualSubstitutionSubtable ContextualPositioningSubtable; +@@ -57,8 +58,7 @@ + + GlyphPositioningLookupProcessor::GlyphPositioningLookupProcessor( + const GlyphPositioningTableHeader *glyphPositioningTableHeader, +- LETag scriptTag, LETag languageTag, +- const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) ++ LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) + : LookupProcessor( + (char *) glyphPositioningTableHeader, + SWAPW(glyphPositioningTableHeader->scriptListOffset), +@@ -166,3 +166,5 @@ + GlyphPositioningLookupProcessor::~GlyphPositioningLookupProcessor() + { + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphPosnLookupProc.h b/src/share/native/sun/font/layout/GlyphPosnLookupProc.h +--- jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.h ++++ jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.h +@@ -24,7 +24,6 @@ + */ + + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -32,6 +31,11 @@ + #ifndef __GLYPHPOSITIONINGLOOKUPPROCESSOR_H + #define __GLYPHPOSITIONINGLOOKUPPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +@@ -42,12 +46,13 @@ + #include "GlyphIterator.h" + #include "LookupProcessor.h" + ++U_NAMESPACE_BEGIN ++ + class GlyphPositioningLookupProcessor : public LookupProcessor + { + public: + GlyphPositioningLookupProcessor(const GlyphPositioningTableHeader *glyphPositioningTableHeader, +- LETag scriptTag, LETag languageTag, +- const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder); ++ LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder); + + virtual ~GlyphPositioningLookupProcessor(); + +@@ -63,4 +68,5 @@ + GlyphPositioningLookupProcessor &operator=(const GlyphPositioningLookupProcessor &other); // forbid copying of this class + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp b/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp +--- jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp +@@ -48,17 +48,17 @@ + #include "GlyphSubstLookupProc.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + GlyphSubstitutionLookupProcessor::GlyphSubstitutionLookupProcessor( + const GlyphSubstitutionTableHeader *glyphSubstitutionTableHeader, +- LETag scriptTag, LETag languageTag, const LEGlyphFilter *filter, +- const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) ++ LETag scriptTag, LETag languageTag, const LEGlyphFilter *filter, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) + : LookupProcessor( + (char *) glyphSubstitutionTableHeader, + SWAPW(glyphSubstitutionTableHeader->scriptListOffset), + SWAPW(glyphSubstitutionTableHeader->featureListOffset), + SWAPW(glyphSubstitutionTableHeader->lookupListOffset), +- scriptTag, languageTag, featureMap, featureMapCount, featureOrder) +- , fFilter(filter) ++ scriptTag, languageTag, featureMap, featureMapCount, featureOrder), fFilter(filter) + { + // anything? + } +@@ -143,3 +143,5 @@ + GlyphSubstitutionLookupProcessor::~GlyphSubstitutionLookupProcessor() + { + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphSubstLookupProc.h b/src/share/native/sun/font/layout/GlyphSubstLookupProc.h +--- jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.h ++++ jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.h +@@ -24,7 +24,6 @@ + */ + + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -32,6 +31,11 @@ + #ifndef __GLYPHSUBSTITUTIONLOOKUPPROCESSOR_H + #define __GLYPHSUBSTITUTIONLOOKUPPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEGlyphFilter.h" + #include "LEFontInstance.h" +@@ -43,12 +47,13 @@ + #include "GlyphIterator.h" + #include "LookupProcessor.h" + ++U_NAMESPACE_BEGIN ++ + class GlyphSubstitutionLookupProcessor : public LookupProcessor + { + public: + GlyphSubstitutionLookupProcessor(const GlyphSubstitutionTableHeader *glyphSubstitutionTableHeader, +- LETag scriptTag, LETag languageTag, const LEGlyphFilter *filter, +- const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder); ++ LETag scriptTag, LETag languageTag, const LEGlyphFilter *filter, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder); + + virtual ~GlyphSubstitutionLookupProcessor(); + +@@ -65,4 +70,5 @@ + GlyphSubstitutionLookupProcessor &operator=(const GlyphSubstitutionLookupProcessor &other); // forbid copying of this class + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp b/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp +--- jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp +@@ -40,14 +40,15 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + +-le_int32 GlyphSubstitutionTableHeader::process(LEGlyphStorage &glyphStorage, +- le_bool rightToLeft, LETag scriptTag, LETag languageTag, +- const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, +- const LEGlyphFilter *filter, const FeatureMap *featureMap, +- le_int32 featureMapCount, le_bool featureOrder) const ++U_NAMESPACE_BEGIN ++ ++le_int32 GlyphSubstitutionTableHeader::process(LEGlyphStorage &glyphStorage, le_bool rightToLeft, LETag scriptTag, LETag languageTag, ++ const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, ++ const LEGlyphFilter *filter, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const + { +- GlyphSubstitutionLookupProcessor processor(this, scriptTag, languageTag, filter, featureMap, +- featureMapCount, featureOrder); ++ GlyphSubstitutionLookupProcessor processor(this, scriptTag, languageTag, filter, featureMap, featureMapCount, featureOrder); + + return processor.process(glyphStorage, NULL, rightToLeft, glyphDefinitionTableHeader, NULL); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphSubstitutionTables.h b/src/share/native/sun/font/layout/GlyphSubstitutionTables.h +--- jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.h ++++ jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.h +@@ -32,22 +32,27 @@ + #ifndef __GLYPHSUBSTITUTIONTABLES_H + #define __GLYPHSUBSTITUTIONTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + #include "Lookups.h" + #include "GlyphLookupTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + class LEGlyphFilter; + struct GlyphDefinitionTableHeader; + + struct GlyphSubstitutionTableHeader : public GlyphLookupTableHeader + { +- le_int32 process(LEGlyphStorage &glyphStorage, +- le_bool rightToLeft, LETag scriptTag, LETag languageTag, +- const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, +- const LEGlyphFilter *filter, const FeatureMap *featureMap, +- le_int32 featureMapCount, le_bool featureOrder) const; ++ le_int32 process(LEGlyphStorage &glyphStorage, le_bool rightToLeft, LETag scriptTag, LETag languageTag, ++ const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, const LEGlyphFilter *filter, ++ const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const; + }; + + enum GlyphSubstitutionSubtableTypes +@@ -64,4 +69,5 @@ + + typedef LookupSubtable GlyphSubstitutionSubtable; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/HanLayoutEngine.cpp b/src/share/native/sun/font/layout/HanLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/HanLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/HanLayoutEngine.cpp +@@ -24,7 +24,6 @@ + */ + + /* +- * + * HanLayoutEngine.cpp: OpenType processing for Han fonts. + * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved. +@@ -41,6 +40,10 @@ + #include "LEGlyphStorage.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HanOpenTypeLayoutEngine) ++ + #define loclFeatureTag LE_LOCL_FEATURE_TAG + #define smplFeatureTag LE_SMPL_FEATURE_TAG + #define tradFeatureTag LE_TRAD_FEATURE_TAG +@@ -60,9 +63,8 @@ + + #define features (loclFeatureMask) + +-HanOpenTypeLayoutEngine::HanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, +- const GlyphSubstitutionTableHeader *gsubTable) ++HanOpenTypeLayoutEngine::HanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) + : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable) + { + fFeatureMap = featureMap; +@@ -74,9 +76,8 @@ + // nothing to do + } + +-le_int32 HanOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_int32 max, le_bool /*rightToLeft*/, +- LEUnicode *&/*outChars*/, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 HanOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool /*rightToLeft*/, ++ LEUnicode *&/*outChars*/, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -104,3 +105,5 @@ + + return count; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/HanLayoutEngine.h b/src/share/native/sun/font/layout/HanLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/HanLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/HanLayoutEngine.h +@@ -23,8 +23,8 @@ + * + */ + ++ + /* +- * + * HanLayoutEngine.h: OpenType processing for Han fonts. + * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved. +@@ -40,6 +40,8 @@ + + #include "GlyphSubstitutionTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + /** +@@ -69,9 +71,8 @@ + * + * @internal + */ +- HanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, +- le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ HanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); + + + /** +@@ -81,6 +82,20 @@ + */ + virtual ~HanOpenTypeLayoutEngine(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + protected: + + /** +@@ -92,10 +107,8 @@ + * @param offset - the index of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - <code>TRUE</code> if the characters are in a +- * right to left directional run +- * @param glyphStorage - the object holding the glyph storage. The char +- * index and auxillary data arrays will be set. ++ * @param rightToLeft - <code>TRUE</code> if the characters are in a right to left directional run ++ * @param glyphStorage - the object holding the glyph storage. The char index and auxillary data arrays will be set. + * + * Output parameters: + * @param outChars - the output character arrayt +@@ -107,9 +120,10 @@ + * + * @internal + */ +- virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/IndicClassTables.cpp b/src/share/native/sun/font/layout/IndicClassTables.cpp +--- jdk/src/share/native/sun/font/layout/IndicClassTables.cpp ++++ jdk/src/share/native/sun/font/layout/IndicClassTables.cpp +@@ -35,6 +35,8 @@ + #include "OpenTypeUtilities.h" + #include "IndicReordering.h" + ++U_NAMESPACE_BEGIN ++ + // Split matra table indices + #define _x1 (1 << CF_INDEX_SHIFT) + #define _x2 (2 << CF_INDEX_SHIFT) +@@ -385,3 +387,5 @@ + + return classTable->getWorstCaseExpansion(); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/IndicLayoutEngine.cpp b/src/share/native/sun/font/layout/IndicLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/IndicLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/IndicLayoutEngine.cpp +@@ -45,20 +45,20 @@ + + #include "IndicReordering.h" + +-IndicOpenTypeLayoutEngine::IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, +- const GlyphSubstitutionTableHeader *gsubTable) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable), +- fMPreFixups(NULL) ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IndicOpenTypeLayoutEngine) ++ ++IndicOpenTypeLayoutEngine::IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable), fMPreFixups(NULL) + { + fFeatureMap = IndicReordering::getFeatureMap(fFeatureMapCount); + fFeatureOrder = TRUE; + } + +-IndicOpenTypeLayoutEngine::IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), +- fMPreFixups(NULL) ++IndicOpenTypeLayoutEngine::IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), fMPreFixups(NULL) + { + fFeatureMap = IndicReordering::getFeatureMap(fFeatureMapCount); + fFeatureOrder = TRUE; +@@ -71,9 +71,8 @@ + + // Input: characters, tags + // Output: glyphs, char indices +-le_int32 IndicOpenTypeLayoutEngine::glyphProcessing(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 IndicOpenTypeLayoutEngine::glyphProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -84,8 +83,7 @@ + return 0; + } + +- le_int32 retCount = OpenTypeLayoutEngine::glyphProcessing(chars, offset, count, max, +- rightToLeft, glyphStorage, success); ++ le_int32 retCount = OpenTypeLayoutEngine::glyphProcessing(chars, offset, count, max, rightToLeft, glyphStorage, success); + + if (LE_FAILURE(success)) { + return 0; +@@ -99,9 +97,8 @@ + // Input: characters + // Output: characters, char indices, tags + // Returns: output character count +-le_int32 IndicOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 IndicOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -131,9 +128,10 @@ + + // NOTE: assumes this allocates featureTags... + // (probably better than doing the worst case stuff here...) +- le_int32 outCharCount = IndicReordering::reorder(&chars[offset], count, fScriptCode, +- outChars, glyphStorage, &fMPreFixups); ++ le_int32 outCharCount = IndicReordering::reorder(&chars[offset], count, fScriptCode, outChars, glyphStorage, &fMPreFixups); ++ + glyphStorage.adoptGlyphCount(outCharCount); +- + return outCharCount; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/IndicLayoutEngine.h b/src/share/native/sun/font/layout/IndicLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/IndicLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/IndicLayoutEngine.h +@@ -43,6 +43,8 @@ + #include "GlyphDefinitionTables.h" + #include "GlyphPositioningTables.h" + ++U_NAMESPACE_BEGIN ++ + class MPreFixups; + class LEGlyphStorage; + +@@ -77,9 +79,8 @@ + * + * @internal + */ +- IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); + + /** + * This constructor is used when the font requires a "canned" GSUB table which can't be known +@@ -94,8 +95,8 @@ + * + * @internal + */ +- IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags); ++ IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -104,6 +105,20 @@ + */ + virtual ~IndicOpenTypeLayoutEngine(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + protected: + + /** +@@ -117,10 +132,9 @@ + * @param offset - the index of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - <code>TRUE</code> if the characters are in a +- * right to left directional run +- * @param glyphStorage - the glyph storage object. The glyph and character +- * index arrays will be set. The auxillary data array will be set to the feature tags. ++ * @param rightToLeft - <code>TRUE</code> if the characters are in a right to left directional run ++ * @param glyphStorage - the glyph storage object. The glyph and character index arrays will be set. ++ * the auxillary data array will be set to the feature tags. + * + * Output parameters: + * @param success - set to an error code if the operation fails +@@ -129,9 +143,8 @@ + * + * @internal + */ +- virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** + * This method does character to glyph mapping, applies the GSUB table and applies +@@ -147,11 +160,9 @@ + * @param offset - the index of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - <code>TRUE</code> if the characters are in a +- * right to left directional run ++ * @param rightToLeft - <code>TRUE</code> if the characters are in a right to left directional run + * @param featureTags - the feature tag array +- * @param glyphStorage - the glyph storage object. The glyph and char +- * index arrays will be set. ++ * @param glyphStorage - the glyph storage object. The glyph and char index arrays will be set. + * + * Output parameters: + * @param success - set to an error code if the operation fails +@@ -163,12 +174,14 @@ + * + * @internal + */ +- virtual le_int32 glyphProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, +- LEErrorCode &success); ++ virtual le_int32 glyphProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success); + + private: ++ + MPreFixups *fMPreFixups; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/IndicRearrangement.h b/src/share/native/sun/font/layout/IndicRearrangement.h +--- jdk/src/share/native/sun/font/layout/IndicRearrangement.h ++++ jdk/src/share/native/sun/font/layout/IndicRearrangement.h +@@ -32,12 +32,19 @@ + #ifndef __INDICREARRANGEMENT_H + #define __INDICREARRANGEMENT_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + #include "StateTables.h" + #include "MorphTables.h" + #include "MorphStateTables.h" + ++U_NAMESPACE_BEGIN ++ + struct IndicRearrangementSubtableHeader : MorphStateTableHeader + { + }; +@@ -78,4 +85,6 @@ + { + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/IndicRearrangementProcessor.cpp b/src/share/native/sun/font/layout/IndicRearrangementProcessor.cpp +--- jdk/src/share/native/sun/font/layout/IndicRearrangementProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/IndicRearrangementProcessor.cpp +@@ -39,6 +39,10 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IndicRearrangementProcessor) ++ + IndicRearrangementProcessor::IndicRearrangementProcessor(const MorphSubtableHeader *morphSubtableHeader) + : StateTableProcessor(morphSubtableHeader) + { +@@ -56,8 +60,7 @@ + lastGlyph = 0; + } + +-ByteOffset IndicRearrangementProcessor::processStateEntry(LEGlyphStorage &glyphStorage, +- le_int32 &currGlyph, EntryTableIndex index) ++ByteOffset IndicRearrangementProcessor::processStateEntry(LEGlyphStorage &glyphStorage, le_int32 &currGlyph, EntryTableIndex index) + { + const IndicRearrangementStateEntry *entry = &entryTable[index]; + ByteOffset newState = SWAPW(entry->newStateOffset); +@@ -416,3 +419,5 @@ + break; + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/IndicRearrangementProcessor.h b/src/share/native/sun/font/layout/IndicRearrangementProcessor.h +--- jdk/src/share/native/sun/font/layout/IndicRearrangementProcessor.h ++++ jdk/src/share/native/sun/font/layout/IndicRearrangementProcessor.h +@@ -32,12 +32,19 @@ + #ifndef __INDICREARRANGEMENTPROCESSOR_H + #define __INDICREARRANGEMENTPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "StateTableProcessor.h" + #include "IndicRearrangement.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class IndicRearrangementProcessor : public StateTableProcessor +@@ -54,12 +61,28 @@ + IndicRearrangementProcessor(const MorphSubtableHeader *morphSubtableHeader); + virtual ~IndicRearrangementProcessor(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + protected: + le_int32 firstGlyph; + le_int32 lastGlyph; + + const IndicRearrangementStateEntry *entryTable; + const IndicRearrangementSubtableHeader *indicRearrangementSubtableHeader; ++ + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/IndicReordering.cpp b/src/share/native/sun/font/layout/IndicReordering.cpp +--- jdk/src/share/native/sun/font/layout/IndicReordering.cpp ++++ jdk/src/share/native/sun/font/layout/IndicReordering.cpp +@@ -36,6 +36,8 @@ + #include "LEGlyphStorage.h" + #include "MPreFixups.h" + ++U_NAMESPACE_BEGIN ++ + #define initFeatureTag LE_INIT_FEATURE_TAG + #define nuktFeatureTag LE_NUKT_FEATURE_TAG + #define akhnFeatureTag LE_AKHN_FEATURE_TAG +@@ -71,7 +73,7 @@ + #define distFeatureMask 0x00020000UL + #define initFeatureMask 0x00010000UL + +-class ReorderingOutput { ++class ReorderingOutput : public UMemory { + private: + le_int32 fOutIndex; + LEUnicode *fOutChars; +@@ -187,8 +189,7 @@ + fOutIndex += 1; + } + +- le_bool noteMatra(const IndicClassTable *classTable, LEUnicode matra, le_uint32 matraIndex, +- FeatureMask matraFeatures, le_bool wordStart) ++ le_bool noteMatra(const IndicClassTable *classTable, LEUnicode matra, le_uint32 matraIndex, FeatureMask matraFeatures, le_bool wordStart) + { + IndicClassTable::CharClass matraClass = classTable->getCharClass(matra); + +@@ -219,13 +220,12 @@ + return FALSE; + } + +- void noteVowelModifier(const IndicClassTable *classTable, LEUnicode vowelModifier, +- le_uint32 vowelModifierIndex, FeatureMask vowelModifierFeatures) ++ void noteVowelModifier(const IndicClassTable *classTable, LEUnicode vowelModifier, le_uint32 vowelModifierIndex, FeatureMask vowelModifierFeatures) + { + IndicClassTable::CharClass vmClass = classTable->getCharClass(vowelModifier); + + fVMIndex = vowelModifierIndex; +- fVMFeatures = vowelModifierFeatures; ++ fVMFeatures = vowelModifierFeatures; + + if (IndicClassTable::isVowelModifier(vmClass)) { + switch (vmClass & CF_POS_MASK) { +@@ -244,13 +244,12 @@ + } + } + +- void noteStressMark(const IndicClassTable *classTable, LEUnicode stressMark, +- le_uint32 stressMarkIndex, FeatureMask stressMarkFeatures) ++ void noteStressMark(const IndicClassTable *classTable, LEUnicode stressMark, le_uint32 stressMarkIndex, FeatureMask stressMarkFeatures) + { + IndicClassTable::CharClass smClass = classTable->getCharClass(stressMark); + + fSMIndex = stressMarkIndex; +- fSMFeatures = stressMarkFeatures; ++ fSMFeatures = stressMarkFeatures; + + if (IndicClassTable::isStressMark(smClass)) { + switch (smClass & CF_POS_MASK) { +@@ -360,9 +359,7 @@ + }; + + // TODO: Find better names for these! +-#define tagArray4 (nuktFeatureMask | akhnFeatureMask | vatuFeatureMask | presFeatureMask | \ +- blwsFeatureMask | abvsFeatureMask | pstsFeatureMask | halnFeatureMask | \ +- blwmFeatureMask | abvmFeatureMask | distFeatureMask) ++#define tagArray4 (nuktFeatureMask | akhnFeatureMask | vatuFeatureMask | presFeatureMask | blwsFeatureMask | abvsFeatureMask | pstsFeatureMask | halnFeatureMask | blwmFeatureMask | abvmFeatureMask | distFeatureMask) + #define tagArray3 (pstfFeatureMask | tagArray4) + #define tagArray2 (halfFeatureMask | tagArray3) + #define tagArray1 (blwfFeatureMask | tagArray2) +@@ -415,8 +412,7 @@ + return featureMap; + } + +-le_int32 IndicReordering::findSyllable(const IndicClassTable *classTable, +- const LEUnicode *chars, le_int32 prev, le_int32 charCount) ++le_int32 IndicReordering::findSyllable(const IndicClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount) + { + le_int32 cursor = prev; + le_int8 state = 0; +@@ -752,3 +748,5 @@ + delete mpreFixups; + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/IndicReordering.h b/src/share/native/sun/font/layout/IndicReordering.h +--- jdk/src/share/native/sun/font/layout/IndicReordering.h ++++ jdk/src/share/native/sun/font/layout/IndicReordering.h +@@ -32,9 +32,16 @@ + #ifndef __INDICREORDERING_H + #define __INDICREORDERING_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + // Characters that get refered to by name... + #define C_SIGN_ZWNJ 0x200C + #define C_SIGN_ZWJ 0x200D +@@ -140,7 +147,7 @@ + static const IndicClassTable *getScriptClassTable(le_int32 scriptCode); + }; + +-class IndicReordering { ++class IndicReordering /* not : public UObject because all methods are static */ { + public: + static le_int32 getWorstCaseExpansion(le_int32 scriptCode); + +@@ -156,8 +163,7 @@ + // do not instantiate + IndicReordering(); + +- static le_int32 findSyllable(const IndicClassTable *classTable, const LEUnicode *chars, +- le_int32 prev, le_int32 charCount); ++ static le_int32 findSyllable(const IndicClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount); + + }; + +@@ -305,4 +311,5 @@ + return hasBelowBaseForm(getCharClass(ch)); + } + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/KernTable.cpp b/src/share/native/sun/font/layout/KernTable.cpp +--- jdk/src/share/native/sun/font/layout/KernTable.cpp ++++ jdk/src/share/native/sun/font/layout/KernTable.cpp +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 2004-2005 - All Rights Reserved + * + */ +@@ -39,6 +40,8 @@ + + #define DEBUG 0 + ++U_NAMESPACE_BEGIN ++ + struct PairInfo { + le_uint32 key; // sigh, MSVC compiler gags on union here + le_int16 value; // fword, kern value in funits +@@ -191,6 +194,12 @@ + float adjust = 0; + for (int i = 1, e = storage.getGlyphCount(); i < e; ++i) { + key = key << 16 | (storage[i] & 0xffff); ++ ++ // argh, to do a binary search, we need to have the pair list in sorted order ++ // but it is not in sorted order on win32 platforms because of the endianness difference ++ // so either I have to swap the element each time I examine it, or I have to swap ++ // all the elements ahead of time and store them in the font ++ + const PairInfo* p = pairs; + const PairInfo* tp = (const PairInfo*)(p + rangeShift); + if (key > tp->key) { +@@ -238,3 +247,6 @@ + storage.adjustPosition(storage.getGlyphCount(), adjust, 0, success); + } + } ++ ++U_NAMESPACE_END ++ +diff --git a/src/share/native/sun/font/layout/KernTable.h b/src/share/native/sun/font/layout/KernTable.h +--- jdk/src/share/native/sun/font/layout/KernTable.h ++++ jdk/src/share/native/sun/font/layout/KernTable.h +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 2004-2005 - All Rights Reserved + * + */ +@@ -37,9 +38,12 @@ + #endif + + #include "LETypes.h" ++//#include "LEFontInstance.h" ++//#include "LEGlyphStorage.h" + + #include <stdio.h> + ++U_NAMESPACE_BEGIN + struct PairInfo; + class LEFontInstance; + class LEGlyphStorage; +@@ -67,4 +71,6 @@ + void process(LEGlyphStorage& storage); + }; + ++U_NAMESPACE_END ++ + #endif +diff --git a/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp b/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp +@@ -23,8 +23,8 @@ + * + */ + ++ + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + * This file is a modification of the ICU file IndicLayoutEngine.cpp +@@ -38,17 +38,20 @@ + #include "LEGlyphStorage.h" + #include "KhmerReordering.h" + +-KhmerOpenTypeLayoutEngine::KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, +- const GlyphSubstitutionTableHeader *gsubTable) ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(KhmerOpenTypeLayoutEngine) ++ ++KhmerOpenTypeLayoutEngine::KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) + : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable) + { + fFeatureMap = KhmerReordering::getFeatureMap(fFeatureMapCount); + fFeatureOrder = TRUE; + } + +-KhmerOpenTypeLayoutEngine::KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) ++KhmerOpenTypeLayoutEngine::KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags) + : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags) + { + fFeatureMap = KhmerReordering::getFeatureMap(fFeatureMapCount); +@@ -63,16 +66,14 @@ + // Input: characters + // Output: characters, char indices, tags + // Returns: output character count +-le_int32 KhmerOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 KhmerOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; + } + +- if (chars == NULL || offset < 0 || count < 0 || max < 0 || +- offset >= max || offset + count > max) { ++ if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } +@@ -96,9 +97,10 @@ + + // NOTE: assumes this allocates featureTags... + // (probably better than doing the worst case stuff here...) +- le_int32 outCharCount = KhmerReordering::reorder(&chars[offset], count, +- fScriptCode, outChars, glyphStorage); ++ le_int32 outCharCount = KhmerReordering::reorder(&chars[offset], count, fScriptCode, outChars, glyphStorage); + + glyphStorage.adoptGlyphCount(outCharCount); + return outCharCount; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/KhmerLayoutEngine.h b/src/share/native/sun/font/layout/KhmerLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.h +@@ -23,6 +23,7 @@ + * + */ + ++ + /* + * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved +@@ -45,19 +46,18 @@ + // #include "GlyphDefinitionTables.h" + // #include "GlyphPositioningTables.h" + ++U_NAMESPACE_BEGIN ++ + // class MPreFixups; + // class LEGlyphStorage; + + /** + * This class implements OpenType layout for Khmer OpenType fonts, as +- * specified by Microsoft in "Creating and Supporting OpenType Fonts +- * for Khmer Scripts" +- * (http://www.microsoft.com/typography/otspec/indicot/default.htm) +- * TODO: change url ++ * specified by Microsoft in "Creating and Supporting OpenType Fonts for ++ * Khmer Scripts" (http://www.microsoft.com/typography/otspec/indicot/default.htm) TODO: change url + * +- * This class overrides the characterProcessing method to do Khmer +- * character processing and reordering (See the MS spec. for more +- * details) ++ * This class overrides the characterProcessing method to do Khmer character processing ++ * and reordering (See the MS spec. for more details) + * + * @internal + */ +@@ -65,11 +65,10 @@ + { + public: + /** +- * This is the main constructor. It constructs an instance of +- * KhmerOpenTypeLayoutEngine for a particular font, script and +- * language. It takes the GSUB table as a parameter since +- * LayoutEngine::layoutEngineFactory has to read the GSUB table to +- * know that it has an Khmer OpenType font. ++ * This is the main constructor. It constructs an instance of KhmerOpenTypeLayoutEngine for ++ * a particular font, script and language. It takes the GSUB table as a parameter since ++ * LayoutEngine::layoutEngineFactory has to read the GSUB table to know that it has an ++ * Khmer OpenType font. + * + * @param fontInstance - the font + * @param scriptCode - the script +@@ -82,14 +81,12 @@ + * + * @internal + */ +- KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, +- const GlyphSubstitutionTableHeader *gsubTable); ++ KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); + + /** +- * This constructor is used when the font requires a "canned" GSUB +- * table which can't be known until after this constructor has +- * been invoked. ++ * This constructor is used when the font requires a "canned" GSUB table which can't be known ++ * until after this constructor has been invoked. + * + * @param fontInstance - the font + * @param scriptCode - the script +@@ -100,8 +97,8 @@ + * + * @internal + */ +- KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags); ++ KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -110,25 +107,35 @@ + */ + virtual ~KhmerOpenTypeLayoutEngine(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + protected: + + /** +- * This method does Khmer OpenType character processing. It +- * assigns the OpenType feature tags to the characters, and may +- * generate output characters which have been reordered. It may +- * also split some vowels, resulting in more output characters +- * than input characters. ++ * This method does Khmer OpenType character processing. It assigns the OpenType feature ++ * tags to the characters, and may generate output characters which have been reordered. ++ * It may also split some vowels, resulting in more output characters than input characters. + * + * Input parameters: + * @param chars - the input character context + * @param offset - the index of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - <code>TRUE</code> if the characters are in +- * a right to left directional run +- * @param glyphStorage - the glyph storage object. The glyph and +- * character index arrays will be set. the auxillary data array +- * will be set to the feature tags. ++ * @param rightToLeft - <code>TRUE</code> if the characters are in a right to left directional run ++ * @param glyphStorage - the glyph storage object. The glyph and character index arrays will be set. ++ * the auxillary data array will be set to the feature tags. + * + * Output parameters: + * @param success - set to an error code if the operation fails +@@ -137,9 +144,11 @@ + * + * @internal + */ +- virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/KhmerReordering.cpp b/src/share/native/sun/font/layout/KhmerReordering.cpp +--- jdk/src/share/native/sun/font/layout/KhmerReordering.cpp ++++ jdk/src/share/native/sun/font/layout/KhmerReordering.cpp +@@ -37,6 +37,9 @@ + #include "KhmerReordering.h" + #include "LEGlyphStorage.h" + ++ ++U_NAMESPACE_BEGIN ++ + // Characters that get refered to by name... + enum + { +@@ -53,35 +56,23 @@ + + enum + { +- // simple classes, they are used in the statetable (in this file) +- // to control the length of a syllable they are also used to know +- // where a character should be placed (location in reference to +- // the base character) and also to know if a character, when +- // independtly displayed, should be displayed with a dotted-circle +- // to indicate error in syllable construction +- ++ // simple classes, they are used in the statetable (in this file) to control the length of a syllable ++ // they are also used to know where a character should be placed (location in reference to the base character) ++ // and also to know if a character, when independtly displayed, should be displayed with a dotted-circle to ++ // indicate error in syllable construction + _xx = KhmerClassTable::CC_RESERVED, +- _sa = KhmerClassTable::CC_SIGN_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE +- | KhmerClassTable::CF_POS_ABOVE, +- _sp = KhmerClassTable::CC_SIGN_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE +- | KhmerClassTable::CF_POS_AFTER, ++ _sa = KhmerClassTable::CC_SIGN_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_POS_ABOVE, ++ _sp = KhmerClassTable::CC_SIGN_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE| KhmerClassTable::CF_POS_AFTER, + _c1 = KhmerClassTable::CC_CONSONANT | KhmerClassTable::CF_CONSONANT, + _c2 = KhmerClassTable::CC_CONSONANT2 | KhmerClassTable::CF_CONSONANT, + _c3 = KhmerClassTable::CC_CONSONANT3 | KhmerClassTable::CF_CONSONANT, +- _rb = KhmerClassTable::CC_ROBAT | KhmerClassTable::CF_POS_ABOVE +- | KhmerClassTable::CF_DOTTED_CIRCLE, +- _cs = KhmerClassTable::CC_CONSONANT_SHIFTER | KhmerClassTable::CF_DOTTED_CIRCLE +- | KhmerClassTable::CF_SHIFTER, +- _dl = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BEFORE +- | KhmerClassTable::CF_DOTTED_CIRCLE, +- _db = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BELOW +- | KhmerClassTable::CF_DOTTED_CIRCLE, +- _da = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_ABOVE +- | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_ABOVE_VOWEL, +- _dr = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_AFTER +- | KhmerClassTable::CF_DOTTED_CIRCLE, +- _co = KhmerClassTable::CC_COENG | KhmerClassTable::CF_COENG +- | KhmerClassTable::CF_DOTTED_CIRCLE, ++ _rb = KhmerClassTable::CC_ROBAT | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE, ++ _cs = KhmerClassTable::CC_CONSONANT_SHIFTER | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_SHIFTER, ++ _dl = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BEFORE | KhmerClassTable::CF_DOTTED_CIRCLE, ++ _db = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BELOW | KhmerClassTable::CF_DOTTED_CIRCLE, ++ _da = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_ABOVE_VOWEL, ++ _dr = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE, ++ _co = KhmerClassTable::CC_COENG | KhmerClassTable::CF_COENG | KhmerClassTable::CF_DOTTED_CIRCLE, + + // split vowel + _va = _da | KhmerClassTable::CF_SPLIT_VOWEL, +@@ -90,13 +81,10 @@ + + + // Character class tables +- +-// _xx character does not combine into syllable, such as numbers, +-// puntuation marks, non-Khmer signs... ++// _xx character does not combine into syllable, such as numbers, puntuation marks, non-Khmer signs... + // _sa Sign placed above the base + // _sp Sign placed after the base +-// _c1 Consonant of type 1 or independent vowel (independent vowels +-// behave as type 1 consonants) ++// _c1 Consonant of type 1 or independent vowel (independent vowels behave as type 1 consonants) + // _c2 Consonant of type 2 (only RO) + // _c3 Consonant of type 3 + // _rb Khmer sign robat u17CC. combining mark for subscript consonants +@@ -105,13 +93,10 @@ + // _db Dependent vowel placed below the base + // _da Dependent vowel placed above the base + // _dr Dependent vowel placed behind the base (right of the base) +-// _co Khmer combining mark COENG u17D2, combines with the consonant +-// or independent vowel following it to create a subscript consonant +-// or independent vowel +-// _va Khmer split vowel in wich the first part is before the base and +-// the second one above the base +-// _vr Khmer split vowel in wich the first part is before the base and +-// the second one behind (right of) the base ++// _co Khmer combining mark COENG u17D2, combines with the consonant or independent vowel following ++// it to create a subscript consonant or independent vowel ++// _va Khmer split vowel in wich the first part is before the base and the second one above the base ++// _vr Khmer split vowel in wich the first part is before the base and the second one behind (right of) the base + + static const KhmerClassTable::CharClass khmerCharClasses[] = + { +@@ -129,19 +114,19 @@ + // + + // +-// The range of characters defined in the above table is defined +-// here. FOr Khmer 1780 to 17DF Even if the Khmer range is bigger, all +-// other characters are not combinable, and therefore treated as _xx ++// The range of characters defined in the above table is defined here. FOr Khmer 1780 to 17DF ++// Even if the Khmer range is bigger, all other characters are not combinable, and therefore treated ++// as _xx + static const KhmerClassTable khmerClassTable = {0x1780, 0x17df, khmerCharClasses}; + + +-// Below we define how a character in the input string is either in +-// the khmerCharClasses table (in which case we get its type back), a +-// ZWJ or ZWNJ (two characters that may appear within the syllable, +-// but are not in the table) we also get their type back, or an +-// unknown object in which case we get _xx (CC_RESERVED) back ++// Below we define how a character in the input string is either in the khmerCharClasses table ++// (in which case we get its type back), a ZWJ or ZWNJ (two characters that may appear ++// within the syllable, but are not in the table) we also get their type back, or an unknown object ++// in which case we get _xx (CC_RESERVED) back + KhmerClassTable::CharClass KhmerClassTable::getCharClass(LEUnicode ch) const + { ++ + if (ch == C_SIGN_ZWJ) { + return CC_ZERO_WIDTH_J_MARK; + } +@@ -164,13 +149,14 @@ + + + +-class ReorderingOutput { ++class ReorderingOutput : public UMemory { + private: + le_int32 fOutIndex; + LEUnicode *fOutChars; + + LEGlyphStorage &fGlyphStorage; + ++ + public: + ReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage) + : fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage) +@@ -232,18 +218,11 @@ + #define abvmFeatureMask 0x00100000UL + #define mkmkFeatureMask 0x00080000UL + +-#define tagPref (prefFeatureMask | presFeatureMask | \ +- cligFeatureMask | distFeatureMask) +-#define tagAbvf (abvfFeatureMask | abvsFeatureMask | \ +- cligFeatureMask | distFeatureMask | abvmFeatureMask | mkmkFeatureMask) +-#define tagPstf (blwfFeatureMask | blwsFeatureMask | prefFeatureMask | \ +- presFeatureMask | pstfFeatureMask | pstsFeatureMask | cligFeatureMask | \ +- distFeatureMask | blwmFeatureMask) +-#define tagBlwf (blwfFeatureMask | blwsFeatureMask | cligFeatureMask | \ +- distFeatureMask | blwmFeatureMask | mkmkFeatureMask) +-#define tagDefault (prefFeatureMask | blwfFeatureMask | presFeatureMask | \ +- blwsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | \ +- blwmFeatureMask | mkmkFeatureMask) ++#define tagPref (prefFeatureMask | presFeatureMask | cligFeatureMask | distFeatureMask) ++#define tagAbvf (abvfFeatureMask | abvsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | mkmkFeatureMask) ++#define tagPstf (blwfFeatureMask | blwsFeatureMask | prefFeatureMask | presFeatureMask | pstfFeatureMask | pstsFeatureMask | cligFeatureMask | distFeatureMask | blwmFeatureMask) ++#define tagBlwf (blwfFeatureMask | blwsFeatureMask | cligFeatureMask | distFeatureMask | blwmFeatureMask | mkmkFeatureMask) ++#define tagDefault (prefFeatureMask | blwfFeatureMask | presFeatureMask | blwsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | blwmFeatureMask | mkmkFeatureMask) + + + +@@ -274,35 +253,32 @@ + // The stateTable is used to calculate the end (the length) of a well + // formed Khmer Syllable. + // +-// Each horizontal line is ordered exactly the same way as the values +-// in KhmerClassTable CharClassValues in KhmerReordering.h This +-// coincidence of values allows the follow up of the table. ++// Each horizontal line is ordered exactly the same way as the values in KhmerClassTable ++// CharClassValues in KhmerReordering.h This coincidence of values allows the ++// follow up of the table. + // +-// Each line corresponds to a state, which does not necessarily need +-// to be a type of component... for example, state 2 is a base, with +-// is always a first character in the syllable, but the state could be +-// produced a consonant of any type when it is the first character +-// that is analysed (in ground state). ++// Each line corresponds to a state, which does not necessarily need to be a type ++// of component... for example, state 2 is a base, with is always a first character ++// in the syllable, but the state could be produced a consonant of any type when ++// it is the first character that is analysed (in ground state). + // + // Differentiating 3 types of consonants is necessary in order to + // forbid the use of certain combinations, such as having a second +-// coeng after a coeng RO. +-// The inexistent possibility of having a type 3 after another type 3 +-// is permitted, eliminating it would very much complicate the table, +-// and it does not create typing problems, as the case above. ++// coeng after a coeng RO, ++// The inexistent possibility of having a type 3 after another type 3 is permitted, ++// eliminating it would very much complicate the table, and it does not create typing ++// problems, as the case above. + // +-// The table is quite complex, in order to limit the number of coeng +-// consonants to 2 (by means of the table). ++// The table is quite complex, in order to limit the number of coeng consonants ++// to 2 (by means of the table). + // + // There a peculiarity, as far as Unicode is concerned: + // - The consonant-shifter is considered in two possible different +-// locations, the one considered in Unicode 3.0 and the one considered +-// in Unicode 4.0. (there is a backwards compatibility problem in this +-// standard). ++// locations, the one considered in Unicode 3.0 and the one considered in ++// Unicode 4.0. (there is a backwards compatibility problem in this standard). + + +-// xx independent character, such as a number, punctuation sign or +-// non-khmer char ++// xx independent character, such as a number, punctuation sign or non-khmer char + // + // c1 Khmer consonant of type 1 or an independent vowel + // that is, a letter in which the subscript for is only under the +@@ -320,10 +296,9 @@ + // + // co coeng character (u17D2) + // +-// dv dependent vowel (including split vowels, they are treated in the +-// same way). even if dv is not defined above, the component that is +-// really tested for is KhmerClassTable::CC_DEPENDENT_VOWEL, which is +-// common to all dependent vowels ++// dv dependent vowel (including split vowels, they are treated in the same way). ++// even if dv is not defined above, the component that is really tested for is ++// KhmerClassTable::CC_DEPENDENT_VOWEL, which is common to all dependent vowels + // + // zwj Zero Width joiner + // +@@ -352,8 +327,7 @@ + {-1, -1, -1, -1, 12, 13, -1, -1, 16, 17, 1, 14}, // 8 - First consonant of type 2 after coeng + {-1, -1, -1, -1, 12, 13, -1, 10, 16, 17, 1, 14}, // 9 - First consonant or type 3 after ceong + {-1, 11, 11, 11, -1, -1, -1, -1, -1, -1, -1, -1}, // 10 - Second Coeng (no register shifter before) +- {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17, 1, 14}, // 11 - Second coeng consonant +- // (or ind. vowel) no register shifter before ++ {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17, 1, 14}, // 11 - Second coeng consonant (or ind. vowel) no register shifter before + {-1, -1, 1, -1, -1, 13, -1, -1, 16, -1, -1, -1}, // 12 - Second ZWNJ before a register shifter + {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17, 1, 14}, // 13 - Second register shifter + {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 14 - ZWJ before vowel +@@ -363,6 +337,7 @@ + {-1, -1, -1, -1, -1, -1, -1, 19, -1, -1, -1, -1}, // 18 - ZWJ after vowel + {-1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19 - Third coeng + {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1}, // 20 - dependent vowel after a Robat ++ + }; + + +@@ -377,15 +352,13 @@ + // Given an input string of characters and a location in which to start looking + // calculate, using the state table, which one is the last character of the syllable + // that starts in the starting position. +-le_int32 KhmerReordering::findSyllable(const KhmerClassTable *classTable, +- const LEUnicode *chars, le_int32 prev, le_int32 charCount) ++le_int32 KhmerReordering::findSyllable(const KhmerClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount) + { + le_int32 cursor = prev; + le_int8 state = 0; + + while (cursor < charCount) { +- KhmerClassTable::CharClass charClass = (classTable->getCharClass(chars[cursor]) +- & KhmerClassTable::CF_CLASS_MASK); ++ KhmerClassTable::CharClass charClass = (classTable->getCharClass(chars[cursor]) & KhmerClassTable::CF_CLASS_MASK); + + state = khmerStateTable[state][charClass]; + +@@ -402,8 +375,8 @@ + + // This is the real reordering function as applied to the Khmer language + +-le_int32 KhmerReordering::reorder(const LEUnicode *chars, le_int32 charCount, +- le_int32 /*scriptCode*/, LEUnicode *outChars, LEGlyphStorage &glyphStorage) ++le_int32 KhmerReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 /*scriptCode*/, ++ LEUnicode *outChars, LEGlyphStorage &glyphStorage) + { + const KhmerClassTable *classTable = KhmerClassTable::getKhmerClassTable(); + +@@ -442,8 +415,7 @@ + // and because CC_CONSONANT2 is enough to identify it, as it is the only consonant + // with this flag + if ( (charClass & KhmerClassTable::CF_COENG) && (i + 1 < syllable) && +- ( (classTable->getCharClass(chars[i + 1]) & +- KhmerClassTable::CF_CLASS_MASK) == KhmerClassTable::CC_CONSONANT2) ) ++ ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == KhmerClassTable::CC_CONSONANT2) ) + { + coengRo = i; + } +@@ -455,16 +427,15 @@ + output.writeChar(C_RO, coengRo + 1, tagPref); + } + +- // shall we add a dotted circle? If in the position in which +- // the base should be (first char in the string) there is a +- // character that has the Dotted circle flag (a character that +- // cannot be a base) then write a dotted circle ++ // shall we add a dotted circle? ++ // If in the position in which the base should be (first char in the string) there is ++ // a character that has the Dotted circle flag (a character that cannot be a base) ++ // then write a dotted circle + if (classTable->getCharClass(chars[prev]) & KhmerClassTable::CF_DOTTED_CIRCLE) { + output.writeChar(C_DOTTED_CIRCLE, prev, tagDefault); + } + +- // copy what is left to the output, skipping before vowels and +- // coeng Ro if they are present ++ // copy what is left to the output, skipping before vowels and coeng Ro if they are present + for (i = prev; i < syllable; i += 1) { + charClass = classTable->getCharClass(chars[i]); + +@@ -515,30 +486,14 @@ + // and there is an extra rule for C_VOWEL_AA + C_SIGN_NIKAHIT also for two + // different positions, right after the shifter or after a vowel (Unicode 4) + if ( (charClass & KhmerClassTable::CF_SHIFTER) && (i + 1 < syllable) ) { +- if (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_ABOVE_VOWEL ) { +- output.writeChar(chars[i], i, tagBlwf); +- break; +- } +- if (i + 2 < syllable && +- ( (classTable->getCharClass(chars[i + 1]) & +- KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA) && +- ( (classTable->getCharClass(chars[i + 2]) & +- KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT) ) +- { +- output.writeChar(chars[i], i, tagBlwf); +- break; +- } +- if (i + 3 < syllable && (classTable->getCharClass(chars[i + 3]) & +- KhmerClassTable::CF_ABOVE_VOWEL) ) +- { +- output.writeChar(chars[i], i, tagBlwf); +- break; +- } +- if (i + 4 < syllable && +- ( (classTable->getCharClass(chars[i + 3]) & +- KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA) && +- ( (classTable->getCharClass(chars[i + 4]) & +- KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT) ) ++ if ((classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_ABOVE_VOWEL) ++ || (i + 2 < syllable ++ && ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA) ++ && ( (classTable->getCharClass(chars[i + 2]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT)) ++ || (i + 3 < syllable && (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_ABOVE_VOWEL)) ++ || (i + 4 < syllable ++ && ( (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA) ++ && ( (classTable->getCharClass(chars[i + 4]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT) ) ) + { + output.writeChar(chars[i], i, tagBlwf); + break; +@@ -556,3 +511,6 @@ + + return output.getOutputIndex(); + } ++ ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/KhmerReordering.h b/src/share/native/sun/font/layout/KhmerReordering.h +--- jdk/src/share/native/sun/font/layout/KhmerReordering.h ++++ jdk/src/share/native/sun/font/layout/KhmerReordering.h +@@ -24,7 +24,6 @@ + */ + + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + * This file is a modification of the ICU file IndicReordering.h +@@ -35,80 +34,60 @@ + #ifndef __KHMERREORDERING_H + #define __KHMERREORDERING_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + // Vocabulary +- +-// Base -> +-// A consonant or an independent vowel in its full (not +-// subscript) form. It is the center of the syllable, it can be +-// souranded by coeng (subscript) consonants, vowels, split +-// vowels, signs... but there is only one base in a syllable, it +-// has to be coded as the first character of the syllable. +-// split vowel -> +-// vowel that has two parts placed separately (e.g. Before and +-// after the consonant). Khmer language has five of them. Khmer +-// split vowels either have one part before the base and one after +-// the base or they have a part before the base and a part above +-// the base. The first part of all Khmer split vowels is the same +-// character, identical to the glyph of Khmer dependent vowel SRA +-// EI +-// coeng -> +-// modifier used in Khmer to construct coeng (subscript) +-// consonants differently than indian languages, the coeng +-// modifies the consonant that follows it, not the one preceding +-// it Each consonant has two forms, the base form and the +-// subscript form the base form is the normal one (using the +-// consonants code-point), the subscript form is displayed when +-// the combination coeng + consonant is encountered. +-// Consonant of type 1 -> +-// A consonant which has subscript for that only occupies space +-// under a base consonant +-// Consonant of type 2 -> +-// Its subscript form occupies space under and before the base +-// (only one, RO) +-// Consonant of Type 3 -> +-// Its subscript form occupies space under and after the base +-// (KHO, CHHO, THHO, BA, YO, SA) +-// Consonant shifter -> +-// Khmer has to series of consonants. The same dependent vowel has +-// different sounds if it is attached to a consonant of the first +-// series or a consonant of the second series Most consonants have +-// an equivalent in the other series, but some of theme exist only +-// in one series (for example SA). If we want to use the consonant +-// SA with a vowel sound that can only be done with a vowel sound +-// that corresponds to a vowel accompanying a consonant of the +-// other series, then we need to use a consonant shifter: TRIISAP +-// or MUSIKATOAN x17C9 y x17CA. TRIISAP changes a first series +-// consonant to second series sound and MUSIKATOAN a second series +-// consonant to have a first series vowel sound. Consonant +-// shifter are both normally supercript marks, but, when they are +-// followed by a superscript, they change shape and take the form +-// of subscript dependent vowel SRA U. If they are in the same +-// syllable as a coeng consonant, Unicode 3.0 says that they +-// should be typed before the coeng. Unicode 4.0 breaks the +-// standard and says that it should be placed after the coeng +-// consonant. +-// Dependent vowel -> +-// In khmer dependent vowels can be placed above, below, before or +-// after the base Each vowel has its own position. Only one vowel +-// per syllable is allowed. +-// Signs -> +-// Khmer has above signs and post signs. Only one above sign +-// and/or one post sign are Allowed in a syllable. ++// Base -> A consonant or an independent vowel in its full (not subscript) form. It is the ++// center of the syllable, it can be souranded by coeng (subscript) consonants, vowels, ++// split vowels, signs... but there is only one base in a syllable, it has to be coded as ++// the first character of the syllable. ++// split vowel --> vowel that has two parts placed separately (e.g. Before and after the consonant). ++// Khmer language has five of them. Khmer split vowels either have one part before the ++// base and one after the base or they have a part before the base and a part above the base. ++// The first part of all Khmer split vowels is the same character, identical to ++// the glyph of Khmer dependent vowel SRA EI ++// coeng --> modifier used in Khmer to construct coeng (subscript) consonants ++// Differently than indian languages, the coeng modifies the consonant that follows it, ++// not the one preceding it Each consonant has two forms, the base form and the subscript form ++// the base form is the normal one (using the consonants code-point), the subscript form is ++// displayed when the combination coeng + consonant is encountered. ++// Consonant of type 1 -> A consonant which has subscript for that only occupies space under a base consonant ++// Consonant of type 2.-> Its subscript form occupies space under and before the base (only one, RO) ++// Consonant of Type 3 -> Its subscript form occupies space under and after the base (KHO, CHHO, THHO, BA, YO, SA) ++// Consonant shifter -> Khmer has to series of consonants. The same dependent vowel has different sounds ++// if it is attached to a consonant of the first series or a consonant of the second series ++// Most consonants have an equivalent in the other series, but some of theme exist only in ++// one series (for example SA). If we want to use the consonant SA with a vowel sound that ++// can only be done with a vowel sound that corresponds to a vowel accompanying a consonant ++// of the other series, then we need to use a consonant shifter: TRIISAP or MUSIKATOAN ++// x17C9 y x17CA. TRIISAP changes a first series consonant to second series sound and ++// MUSIKATOAN a second series consonant to have a first series vowel sound. ++// Consonant shifter are both normally supercript marks, but, when they are followed by a ++// superscript, they change shape and take the form of subscript dependent vowel SRA U. ++// If they are in the same syllable as a coeng consonant, Unicode 3.0 says that they ++// should be typed before the coeng. Unicode 4.0 breaks the standard and says that it should ++// be placed after the coeng consonant. ++// Dependent vowel -> In khmer dependent vowels can be placed above, below, before or after the base ++// Each vowel has its own position. Only one vowel per syllable is allowed. ++// Signs -> Khmer has above signs and post signs. Only one above sign and/or one post sign are ++// Allowed in a syllable. ++// + // + +-// This list must include all types of components that can be used +-// inside a syllable +-struct KhmerClassTable ++struct KhmerClassTable // This list must include all types of components that can be used inside a syllable + { +- // order is important here! This order must be the same that is +- // found in each horizontal line in the statetable for Khmer (file +- // KhmerReordering.cpp). +- enum CharClassValues ++ enum CharClassValues // order is important here! This order must be the same that is found in each horizontal ++ // line in the statetable for Khmer (file KhmerReordering.cpp). + { + CC_RESERVED = 0, + CC_CONSONANT = 1, // consonant of type 1 or independent vowel +@@ -116,8 +95,7 @@ + CC_CONSONANT3 = 3, // Consonant of type 3 + CC_ZERO_WIDTH_NJ_MARK = 4, // Zero Width non joiner character (0x200C) + CC_CONSONANT_SHIFTER = 5, +- CC_ROBAT = 6, // Khmer special diacritic accent +- // -treated differently in state table ++ CC_ROBAT = 6, // Khmer special diacritic accent -treated differently in state table + CC_COENG = 7, // Subscript consonant combining character + CC_DEPENDENT_VOWEL = 8, + CC_SIGN_ABOVE = 9, +@@ -131,10 +109,8 @@ + CF_CLASS_MASK = 0x0000FFFF, + + CF_CONSONANT = 0x01000000, // flag to speed up comparing +- CF_SPLIT_VOWEL = 0x02000000, // flag for a split vowel -> the first part +- // is added in front of the syllable +- CF_DOTTED_CIRCLE = 0x04000000, // add a dotted circle if a character with +- // this flag is the first in a syllable ++ CF_SPLIT_VOWEL = 0x02000000, // flag for a split vowel -> the first part is added in front of the syllable ++ CF_DOTTED_CIRCLE = 0x04000000, // add a dotted circle if a character with this flag is the first in a syllable + CF_COENG = 0x08000000, // flag to speed up comparing + CF_SHIFTER = 0x10000000, // flag to speed up comparing + CF_ABOVE_VOWEL = 0x20000000, // flag to speed up comparing +@@ -161,10 +137,10 @@ + }; + + +-class KhmerReordering { ++class KhmerReordering /* not : public UObject because all methods are static */ { + public: +- static le_int32 reorder(const LEUnicode *theChars, le_int32 charCount, +- le_int32 scriptCode, LEUnicode *outChars, LEGlyphStorage &glyphStorage); ++ static le_int32 reorder(const LEUnicode *theChars, le_int32 charCount, le_int32 scriptCode, ++ LEUnicode *outChars, LEGlyphStorage &glyphStorage); + + static const FeatureMap *getFeatureMap(le_int32 &count); + +@@ -172,8 +148,10 @@ + // do not instantiate + KhmerReordering(); + +- static le_int32 findSyllable(const KhmerClassTable *classTable, +- const LEUnicode *chars, le_int32 prev, le_int32 charCount); ++ static le_int32 findSyllable(const KhmerClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount); ++ + }; + ++ ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LEFontInstance.cpp b/src/share/native/sun/font/layout/LEFontInstance.cpp +--- jdk/src/share/native/sun/font/layout/LEFontInstance.cpp ++++ jdk/src/share/native/sun/font/layout/LEFontInstance.cpp +@@ -24,7 +24,6 @@ + */ + + /* +- * + ******************************************************************************* + * + * Copyright (C) 1999-2005, International Business Machines +@@ -42,6 +41,10 @@ + #include "LEFontInstance.h" + #include "LEGlyphStorage.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LEFontInstance) ++ + const LEFontInstance *LEFontInstance::getSubFont(const LEUnicode chars[], le_int32 *offset, le_int32 limit, + le_int32 script, LEErrorCode &success) const + { +@@ -59,7 +62,7 @@ + } + + void LEFontInstance::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, +- le_bool reverse, const LECharMapper *mapper, LEGlyphStorage &glyphStorage) const ++ le_bool reverse, const LECharMapper *mapper, LEGlyphStorage &glyphStorage) const + { + le_int32 i, out = 0, dir = 1; + +@@ -100,3 +103,5 @@ + + return mapCharToGlyph(mappedChar); + } ++U_NAMESPACE_END ++ +diff --git a/src/share/native/sun/font/layout/LEFontInstance.h b/src/share/native/sun/font/layout/LEFontInstance.h +--- jdk/src/share/native/sun/font/layout/LEFontInstance.h ++++ jdk/src/share/native/sun/font/layout/LEFontInstance.h +@@ -34,6 +34,12 @@ + #define __LEFONTINSTANCE_H + + #include "LETypes.h" ++/** ++ * \file ++ * \brief C++ API: Layout Engine Font Instance object ++ */ ++ ++U_NAMESPACE_BEGIN + + /** + * Instances of this class are used by <code>LEFontInstance::mapCharsToGlyphs</code> and +@@ -44,7 +50,7 @@ + * + * @stable ICU 3.2 + */ +-class LECharMapper ++class LECharMapper /* not : public UObject because this is an interface/mixin class */ + { + public: + /** +@@ -97,7 +103,7 @@ + * + * @draft ICU 3.0 + */ +-class LEFontInstance ++class U_LAYOUT_API LEFontInstance : public UObject + { + public: + +@@ -160,8 +166,7 @@ + * + * @stable ICU 3.2 + */ +- virtual const LEFontInstance *getSubFont(const LEUnicode chars[], le_int32 *offset, +- le_int32 limit, le_int32 script, LEErrorCode &success) const; ++ virtual const LEFontInstance *getSubFont(const LEUnicode chars[], le_int32 *offset, le_int32 limit, le_int32 script, LEErrorCode &success) const; + + // + // Font file access +@@ -238,8 +243,7 @@ + * + * @draft ICU 3.0 + */ +- virtual void mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, +- le_bool reverse, const LECharMapper *mapper, LEGlyphStorage &glyphStorage) const; ++ virtual void mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, const LECharMapper *mapper, LEGlyphStorage &glyphStorage) const; + + /** + * This method maps a single character to a glyph index, using the +@@ -502,6 +506,21 @@ + * @stable ICU 3.2 + */ + virtual le_int32 getLineHeight() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 3.2 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 3.2 ++ */ ++ static UClassID getStaticClassID(); ++ + }; + + inline le_bool LEFontInstance::canDisplay(LEUnicode32 ch) const +@@ -562,4 +581,7 @@ + return getAscent() + getDescent() + getLeading(); + } + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/LEGlyphFilter.h b/src/share/native/sun/font/layout/LEGlyphFilter.h +--- jdk/src/share/native/sun/font/layout/LEGlyphFilter.h ++++ jdk/src/share/native/sun/font/layout/LEGlyphFilter.h +@@ -34,14 +34,15 @@ + + #include "LETypes.h" + ++U_NAMESPACE_BEGIN ++ + /** + * This is a helper class that is used to + * recognize a set of glyph indices. + * + * @internal + */ +-class LEGlyphFilter +-{ ++class LEGlyphFilter /* not : public UObject because this is an interface/mixin class */ { + public: + /** + * Destructor. +@@ -63,4 +64,5 @@ + virtual le_bool accept(LEGlyphID glyph) const = 0; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LEGlyphStorage.cpp b/src/share/native/sun/font/layout/LEGlyphStorage.cpp +--- jdk/src/share/native/sun/font/layout/LEGlyphStorage.cpp ++++ jdk/src/share/native/sun/font/layout/LEGlyphStorage.cpp +@@ -24,7 +24,6 @@ + */ + + /* +- * + ********************************************************************** + * Copyright (C) 1998-2005, International Business Machines + * Corporation and others. All Rights Reserved. +@@ -35,6 +34,10 @@ + #include "LEInsertionList.h" + #include "LEGlyphStorage.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LEGlyphStorage) ++ + LEGlyphStorage::LEGlyphStorage() + : fGlyphCount(0), fGlyphs(NULL), fCharIndices(NULL), fPositions(NULL), + fAuxData(NULL), fInsertionList(NULL), fSrcIndex(0), fDestIndex(0) +@@ -603,3 +606,6 @@ + + return FALSE; + } ++ ++U_NAMESPACE_END ++ +diff --git a/src/share/native/sun/font/layout/LEGlyphStorage.h b/src/share/native/sun/font/layout/LEGlyphStorage.h +--- jdk/src/share/native/sun/font/layout/LEGlyphStorage.h ++++ jdk/src/share/native/sun/font/layout/LEGlyphStorage.h +@@ -24,7 +24,6 @@ + */ + + /* +- * + ********************************************************************** + * Copyright (C) 1998-2005, International Business Machines + * Corporation and others. All Rights Reserved. +@@ -38,6 +37,13 @@ + #include "LEInsertionList.h" + + /** ++ * \file ++ * \brief C++ API: This class encapsulates the per-glyph storage used by the ICU LayoutEngine. ++ */ ++ ++U_NAMESPACE_BEGIN ++ ++/** + * This class encapsulates the per-glyph storage used by the ICU LayoutEngine. + * For each glyph it holds the glyph ID, the index of the backing store character + * which produced the glyph, the X and Y position of the glyph and an auxillary data +@@ -50,7 +56,7 @@ + * + * @draft ICU 3.6 + */ +-class U_LAYOUT_API LEGlyphStorage : protected LEInsertionCallback ++class U_LAYOUT_API LEGlyphStorage : public UObject, protected LEInsertionCallback + { + private: + /** +@@ -112,35 +118,37 @@ + + protected: + /** +- * This implements <code>LEInsertionCallback</code>. The +- * <code>LEInsertionList</code> will call this method once for +- * each insertion. ++ * This implements <code>LEInsertionCallback</code>. The <code>LEInsertionList</code> ++ * will call this method once for each insertion. + * + * @param atPosition the position of the insertion + * @param count the number of glyphs being inserted + * @param newGlyphs the address of the new glyph IDs + * +- * @return <code>true</code> if <code>LEInsertionList</code> +- * should stop processing the insertion list after this insertion. ++ * @return <code>true</code> if <code>LEInsertionList</code> should stop ++ * processing the insertion list after this insertion. + * + * @see LEInsertionList.h + * + * @draft ICU 3.0 + */ +- virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, +- LEGlyphID newGlyphs[]); ++ virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[]); + + public: + + /** +- * Allocates an empty <code>LEGlyphStorage</code> object. You must +- * call <code>allocateGlyphArray, allocatePositions and +- * allocateAuxData</code> to allocate the data. ++ * Allocates an empty <code>LEGlyphStorage</code> object. You must call ++ * <code>allocateGlyphArray, allocatePositions and allocateAuxData</code> ++ * to allocate the data. ++ * ++ * @draft ICU 3.0 + */ + LEGlyphStorage(); + + /** + * The destructor. This will deallocate all of the arrays. ++ * ++ * @draft ICU 3.0 + */ + ~LEGlyphStorage(); + +@@ -154,9 +162,9 @@ + inline le_int32 getGlyphCount() const; + + /** +- * This method copies the glyph array into a caller supplied +- * array. The caller must ensure that the array is large enough +- * to hold all the glyphs. ++ * This method copies the glyph array into a caller supplied array. ++ * The caller must ensure that the array is large enough to hold all ++ * the glyphs. + * + * @param glyphs - the destiniation glyph array + * @param success - set to an error code if the operation fails +@@ -166,10 +174,10 @@ + void getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const; + + /** +- * This method copies the glyph array into a caller supplied +- * array, ORing in extra bits. (This functionality is needed by +- * the JDK, which uses 32 bits pre glyph idex, with the high 16 +- * bits encoding the composite font slot number) ++ * This method copies the glyph array into a caller supplied array, ++ * ORing in extra bits. (This functionality is needed by the JDK, ++ * which uses 32 bits pre glyph idex, with the high 16 bits encoding ++ * the composite font slot number) + * + * @param glyphs - the destination (32 bit) glyph array + * @param extraBits - this value will be ORed with each glyph index +@@ -177,13 +185,12 @@ + * + * @draft ICU 3.0 + */ +- void getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, +- LEErrorCode &success) const; ++ void getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const; + + /** +- * This method copies the character index array into a caller +- * supplied array. The caller must ensure that the array is large +- * enough to hold a character index for each glyph. ++ * This method copies the character index array into a caller supplied array. ++ * The caller must ensure that the array is large enough to hold a ++ * character index for each glyph. + * + * @param charIndices - the destiniation character index array + * @param success - set to an error code if the operation fails +@@ -193,9 +200,9 @@ + void getCharIndices(le_int32 charIndices[], LEErrorCode &success) const; + + /** +- * This method copies the character index array into a caller +- * supplied array. The caller must ensure that the array is large +- * enough to hold a character index for each glyph. ++ * This method copies the character index array into a caller supplied array. ++ * The caller must ensure that the array is large enough to hold a ++ * character index for each glyph. + * + * @param charIndices - the destiniation character index array + * @param indexBase - an offset which will be added to each index +@@ -203,14 +210,13 @@ + * + * @draft ICU 3.0 + */ +- void getCharIndices(le_int32 charIndices[], le_int32 indexBase, +- LEErrorCode &success) const; ++ void getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const; + + /** +- * This method copies the position array into a caller supplied +- * array. The caller must ensure that the array is large enough +- * to hold an X and Y position for each glyph, plus an extra X and +- * Y for the advance of the last glyph. ++ * This method copies the position array into a caller supplied array. ++ * The caller must ensure that the array is large enough to hold an ++ * X and Y position for each glyph, plus an extra X and Y for the ++ * advance of the last glyph. + * + * @param positions - the destiniation position array + * @param success - set to an error code if the operation fails +@@ -233,33 +239,27 @@ + * + * @draft ICU 3.0 + */ +- void getGlyphPosition(le_int32 glyphIndex, float &x, float &y, +- LEErrorCode &success) const; ++ void getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const; + + /** +- * This method allocates the glyph array, the char indices array +- * and the insertion list. You must call this method before using +- * the object. This method also initializes the char indices ++ * This method allocates the glyph array, the char indices array and the insertion list. You ++ * must call this method before using the object. This method also initializes the char indices + * array. +- * @param initialGlyphCount the initial size of the glyph and char +- * indices arrays. +- * @param rightToLeft <code>true</code> if the original input text +- * is right to left. +- * @param success set to an error code if the storage cannot be +- * allocated of if the initial glyph count is not positive. ++ * ++ * @param initialGlyphCount the initial size of the glyph and char indices arrays. ++ * @param rightToLeft <code>true</code> if the original input text is right to left. ++ * @param success set to an error code if the storage cannot be allocated of if the initial ++ * glyph count is not positive. + * + * @draft ICU 3.0 + */ +- void allocateGlyphArray(le_int32 initialGlyphCount, le_bool rightToLeft, +- LEErrorCode &success); ++ void allocateGlyphArray(le_int32 initialGlyphCount, le_bool rightToLeft, LEErrorCode &success); + + /** +- * This method allocates the storage for the glyph positions. It +- * allocates one extra X, Y position pair for the position just +- * after the last glyph. ++ * This method allocates the storage for the glyph positions. It allocates one extra X, Y ++ * position pair for the position just after the last glyph. + * +- * @param success set to an error code if the positions array +- * cannot be allocated. ++ * @param success set to an error code if the positions array cannot be allocated. + * + * @return the number of X, Y position pairs allocated. + * +@@ -270,8 +270,7 @@ + /** + * This method allocates the storage for the auxillary glyph data. + * +- * @param success set to an error code if the aulillary data array +- * cannot be allocated. ++ * @param success set to an error code if the aulillary data array cannot be allocated. + * + * @return the size of the auxillary data array. + * +@@ -282,10 +281,8 @@ + /** + * Copy the entire auxillary data array. + * +- * @param auxData the auxillary data array will be copied to this +- * address +- * @param success set to an error code if the data cannot be +- * copied ++ * @param auxData the auxillary data array will be copied to this address ++ * @param success set to an error code if the data cannot be copied + * + * @draft ICU 3.6 + */ +@@ -295,8 +292,7 @@ + * Get the glyph ID for a particular glyph. + * + * @param glyphIndex the index into the glyph array +- * @param success set to an error code if the glyph ID cannot be +- * retrieved. ++ * @param success set to an error code if the glyph ID cannot be retrieved. + * + * @return the glyph ID + * +@@ -308,8 +304,7 @@ + * Get the char index for a particular glyph. + * + * @param glyphIndex the index into the glyph array +- * @param success set to an error code if the char index cannot be +- * retrieved. ++ * @param success set to an error code if the char index cannot be retrieved. + * + * @return the character index + * +@@ -322,8 +317,7 @@ + * Get the auxillary data for a particular glyph. + * + * @param glyphIndex the index into the glyph array +- * @param success set to an error code if the auxillary data +- * cannot be retrieved. ++ * @param success set to an error code if the auxillary data cannot be retrieved. + * + * @return the auxillary data + * +@@ -345,11 +339,10 @@ + + /** + * Call this method to replace a single glyph in the glyph array +- * with multiple glyphs. This method uses the +- * <code>LEInsertionList</code> to do the insertion. It returns +- * the address of storage where the new glyph IDs can be +- * stored. They will not actually be inserted into the glyph array +- * until <code>applyInsertions</code> is called. ++ * with multiple glyphs. This method uses the <code>LEInsertionList</code> ++ * to do the insertion. It returns the address of storage where the new ++ * glyph IDs can be stored. They will not actually be inserted into the ++ * glyph array until <code>applyInsertions</code> is called. + * + * @param atIndex the index of the glyph to be replaced + * @param insertCount the number of glyphs to replace it with +@@ -381,26 +374,22 @@ + * + * @param glyphIndex the index of the glyph + * @param glyphID the new glyph ID +- * @param success will be set to an error code if the glyph ID +- * cannot be set. ++ * @param success will be set to an error code if the glyph ID cannot be set. + * + * @draft ICU 3.0 + */ +- void setGlyphID(le_int32 glyphIndex, LEGlyphID glyphID, +- LEErrorCode &success); ++ void setGlyphID(le_int32 glyphIndex, LEGlyphID glyphID, LEErrorCode &success); + + /** + * Set the char index for a particular glyph. + * + * @param glyphIndex the index of the glyph + * @param charIndex the new char index +- * @param success will be set to an error code if the char index +- * cannot be set. ++ * @param success will be set to an error code if the char index cannot be set. + * + * @draft ICU 3.0 + */ +- void setCharIndex(le_int32 glyphIndex, le_int32 charIndex, +- LEErrorCode &success); ++ void setCharIndex(le_int32 glyphIndex, le_int32 charIndex, LEErrorCode &success); + + /** + * Set the X, Y position for a particular glyph. +@@ -408,13 +397,11 @@ + * @param glyphIndex the index of the glyph + * @param x the new X position + * @param y the new Y position +- * @param success will be set to an error code if the position +- * cannot be set. ++ * @param success will be set to an error code if the position cannot be set. + * + * @draft ICU 3.0 + */ +- void setPosition(le_int32 glyphIndex, float x, float y, +- LEErrorCode &success); ++ void setPosition(le_int32 glyphIndex, float x, float y, LEErrorCode &success); + + /** + * Adjust the X, Y position for a particular glyph. +@@ -422,21 +409,18 @@ + * @param glyphIndex the index of the glyph + * @param xAdjust the adjustment to the glyph's X position + * @param yAdjust the adjustment to the glyph's Y position +- * @param success will be set to an error code if the glyph's +- * position cannot be adjusted. ++ * @param success will be set to an error code if the glyph's position cannot be adjusted. + * + * @draft ICU 3.0 + */ +- void adjustPosition(le_int32 glyphIndex, float xAdjust, float yAdjust, +- LEErrorCode &success); ++ void adjustPosition(le_int32 glyphIndex, float xAdjust, float yAdjust, LEErrorCode &success); + + /** + * Set the auxillary data for a particular glyph. + * + * @param glyphIndex the index of the glyph + * @param auxData the new auxillary data +- * @param success will be set to an error code if the auxillary +- * data cannot be set. ++ * @param success will be set to an error code if the auxillary data cannot be set. + * + * @draft ICU 3.6 + */ +@@ -511,14 +495,28 @@ + void adoptGlyphCount(le_int32 newGlyphCount); + + /** +- * This method frees the glyph, character index, position and +- * auxillary data arrays so that the LayoutEngine can be reused to +- * layout a different characer array. (This method is also called ++ * This method frees the glyph, character index, position and ++ * auxillary data arrays so that the LayoutEngine can be reused ++ * to layout a different characer array. (This method is also called + * by the destructor) + * + * @draft ICU 3.0 + */ + void reset(); ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @draft ICU 3.0 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @draft ICU 3.0 ++ */ ++ static UClassID getStaticClassID(); + }; + + inline le_int32 LEGlyphStorage::getGlyphCount() const +@@ -531,4 +529,7 @@ + return fGlyphs[glyphIndex]; + } + ++ ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/LEInsertionList.cpp b/src/share/native/sun/font/layout/LEInsertionList.cpp +--- jdk/src/share/native/sun/font/layout/LEInsertionList.cpp ++++ jdk/src/share/native/sun/font/layout/LEInsertionList.cpp +@@ -24,7 +24,6 @@ + */ + + /* +- * + ********************************************************************** + * Copyright (C) 1998-2004, International Business Machines + * Corporation and others. All Rights Reserved. +@@ -34,6 +33,8 @@ + #include "LETypes.h" + #include "LEInsertionList.h" + ++U_NAMESPACE_BEGIN ++ + #define ANY_NUMBER 1 + + struct InsertionRecord +@@ -44,6 +45,8 @@ + LEGlyphID glyphs[ANY_NUMBER]; + }; + ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LEInsertionList) ++ + LEInsertionList::LEInsertionList(le_bool rightToLeft) + : head(NULL), tail(NULL), growAmount(0), append(rightToLeft) + { +@@ -106,3 +109,5 @@ + + return FALSE; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/LEInsertionList.h b/src/share/native/sun/font/layout/LEInsertionList.h +--- jdk/src/share/native/sun/font/layout/LEInsertionList.h ++++ jdk/src/share/native/sun/font/layout/LEInsertionList.h +@@ -24,7 +24,6 @@ + */ + + /* +- * + ********************************************************************** + * Copyright (C) 1998-2004, International Business Machines + * Corporation and others. All Rights Reserved. +@@ -36,6 +35,8 @@ + + #include "LETypes.h" + ++U_NAMESPACE_BEGIN ++ + struct InsertionRecord; + + /** +@@ -78,7 +79,7 @@ + * + * @internal + */ +-class LEInsertionList ++class LEInsertionList : public UObject + { + public: + /** +@@ -140,6 +141,20 @@ + */ + void reset(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + + /** +@@ -174,4 +189,6 @@ + le_bool append; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/LELanguages.h b/src/share/native/sun/font/layout/LELanguages.h +--- jdk/src/share/native/sun/font/layout/LELanguages.h ++++ jdk/src/share/native/sun/font/layout/LELanguages.h +@@ -25,10 +25,12 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004. All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2005. All Rights Reserved. + * + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS + * YOU REALLY KNOW WHAT YOU'RE DOING. ++ * ++ * Generated on: 07/19/2005 01:01:08 PM PDT + */ + + #ifndef __LELANGUAGES_H +@@ -37,11 +39,18 @@ + #include "LETypes.h" + + /** ++ * \file ++ * \brief C++ API: List of language codes for LayoutEngine ++ */ ++ ++U_NAMESPACE_BEGIN ++ ++/** + * A provisional list of language codes. For now, + * this is just a list of languages which the LayoutEngine + * supports. + * +- * @draft ICU 3.0 ++ * @draft ICU 3.4 + */ + + enum LanguageCodes { +@@ -79,4 +88,5 @@ + languageCodeCount = 30 + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LEScripts.h b/src/share/native/sun/font/layout/LEScripts.h +--- jdk/src/share/native/sun/font/layout/LEScripts.h ++++ jdk/src/share/native/sun/font/layout/LEScripts.h +@@ -25,17 +25,23 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004. All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2005. All Rights Reserved. + * + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS + * YOU REALLY KNOW WHAT YOU'RE DOING. +- * + */ + + #ifndef __LESCRIPTS_H + #define __LESCRIPTS_H + + #include "LETypes.h" ++/** ++ * \file ++ * \brief C++ API: Constants for Unicode script values ++ */ ++ ++ ++U_NAMESPACE_BEGIN + + /** + * Constants for Unicode script values, generated using +@@ -104,4 +110,5 @@ + scriptCodeCount = 55 + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LEStandalone.h b/src/share/native/sun/font/layout/LEStandalone.h +new file mode 100644 +--- /dev/null ++++ jdk/src/share/native/sun/font/layout/LEStandalone.h +@@ -0,0 +1,132 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Sun designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Sun in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ * ++ */ ++ ++#ifndef __LESTANDALONE ++#define __LESTANDALONE ++ ++/* Definitions to make Layout Engine work away from ICU. */ ++#ifndef U_NAMESPACE_BEGIN ++#define U_NAMESPACE_BEGIN ++#endif ++ ++#ifndef U_NAMESPACE_END ++#define U_NAMESPACE_END ++#endif ++ ++/* RTTI Definition */ ++typedef const char *UClassID; ++#ifndef UOBJECT_DEFINE_RTTI_IMPLEMENTATION ++#define UOBJECT_DEFINE_RTTI_IMPLEMENTATION(x) UClassID x::getStaticClassID(){static char z=0; return (UClassID)&z; } UClassID x::getDynamicClassID() const{return x::getStaticClassID(); } ++#endif ++ ++/* UMemory's functions aren't used by the layout engine. */ ++struct UMemory {}; ++/* UObject's functions aren't used by the layout engine. */ ++struct UObject {}; ++ ++/* String handling */ ++#include <stdlib.h> ++#include <string.h> ++ ++/** ++ * A convenience macro to test for the success of a LayoutEngine call. ++ * ++ * @stable ICU 2.4 ++ */ ++#define LE_SUCCESS(code) ((code)<=LE_NO_ERROR) ++ ++/** ++ * A convenience macro to test for the failure of a LayoutEngine call. ++ * ++ * @stable ICU 2.4 ++ */ ++#define LE_FAILURE(code) ((code)>LE_NO_ERROR) ++ ++ ++#ifndef _LP64 ++typedef long le_int32; ++typedef unsigned long le_uint32; ++#else ++typedef int le_int32; ++typedef unsigned int le_uint32; ++#endif ++ ++#define HAVE_LE_INT32 1 ++#define HAVE_LE_UINT32 1 ++ ++typedef unsigned short UChar; ++typedef le_uint32 UChar32; ++ ++typedef short le_int16; ++#define HAVE_LE_INT16 1 ++ ++typedef unsigned short le_uint16; ++#define HAVE_LE_UINT16 ++ ++typedef signed char le_int8; ++#define HAVE_LE_INT8 ++ ++typedef unsigned char le_uint8; ++#define HAVE_LE_UINT8 ++ ++typedef char UBool; ++ ++/** ++ * Error codes returned by the LayoutEngine. ++ * ++ * @stable ICU 2.4 ++ */ ++enum LEErrorCode { ++ /* informational */ ++ LE_NO_SUBFONT_WARNING = -127, // U_USING_DEFAULT_WARNING, ++ ++ /* success */ ++ LE_NO_ERROR = 0, // U_ZERO_ERROR, ++ ++ /* failures */ ++ LE_ILLEGAL_ARGUMENT_ERROR = 1, // U_ILLEGAL_ARGUMENT_ERROR, ++ LE_MEMORY_ALLOCATION_ERROR = 7, // U_MEMORY_ALLOCATION_ERROR, ++ LE_INDEX_OUT_OF_BOUNDS_ERROR = 8, //U_INDEX_OUTOFBOUNDS_ERROR, ++ LE_NO_LAYOUT_ERROR = 16, // U_UNSUPPORTED_ERROR, ++ LE_INTERNAL_ERROR = 5, // U_INTERNAL_PROGRAM_ERROR, ++ LE_FONT_FILE_NOT_FOUND_ERROR = 4, // U_FILE_ACCESS_ERROR, ++ LE_MISSING_FONT_TABLE_ERROR = 2 // U_MISSING_RESOURCE_ERROR ++}; ++#define HAVE_LEERRORCODE ++ ++#define U_LAYOUT_API ++ ++#define uprv_malloc malloc ++#define uprv_free free ++#define uprv_memcpy memcpy ++#define uprv_realloc realloc ++ ++#if !defined(U_IS_BIG_ENDIAN) ++ #ifdef _LITTLE_ENDIAN ++ #define U_IS_BIG_ENDIAN 0 ++ #endif ++#endif ++ ++#endif +diff --git a/src/share/native/sun/font/layout/LESwaps.h b/src/share/native/sun/font/layout/LESwaps.h +--- jdk/src/share/native/sun/font/layout/LESwaps.h ++++ jdk/src/share/native/sun/font/layout/LESwaps.h +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ + +@@ -35,11 +35,12 @@ + + #include "LETypes.h" + +-#if !defined(U_IS_BIG_ENDIAN) +- #ifdef _LITTLE_ENDIAN +- #define U_IS_BIG_ENDIAN 0 +- #endif +-#endif ++/** ++ * \file ++ * \brief C++ API: Endian independent access to data for LayoutEngine ++ */ ++ ++U_NAMESPACE_BEGIN + + /** + * A convenience macro which invokes the swapWord member function +@@ -47,7 +48,6 @@ + * + * @stable ICU 2.8 + */ +- + #if defined(U_IS_BIG_ENDIAN) + #if U_IS_BIG_ENDIAN + #define SWAPW(value) (value) +@@ -64,7 +64,6 @@ + * + * @stable ICU 2.8 + */ +- + #if defined(U_IS_BIG_ENDIAN) + #if U_IS_BIG_ENDIAN + #define SWAPL(value) (value) +@@ -86,8 +85,7 @@ + * + * @stable ICU 2.8 + */ +-class LESwaps +-{ ++class U_LAYOUT_API LESwaps /* not : public UObject because all methods are static */ { + public: + + #if !defined(U_IS_BIG_ENDIAN) +@@ -144,4 +142,5 @@ + LESwaps() {} // private - forbid instantiation + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LETypes.h b/src/share/native/sun/font/layout/LETypes.h +--- jdk/src/share/native/sun/font/layout/LETypes.h ++++ jdk/src/share/native/sun/font/layout/LETypes.h +@@ -23,7 +23,6 @@ + * + */ + +- + /* + * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved +@@ -33,73 +32,97 @@ + #ifndef __LETYPES_H + #define __LETYPES_H + ++/** ++ * If LE_Standalone is defined, it must exist and contain ++ * definitions for some core ICU defines. ++ */ ++#ifdef LE_STANDALONE ++#include "LEStandalone.h" ++#endif ++ ++#ifdef LE_STANDALONE ++/* Stand-alone Layout Engine- without ICU. */ ++#include "LEStandalone.h" + #define LE_USE_CMEMORY ++#else ++#if !defined(LE_USE_CMEMORY) && (defined(U_LAYOUT_IMPLEMENTATION) || defined(U_LAYOUTEX_IMPLEMENTATION) || defined(U_STATIC_IMPLEMENTATION) || defined(U_COMBINED_IMPLEMENTATION)) ++#define LE_USE_CMEMORY ++#endif + ++#include "unicode/utypes.h" ++#include "unicode/uobject.h" + #ifdef LE_USE_CMEMORY + #include "cmemory.h" + #endif ++#endif /* not standalone */ + +-#ifndef _LP64 +-typedef long le_int32; +-typedef unsigned long le_uint32; +-#else +-typedef int le_int32; +-typedef unsigned int le_uint32; +-#endif ++U_NAMESPACE_BEGIN + +-typedef short le_int16; +-typedef unsigned short le_uint16; +-typedef signed char le_int8; +-typedef unsigned char le_uint8; +-typedef char le_bool; ++/*! ++ * \file ++ * \brief Basic definitions for the ICU LayoutEngine ++ */ + +-typedef char UClassID; +- +-#if 0 + /** + * A type used for signed, 32-bit integers. + * + * @stable ICU 2.4 + */ ++#ifndef HAVE_LE_INT32 + typedef int32_t le_int32; ++#endif + + /** + * A type used for unsigned, 32-bit integers. + * + * @stable ICU 2.4 + */ ++#ifndef HAVE_LE_UINT32 + typedef uint32_t le_uint32; ++#endif + + /** + * A type used for signed, 16-bit integers. + * + * @stable ICU 2.4 + */ ++#ifndef HAVE_LE_INT16 + typedef int16_t le_int16; ++#endif + ++#ifndef HAVE_LE_UINT16 + /** + * A type used for unsigned, 16-bit integers. + * + * @stable ICU 2.4 + */ + typedef uint16_t le_uint16; ++#endif + ++#ifndef HAVE_LE_INT8 + /** + * A type used for signed, 8-bit integers. + * + * @stable ICU 2.4 + */ + typedef int8_t le_int8; +- ++#endif ++ ++#ifndef HAVE_LE_UINT8 + /** + * A type used for unsigned, 8-bit integers. + * + * @stable ICU 2.4 + */ + typedef uint8_t le_uint8; ++#endif + +-typedef char le_bool; +-#endif ++/** ++* A type used for boolean values. ++* ++* @stable ICU 2.4 ++*/ ++typedef UBool le_bool; + + #ifndef TRUE + /** +@@ -292,21 +315,21 @@ + * + * @stable ICU 2.4 + */ +-typedef le_uint16 LEUnicode16; ++typedef UChar LEUnicode16; + + /** + * Used to represent 32-bit Unicode code points. + * + * @stable ICU 2.4 + */ +-typedef le_uint32 LEUnicode32; ++typedef UChar32 LEUnicode32; + + /** + * Used to represent 16-bit Unicode code points. + * + * @deprecated since ICU 2.4. Use LEUnicode16 instead + */ +-typedef le_uint16 LEUnicode; ++typedef UChar LEUnicode; + + /** + * Used to hold a pair of (x, y) values which represent a point. +@@ -353,7 +376,7 @@ + * + * @internal + */ +-#define LE_ARRAY_COPY(dst, src, count) memcpy((void *) (dst), (void *) (src), (count) * sizeof (src)[0]) ++#define LE_ARRAY_COPY(dst, src, count) uprv_memcpy((void *) (dst), (void *) (src), (count) * sizeof (src)[0]) + + /** + * Allocate an array of basic types. This is used to isolate the rest of +@@ -361,7 +384,7 @@ + * + * @internal + */ +-#define LE_NEW_ARRAY(type, count) (type *) malloc((count) * sizeof(type)) ++#define LE_NEW_ARRAY(type, count) (type *) uprv_malloc((count) * sizeof(type)) + + /** + * Re-allocate an array of basic types. This is used to isolate the rest of +@@ -369,7 +392,7 @@ + * + * @internal + */ +-#define LE_GROW_ARRAY(array, newSize) realloc((void *) (array), (newSize) * sizeof (array)[0]) ++#define LE_GROW_ARRAY(array, newSize) uprv_realloc((void *) (array), (newSize) * sizeof (array)[0]) + + /** + * Free an array of basic types. This is used to isolate the rest of +@@ -377,7 +400,7 @@ + * + * @internal + */ +-#define LE_DELETE_ARRAY(array) free((void *) (array)) ++#define LE_DELETE_ARRAY(array) uprv_free((void *) (array)) + #endif + + /** +@@ -595,22 +618,24 @@ + * + * @stable ICU 2.4 + */ ++#ifndef HAVE_LEERRORCODE + enum LEErrorCode { + /* informational */ +- LE_NO_SUBFONT_WARNING = -127, // U_USING_DEFAULT_WARNING, ++ LE_NO_SUBFONT_WARNING = U_USING_DEFAULT_WARNING, /**< The font does not contain subfonts. */ + + /* success */ +- LE_NO_ERROR = 0, // U_ZERO_ERROR, ++ LE_NO_ERROR = U_ZERO_ERROR, /**< No error, no warning. */ + + /* failures */ +- LE_ILLEGAL_ARGUMENT_ERROR = 1, // U_ILLEGAL_ARGUMENT_ERROR, +- LE_MEMORY_ALLOCATION_ERROR = 7, // U_MEMORY_ALLOCATION_ERROR, +- LE_INDEX_OUT_OF_BOUNDS_ERROR = 8, //U_INDEX_OUTOFBOUNDS_ERROR, +- LE_NO_LAYOUT_ERROR = 16, // U_UNSUPPORTED_ERROR, +- LE_INTERNAL_ERROR = 5, // U_INTERNAL_PROGRAM_ERROR, +- LE_FONT_FILE_NOT_FOUND_ERROR = 4, // U_FILE_ACCESS_ERROR, +- LE_MISSING_FONT_TABLE_ERROR = 2 // U_MISSING_RESOURCE_ERROR ++ LE_ILLEGAL_ARGUMENT_ERROR = U_ILLEGAL_ARGUMENT_ERROR, /**< An illegal argument was detected. */ ++ LE_MEMORY_ALLOCATION_ERROR = U_MEMORY_ALLOCATION_ERROR, /**< Memory allocation error. */ ++ LE_INDEX_OUT_OF_BOUNDS_ERROR = U_INDEX_OUTOFBOUNDS_ERROR, /**< Trying to access an index that is out of bounds. */ ++ LE_NO_LAYOUT_ERROR = U_UNSUPPORTED_ERROR, /**< You must call layoutChars() first. */ ++ LE_INTERNAL_ERROR = U_INTERNAL_PROGRAM_ERROR, /**< An internal error was encountered. */ ++ LE_FONT_FILE_NOT_FOUND_ERROR = U_FILE_ACCESS_ERROR, /**< The requested font file cannot be opened. */ ++ LE_MISSING_FONT_TABLE_ERROR = U_MISSING_RESOURCE_ERROR /**< The requested font table does not exist. */ + }; ++#endif + + #ifndef XP_CPLUSPLUS + /** +@@ -626,7 +651,9 @@ + * + * @stable ICU 2.4 + */ +-#define LE_SUCCESS(code) ((code)<=LE_NO_ERROR) ++#ifndef LE_FAILURE ++#define LE_SUCCESS(code) (U_SUCCESS((UErrorCode)code)) ++#endif + + enum LEFeatureENUMs { + LE_Kerning_FEATURE_ENUM = 0, +@@ -648,7 +675,11 @@ + * + * @stable ICU 2.4 + */ +-#define LE_FAILURE(code) ((code)>LE_NO_ERROR) ++#ifndef LE_FAILURE ++#define LE_FAILURE(code) (U_FAILURE((UErrorCode)code)) ++#endif + +-#define U_LAYOUT_API ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/LayoutEngine.cpp b/src/share/native/sun/font/layout/LayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/LayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/LayoutEngine.cpp +@@ -23,6 +23,7 @@ + * + */ + ++ + /* + * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved +@@ -41,6 +42,7 @@ + #include "IndicLayoutEngine.h" + #include "KhmerLayoutEngine.h" + #include "ThaiLayoutEngine.h" ++//#include "TibetanLayoutEngine.h" + #include "GXLayoutEngine.h" + #include "ScriptAndLanguageTags.h" + #include "CharSubstitutionFilter.h" +@@ -56,6 +58,8 @@ + + #include "KernTable.h" + ++U_NAMESPACE_BEGIN ++ + const LEUnicode32 DefaultCharMapper::controlChars[] = { + 0x0009, 0x000A, 0x000D, + /*0x200C, 0x200D,*/ 0x200E, 0x200F, +@@ -102,9 +106,7 @@ + } + + if (fMirror) { +- le_int32 index = OpenTypeUtilities::search((le_uint32) ch, +- (le_uint32 *)DefaultCharMapper::mirroredChars, +- DefaultCharMapper::mirroredCharsCount); ++ le_int32 index = OpenTypeUtilities::search((le_uint32) ch, (le_uint32 *)DefaultCharMapper::mirroredChars, DefaultCharMapper::mirroredCharsCount); + + if (mirroredChars[index] == ch) { + return DefaultCharMapper::srahCderorrim[index]; +@@ -133,6 +135,9 @@ + // nothing to do + } + ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine) ++ + #define ccmpFeatureTag LE_CCMP_FEATURE_TAG + + #define ccmpFeatureMask 0x80000000UL +@@ -146,10 +151,9 @@ + + static const le_int32 canonFeatureMapCount = LE_ARRAY_SIZE(canonFeatureMap); + +-LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, +- le_int32 languageCode, le_int32 typoFlags) +- : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), +- fLanguageCode(languageCode), fTypoFlags(typoFlags) ++LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) ++ : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), fLanguageCode(languageCode), ++ fTypoFlags(typoFlags) + { + fGlyphStorage = new LEGlyphStorage(); + } +@@ -159,8 +163,7 @@ + return fGlyphStorage->getGlyphCount(); + } + +-void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, +- LEErrorCode &success) const ++void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const + { + fGlyphStorage->getCharIndices(charIndices, indexBase, success); + } +@@ -171,8 +174,7 @@ + } + + // Copy the glyphs into caller's (32-bit) glyph array, OR in extraBits +-void LayoutEngine::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, +- LEErrorCode &success) const ++void LayoutEngine::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const + { + fGlyphStorage->getGlyphs(glyphs, extraBits, success); + } +@@ -219,15 +221,13 @@ + fGlyphStorage->getGlyphPositions(positions, success); + } + +-void LayoutEngine::getGlyphPosition(le_int32 glyphIndex, float &x, float &y, +- LEErrorCode &success) const ++void LayoutEngine::getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const + { + fGlyphStorage->getGlyphPosition(glyphIndex, x, y, success); + } + +-le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, LEUnicode *&outChars, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -238,12 +238,7 @@ + return 0; + } + +- if ((fTypoFlags & 0x4) == 0) { // no canonical processing +- return count; +- } +- +- const GlyphSubstitutionTableHeader *canonGSUBTable = +- (GlyphSubstitutionTableHeader *) CanonShaping::glyphSubstitutionTable; ++ const GlyphSubstitutionTableHeader *canonGSUBTable = (GlyphSubstitutionTableHeader *) CanonShaping::glyphSubstitutionTable; + LETag scriptTag = OpenTypeLayoutEngine::getScriptTag(fScriptCode); + LETag langSysTag = OpenTypeLayoutEngine::getLangSysTag(fLanguageCode); + le_int32 i, dir = 1, out = 0, outCharCount = count; +@@ -257,16 +252,15 @@ + // We could just do the mark reordering for all scripts, but most + // of them probably don't need it... + if (fScriptCode == hebrScriptCode) { +- reordered = LE_NEW_ARRAY(LEUnicode, count); ++ reordered = LE_NEW_ARRAY(LEUnicode, count); + +- if (reordered == NULL) { +- success = LE_MEMORY_ALLOCATION_ERROR; +- return 0; +- } ++ if (reordered == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return 0; ++ } + +- CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, +- reordered, glyphStorage); +- inChars = reordered; ++ CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, reordered, glyphStorage); ++ inChars = reordered; + } + + glyphStorage.allocateGlyphArray(count, rightToLeft, success); +@@ -290,8 +284,7 @@ + LE_DELETE_ARRAY(reordered); + } + +- outCharCount = canonGSUBTable->process(glyphStorage, rightToLeft, scriptTag, +- langSysTag, NULL, substitutionFilter, canonFeatureMap, canonFeatureMapCount, FALSE); ++ outCharCount = canonGSUBTable->process(glyphStorage, rightToLeft, scriptTag, langSysTag, NULL, substitutionFilter, canonFeatureMap, canonFeatureMapCount, FALSE); + + out = (rightToLeft? outCharCount - 1 : 0); + +@@ -306,35 +299,26 @@ + return outCharCount; + } + +- +-le_int32 LayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 LayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; + } + +- if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || +- offset + count > max) { +- ++ if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + + LEUnicode *outChars = NULL; +- le_int32 outCharCount = characterProcessing(chars, offset, count, max, +- rightToLeft, outChars, glyphStorage, success); ++ le_int32 outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, outChars, glyphStorage, success); + + if (outChars != NULL) { +- mapCharsToGlyphs(outChars, 0, outCharCount, rightToLeft, rightToLeft, +- glyphStorage, success); +- // FIXME: a subclass may have allocated this, in which case this delete +- // might not work... +- LE_DELETE_ARRAY(outChars); ++ mapCharsToGlyphs(outChars, 0, outCharCount, rightToLeft, rightToLeft, glyphStorage, success); ++ LE_DELETE_ARRAY(outChars); // FIXME: a subclass may have allocated this, in which case this delete might not work... + } else { +- mapCharsToGlyphs(chars, offset, count, rightToLeft, rightToLeft, +- glyphStorage, success); ++ mapCharsToGlyphs(chars, offset, count, rightToLeft, rightToLeft, glyphStorage, success); + } + + return glyphStorage.getGlyphCount(); +@@ -342,8 +326,7 @@ + + // Input: glyphs + // Output: positions +-void LayoutEngine::positionGlyphs(LEGlyphStorage &glyphStorage, +- float x, float y, LEErrorCode &success) ++void LayoutEngine::positionGlyphs(LEGlyphStorage &glyphStorage, float x, float y, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return; +@@ -370,9 +353,8 @@ + glyphStorage.setPosition(glyphCount, x, y, success); + } + +-void LayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++void LayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return; +@@ -399,8 +381,7 @@ + return; + } + +-void LayoutEngine::adjustMarkGlyphs(LEGlyphStorage &glyphStorage, +- LEGlyphFilter *markFilter, LEErrorCode &success) ++void LayoutEngine::adjustMarkGlyphs(LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success) + { + float xAdjust = 0; + le_int32 p, glyphCount = glyphStorage.getGlyphCount(); +@@ -436,9 +417,7 @@ + glyphStorage.adjustPosition(glyphCount, xAdjust, 0, success); + } + +-void LayoutEngine::adjustMarkGlyphs(const LEUnicode chars[], le_int32 charCount, +- le_bool reverse, LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, +- LEErrorCode &success) ++void LayoutEngine::adjustMarkGlyphs(const LEUnicode chars[], le_int32 charCount, le_bool reverse, LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success) + { + float xAdjust = 0; + le_int32 c = 0, direction = 1, p; +@@ -485,9 +464,8 @@ + return fFontInstance->getFontTable(tableTag); + } + +-void LayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, le_bool mirror, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++void LayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, le_bool mirror, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return; +@@ -497,32 +475,27 @@ + + DefaultCharMapper charMapper(TRUE, mirror); + +- fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, +- &charMapper, glyphStorage); ++ fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, glyphStorage); + } + + // Input: characters, font? + // Output: glyphs, positions, char indices + // Returns: number of glyphs +-le_int32 LayoutEngine::layoutChars(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- float x, float y, LEErrorCode &success) ++le_int32 LayoutEngine::layoutChars(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ float x, float y, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; + } + +- if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || +- offset + count > max) { +- ++ if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + + le_int32 glyphCount; + +- glyphCount = computeGlyphs(chars, offset, count, max, rightToLeft, +- *fGlyphStorage, success); ++ glyphCount = computeGlyphs(chars, offset, count, max, rightToLeft, *fGlyphStorage, success); + positionGlyphs(*fGlyphStorage, x, y, success); + adjustGlyphPositions(chars, offset, count, rightToLeft, *fGlyphStorage, success); + +@@ -534,17 +507,13 @@ + fGlyphStorage->reset(); + } + +-LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success) ++LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success) + { + // 3 -> kerning and ligatures +- return LayoutEngine::layoutEngineFactory(fontInstance, scriptCode, +- languageCode, LE_DEFAULT_FEATURE_FLAG, success); ++ return LayoutEngine::layoutEngineFactory(fontInstance, scriptCode, languageCode, LE_DEFAULT_FEATURE_FLAG, success); + } + +-LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, +- LEErrorCode &success) ++LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success) + { + static const le_uint32 gsubTableTag = LE_GSUB_TABLE_TAG; + static const le_uint32 mortTableTag = LE_MORT_TABLE_TAG; +@@ -553,18 +522,12 @@ + return NULL; + } + +- // code2000 has GPOS kern feature tags for latn script +- +- const GlyphSubstitutionTableHeader *gsubTable = +- (const GlyphSubstitutionTableHeader *) fontInstance->getFontTable(gsubTableTag); ++ const GlyphSubstitutionTableHeader *gsubTable = (const GlyphSubstitutionTableHeader *) fontInstance->getFontTable(gsubTableTag); + LayoutEngine *result = NULL; + LETag scriptTag = 0x00000000; + LETag languageTag = 0x00000000; + +- if (gsubTable != NULL && +- gsubTable->coversScript(scriptTag = +- OpenTypeLayoutEngine::getScriptTag(scriptCode))) { +- ++ if (gsubTable != NULL && gsubTable->coversScript(scriptTag = OpenTypeLayoutEngine::getScriptTag(scriptCode))) { + switch (scriptCode) { + case bengScriptCode: + case devaScriptCode: +@@ -576,13 +539,11 @@ + case tamlScriptCode: + case teluScriptCode: + case sinhScriptCode: +- result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, +- languageCode, typoFlags, gsubTable); ++ result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + case arabScriptCode: +- result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, +- languageCode, typoFlags, gsubTable); ++ result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + case haniScriptCode: +@@ -594,33 +555,33 @@ + case zhtLanguageCode: + case zhsLanguageCode: + if (gsubTable->coversScriptAndLanguage(scriptTag, languageTag, TRUE)) { +- result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, +- languageCode, typoFlags, gsubTable); ++ result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + } + + // note: falling through to default case. + default: +- result = new OpenTypeLayoutEngine(fontInstance, scriptCode, +- languageCode, typoFlags, gsubTable); ++ result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + } + + break; ++#if 0 ++ case tibtScriptCode: ++ result = new TibetanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); ++ break; ++#endif + + case khmrScriptCode: +- result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, +- languageCode, typoFlags, gsubTable); ++ result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + default: +- result = new OpenTypeLayoutEngine(fontInstance, scriptCode, +- languageCode, typoFlags, gsubTable); ++ result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + } + } else { +- const MorphTableHeader *morphTable = +- (MorphTableHeader *) fontInstance->getFontTable(mortTableTag); ++ const MorphTableHeader *morphTable = (MorphTableHeader *) fontInstance->getFontTable(mortTableTag); + + if (morphTable != NULL && SWAPL(morphTable->version)==0x00010000) { + result = new GXLayoutEngine(fontInstance, scriptCode, languageCode, morphTable); +@@ -637,16 +598,18 @@ + case teluScriptCode: + case sinhScriptCode: + { +- result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, +- languageCode, typoFlags); ++ result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + } + + case arabScriptCode: +- result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, +- languageCode, typoFlags); ++ //case hebrScriptCode: ++ result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + ++ //case hebrScriptCode: ++ // return new HebrewOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); ++ + case thaiScriptCode: + result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; +@@ -668,3 +631,5 @@ + LayoutEngine::~LayoutEngine() { + delete fGlyphStorage; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/LayoutEngine.h b/src/share/native/sun/font/layout/LayoutEngine.h +--- jdk/src/share/native/sun/font/layout/LayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/LayoutEngine.h +@@ -23,6 +23,7 @@ + * + */ + ++ + /* + * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved +@@ -34,63 +35,61 @@ + + #include "LETypes.h" + +-#include <string.h> ++/** ++ * \file ++ * \brief C++ API: Virtual base class for complex text layout. ++ */ ++ ++U_NAMESPACE_BEGIN + + class LEFontInstance; + class LEGlyphFilter; + class LEGlyphStorage; + + /** +- * This is a virtual base class used to do complex text layout. The +- * text must all be in a single font, script, and language. An +- * instance of a LayoutEngine can be created by calling the +- * layoutEngineFactory method. Fonts are identified by instances of +- * the LEFontInstance class. Script and language codes are identified ++ * This is a virtual base class used to do complex text layout. The text must all ++ * be in a single font, script, and language. An instance of a LayoutEngine can be ++ * created by calling the layoutEngineFactory method. Fonts are identified by ++ * instances of the LEFontInstance class. Script and language codes are identified + * by integer codes, which are defined in ScriptAndLanuageTags.h. + * +- * Note that this class is not public API. It is declared public so +- * that it can be exported from the library that it is a part of. ++ * Note that this class is not public API. It is declared public so that it can be ++ * exported from the library that it is a part of. + * +- * The input to the layout process is an array of characters in +- * logical order, and a starting X, Y position for the text. The +- * output is an array of glyph indices, an array of character indices +- * for the glyphs, and an array of glyph positions. These arrays are +- * protected members of LayoutEngine which can be retreived by a +- * public method. The reset method can be called to free these arrays +- * so that the LayoutEngine can be reused. ++ * The input to the layout process is an array of characters in logical order, ++ * and a starting X, Y position for the text. The output is an array of glyph indices, ++ * an array of character indices for the glyphs, and an array of glyph positions. ++ * These arrays are protected members of LayoutEngine which can be retreived by a ++ * public method. The reset method can be called to free these arrays so that the ++ * LayoutEngine can be reused. + * +- * The layout process is done in three steps. There is a protected +- * virtual method for each step. These methods have a default +- * implementation which only does character to glyph mapping and +- * default positioning using the glyph's advance widths. Subclasses +- * can override these methods for more advanced layout. There is a +- * public method which invokes the steps in the correct order. ++ * The layout process is done in three steps. There is a protected virtual method ++ * for each step. These methods have a default implementation which only does ++ * character to glyph mapping and default positioning using the glyph's advance ++ * widths. Subclasses can override these methods for more advanced layout. ++ * There is a public method which invokes the steps in the correct order. + * + * The steps are: + * +- * 1) Glyph processing - character to glyph mapping and any other +- * glyph processing such as ligature substitution and contextual +- * forms. ++ * 1) Glyph processing - character to glyph mapping and any other glyph processing ++ * such as ligature substitution and contextual forms. + * +- * 2) Glyph positioning - position the glyphs based on their advance +- * widths. ++ * 2) Glyph positioning - position the glyphs based on their advance widths. + * +- * 3) Glyph position adjustments - adjustment of glyph positions for +- * kerning, accent placement, etc. ++ * 3) Glyph position adjustments - adjustment of glyph positions for kerning, ++ * accent placement, etc. + * +- * NOTE: in all methods below, output parameters are references to +- * pointers so the method can allocate and free the storage as +- * needed. All storage allocated in this way is owned by the object +- * which created it, and will be freed when it is no longer needed, or +- * when the object's destructor is invoked. ++ * NOTE: in all methods below, output parameters are references to pointers so ++ * the method can allocate and free the storage as needed. All storage allocated ++ * in this way is owned by the object which created it, and will be freed when it ++ * is no longer needed, or when the object's destructor is invoked. + * + * @see LEFontInstance + * @see ScriptAndLanguageTags.h + * + * @stable ICU 2.8 + */ +-class U_LAYOUT_API LayoutEngine +-{ ++class U_LAYOUT_API LayoutEngine : public UObject { + protected: + /** + * The object which holds the glyph storage +@@ -134,21 +133,21 @@ + le_int32 fTypoFlags; + + /** +- * This constructs an instance for a given font, script and +- * language. Subclass constructors ++ * This constructs an instance for a given font, script and language. Subclass constructors + * must call this constructor. + * + * @param fontInstance - the font for the text + * @param scriptCode - the script for the text + * @param languageCode - the language for the text ++ * @param typoFlags - the typographic control flags for the text. Set bit 1 if kerning ++ * is desired, set bit 2 if ligature formation is desired. Others are reserved. + * + * @see LEFontInstance + * @see ScriptAndLanguageTags.h + * + * @internal + */ +- LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, +- le_int32 languageCode, le_int32 typoFlags); ++ LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags); + + /** + * This overrides the default no argument constructor to make it +@@ -160,11 +159,10 @@ + LayoutEngine(); + + /** +- * This method does any required pre-processing to the input +- * characters. It may generate output characters that differ from +- * the input charcters due to insertions, deletions, or +- * reorderings. In such cases, it will also generate an output +- * character index array reflecting these changes. ++ * This method does any required pre-processing to the input characters. It ++ * may generate output characters that differ from the input charcters due to ++ * insertions, deletions, or reorderings. In such cases, it will also generate an ++ * output character index array reflecting these changes. + * + * Subclasses must override this method. + * +@@ -173,44 +171,36 @@ + * @param offset - the index of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - TRUE if the characters are in a right to +- * left directional run +- * @param outChars - the output character array, if different from +- * the input +- * @param glyphStorage - the object that holds the per-glyph +- * storage. The character index array may be set. ++ * @param rightToLeft - TRUE if the characters are in a right to left directional run ++ * @param outChars - the output character array, if different from the input ++ * @param glyphStorage - the object that holds the per-glyph storage. The character index array may be set. + * @param success - set to an error code if the operation fails +- * @return the output character count (input character count if no +- * change) ++ * ++ * @return the output character count (input character count if no change) + * + * @internal + */ +- virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** +- * This method does the glyph processing. It converts an array of +- * characters into an array of glyph indices and character +- * indices. The characters to be processed are passed in a +- * surrounding context. The context is specified as a starting +- * address and a maximum character count. An offset and a count +- * are used to specify the characters to be processed. ++ * This method does the glyph processing. It converts an array of characters ++ * into an array of glyph indices and character indices. The characters to be ++ * processed are passed in a surrounding context. The context is specified as ++ * a starting address and a maximum character count. An offset and a count are ++ * used to specify the characters to be processed. + * +- * The default implementation of this method only does character +- * to glyph mapping. Subclasses needing more elaborate glyph +- * processing must override this method. ++ * The default implementation of this method only does character to glyph mapping. ++ * Subclasses needing more elaborate glyph processing must override this method. + * + * Input parameters: + * @param chars - the character context + * @param offset - the offset of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the context. +- * @param rightToLeft - TRUE if the text is in a right to left +- * directional run +- * @param glyphStorage - the object which holds the per-glyph +- * storage. The glyph and char indices arrays will be +- * set. ++ * @param rightToLeft - TRUE if the text is in a right to left directional run ++ * @param glyphStorage - the object which holds the per-glyph storage. The glyph and char indices arrays ++ * will be set. + * + * Output parameters: + * @param success - set to an error code if the operation fails +@@ -219,60 +209,50 @@ + * + * @internal + */ +- virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** +- * This method does basic glyph positioning. The default +- * implementation positions the glyphs based on their advance +- * widths. This is sufficient for most uses. It is not expected +- * that many subclasses will override this method. ++ * This method does basic glyph positioning. The default implementation positions ++ * the glyphs based on their advance widths. This is sufficient for most uses. It ++ * is not expected that many subclasses will override this method. + * + * Input parameters: +- * @param glyphStorage - the object which holds the per-glyph storage. +- * The glyph position array will be set. ++ * @param glyphStorage - the object which holds the per-glyph storage. The glyph position array will be set. + * @param x - the starting X position + * @param y - the starting Y position + * @param success - set to an error code if the operation fails + * + * @internal + */ +- virtual void positionGlyphs(LEGlyphStorage &glyphStorage, +- float x, float y, LEErrorCode &success); ++ virtual void positionGlyphs(LEGlyphStorage &glyphStorage, float x, float y, LEErrorCode &success); + + /** +- * This method does positioning adjustments like accent +- * positioning and kerning. The default implementation does +- * nothing. Subclasses needing position adjustments must override +- * this method. ++ * This method does positioning adjustments like accent positioning and ++ * kerning. The default implementation does nothing. Subclasses needing ++ * position adjustments must override this method. + * +- * Note that this method has both characters and glyphs as input +- * so that it can use the character codes to determine glyph types +- * if that information isn't directly available. (e.g. Some Arabic +- * OpenType fonts don't have a GDEF table) ++ * Note that this method has both characters and glyphs as input so that ++ * it can use the character codes to determine glyph types if that information ++ * isn't directly available. (e.g. Some Arabic OpenType fonts don't have a GDEF ++ * table) + * + * @param chars - the input character context + * @param offset - the offset of the first character to process + * @param count - the number of characters to process +- * @param reverse - <code>TRUE</code> if the glyphs in the glyph +- * array have been reordered +- * @param glyphStorage - the object which holds the per-glyph +- * storage. The glyph positions will be adjusted as needed. +- * @param success - output parameter set to an error code if the +- * operation fails ++ * @param reverse - <code>TRUE</code> if the glyphs in the glyph array have been reordered ++ * @param glyphStorage - the object which holds the per-glyph storage. The glyph positions will be ++ * adjusted as needed. ++ * @param success - output parameter set to an error code if the operation fails + * + * @internal + */ +- virtual void adjustGlyphPositions(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_bool reverse, +- LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** +- * This method gets a table from the font associated with the +- * text. The default implementation gets the table from the font +- * instance. Subclasses which need to get the tables some other +- * way must override this method. ++ * This method gets a table from the font associated with ++ * the text. The default implementation gets the table from ++ * the font instance. Subclasses which need to get the tables ++ * some other way must override this method. + * + * @param tableTag - the four byte table tag. + * +@@ -283,127 +263,106 @@ + virtual const void *getFontTable(LETag tableTag) const; + + /** +- * This method does character to glyph mapping. The default +- * implementation uses the font instance to do the mapping. It +- * will allocate the glyph and character index arrays if they're +- * not already allocated. If it allocates the character index +- * array, it will fill it it. ++ * This method does character to glyph mapping. The default implementation ++ * uses the font instance to do the mapping. It will allocate the glyph and ++ * character index arrays if they're not already allocated. If it allocates the ++ * character index array, it will fill it it. + * +- * This method supports right to left text with the ability to +- * store the glyphs in reverse order, and by supporting character +- * mirroring, which will replace a character which has a left and +- * right form, such as parens, with the opposite form before +- * mapping it to a glyph index. ++ * This method supports right to left ++ * text with the ability to store the glyphs in reverse order, and by supporting ++ * character mirroring, which will replace a character which has a left and right ++ * form, such as parens, with the opposite form before mapping it to a glyph index. + * + * Input parameters: + * @param chars - the input character context + * @param offset - the offset of the first character to be mapped + * @param count - the number of characters to be mapped +- * @param reverse - if <code>TRUE</code>, the output will be in +- * reverse order ++ * @param reverse - if <code>TRUE</code>, the output will be in reverse order + * @param mirror - if <code>TRUE</code>, do character mirroring +- * @param glyphStorage - the object which holds the per-glyph +- * storage. The glyph and char indices arrays will be +- * filled in. ++ * @param glyphStorage - the object which holds the per-glyph storage. The glyph and char ++ * indices arrays will be filled in. + * @param success - set to an error code if the operation fails + * + * @see LEFontInstance + * + * @internal + */ +- virtual void mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, le_bool mirror, +- LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual void mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, le_bool mirror, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** +- * This is a convenience method that forces the advance width of +- * mark glyphs to be zero, which is required for proper selection +- * and highlighting. ++ * This is a convenience method that forces the advance width of mark ++ * glyphs to be zero, which is required for proper selection and highlighting. + * +- * @param glyphStorage - the object containing the per-glyph +- * storage. The positions array will be modified. ++ * @param glyphStorage - the object containing the per-glyph storage. The positions array will be modified. + * @param markFilter - used to identify mark glyphs +- * @param success - output parameter set to an error code if the +- * operation fails ++ * @param success - output parameter set to an error code if the operation fails + * + * @see LEGlyphFilter + * + * @internal + */ +- static void adjustMarkGlyphs(LEGlyphStorage &glyphStorage, +- LEGlyphFilter *markFilter, LEErrorCode &success); ++ static void adjustMarkGlyphs(LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success); + + + /** +- * This is a convenience method that forces the advance width of +- * mark glyphs to be zero, which is required for proper selection +- * and highlighting. This method uses the input characters to +- * identify marks. This is required in cases where the font does +- * not contain enough information to identify them based on the +- * glyph IDs. ++ * This is a convenience method that forces the advance width of mark ++ * glyphs to be zero, which is required for proper selection and highlighting. ++ * This method uses the input characters to identify marks. This is required in ++ * cases where the font does not contain enough information to identify them based ++ * on the glyph IDs. + * + * @param chars - the array of input characters + * @param charCount - the number of input characers +- * @param glyphStorage - the object containing the per-glyph +- * storage. The positions array will be modified. +- * @param reverse - <code>TRUE</code> if the glyph array has been +- * reordered ++ * @param glyphStorage - the object containing the per-glyph storage. The positions array will be modified. ++ * @param reverse - <code>TRUE</code> if the glyph array has been reordered + * @param markFilter - used to identify mark glyphs +- * @param success - output parameter set to an error code if the +- * operation fails ++ * @param success - output parameter set to an error code if the operation fails + * + * @see LEGlyphFilter + * + * @internal + */ +- static void adjustMarkGlyphs(const LEUnicode chars[], +- le_int32 charCount, le_bool reverse, +- LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, +- LEErrorCode &success); ++ static void adjustMarkGlyphs(const LEUnicode chars[], le_int32 charCount, le_bool reverse, LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success); ++ + + public: + /** + * The destructor. It will free any storage allocated for the + * glyph, character index and position arrays by calling the reset +- * method. It is declared virtual so that it will be invoked by +- * the subclass destructors. ++ * method. It is declared virtual so that it will be invoked by the ++ * subclass destructors. + * + * @stable ICU 2.8 + */ + virtual ~LayoutEngine(); + + /** +- * This method will invoke the layout steps in their correct order +- * by calling the 32 bit versions of the computeGlyphs and +- * positionGlyphs methods.(It doesn't * call the +- * adjustGlyphPositions method because that doesn't apply for +- * default * processing.) It will compute the glyph, character +- * index and position arrays. ++ * This method will invoke the layout steps in their correct order by calling ++ * the computeGlyphs, positionGlyphs and adjustGlyphPosition methods.. It will ++ * compute the glyph, character index and position arrays. + * + * @param chars - the input character context + * @param offset - the offset of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - true if the characers are in a right to +- * left directional run ++ * @param rightToLeft - TRUE if the characers are in a right to left directional run + * @param x - the initial X position + * @param y - the initial Y position +- * @param success - output parameter set to an error code if the +- * operation fails ++ * @param success - output parameter set to an error code if the operation fails ++ * + * @return the number of glyphs in the glyph array + * +- * Note: the glyph, character index and position array can be +- * accessed using the getter method below. ++ * Note; the glyph, character index and position array can be accessed ++ * using the getter method below. ++ * ++ * @stable ICU 2.8 + */ +- le_int32 layoutChars(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, float x, +- float y, LEErrorCode &success); ++ virtual le_int32 layoutChars(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, float x, float y, LEErrorCode &success); + + /** +- * This method returns the number of glyphs in the glyph +- * array. Note that the number of glyphs will be greater than or +- * equal to the number of characters used to create the +- * LayoutEngine. ++ * This method returns the number of glyphs in the glyph array. Note ++ * that the number of glyphs will be greater than or equal to the number ++ * of characters used to create the LayoutEngine. + * + * @return the number of glyphs in the glyph array + * +@@ -412,9 +371,9 @@ + le_int32 getGlyphCount() const; + + /** +- * This method copies the glyph array into a caller supplied +- * array. The caller must ensure that the array is large enough +- * to hold all the glyphs. ++ * This method copies the glyph array into a caller supplied array. ++ * The caller must ensure that the array is large enough to hold all ++ * the glyphs. + * + * @param glyphs - the destiniation glyph array + * @param success - set to an error code if the operation fails +@@ -424,10 +383,10 @@ + void getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const; + + /** +- * This method copies the glyph array into a caller supplied +- * array, ORing in extra bits. (This functionality is needed by +- * the JDK, which uses 32 bits pre glyph idex, with the high 16 +- * bits encoding the composite font slot number) ++ * This method copies the glyph array into a caller supplied array, ++ * ORing in extra bits. (This functionality is needed by the JDK, ++ * which uses 32 bits pre glyph idex, with the high 16 bits encoding ++ * the composite font slot number) + * + * @param glyphs - the destination (32 bit) glyph array + * @param extraBits - this value will be ORed with each glyph index +@@ -435,13 +394,12 @@ + * + * @stable ICU 2.8 + */ +- virtual void getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, +- LEErrorCode &success) const; ++ virtual void getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const; + + /** +- * This method copies the character index array into a caller +- * supplied array. The caller must ensure that the array is large +- * enough to hold a character index for each glyph. ++ * This method copies the character index array into a caller supplied array. ++ * The caller must ensure that the array is large enough to hold a ++ * character index for each glyph. + * + * @param charIndices - the destiniation character index array + * @param success - set to an error code if the operation fails +@@ -451,9 +409,9 @@ + void getCharIndices(le_int32 charIndices[], LEErrorCode &success) const; + + /** +- * This method copies the character index array into a caller +- * supplied array. The caller must ensure that the array is large +- * enough to hold a character index for each glyph. ++ * This method copies the character index array into a caller supplied array. ++ * The caller must ensure that the array is large enough to hold a ++ * character index for each glyph. + * + * @param charIndices - the destiniation character index array + * @param indexBase - an offset which will be added to each index +@@ -461,14 +419,13 @@ + * + * @stable ICU 2.8 + */ +- void getCharIndices(le_int32 charIndices[], le_int32 indexBase, +- LEErrorCode &success) const; ++ void getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const; + + /** +- * This method copies the position array into a caller supplied +- * array. The caller must ensure that the array is large enough +- * to hold an X and Y position for each glyph, plus an extra X and +- * Y for the advance of the last glyph. ++ * This method copies the position array into a caller supplied array. ++ * The caller must ensure that the array is large enough to hold an ++ * X and Y position for each glyph, plus an extra X and Y for the ++ * advance of the last glyph. + * + * @param positions - the destiniation position array + * @param success - set to an error code if the operation fails +@@ -491,8 +448,7 @@ + * + * @stable ICU 2.8 + */ +- void getGlyphPosition(le_int32 glyphIndex, float &x, float &y, +- LEErrorCode &success) const; ++ void getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const; + + /** + * This method frees the glyph, character index and position arrays +@@ -511,8 +467,7 @@ + * @param fontInstance - the font of the text + * @param scriptCode - the script of the text + * @param languageCode - the language of the text +- * @param success - output parameter set to an error code if the +- * operation fails ++ * @param success - output parameter set to an error code if the operation fails + * + * @return a LayoutEngine which can layout text in the given font. + * +@@ -520,17 +475,30 @@ + * + * @stable ICU 2.8 + */ +- static LayoutEngine *layoutEngineFactory(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success); ++ static LayoutEngine *layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success); + + /** + * Override of existing call that provides flags to control typography. + * @draft ICU 3.4 + */ +- static LayoutEngine *layoutEngineFactory( +- const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, +- le_int32 typo_flags, LEErrorCode &success); ++ static LayoutEngine *layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typo_flags, LEErrorCode &success); ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/LayoutTables.h b/src/share/native/sun/font/layout/LayoutTables.h +--- jdk/src/share/native/sun/font/layout/LayoutTables.h ++++ jdk/src/share/native/sun/font/layout/LayoutTables.h +@@ -32,11 +32,20 @@ + #ifndef __LAYOUTTABLES_H + #define __LAYOUTTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + ++U_NAMESPACE_BEGIN ++ + #define ANY_NUMBER 1 + + typedef le_int16 ByteOffset; + typedef le_int16 WordOffset; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/LigatureSubstProc.cpp b/src/share/native/sun/font/layout/LigatureSubstProc.cpp +--- jdk/src/share/native/sun/font/layout/LigatureSubstProc.cpp ++++ jdk/src/share/native/sun/font/layout/LigatureSubstProc.cpp +@@ -39,10 +39,14 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + #define ExtendedComplement(m) ((le_int32) (~((le_uint32) (m)))) + #define SignBit(m) ((ExtendedComplement(m) >> 1) & (le_int32)(m)) + #define SignExtend(v,m) (((v) & SignBit(m))? ((v) | ExtendedComplement(m)): (v)) + ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LigatureSubstitutionProcessor) ++ + LigatureSubstitutionProcessor::LigatureSubstitutionProcessor(const MorphSubtableHeader *morphSubtableHeader) + : StateTableProcessor(morphSubtableHeader) + { +@@ -63,8 +67,7 @@ + m = -1; + } + +-ByteOffset LigatureSubstitutionProcessor::processStateEntry(LEGlyphStorage &glyphStorage, +- le_int32 &currGlyph, EntryTableIndex index) ++ByteOffset LigatureSubstitutionProcessor::processStateEntry(LEGlyphStorage &glyphStorage, le_int32 &currGlyph, EntryTableIndex index) + { + const LigatureSubstitutionStateEntry *entry = &entryTable[index]; + ByteOffset newState = SWAPW(entry->newStateOffset); +@@ -162,3 +165,5 @@ + void LigatureSubstitutionProcessor::endStateTable() + { + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/LigatureSubstProc.h b/src/share/native/sun/font/layout/LigatureSubstProc.h +--- jdk/src/share/native/sun/font/layout/LigatureSubstProc.h ++++ jdk/src/share/native/sun/font/layout/LigatureSubstProc.h +@@ -32,12 +32,19 @@ + #ifndef __LIGATURESUBSTITUTIONPROCESSOR_H + #define __LIGATURESUBSTITUTIONPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "StateTableProcessor.h" + #include "LigatureSubstitution.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + #define nComponents 16 +@@ -54,6 +61,20 @@ + LigatureSubstitutionProcessor(const MorphSubtableHeader *morphSubtableHeader); + virtual ~LigatureSubstitutionProcessor(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + LigatureSubstitutionProcessor(); + +@@ -68,6 +89,8 @@ + le_int16 m; + + const LigatureSubstitutionHeader *ligatureSubstitutionHeader; ++ + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp b/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp +--- jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved + * + */ +@@ -37,6 +38,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_uint32 LigatureSubstitutionSubtable::process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter) const + { + LEGlyphID glyph = glyphIterator->getCurrGlyphID(); +@@ -92,3 +95,5 @@ + + return 0; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/LigatureSubstSubtables.h b/src/share/native/sun/font/layout/LigatureSubstSubtables.h +--- jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.h ++++ jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.h +@@ -32,12 +32,19 @@ + #ifndef __LIGATURESUBSTITUTIONSUBTABLES_H + #define __LIGATURESUBSTITUTIONSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEGlyphFilter.h" + #include "OpenTypeTables.h" + #include "GlyphSubstitutionTables.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct LigatureSetTable + { + le_uint16 ligatureCount; +@@ -59,4 +66,5 @@ + le_uint32 process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter = NULL) const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LigatureSubstitution.h b/src/share/native/sun/font/layout/LigatureSubstitution.h +--- jdk/src/share/native/sun/font/layout/LigatureSubstitution.h ++++ jdk/src/share/native/sun/font/layout/LigatureSubstitution.h +@@ -32,12 +32,19 @@ + #ifndef __LIGATURESUBSTITUTION_H + #define __LIGATURESUBSTITUTION_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + #include "StateTables.h" + #include "MorphTables.h" + #include "MorphStateTables.h" + ++U_NAMESPACE_BEGIN ++ + struct LigatureSubstitutionHeader : MorphStateTableHeader + { + ByteOffset ligatureActionTableOffset; +@@ -65,4 +72,5 @@ + lafComponentOffsetMask = 0x3FFFFFFF + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LookupProcessor.cpp b/src/share/native/sun/font/layout/LookupProcessor.cpp +--- jdk/src/share/native/sun/font/layout/LookupProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/LookupProcessor.cpp +@@ -42,6 +42,8 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_uint32 LookupProcessor::applyLookupTable(const LookupTable *lookupTable, GlyphIterator *glyphIterator, + const LEFontInstance *fontInstance) const + { +@@ -65,10 +67,9 @@ + return 1; + } + +-le_int32 LookupProcessor::process(LEGlyphStorage &glyphStorage, +- GlyphPositionAdjustments *glyphPositionAdjustments, +- le_bool rightToLeft, const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, +- const LEFontInstance *fontInstance) const ++le_int32 LookupProcessor::process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, ++ le_bool rightToLeft, const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, ++ const LEFontInstance *fontInstance) const + { + le_int32 glyphCount = glyphStorage.getGlyphCount(); + +@@ -140,8 +141,7 @@ + + LookupProcessor::LookupProcessor(const char *baseAddress, + Offset scriptListOffset, Offset featureListOffset, Offset lookupListOffset, +- LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, +- le_int32 featureMapCount, le_bool orderFeatures) ++ LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool orderFeatures) + : lookupListTable(NULL), featureListTable(NULL), lookupSelectArray(NULL), lookupSelectCount(0), + lookupOrderArray(NULL), lookupOrderCount(0) + { +@@ -309,3 +309,5 @@ + LE_DELETE_ARRAY(lookupOrderArray); + LE_DELETE_ARRAY(lookupSelectArray); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/LookupProcessor.h b/src/share/native/sun/font/layout/LookupProcessor.h +--- jdk/src/share/native/sun/font/layout/LookupProcessor.h ++++ jdk/src/share/native/sun/font/layout/LookupProcessor.h +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -32,9 +33,18 @@ + #ifndef __LOOKUPPROCESSOR_H + #define __LOOKUPPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" ++//#include "Lookups.h" ++//#include "Features.h" ++ ++U_NAMESPACE_BEGIN + + class LEFontInstance; + class LEGlyphStorage; +@@ -46,13 +56,10 @@ + struct LookupSubtable; + struct LookupTable; + +-class LookupProcessor +-{ ++class LookupProcessor : public UMemory { + public: +- le_int32 process(LEGlyphStorage &glyphStorage, +- GlyphPositionAdjustments *glyphPositionAdjustments, +- le_bool rightToLeft, const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, +- const LEFontInstance *fontInstance) const; ++ le_int32 process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, ++ le_bool rightToLeft, const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, const LEFontInstance *fontInstance) const; + + le_uint32 applyLookupTable(const LookupTable *lookupTable, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; + +@@ -64,19 +71,18 @@ + virtual ~LookupProcessor(); + + protected: +- LookupProcessor(const char *baseAddress, ++ LookupProcessor(const char *baseAddress, + Offset scriptListOffset, Offset featureListOffset, Offset lookupListOffset, +- LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, +- le_int32 featureMapCount, le_bool orderFeatures); ++ LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool orderFeatures); + +- LookupProcessor(); ++ LookupProcessor(); + + le_int32 selectLookups(const FeatureTable *featureTable, FeatureMask featureMask, le_int32 order); + + const LookupListTable *lookupListTable; + const FeatureListTable *featureListTable; + +- FeatureMask *lookupSelectArray; ++ FeatureMask *lookupSelectArray; + le_uint32 lookupSelectCount; + + le_uint16 *lookupOrderArray; +@@ -88,4 +94,5 @@ + LookupProcessor &operator=(const LookupProcessor &other); // forbid copying of this class + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/LookupTables.cpp b/src/share/native/sun/font/layout/LookupTables.cpp +--- jdk/src/share/native/sun/font/layout/LookupTables.cpp ++++ jdk/src/share/native/sun/font/layout/LookupTables.cpp +@@ -34,6 +34,8 @@ + #include "LookupTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + /* + These are the rolled-up versions of the uniform binary search. + Someday, if we need more performance, we can un-roll them. +@@ -104,3 +106,5 @@ + + return NULL; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/LookupTables.h b/src/share/native/sun/font/layout/LookupTables.h +--- jdk/src/share/native/sun/font/layout/LookupTables.h ++++ jdk/src/share/native/sun/font/layout/LookupTables.h +@@ -32,9 +32,16 @@ + #ifndef __LOOKUPTABLES_H + #define __LOOKUPTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + ++U_NAMESPACE_BEGIN ++ + enum LookupTableFormat + { + ltfSimpleArray = 0, +@@ -104,4 +111,5 @@ + LookupValue valueArray[ANY_NUMBER]; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/Lookups.cpp b/src/share/native/sun/font/layout/Lookups.cpp +--- jdk/src/share/native/sun/font/layout/Lookups.cpp ++++ jdk/src/share/native/sun/font/layout/Lookups.cpp +@@ -35,6 +35,8 @@ + #include "CoverageTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + const LookupTable *LookupListTable::getLookupTable(le_uint16 lookupTableIndex) const + { + if (lookupTableIndex >= SWAPW(lookupCount)) { +@@ -63,3 +65,5 @@ + + return coverageTable->getGlyphCoverage(glyphID); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/Lookups.h b/src/share/native/sun/font/layout/Lookups.h +--- jdk/src/share/native/sun/font/layout/Lookups.h ++++ jdk/src/share/native/sun/font/layout/Lookups.h +@@ -32,9 +32,16 @@ + #ifndef __LOOKUPS_H + #define __LOOKUPS_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + enum LookupFlags + { + lfBaselineIsLogicalEnd = 0x0001, // The MS spec. calls this flag "RightToLeft" but this name is more accurate +@@ -79,6 +86,5 @@ + return getGlyphCoverage(coverageTableOffset, glyphID); + } + +- +- ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/MPreFixups.cpp b/src/share/native/sun/font/layout/MPreFixups.cpp +--- jdk/src/share/native/sun/font/layout/MPreFixups.cpp ++++ jdk/src/share/native/sun/font/layout/MPreFixups.cpp +@@ -33,6 +33,8 @@ + #include "LEGlyphStorage.h" + #include "MPreFixups.h" + ++U_NAMESPACE_BEGIN ++ + struct FixupData + { + le_int32 fBaseIndex; +@@ -92,7 +94,7 @@ + + for (i = 0; i < mpreCount; i += 1) { + mpreSave[i] = glyphStorage[mpreIndex + i]; +- indexSave[i] = glyphStorage.getCharIndex(mpreIndex + i, success); ++ indexSave[i] = glyphStorage.getCharIndex(mpreIndex + i, success); //charIndices[mpreIndex + i]; + } + + for (i = 0; i < moveCount; i += 1) { +@@ -112,3 +114,5 @@ + LE_DELETE_ARRAY(mpreSave); + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/MPreFixups.h b/src/share/native/sun/font/layout/MPreFixups.h +--- jdk/src/share/native/sun/font/layout/MPreFixups.h ++++ jdk/src/share/native/sun/font/layout/MPreFixups.h +@@ -32,14 +32,22 @@ + #ifndef __MPREFIXUPS_H + #define __MPREFIXUPS_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + // Might want to make this a private member... + struct FixupData; + +-class MPreFixups { ++class MPreFixups : public UMemory ++{ + public: + MPreFixups(le_int32 charCount); + ~MPreFixups(); +@@ -53,4 +61,7 @@ + le_int32 fFixupCount; + }; + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/MarkArrays.cpp b/src/share/native/sun/font/layout/MarkArrays.cpp +--- jdk/src/share/native/sun/font/layout/MarkArrays.cpp ++++ jdk/src/share/native/sun/font/layout/MarkArrays.cpp +@@ -36,6 +36,8 @@ + #include "MarkArrays.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_int32 MarkArray::getMarkClass(LEGlyphID glyphID, le_int32 coverageIndex, const LEFontInstance *fontInstance, + LEPoint &anchor) const + { +@@ -58,3 +60,5 @@ + + return markClass; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/MarkArrays.h b/src/share/native/sun/font/layout/MarkArrays.h +--- jdk/src/share/native/sun/font/layout/MarkArrays.h ++++ jdk/src/share/native/sun/font/layout/MarkArrays.h +@@ -32,10 +32,17 @@ + #ifndef __MARKARRAYS_H + #define __MARKARRAYS_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + struct MarkRecord + { + le_uint16 markClass; +@@ -51,4 +58,7 @@ + LEPoint &anchor) const; + }; + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp b/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp +--- jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp +@@ -40,6 +40,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + LEGlyphID MarkToBasePositioningSubtable::findBaseGlyph(GlyphIterator *glyphIterator) const + { + if (glyphIterator->prev()) { +@@ -106,7 +108,6 @@ + glyphIterator->setCurrGlyphBaseOffset(baseIterator.getCurrStreamPosition()); + + if (glyphIterator->isRightToLeft()) { +- // dlf flip advance to local coordinate system + glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX, anchorDiffY, -markAdvance.fX, -markAdvance.fY); + } else { + LEPoint baseAdvance; +@@ -114,9 +115,10 @@ + fontInstance->getGlyphAdvance(baseGlyph, pixels); + fontInstance->pixelsToUnits(pixels, baseAdvance); + +- // flip advances to local coordinate system + glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - baseAdvance.fX, anchorDiffY - baseAdvance.fY, -markAdvance.fX, -markAdvance.fY); + } + + return 1; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/MarkToBasePosnSubtables.h b/src/share/native/sun/font/layout/MarkToBasePosnSubtables.h +--- jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.h ++++ jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.h +@@ -32,6 +32,11 @@ + #ifndef __MARKTOBASEPOSITIONINGSUBTABLES_H + #define __MARKTOBASEPOSITIONINGSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +@@ -39,6 +44,8 @@ + #include "AttachmentPosnSubtables.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct MarkToBasePositioningSubtable : AttachmentPositioningSubtable + { + le_int32 process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; +@@ -56,4 +63,6 @@ + BaseRecord baseRecordArray[ANY_NUMBER]; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/MarkToLigaturePosnSubtables.cpp b/src/share/native/sun/font/layout/MarkToLigaturePosnSubtables.cpp +--- jdk/src/share/native/sun/font/layout/MarkToLigaturePosnSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/MarkToLigaturePosnSubtables.cpp +@@ -39,6 +39,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + LEGlyphID MarkToLigaturePositioningSubtable::findLigatureGlyph(GlyphIterator *glyphIterator) const + { + if (glyphIterator->prev()) { +@@ -117,9 +119,10 @@ + fontInstance->getGlyphAdvance(ligatureGlyph, pixels); + fontInstance->pixelsToUnits(pixels, ligatureAdvance); + +- glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - ligatureAdvance.fX, +- anchorDiffY - ligatureAdvance.fY, -markAdvance.fX, -markAdvance.fY); ++ glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - ligatureAdvance.fX, anchorDiffY - ligatureAdvance.fY, -markAdvance.fX, -markAdvance.fY); + } + + return 1; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/MarkToLigaturePosnSubtables.h b/src/share/native/sun/font/layout/MarkToLigaturePosnSubtables.h +--- jdk/src/share/native/sun/font/layout/MarkToLigaturePosnSubtables.h ++++ jdk/src/share/native/sun/font/layout/MarkToLigaturePosnSubtables.h +@@ -32,6 +32,11 @@ + #ifndef __MARKTOLIGATUREPOSITIONINGSUBTABLES_H + #define __MARKTOLIGATUREPOSITIONINGSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +@@ -39,6 +44,8 @@ + #include "AttachmentPosnSubtables.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct MarkToLigaturePositioningSubtable : AttachmentPositioningSubtable + { + le_int32 process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; +@@ -62,4 +69,6 @@ + Offset ligatureAttachTableOffsetArray[ANY_NUMBER]; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/MarkToMarkPosnSubtables.cpp b/src/share/native/sun/font/layout/MarkToMarkPosnSubtables.cpp +--- jdk/src/share/native/sun/font/layout/MarkToMarkPosnSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/MarkToMarkPosnSubtables.cpp +@@ -40,6 +40,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + LEGlyphID MarkToMarkPositioningSubtable::findMark2Glyph(GlyphIterator *glyphIterator) const + { + if (glyphIterator->findMark2Glyph()) { +@@ -88,7 +90,7 @@ + const AnchorTable *anchorTable = (const AnchorTable *) ((char *) mark2Array + anchorTableOffset); + LEPoint mark2Anchor, markAdvance, pixels; + +- if (anchorTableOffset == 0) { // jb4729 ++ if (anchorTableOffset == 0) { + // this seems to mean that the marks don't attach... + return 0; + } +@@ -111,9 +113,10 @@ + fontInstance->getGlyphAdvance(mark2Glyph, pixels); + fontInstance->pixelsToUnits(pixels, mark2Advance); + +- glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - mark2Advance.fX, +- anchorDiffY - mark2Advance.fY, -markAdvance.fX, -markAdvance.fY); ++ glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - mark2Advance.fX, anchorDiffY - mark2Advance.fY, -markAdvance.fX, -markAdvance.fY); + } + + return 1; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/MarkToMarkPosnSubtables.h b/src/share/native/sun/font/layout/MarkToMarkPosnSubtables.h +--- jdk/src/share/native/sun/font/layout/MarkToMarkPosnSubtables.h ++++ jdk/src/share/native/sun/font/layout/MarkToMarkPosnSubtables.h +@@ -32,6 +32,11 @@ + #ifndef __MARKTOMARKPOSITIONINGSUBTABLES_H + #define __MARKTOMARKPOSITIONINGSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +@@ -39,6 +44,8 @@ + #include "AttachmentPosnSubtables.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct MarkToMarkPositioningSubtable : AttachmentPositioningSubtable + { + le_int32 process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; +@@ -56,4 +63,6 @@ + Mark2Record mark2RecordArray[ANY_NUMBER]; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/MirroredCharData.cpp b/src/share/native/sun/font/layout/MirroredCharData.cpp +--- jdk/src/share/native/sun/font/layout/MirroredCharData.cpp ++++ jdk/src/share/native/sun/font/layout/MirroredCharData.cpp +@@ -36,6 +36,8 @@ + #include "LETypes.h" + #include "DefaultCharMapper.h" + ++U_NAMESPACE_BEGIN ++ + const LEUnicode32 DefaultCharMapper::mirroredChars[] = { + 0x0028, 0x0029, 0x003C, 0x003E, 0x005B, 0x005D, 0x007B, 0x007D, + 0x00AB, 0x00BB, 0x2039, 0x203A, 0x2045, 0x2046, 0x207D, 0x207E, +@@ -127,3 +129,5 @@ + }; + + const le_int32 DefaultCharMapper::mirroredCharsCount = 332; ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/MorphStateTables.h b/src/share/native/sun/font/layout/MorphStateTables.h +--- jdk/src/share/native/sun/font/layout/MorphStateTables.h ++++ jdk/src/share/native/sun/font/layout/MorphStateTables.h +@@ -32,14 +32,22 @@ + #ifndef __MORPHSTATETABLES_H + #define __MORPHSTATETABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + #include "MorphTables.h" + #include "StateTables.h" + ++U_NAMESPACE_BEGIN ++ + struct MorphStateTableHeader : MorphSubtableHeader + { + StateTableHeader stHeader; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/MorphTables.cpp b/src/share/native/sun/font/layout/MorphTables.cpp +--- jdk/src/share/native/sun/font/layout/MorphTables.cpp ++++ jdk/src/share/native/sun/font/layout/MorphTables.cpp +@@ -42,6 +42,8 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + void MorphTableHeader::process(LEGlyphStorage &glyphStorage) const + { + const ChainHeader *chainHeader = chains; +@@ -114,3 +116,5 @@ + delete processor; + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/MorphTables.h b/src/share/native/sun/font/layout/MorphTables.h +--- jdk/src/share/native/sun/font/layout/MorphTables.h ++++ jdk/src/share/native/sun/font/layout/MorphTables.h +@@ -32,9 +32,16 @@ + #ifndef __MORPHTABLES_H + #define __MORPHTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + typedef le_uint32 FeatureFlags; +@@ -98,4 +105,6 @@ + void process(LEGlyphStorage &glyphStorage) const; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp b/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp +--- jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp +@@ -37,6 +37,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_uint32 MultipleSubstitutionSubtable::process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter) const + { + LEGlyphID glyph = glyphIterator->getCurrGlyphID(); +@@ -106,3 +108,5 @@ + + return 0; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/MultipleSubstSubtables.h b/src/share/native/sun/font/layout/MultipleSubstSubtables.h +--- jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.h ++++ jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.h +@@ -32,12 +32,19 @@ + #ifndef __MULTIPLESUBSTITUTIONSUBTABLES_H + #define __MULTIPLESUBSTITUTIONSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEGlyphFilter.h" + #include "OpenTypeTables.h" + #include "GlyphSubstitutionTables.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct SequenceTable + { + le_uint16 glyphCount; +@@ -52,4 +59,5 @@ + le_uint32 process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter = NULL) const; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/NonContextualGlyphSubst.h b/src/share/native/sun/font/layout/NonContextualGlyphSubst.h +--- jdk/src/share/native/sun/font/layout/NonContextualGlyphSubst.h ++++ jdk/src/share/native/sun/font/layout/NonContextualGlyphSubst.h +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved + * + */ +@@ -32,14 +33,23 @@ + #ifndef __NONCONTEXTUALGLYPHSUBSTITUTION_H + #define __NONCONTEXTUALGLYPHSUBSTITUTION_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + #include "LookupTables.h" + #include "MorphTables.h" + ++U_NAMESPACE_BEGIN ++ + struct NonContextualGlyphSubstitutionHeader : MorphSubtableHeader + { + LookupTable table; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/NonContextualGlyphSubstProc.cpp b/src/share/native/sun/font/layout/NonContextualGlyphSubstProc.cpp +--- jdk/src/share/native/sun/font/layout/NonContextualGlyphSubstProc.cpp ++++ jdk/src/share/native/sun/font/layout/NonContextualGlyphSubstProc.cpp +@@ -41,6 +41,8 @@ + #include "TrimmedArrayProcessor.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + NonContextualGlyphSubstitutionProcessor::NonContextualGlyphSubstitutionProcessor() + { + } +@@ -79,3 +81,5 @@ + return NULL; + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/NonContextualGlyphSubstProc.h b/src/share/native/sun/font/layout/NonContextualGlyphSubstProc.h +--- jdk/src/share/native/sun/font/layout/NonContextualGlyphSubstProc.h ++++ jdk/src/share/native/sun/font/layout/NonContextualGlyphSubstProc.h +@@ -32,11 +32,18 @@ + #ifndef __NONCONTEXTUALGLYPHSUBSTITUTIONPROCESSOR_H + #define __NONCONTEXTUALGLYPHSUBSTITUTIONPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "NonContextualGlyphSubst.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class NonContextualGlyphSubstitutionProcessor : public SubtableProcessor +@@ -57,4 +64,5 @@ + NonContextualGlyphSubstitutionProcessor &operator=(const NonContextualGlyphSubstitutionProcessor &other); // forbid copying of this class + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp b/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp +@@ -47,6 +47,10 @@ + + #include "GDEFMarkFilter.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OpenTypeLayoutEngine) ++ + #define ccmpFeatureTag LE_CCMP_FEATURE_TAG + #define ligaFeatureTag LE_LIGA_FEATURE_TAG + #define cligFeatureTag LE_CLIG_FEATURE_TAG +@@ -78,7 +82,7 @@ + {ccmpFeatureTag, ccmpFeatureMask}, + {ligaFeatureTag, ligaFeatureMask}, + {cligFeatureTag, cligFeatureMask}, +- {kernFeatureTag, kernFeatureMask}, ++ {kernFeatureTag, kernFeatureMask}, + {paltFeatureTag, paltFeatureMask}, + {markFeatureTag, markFeatureMask}, + {mkmkFeatureTag, mkmkFeatureMask} +@@ -86,19 +90,15 @@ + + static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap); + +-OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, +- const GlyphSubstitutionTableHeader *gsubTable) +- : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), +- fFeatureMask(minimalFeatures), fFeatureMap(featureMap), +- fFeatureMapCount(featureMapCount), fFeatureOrder(FALSE), +- fGSUBTable(gsubTable), fGDEFTable(NULL), fGPOSTable(NULL), +- fSubstitutionFilter(NULL) ++OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) ++ : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), fFeatureMask(minimalFeatures), ++ fFeatureMap(featureMap), fFeatureMapCount(featureMapCount), fFeatureOrder(FALSE), ++ fGSUBTable(gsubTable), fGDEFTable(NULL), fGPOSTable(NULL), fSubstitutionFilter(NULL) + { + static const le_uint32 gdefTableTag = LE_GDEF_TABLE_TAG; + static const le_uint32 gposTableTag = LE_GPOS_TABLE_TAG; +- const GlyphPositioningTableHeader *gposTable = +- (const GlyphPositioningTableHeader *) getFontTable(gposTableTag); ++ const GlyphPositioningTableHeader *gposTable = (const GlyphPositioningTableHeader *) getFontTable(gposTableTag); + + applyTypoFlags(); + +@@ -128,11 +128,10 @@ + LayoutEngine::reset(); + } + +-OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) +- : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), +- fFeatureOrder(FALSE), fGSUBTable(NULL), fGDEFTable(NULL), +- fGPOSTable(NULL), fSubstitutionFilter(NULL) ++OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags) ++ : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), fFeatureOrder(FALSE), ++ fGSUBTable(NULL), fGDEFTable(NULL), fGPOSTable(NULL), fSubstitutionFilter(NULL) + { + applyTypoFlags(); + setScriptAndLanguageTags(); +@@ -171,9 +170,8 @@ + fLangSysTag = getLangSysTag(fLanguageCode); + } + +-le_int32 OpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], +- le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, +- LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 OpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -184,8 +182,7 @@ + return 0; + } + +- le_int32 outCharCount = LayoutEngine::characterProcessing(chars, offset, count, +- max, rightToLeft, outChars, glyphStorage, success); ++ le_int32 outCharCount = LayoutEngine::characterProcessing(chars, offset, count, max, rightToLeft, outChars, glyphStorage, success); + + if (LE_FAILURE(success)) { + return 0; +@@ -203,16 +200,14 @@ + + // Input: characters, tags + // Output: glyphs, char indices +-le_int32 OpenTypeLayoutEngine::glyphProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 OpenTypeLayoutEngine::glyphProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; + } + +- if (chars == NULL || offset < 0 || count < 0 || max < 0 || +- offset >= max || offset + count > max) { ++ if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } +@@ -224,16 +219,14 @@ + } + + if (fGSUBTable != NULL) { +- count = fGSUBTable->process(glyphStorage, rightToLeft, +- fScriptTag, fLangSysTag, fGDEFTable, fSubstitutionFilter, +- fFeatureMap, fFeatureMapCount, fFeatureOrder); ++ count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTag, fLangSysTag, fGDEFTable, fSubstitutionFilter, ++ fFeatureMap, fFeatureMapCount, fFeatureOrder); + } + + return count; + } + +-le_int32 OpenTypeLayoutEngine::glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 OpenTypeLayoutEngine::glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; +@@ -247,9 +240,7 @@ + return glyphStorage.getGlyphCount(); + } + +-le_int32 OpenTypeLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, +- LEErrorCode &success) ++le_int32 OpenTypeLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + LEUnicode *outChars = NULL; + LEGlyphStorage fakeGlyphStorage; +@@ -259,25 +250,19 @@ + return 0; + } + +- if (chars == NULL || offset < 0 || count < 0 || max < 0 || +- offset >= max || offset + count > max) { ++ if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + +- outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, +- outChars, fakeGlyphStorage, success); ++ outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, outChars, fakeGlyphStorage, success); + + if (outChars != NULL) { +- fakeGlyphCount = glyphProcessing(outChars, 0, outCharCount, outCharCount, +- rightToLeft, fakeGlyphStorage, success); +- // FIXME: a subclass may have allocated this, in which case +- // this delete might not work... +- LE_DELETE_ARRAY(outChars); ++ fakeGlyphCount = glyphProcessing(outChars, 0, outCharCount, outCharCount, rightToLeft, fakeGlyphStorage, success); ++ LE_DELETE_ARRAY(outChars); // FIXME: a subclass may have allocated this, in which case this delete might not work... + //adjustGlyphs(outChars, 0, outCharCount, rightToLeft, fakeGlyphs, fakeGlyphCount); + } else { +- fakeGlyphCount = glyphProcessing(chars, offset, count, max, rightToLeft, +- fakeGlyphStorage, success); ++ fakeGlyphCount = glyphProcessing(chars, offset, count, max, rightToLeft, fakeGlyphStorage, success); + //adjustGlyphs(chars, offset, count, rightToLeft, fakeGlyphs, fakeGlyphCount); + } + +@@ -287,8 +272,8 @@ + } + + // apply GPOS table, if any +-void OpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++void OpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return; +@@ -324,8 +309,8 @@ + } + #endif + +- fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTag, fLangSysTag, +- fGDEFTable, fFontInstance, fFeatureMap, fFeatureMapCount, fFeatureOrder); ++ fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTag, fLangSysTag, fGDEFTable, fFontInstance, ++ fFeatureMap, fFeatureMapCount, fFeatureOrder); + + float xAdjust = 0, yAdjust = 0; + +@@ -360,4 +345,12 @@ + + delete adjustments; + } ++ ++#if 0 ++ // Don't know why this is here... ++ LE_DELETE_ARRAY(fFeatureTags); ++ fFeatureTags = NULL; ++#endif + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h b/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h +@@ -23,9 +23,7 @@ + * + */ + +- + /* +- * + * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved + * + */ +@@ -42,6 +40,8 @@ + #include "GlyphDefinitionTables.h" + #include "GlyphPositioningTables.h" + ++U_NAMESPACE_BEGIN ++ + /** + * OpenTypeLayoutEngine implements complex text layout for OpenType fonts - that is + * fonts which have GSUB and GPOS tables associated with them. In order to do this, +@@ -87,7 +87,7 @@ + * @internal + */ + OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); + + /** + * This constructor is used when the font requires a "canned" GSUB table which can't be known +@@ -95,11 +95,12 @@ + * + * @param fontInstance - the font + * @param scriptCode - the script +- * @param languageCode - the language ++ * @param langaugeCode - the language + * + * @internal + */ +- OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags); ++ OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -132,6 +133,20 @@ + */ + static LETag getLangSysTag(le_int32 languageCode); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + + /** +@@ -259,9 +274,8 @@ + * + * @internal + */ +- virtual le_int32 characterProcessing(const LEUnicode /*chars*/[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool /*rightToLeft*/, +- LEUnicode *&/*outChars*/, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 characterProcessing(const LEUnicode /*chars*/[], le_int32 offset, le_int32 count, le_int32 max, le_bool /*rightToLeft*/, ++ LEUnicode *&/*outChars*/, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** + * This method does character to glyph mapping, and applies the GSUB table. The +@@ -292,9 +306,8 @@ + * + * @internal + */ +- virtual le_int32 glyphProcessing(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, +- LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 glyphProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** + * This method does any processing necessary to convert "fake" +@@ -321,8 +334,7 @@ + * + * @internal + */ +- virtual le_int32 glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, +- LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** + * This method applies the characterProcessing, glyphProcessing and glyphPostProcessing +@@ -346,8 +358,7 @@ + * + * @internal + */ +- virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, +- le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** + * This method uses the GPOS table, if there is one, to adjust the glyph positions. +@@ -364,8 +375,7 @@ + * + * @internal + */ +- virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, +- le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); + + /** + * This method frees the feature tag array so that the +@@ -377,4 +387,6 @@ + virtual void reset(); + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/OpenTypeTables.h b/src/share/native/sun/font/layout/OpenTypeTables.h +--- jdk/src/share/native/sun/font/layout/OpenTypeTables.h ++++ jdk/src/share/native/sun/font/layout/OpenTypeTables.h +@@ -32,8 +32,15 @@ + #ifndef __OPENTYPETABLES_H + #define __OPENTYPETABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + ++U_NAMESPACE_BEGIN ++ + #define ANY_NUMBER 1 + + typedef le_uint16 Offset; +@@ -62,4 +69,5 @@ + FeatureMask mask; + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/OpenTypeUtilities.cpp b/src/share/native/sun/font/layout/OpenTypeUtilities.cpp +--- jdk/src/share/native/sun/font/layout/OpenTypeUtilities.cpp ++++ jdk/src/share/native/sun/font/layout/OpenTypeUtilities.cpp +@@ -34,6 +34,8 @@ + #include "OpenTypeUtilities.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + // + // Finds the high bit by binary searching + // through the bits in n. +@@ -192,3 +194,7 @@ + array[i + 1] = v; + } + } ++ ++ ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/OpenTypeUtilities.h b/src/share/native/sun/font/layout/OpenTypeUtilities.h +--- jdk/src/share/native/sun/font/layout/OpenTypeUtilities.h ++++ jdk/src/share/native/sun/font/layout/OpenTypeUtilities.h +@@ -32,10 +32,17 @@ + #ifndef __OPENTYPEUTILITIES_H + #define __OPENTYPEUTILITIES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + +-class OpenTypeUtilities { ++U_NAMESPACE_BEGIN ++ ++class OpenTypeUtilities /* not : public UObject because all methods are static */ { + public: + static le_int8 highBit(le_int32 value); + static Offset getTagOffset(LETag tag, const TagAndOffsetRecord *records, le_int32 recordCount); +@@ -48,4 +55,5 @@ + OpenTypeUtilities() {} // private - forbid instantiation + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/PairPositioningSubtables.cpp b/src/share/native/sun/font/layout/PairPositioningSubtables.cpp +--- jdk/src/share/native/sun/font/layout/PairPositioningSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/PairPositioningSubtables.cpp +@@ -39,6 +39,8 @@ + #include "OpenTypeUtilities.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_uint32 PairPositioningSubtable::process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const + { + switch(SWAPW(subtableFormat)) +@@ -82,8 +84,7 @@ + const PairValueRecord *pairValueRecord = NULL; + + if (pairValueCount != 0) { +- pairValueRecord = findPairValueRecord((TTGlyphID) LE_GET_GLYPH(secondGlyph), +- pairSetTable->pairValueRecordArray, pairValueCount, recordSize); ++ pairValueRecord = findPairValueRecord((TTGlyphID) LE_GET_GLYPH(secondGlyph), pairSetTable->pairValueRecordArray, pairValueCount, recordSize); + } + + if (pairValueRecord == NULL) { +@@ -91,8 +92,7 @@ + } + + if (valueFormat1 != 0) { +- pairValueRecord->valueRecord1.adjustPosition(SWAPW(valueFormat1), (char *) this, +- tempIterator, fontInstance); ++ pairValueRecord->valueRecord1.adjustPosition(SWAPW(valueFormat1), (char *) this, tempIterator, fontInstance); + } + + if (valueFormat2 != 0) { +@@ -171,3 +171,5 @@ + + return NULL; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/PairPositioningSubtables.h b/src/share/native/sun/font/layout/PairPositioningSubtables.h +--- jdk/src/share/native/sun/font/layout/PairPositioningSubtables.h ++++ jdk/src/share/native/sun/font/layout/PairPositioningSubtables.h +@@ -32,6 +32,11 @@ + #ifndef __PAIRPOSITIONINGSUBTABLES_H + #define __PAIRPOSITIONINGSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +@@ -39,6 +44,8 @@ + #include "ValueRecords.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + // NOTE: ValueRecord has a variable size + struct PairValueRecord + { +@@ -96,4 +103,7 @@ + le_uint32 process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; + }; + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/ScriptAndLanguage.cpp b/src/share/native/sun/font/layout/ScriptAndLanguage.cpp +--- jdk/src/share/native/sun/font/layout/ScriptAndLanguage.cpp ++++ jdk/src/share/native/sun/font/layout/ScriptAndLanguage.cpp +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved + * + */ +@@ -35,6 +36,8 @@ + #include "ScriptAndLanguage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + const LangSysTable *ScriptTable::findLanguage(LETag languageTag, le_bool exactMatch) const + { + le_uint16 count = SWAPW(langSysCount); +@@ -79,3 +82,5 @@ + + return scriptTable->findLanguage(languageTag, exactMatch); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ScriptAndLanguage.h b/src/share/native/sun/font/layout/ScriptAndLanguage.h +--- jdk/src/share/native/sun/font/layout/ScriptAndLanguage.h ++++ jdk/src/share/native/sun/font/layout/ScriptAndLanguage.h +@@ -32,9 +32,16 @@ + #ifndef __SCRIPTANDLANGUAGE_H + #define __SCRIPTANDLANGUAGE_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + typedef TagAndOffsetRecord LangSysRecord; + + struct LangSysTable +@@ -65,4 +72,6 @@ + const LangSysTable *findLanguage(LETag scriptTag, LETag languageTag, le_bool exactMatch = FALSE) const; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp b/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp +--- jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp ++++ jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp +@@ -35,6 +35,8 @@ + #include "ScriptAndLanguageTags.h" + #include "OpenTypeLayoutEngine.h" + ++U_NAMESPACE_BEGIN ++ + const LETag OpenTypeLayoutEngine::scriptTags[] = { + zyyyScriptTag, /* 'zyyy' (COMMON) */ + qaaiScriptTag, /* 'qaai' (INHERITED) */ +@@ -125,3 +127,5 @@ + zhsLanguageTag, /* 'ZHS' (Chinese (Simplified)) */ + zhtLanguageTag /* 'ZHT' (Chinese (Traditional)) */ + }; ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ScriptAndLanguageTags.h b/src/share/native/sun/font/layout/ScriptAndLanguageTags.h +--- jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.h ++++ jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.h +@@ -36,6 +36,13 @@ + + #include "LETypes.h" + ++U_NAMESPACE_BEGIN ++ ++/** ++ * \file ++ * \internal ++ */ ++ + const LETag zyyyScriptTag = 0x7A797979; /* 'zyyy' (COMMON) */ + const LETag qaaiScriptTag = 0x71616169; /* 'qaai' (INHERITED) */ + const LETag arabScriptTag = 0x61726162; /* 'arab' (ARABIC) */ +@@ -126,4 +133,6 @@ + const LETag zhsLanguageTag = 0x5A485320; /* 'ZHS' (Chinese (Simplified)) */ + const LETag zhtLanguageTag = 0x5A485420; /* 'ZHT' (Chinese (Traditional)) */ + ++ ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp b/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp +--- jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp +@@ -38,6 +38,10 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SegmentArrayProcessor) ++ + SegmentArrayProcessor::SegmentArrayProcessor() + { + } +@@ -77,3 +81,5 @@ + } + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SegmentArrayProcessor.h b/src/share/native/sun/font/layout/SegmentArrayProcessor.h +--- jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.h ++++ jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.h +@@ -32,12 +32,19 @@ + #ifndef __SEGMENTARRAYPROCESSOR_H + #define __SEGMENTARRAYPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "NonContextualGlyphSubst.h" + #include "NonContextualGlyphSubstProc.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class SegmentArrayProcessor : public NonContextualGlyphSubstitutionProcessor +@@ -49,11 +56,28 @@ + + virtual ~SegmentArrayProcessor(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + SegmentArrayProcessor(); + + protected: + const SegmentArrayLookupTable *segmentArrayLookupTable; ++ + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/SegmentSingleProcessor.cpp b/src/share/native/sun/font/layout/SegmentSingleProcessor.cpp +--- jdk/src/share/native/sun/font/layout/SegmentSingleProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/SegmentSingleProcessor.cpp +@@ -38,6 +38,10 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SegmentSingleProcessor) ++ + SegmentSingleProcessor::SegmentSingleProcessor() + { + } +@@ -71,3 +75,5 @@ + } + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SegmentSingleProcessor.h b/src/share/native/sun/font/layout/SegmentSingleProcessor.h +--- jdk/src/share/native/sun/font/layout/SegmentSingleProcessor.h ++++ jdk/src/share/native/sun/font/layout/SegmentSingleProcessor.h +@@ -32,12 +32,19 @@ + #ifndef __SEGMENTSINGLEPROCESSOR_H + #define __SEGMENTSINGLEPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "NonContextualGlyphSubst.h" + #include "NonContextualGlyphSubstProc.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class SegmentSingleProcessor : public NonContextualGlyphSubstitutionProcessor +@@ -49,11 +56,28 @@ + + virtual ~SegmentSingleProcessor(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + SegmentSingleProcessor(); + + protected: + const SegmentSingleLookupTable *segmentSingleLookupTable; ++ + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/ShapingTypeData.cpp b/src/share/native/sun/font/layout/ShapingTypeData.cpp +--- jdk/src/share/native/sun/font/layout/ShapingTypeData.cpp ++++ jdk/src/share/native/sun/font/layout/ShapingTypeData.cpp +@@ -36,6 +36,8 @@ + #include "LETypes.h" + #include "ArabicShaping.h" + ++U_NAMESPACE_BEGIN ++ + const le_uint8 ArabicShaping::shapingTypeTable[] = { + 0x00, 0x02, 0x00, 0xAD, 0x00, 0xAD, 0x00, 0xAD, 0x00, 0x05, 0x03, 0x00, 0x03, 0x6F, 0x00, 0x05, + 0x04, 0x83, 0x04, 0x86, 0x00, 0x05, 0x04, 0x88, 0x04, 0x89, 0x00, 0x05, 0x05, 0x91, 0x05, 0xB9, +@@ -104,3 +106,5 @@ + 0xFE, 0x20, 0xFE, 0x23, 0x00, 0x05, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x05, 0xFF, 0xF9, 0xFF, 0xFB, + 0x00, 0x05 + }; ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SimpleArrayProcessor.cpp b/src/share/native/sun/font/layout/SimpleArrayProcessor.cpp +--- jdk/src/share/native/sun/font/layout/SimpleArrayProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/SimpleArrayProcessor.cpp +@@ -38,6 +38,10 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleArrayProcessor) ++ + SimpleArrayProcessor::SimpleArrayProcessor() + { + } +@@ -68,3 +72,5 @@ + } + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SimpleArrayProcessor.h b/src/share/native/sun/font/layout/SimpleArrayProcessor.h +--- jdk/src/share/native/sun/font/layout/SimpleArrayProcessor.h ++++ jdk/src/share/native/sun/font/layout/SimpleArrayProcessor.h +@@ -32,12 +32,19 @@ + #ifndef __SIMPLEARRAYPROCESSOR_H + #define __SIMPLEARRAYPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "NonContextualGlyphSubst.h" + #include "NonContextualGlyphSubstProc.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class SimpleArrayProcessor : public NonContextualGlyphSubstitutionProcessor +@@ -49,11 +56,28 @@ + + virtual ~SimpleArrayProcessor(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + SimpleArrayProcessor(); + + protected: + const SimpleArrayLookupTable *simpleArrayLookupTable; ++ + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/SinglePositioningSubtables.cpp b/src/share/native/sun/font/layout/SinglePositioningSubtables.cpp +--- jdk/src/share/native/sun/font/layout/SinglePositioningSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/SinglePositioningSubtables.cpp +@@ -38,6 +38,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_uint32 SinglePositioningSubtable::process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const + { + switch(SWAPW(subtableFormat)) +@@ -84,11 +86,12 @@ + le_int16 coverageIndex = (le_int16) getGlyphCoverage(glyph); + + if (coverageIndex >= 0) { +- valueRecordArray[0].adjustPosition(coverageIndex, SWAPW(valueFormat), (const char *) this, +- *glyphIterator, fontInstance); ++ valueRecordArray[0].adjustPosition(coverageIndex, SWAPW(valueFormat), (const char *) this, *glyphIterator, fontInstance); + + return 1; + } + + return 0; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SinglePositioningSubtables.h b/src/share/native/sun/font/layout/SinglePositioningSubtables.h +--- jdk/src/share/native/sun/font/layout/SinglePositioningSubtables.h ++++ jdk/src/share/native/sun/font/layout/SinglePositioningSubtables.h +@@ -32,6 +32,11 @@ + #ifndef __SINGLEPOSITIONINGSUBTABLES_H + #define __SINGLEPOSITIONINGSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +@@ -39,6 +44,8 @@ + #include "ValueRecords.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct SinglePositioningSubtable : GlyphPositioningSubtable + { + le_uint32 process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; +@@ -61,4 +68,7 @@ + le_uint32 process(GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; + }; + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/SingleSubstitutionSubtables.cpp b/src/share/native/sun/font/layout/SingleSubstitutionSubtables.cpp +--- jdk/src/share/native/sun/font/layout/SingleSubstitutionSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/SingleSubstitutionSubtables.cpp +@@ -37,6 +37,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + le_uint32 SingleSubstitutionSubtable::process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter) const + { + switch(SWAPW(subtableFormat)) +@@ -98,3 +100,5 @@ + + return 0; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SingleSubstitutionSubtables.h b/src/share/native/sun/font/layout/SingleSubstitutionSubtables.h +--- jdk/src/share/native/sun/font/layout/SingleSubstitutionSubtables.h ++++ jdk/src/share/native/sun/font/layout/SingleSubstitutionSubtables.h +@@ -32,12 +32,19 @@ + #ifndef __SINGLESUBSTITUTIONSUBTABLES_H + #define __SINGLESUBSTITUTIONSUBTABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEGlyphFilter.h" + #include "OpenTypeTables.h" + #include "GlyphSubstitutionTables.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + struct SingleSubstitutionSubtable : GlyphSubstitutionSubtable + { + le_uint32 process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter = NULL) const; +@@ -58,4 +65,7 @@ + le_uint32 process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter = NULL) const; + }; + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/SingleTableProcessor.cpp b/src/share/native/sun/font/layout/SingleTableProcessor.cpp +--- jdk/src/share/native/sun/font/layout/SingleTableProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/SingleTableProcessor.cpp +@@ -38,6 +38,10 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SingleTableProcessor) ++ + SingleTableProcessor::SingleTableProcessor() + { + } +@@ -68,3 +72,5 @@ + } + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SingleTableProcessor.h b/src/share/native/sun/font/layout/SingleTableProcessor.h +--- jdk/src/share/native/sun/font/layout/SingleTableProcessor.h ++++ jdk/src/share/native/sun/font/layout/SingleTableProcessor.h +@@ -32,12 +32,19 @@ + #ifndef __SINGLETABLEPROCESSOR_H + #define __SINGLETABLEPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "NonContextualGlyphSubst.h" + #include "NonContextualGlyphSubstProc.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class SingleTableProcessor : public NonContextualGlyphSubstitutionProcessor +@@ -49,11 +56,27 @@ + + virtual ~SingleTableProcessor(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + SingleTableProcessor(); + + protected: + const SingleTableLookupTable *singleTableLookupTable; ++ + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/StateTableProcessor.cpp b/src/share/native/sun/font/layout/StateTableProcessor.cpp +--- jdk/src/share/native/sun/font/layout/StateTableProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/StateTableProcessor.cpp +@@ -38,6 +38,8 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + StateTableProcessor::StateTableProcessor() + { + } +@@ -101,3 +103,5 @@ + + endStateTable(); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/StateTableProcessor.h b/src/share/native/sun/font/layout/StateTableProcessor.h +--- jdk/src/share/native/sun/font/layout/StateTableProcessor.h ++++ jdk/src/share/native/sun/font/layout/StateTableProcessor.h +@@ -32,11 +32,18 @@ + #ifndef __STATETABLEPROCESSOR_H + #define __STATETABLEPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "MorphStateTables.h" + #include "SubtableProcessor.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class StateTableProcessor : public SubtableProcessor +@@ -72,4 +79,5 @@ + StateTableProcessor &operator=(const StateTableProcessor &other); // forbid copying of this class + }; + ++U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/StateTables.h b/src/share/native/sun/font/layout/StateTables.h +--- jdk/src/share/native/sun/font/layout/StateTables.h ++++ jdk/src/share/native/sun/font/layout/StateTables.h +@@ -32,6 +32,11 @@ + #ifndef __STATETABLES_H + #define __STATETABLES_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LayoutTables.h" + +@@ -70,6 +75,8 @@ + #define LE_STATE_PATIENCE_INCR(x) if((x)!=le_patience_curr) ++le_patience_count; + + ++U_NAMESPACE_BEGIN ++ + struct StateTableHeader + { + le_int16 stateSize; +@@ -113,4 +120,6 @@ + le_int16 flags; + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/SubstitutionLookups.cpp b/src/share/native/sun/font/layout/SubstitutionLookups.cpp +--- jdk/src/share/native/sun/font/layout/SubstitutionLookups.cpp ++++ jdk/src/share/native/sun/font/layout/SubstitutionLookups.cpp +@@ -39,6 +39,8 @@ + #include "CoverageTables.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + /* + NOTE: This could be optimized somewhat by keeping track + of the previous sequenceIndex in the loop and doing next() +@@ -65,3 +67,5 @@ + lookupProcessor->applySingleLookup(lookupListIndex, &tempIterator, fontInstance); + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SubstitutionLookups.h b/src/share/native/sun/font/layout/SubstitutionLookups.h +--- jdk/src/share/native/sun/font/layout/SubstitutionLookups.h ++++ jdk/src/share/native/sun/font/layout/SubstitutionLookups.h +@@ -32,6 +32,11 @@ + #ifndef __SUBSTITUTIONLOOKUPS_H + #define __SUBSTITUTIONLOOKUPS_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +@@ -39,6 +44,8 @@ + #include "GlyphIterator.h" + #include "LookupProcessor.h" + ++U_NAMESPACE_BEGIN ++ + struct SubstitutionLookupRecord + { + le_uint16 sequenceIndex; +@@ -56,4 +63,6 @@ + le_int32 position); + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/SubtableProcessor.cpp b/src/share/native/sun/font/layout/SubtableProcessor.cpp +--- jdk/src/share/native/sun/font/layout/SubtableProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/SubtableProcessor.cpp +@@ -34,6 +34,8 @@ + #include "SubtableProcessor.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + SubtableProcessor::SubtableProcessor() + { + } +@@ -50,3 +52,5 @@ + SubtableProcessor::~SubtableProcessor() + { + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SubtableProcessor.h b/src/share/native/sun/font/layout/SubtableProcessor.h +--- jdk/src/share/native/sun/font/layout/SubtableProcessor.h ++++ jdk/src/share/native/sun/font/layout/SubtableProcessor.h +@@ -32,13 +32,19 @@ + #ifndef __SUBTABLEPROCESSOR_H + #define __SUBTABLEPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + +-class SubtableProcessor +-{ ++class SubtableProcessor : public UMemory { + public: + virtual void process(LEGlyphStorage &glyphStorage) = 0; + virtual ~SubtableProcessor(); +@@ -60,4 +66,6 @@ + SubtableProcessor &operator=(const SubtableProcessor &other); // forbid copying of this class + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp b/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp +@@ -38,8 +38,11 @@ + + #include "ThaiShaping.h" + +-ThaiLayoutEngine::ThaiLayoutEngine(const LEFontInstance *fontInstance, +- le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ThaiLayoutEngine) ++ ++ThaiLayoutEngine::ThaiLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) + : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags) + { + fErrorChar = 0x25CC; +@@ -73,16 +76,13 @@ + // Output: glyphs, char indices + // Returns: the glyph count + // NOTE: this assumes that ThaiShaping::compose will allocate the outChars array... +-le_int32 ThaiLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool /*rightToLeft*/, +- LEGlyphStorage &glyphStorage, LEErrorCode &success) ++le_int32 ThaiLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool /*rightToLeft*/, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { + return 0; + } + +- if (chars == NULL || offset < 0 || count < 0 || max < 0 || +- offset >= max || offset + count > max) { ++ if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } +@@ -107,8 +107,7 @@ + return 0; + } + +- glyphCount = ThaiShaping::compose(chars, offset, count, fGlyphSet, fErrorChar, +- outChars, glyphStorage); ++ glyphCount = ThaiShaping::compose(chars, offset, count, fGlyphSet, fErrorChar, outChars, glyphStorage); + mapCharsToGlyphs(outChars, 0, glyphCount, FALSE, FALSE, glyphStorage, success); + + LE_DELETE_ARRAY(outChars); +@@ -116,3 +115,5 @@ + glyphStorage.adoptGlyphCount(glyphCount); + return glyphCount; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ThaiLayoutEngine.h b/src/share/native/sun/font/layout/ThaiLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.h +@@ -39,6 +39,8 @@ + + #include "ThaiShaping.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + /** +@@ -66,8 +68,7 @@ + * + * @internal + */ +- ThaiLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, +- le_int32 languageCode, le_int32 typoFlags); ++ ThaiLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -76,6 +77,20 @@ + */ + virtual ~ThaiLayoutEngine(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + protected: + /** + * A small integer indicating which Thai encoding +@@ -109,10 +124,8 @@ + * @param offset - the index of the first character to process + * @param count - the number of characters to process + * @param max - the number of characters in the input context +- * @param rightToLeft - <code>TRUE</code> if the text is in a +- * right to left directional run +- * @param glyphStorage - the glyph storage object. The glyph and +- * char index arrays will be set. ++ * @param rightToLeft - <code>TRUE</code> if the text is in a right to left directional run ++ * @param glyphStorage - the glyph storage object. The glyph and char index arrays will be set. + * + * Output parameters: + * @param success - set to an error code if the operation fails +@@ -123,10 +136,11 @@ + * + * @internal + */ +- virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, +- le_int32 count, le_int32 max, le_bool rightToLeft, ++ virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, + LEGlyphStorage &glyphStorage, LEErrorCode &success); + + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/ThaiShaping.cpp b/src/share/native/sun/font/layout/ThaiShaping.cpp +--- jdk/src/share/native/sun/font/layout/ThaiShaping.cpp ++++ jdk/src/share/native/sun/font/layout/ThaiShaping.cpp +@@ -35,6 +35,8 @@ + #include "LEGlyphStorage.h" + #include "ThaiShaping.h" + ++U_NAMESPACE_BEGIN ++ + enum { + CH_SPACE = 0x0020, + CH_YAMAKKAN = 0x0E4E, +@@ -248,9 +250,8 @@ + return transition.nextState; + } + +-le_uint8 ThaiShaping::getNextState(LEUnicode ch, le_uint8 prevState, le_int32 inputIndex, +- le_uint8 glyphSet, LEUnicode errorChar, +- le_uint8 &charClass, LEUnicode *output, LEGlyphStorage &glyphStorage, le_int32 &outputIndex) ++le_uint8 ThaiShaping::getNextState(LEUnicode ch, le_uint8 prevState, le_int32 inputIndex, le_uint8 glyphSet, LEUnicode errorChar, ++ le_uint8 &charClass, LEUnicode *output, LEGlyphStorage &glyphStorage, le_int32 &outputIndex) + { + StateTransition transition; + +@@ -327,3 +328,5 @@ + + return outputIndex; + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ThaiShaping.h b/src/share/native/sun/font/layout/ThaiShaping.h +--- jdk/src/share/native/sun/font/layout/ThaiShaping.h ++++ jdk/src/share/native/sun/font/layout/ThaiShaping.h +@@ -32,13 +32,20 @@ + #ifndef __THAISHAPING_H + #define __THAISHAPING_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEGlyphFilter.h" + #include "OpenTypeTables.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + +-class ThaiShaping { ++class ThaiShaping /* not : public UObject because all methods are static */ { + public: + + enum { +@@ -120,4 +127,7 @@ + return thaiStateTable[state][currClass]; + } + ++U_NAMESPACE_END + #endif ++ ++ +diff --git a/src/share/native/sun/font/layout/ThaiStateTables.cpp b/src/share/native/sun/font/layout/ThaiStateTables.cpp +--- jdk/src/share/native/sun/font/layout/ThaiStateTables.cpp ++++ jdk/src/share/native/sun/font/layout/ThaiStateTables.cpp +@@ -25,6 +25,7 @@ + + /* + * ++ * + * (C) Copyright IBM Corp. 1999-2003 - All Rights Reserved + * + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS +@@ -35,6 +36,8 @@ + #include "LETypes.h" + #include "ThaiShaping.h" + ++U_NAMESPACE_BEGIN ++ + const le_uint8 ThaiShaping::classTable[] = { + // 0 1 2 3 4 5 6 7 8 9 A B C D E F + // ------------------------------------------------------------------------------- +@@ -105,3 +108,5 @@ + /*50*/ {{ 0, tA}, { 1, tA}, {18, tA}, {35, tA}, { 0, tA}, { 0, tS}, { 0, tS}, { 0, tA}, { 0, tR}, { 0, tR}, { 0, tR}, {51, tC}, { 0, tR}, { 0, tC}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}}, + /*51*/ {{ 0, tA}, { 1, tA}, {18, tA}, {35, tA}, { 0, tA}, { 0, tS}, { 0, tA}, { 0, tA}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}, { 0, tR}} + }; ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/TrimmedArrayProcessor.cpp b/src/share/native/sun/font/layout/TrimmedArrayProcessor.cpp +--- jdk/src/share/native/sun/font/layout/TrimmedArrayProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/TrimmedArrayProcessor.cpp +@@ -38,6 +38,10 @@ + #include "LEGlyphStorage.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TrimmedArrayProcessor) ++ + TrimmedArrayProcessor::TrimmedArrayProcessor() + { + } +@@ -72,3 +76,5 @@ + } + } + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/TrimmedArrayProcessor.h b/src/share/native/sun/font/layout/TrimmedArrayProcessor.h +--- jdk/src/share/native/sun/font/layout/TrimmedArrayProcessor.h ++++ jdk/src/share/native/sun/font/layout/TrimmedArrayProcessor.h +@@ -32,12 +32,19 @@ + #ifndef __TRIMMEDARRAYPROCESSOR_H + #define __TRIMMEDARRAYPROCESSOR_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "MorphTables.h" + #include "SubtableProcessor.h" + #include "NonContextualGlyphSubst.h" + #include "NonContextualGlyphSubstProc.h" + ++U_NAMESPACE_BEGIN ++ + class LEGlyphStorage; + + class TrimmedArrayProcessor : public NonContextualGlyphSubstitutionProcessor +@@ -49,6 +56,20 @@ + + virtual ~TrimmedArrayProcessor(); + ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ + private: + TrimmedArrayProcessor(); + +@@ -56,6 +77,9 @@ + TTGlyphID firstGlyph; + TTGlyphID lastGlyph; + const TrimmedArrayLookupTable *trimmedArrayLookupTable; ++ + }; + ++U_NAMESPACE_END + #endif ++ +diff --git a/src/share/native/sun/font/layout/ValueRecords.cpp b/src/share/native/sun/font/layout/ValueRecords.cpp +--- jdk/src/share/native/sun/font/layout/ValueRecords.cpp ++++ jdk/src/share/native/sun/font/layout/ValueRecords.cpp +@@ -37,6 +37,8 @@ + #include "GlyphIterator.h" + #include "LESwaps.h" + ++U_NAMESPACE_BEGIN ++ + #define Nibble(value, nibble) ((value >> (nibble * 4)) & 0xF) + #define NibbleBits(value, nibble) (bitsInNibble[Nibble(value, nibble)]) + +@@ -161,8 +163,8 @@ + xPlacementAdjustment, yPlacementAdjustment, xAdvanceAdjustment, yAdvanceAdjustment); + } + +-void ValueRecord::adjustPosition(le_int16 index, ValueFormat valueFormat, const char *base, +- GlyphIterator &glyphIterator, const LEFontInstance *fontInstance) const ++void ValueRecord::adjustPosition(le_int16 index, ValueFormat valueFormat, const char *base, GlyphIterator &glyphIterator, ++ const LEFontInstance *fontInstance) const + { + float xPlacementAdjustment = 0; + float yPlacementAdjustment = 0; +@@ -323,3 +325,5 @@ + + return getFieldCount(valueFormat & beforeMasks[field]); + } ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ValueRecords.h b/src/share/native/sun/font/layout/ValueRecords.h +--- jdk/src/share/native/sun/font/layout/ValueRecords.h ++++ jdk/src/share/native/sun/font/layout/ValueRecords.h +@@ -32,11 +32,18 @@ + #ifndef __VALUERECORDS_H + #define __VALUERECORDS_H + ++/** ++ * \file ++ * \internal ++ */ ++ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" + #include "GlyphIterator.h" + ++U_NAMESPACE_BEGIN ++ + typedef le_uint16 ValueFormat; + typedef le_int16 ValueRecordField; + +@@ -84,5 +91,7 @@ + vfbAnyDevice = vfbXPlaDevice + vfbYPlaDevice + vfbXAdvDevice + vfbYAdvDevice + }; + ++U_NAMESPACE_END ++#endif + +-#endif ++ diff --git a/java/openjdk6/files/icedtea/openjdk/6669869-queries_per_appcontext.patch b/java/openjdk6/files/icedtea/openjdk/6669869-queries_per_appcontext.patch new file mode 100644 index 000000000000..5e0f001e7b35 --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/6669869-queries_per_appcontext.patch @@ -0,0 +1,355 @@ +# HG changeset patch +# User andrew +# Date 1365686276 -3600 +# Node ID a939f541de9af5ccb78225c27cd46cd7dc6bcf87 +# Parent 9745a1f43592582cce60d8632d614fafc7dfdc3c +6669869: Beans.isDesignTime() and other queries should be per-AppContext +Reviewed-by: peterz, rupashka + +diff --git a/src/share/classes/java/beans/Beans.java b/src/share/classes/java/beans/Beans.java +--- jdk/src/share/classes/java/beans/Beans.java ++++ jdk/src/share/classes/java/beans/Beans.java +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved. ++ * Copyright (c) 1996, 2009, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it +@@ -27,26 +27,41 @@ + + import com.sun.beans.finder.ClassFinder; + +-import java.applet.*; ++import java.applet.Applet; ++import java.applet.AppletContext; ++import java.applet.AppletStub; ++import java.applet.AudioClip; + +-import java.awt.*; +- +-import java.beans.AppletInitializer; ++import java.awt.GraphicsEnvironment; ++import java.awt.Image; + + import java.beans.beancontext.BeanContext; + +-import java.io.*; +- +-import java.lang.reflect.Constructor; ++import java.io.IOException; ++import java.io.InputStream; ++import java.io.ObjectInputStream; ++import java.io.ObjectStreamClass; ++import java.io.StreamCorruptedException; + + import java.net.URL; +-import java.lang.reflect.Array; ++ ++import java.security.AccessController; ++import java.security.PrivilegedAction; ++ ++import java.util.Enumeration; ++import java.util.Hashtable; ++import java.util.Iterator; ++import java.util.Vector; ++ ++import sun.awt.AppContext; + + /** + * This class provides some general purpose beans control methods. + */ + + public class Beans { ++ private static final Object DESIGN_TIME = new Object(); ++ private static final Object GUI_AVAILABLE = new Object(); + + /** + * <p> +@@ -59,12 +74,12 @@ + * @param beanName the name of the bean within the class-loader. + * For example "sun.beanbox.foobah" + * +- * @exception java.lang.ClassNotFoundException if the class of a serialized ++ * @exception ClassNotFoundException if the class of a serialized + * object could not be found. +- * @exception java.io.IOException if an I/O error occurs. ++ * @exception IOException if an I/O error occurs. + */ + +- public static Object instantiate(ClassLoader cls, String beanName) throws java.io.IOException, ClassNotFoundException { ++ public static Object instantiate(ClassLoader cls, String beanName) throws IOException, ClassNotFoundException { + return Beans.instantiate(cls, beanName, null, null); + } + +@@ -80,12 +95,12 @@ + * For example "sun.beanbox.foobah" + * @param beanContext The BeanContext in which to nest the new bean + * +- * @exception java.lang.ClassNotFoundException if the class of a serialized ++ * @exception ClassNotFoundException if the class of a serialized + * object could not be found. +- * @exception java.io.IOException if an I/O error occurs. ++ * @exception IOException if an I/O error occurs. + */ + +- public static Object instantiate(ClassLoader cls, String beanName, BeanContext beanContext) throws java.io.IOException, ClassNotFoundException { ++ public static Object instantiate(ClassLoader cls, String beanName, BeanContext beanContext) throws IOException, ClassNotFoundException { + return Beans.instantiate(cls, beanName, beanContext, null); + } + +@@ -135,19 +150,19 @@ + * @param beanContext The BeanContext in which to nest the new bean + * @param initializer The AppletInitializer for the new bean + * +- * @exception java.lang.ClassNotFoundException if the class of a serialized ++ * @exception ClassNotFoundException if the class of a serialized + * object could not be found. +- * @exception java.io.IOException if an I/O error occurs. ++ * @exception IOException if an I/O error occurs. + */ + + public static Object instantiate(ClassLoader cls, String beanName, BeanContext beanContext, AppletInitializer initializer) +- throws java.io.IOException, ClassNotFoundException { ++ throws IOException, ClassNotFoundException { + +- java.io.InputStream ins; +- java.io.ObjectInputStream oins = null; ++ InputStream ins; ++ ObjectInputStream oins = null; + Object result = null; + boolean serialized = false; +- java.io.IOException serex = null; ++ IOException serex = null; + + // If the given classloader is null, we check if an + // system classloader is available and (if so) +@@ -166,8 +181,8 @@ + // Try to find a serialized object with this name + final String serName = beanName.replace('.','/').concat(".ser"); + final ClassLoader loader = cls; +- ins = (InputStream)java.security.AccessController.doPrivileged +- (new java.security.PrivilegedAction() { ++ ins = (InputStream)AccessController.doPrivileged ++ (new PrivilegedAction() { + public Object run() { + if (loader == null) + return ClassLoader.getSystemResourceAsStream(serName); +@@ -185,7 +200,7 @@ + result = oins.readObject(); + serialized = true; + oins.close(); +- } catch (java.io.IOException ex) { ++ } catch (IOException ex) { + ins.close(); + // Drop through and try opening the class. But remember + // the exception in case we can't find the class either. +@@ -264,8 +279,8 @@ + + final ClassLoader cloader = cls; + objectUrl = (URL) +- java.security.AccessController.doPrivileged +- (new java.security.PrivilegedAction() { ++ AccessController.doPrivileged ++ (new PrivilegedAction() { + public Object run() { + if (cloader == null) + return ClassLoader.getSystemResource +@@ -377,10 +392,11 @@ + * @return True if we are running in an application construction + * environment. + * +- * @see java.beans.DesignMode ++ * @see DesignMode + */ + public static boolean isDesignTime() { +- return designTime; ++ Object value = AppContext.getAppContext().get(DESIGN_TIME); ++ return (value instanceof Boolean) && (Boolean) value; + } + + /** +@@ -393,11 +409,12 @@ + * false in a server environment or if an application is + * running as part of a batch job. + * +- * @see java.beans.Visibility ++ * @see Visibility + * + */ + public static boolean isGuiAvailable() { +- return guiAvailable; ++ Object value = AppContext.getAppContext().get(GUI_AVAILABLE); ++ return (value instanceof Boolean) ? (Boolean) value : !GraphicsEnvironment.isHeadless(); + } + + /** +@@ -423,7 +440,7 @@ + if (sm != null) { + sm.checkPropertiesAccess(); + } +- designTime = isDesignTime; ++ AppContext.getAppContext().put(DESIGN_TIME, Boolean.valueOf(isDesignTime)); + } + + /** +@@ -449,14 +466,7 @@ + if (sm != null) { + sm.checkPropertiesAccess(); + } +- guiAvailable = isGuiAvailable; +- } +- +- +- private static boolean designTime; +- private static boolean guiAvailable; +- static { +- guiAvailable = !GraphicsEnvironment.isHeadless(); ++ AppContext.getAppContext().put(GUI_AVAILABLE, Boolean.valueOf(isGuiAvailable)); + } + } + +@@ -501,7 +511,7 @@ + + class BeansAppletContext implements AppletContext { + Applet target; +- java.util.Hashtable imageCache = new java.util.Hashtable(); ++ Hashtable imageCache = new Hashtable(); + + BeansAppletContext(Applet target) { + this.target = target; +@@ -546,8 +556,8 @@ + return null; + } + +- public java.util.Enumeration getApplets() { +- java.util.Vector applets = new java.util.Vector(); ++ public Enumeration getApplets() { ++ Vector applets = new Vector(); + applets.addElement(target); + return applets.elements(); + } +@@ -573,7 +583,7 @@ + return null; + } + +- public java.util.Iterator getStreamKeys(){ ++ public Iterator getStreamKeys(){ + // We do nothing. + return null; + } +diff --git a/test/java/beans/Beans/6669869/TestDesignTime.java b/test/java/beans/Beans/6669869/TestDesignTime.java +new file mode 100644 +--- /dev/null ++++ jdk/test/java/beans/Beans/6669869/TestDesignTime.java +@@ -0,0 +1,52 @@ ++/* ++ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ */ ++ ++/* ++ * @test ++ * @bug 6669869 ++ * @summary Tests DesignTime property in different application contexts ++ * @author Sergey Malenkov ++ */ ++ ++import java.beans.Beans; ++import sun.awt.SunToolkit; ++ ++public class TestDesignTime implements Runnable { ++ public static void main(String[] args) throws InterruptedException { ++ if (Beans.isDesignTime()) { ++ throw new Error("unexpected DesignTime property"); ++ } ++ Beans.setDesignTime(!Beans.isDesignTime()); ++ ThreadGroup group = new ThreadGroup("$$$"); ++ Thread thread = new Thread(group, new TestDesignTime()); ++ thread.start(); ++ thread.join(); ++ } ++ ++ public void run() { ++ SunToolkit.createNewAppContext(); ++ if (Beans.isDesignTime()) { ++ throw new Error("shared DesignTime property"); ++ } ++ } ++} +diff --git a/test/java/beans/Beans/6669869/TestGuiAvailable.java b/test/java/beans/Beans/6669869/TestGuiAvailable.java +new file mode 100644 +--- /dev/null ++++ jdk/test/java/beans/Beans/6669869/TestGuiAvailable.java +@@ -0,0 +1,53 @@ ++/* ++ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ */ ++ ++/* ++ * @test ++ * @bug 6669869 ++ * @summary Tests GuiAvailable property in different application contexts ++ * @author Sergey Malenkov ++ */ ++ ++import java.awt.GraphicsEnvironment; ++import java.beans.Beans; ++import sun.awt.SunToolkit; ++ ++public class TestGuiAvailable implements Runnable { ++ public static void main(String[] args) throws InterruptedException { ++ if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) { ++ throw new Error("unexpected GuiAvailable property"); ++ } ++ Beans.setGuiAvailable(!Beans.isGuiAvailable()); ++ ThreadGroup group = new ThreadGroup("$$$"); ++ Thread thread = new Thread(group, new TestGuiAvailable()); ++ thread.start(); ++ thread.join(); ++ } ++ ++ public void run() { ++ SunToolkit.createNewAppContext(); ++ if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) { ++ throw new Error("shared GuiAvailable property"); ++ } ++ } ++} diff --git a/java/openjdk6/files/icedtea/openjdk/6886358-layout_update.patch b/java/openjdk6/files/icedtea/openjdk/6886358-layout_update.patch new file mode 100644 index 000000000000..ac485c96d1ba --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/6886358-layout_update.patch @@ -0,0 +1,13847 @@ +# HG changeset patch +# User andrew +# Date 1365742546 -3600 +# Node ID ec8a935f0737e033e4ffd401c4d554cd73739c39 +# Parent e8ed86062291305172267be90dcec2acef7c15a8 +6886358: layout code update +Reviewed-by: igor, prr + +diff --git a/make/sun/font/FILES_c.gmk b/make/sun/font/FILES_c.gmk +--- jdk/make/sun/font/FILES_c.gmk ++++ jdk/make/sun/font/FILES_c.gmk +@@ -72,8 +72,7 @@ + GlyphPositioningTables.cpp \ + GlyphSubstLookupProc.cpp \ + GlyphSubstitutionTables.cpp \ +- HebrewLigatureData.cpp \ +- HebrewShaping.cpp \ ++ HangulLayoutEngine.cpp \ + IndicClassTables.cpp \ + IndicReordering.cpp \ + KernTable.cpp \ +@@ -99,6 +98,8 @@ + SubstitutionLookups.cpp \ + ThaiShaping.cpp \ + ThaiStateTables.cpp \ ++ TibetanLayoutEngine.cpp \ ++ TibetanReordering.cpp \ + ValueRecords.cpp \ + ArabicLayoutEngine.cpp \ + ArabicShaping.cpp \ +diff --git a/src/share/classes/sun/font/FontManager.java b/src/share/classes/sun/font/FontManager.java +--- jdk/src/share/classes/sun/font/FontManager.java ++++ jdk/src/share/classes/sun/font/FontManager.java +@@ -3598,6 +3598,18 @@ + // 0E00 - 0E7F if Thai, assume shaping for vowel, tone marks + return true; + } ++ else if (code < 0x0f00) { ++ return false; ++ } ++ else if (code <= 0x0fff) { // U+0F00 - U+0FFF Tibetan ++ return true; ++ } ++ else if (code < 0x1100) { ++ return false; ++ } ++ else if (code < 0x11ff) { // U+1100 - U+11FF Old Hangul ++ return true; ++ } + else if (code < 0x1780) { + return false; + } +diff --git a/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp b/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp +@@ -59,16 +59,16 @@ + UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ArabicOpenTypeLayoutEngine) + + ArabicOpenTypeLayoutEngine::ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable) ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success) + { + fFeatureMap = ArabicShaping::getFeatureMap(fFeatureMapCount); + fFeatureOrder = TRUE; + } + + ArabicOpenTypeLayoutEngine::ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags) ++ le_int32 typoFlags, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success) + { + fFeatureMap = ArabicShaping::getFeatureMap(fFeatureMapCount); + +@@ -151,8 +151,8 @@ + } + } + +-UnicodeArabicOpenTypeLayoutEngine::UnicodeArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) +- : ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags | LE_CHAR_FILTER_FEATURE_FLAG) ++UnicodeArabicOpenTypeLayoutEngine::UnicodeArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success) ++ : ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags | LE_CHAR_FILTER_FEATURE_FLAG, success) + { + fGSUBTable = (const GlyphSubstitutionTableHeader *) CanonShaping::glyphSubstitutionTable; + fGDEFTable = (const GlyphDefinitionTableHeader *) CanonShaping::glyphDefinitionTable; +diff --git a/src/share/native/sun/font/layout/ArabicLayoutEngine.h b/src/share/native/sun/font/layout/ArabicLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.h +@@ -66,6 +66,7 @@ + * @param scriptCode - the script + * @param langaugeCode - the language + * @param gsubTable - the GSUB table ++ * @param success - set to an error code if the operation fails + * + * @see LayoutEngine::layoutEngineFactory + * @see OpenTypeLayoutEngine +@@ -74,7 +75,7 @@ + * @internal + */ + ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success); + + /** + * This constructor is used when the font requires a "canned" GSUB table which can't be known +@@ -83,6 +84,7 @@ + * @param fontInstance - the font + * @param scriptCode - the script + * @param langaugeCode - the language ++ * @param success - set to an error code if the operation fails + * + * @see OpenTypeLayoutEngine + * @see ScriptAndLanguageTags.h for script and language codes +@@ -90,7 +92,7 @@ + * @internal + */ + ArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags); ++ le_int32 typoFlags, LEErrorCode &success); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -184,6 +186,7 @@ + * @param fontInstance - the font + * @param scriptCode - the script + * @param languageCode - the language ++ * @param success - set to an error code if the operation fails + * + * @see LEFontInstance + * @see ScriptAndLanguageTags.h for script and language codes +@@ -191,7 +194,7 @@ + * @internal + */ + UnicodeArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags); ++ le_int32 typoFlags, LEErrorCode &success); + + /** + * The destructor, virtual for correct polymorphic invocation. +diff --git a/src/share/native/sun/font/layout/ArabicShaping.cpp b/src/share/native/sun/font/layout/ArabicShaping.cpp +--- jdk/src/share/native/sun/font/layout/ArabicShaping.cpp ++++ jdk/src/share/native/sun/font/layout/ArabicShaping.cpp +@@ -104,6 +104,7 @@ + #define markFeatureMask 0x00040000UL + #define mkmkFeatureMask 0x00020000UL + ++#define NO_FEATURES 0 + #define ISOL_FEATURES (isolFeatureMask | ligaFeatureMask | msetFeatureMask | markFeatureMask | ccmpFeatureMask | rligFeatureMask | caltFeatureMask | dligFeatureMask | cswhFeatureMask | cursFeatureMask | kernFeatureMask | mkmkFeatureMask) + + #define SHAPE_MASK 0xF0000000UL +@@ -198,7 +199,11 @@ + LEUnicode c = chars[in]; + ShapeType t = getShapeType(c); + ++ if (t == ST_NOSHAPE_NONE) { ++ glyphStorage.setAuxData(out, NO_FEATURES, success); ++ } else { + glyphStorage.setAuxData(out, ISOL_FEATURES, success); ++ } + + if ((t & MASK_TRANSPARENT) != 0) { + continue; +diff --git a/src/share/native/sun/font/layout/CanonData.cpp b/src/share/native/sun/font/layout/CanonData.cpp +--- jdk/src/share/native/sun/font/layout/CanonData.cpp ++++ jdk/src/share/native/sun/font/layout/CanonData.cpp +@@ -30,7 +30,7 @@ + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS + * YOU REALLY KNOW WHAT YOU'RE DOING. + * +- * Generated on: 03/31/2005 08:15:27 AM HST ++ * Generated on: 03/12/2008 03:14:34 PM HST + */ + + #include "LETypes.h" +@@ -39,36 +39,33 @@ + U_NAMESPACE_BEGIN + + const le_uint8 CanonShaping::glyphSubstitutionTable[] = { +- 0x00, 0x01, 0x00, 0x00, 0x00, 0x0A, 0x01, 0x58, 0x02, 0x86, 0x00, 0x12, 0x61, 0x72, 0x61, 0x62, +- 0x00, 0x6E, 0x62, 0x65, 0x6E, 0x67, 0x00, 0x82, 0x63, 0x79, 0x72, 0x6C, 0x00, 0x8E, 0x64, 0x65, +- 0x76, 0x61, 0x00, 0x9A, 0x67, 0x72, 0x65, 0x6B, 0x00, 0xA6, 0x67, 0x75, 0x72, 0x75, 0x00, 0xB2, +- 0x68, 0x65, 0x62, 0x72, 0x00, 0xBE, 0x68, 0x69, 0x72, 0x61, 0x00, 0xCA, 0x6B, 0x61, 0x6E, 0x61, +- 0x00, 0xD6, 0x6B, 0x6E, 0x64, 0x61, 0x00, 0xE2, 0x6C, 0x61, 0x74, 0x6E, 0x00, 0xEE, 0x6D, 0x6C, +- 0x79, 0x6D, 0x00, 0xFA, 0x6D, 0x79, 0x6D, 0x72, 0x01, 0x06, 0x6F, 0x72, 0x79, 0x61, 0x01, 0x12, +- 0x73, 0x69, 0x6E, 0x68, 0x01, 0x1E, 0x74, 0x61, 0x6D, 0x6C, 0x01, 0x2A, 0x74, 0x65, 0x6C, 0x75, +- 0x01, 0x36, 0x74, 0x69, 0x62, 0x74, 0x01, 0x42, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, +- 0x00, 0x05, 0x00, 0x00, 0x00, 0x13, 0x00, 0x15, 0x00, 0x12, 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, ++ 0x00, 0x01, 0x00, 0x00, 0x00, 0x0A, 0x01, 0x34, 0x02, 0x46, 0x00, 0x10, 0x61, 0x72, 0x61, 0x62, ++ 0x00, 0x62, 0x62, 0x61, 0x6C, 0x69, 0x00, 0x76, 0x62, 0x65, 0x6E, 0x67, 0x00, 0x82, 0x63, 0x79, ++ 0x72, 0x6C, 0x00, 0x8E, 0x64, 0x65, 0x76, 0x61, 0x00, 0x9A, 0x67, 0x72, 0x65, 0x6B, 0x00, 0xA6, ++ 0x68, 0x69, 0x72, 0x61, 0x00, 0xB2, 0x6B, 0x61, 0x6E, 0x61, 0x00, 0xBE, 0x6B, 0x6E, 0x64, 0x61, ++ 0x00, 0xCA, 0x6C, 0x61, 0x74, 0x6E, 0x00, 0xD6, 0x6D, 0x6C, 0x79, 0x6D, 0x00, 0xE2, 0x6D, 0x79, ++ 0x6D, 0x72, 0x00, 0xEE, 0x6F, 0x72, 0x79, 0x61, 0x00, 0xFA, 0x73, 0x69, 0x6E, 0x68, 0x01, 0x06, ++ 0x74, 0x61, 0x6D, 0x6C, 0x01, 0x12, 0x74, 0x65, 0x6C, 0x75, 0x01, 0x1E, 0x00, 0x04, 0x00, 0x00, ++ 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x05, 0x00, 0x00, 0x00, 0x11, 0x00, 0x13, 0x00, 0x10, 0x00, 0x12, ++ 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x0F, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, + 0x00, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x03, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, +- 0x00, 0x01, 0x00, 0x06, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x07, +- 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x09, 0x00, 0x04, 0x00, 0x00, +- 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, ++ 0x00, 0x01, 0x00, 0x07, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x06, ++ 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, ++ 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x09, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, + 0x00, 0x01, 0x00, 0x0A, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x0B, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x0D, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, +- 0x00, 0x01, 0x00, 0x0E, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x0F, +- 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, +- 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x11, 0x00, 0x16, 0x63, 0x63, 0x6D, 0x70, 0x00, 0x86, +- 0x63, 0x63, 0x6D, 0x70, 0x00, 0x8E, 0x63, 0x63, 0x6D, 0x70, 0x00, 0x96, 0x63, 0x63, 0x6D, 0x70, +- 0x00, 0x9E, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xA6, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xAE, 0x63, 0x63, +- 0x6D, 0x70, 0x00, 0xB6, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xBE, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xC6, +- 0x63, 0x63, 0x6D, 0x70, 0x00, 0xCE, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xD6, 0x63, 0x63, 0x6D, 0x70, +- 0x00, 0xDE, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xE6, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xEE, 0x63, 0x63, +- 0x6D, 0x70, 0x00, 0xF6, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xFE, 0x63, 0x63, 0x6D, 0x70, 0x01, 0x06, +- 0x63, 0x63, 0x6D, 0x70, 0x01, 0x0E, 0x66, 0x69, 0x6E, 0x61, 0x01, 0x16, 0x69, 0x6E, 0x69, 0x74, +- 0x01, 0x1C, 0x6C, 0x69, 0x67, 0x61, 0x01, 0x22, 0x6D, 0x65, 0x64, 0x69, 0x01, 0x28, 0x00, 0x00, ++ 0x00, 0x01, 0x00, 0x0E, 0x00, 0x14, 0x63, 0x63, 0x6D, 0x70, 0x00, 0x7A, 0x63, 0x63, 0x6D, 0x70, ++ 0x00, 0x82, 0x63, 0x63, 0x6D, 0x70, 0x00, 0x8A, 0x63, 0x63, 0x6D, 0x70, 0x00, 0x92, 0x63, 0x63, ++ 0x6D, 0x70, 0x00, 0x9A, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xA2, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xAA, ++ 0x63, 0x63, 0x6D, 0x70, 0x00, 0xB2, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xBA, 0x63, 0x63, 0x6D, 0x70, ++ 0x00, 0xC2, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xCA, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xD2, 0x63, 0x63, ++ 0x6D, 0x70, 0x00, 0xDA, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xE2, 0x63, 0x63, 0x6D, 0x70, 0x00, 0xEA, ++ 0x63, 0x63, 0x6D, 0x70, 0x00, 0xF2, 0x66, 0x69, 0x6E, 0x61, 0x00, 0xFA, 0x69, 0x6E, 0x69, 0x74, ++ 0x01, 0x00, 0x6C, 0x69, 0x67, 0x61, 0x01, 0x06, 0x6D, 0x65, 0x64, 0x69, 0x01, 0x0C, 0x00, 0x00, + 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x06, 0x00, 0x07, 0x00, 0x00, + 0x00, 0x02, 0x00, 0x08, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x0B, 0x00, 0x00, + 0x00, 0x02, 0x00, 0x0C, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0E, 0x00, 0x0F, 0x00, 0x00, +@@ -77,355 +74,349 @@ + 0x00, 0x02, 0x00, 0x18, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x1A, 0x00, 0x1B, 0x00, 0x00, + 0x00, 0x02, 0x00, 0x1C, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x02, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x00, + 0x00, 0x02, 0x00, 0x20, 0x00, 0x21, 0x00, 0x00, 0x00, 0x02, 0x00, 0x22, 0x00, 0x23, 0x00, 0x00, +- 0x00, 0x02, 0x00, 0x24, 0x00, 0x25, 0x00, 0x00, 0x00, 0x02, 0x00, 0x26, 0x00, 0x27, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, +- 0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x28, 0x00, 0x52, 0x00, 0xC8, 0x01, 0x2A, 0x01, 0xF4, +- 0x02, 0xBE, 0x03, 0xF8, 0x15, 0x06, 0x15, 0x58, 0x15, 0x9C, 0x18, 0x4E, 0x1A, 0xC4, 0x1B, 0x70, +- 0x1B, 0xF0, 0x4F, 0xEA, 0x8E, 0xAE, 0x8F, 0x14, 0x8F, 0x62, 0x91, 0x58, 0x93, 0x26, 0x94, 0x94, +- 0x95, 0xB4, 0x96, 0x0A, 0x96, 0x66, 0x98, 0x0C, 0x99, 0x54, 0xB9, 0x0C, 0xDC, 0x92, 0xDC, 0xC8, +- 0xDC, 0xF8, 0xDD, 0x18, 0xDD, 0x34, 0xDD, 0x80, 0xDD, 0xC4, 0xDE, 0x0C, 0xDE, 0x5E, 0xDE, 0xA2, +- 0xDE, 0xDC, 0xDE, 0xFC, 0xDF, 0x18, 0xE0, 0x36, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, +- 0x00, 0x01, 0x00, 0x5E, 0x00, 0x06, 0x00, 0x12, 0x00, 0x2C, 0x00, 0x36, 0x00, 0x40, 0x00, 0x4A, +- 0x00, 0x54, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x06, 0x22, 0x00, 0x02, 0x06, 0x53, +- 0x06, 0x23, 0x00, 0x02, 0x06, 0x54, 0x06, 0x25, 0x00, 0x02, 0x06, 0x55, 0x00, 0x01, 0x00, 0x04, +- 0x06, 0x24, 0x00, 0x02, 0x06, 0x54, 0x00, 0x01, 0x00, 0x04, 0x06, 0x26, 0x00, 0x02, 0x06, 0x54, +- 0x00, 0x01, 0x00, 0x04, 0x06, 0xC2, 0x00, 0x02, 0x06, 0x54, 0x00, 0x01, 0x00, 0x04, 0x06, 0xD3, +- 0x00, 0x02, 0x06, 0x54, 0x00, 0x01, 0x00, 0x04, 0x06, 0xC0, 0x00, 0x02, 0x06, 0x54, 0x00, 0x01, +- 0x00, 0x06, 0x06, 0x27, 0x06, 0x48, 0x06, 0x4A, 0x06, 0xC1, 0x06, 0xD2, 0x06, 0xD5, 0x00, 0x02, +- 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x46, 0x00, 0x08, 0x00, 0x16, 0x00, 0x1C, +- 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x00, 0x3A, 0x00, 0x40, 0x00, 0x02, 0x06, 0x27, +- 0x06, 0x53, 0x00, 0x02, 0x06, 0x27, 0x06, 0x54, 0x00, 0x02, 0x06, 0x48, 0x06, 0x54, 0x00, 0x02, +- 0x06, 0x27, 0x06, 0x55, 0x00, 0x02, 0x06, 0x4A, 0x06, 0x54, 0x00, 0x02, 0x06, 0xD5, 0x06, 0x54, +- 0x00, 0x02, 0x06, 0xC1, 0x06, 0x54, 0x00, 0x02, 0x06, 0xD2, 0x06, 0x54, 0x00, 0x01, 0x00, 0x08, +- 0x06, 0x22, 0x06, 0x23, 0x06, 0x24, 0x06, 0x25, 0x06, 0x26, 0x06, 0xC0, 0x06, 0xC2, 0x06, 0xD3, +- 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x62, 0x00, 0x2E, 0xFE, 0x8B, +- 0xFE, 0x91, 0xFE, 0x97, 0xFE, 0x9B, 0xFE, 0x9F, 0xFE, 0xA3, 0xFE, 0xA7, 0xFE, 0xB3, 0xFE, 0xB7, +- 0xFE, 0xBB, 0xFE, 0xBF, 0xFE, 0xC3, 0xFE, 0xC7, 0xFE, 0xCB, 0xFE, 0xCF, 0xFE, 0xD3, 0xFE, 0xD7, +- 0xFE, 0xDB, 0xFE, 0xDF, 0xFE, 0xE3, 0xFE, 0xE7, 0xFE, 0xEB, 0xFB, 0xE8, 0xFE, 0xF3, 0xFB, 0x68, +- 0xFB, 0x60, 0xFB, 0x54, 0xFB, 0x58, 0xFB, 0x64, 0xFB, 0x5C, 0xFB, 0x78, 0xFB, 0x74, 0xFB, 0x7C, +- 0xFB, 0x80, 0xFB, 0x6C, 0xFB, 0x70, 0xFB, 0x90, 0xFB, 0xD5, 0xFB, 0x94, 0xFB, 0x9C, 0xFB, 0x98, +- 0xFB, 0xA2, 0xFB, 0xAC, 0xFB, 0xA8, 0xFB, 0xFE, 0xFB, 0xE6, 0x00, 0x01, 0x00, 0x2E, 0x06, 0x26, +- 0x06, 0x28, 0x06, 0x2A, 0x06, 0x2B, 0x06, 0x2C, 0x06, 0x2D, 0x06, 0x2E, 0x06, 0x33, 0x06, 0x34, +- 0x06, 0x35, 0x06, 0x36, 0x06, 0x37, 0x06, 0x38, 0x06, 0x39, 0x06, 0x3A, 0x06, 0x41, 0x06, 0x42, +- 0x06, 0x43, 0x06, 0x44, 0x06, 0x45, 0x06, 0x46, 0x06, 0x47, 0x06, 0x49, 0x06, 0x4A, 0x06, 0x79, +- 0x06, 0x7A, 0x06, 0x7B, 0x06, 0x7E, 0x06, 0x7F, 0x06, 0x80, 0x06, 0x83, 0x06, 0x84, 0x06, 0x86, +- 0x06, 0x87, 0x06, 0xA4, 0x06, 0xA6, 0x06, 0xA9, 0x06, 0xAD, 0x06, 0xAF, 0x06, 0xB1, 0x06, 0xB3, +- 0x06, 0xBB, 0x06, 0xBE, 0x06, 0xC1, 0x06, 0xCC, 0x06, 0xD0, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x02, 0x00, 0x62, 0x00, 0x2E, 0xFE, 0x8C, 0xFE, 0x92, 0xFE, 0x98, 0xFE, 0x9C, +- 0xFE, 0xA0, 0xFE, 0xA4, 0xFE, 0xA8, 0xFE, 0xB4, 0xFE, 0xB8, 0xFE, 0xBC, 0xFE, 0xC0, 0xFE, 0xC4, +- 0xFE, 0xC8, 0xFE, 0xCC, 0xFE, 0xD0, 0xFE, 0xD4, 0xFE, 0xD8, 0xFE, 0xDC, 0xFE, 0xE0, 0xFE, 0xE4, +- 0xFE, 0xE8, 0xFE, 0xEC, 0xFB, 0xE9, 0xFE, 0xF4, 0xFB, 0x69, 0xFB, 0x61, 0xFB, 0x55, 0xFB, 0x59, +- 0xFB, 0x65, 0xFB, 0x5D, 0xFB, 0x79, 0xFB, 0x75, 0xFB, 0x7D, 0xFB, 0x81, 0xFB, 0x6D, 0xFB, 0x71, +- 0xFB, 0x91, 0xFB, 0xD6, 0xFB, 0x95, 0xFB, 0x9D, 0xFB, 0x99, 0xFB, 0xA3, 0xFB, 0xAD, 0xFB, 0xA9, +- 0xFB, 0xFF, 0xFB, 0xE7, 0x00, 0x01, 0x00, 0x2E, 0x06, 0x26, 0x06, 0x28, 0x06, 0x2A, 0x06, 0x2B, +- 0x06, 0x2C, 0x06, 0x2D, 0x06, 0x2E, 0x06, 0x33, 0x06, 0x34, 0x06, 0x35, 0x06, 0x36, 0x06, 0x37, +- 0x06, 0x38, 0x06, 0x39, 0x06, 0x3A, 0x06, 0x41, 0x06, 0x42, 0x06, 0x43, 0x06, 0x44, 0x06, 0x45, +- 0x06, 0x46, 0x06, 0x47, 0x06, 0x49, 0x06, 0x4A, 0x06, 0x79, 0x06, 0x7A, 0x06, 0x7B, 0x06, 0x7E, +- 0x06, 0x7F, 0x06, 0x80, 0x06, 0x83, 0x06, 0x84, 0x06, 0x86, 0x06, 0x87, 0x06, 0xA4, 0x06, 0xA6, +- 0x06, 0xA9, 0x06, 0xAD, 0x06, 0xAF, 0x06, 0xB1, 0x06, 0xB3, 0x06, 0xBB, 0x06, 0xBE, 0x06, 0xC1, +- 0x06, 0xCC, 0x06, 0xD0, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x9A, +- 0x00, 0x4A, 0xFE, 0x82, 0xFE, 0x84, 0xFE, 0x86, 0xFE, 0x88, 0xFE, 0x8A, 0xFE, 0x8E, 0xFE, 0x90, +- 0xFE, 0x94, 0xFE, 0x96, 0xFE, 0x9A, 0xFE, 0x9E, 0xFE, 0xA2, 0xFE, 0xA6, 0xFE, 0xAA, 0xFE, 0xAC, +- 0xFE, 0xAE, 0xFE, 0xB0, 0xFE, 0xB2, 0xFE, 0xB6, 0xFE, 0xBA, 0xFE, 0xBE, 0xFE, 0xC2, 0xFE, 0xC6, +- 0xFE, 0xCA, 0xFE, 0xCE, 0xFE, 0xD2, 0xFE, 0xD6, 0xFE, 0xDA, 0xFE, 0xDE, 0xFE, 0xE2, 0xFE, 0xE6, +- 0xFE, 0xEA, 0xFE, 0xEE, 0xFE, 0xF0, 0xFE, 0xF2, 0xFB, 0x51, 0xFB, 0x67, 0xFB, 0x5F, 0xFB, 0x53, +- 0xFB, 0x57, 0xFB, 0x63, 0xFB, 0x5B, 0xFB, 0x77, 0xFB, 0x73, 0xFB, 0x7B, 0xFB, 0x7F, 0xFB, 0x89, +- 0xFB, 0x85, 0xFB, 0x83, 0xFB, 0x87, 0xFB, 0x8D, 0xFB, 0x8B, 0xFB, 0x6B, 0xFB, 0x6F, 0xFB, 0x8F, +- 0xFB, 0xD4, 0xFB, 0x93, 0xFB, 0x9B, 0xFB, 0x97, 0xFB, 0x9F, 0xFB, 0xA1, 0xFB, 0xAB, 0xFB, 0xA5, +- 0xFB, 0xA7, 0xFB, 0xE1, 0xFB, 0xDA, 0xFB, 0xD8, 0xFB, 0xDC, 0xFB, 0xE3, 0xFB, 0xDF, 0xFB, 0xFD, +- 0xFB, 0xE5, 0xFB, 0xAF, 0xFB, 0xB1, 0x00, 0x01, 0x00, 0x4A, 0x06, 0x22, 0x06, 0x23, 0x06, 0x24, +- 0x06, 0x25, 0x06, 0x26, 0x06, 0x27, 0x06, 0x28, 0x06, 0x29, 0x06, 0x2A, 0x06, 0x2B, 0x06, 0x2C, +- 0x06, 0x2D, 0x06, 0x2E, 0x06, 0x2F, 0x06, 0x30, 0x06, 0x31, 0x06, 0x32, 0x06, 0x33, 0x06, 0x34, +- 0x06, 0x35, 0x06, 0x36, 0x06, 0x37, 0x06, 0x38, 0x06, 0x39, 0x06, 0x3A, 0x06, 0x41, 0x06, 0x42, +- 0x06, 0x43, 0x06, 0x44, 0x06, 0x45, 0x06, 0x46, 0x06, 0x47, 0x06, 0x48, 0x06, 0x49, 0x06, 0x4A, +- 0x06, 0x71, 0x06, 0x79, 0x06, 0x7A, 0x06, 0x7B, 0x06, 0x7E, 0x06, 0x7F, 0x06, 0x80, 0x06, 0x83, +- 0x06, 0x84, 0x06, 0x86, 0x06, 0x87, 0x06, 0x88, 0x06, 0x8C, 0x06, 0x8D, 0x06, 0x8E, 0x06, 0x91, +- 0x06, 0x98, 0x06, 0xA4, 0x06, 0xA6, 0x06, 0xA9, 0x06, 0xAD, 0x06, 0xAF, 0x06, 0xB1, 0x06, 0xB3, +- 0x06, 0xBA, 0x06, 0xBB, 0x06, 0xBE, 0x06, 0xC0, 0x06, 0xC1, 0x06, 0xC5, 0x06, 0xC6, 0x06, 0xC7, +- 0x06, 0xC8, 0x06, 0xC9, 0x06, 0xCB, 0x06, 0xCC, 0x06, 0xD0, 0x06, 0xD2, 0x06, 0xD3, 0x00, 0x04, +- 0x00, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x10, 0x98, 0x00, 0x35, 0x00, 0x70, 0x00, 0x7A, +- 0x01, 0x0C, 0x01, 0x86, 0x01, 0xA8, 0x01, 0xB2, 0x02, 0x0C, 0x02, 0x62, 0x03, 0x02, 0x03, 0x8A, +- 0x03, 0xB4, 0x03, 0xF6, 0x04, 0x46, 0x04, 0x8A, 0x04, 0xBC, 0x04, 0xEC, 0x05, 0x26, 0x05, 0x38, +- 0x05, 0x42, 0x05, 0x64, 0x05, 0xF8, 0x06, 0x6C, 0x06, 0xEC, 0x07, 0x80, 0x08, 0x1E, 0x08, 0x56, +- 0x08, 0xBA, 0x08, 0xF2, 0x09, 0x38, 0x09, 0x66, 0x09, 0x78, 0x09, 0x82, 0x09, 0xD4, 0x0A, 0x0E, +- 0x0A, 0x40, 0x0A, 0x70, 0x0A, 0xCC, 0x0A, 0xF2, 0x0B, 0x38, 0x0B, 0x68, 0x0B, 0xDC, 0x0C, 0x2A, +- 0x0C, 0xD6, 0x0D, 0x72, 0x0E, 0x16, 0x0E, 0x50, 0x0E, 0xC8, 0x0F, 0x5A, 0x0F, 0xA8, 0x0F, 0xB6, +- 0x0F, 0xC0, 0x0F, 0xCA, 0x10, 0x2E, 0x00, 0x01, 0x00, 0x04, 0xFB, 0xDD, 0x00, 0x02, 0x06, 0x74, +- 0x00, 0x12, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, +- 0x00, 0x50, 0x00, 0x56, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x7A, +- 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, 0xFB, 0xEC, 0x00, 0x02, 0x00, 0x01, 0xFB, 0xF0, 0x00, 0x02, +- 0xFB, 0xD8, 0xFB, 0xF2, 0x00, 0x02, 0xFB, 0xDA, 0xFB, 0xF4, 0x00, 0x02, 0xFB, 0xDC, 0xFB, 0xF6, +- 0x00, 0x02, 0xFB, 0xE5, 0xFB, 0xF8, 0x00, 0x02, 0xFB, 0xE7, 0xFB, 0xEA, 0x00, 0x02, 0xFE, 0x8E, +- 0xFC, 0x00, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0x97, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x01, 0x00, 0x02, +- 0xFE, 0xA2, 0xFC, 0x98, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x99, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x02, +- 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0x9A, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x9B, 0x00, 0x02, 0xFE, 0xEC, +- 0xFB, 0xEE, 0x00, 0x02, 0xFE, 0xEE, 0xFB, 0xF9, 0x00, 0x02, 0xFE, 0xF0, 0xFB, 0xFB, 0x00, 0x02, +- 0xFE, 0xF2, 0x00, 0x0F, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, +- 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, +- 0x00, 0x74, 0xFB, 0xED, 0x00, 0x02, 0x00, 0x01, 0xFB, 0xF1, 0x00, 0x02, 0xFB, 0xD8, 0xFB, 0xF3, +- 0x00, 0x02, 0xFB, 0xDA, 0xFB, 0xF5, 0x00, 0x02, 0xFB, 0xDC, 0xFB, 0xF7, 0x00, 0x02, 0xFB, 0xE5, +- 0xFB, 0xEB, 0x00, 0x02, 0xFE, 0x8E, 0xFC, 0x64, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x65, 0x00, 0x02, +- 0xFE, 0xB0, 0xFC, 0x66, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xDF, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x67, +- 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xE0, 0x00, 0x02, 0xFE, 0xEC, 0xFB, 0xEF, 0x00, 0x02, 0xFE, 0xEE, +- 0xFB, 0xFA, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x69, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x03, 0x00, 0x08, +- 0x00, 0x0E, 0x00, 0x18, 0xFD, 0x3D, 0x00, 0x02, 0x06, 0x4B, 0xFD, 0xF3, 0x00, 0x04, 0xFE, 0xDB, +- 0xFE, 0x92, 0xFE, 0xAE, 0xFD, 0xF2, 0x00, 0x04, 0xFE, 0xDF, 0xFE, 0xE0, 0xFE, 0xEA, 0x00, 0x01, +- 0x00, 0x04, 0xFD, 0x3C, 0x00, 0x02, 0x06, 0x4B, 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, +- 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, +- 0xFC, 0x05, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0x9C, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x06, 0x00, 0x02, +- 0xFE, 0xA2, 0xFC, 0x9D, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x07, 0x00, 0x02, 0xFE, 0xA6, 0xFC, 0x9E, +- 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x08, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0x9F, 0x00, 0x02, 0xFE, 0xE4, +- 0xFC, 0xA0, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x09, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x0A, 0x00, 0x02, +- 0xFE, 0xF2, 0x00, 0x0A, 0x00, 0x16, 0x00, 0x1E, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, +- 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0xFD, 0xC2, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, +- 0xFD, 0x9E, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF2, 0xFC, 0x6A, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x6B, +- 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x6C, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xE1, 0x00, 0x02, 0xFE, 0xE4, +- 0xFC, 0x6D, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xE2, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x6E, 0x00, 0x02, +- 0xFE, 0xF0, 0xFC, 0x6F, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x12, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, +- 0x00, 0x3A, 0x00, 0x40, 0x00, 0x48, 0x00, 0x50, 0x00, 0x56, 0x00, 0x5C, 0x00, 0x64, 0x00, 0x6A, +- 0x00, 0x70, 0x00, 0x78, 0x00, 0x80, 0x00, 0x88, 0x00, 0x8E, 0x00, 0x94, 0x00, 0x9A, 0xFC, 0x0B, +- 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x50, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE4, 0xFC, 0xA1, 0x00, 0x02, +- 0xFE, 0xA0, 0xFC, 0x0C, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x52, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xA0, +- 0xFD, 0x53, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE4, 0xFC, 0xA2, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x0D, +- 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x54, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xA3, 0x00, 0x02, +- 0xFE, 0xA8, 0xFC, 0x0E, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x55, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA0, +- 0xFD, 0x56, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA4, 0xFD, 0x57, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA8, +- 0xFC, 0xA4, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xA5, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x0F, 0x00, 0x02, +- 0xFE, 0xF0, 0xFC, 0x10, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0F, 0x00, 0x20, 0x00, 0x28, 0x00, 0x30, +- 0x00, 0x38, 0x00, 0x40, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x62, 0x00, 0x6A, +- 0x00, 0x70, 0x00, 0x76, 0x00, 0x7C, 0x00, 0x82, 0xFD, 0xA0, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF0, +- 0xFD, 0x9F, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0x51, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0x9E, +- 0xFD, 0xA2, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF0, 0xFD, 0xA1, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF2, +- 0xFC, 0x70, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x71, 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x72, 0x00, 0x02, +- 0xFE, 0xE2, 0xFD, 0xA4, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF0, 0xFD, 0xA3, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xF2, 0xFC, 0xE3, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x73, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xE4, +- 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x74, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x75, 0x00, 0x02, 0xFE, 0xF2, +- 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0xFC, 0x11, 0x00, 0x02, +- 0xFE, 0x9E, 0xFC, 0x12, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xA6, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x13, +- 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x14, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, +- 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0xFC, 0x76, 0x00, 0x02, +- 0xFE, 0xAE, 0xFC, 0x77, 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x78, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xE5, +- 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x79, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xE6, 0x00, 0x02, 0xFE, 0xEC, +- 0xFC, 0x7A, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x7B, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x08, 0x00, 0x12, +- 0x00, 0x18, 0x00, 0x1E, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, 0xFC, 0x15, +- 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xA7, 0x00, 0x02, 0xFE, 0xA4, 0xFD, 0xFB, 0x00, 0x08, 0xFE, 0xDE, +- 0x00, 0x20, 0xFE, 0x9F, 0xFE, 0xE0, 0xFE, 0x8E, 0xFE, 0xDF, 0xFE, 0xEA, 0xFC, 0x16, 0x00, 0x02, +- 0xFE, 0xE2, 0xFD, 0x59, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA4, 0xFC, 0xA8, 0x00, 0x02, 0xFE, 0xE4, +- 0xFD, 0x01, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x02, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x07, 0x00, 0x10, +- 0x00, 0x18, 0x00, 0x20, 0x00, 0x28, 0x00, 0x30, 0x00, 0x38, 0x00, 0x3E, 0xFD, 0xA6, 0x00, 0x03, +- 0xFE, 0xA4, 0xFE, 0xF0, 0xFD, 0xBE, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0x58, 0x00, 0x03, +- 0xFE, 0xE4, 0xFE, 0xA2, 0xFD, 0xA7, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF0, 0xFD, 0xA5, 0x00, 0x03, +- 0xFE, 0xE4, 0xFE, 0xF2, 0xFD, 0x1D, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x1E, 0x00, 0x02, 0xFE, 0xF2, +- 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0xFC, 0x17, +- 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xA9, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x18, 0x00, 0x02, 0xFE, 0xE2, +- 0xFC, 0xAA, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xFF, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x00, 0x00, 0x02, +- 0xFE, 0xF2, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0xFD, 0xBF, +- 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0x5B, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF0, 0xFD, 0x5A, +- 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFD, 0x1B, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x1C, 0x00, 0x02, +- 0xFE, 0xF2, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, +- 0x00, 0x34, 0xFC, 0x19, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xAB, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x1A, +- 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0x1B, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xAC, 0x00, 0x02, 0xFE, 0xE4, +- 0xFD, 0x03, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x04, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x02, 0x00, 0x06, +- 0x00, 0x0C, 0xFD, 0x1F, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x20, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x01, +- 0x00, 0x04, 0xFC, 0x5B, 0x00, 0x02, 0x06, 0x70, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x18, +- 0xFC, 0x5C, 0x00, 0x02, 0x06, 0x70, 0xFD, 0xFC, 0x00, 0x04, 0xFB, 0xFE, 0xFE, 0x8E, 0xFE, 0xDD, +- 0xFD, 0xF6, 0x00, 0x04, 0xFE, 0xB3, 0xFE, 0xEE, 0xFE, 0xDD, 0x00, 0x11, 0x00, 0x24, 0x00, 0x2A, +- 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x5E, +- 0x00, 0x64, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7C, 0x00, 0x82, 0x00, 0x88, 0x00, 0x8E, 0xFC, 0x1C, +- 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x5D, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xA4, 0xFC, 0xAD, 0x00, 0x02, +- 0xFE, 0xA0, 0xFC, 0x1D, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x5C, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xA0, +- 0xFC, 0xAE, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x1E, 0x00, 0x02, 0xFE, 0xA6, 0xFC, 0xAF, 0x00, 0x02, +- 0xFE, 0xA8, 0xFD, 0x0E, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x1F, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x61, +- 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA0, 0xFD, 0x60, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA4, 0xFD, 0x63, +- 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xB0, 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x31, 0x00, 0x02, +- 0xFE, 0xEC, 0xFC, 0xFB, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0xFC, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0D, +- 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x38, 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, +- 0x00, 0x54, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, 0xFD, 0x5E, 0x00, 0x03, 0xFE, 0xA0, +- 0xFE, 0xF0, 0xFD, 0x34, 0x00, 0x02, 0xFE, 0xA0, 0xFD, 0x35, 0x00, 0x02, 0xFE, 0xA4, 0xFD, 0xA8, +- 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF0, 0xFD, 0xC6, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF2, 0xFD, 0x36, +- 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x2A, 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0x5F, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xA2, 0xFD, 0x62, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFC, 0xE7, 0x00, 0x02, 0xFE, 0xE4, +- 0xFC, 0xE8, 0x00, 0x02, 0xFE, 0xEC, 0xFD, 0x17, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x18, 0x00, 0x02, +- 0xFE, 0xF2, 0x00, 0x0F, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x3A, 0x00, 0x40, +- 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x60, 0x00, 0x68, 0x00, 0x6E, 0x00, 0x74, +- 0x00, 0x7A, 0xFD, 0x09, 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x2D, 0x00, 0x02, 0xFE, 0xA0, 0xFD, 0x0A, +- 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x68, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE4, 0xFD, 0x2E, 0x00, 0x02, +- 0xFE, 0xA4, 0xFD, 0x0B, 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x2F, 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x0D, +- 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0x0C, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x6B, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xA8, 0xFD, 0x6D, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFD, 0x30, 0x00, 0x02, 0xFE, 0xE4, +- 0xFD, 0x32, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0xFD, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0xFE, 0x00, 0x02, +- 0xFE, 0xF2, 0x00, 0x11, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, +- 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7C, +- 0x00, 0x82, 0x00, 0x88, 0x00, 0x8E, 0xFD, 0x25, 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x69, 0x00, 0x03, +- 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0x37, 0x00, 0x02, 0xFE, 0xA0, 0xFD, 0x26, 0x00, 0x02, 0xFE, 0xA2, +- 0xFD, 0x67, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE2, 0xFD, 0xAA, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, +- 0xFD, 0x38, 0x00, 0x02, 0xFE, 0xA4, 0xFD, 0x27, 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x39, 0x00, 0x02, +- 0xFE, 0xA8, 0xFD, 0x29, 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0x28, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x6A, +- 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA6, 0xFD, 0x6C, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFC, 0xE9, +- 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xEA, 0x00, 0x02, 0xFE, 0xEC, 0xFD, 0x19, 0x00, 0x02, 0xFE, 0xF0, +- 0xFD, 0x1A, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0E, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2C, 0x00, 0x32, +- 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x50, 0x00, 0x76, 0x00, 0x7E, 0x00, 0x84, 0x00, 0x8C, +- 0x00, 0x92, 0x00, 0x98, 0xFC, 0x20, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x65, 0x00, 0x03, 0xFE, 0xA4, +- 0xFE, 0xA4, 0xFC, 0xB1, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0xB2, 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x0F, +- 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0xF0, 0x00, 0x03, 0xFE, 0xE0, 0xFB, 0xAF, 0xFD, 0xF5, 0x00, 0x04, +- 0xFE, 0xE0, 0xFE, 0xCC, 0xFE, 0xE2, 0xFD, 0xFA, 0x00, 0x12, 0xFE, 0xE0, 0xFE, 0xF0, 0x00, 0x20, +- 0xFE, 0x8D, 0xFE, 0xDF, 0xFE, 0xE0, 0xFE, 0xEA, 0x00, 0x20, 0xFE, 0xCB, 0xFE, 0xE0, 0xFE, 0xF4, +- 0xFE, 0xEA, 0x00, 0x20, 0xFE, 0xED, 0xFE, 0xB3, 0xFE, 0xE0, 0xFE, 0xE2, 0xFD, 0xF9, 0x00, 0x03, +- 0xFE, 0xE0, 0xFE, 0xF0, 0xFC, 0x21, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xC5, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xE4, 0xFC, 0xB3, 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x05, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x06, +- 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x16, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2C, +- 0x00, 0x32, 0xFD, 0x64, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xA2, 0xFD, 0xA9, 0x00, 0x03, 0xFE, 0xA4, +- 0xFE, 0xF2, 0xFD, 0x2B, 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0x66, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, +- 0xFD, 0x21, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x22, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0C, 0x00, 0x1A, +- 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, +- 0x00, 0x52, 0x00, 0x58, 0x00, 0x5E, 0xFC, 0x22, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xB4, 0x00, 0x02, +- 0xFE, 0xA0, 0xFC, 0x23, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xB5, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x24, +- 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x70, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xB6, 0x00, 0x02, +- 0xFE, 0xA8, 0xFD, 0x10, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x25, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xB7, +- 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x07, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x08, 0x00, 0x02, 0xFE, 0xF2, +- 0x00, 0x06, 0x00, 0x0E, 0x00, 0x16, 0x00, 0x1E, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0xFD, 0x6E, +- 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF0, 0xFD, 0xAB, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0x6F, +- 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE2, 0xFD, 0x2C, 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0x23, 0x00, 0x02, +- 0xFE, 0xF0, 0xFD, 0x24, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, +- 0x00, 0x24, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3A, 0x00, 0x40, 0xFC, 0x26, 0x00, 0x02, 0xFE, 0xA2, +- 0xFC, 0xB8, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x27, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x72, 0x00, 0x03, +- 0xFE, 0xE4, 0xFE, 0xA4, 0xFD, 0x73, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFD, 0x33, 0x00, 0x02, +- 0xFE, 0xE4, 0xFC, 0xF5, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0xF6, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x05, +- 0x00, 0x0C, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0xFD, 0x71, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xA2, 0xFD, 0x74, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFD, 0x3A, 0x00, 0x02, 0xFE, 0xE4, +- 0xFD, 0x11, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x12, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x02, 0x00, 0x06, +- 0x00, 0x0C, 0xFC, 0x28, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xB9, 0x00, 0x02, 0xFE, 0xE4, 0x00, 0x01, +- 0x00, 0x04, 0xFD, 0x3B, 0x00, 0x02, 0xFE, 0xE4, 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x22, +- 0x00, 0x28, 0x00, 0x32, 0x00, 0x38, 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, 0xFC, 0x29, 0x00, 0x02, +- 0xFE, 0x9E, 0xFD, 0xC4, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE4, 0xFC, 0xBA, 0x00, 0x02, 0xFE, 0xA0, +- 0xFD, 0xF7, 0x00, 0x04, 0xFE, 0xE0, 0xFE, 0xF4, 0xFE, 0xEA, 0xFC, 0x2A, 0x00, 0x02, 0xFE, 0xE2, +- 0xFD, 0x77, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xBB, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xF7, +- 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0xF8, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x16, +- 0x00, 0x1E, 0x00, 0x26, 0x00, 0x2E, 0x00, 0x34, 0xFD, 0x75, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE2, +- 0xFD, 0x76, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFD, 0x78, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF0, +- 0xFD, 0xB6, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFD, 0x13, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x14, +- 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, +- 0x00, 0x2C, 0xFC, 0x2B, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xBC, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x2C, +- 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xBD, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xF9, 0x00, 0x02, 0xFE, 0xF0, +- 0xFC, 0xFA, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x24, +- 0x00, 0x2A, 0xFD, 0x79, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFD, 0x7B, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xF0, 0xFD, 0x7A, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFD, 0x15, 0x00, 0x02, 0xFE, 0xF0, +- 0xFD, 0x16, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, +- 0x00, 0x30, 0x00, 0x36, 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, 0xFC, 0x2D, +- 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xBE, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x2E, 0x00, 0x02, 0xFE, 0xA2, +- 0xFC, 0xBF, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x2F, 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x7D, 0x00, 0x03, +- 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xC0, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x30, 0x00, 0x02, 0xFE, 0xE2, +- 0xFC, 0xC1, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x31, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x32, 0x00, 0x02, +- 0xFE, 0xF2, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x12, 0x00, 0x1A, 0x00, 0x20, 0xFD, 0x7C, 0x00, 0x03, +- 0xFE, 0xA8, 0xFE, 0xE2, 0xFD, 0xC1, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0x7C, 0x00, 0x02, +- 0xFE, 0xF0, 0xFC, 0x7D, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, +- 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3A, 0x00, 0x40, 0xFC, 0x33, 0x00, 0x02, 0xFE, 0xA2, +- 0xFC, 0xC2, 0x00, 0x02, 0xFE, 0xA4, 0xFD, 0xF1, 0x00, 0x03, 0xFE, 0xE0, 0xFB, 0xAF, 0xFC, 0x34, +- 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xB4, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA4, 0xFC, 0xC3, 0x00, 0x02, +- 0xFE, 0xE4, 0xFC, 0x35, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x36, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x05, +- 0x00, 0x0C, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0xFD, 0x7E, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xA2, 0xFD, 0x7F, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFD, 0xB2, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xF2, 0xFC, 0x7E, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x7F, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0E, +- 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, +- 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, 0xFC, 0x37, 0x00, 0x02, +- 0xFE, 0x8E, 0xFC, 0x38, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xC4, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x39, +- 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xC5, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x3A, 0x00, 0x02, 0xFE, 0xA6, +- 0xFC, 0xC6, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x3B, 0x00, 0x02, 0xFE, 0xDE, 0xFC, 0xC7, 0x00, 0x02, +- 0xFE, 0xE0, 0xFC, 0x3C, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xC3, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, +- 0xFC, 0xC8, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x3D, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x3E, 0x00, 0x02, +- 0xFE, 0xF2, 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, +- 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0xFC, 0x80, 0x00, 0x02, 0xFE, 0x8E, 0xFC, 0x81, 0x00, 0x02, +- 0xFE, 0xDE, 0xFC, 0xEB, 0x00, 0x02, 0xFE, 0xE0, 0xFC, 0x82, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xBB, +- 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFD, 0xB7, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0xEC, +- 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x83, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x84, 0x00, 0x02, 0xFE, 0xF2, +- 0x00, 0x14, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x50, +- 0x00, 0x58, 0x00, 0x5E, 0x00, 0x64, 0x00, 0x6C, 0x00, 0x72, 0x00, 0x78, 0x00, 0x80, 0x00, 0x86, +- 0x00, 0x8C, 0x00, 0x94, 0x00, 0x9A, 0x00, 0xA0, 0x00, 0xA6, 0xFE, 0xF5, 0x00, 0x02, 0xFE, 0x82, +- 0xFE, 0xF7, 0x00, 0x02, 0xFE, 0x84, 0xFE, 0xF9, 0x00, 0x02, 0xFE, 0x88, 0xFE, 0xFB, 0x00, 0x02, +- 0xFE, 0x8E, 0xFC, 0x3F, 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x83, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xA0, +- 0xFD, 0xBA, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE4, 0xFC, 0xC9, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x40, +- 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0xB5, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE4, 0xFC, 0xCA, 0x00, 0x02, +- 0xFE, 0xA4, 0xFC, 0x41, 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x86, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE4, +- 0xFC, 0xCB, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x42, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x88, 0x00, 0x03, +- 0xFE, 0xE4, 0xFE, 0xA4, 0xFC, 0xCC, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xCD, 0x00, 0x02, 0xFE, 0xEC, +- 0xFC, 0x43, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x44, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x11, 0x00, 0x24, +- 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, +- 0x00, 0x64, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7A, 0x00, 0x82, 0x00, 0x8A, 0x00, 0x90, 0x00, 0x96, +- 0xFE, 0xF6, 0x00, 0x02, 0xFE, 0x82, 0xFE, 0xF8, 0x00, 0x02, 0xFE, 0x84, 0xFE, 0xFA, 0x00, 0x02, +- 0xFE, 0x88, 0xFE, 0xFC, 0x00, 0x02, 0xFE, 0x8E, 0xFD, 0x84, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0x9E, +- 0xFD, 0xBC, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE2, 0xFD, 0xAC, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, +- 0xFD, 0x80, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE2, 0xFD, 0x82, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF0, +- 0xFD, 0x81, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0x85, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE2, +- 0xFC, 0x85, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x87, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA2, 0xFD, 0xAD, +- 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0xED, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x86, 0x00, 0x02, +- 0xFE, 0xF0, 0xFC, 0x87, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x12, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, +- 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x58, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x70, +- 0x00, 0x76, 0x00, 0x7E, 0x00, 0x86, 0x00, 0x8C, 0x00, 0x92, 0x00, 0x98, 0x00, 0x9E, 0xFC, 0x45, +- 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x8C, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xA4, 0xFD, 0x92, 0x00, 0x03, +- 0xFE, 0xA0, 0xFE, 0xA8, 0xFD, 0x8D, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE4, 0xFC, 0xCE, 0x00, 0x02, +- 0xFE, 0xA0, 0xFC, 0x46, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x89, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xA0, +- 0xFD, 0xF4, 0x00, 0x04, 0xFE, 0xA4, 0xFE, 0xE4, 0xFE, 0xAA, 0xFD, 0x8A, 0x00, 0x03, 0xFE, 0xA4, +- 0xFE, 0xE4, 0xFC, 0xCF, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x47, 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x8E, +- 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xA0, 0xFD, 0x8F, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xD0, +- 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x48, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xD1, 0x00, 0x02, 0xFE, 0xE4, +- 0xFC, 0x49, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x4A, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, +- 0x00, 0x14, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2C, 0x00, 0x32, 0xFC, 0x88, 0x00, 0x02, 0xFE, 0x8E, +- 0xFD, 0xC0, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0x8B, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, +- 0xFD, 0xB9, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF2, 0xFC, 0x89, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xB1, +- 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0x00, 0x0E, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2C, 0x00, 0x34, +- 0x00, 0x3A, 0x00, 0x40, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, +- 0x00, 0x6C, 0x00, 0x72, 0xFC, 0x4B, 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0xB8, 0x00, 0x03, 0xFE, 0xA0, +- 0xFE, 0xA4, 0xFD, 0x98, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE4, 0xFC, 0xD2, 0x00, 0x02, 0xFE, 0xA0, +- 0xFC, 0x4C, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x95, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE4, 0xFC, 0xD3, +- 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x4D, 0x00, 0x02, 0xFE, 0xA6, 0xFC, 0xD4, 0x00, 0x02, 0xFE, 0xA8, +- 0xFC, 0x4E, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xD5, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xD6, 0x00, 0x02, +- 0xFE, 0xEC, 0xFC, 0x4F, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x50, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x10, +- 0x00, 0x22, 0x00, 0x2A, 0x00, 0x32, 0x00, 0x3A, 0x00, 0x42, 0x00, 0x4A, 0x00, 0x52, 0x00, 0x58, +- 0x00, 0x5E, 0x00, 0x64, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7A, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, +- 0xFD, 0xBD, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xA2, 0xFD, 0x97, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE2, +- 0xFD, 0x99, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF0, 0xFD, 0xC7, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, +- 0xFD, 0x96, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF0, 0xFD, 0xB3, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, +- 0xFC, 0x8A, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x8B, 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x8C, 0x00, 0x02, +- 0xFE, 0xE2, 0xFD, 0x9B, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF0, 0xFD, 0x9A, 0x00, 0x03, 0xFE, 0xE4, +- 0xFE, 0xF2, 0xFC, 0xEE, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x8D, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xEF, +- 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x8E, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x8F, 0x00, 0x02, 0xFE, 0xF2, +- 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3C, +- 0x00, 0x42, 0x00, 0x48, 0xFC, 0xD9, 0x00, 0x02, 0x06, 0x70, 0xFC, 0x51, 0x00, 0x02, 0xFE, 0x9E, +- 0xFC, 0xD7, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x52, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x93, 0x00, 0x03, +- 0xFE, 0xE4, 0xFE, 0xA0, 0xFD, 0x94, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xD8, 0x00, 0x02, +- 0xFE, 0xE4, 0xFC, 0x53, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x54, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x01, +- 0x00, 0x04, 0xFD, 0xF8, 0x00, 0x04, 0xFE, 0xB3, 0xFE, 0xE0, 0xFE, 0xE2, 0x00, 0x01, 0x00, 0x04, +- 0xFC, 0x5D, 0x00, 0x02, 0x06, 0x70, 0x00, 0x01, 0x00, 0x04, 0xFC, 0x90, 0x00, 0x02, 0x06, 0x70, +- 0x00, 0x0C, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, +- 0x00, 0x44, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x5E, 0xFC, 0x55, 0x00, 0x02, 0xFE, 0x9E, +- 0xFC, 0xDA, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x56, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xDB, 0x00, 0x02, +- 0xFE, 0xA4, 0xFC, 0x57, 0x00, 0x02, 0xFE, 0xA6, 0xFC, 0xDC, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x58, +- 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x9D, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xDD, 0x00, 0x02, +- 0xFE, 0xE4, 0xFC, 0xDE, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x59, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x5A, +- 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0C, 0x00, 0x1A, 0x00, 0x22, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, +- 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x5E, 0x00, 0x64, 0xFD, 0xAF, +- 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0xAE, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFC, 0x91, +- 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x92, 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x93, 0x00, 0x02, 0xFE, 0xE2, +- 0xFD, 0x9C, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFD, 0xB0, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, +- 0xFC, 0xF0, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x94, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xF1, 0x00, 0x02, +- 0xFE, 0xEC, 0xFC, 0x95, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x96, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x01, +- 0x00, 0x35, 0xFB, 0xD7, 0xFE, 0x8B, 0xFE, 0x8C, 0xFE, 0x8D, 0xFE, 0x8E, 0xFE, 0x91, 0xFE, 0x92, +- 0xFE, 0x97, 0xFE, 0x98, 0xFE, 0x9B, 0xFE, 0x9C, 0xFE, 0x9F, 0xFE, 0xA0, 0xFE, 0xA3, 0xFE, 0xA4, +- 0xFE, 0xA7, 0xFE, 0xA8, 0xFE, 0xAB, 0xFE, 0xAD, 0xFE, 0xB3, 0xFE, 0xB4, 0xFE, 0xB7, 0xFE, 0xB8, +- 0xFE, 0xBB, 0xFE, 0xBC, 0xFE, 0xBF, 0xFE, 0xC0, 0xFE, 0xC3, 0xFE, 0xC4, 0xFE, 0xC7, 0xFE, 0xC8, +- 0xFE, 0xCB, 0xFE, 0xCC, 0xFE, 0xCF, 0xFE, 0xD0, 0xFE, 0xD3, 0xFE, 0xD4, 0xFE, 0xD7, 0xFE, 0xD8, +- 0xFE, 0xDB, 0xFE, 0xDC, 0xFE, 0xDF, 0xFE, 0xE0, 0xFE, 0xE3, 0xFE, 0xE4, 0xFE, 0xE7, 0xFE, 0xE8, +- 0xFE, 0xEB, 0xFE, 0xED, 0xFE, 0xEF, 0xFE, 0xF0, 0xFE, 0xF3, 0xFE, 0xF4, 0x00, 0x04, 0x00, 0x00, +- 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x3E, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x18, 0x00, 0x22, +- 0x00, 0x2C, 0x00, 0x01, 0x00, 0x04, 0x09, 0xDC, 0x00, 0x02, 0x09, 0xBC, 0x00, 0x01, 0x00, 0x04, +- 0x09, 0xDD, 0x00, 0x02, 0x09, 0xBC, 0x00, 0x01, 0x00, 0x04, 0x09, 0xDF, 0x00, 0x02, 0x09, 0xBC, +- 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x09, 0xCB, 0x00, 0x02, 0x09, 0xBE, 0x09, 0xCC, 0x00, 0x02, +- 0x09, 0xD7, 0x00, 0x01, 0x00, 0x04, 0x09, 0xA1, 0x09, 0xA2, 0x09, 0xAF, 0x09, 0xC7, 0x00, 0x02, +- 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x2E, 0x00, 0x05, 0x00, 0x10, 0x00, 0x16, +- 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x02, 0x09, 0xC7, 0x09, 0xBE, 0x00, 0x02, 0x09, 0xC7, +- 0x09, 0xD7, 0x00, 0x02, 0x09, 0xA1, 0x09, 0xBC, 0x00, 0x02, 0x09, 0xA2, 0x09, 0xBC, 0x00, 0x02, +- 0x09, 0xAF, 0x09, 0xBC, 0x00, 0x01, 0x00, 0x05, 0x09, 0xCB, 0x09, 0xCC, 0x09, 0xDC, 0x09, 0xDD, +- 0x09, 0xDF, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x02, 0x66, 0x00, 0x20, ++ 0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x24, 0x00, 0x4A, 0x00, 0xC0, 0x01, 0x22, 0x01, 0xEC, ++ 0x02, 0xB6, 0x03, 0xF0, 0x14, 0xFE, 0x15, 0x26, 0x15, 0x4C, 0x17, 0xFE, 0x1A, 0x74, 0x1A, 0xB0, ++ 0x1A, 0xE0, 0x4E, 0xDA, 0x8B, 0xBC, 0x8D, 0x2A, 0x8E, 0x4A, 0x8E, 0xA0, 0x8E, 0xFC, 0x90, 0xA2, ++ 0x91, 0xEA, 0xB1, 0xA2, 0xD5, 0x1E, 0xD5, 0x54, 0xD5, 0x84, 0xD5, 0xA4, 0xD5, 0xC0, 0xD5, 0xF0, ++ 0xD6, 0x20, 0xD6, 0x68, 0xD6, 0xBA, 0xD6, 0xFE, 0xD7, 0x38, 0xD7, 0x58, 0xD7, 0x74, 0xD8, 0x20, ++ 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x5E, 0x00, 0x06, 0x00, 0x12, ++ 0x00, 0x2C, 0x00, 0x36, 0x00, 0x40, 0x00, 0x4A, 0x00, 0x54, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, ++ 0x00, 0x14, 0x06, 0x22, 0x00, 0x02, 0x06, 0x53, 0x06, 0x23, 0x00, 0x02, 0x06, 0x54, 0x06, 0x25, ++ 0x00, 0x02, 0x06, 0x55, 0x00, 0x01, 0x00, 0x04, 0x06, 0x24, 0x00, 0x02, 0x06, 0x54, 0x00, 0x01, ++ 0x00, 0x04, 0x06, 0x26, 0x00, 0x02, 0x06, 0x54, 0x00, 0x01, 0x00, 0x04, 0x06, 0xC2, 0x00, 0x02, ++ 0x06, 0x54, 0x00, 0x01, 0x00, 0x04, 0x06, 0xD3, 0x00, 0x02, 0x06, 0x54, 0x00, 0x01, 0x00, 0x04, ++ 0x06, 0xC0, 0x00, 0x02, 0x06, 0x54, 0x00, 0x01, 0x00, 0x06, 0x06, 0x27, 0x06, 0x48, 0x06, 0x4A, ++ 0x06, 0xC1, 0x06, 0xD2, 0x06, 0xD5, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, ++ 0x00, 0x46, 0x00, 0x08, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, ++ 0x00, 0x3A, 0x00, 0x40, 0x00, 0x02, 0x06, 0x27, 0x06, 0x53, 0x00, 0x02, 0x06, 0x27, 0x06, 0x54, ++ 0x00, 0x02, 0x06, 0x48, 0x06, 0x54, 0x00, 0x02, 0x06, 0x27, 0x06, 0x55, 0x00, 0x02, 0x06, 0x4A, ++ 0x06, 0x54, 0x00, 0x02, 0x06, 0xD5, 0x06, 0x54, 0x00, 0x02, 0x06, 0xC1, 0x06, 0x54, 0x00, 0x02, ++ 0x06, 0xD2, 0x06, 0x54, 0x00, 0x01, 0x00, 0x08, 0x06, 0x22, 0x06, 0x23, 0x06, 0x24, 0x06, 0x25, ++ 0x06, 0x26, 0x06, 0xC0, 0x06, 0xC2, 0x06, 0xD3, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, ++ 0x00, 0x02, 0x00, 0x62, 0x00, 0x2E, 0xFE, 0x8B, 0xFE, 0x91, 0xFE, 0x97, 0xFE, 0x9B, 0xFE, 0x9F, ++ 0xFE, 0xA3, 0xFE, 0xA7, 0xFE, 0xB3, 0xFE, 0xB7, 0xFE, 0xBB, 0xFE, 0xBF, 0xFE, 0xC3, 0xFE, 0xC7, ++ 0xFE, 0xCB, 0xFE, 0xCF, 0xFE, 0xD3, 0xFE, 0xD7, 0xFE, 0xDB, 0xFE, 0xDF, 0xFE, 0xE3, 0xFE, 0xE7, ++ 0xFE, 0xEB, 0xFB, 0xE8, 0xFE, 0xF3, 0xFB, 0x68, 0xFB, 0x60, 0xFB, 0x54, 0xFB, 0x58, 0xFB, 0x64, ++ 0xFB, 0x5C, 0xFB, 0x78, 0xFB, 0x74, 0xFB, 0x7C, 0xFB, 0x80, 0xFB, 0x6C, 0xFB, 0x70, 0xFB, 0x90, ++ 0xFB, 0xD5, 0xFB, 0x94, 0xFB, 0x9C, 0xFB, 0x98, 0xFB, 0xA2, 0xFB, 0xAC, 0xFB, 0xA8, 0xFB, 0xFE, ++ 0xFB, 0xE6, 0x00, 0x01, 0x00, 0x2E, 0x06, 0x26, 0x06, 0x28, 0x06, 0x2A, 0x06, 0x2B, 0x06, 0x2C, ++ 0x06, 0x2D, 0x06, 0x2E, 0x06, 0x33, 0x06, 0x34, 0x06, 0x35, 0x06, 0x36, 0x06, 0x37, 0x06, 0x38, ++ 0x06, 0x39, 0x06, 0x3A, 0x06, 0x41, 0x06, 0x42, 0x06, 0x43, 0x06, 0x44, 0x06, 0x45, 0x06, 0x46, ++ 0x06, 0x47, 0x06, 0x49, 0x06, 0x4A, 0x06, 0x79, 0x06, 0x7A, 0x06, 0x7B, 0x06, 0x7E, 0x06, 0x7F, ++ 0x06, 0x80, 0x06, 0x83, 0x06, 0x84, 0x06, 0x86, 0x06, 0x87, 0x06, 0xA4, 0x06, 0xA6, 0x06, 0xA9, ++ 0x06, 0xAD, 0x06, 0xAF, 0x06, 0xB1, 0x06, 0xB3, 0x06, 0xBB, 0x06, 0xBE, 0x06, 0xC1, 0x06, 0xCC, ++ 0x06, 0xD0, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x62, 0x00, 0x2E, ++ 0xFE, 0x8C, 0xFE, 0x92, 0xFE, 0x98, 0xFE, 0x9C, 0xFE, 0xA0, 0xFE, 0xA4, 0xFE, 0xA8, 0xFE, 0xB4, ++ 0xFE, 0xB8, 0xFE, 0xBC, 0xFE, 0xC0, 0xFE, 0xC4, 0xFE, 0xC8, 0xFE, 0xCC, 0xFE, 0xD0, 0xFE, 0xD4, ++ 0xFE, 0xD8, 0xFE, 0xDC, 0xFE, 0xE0, 0xFE, 0xE4, 0xFE, 0xE8, 0xFE, 0xEC, 0xFB, 0xE9, 0xFE, 0xF4, ++ 0xFB, 0x69, 0xFB, 0x61, 0xFB, 0x55, 0xFB, 0x59, 0xFB, 0x65, 0xFB, 0x5D, 0xFB, 0x79, 0xFB, 0x75, ++ 0xFB, 0x7D, 0xFB, 0x81, 0xFB, 0x6D, 0xFB, 0x71, 0xFB, 0x91, 0xFB, 0xD6, 0xFB, 0x95, 0xFB, 0x9D, ++ 0xFB, 0x99, 0xFB, 0xA3, 0xFB, 0xAD, 0xFB, 0xA9, 0xFB, 0xFF, 0xFB, 0xE7, 0x00, 0x01, 0x00, 0x2E, ++ 0x06, 0x26, 0x06, 0x28, 0x06, 0x2A, 0x06, 0x2B, 0x06, 0x2C, 0x06, 0x2D, 0x06, 0x2E, 0x06, 0x33, ++ 0x06, 0x34, 0x06, 0x35, 0x06, 0x36, 0x06, 0x37, 0x06, 0x38, 0x06, 0x39, 0x06, 0x3A, 0x06, 0x41, ++ 0x06, 0x42, 0x06, 0x43, 0x06, 0x44, 0x06, 0x45, 0x06, 0x46, 0x06, 0x47, 0x06, 0x49, 0x06, 0x4A, ++ 0x06, 0x79, 0x06, 0x7A, 0x06, 0x7B, 0x06, 0x7E, 0x06, 0x7F, 0x06, 0x80, 0x06, 0x83, 0x06, 0x84, ++ 0x06, 0x86, 0x06, 0x87, 0x06, 0xA4, 0x06, 0xA6, 0x06, 0xA9, 0x06, 0xAD, 0x06, 0xAF, 0x06, 0xB1, ++ 0x06, 0xB3, 0x06, 0xBB, 0x06, 0xBE, 0x06, 0xC1, 0x06, 0xCC, 0x06, 0xD0, 0x00, 0x01, 0x00, 0x00, ++ 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x9A, 0x00, 0x4A, 0xFE, 0x82, 0xFE, 0x84, 0xFE, 0x86, ++ 0xFE, 0x88, 0xFE, 0x8A, 0xFE, 0x8E, 0xFE, 0x90, 0xFE, 0x94, 0xFE, 0x96, 0xFE, 0x9A, 0xFE, 0x9E, ++ 0xFE, 0xA2, 0xFE, 0xA6, 0xFE, 0xAA, 0xFE, 0xAC, 0xFE, 0xAE, 0xFE, 0xB0, 0xFE, 0xB2, 0xFE, 0xB6, ++ 0xFE, 0xBA, 0xFE, 0xBE, 0xFE, 0xC2, 0xFE, 0xC6, 0xFE, 0xCA, 0xFE, 0xCE, 0xFE, 0xD2, 0xFE, 0xD6, ++ 0xFE, 0xDA, 0xFE, 0xDE, 0xFE, 0xE2, 0xFE, 0xE6, 0xFE, 0xEA, 0xFE, 0xEE, 0xFE, 0xF0, 0xFE, 0xF2, ++ 0xFB, 0x51, 0xFB, 0x67, 0xFB, 0x5F, 0xFB, 0x53, 0xFB, 0x57, 0xFB, 0x63, 0xFB, 0x5B, 0xFB, 0x77, ++ 0xFB, 0x73, 0xFB, 0x7B, 0xFB, 0x7F, 0xFB, 0x89, 0xFB, 0x85, 0xFB, 0x83, 0xFB, 0x87, 0xFB, 0x8D, ++ 0xFB, 0x8B, 0xFB, 0x6B, 0xFB, 0x6F, 0xFB, 0x8F, 0xFB, 0xD4, 0xFB, 0x93, 0xFB, 0x9B, 0xFB, 0x97, ++ 0xFB, 0x9F, 0xFB, 0xA1, 0xFB, 0xAB, 0xFB, 0xA5, 0xFB, 0xA7, 0xFB, 0xE1, 0xFB, 0xDA, 0xFB, 0xD8, ++ 0xFB, 0xDC, 0xFB, 0xE3, 0xFB, 0xDF, 0xFB, 0xFD, 0xFB, 0xE5, 0xFB, 0xAF, 0xFB, 0xB1, 0x00, 0x01, ++ 0x00, 0x4A, 0x06, 0x22, 0x06, 0x23, 0x06, 0x24, 0x06, 0x25, 0x06, 0x26, 0x06, 0x27, 0x06, 0x28, ++ 0x06, 0x29, 0x06, 0x2A, 0x06, 0x2B, 0x06, 0x2C, 0x06, 0x2D, 0x06, 0x2E, 0x06, 0x2F, 0x06, 0x30, ++ 0x06, 0x31, 0x06, 0x32, 0x06, 0x33, 0x06, 0x34, 0x06, 0x35, 0x06, 0x36, 0x06, 0x37, 0x06, 0x38, ++ 0x06, 0x39, 0x06, 0x3A, 0x06, 0x41, 0x06, 0x42, 0x06, 0x43, 0x06, 0x44, 0x06, 0x45, 0x06, 0x46, ++ 0x06, 0x47, 0x06, 0x48, 0x06, 0x49, 0x06, 0x4A, 0x06, 0x71, 0x06, 0x79, 0x06, 0x7A, 0x06, 0x7B, ++ 0x06, 0x7E, 0x06, 0x7F, 0x06, 0x80, 0x06, 0x83, 0x06, 0x84, 0x06, 0x86, 0x06, 0x87, 0x06, 0x88, ++ 0x06, 0x8C, 0x06, 0x8D, 0x06, 0x8E, 0x06, 0x91, 0x06, 0x98, 0x06, 0xA4, 0x06, 0xA6, 0x06, 0xA9, ++ 0x06, 0xAD, 0x06, 0xAF, 0x06, 0xB1, 0x06, 0xB3, 0x06, 0xBA, 0x06, 0xBB, 0x06, 0xBE, 0x06, 0xC0, ++ 0x06, 0xC1, 0x06, 0xC5, 0x06, 0xC6, 0x06, 0xC7, 0x06, 0xC8, 0x06, 0xC9, 0x06, 0xCB, 0x06, 0xCC, ++ 0x06, 0xD0, 0x06, 0xD2, 0x06, 0xD3, 0x00, 0x04, 0x00, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, ++ 0x10, 0x98, 0x00, 0x35, 0x00, 0x70, 0x00, 0x7A, 0x01, 0x0C, 0x01, 0x86, 0x01, 0xA8, 0x01, 0xB2, ++ 0x02, 0x0C, 0x02, 0x62, 0x03, 0x02, 0x03, 0x8A, 0x03, 0xB4, 0x03, 0xF6, 0x04, 0x46, 0x04, 0x8A, ++ 0x04, 0xBC, 0x04, 0xEC, 0x05, 0x26, 0x05, 0x38, 0x05, 0x42, 0x05, 0x64, 0x05, 0xF8, 0x06, 0x6C, ++ 0x06, 0xEC, 0x07, 0x80, 0x08, 0x1E, 0x08, 0x56, 0x08, 0xBA, 0x08, 0xF2, 0x09, 0x38, 0x09, 0x66, ++ 0x09, 0x78, 0x09, 0x82, 0x09, 0xD4, 0x0A, 0x0E, 0x0A, 0x40, 0x0A, 0x70, 0x0A, 0xCC, 0x0A, 0xF2, ++ 0x0B, 0x38, 0x0B, 0x68, 0x0B, 0xDC, 0x0C, 0x2A, 0x0C, 0xD6, 0x0D, 0x72, 0x0E, 0x16, 0x0E, 0x50, ++ 0x0E, 0xC8, 0x0F, 0x5A, 0x0F, 0xA8, 0x0F, 0xB6, 0x0F, 0xC0, 0x0F, 0xCA, 0x10, 0x2E, 0x00, 0x01, ++ 0x00, 0x04, 0xFB, 0xDD, 0x00, 0x02, 0x06, 0x74, 0x00, 0x12, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, ++ 0x00, 0x38, 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, 0x00, 0x5C, 0x00, 0x62, ++ 0x00, 0x68, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x7A, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, 0xFB, 0xEC, ++ 0x00, 0x02, 0x00, 0x01, 0xFB, 0xF0, 0x00, 0x02, 0xFB, 0xD8, 0xFB, 0xF2, 0x00, 0x02, 0xFB, 0xDA, ++ 0xFB, 0xF4, 0x00, 0x02, 0xFB, 0xDC, 0xFB, 0xF6, 0x00, 0x02, 0xFB, 0xE5, 0xFB, 0xF8, 0x00, 0x02, ++ 0xFB, 0xE7, 0xFB, 0xEA, 0x00, 0x02, 0xFE, 0x8E, 0xFC, 0x00, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0x97, ++ 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x01, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0x98, 0x00, 0x02, 0xFE, 0xA4, ++ 0xFC, 0x99, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x02, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0x9A, 0x00, 0x02, ++ 0xFE, 0xE4, 0xFC, 0x9B, 0x00, 0x02, 0xFE, 0xEC, 0xFB, 0xEE, 0x00, 0x02, 0xFE, 0xEE, 0xFB, 0xF9, ++ 0x00, 0x02, 0xFE, 0xF0, 0xFB, 0xFB, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0F, 0x00, 0x20, 0x00, 0x26, ++ 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, ++ 0x00, 0x5C, 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, 0x00, 0x74, 0xFB, 0xED, 0x00, 0x02, 0x00, 0x01, ++ 0xFB, 0xF1, 0x00, 0x02, 0xFB, 0xD8, 0xFB, 0xF3, 0x00, 0x02, 0xFB, 0xDA, 0xFB, 0xF5, 0x00, 0x02, ++ 0xFB, 0xDC, 0xFB, 0xF7, 0x00, 0x02, 0xFB, 0xE5, 0xFB, 0xEB, 0x00, 0x02, 0xFE, 0x8E, 0xFC, 0x64, ++ 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x65, 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x66, 0x00, 0x02, 0xFE, 0xE2, ++ 0xFC, 0xDF, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x67, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xE0, 0x00, 0x02, ++ 0xFE, 0xEC, 0xFB, 0xEF, 0x00, 0x02, 0xFE, 0xEE, 0xFB, 0xFA, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x69, ++ 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x18, 0xFD, 0x3D, 0x00, 0x02, ++ 0x06, 0x4B, 0xFD, 0xF3, 0x00, 0x04, 0xFE, 0xDB, 0xFE, 0x92, 0xFE, 0xAE, 0xFD, 0xF2, 0x00, 0x04, ++ 0xFE, 0xDF, 0xFE, 0xE0, 0xFE, 0xEA, 0x00, 0x01, 0x00, 0x04, 0xFD, 0x3C, 0x00, 0x02, 0x06, 0x4B, ++ 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, ++ 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0xFC, 0x05, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0x9C, ++ 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x06, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0x9D, 0x00, 0x02, 0xFE, 0xA4, ++ 0xFC, 0x07, 0x00, 0x02, 0xFE, 0xA6, 0xFC, 0x9E, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x08, 0x00, 0x02, ++ 0xFE, 0xE2, 0xFC, 0x9F, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xA0, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x09, ++ 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x0A, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0A, 0x00, 0x16, 0x00, 0x1E, ++ 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, ++ 0xFD, 0xC2, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0x9E, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF2, ++ 0xFC, 0x6A, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x6B, 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x6C, 0x00, 0x02, ++ 0xFE, 0xE2, 0xFC, 0xE1, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x6D, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xE2, ++ 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x6E, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x6F, 0x00, 0x02, 0xFE, 0xF2, ++ 0x00, 0x12, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3A, 0x00, 0x40, 0x00, 0x48, 0x00, 0x50, ++ 0x00, 0x56, 0x00, 0x5C, 0x00, 0x64, 0x00, 0x6A, 0x00, 0x70, 0x00, 0x78, 0x00, 0x80, 0x00, 0x88, ++ 0x00, 0x8E, 0x00, 0x94, 0x00, 0x9A, 0xFC, 0x0B, 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x50, 0x00, 0x03, ++ 0xFE, 0xA0, 0xFE, 0xE4, 0xFC, 0xA1, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x0C, 0x00, 0x02, 0xFE, 0xA2, ++ 0xFD, 0x52, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xA0, 0xFD, 0x53, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE4, ++ 0xFC, 0xA2, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x0D, 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x54, 0x00, 0x03, ++ 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xA3, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x0E, 0x00, 0x02, 0xFE, 0xE2, ++ 0xFD, 0x55, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA0, 0xFD, 0x56, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA4, ++ 0xFD, 0x57, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA8, 0xFC, 0xA4, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xA5, ++ 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x0F, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x10, 0x00, 0x02, 0xFE, 0xF2, ++ 0x00, 0x0F, 0x00, 0x20, 0x00, 0x28, 0x00, 0x30, 0x00, 0x38, 0x00, 0x40, 0x00, 0x48, 0x00, 0x4E, ++ 0x00, 0x54, 0x00, 0x5A, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x70, 0x00, 0x76, 0x00, 0x7C, 0x00, 0x82, ++ 0xFD, 0xA0, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF0, 0xFD, 0x9F, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, ++ 0xFD, 0x51, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0x9E, 0xFD, 0xA2, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF0, ++ 0xFD, 0xA1, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF2, 0xFC, 0x70, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x71, ++ 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x72, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xA4, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xF0, 0xFD, 0xA3, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0xE3, 0x00, 0x02, 0xFE, 0xE4, ++ 0xFC, 0x73, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xE4, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x74, 0x00, 0x02, ++ 0xFE, 0xF0, 0xFC, 0x75, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, ++ 0x00, 0x1E, 0x00, 0x24, 0xFC, 0x11, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0x12, 0x00, 0x02, 0xFE, 0xE2, ++ 0xFC, 0xA6, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x13, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x14, 0x00, 0x02, ++ 0xFE, 0xF2, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, ++ 0x00, 0x36, 0x00, 0x3C, 0xFC, 0x76, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x77, 0x00, 0x02, 0xFE, 0xB0, ++ 0xFC, 0x78, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xE5, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x79, 0x00, 0x02, ++ 0xFE, 0xE6, 0xFC, 0xE6, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x7A, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x7B, ++ 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x30, 0x00, 0x36, ++ 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, 0xFC, 0x15, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xA7, 0x00, 0x02, ++ 0xFE, 0xA4, 0xFD, 0xFB, 0x00, 0x08, 0xFE, 0xDE, 0x00, 0x20, 0xFE, 0x9F, 0xFE, 0xE0, 0xFE, 0x8E, ++ 0xFE, 0xDF, 0xFE, 0xEA, 0xFC, 0x16, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x59, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xA4, 0xFC, 0xA8, 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x01, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x02, ++ 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x07, 0x00, 0x10, 0x00, 0x18, 0x00, 0x20, 0x00, 0x28, 0x00, 0x30, ++ 0x00, 0x38, 0x00, 0x3E, 0xFD, 0xA6, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF0, 0xFD, 0xBE, 0x00, 0x03, ++ 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0x58, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA2, 0xFD, 0xA7, 0x00, 0x03, ++ 0xFE, 0xE4, 0xFE, 0xF0, 0xFD, 0xA5, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFD, 0x1D, 0x00, 0x02, ++ 0xFE, 0xF0, 0xFD, 0x1E, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, ++ 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0xFC, 0x17, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xA9, 0x00, 0x02, ++ 0xFE, 0xA0, 0xFC, 0x18, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xAA, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xFF, ++ 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x00, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x14, ++ 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0xFD, 0xBF, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0x5B, ++ 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF0, 0xFD, 0x5A, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFD, 0x1B, ++ 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x1C, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, ++ 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0xFC, 0x19, 0x00, 0x02, 0xFE, 0x9E, ++ 0xFC, 0xAB, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x1A, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0x1B, 0x00, 0x02, ++ 0xFE, 0xE2, 0xFC, 0xAC, 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x03, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x04, ++ 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFD, 0x1F, 0x00, 0x02, 0xFE, 0xF0, ++ 0xFD, 0x20, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x01, 0x00, 0x04, 0xFC, 0x5B, 0x00, 0x02, 0x06, 0x70, ++ 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x18, 0xFC, 0x5C, 0x00, 0x02, 0x06, 0x70, 0xFD, 0xFC, ++ 0x00, 0x04, 0xFB, 0xFE, 0xFE, 0x8E, 0xFE, 0xDD, 0xFD, 0xF6, 0x00, 0x04, 0xFE, 0xB3, 0xFE, 0xEE, ++ 0xFE, 0xDD, 0x00, 0x11, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, ++ 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x5E, 0x00, 0x64, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7C, ++ 0x00, 0x82, 0x00, 0x88, 0x00, 0x8E, 0xFC, 0x1C, 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x5D, 0x00, 0x03, ++ 0xFE, 0xA0, 0xFE, 0xA4, 0xFC, 0xAD, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x1D, 0x00, 0x02, 0xFE, 0xA2, ++ 0xFD, 0x5C, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xA0, 0xFC, 0xAE, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x1E, ++ 0x00, 0x02, 0xFE, 0xA6, 0xFC, 0xAF, 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x0E, 0x00, 0x02, 0xFE, 0xAE, ++ 0xFC, 0x1F, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x61, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA0, 0xFD, 0x60, ++ 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA4, 0xFD, 0x63, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xB0, ++ 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x31, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0xFB, 0x00, 0x02, 0xFE, 0xF0, ++ 0xFC, 0xFC, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0D, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, ++ 0x00, 0x38, 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x68, ++ 0x00, 0x6E, 0xFD, 0x5E, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF0, 0xFD, 0x34, 0x00, 0x02, 0xFE, 0xA0, ++ 0xFD, 0x35, 0x00, 0x02, 0xFE, 0xA4, 0xFD, 0xA8, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF0, 0xFD, 0xC6, ++ 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF2, 0xFD, 0x36, 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x2A, 0x00, 0x02, ++ 0xFE, 0xAE, 0xFD, 0x5F, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA2, 0xFD, 0x62, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xE2, 0xFC, 0xE7, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xE8, 0x00, 0x02, 0xFE, 0xEC, 0xFD, 0x17, ++ 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x18, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0F, 0x00, 0x20, 0x00, 0x26, ++ 0x00, 0x2C, 0x00, 0x32, 0x00, 0x3A, 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, ++ 0x00, 0x60, 0x00, 0x68, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x7A, 0xFD, 0x09, 0x00, 0x02, 0xFE, 0x9E, ++ 0xFD, 0x2D, 0x00, 0x02, 0xFE, 0xA0, 0xFD, 0x0A, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x68, 0x00, 0x03, ++ 0xFE, 0xA4, 0xFE, 0xE4, 0xFD, 0x2E, 0x00, 0x02, 0xFE, 0xA4, 0xFD, 0x0B, 0x00, 0x02, 0xFE, 0xA6, ++ 0xFD, 0x2F, 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x0D, 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0x0C, 0x00, 0x02, ++ 0xFE, 0xE2, 0xFD, 0x6B, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA8, 0xFD, 0x6D, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xE4, 0xFD, 0x30, 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x32, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0xFD, ++ 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0xFE, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x11, 0x00, 0x24, 0x00, 0x2A, ++ 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, ++ 0x00, 0x66, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7C, 0x00, 0x82, 0x00, 0x88, 0x00, 0x8E, 0xFD, 0x25, ++ 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x69, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0x37, 0x00, 0x02, ++ 0xFE, 0xA0, 0xFD, 0x26, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x67, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE2, ++ 0xFD, 0xAA, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0x38, 0x00, 0x02, 0xFE, 0xA4, 0xFD, 0x27, ++ 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x39, 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x29, 0x00, 0x02, 0xFE, 0xAE, ++ 0xFD, 0x28, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x6A, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA6, 0xFD, 0x6C, ++ 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFC, 0xE9, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xEA, 0x00, 0x02, ++ 0xFE, 0xEC, 0xFD, 0x19, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x1A, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0E, ++ 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x50, ++ 0x00, 0x76, 0x00, 0x7E, 0x00, 0x84, 0x00, 0x8C, 0x00, 0x92, 0x00, 0x98, 0xFC, 0x20, 0x00, 0x02, ++ 0xFE, 0xA2, 0xFD, 0x65, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xA4, 0xFC, 0xB1, 0x00, 0x02, 0xFE, 0xA4, ++ 0xFC, 0xB2, 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x0F, 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0xF0, 0x00, 0x03, ++ 0xFE, 0xE0, 0xFB, 0xAF, 0xFD, 0xF5, 0x00, 0x04, 0xFE, 0xE0, 0xFE, 0xCC, 0xFE, 0xE2, 0xFD, 0xFA, ++ 0x00, 0x12, 0xFE, 0xE0, 0xFE, 0xF0, 0x00, 0x20, 0xFE, 0x8D, 0xFE, 0xDF, 0xFE, 0xE0, 0xFE, 0xEA, ++ 0x00, 0x20, 0xFE, 0xCB, 0xFE, 0xE0, 0xFE, 0xF4, 0xFE, 0xEA, 0x00, 0x20, 0xFE, 0xED, 0xFE, 0xB3, ++ 0xFE, 0xE0, 0xFE, 0xE2, 0xFD, 0xF9, 0x00, 0x03, 0xFE, 0xE0, 0xFE, 0xF0, 0xFC, 0x21, 0x00, 0x02, ++ 0xFE, 0xE2, 0xFD, 0xC5, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xB3, 0x00, 0x02, 0xFE, 0xE4, ++ 0xFD, 0x05, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x06, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, ++ 0x00, 0x16, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2C, 0x00, 0x32, 0xFD, 0x64, 0x00, 0x03, 0xFE, 0xA4, ++ 0xFE, 0xA2, 0xFD, 0xA9, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0x2B, 0x00, 0x02, 0xFE, 0xAE, ++ 0xFD, 0x66, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFD, 0x21, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x22, ++ 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0C, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, ++ 0x00, 0x38, 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x5E, 0xFC, 0x22, ++ 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xB4, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x23, 0x00, 0x02, 0xFE, 0xA2, ++ 0xFC, 0xB5, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x24, 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x70, 0x00, 0x03, ++ 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xB6, 0x00, 0x02, 0xFE, 0xA8, 0xFD, 0x10, 0x00, 0x02, 0xFE, 0xAE, ++ 0xFC, 0x25, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xB7, 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x07, 0x00, 0x02, ++ 0xFE, 0xF0, 0xFD, 0x08, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x16, 0x00, 0x1E, ++ 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0xFD, 0x6E, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF0, 0xFD, 0xAB, ++ 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0x6F, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE2, 0xFD, 0x2C, ++ 0x00, 0x02, 0xFE, 0xAE, 0xFD, 0x23, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x24, 0x00, 0x02, 0xFE, 0xF2, ++ 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3A, ++ 0x00, 0x40, 0xFC, 0x26, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xB8, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x27, ++ 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x72, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA4, 0xFD, 0x73, 0x00, 0x03, ++ 0xFE, 0xE4, 0xFE, 0xE4, 0xFD, 0x33, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xF5, 0x00, 0x02, 0xFE, 0xF0, ++ 0xFC, 0xF6, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x22, ++ 0x00, 0x28, 0xFD, 0x71, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA2, 0xFD, 0x74, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xF2, 0xFD, 0x3A, 0x00, 0x02, 0xFE, 0xE4, 0xFD, 0x11, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x12, ++ 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFC, 0x28, 0x00, 0x02, 0xFE, 0xE2, ++ 0xFC, 0xB9, 0x00, 0x02, 0xFE, 0xE4, 0x00, 0x01, 0x00, 0x04, 0xFD, 0x3B, 0x00, 0x02, 0xFE, 0xE4, ++ 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x22, 0x00, 0x28, 0x00, 0x32, 0x00, 0x38, 0x00, 0x40, ++ 0x00, 0x46, 0x00, 0x4C, 0xFC, 0x29, 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0xC4, 0x00, 0x03, 0xFE, 0xA0, ++ 0xFE, 0xE4, 0xFC, 0xBA, 0x00, 0x02, 0xFE, 0xA0, 0xFD, 0xF7, 0x00, 0x04, 0xFE, 0xE0, 0xFE, 0xF4, ++ 0xFE, 0xEA, 0xFC, 0x2A, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x77, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, ++ 0xFC, 0xBB, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xF7, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0xF8, 0x00, 0x02, ++ 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x16, 0x00, 0x1E, 0x00, 0x26, 0x00, 0x2E, 0x00, 0x34, ++ 0xFD, 0x75, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE2, 0xFD, 0x76, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, ++ 0xFD, 0x78, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF0, 0xFD, 0xB6, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, ++ 0xFD, 0x13, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x14, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, ++ 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0xFC, 0x2B, 0x00, 0x02, 0xFE, 0x9E, ++ 0xFC, 0xBC, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x2C, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xBD, 0x00, 0x02, ++ 0xFE, 0xE4, 0xFC, 0xF9, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0xFA, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x05, ++ 0x00, 0x0C, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0xFD, 0x79, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xE2, 0xFD, 0x7B, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF0, 0xFD, 0x7A, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xF2, 0xFD, 0x15, 0x00, 0x02, 0xFE, 0xF0, 0xFD, 0x16, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0B, ++ 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3E, 0x00, 0x44, ++ 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, 0xFC, 0x2D, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xBE, 0x00, 0x02, ++ 0xFE, 0xA0, 0xFC, 0x2E, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xBF, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x2F, ++ 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x7D, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xC0, 0x00, 0x02, ++ 0xFE, 0xA8, 0xFC, 0x30, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xC1, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x31, ++ 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x32, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x12, ++ 0x00, 0x1A, 0x00, 0x20, 0xFD, 0x7C, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE2, 0xFD, 0xC1, 0x00, 0x03, ++ 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0x7C, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x7D, 0x00, 0x02, 0xFE, 0xF2, ++ 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3A, ++ 0x00, 0x40, 0xFC, 0x33, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xC2, 0x00, 0x02, 0xFE, 0xA4, 0xFD, 0xF1, ++ 0x00, 0x03, 0xFE, 0xE0, 0xFB, 0xAF, 0xFC, 0x34, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xB4, 0x00, 0x03, ++ 0xFE, 0xE4, 0xFE, 0xA4, 0xFC, 0xC3, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x35, 0x00, 0x02, 0xFE, 0xF0, ++ 0xFC, 0x36, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x24, ++ 0x00, 0x2A, 0xFD, 0x7E, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA2, 0xFD, 0x7F, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xE2, 0xFD, 0xB2, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0x7E, 0x00, 0x02, 0xFE, 0xF0, ++ 0xFC, 0x7F, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0E, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, ++ 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x62, ++ 0x00, 0x68, 0x00, 0x6E, 0xFC, 0x37, 0x00, 0x02, 0xFE, 0x8E, 0xFC, 0x38, 0x00, 0x02, 0xFE, 0x9E, ++ 0xFC, 0xC4, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x39, 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xC5, 0x00, 0x02, ++ 0xFE, 0xA4, 0xFC, 0x3A, 0x00, 0x02, 0xFE, 0xA6, 0xFC, 0xC6, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x3B, ++ 0x00, 0x02, 0xFE, 0xDE, 0xFC, 0xC7, 0x00, 0x02, 0xFE, 0xE0, 0xFC, 0x3C, 0x00, 0x02, 0xFE, 0xE2, ++ 0xFD, 0xC3, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xC8, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x3D, ++ 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x3E, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, ++ 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0xFC, 0x80, ++ 0x00, 0x02, 0xFE, 0x8E, 0xFC, 0x81, 0x00, 0x02, 0xFE, 0xDE, 0xFC, 0xEB, 0x00, 0x02, 0xFE, 0xE0, ++ 0xFC, 0x82, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xBB, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, 0xFD, 0xB7, ++ 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0xEC, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x83, 0x00, 0x02, ++ 0xFE, 0xF0, 0xFC, 0x84, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x14, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, ++ 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x50, 0x00, 0x58, 0x00, 0x5E, 0x00, 0x64, 0x00, 0x6C, ++ 0x00, 0x72, 0x00, 0x78, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, 0x00, 0x94, 0x00, 0x9A, 0x00, 0xA0, ++ 0x00, 0xA6, 0xFE, 0xF5, 0x00, 0x02, 0xFE, 0x82, 0xFE, 0xF7, 0x00, 0x02, 0xFE, 0x84, 0xFE, 0xF9, ++ 0x00, 0x02, 0xFE, 0x88, 0xFE, 0xFB, 0x00, 0x02, 0xFE, 0x8E, 0xFC, 0x3F, 0x00, 0x02, 0xFE, 0x9E, ++ 0xFD, 0x83, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xA0, 0xFD, 0xBA, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE4, ++ 0xFC, 0xC9, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x40, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0xB5, 0x00, 0x03, ++ 0xFE, 0xA4, 0xFE, 0xE4, 0xFC, 0xCA, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x41, 0x00, 0x02, 0xFE, 0xA6, ++ 0xFD, 0x86, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xCB, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x42, ++ 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x88, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA4, 0xFC, 0xCC, 0x00, 0x02, ++ 0xFE, 0xE4, 0xFC, 0xCD, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x43, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x44, ++ 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x11, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, ++ 0x00, 0x44, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, 0x00, 0x64, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7A, ++ 0x00, 0x82, 0x00, 0x8A, 0x00, 0x90, 0x00, 0x96, 0xFE, 0xF6, 0x00, 0x02, 0xFE, 0x82, 0xFE, 0xF8, ++ 0x00, 0x02, 0xFE, 0x84, 0xFE, 0xFA, 0x00, 0x02, 0xFE, 0x88, 0xFE, 0xFC, 0x00, 0x02, 0xFE, 0x8E, ++ 0xFD, 0x84, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0x9E, 0xFD, 0xBC, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE2, ++ 0xFD, 0xAC, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0x80, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE2, ++ 0xFD, 0x82, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF0, 0xFD, 0x81, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, ++ 0xFD, 0x85, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE2, 0xFC, 0x85, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x87, ++ 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA2, 0xFD, 0xAD, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0xED, ++ 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x86, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x87, 0x00, 0x02, 0xFE, 0xF2, ++ 0x00, 0x12, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, ++ 0x00, 0x58, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x70, 0x00, 0x76, 0x00, 0x7E, 0x00, 0x86, 0x00, 0x8C, ++ 0x00, 0x92, 0x00, 0x98, 0x00, 0x9E, 0xFC, 0x45, 0x00, 0x02, 0xFE, 0x9E, 0xFD, 0x8C, 0x00, 0x03, ++ 0xFE, 0xA0, 0xFE, 0xA4, 0xFD, 0x92, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xA8, 0xFD, 0x8D, 0x00, 0x03, ++ 0xFE, 0xA0, 0xFE, 0xE4, 0xFC, 0xCE, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x46, 0x00, 0x02, 0xFE, 0xA2, ++ 0xFD, 0x89, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xA0, 0xFD, 0xF4, 0x00, 0x04, 0xFE, 0xA4, 0xFE, 0xE4, ++ 0xFE, 0xAA, 0xFD, 0x8A, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE4, 0xFC, 0xCF, 0x00, 0x02, 0xFE, 0xA4, ++ 0xFC, 0x47, 0x00, 0x02, 0xFE, 0xA6, 0xFD, 0x8E, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xA0, 0xFD, 0x8F, ++ 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xE4, 0xFC, 0xD0, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x48, 0x00, 0x02, ++ 0xFE, 0xE2, 0xFC, 0xD1, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x49, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x4A, ++ 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2C, ++ 0x00, 0x32, 0xFC, 0x88, 0x00, 0x02, 0xFE, 0x8E, 0xFD, 0xC0, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, ++ 0xFD, 0x8B, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFD, 0xB9, 0x00, 0x03, 0xFE, 0xA8, 0xFE, 0xF2, ++ 0xFC, 0x89, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0xB1, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0x00, 0x0E, ++ 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3A, 0x00, 0x40, 0x00, 0x48, 0x00, 0x4E, ++ 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, 0x00, 0x6C, 0x00, 0x72, 0xFC, 0x4B, 0x00, 0x02, ++ 0xFE, 0x9E, 0xFD, 0xB8, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xA4, 0xFD, 0x98, 0x00, 0x03, 0xFE, 0xA0, ++ 0xFE, 0xE4, 0xFC, 0xD2, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x4C, 0x00, 0x02, 0xFE, 0xA2, 0xFD, 0x95, ++ 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xE4, 0xFC, 0xD3, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x4D, 0x00, 0x02, ++ 0xFE, 0xA6, 0xFC, 0xD4, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x4E, 0x00, 0x02, 0xFE, 0xE2, 0xFC, 0xD5, ++ 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xD6, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x4F, 0x00, 0x02, 0xFE, 0xF0, ++ 0xFC, 0x50, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x10, 0x00, 0x22, 0x00, 0x2A, 0x00, 0x32, 0x00, 0x3A, ++ 0x00, 0x42, 0x00, 0x4A, 0x00, 0x52, 0x00, 0x58, 0x00, 0x5E, 0x00, 0x64, 0x00, 0x6C, 0x00, 0x74, ++ 0x00, 0x7A, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, 0xFD, 0xBD, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xA2, ++ 0xFD, 0x97, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xE2, 0xFD, 0x99, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF0, ++ 0xFD, 0xC7, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0x96, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF0, ++ 0xFD, 0xB3, 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFC, 0x8A, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x8B, ++ 0x00, 0x02, 0xFE, 0xB0, 0xFC, 0x8C, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x9B, 0x00, 0x03, 0xFE, 0xE4, ++ 0xFE, 0xF0, 0xFD, 0x9A, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0xEE, 0x00, 0x02, 0xFE, 0xE4, ++ 0xFC, 0x8D, 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xEF, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x8E, 0x00, 0x02, ++ 0xFE, 0xF0, 0xFC, 0x8F, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, ++ 0x00, 0x26, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0xFC, 0xD9, 0x00, 0x02, ++ 0x06, 0x70, 0xFC, 0x51, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xD7, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x52, ++ 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x93, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xA0, 0xFD, 0x94, 0x00, 0x03, ++ 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xD8, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x53, 0x00, 0x02, 0xFE, 0xF0, ++ 0xFC, 0x54, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x01, 0x00, 0x04, 0xFD, 0xF8, 0x00, 0x04, 0xFE, 0xB3, ++ 0xFE, 0xE0, 0xFE, 0xE2, 0x00, 0x01, 0x00, 0x04, 0xFC, 0x5D, 0x00, 0x02, 0x06, 0x70, 0x00, 0x01, ++ 0x00, 0x04, 0xFC, 0x90, 0x00, 0x02, 0x06, 0x70, 0x00, 0x0C, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, ++ 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, ++ 0x00, 0x5E, 0xFC, 0x55, 0x00, 0x02, 0xFE, 0x9E, 0xFC, 0xDA, 0x00, 0x02, 0xFE, 0xA0, 0xFC, 0x56, ++ 0x00, 0x02, 0xFE, 0xA2, 0xFC, 0xDB, 0x00, 0x02, 0xFE, 0xA4, 0xFC, 0x57, 0x00, 0x02, 0xFE, 0xA6, ++ 0xFC, 0xDC, 0x00, 0x02, 0xFE, 0xA8, 0xFC, 0x58, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x9D, 0x00, 0x03, ++ 0xFE, 0xE4, 0xFE, 0xE4, 0xFC, 0xDD, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0xDE, 0x00, 0x02, 0xFE, 0xEC, ++ 0xFC, 0x59, 0x00, 0x02, 0xFE, 0xF0, 0xFC, 0x5A, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x0C, 0x00, 0x1A, ++ 0x00, 0x22, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4C, 0x00, 0x52, ++ 0x00, 0x58, 0x00, 0x5E, 0x00, 0x64, 0xFD, 0xAF, 0x00, 0x03, 0xFE, 0xA0, 0xFE, 0xF2, 0xFD, 0xAE, ++ 0x00, 0x03, 0xFE, 0xA4, 0xFE, 0xF2, 0xFC, 0x91, 0x00, 0x02, 0xFE, 0xAE, 0xFC, 0x92, 0x00, 0x02, ++ 0xFE, 0xB0, 0xFC, 0x93, 0x00, 0x02, 0xFE, 0xE2, 0xFD, 0x9C, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xE2, ++ 0xFD, 0xB0, 0x00, 0x03, 0xFE, 0xE4, 0xFE, 0xF2, 0xFC, 0xF0, 0x00, 0x02, 0xFE, 0xE4, 0xFC, 0x94, ++ 0x00, 0x02, 0xFE, 0xE6, 0xFC, 0xF1, 0x00, 0x02, 0xFE, 0xEC, 0xFC, 0x95, 0x00, 0x02, 0xFE, 0xF0, ++ 0xFC, 0x96, 0x00, 0x02, 0xFE, 0xF2, 0x00, 0x01, 0x00, 0x35, 0xFB, 0xD7, 0xFE, 0x8B, 0xFE, 0x8C, ++ 0xFE, 0x8D, 0xFE, 0x8E, 0xFE, 0x91, 0xFE, 0x92, 0xFE, 0x97, 0xFE, 0x98, 0xFE, 0x9B, 0xFE, 0x9C, ++ 0xFE, 0x9F, 0xFE, 0xA0, 0xFE, 0xA3, 0xFE, 0xA4, 0xFE, 0xA7, 0xFE, 0xA8, 0xFE, 0xAB, 0xFE, 0xAD, ++ 0xFE, 0xB3, 0xFE, 0xB4, 0xFE, 0xB7, 0xFE, 0xB8, 0xFE, 0xBB, 0xFE, 0xBC, 0xFE, 0xBF, 0xFE, 0xC0, ++ 0xFE, 0xC3, 0xFE, 0xC4, 0xFE, 0xC7, 0xFE, 0xC8, 0xFE, 0xCB, 0xFE, 0xCC, 0xFE, 0xCF, 0xFE, 0xD0, ++ 0xFE, 0xD3, 0xFE, 0xD4, 0xFE, 0xD7, 0xFE, 0xD8, 0xFE, 0xDB, 0xFE, 0xDC, 0xFE, 0xDF, 0xFE, 0xE0, ++ 0xFE, 0xE3, 0xFE, 0xE4, 0xFE, 0xE7, 0xFE, 0xE8, 0xFE, 0xEB, 0xFE, 0xED, 0xFE, 0xEF, 0xFE, 0xF0, ++ 0xFE, 0xF3, 0xFE, 0xF4, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x1A, ++ 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x09, 0xCB, 0x00, 0x02, 0x09, 0xBE, ++ 0x09, 0xCC, 0x00, 0x02, 0x09, 0xD7, 0x00, 0x01, 0x00, 0x01, 0x09, 0xC7, 0x00, 0x02, 0x00, 0x00, ++ 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x16, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x02, ++ 0x09, 0xC7, 0x09, 0xBE, 0x00, 0x02, 0x09, 0xC7, 0x09, 0xD7, 0x00, 0x01, 0x00, 0x02, 0x09, 0xCB, ++ 0x09, 0xCC, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x02, 0x66, 0x00, 0x20, + 0x00, 0x46, 0x00, 0x50, 0x00, 0x62, 0x00, 0x74, 0x00, 0x96, 0x00, 0xA8, 0x00, 0xB2, 0x00, 0xDC, + 0x00, 0xEE, 0x00, 0xF8, 0x01, 0x1A, 0x01, 0x24, 0x01, 0x2E, 0x01, 0x38, 0x01, 0x4A, 0x01, 0x5C, + 0x01, 0x7E, 0x01, 0x90, 0x01, 0x9A, 0x01, 0xC4, 0x01, 0xD6, 0x01, 0xE0, 0x02, 0x02, 0x02, 0x0C, +@@ -508,25 +499,13 @@ + 0x04, 0x35, 0x03, 0x40, 0x00, 0x02, 0x04, 0x33, 0x03, 0x41, 0x00, 0x02, 0x04, 0x3A, 0x03, 0x41, + 0x00, 0x02, 0x04, 0x38, 0x03, 0x40, 0x00, 0x01, 0x00, 0x08, 0x04, 0x00, 0x04, 0x03, 0x04, 0x0C, + 0x04, 0x0D, 0x04, 0x50, 0x04, 0x53, 0x04, 0x5C, 0x04, 0x5D, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x01, 0x00, 0x8A, 0x00, 0x0B, 0x00, 0x1C, 0x00, 0x26, 0x00, 0x30, 0x00, 0x3A, +- 0x00, 0x44, 0x00, 0x4E, 0x00, 0x58, 0x00, 0x62, 0x00, 0x6C, 0x00, 0x76, 0x00, 0x80, 0x00, 0x01, +- 0x00, 0x04, 0x09, 0x58, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x59, 0x00, 0x02, +- 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x5A, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, +- 0x09, 0x5B, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x5C, 0x00, 0x02, 0x09, 0x3C, +- 0x00, 0x01, 0x00, 0x04, 0x09, 0x5D, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x29, +- 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x5E, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, +- 0x00, 0x04, 0x09, 0x5F, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x31, 0x00, 0x02, +- 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x34, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x0B, +- 0x09, 0x15, 0x09, 0x16, 0x09, 0x17, 0x09, 0x1C, 0x09, 0x21, 0x09, 0x22, 0x09, 0x28, 0x09, 0x2B, +- 0x09, 0x2F, 0x09, 0x30, 0x09, 0x33, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, +- 0x00, 0x5E, 0x00, 0x0B, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x00, 0x3A, +- 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x02, 0x09, 0x28, 0x09, 0x3C, +- 0x00, 0x02, 0x09, 0x30, 0x09, 0x3C, 0x00, 0x02, 0x09, 0x33, 0x09, 0x3C, 0x00, 0x02, 0x09, 0x15, +- 0x09, 0x3C, 0x00, 0x02, 0x09, 0x16, 0x09, 0x3C, 0x00, 0x02, 0x09, 0x17, 0x09, 0x3C, 0x00, 0x02, +- 0x09, 0x1C, 0x09, 0x3C, 0x00, 0x02, 0x09, 0x21, 0x09, 0x3C, 0x00, 0x02, 0x09, 0x22, 0x09, 0x3C, +- 0x00, 0x02, 0x09, 0x2B, 0x09, 0x3C, 0x00, 0x02, 0x09, 0x2F, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x0B, +- 0x09, 0x29, 0x09, 0x31, 0x09, 0x34, 0x09, 0x58, 0x09, 0x59, 0x09, 0x5A, 0x09, 0x5B, 0x09, 0x5C, +- 0x09, 0x5D, 0x09, 0x5E, 0x09, 0x5F, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, ++ 0x00, 0x08, 0x00, 0x01, 0x00, 0x2A, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x16, 0x00, 0x20, 0x00, 0x01, ++ 0x00, 0x04, 0x09, 0x29, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x31, 0x00, 0x02, ++ 0x09, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x09, 0x34, 0x00, 0x02, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x03, ++ 0x09, 0x28, 0x09, 0x30, 0x09, 0x33, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, ++ 0x00, 0x1E, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x02, 0x09, 0x28, 0x09, 0x3C, ++ 0x00, 0x02, 0x09, 0x30, 0x09, 0x3C, 0x00, 0x02, 0x09, 0x33, 0x09, 0x3C, 0x00, 0x01, 0x00, 0x03, ++ 0x09, 0x29, 0x09, 0x31, 0x09, 0x34, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, + 0x33, 0x04, 0x00, 0x75, 0x00, 0xF0, 0x01, 0x1A, 0x04, 0x5A, 0x05, 0x0C, 0x08, 0x3C, 0x09, 0x24, + 0x09, 0xD6, 0x09, 0xE0, 0x0A, 0x54, 0x0D, 0x84, 0x0D, 0x8E, 0x0D, 0x98, 0x11, 0x44, 0x11, 0xF6, + 0x15, 0x92, 0x16, 0xBC, 0x17, 0x6E, 0x17, 0x88, 0x18, 0xB2, 0x1C, 0x4E, 0x1C, 0x78, 0x1C, 0xA2, +@@ -1358,569 +1337,541 @@ + 0x1F, 0x81, 0x1F, 0x88, 0x1F, 0x89, 0x1F, 0x90, 0x1F, 0x91, 0x1F, 0x98, 0x1F, 0x99, 0x1F, 0xA0, + 0x1F, 0xA1, 0x1F, 0xA8, 0x1F, 0xA9, 0x1F, 0xB3, 0x1F, 0xB6, 0x1F, 0xBC, 0x1F, 0xBE, 0x1F, 0xBF, + 0x1F, 0xC3, 0x1F, 0xC6, 0x1F, 0xCC, 0x1F, 0xF3, 0x1F, 0xF6, 0x1F, 0xFC, 0x1F, 0xFE, 0x21, 0x26, +- 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x4C, 0x0A, 0x10, 0x12, 0x6E, 0x18, 0x84, 0x1E, 0x68, +- 0x22, 0x7A, 0x26, 0x68, 0x29, 0x12, 0x2B, 0x5C, 0x2D, 0x24, 0x2F, 0x04, 0x30, 0xB4, 0x32, 0x62, +- 0x33, 0xCA, 0x35, 0x32, 0x36, 0x9A, 0x37, 0x76, 0x38, 0x52, 0x39, 0x2E, 0x39, 0xFC, 0x3A, 0xCA, +- 0x3B, 0x98, 0x3C, 0x4A, 0x3C, 0xFC, 0x3D, 0x22, 0x3D, 0x48, 0x3D, 0x6E, 0x3D, 0x94, 0x3D, 0xBA, +- 0x3D, 0xE0, 0x3E, 0x06, 0x3E, 0x2C, 0x3E, 0x52, 0x3E, 0x78, 0x3E, 0x9E, 0x00, 0x01, 0x07, 0xCE, +- 0x00, 0xF9, 0x01, 0xF8, 0x01, 0xFE, 0x02, 0x04, 0x02, 0x0A, 0x02, 0x10, 0x02, 0x16, 0x02, 0x1C, +- 0x02, 0x22, 0x02, 0x28, 0x02, 0x2E, 0x02, 0x34, 0x02, 0x3A, 0x02, 0x40, 0x02, 0x46, 0x02, 0x4C, +- 0x02, 0x52, 0x02, 0x58, 0x02, 0x5E, 0x02, 0x64, 0x02, 0x6A, 0x02, 0x70, 0x02, 0x76, 0x02, 0x7C, +- 0x02, 0x82, 0x02, 0x88, 0x02, 0x8E, 0x02, 0x94, 0x02, 0x9A, 0x02, 0xA0, 0x02, 0xA6, 0x02, 0xAC, +- 0x02, 0xB2, 0x02, 0xB8, 0x02, 0xBE, 0x02, 0xC4, 0x02, 0xCA, 0x02, 0xD0, 0x02, 0xD6, 0x02, 0xDC, +- 0x02, 0xE2, 0x02, 0xE8, 0x02, 0xEE, 0x02, 0xF4, 0x02, 0xFA, 0x03, 0x00, 0x03, 0x06, 0x03, 0x0C, +- 0x03, 0x12, 0x03, 0x18, 0x03, 0x1E, 0x03, 0x24, 0x03, 0x2A, 0x03, 0x30, 0x03, 0x36, 0x03, 0x3C, +- 0x03, 0x42, 0x03, 0x48, 0x03, 0x4E, 0x03, 0x54, 0x03, 0x5A, 0x03, 0x60, 0x03, 0x66, 0x03, 0x6C, +- 0x03, 0x72, 0x03, 0x78, 0x03, 0x7E, 0x03, 0x84, 0x03, 0x8A, 0x03, 0x90, 0x03, 0x96, 0x03, 0x9C, +- 0x03, 0xA2, 0x03, 0xA8, 0x03, 0xAE, 0x03, 0xB4, 0x03, 0xBA, 0x03, 0xC0, 0x03, 0xC6, 0x03, 0xCC, +- 0x03, 0xD2, 0x03, 0xD8, 0x03, 0xDE, 0x03, 0xE4, 0x03, 0xEA, 0x03, 0xF0, 0x03, 0xF6, 0x03, 0xFC, +- 0x04, 0x02, 0x04, 0x08, 0x04, 0x0E, 0x04, 0x14, 0x04, 0x1A, 0x04, 0x20, 0x04, 0x26, 0x04, 0x2C, +- 0x04, 0x32, 0x04, 0x38, 0x04, 0x3E, 0x04, 0x44, 0x04, 0x4A, 0x04, 0x50, 0x04, 0x56, 0x04, 0x5C, +- 0x04, 0x62, 0x04, 0x68, 0x04, 0x6E, 0x04, 0x74, 0x04, 0x7A, 0x04, 0x80, 0x04, 0x86, 0x04, 0x8C, +- 0x04, 0x92, 0x04, 0x98, 0x04, 0x9E, 0x04, 0xA4, 0x04, 0xAA, 0x04, 0xB0, 0x04, 0xB6, 0x04, 0xBC, +- 0x04, 0xC2, 0x04, 0xC8, 0x04, 0xCE, 0x04, 0xD4, 0x04, 0xDA, 0x04, 0xE0, 0x04, 0xE6, 0x04, 0xEC, +- 0x04, 0xF2, 0x04, 0xF8, 0x04, 0xFE, 0x05, 0x04, 0x05, 0x0A, 0x05, 0x10, 0x05, 0x16, 0x05, 0x1C, +- 0x05, 0x22, 0x05, 0x28, 0x05, 0x2E, 0x05, 0x34, 0x05, 0x3A, 0x05, 0x40, 0x05, 0x46, 0x05, 0x4C, +- 0x05, 0x52, 0x05, 0x58, 0x05, 0x5E, 0x05, 0x64, 0x05, 0x6A, 0x05, 0x70, 0x05, 0x76, 0x05, 0x7C, +- 0x05, 0x82, 0x05, 0x88, 0x05, 0x8E, 0x05, 0x94, 0x05, 0x9A, 0x05, 0xA0, 0x05, 0xA6, 0x05, 0xAC, +- 0x05, 0xB2, 0x05, 0xB8, 0x05, 0xBE, 0x05, 0xC4, 0x05, 0xCA, 0x05, 0xD0, 0x05, 0xD6, 0x05, 0xDC, +- 0x05, 0xE2, 0x05, 0xE8, 0x05, 0xEE, 0x05, 0xF4, 0x05, 0xFA, 0x06, 0x00, 0x06, 0x06, 0x06, 0x0C, +- 0x06, 0x12, 0x06, 0x18, 0x06, 0x1E, 0x06, 0x24, 0x06, 0x2A, 0x06, 0x30, 0x06, 0x36, 0x06, 0x3C, +- 0x06, 0x42, 0x06, 0x48, 0x06, 0x4E, 0x06, 0x54, 0x06, 0x5A, 0x06, 0x60, 0x06, 0x66, 0x06, 0x6C, +- 0x06, 0x72, 0x06, 0x78, 0x06, 0x7E, 0x06, 0x84, 0x06, 0x8A, 0x06, 0x90, 0x06, 0x96, 0x06, 0x9C, +- 0x06, 0xA2, 0x06, 0xA8, 0x06, 0xAE, 0x06, 0xB4, 0x06, 0xBA, 0x06, 0xC0, 0x06, 0xC6, 0x06, 0xCC, +- 0x06, 0xD2, 0x06, 0xD8, 0x06, 0xDE, 0x06, 0xE4, 0x06, 0xEA, 0x06, 0xF0, 0x06, 0xF6, 0x06, 0xFC, +- 0x07, 0x02, 0x07, 0x08, 0x07, 0x0E, 0x07, 0x14, 0x07, 0x1A, 0x07, 0x20, 0x07, 0x26, 0x07, 0x2C, +- 0x07, 0x32, 0x07, 0x38, 0x07, 0x3E, 0x07, 0x44, 0x07, 0x4A, 0x07, 0x50, 0x07, 0x56, 0x07, 0x5C, +- 0x07, 0x62, 0x07, 0x68, 0x07, 0x6E, 0x07, 0x74, 0x07, 0x7A, 0x07, 0x80, 0x07, 0x86, 0x07, 0x8C, +- 0x07, 0x92, 0x07, 0x98, 0x07, 0x9E, 0x07, 0xA4, 0x07, 0xAA, 0x07, 0xB0, 0x07, 0xB6, 0x07, 0xBC, +- 0x07, 0xC2, 0x07, 0xC8, 0x00, 0x02, 0x00, 0xA8, 0x03, 0x01, 0x00, 0x02, 0x03, 0x91, 0x03, 0x01, +- 0x00, 0x02, 0x03, 0x95, 0x03, 0x01, 0x00, 0x02, 0x03, 0x97, 0x03, 0x01, 0x00, 0x02, 0x03, 0x99, +- 0x03, 0x01, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x01, 0x00, 0x02, 0x03, 0xA5, 0x03, 0x01, 0x00, 0x02, +- 0x03, 0xA9, 0x03, 0x01, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x44, 0x00, 0x02, 0x03, 0x99, 0x03, 0x08, +- 0x00, 0x02, 0x03, 0xA5, 0x03, 0x08, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x01, 0x00, 0x02, 0x03, 0xB5, +- 0x03, 0x01, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x01, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x01, 0x00, 0x02, +- 0x03, 0xC5, 0x03, 0x44, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x08, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x08, +- 0x00, 0x02, 0x03, 0xBF, 0x03, 0x01, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x01, 0x00, 0x02, 0x03, 0xC9, +- 0x03, 0x01, 0x00, 0x02, 0x03, 0xD2, 0x03, 0x01, 0x00, 0x02, 0x03, 0xD2, 0x03, 0x08, 0x00, 0x02, +- 0x03, 0xB1, 0x03, 0x13, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x00, 0x03, 0x00, +- 0x00, 0x02, 0x1F, 0x01, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x00, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x01, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0x00, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x01, 0x03, 0x42, 0x00, 0x02, +- 0x03, 0x91, 0x03, 0x13, 0x00, 0x02, 0x03, 0x91, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x08, 0x03, 0x00, +- 0x00, 0x02, 0x1F, 0x09, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x08, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x09, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0x08, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x09, 0x03, 0x42, 0x00, 0x02, +- 0x03, 0xB5, 0x03, 0x13, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x10, 0x03, 0x00, +- 0x00, 0x02, 0x1F, 0x11, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x10, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x11, +- 0x03, 0x01, 0x00, 0x02, 0x03, 0x95, 0x03, 0x13, 0x00, 0x02, 0x03, 0x95, 0x03, 0x14, 0x00, 0x02, +- 0x1F, 0x18, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x19, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x18, 0x03, 0x01, +- 0x00, 0x02, 0x1F, 0x19, 0x03, 0x01, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x13, 0x00, 0x02, 0x03, 0xB7, +- 0x03, 0x14, 0x00, 0x02, 0x1F, 0x20, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x21, 0x03, 0x00, 0x00, 0x02, +- 0x1F, 0x20, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x21, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x20, 0x03, 0x42, +- 0x00, 0x02, 0x1F, 0x21, 0x03, 0x42, 0x00, 0x02, 0x03, 0x97, 0x03, 0x13, 0x00, 0x02, 0x03, 0x97, +- 0x03, 0x14, 0x00, 0x02, 0x1F, 0x28, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x29, 0x03, 0x00, 0x00, 0x02, +- 0x1F, 0x28, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x29, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x28, 0x03, 0x42, +- 0x00, 0x02, 0x1F, 0x29, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x13, 0x00, 0x02, 0x03, 0xB9, +- 0x03, 0x14, 0x00, 0x02, 0x1F, 0x30, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x31, 0x03, 0x00, 0x00, 0x02, +- 0x1F, 0x30, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x31, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x30, 0x03, 0x42, +- 0x00, 0x02, 0x1F, 0x31, 0x03, 0x42, 0x00, 0x02, 0x03, 0x99, 0x03, 0x13, 0x00, 0x02, 0x03, 0x99, +- 0x03, 0x14, 0x00, 0x02, 0x1F, 0x38, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x39, 0x03, 0x00, 0x00, 0x02, +- 0x1F, 0x38, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x39, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x38, 0x03, 0x42, +- 0x00, 0x02, 0x1F, 0x39, 0x03, 0x42, 0x00, 0x02, 0x03, 0xBF, 0x03, 0x13, 0x00, 0x02, 0x03, 0xBF, +- 0x03, 0x14, 0x00, 0x02, 0x1F, 0x40, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x41, 0x03, 0x00, 0x00, 0x02, +- 0x1F, 0x40, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x41, 0x03, 0x01, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x13, +- 0x00, 0x02, 0x03, 0x9F, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x48, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x49, +- 0x03, 0x00, 0x00, 0x02, 0x1F, 0x48, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x49, 0x03, 0x01, 0x00, 0x02, +- 0x03, 0xC5, 0x03, 0x13, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x50, 0x03, 0x00, +- 0x00, 0x02, 0x1F, 0x51, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x50, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x51, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0x50, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x51, 0x03, 0x42, 0x00, 0x02, +- 0x03, 0xA5, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x59, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x59, 0x03, 0x01, +- 0x00, 0x02, 0x1F, 0x59, 0x03, 0x42, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x13, 0x00, 0x02, 0x03, 0xC9, +- 0x03, 0x14, 0x00, 0x02, 0x1F, 0x60, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x61, 0x03, 0x00, 0x00, 0x02, +- 0x1F, 0x60, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x61, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x60, 0x03, 0x42, +- 0x00, 0x02, 0x1F, 0x61, 0x03, 0x42, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x13, 0x00, 0x02, 0x03, 0xA9, +- 0x03, 0x14, 0x00, 0x02, 0x1F, 0x68, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x69, 0x03, 0x00, 0x00, 0x02, +- 0x1F, 0x68, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x69, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x68, 0x03, 0x42, +- 0x00, 0x02, 0x1F, 0x69, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x00, 0x00, 0x02, 0x03, 0xB1, +- 0x03, 0x01, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x00, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x01, 0x00, 0x02, +- 0x03, 0xB7, 0x03, 0x00, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x01, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x00, +- 0x00, 0x02, 0x03, 0xB9, 0x03, 0x01, 0x00, 0x02, 0x03, 0xBF, 0x03, 0x00, 0x00, 0x02, 0x03, 0xBF, +- 0x03, 0x01, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x00, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x01, 0x00, 0x02, +- 0x03, 0xC9, 0x03, 0x00, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x00, 0x03, 0x45, +- 0x00, 0x02, 0x1F, 0x01, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x02, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x03, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0x04, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x05, 0x03, 0x45, 0x00, 0x02, +- 0x1F, 0x06, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x07, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x08, 0x03, 0x45, +- 0x00, 0x02, 0x1F, 0x09, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0A, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0B, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0C, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0D, 0x03, 0x45, 0x00, 0x02, +- 0x1F, 0x0E, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0F, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x20, 0x03, 0x45, +- 0x00, 0x02, 0x1F, 0x21, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x22, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x23, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0x24, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x25, 0x03, 0x45, 0x00, 0x02, +- 0x1F, 0x26, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x27, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x28, 0x03, 0x45, +- 0x00, 0x02, 0x1F, 0x29, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2A, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2B, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2C, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2D, 0x03, 0x45, 0x00, 0x02, +- 0x1F, 0x2E, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2F, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x60, 0x03, 0x45, +- 0x00, 0x02, 0x1F, 0x61, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x62, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x63, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0x64, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x65, 0x03, 0x45, 0x00, 0x02, +- 0x1F, 0x66, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x67, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x68, 0x03, 0x45, +- 0x00, 0x02, 0x1F, 0x69, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6A, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6B, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6C, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6D, 0x03, 0x45, 0x00, 0x02, +- 0x1F, 0x6E, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6F, 0x03, 0x45, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x06, +- 0x00, 0x02, 0x03, 0xB1, 0x03, 0x04, 0x00, 0x02, 0x1F, 0x70, 0x03, 0x45, 0x00, 0x02, 0x03, 0xB1, +- 0x03, 0x45, 0x00, 0x02, 0x03, 0xAC, 0x03, 0x45, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0xB3, 0x03, 0x42, 0x00, 0x02, 0x03, 0x91, 0x03, 0x06, 0x00, 0x02, 0x03, 0x91, 0x03, 0x04, +- 0x00, 0x02, 0x03, 0x91, 0x03, 0x00, 0x00, 0x02, 0x03, 0x91, 0x03, 0x01, 0x00, 0x02, 0x03, 0x91, +- 0x03, 0x45, 0x00, 0x02, 0x00, 0xA8, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x74, 0x03, 0x45, 0x00, 0x02, +- 0x03, 0xB7, 0x03, 0x45, 0x00, 0x02, 0x03, 0xAE, 0x03, 0x45, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x42, +- 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x42, 0x00, 0x02, 0x03, 0x95, 0x03, 0x00, 0x00, 0x02, 0x03, 0x95, +- 0x03, 0x01, 0x00, 0x02, 0x03, 0x97, 0x03, 0x00, 0x00, 0x02, 0x03, 0x97, 0x03, 0x01, 0x00, 0x02, +- 0x03, 0x97, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xBF, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xBF, 0x03, 0x01, +- 0x00, 0x02, 0x1F, 0xBF, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x06, 0x00, 0x02, 0x03, 0xB9, +- 0x03, 0x04, 0x00, 0x02, 0x03, 0xCA, 0x03, 0x00, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x44, 0x00, 0x02, +- 0x03, 0xB9, 0x03, 0x42, 0x00, 0x02, 0x03, 0xCA, 0x03, 0x42, 0x00, 0x02, 0x03, 0x99, 0x03, 0x06, +- 0x00, 0x02, 0x03, 0x99, 0x03, 0x04, 0x00, 0x02, 0x03, 0x99, 0x03, 0x00, 0x00, 0x02, 0x03, 0x99, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0xFE, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xFE, 0x03, 0x01, 0x00, 0x02, +- 0x1F, 0xFE, 0x03, 0x42, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x06, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x04, +- 0x00, 0x02, 0x03, 0xCB, 0x03, 0x00, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x44, 0x00, 0x02, 0x03, 0xC1, ++ 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x4C, 0x09, 0x66, 0x11, 0x1A, 0x17, 0x08, 0x1C, 0xC2, ++ 0x20, 0xBC, 0x24, 0x9E, 0x27, 0x3C, 0x29, 0x7A, 0x2B, 0x42, 0x2D, 0x22, 0x2E, 0xD2, 0x30, 0x80, ++ 0x31, 0xE8, 0x33, 0x50, 0x34, 0xB8, 0x35, 0x94, 0x36, 0x70, 0x37, 0x4C, 0x38, 0x1A, 0x38, 0xE8, ++ 0x39, 0xB6, 0x3A, 0x68, 0x3B, 0x1A, 0x3B, 0x40, 0x3B, 0x66, 0x3B, 0x8C, 0x3B, 0xB2, 0x3B, 0xD8, ++ 0x3B, 0xFE, 0x3C, 0x24, 0x3C, 0x4A, 0x3C, 0x70, 0x3C, 0x96, 0x3C, 0xBC, 0x00, 0x01, 0x07, 0x46, ++ 0x00, 0xE8, 0x01, 0xD6, 0x01, 0xDC, 0x01, 0xE2, 0x01, 0xE8, 0x01, 0xEE, 0x01, 0xF4, 0x01, 0xFA, ++ 0x02, 0x00, 0x02, 0x06, 0x02, 0x0C, 0x02, 0x12, 0x02, 0x18, 0x02, 0x1E, 0x02, 0x24, 0x02, 0x2A, ++ 0x02, 0x30, 0x02, 0x36, 0x02, 0x3C, 0x02, 0x42, 0x02, 0x48, 0x02, 0x4E, 0x02, 0x54, 0x02, 0x5A, ++ 0x02, 0x60, 0x02, 0x66, 0x02, 0x6C, 0x02, 0x72, 0x02, 0x78, 0x02, 0x7E, 0x02, 0x84, 0x02, 0x8A, ++ 0x02, 0x90, 0x02, 0x96, 0x02, 0x9C, 0x02, 0xA2, 0x02, 0xA8, 0x02, 0xAE, 0x02, 0xB4, 0x02, 0xBA, ++ 0x02, 0xC0, 0x02, 0xC6, 0x02, 0xCC, 0x02, 0xD2, 0x02, 0xD8, 0x02, 0xDE, 0x02, 0xE4, 0x02, 0xEA, ++ 0x02, 0xF0, 0x02, 0xF6, 0x02, 0xFC, 0x03, 0x02, 0x03, 0x08, 0x03, 0x0E, 0x03, 0x14, 0x03, 0x1A, ++ 0x03, 0x20, 0x03, 0x26, 0x03, 0x2C, 0x03, 0x32, 0x03, 0x38, 0x03, 0x3E, 0x03, 0x44, 0x03, 0x4A, ++ 0x03, 0x50, 0x03, 0x56, 0x03, 0x5C, 0x03, 0x62, 0x03, 0x68, 0x03, 0x6E, 0x03, 0x74, 0x03, 0x7A, ++ 0x03, 0x80, 0x03, 0x86, 0x03, 0x8C, 0x03, 0x92, 0x03, 0x98, 0x03, 0x9E, 0x03, 0xA4, 0x03, 0xAA, ++ 0x03, 0xB0, 0x03, 0xB6, 0x03, 0xBC, 0x03, 0xC2, 0x03, 0xC8, 0x03, 0xCE, 0x03, 0xD4, 0x03, 0xDA, ++ 0x03, 0xE0, 0x03, 0xE6, 0x03, 0xEC, 0x03, 0xF2, 0x03, 0xF8, 0x03, 0xFE, 0x04, 0x04, 0x04, 0x0A, ++ 0x04, 0x10, 0x04, 0x16, 0x04, 0x1C, 0x04, 0x22, 0x04, 0x28, 0x04, 0x2E, 0x04, 0x34, 0x04, 0x3A, ++ 0x04, 0x40, 0x04, 0x46, 0x04, 0x4C, 0x04, 0x52, 0x04, 0x58, 0x04, 0x5E, 0x04, 0x64, 0x04, 0x6A, ++ 0x04, 0x70, 0x04, 0x76, 0x04, 0x7C, 0x04, 0x82, 0x04, 0x88, 0x04, 0x8E, 0x04, 0x94, 0x04, 0x9A, ++ 0x04, 0xA0, 0x04, 0xA6, 0x04, 0xAC, 0x04, 0xB2, 0x04, 0xB8, 0x04, 0xBE, 0x04, 0xC4, 0x04, 0xCA, ++ 0x04, 0xD0, 0x04, 0xD6, 0x04, 0xDC, 0x04, 0xE2, 0x04, 0xE8, 0x04, 0xEE, 0x04, 0xF4, 0x04, 0xFA, ++ 0x05, 0x00, 0x05, 0x06, 0x05, 0x0C, 0x05, 0x12, 0x05, 0x18, 0x05, 0x1E, 0x05, 0x24, 0x05, 0x2A, ++ 0x05, 0x30, 0x05, 0x36, 0x05, 0x3C, 0x05, 0x42, 0x05, 0x48, 0x05, 0x4E, 0x05, 0x54, 0x05, 0x5A, ++ 0x05, 0x60, 0x05, 0x66, 0x05, 0x6C, 0x05, 0x72, 0x05, 0x78, 0x05, 0x7E, 0x05, 0x84, 0x05, 0x8A, ++ 0x05, 0x90, 0x05, 0x96, 0x05, 0x9C, 0x05, 0xA2, 0x05, 0xA8, 0x05, 0xAE, 0x05, 0xB4, 0x05, 0xBA, ++ 0x05, 0xC0, 0x05, 0xC6, 0x05, 0xCC, 0x05, 0xD2, 0x05, 0xD8, 0x05, 0xDE, 0x05, 0xE4, 0x05, 0xEA, ++ 0x05, 0xF0, 0x05, 0xF6, 0x05, 0xFC, 0x06, 0x02, 0x06, 0x08, 0x06, 0x0E, 0x06, 0x14, 0x06, 0x1A, ++ 0x06, 0x20, 0x06, 0x26, 0x06, 0x2C, 0x06, 0x32, 0x06, 0x38, 0x06, 0x3E, 0x06, 0x44, 0x06, 0x4A, ++ 0x06, 0x50, 0x06, 0x56, 0x06, 0x5C, 0x06, 0x62, 0x06, 0x68, 0x06, 0x6E, 0x06, 0x74, 0x06, 0x7A, ++ 0x06, 0x80, 0x06, 0x86, 0x06, 0x8C, 0x06, 0x92, 0x06, 0x98, 0x06, 0x9E, 0x06, 0xA4, 0x06, 0xAA, ++ 0x06, 0xB0, 0x06, 0xB6, 0x06, 0xBC, 0x06, 0xC2, 0x06, 0xC8, 0x06, 0xCE, 0x06, 0xD4, 0x06, 0xDA, ++ 0x06, 0xE0, 0x06, 0xE6, 0x06, 0xEC, 0x06, 0xF2, 0x06, 0xF8, 0x06, 0xFE, 0x07, 0x04, 0x07, 0x0A, ++ 0x07, 0x10, 0x07, 0x16, 0x07, 0x1C, 0x07, 0x22, 0x07, 0x28, 0x07, 0x2E, 0x07, 0x34, 0x07, 0x3A, ++ 0x07, 0x40, 0x00, 0x02, 0x00, 0xA8, 0x03, 0x01, 0x00, 0x02, 0x03, 0x91, 0x03, 0x01, 0x00, 0x02, ++ 0x03, 0x95, 0x03, 0x01, 0x00, 0x02, 0x03, 0x97, 0x03, 0x01, 0x00, 0x02, 0x03, 0x99, 0x03, 0x01, ++ 0x00, 0x02, 0x03, 0x9F, 0x03, 0x01, 0x00, 0x02, 0x03, 0xA5, 0x03, 0x01, 0x00, 0x02, 0x03, 0xA9, ++ 0x03, 0x01, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x44, 0x00, 0x02, 0x03, 0x99, 0x03, 0x08, 0x00, 0x02, ++ 0x03, 0xA5, 0x03, 0x08, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x01, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x01, ++ 0x00, 0x02, 0x03, 0xB7, 0x03, 0x01, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x01, 0x00, 0x02, 0x03, 0xC5, ++ 0x03, 0x44, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x08, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x08, 0x00, 0x02, ++ 0x03, 0xBF, 0x03, 0x01, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x01, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x01, ++ 0x00, 0x02, 0x03, 0xD2, 0x03, 0x01, 0x00, 0x02, 0x03, 0xD2, 0x03, 0x08, 0x00, 0x02, 0x03, 0xB1, ++ 0x03, 0x13, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x00, 0x03, 0x00, 0x00, 0x02, ++ 0x1F, 0x01, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x00, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x01, 0x03, 0x01, ++ 0x00, 0x02, 0x1F, 0x00, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x01, 0x03, 0x42, 0x00, 0x02, 0x03, 0x91, ++ 0x03, 0x13, 0x00, 0x02, 0x03, 0x91, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x08, 0x03, 0x00, 0x00, 0x02, ++ 0x1F, 0x09, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x08, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x09, 0x03, 0x01, ++ 0x00, 0x02, 0x1F, 0x08, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x09, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB5, ++ 0x03, 0x13, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x10, 0x03, 0x00, 0x00, 0x02, ++ 0x1F, 0x11, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x10, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x11, 0x03, 0x01, ++ 0x00, 0x02, 0x03, 0x95, 0x03, 0x13, 0x00, 0x02, 0x03, 0x95, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x18, ++ 0x03, 0x00, 0x00, 0x02, 0x1F, 0x19, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x18, 0x03, 0x01, 0x00, 0x02, ++ 0x1F, 0x19, 0x03, 0x01, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x13, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x14, ++ 0x00, 0x02, 0x1F, 0x20, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x21, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x20, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x21, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x20, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0x21, 0x03, 0x42, 0x00, 0x02, 0x03, 0x97, 0x03, 0x13, 0x00, 0x02, 0x03, 0x97, 0x03, 0x14, ++ 0x00, 0x02, 0x1F, 0x28, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x29, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x28, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x29, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x28, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0x29, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x13, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x14, ++ 0x00, 0x02, 0x1F, 0x30, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x31, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x30, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x31, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x30, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0x31, 0x03, 0x42, 0x00, 0x02, 0x03, 0x99, 0x03, 0x13, 0x00, 0x02, 0x03, 0x99, 0x03, 0x14, ++ 0x00, 0x02, 0x1F, 0x38, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x39, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x38, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x39, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x38, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0x39, 0x03, 0x42, 0x00, 0x02, 0x03, 0xBF, 0x03, 0x13, 0x00, 0x02, 0x03, 0xBF, 0x03, 0x14, ++ 0x00, 0x02, 0x1F, 0x40, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x41, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x40, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x41, 0x03, 0x01, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x13, 0x00, 0x02, ++ 0x03, 0x9F, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x48, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x49, 0x03, 0x00, ++ 0x00, 0x02, 0x1F, 0x48, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x49, 0x03, 0x01, 0x00, 0x02, 0x03, 0xC5, ++ 0x03, 0x13, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x50, 0x03, 0x00, 0x00, 0x02, ++ 0x1F, 0x51, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x50, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x51, 0x03, 0x01, ++ 0x00, 0x02, 0x1F, 0x50, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x51, 0x03, 0x42, 0x00, 0x02, 0x03, 0xA5, ++ 0x03, 0x14, 0x00, 0x02, 0x1F, 0x59, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x59, 0x03, 0x01, 0x00, 0x02, ++ 0x1F, 0x59, 0x03, 0x42, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x13, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x14, ++ 0x00, 0x02, 0x1F, 0x60, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x61, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x60, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x61, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x60, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0x61, 0x03, 0x42, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x13, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x14, ++ 0x00, 0x02, 0x1F, 0x68, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x69, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x68, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x69, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x68, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0x69, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x00, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x00, ++ 0x00, 0x02, 0x03, 0xB7, 0x03, 0x00, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x00, 0x00, 0x02, 0x03, 0xBF, ++ 0x03, 0x00, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x00, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x00, 0x00, 0x02, ++ 0x1F, 0x00, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x01, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x02, 0x03, 0x45, ++ 0x00, 0x02, 0x1F, 0x03, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x04, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x05, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0x06, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x07, 0x03, 0x45, 0x00, 0x02, ++ 0x1F, 0x08, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x09, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0A, 0x03, 0x45, ++ 0x00, 0x02, 0x1F, 0x0B, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0C, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0D, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0E, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x0F, 0x03, 0x45, 0x00, 0x02, ++ 0x1F, 0x20, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x21, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x22, 0x03, 0x45, ++ 0x00, 0x02, 0x1F, 0x23, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x24, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x25, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0x26, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x27, 0x03, 0x45, 0x00, 0x02, ++ 0x1F, 0x28, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x29, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2A, 0x03, 0x45, ++ 0x00, 0x02, 0x1F, 0x2B, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2C, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2D, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2E, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x2F, 0x03, 0x45, 0x00, 0x02, ++ 0x1F, 0x60, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x61, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x62, 0x03, 0x45, ++ 0x00, 0x02, 0x1F, 0x63, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x64, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x65, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0x66, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x67, 0x03, 0x45, 0x00, 0x02, ++ 0x1F, 0x68, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x69, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6A, 0x03, 0x45, ++ 0x00, 0x02, 0x1F, 0x6B, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6C, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6D, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6E, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x6F, 0x03, 0x45, 0x00, 0x02, ++ 0x03, 0xB1, 0x03, 0x06, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x04, 0x00, 0x02, 0x1F, 0x70, 0x03, 0x45, ++ 0x00, 0x02, 0x03, 0xB1, 0x03, 0x45, 0x00, 0x02, 0x03, 0xAC, 0x03, 0x45, 0x00, 0x02, 0x03, 0xB1, ++ 0x03, 0x42, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x42, 0x00, 0x02, 0x03, 0x91, 0x03, 0x06, 0x00, 0x02, ++ 0x03, 0x91, 0x03, 0x04, 0x00, 0x02, 0x03, 0x91, 0x03, 0x00, 0x00, 0x02, 0x03, 0x91, 0x03, 0x45, ++ 0x00, 0x02, 0x00, 0xA8, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x74, 0x03, 0x45, 0x00, 0x02, 0x03, 0xB7, ++ 0x03, 0x45, 0x00, 0x02, 0x03, 0xAE, 0x03, 0x45, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0xC3, 0x03, 0x42, 0x00, 0x02, 0x03, 0x95, 0x03, 0x00, 0x00, 0x02, 0x03, 0x97, 0x03, 0x00, ++ 0x00, 0x02, 0x03, 0x97, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xBF, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xBF, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0xBF, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x06, 0x00, 0x02, ++ 0x03, 0xB9, 0x03, 0x04, 0x00, 0x02, 0x03, 0xCA, 0x03, 0x00, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x42, ++ 0x00, 0x02, 0x03, 0xCA, 0x03, 0x42, 0x00, 0x02, 0x03, 0x99, 0x03, 0x06, 0x00, 0x02, 0x03, 0x99, ++ 0x03, 0x04, 0x00, 0x02, 0x03, 0x99, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xFE, 0x03, 0x00, 0x00, 0x02, ++ 0x1F, 0xFE, 0x03, 0x01, 0x00, 0x02, 0x1F, 0xFE, 0x03, 0x42, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x06, ++ 0x00, 0x02, 0x03, 0xC5, 0x03, 0x04, 0x00, 0x02, 0x03, 0xCB, 0x03, 0x00, 0x00, 0x02, 0x03, 0xC1, + 0x03, 0x13, 0x00, 0x02, 0x03, 0xC1, 0x03, 0x14, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x42, 0x00, 0x02, + 0x03, 0xCB, 0x03, 0x42, 0x00, 0x02, 0x03, 0xA5, 0x03, 0x06, 0x00, 0x02, 0x03, 0xA5, 0x03, 0x04, +- 0x00, 0x02, 0x03, 0xA5, 0x03, 0x00, 0x00, 0x02, 0x03, 0xA5, 0x03, 0x01, 0x00, 0x02, 0x03, 0xA1, +- 0x03, 0x14, 0x00, 0x02, 0x00, 0xA8, 0x03, 0x00, 0x00, 0x02, 0x00, 0xA8, 0x03, 0x01, 0x00, 0x02, +- 0x1F, 0x7C, 0x03, 0x45, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x45, 0x00, 0x02, 0x03, 0xCE, 0x03, 0x45, +- 0x00, 0x02, 0x03, 0xC9, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x42, 0x00, 0x02, 0x03, 0x9F, +- 0x03, 0x00, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x01, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x00, 0x00, 0x02, +- 0x03, 0xA9, 0x03, 0x01, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x45, 0x00, 0x01, 0x00, 0xF9, 0x03, 0x85, +- 0x03, 0x86, 0x03, 0x88, 0x03, 0x89, 0x03, 0x8A, 0x03, 0x8C, 0x03, 0x8E, 0x03, 0x8F, 0x03, 0x90, +- 0x03, 0xAA, 0x03, 0xAB, 0x03, 0xAC, 0x03, 0xAD, 0x03, 0xAE, 0x03, 0xAF, 0x03, 0xB0, 0x03, 0xCA, +- 0x03, 0xCB, 0x03, 0xCC, 0x03, 0xCD, 0x03, 0xCE, 0x03, 0xD3, 0x03, 0xD4, 0x1F, 0x00, 0x1F, 0x01, +- 0x1F, 0x02, 0x1F, 0x03, 0x1F, 0x04, 0x1F, 0x05, 0x1F, 0x06, 0x1F, 0x07, 0x1F, 0x08, 0x1F, 0x09, +- 0x1F, 0x0A, 0x1F, 0x0B, 0x1F, 0x0C, 0x1F, 0x0D, 0x1F, 0x0E, 0x1F, 0x0F, 0x1F, 0x10, 0x1F, 0x11, +- 0x1F, 0x12, 0x1F, 0x13, 0x1F, 0x14, 0x1F, 0x15, 0x1F, 0x18, 0x1F, 0x19, 0x1F, 0x1A, 0x1F, 0x1B, +- 0x1F, 0x1C, 0x1F, 0x1D, 0x1F, 0x20, 0x1F, 0x21, 0x1F, 0x22, 0x1F, 0x23, 0x1F, 0x24, 0x1F, 0x25, +- 0x1F, 0x26, 0x1F, 0x27, 0x1F, 0x28, 0x1F, 0x29, 0x1F, 0x2A, 0x1F, 0x2B, 0x1F, 0x2C, 0x1F, 0x2D, +- 0x1F, 0x2E, 0x1F, 0x2F, 0x1F, 0x30, 0x1F, 0x31, 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, +- 0x1F, 0x36, 0x1F, 0x37, 0x1F, 0x38, 0x1F, 0x39, 0x1F, 0x3A, 0x1F, 0x3B, 0x1F, 0x3C, 0x1F, 0x3D, +- 0x1F, 0x3E, 0x1F, 0x3F, 0x1F, 0x40, 0x1F, 0x41, 0x1F, 0x42, 0x1F, 0x43, 0x1F, 0x44, 0x1F, 0x45, +- 0x1F, 0x48, 0x1F, 0x49, 0x1F, 0x4A, 0x1F, 0x4B, 0x1F, 0x4C, 0x1F, 0x4D, 0x1F, 0x50, 0x1F, 0x51, +- 0x1F, 0x52, 0x1F, 0x53, 0x1F, 0x54, 0x1F, 0x55, 0x1F, 0x56, 0x1F, 0x57, 0x1F, 0x59, 0x1F, 0x5B, +- 0x1F, 0x5D, 0x1F, 0x5F, 0x1F, 0x60, 0x1F, 0x61, 0x1F, 0x62, 0x1F, 0x63, 0x1F, 0x64, 0x1F, 0x65, +- 0x1F, 0x66, 0x1F, 0x67, 0x1F, 0x68, 0x1F, 0x69, 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, +- 0x1F, 0x6E, 0x1F, 0x6F, 0x1F, 0x70, 0x1F, 0x71, 0x1F, 0x72, 0x1F, 0x73, 0x1F, 0x74, 0x1F, 0x75, +- 0x1F, 0x76, 0x1F, 0x77, 0x1F, 0x78, 0x1F, 0x79, 0x1F, 0x7A, 0x1F, 0x7B, 0x1F, 0x7C, 0x1F, 0x7D, +- 0x1F, 0x80, 0x1F, 0x81, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, +- 0x1F, 0x88, 0x1F, 0x89, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, +- 0x1F, 0x90, 0x1F, 0x91, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, +- 0x1F, 0x98, 0x1F, 0x99, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, +- 0x1F, 0xA0, 0x1F, 0xA1, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, +- 0x1F, 0xA8, 0x1F, 0xA9, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, +- 0x1F, 0xB0, 0x1F, 0xB1, 0x1F, 0xB2, 0x1F, 0xB3, 0x1F, 0xB4, 0x1F, 0xB6, 0x1F, 0xB7, 0x1F, 0xB8, +- 0x1F, 0xB9, 0x1F, 0xBA, 0x1F, 0xBB, 0x1F, 0xBC, 0x1F, 0xC1, 0x1F, 0xC2, 0x1F, 0xC3, 0x1F, 0xC4, +- 0x1F, 0xC6, 0x1F, 0xC7, 0x1F, 0xC8, 0x1F, 0xC9, 0x1F, 0xCA, 0x1F, 0xCB, 0x1F, 0xCC, 0x1F, 0xCD, +- 0x1F, 0xCE, 0x1F, 0xCF, 0x1F, 0xD0, 0x1F, 0xD1, 0x1F, 0xD2, 0x1F, 0xD3, 0x1F, 0xD6, 0x1F, 0xD7, +- 0x1F, 0xD8, 0x1F, 0xD9, 0x1F, 0xDA, 0x1F, 0xDB, 0x1F, 0xDD, 0x1F, 0xDE, 0x1F, 0xDF, 0x1F, 0xE0, +- 0x1F, 0xE1, 0x1F, 0xE2, 0x1F, 0xE3, 0x1F, 0xE4, 0x1F, 0xE5, 0x1F, 0xE6, 0x1F, 0xE7, 0x1F, 0xE8, +- 0x1F, 0xE9, 0x1F, 0xEA, 0x1F, 0xEB, 0x1F, 0xEC, 0x1F, 0xED, 0x1F, 0xEE, 0x1F, 0xF2, 0x1F, 0xF3, +- 0x1F, 0xF4, 0x1F, 0xF6, 0x1F, 0xF7, 0x1F, 0xF8, 0x1F, 0xF9, 0x1F, 0xFA, 0x1F, 0xFB, 0x1F, 0xFC, +- 0x00, 0x01, 0x06, 0xB8, 0x00, 0xD1, 0x01, 0xA8, 0x01, 0xAE, 0x01, 0xB4, 0x01, 0xBA, 0x01, 0xC0, +- 0x01, 0xC6, 0x01, 0xCC, 0x01, 0xD2, 0x01, 0xD8, 0x01, 0xDE, 0x01, 0xE4, 0x01, 0xEA, 0x01, 0xF0, +- 0x01, 0xF6, 0x01, 0xFC, 0x02, 0x02, 0x02, 0x08, 0x02, 0x0E, 0x02, 0x14, 0x02, 0x1A, 0x02, 0x20, +- 0x02, 0x26, 0x02, 0x2C, 0x02, 0x32, 0x02, 0x38, 0x02, 0x40, 0x02, 0x48, 0x02, 0x4E, 0x02, 0x54, +- 0x02, 0x5A, 0x02, 0x60, 0x02, 0x66, 0x02, 0x6E, 0x02, 0x76, 0x02, 0x7C, 0x02, 0x82, 0x02, 0x88, +- 0x02, 0x8E, 0x02, 0x94, 0x02, 0x9A, 0x02, 0xA0, 0x02, 0xA6, 0x02, 0xAC, 0x02, 0xB2, 0x02, 0xB8, +- 0x02, 0xBE, 0x02, 0xC4, 0x02, 0xCA, 0x02, 0xD0, 0x02, 0xD8, 0x02, 0xE0, 0x02, 0xE6, 0x02, 0xEC, +- 0x02, 0xF2, 0x02, 0xF8, 0x02, 0xFE, 0x03, 0x06, 0x03, 0x0E, 0x03, 0x14, 0x03, 0x1A, 0x03, 0x20, +- 0x03, 0x26, 0x03, 0x2C, 0x03, 0x32, 0x03, 0x3A, 0x03, 0x42, 0x03, 0x48, 0x03, 0x4E, 0x03, 0x54, +- 0x03, 0x5A, 0x03, 0x60, 0x03, 0x68, 0x03, 0x70, 0x03, 0x76, 0x03, 0x7C, 0x03, 0x82, 0x03, 0x88, +- 0x03, 0x8E, 0x03, 0x94, 0x03, 0x9A, 0x03, 0xA0, 0x03, 0xA6, 0x03, 0xAC, 0x03, 0xB2, 0x03, 0xB8, +- 0x03, 0xBE, 0x03, 0xC4, 0x03, 0xCA, 0x03, 0xD2, 0x03, 0xDA, 0x03, 0xE0, 0x03, 0xE6, 0x03, 0xEE, +- 0x03, 0xF4, 0x03, 0xFA, 0x04, 0x00, 0x04, 0x06, 0x04, 0x0C, 0x04, 0x14, 0x04, 0x1C, 0x04, 0x22, +- 0x04, 0x28, 0x04, 0x2E, 0x04, 0x34, 0x04, 0x3A, 0x04, 0x40, 0x04, 0x48, 0x04, 0x50, 0x04, 0x56, +- 0x04, 0x5C, 0x04, 0x62, 0x04, 0x68, 0x04, 0x6E, 0x04, 0x74, 0x04, 0x7A, 0x04, 0x80, 0x04, 0x86, +- 0x04, 0x8C, 0x04, 0x92, 0x04, 0x98, 0x04, 0x9E, 0x04, 0xA4, 0x04, 0xAA, 0x04, 0xB0, 0x04, 0xB6, +- 0x04, 0xBC, 0x04, 0xC2, 0x04, 0xC8, 0x04, 0xCE, 0x04, 0xD4, 0x04, 0xDA, 0x04, 0xE0, 0x04, 0xE6, +- 0x04, 0xEC, 0x04, 0xF2, 0x04, 0xF8, 0x04, 0xFE, 0x05, 0x04, 0x05, 0x0A, 0x05, 0x10, 0x05, 0x16, +- 0x05, 0x1C, 0x05, 0x22, 0x05, 0x28, 0x05, 0x2E, 0x05, 0x34, 0x05, 0x3A, 0x05, 0x40, 0x05, 0x46, +- 0x05, 0x4C, 0x05, 0x52, 0x05, 0x58, 0x05, 0x5E, 0x05, 0x64, 0x05, 0x6A, 0x05, 0x70, 0x05, 0x76, +- 0x05, 0x7C, 0x05, 0x82, 0x05, 0x88, 0x05, 0x8E, 0x05, 0x94, 0x05, 0x9A, 0x05, 0xA0, 0x05, 0xA6, +- 0x05, 0xAC, 0x05, 0xB2, 0x05, 0xB8, 0x05, 0xBE, 0x05, 0xC4, 0x05, 0xCA, 0x05, 0xD0, 0x05, 0xD6, +- 0x05, 0xDC, 0x05, 0xE2, 0x05, 0xE8, 0x05, 0xEE, 0x05, 0xF4, 0x05, 0xFA, 0x06, 0x00, 0x06, 0x06, +- 0x06, 0x0C, 0x06, 0x12, 0x06, 0x18, 0x06, 0x1E, 0x06, 0x24, 0x06, 0x2A, 0x06, 0x30, 0x06, 0x36, +- 0x06, 0x3E, 0x06, 0x44, 0x06, 0x4A, 0x06, 0x50, 0x06, 0x56, 0x06, 0x5C, 0x06, 0x62, 0x06, 0x68, +- 0x06, 0x70, 0x06, 0x76, 0x06, 0x7C, 0x06, 0x82, 0x06, 0x88, 0x06, 0x8E, 0x06, 0x94, 0x06, 0x9A, +- 0x06, 0xA0, 0x06, 0xA6, 0x06, 0xAC, 0x06, 0xB2, 0x00, 0x02, 0x00, 0xA8, 0x03, 0x41, 0x00, 0x02, +- 0x03, 0x91, 0x03, 0x41, 0x00, 0x02, 0x03, 0x95, 0x03, 0x41, 0x00, 0x02, 0x03, 0x97, 0x03, 0x41, +- 0x00, 0x02, 0x03, 0x99, 0x03, 0x41, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x41, 0x00, 0x02, 0x03, 0xA5, +- 0x03, 0x41, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x41, 0x00, 0x02, 0x03, 0xCA, 0x03, 0x01, 0x00, 0x02, +- 0x03, 0xB1, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x41, +- 0x00, 0x02, 0x03, 0xB9, 0x03, 0x41, 0x00, 0x02, 0x03, 0xCB, 0x03, 0x01, 0x00, 0x02, 0x1F, 0xBE, +- 0x03, 0x08, 0x00, 0x02, 0x03, 0xBF, 0x03, 0x41, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x41, 0x00, 0x02, +- 0x03, 0xC9, 0x03, 0x41, 0x00, 0x02, 0x03, 0xD2, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x43, +- 0x00, 0x02, 0x1F, 0x00, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x01, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x00, +- 0x03, 0x41, 0x00, 0x02, 0x1F, 0x01, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x42, +- 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0x91, 0x03, 0x43, 0x00, 0x02, +- 0x1F, 0x08, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x09, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x08, 0x03, 0x41, +- 0x00, 0x02, 0x1F, 0x09, 0x03, 0x41, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, +- 0x03, 0x91, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x10, +- 0x03, 0x40, 0x00, 0x02, 0x1F, 0x11, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x10, 0x03, 0x41, 0x00, 0x02, +- 0x1F, 0x11, 0x03, 0x41, 0x00, 0x02, 0x03, 0x95, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x18, 0x03, 0x40, +- 0x00, 0x02, 0x1F, 0x19, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x18, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x19, +- 0x03, 0x41, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x20, 0x03, 0x40, 0x00, 0x02, +- 0x1F, 0x21, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x20, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x21, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x42, +- 0x00, 0x02, 0x03, 0x97, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x28, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x29, +- 0x03, 0x40, 0x00, 0x02, 0x1F, 0x28, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x29, 0x03, 0x41, 0x00, 0x03, +- 0x03, 0x97, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, +- 0x03, 0xB9, 0x03, 0x43, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x30, 0x03, 0x40, +- 0x00, 0x02, 0x1F, 0x31, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x30, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x31, +- 0x03, 0x41, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x14, +- 0x03, 0x42, 0x00, 0x02, 0x03, 0x99, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x38, 0x03, 0x40, 0x00, 0x02, +- 0x1F, 0x39, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x38, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x39, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0x99, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0x99, 0x03, 0x14, 0x03, 0x42, +- 0x00, 0x02, 0x03, 0xBF, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x40, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x41, +- 0x03, 0x40, 0x00, 0x02, 0x1F, 0x40, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x41, 0x03, 0x41, 0x00, 0x02, +- 0x03, 0x9F, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x48, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x49, 0x03, 0x40, +- 0x00, 0x02, 0x1F, 0x48, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x49, 0x03, 0x41, 0x00, 0x02, 0x03, 0xC5, +- 0x03, 0x43, 0x00, 0x02, 0x1F, 0x50, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x51, 0x03, 0x40, 0x00, 0x02, +- 0x1F, 0x50, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x51, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x13, +- 0x03, 0x42, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x59, 0x03, 0x40, +- 0x00, 0x02, 0x1F, 0x59, 0x03, 0x41, 0x00, 0x03, 0x03, 0xA5, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, +- 0x03, 0xC9, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x60, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x61, 0x03, 0x40, +- 0x00, 0x02, 0x1F, 0x60, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x61, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, +- 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0xA9, +- 0x03, 0x43, 0x00, 0x02, 0x21, 0x26, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x68, 0x03, 0x40, 0x00, 0x02, +- 0x1F, 0x69, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x68, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x69, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x42, +- 0x00, 0x02, 0x03, 0xB1, 0x03, 0x40, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB5, +- 0x03, 0x40, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x40, 0x00, 0x02, +- 0x03, 0xB7, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x40, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x41, +- 0x00, 0x02, 0x03, 0xBF, 0x03, 0x40, 0x00, 0x02, 0x03, 0xBF, 0x03, 0x41, 0x00, 0x02, 0x03, 0xC5, +- 0x03, 0x40, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x41, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x40, 0x00, 0x02, +- 0x03, 0xC9, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x14, +- 0x00, 0x02, 0x1F, 0x80, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x81, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x80, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0x81, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x80, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0x81, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xBC, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xBC, 0x03, 0x14, +- 0x00, 0x02, 0x1F, 0x88, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x89, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x88, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0x89, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x88, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0x89, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x14, +- 0x00, 0x02, 0x1F, 0x90, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x91, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x90, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0x91, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x90, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0x91, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xCC, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xCC, 0x03, 0x14, +- 0x00, 0x02, 0x1F, 0x98, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x99, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x98, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0x99, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x98, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0x99, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x14, +- 0x00, 0x02, 0x1F, 0xA0, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xA1, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xA0, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0xA1, 0x03, 0x01, 0x00, 0x02, 0x1F, 0xA0, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0xA1, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xFC, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xFC, 0x03, 0x14, +- 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xA9, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xA8, +- 0x03, 0x01, 0x00, 0x02, 0x1F, 0xA9, 0x03, 0x01, 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0xA9, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x71, 0x03, 0x45, +- 0x00, 0x02, 0x1F, 0xB6, 0x03, 0x45, 0x00, 0x02, 0x03, 0x91, 0x03, 0x40, 0x00, 0x02, 0x03, 0x91, +- 0x03, 0x41, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x75, 0x03, 0x45, 0x00, 0x02, +- 0x1F, 0xC6, 0x03, 0x45, 0x00, 0x02, 0x03, 0x95, 0x03, 0x40, 0x00, 0x02, 0x03, 0x95, 0x03, 0x41, +- 0x00, 0x02, 0x03, 0x97, 0x03, 0x40, 0x00, 0x02, 0x03, 0x97, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xBF, +- 0x03, 0x40, 0x00, 0x02, 0x1F, 0xBF, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x06, 0x00, 0x02, +- 0x1F, 0xBE, 0x03, 0x04, 0x00, 0x02, 0x03, 0xCA, 0x03, 0x40, 0x00, 0x02, 0x03, 0xCA, 0x03, 0x01, +- 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, 0x03, 0x42, 0x00, 0x02, +- 0x03, 0x99, 0x03, 0x40, 0x00, 0x02, 0x03, 0x99, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xFE, 0x03, 0x40, +- 0x00, 0x02, 0x1F, 0xFE, 0x03, 0x41, 0x00, 0x02, 0x03, 0xCB, 0x03, 0x40, 0x00, 0x02, 0x03, 0xCB, +- 0x03, 0x01, 0x00, 0x02, 0x03, 0xC1, 0x03, 0x43, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x42, +- 0x00, 0x02, 0x03, 0xA5, 0x03, 0x40, 0x00, 0x02, 0x03, 0xA5, 0x03, 0x41, 0x00, 0x02, 0x00, 0xA8, +- 0x03, 0x40, 0x00, 0x02, 0x00, 0xA8, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x00, 0x00, 0x02, +- 0x1F, 0x7D, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xF6, 0x03, 0x45, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x40, +- 0x00, 0x02, 0x03, 0x9F, 0x03, 0x41, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x40, 0x00, 0x02, 0x03, 0xA9, +- 0x03, 0x41, 0x00, 0x02, 0x21, 0x26, 0x03, 0x45, 0x00, 0x01, 0x00, 0xD1, 0x03, 0x85, 0x03, 0x86, +- 0x03, 0x88, 0x03, 0x89, 0x03, 0x8A, 0x03, 0x8C, 0x03, 0x8E, 0x03, 0x8F, 0x03, 0x90, 0x03, 0xAC, +- 0x03, 0xAD, 0x03, 0xAE, 0x03, 0xAF, 0x03, 0xB0, 0x03, 0xCA, 0x03, 0xCC, 0x03, 0xCD, 0x03, 0xCE, +- 0x03, 0xD3, 0x1F, 0x00, 0x1F, 0x02, 0x1F, 0x03, 0x1F, 0x04, 0x1F, 0x05, 0x1F, 0x06, 0x1F, 0x07, +- 0x1F, 0x08, 0x1F, 0x0A, 0x1F, 0x0B, 0x1F, 0x0C, 0x1F, 0x0D, 0x1F, 0x0E, 0x1F, 0x0F, 0x1F, 0x10, +- 0x1F, 0x12, 0x1F, 0x13, 0x1F, 0x14, 0x1F, 0x15, 0x1F, 0x18, 0x1F, 0x1A, 0x1F, 0x1B, 0x1F, 0x1C, +- 0x1F, 0x1D, 0x1F, 0x20, 0x1F, 0x22, 0x1F, 0x23, 0x1F, 0x24, 0x1F, 0x25, 0x1F, 0x26, 0x1F, 0x27, +- 0x1F, 0x28, 0x1F, 0x2A, 0x1F, 0x2B, 0x1F, 0x2C, 0x1F, 0x2D, 0x1F, 0x2E, 0x1F, 0x2F, 0x1F, 0x30, +- 0x1F, 0x31, 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x36, 0x1F, 0x37, 0x1F, 0x38, +- 0x1F, 0x3A, 0x1F, 0x3B, 0x1F, 0x3C, 0x1F, 0x3D, 0x1F, 0x3E, 0x1F, 0x3F, 0x1F, 0x40, 0x1F, 0x42, +- 0x1F, 0x43, 0x1F, 0x44, 0x1F, 0x45, 0x1F, 0x48, 0x1F, 0x4A, 0x1F, 0x4B, 0x1F, 0x4C, 0x1F, 0x4D, +- 0x1F, 0x50, 0x1F, 0x52, 0x1F, 0x53, 0x1F, 0x54, 0x1F, 0x55, 0x1F, 0x56, 0x1F, 0x57, 0x1F, 0x5B, +- 0x1F, 0x5D, 0x1F, 0x5F, 0x1F, 0x60, 0x1F, 0x62, 0x1F, 0x63, 0x1F, 0x64, 0x1F, 0x65, 0x1F, 0x66, +- 0x1F, 0x67, 0x1F, 0x68, 0x1F, 0x69, 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x6E, +- 0x1F, 0x6F, 0x1F, 0x70, 0x1F, 0x71, 0x1F, 0x72, 0x1F, 0x73, 0x1F, 0x74, 0x1F, 0x75, 0x1F, 0x76, +- 0x1F, 0x77, 0x1F, 0x78, 0x1F, 0x79, 0x1F, 0x7A, 0x1F, 0x7B, 0x1F, 0x7C, 0x1F, 0x7D, 0x1F, 0x80, ++ 0x00, 0x02, 0x03, 0xA5, 0x03, 0x00, 0x00, 0x02, 0x03, 0xA1, 0x03, 0x14, 0x00, 0x02, 0x00, 0xA8, ++ 0x03, 0x00, 0x00, 0x02, 0x1F, 0x7C, 0x03, 0x45, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x45, 0x00, 0x02, ++ 0x03, 0xCE, 0x03, 0x45, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x42, ++ 0x00, 0x02, 0x03, 0x9F, 0x03, 0x00, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x00, 0x00, 0x02, 0x03, 0xA9, ++ 0x03, 0x45, 0x00, 0x01, 0x00, 0xE8, 0x03, 0x85, 0x03, 0x86, 0x03, 0x88, 0x03, 0x89, 0x03, 0x8A, ++ 0x03, 0x8C, 0x03, 0x8E, 0x03, 0x8F, 0x03, 0x90, 0x03, 0xAA, 0x03, 0xAB, 0x03, 0xAC, 0x03, 0xAD, ++ 0x03, 0xAE, 0x03, 0xAF, 0x03, 0xB0, 0x03, 0xCA, 0x03, 0xCB, 0x03, 0xCC, 0x03, 0xCD, 0x03, 0xCE, ++ 0x03, 0xD3, 0x03, 0xD4, 0x1F, 0x00, 0x1F, 0x01, 0x1F, 0x02, 0x1F, 0x03, 0x1F, 0x04, 0x1F, 0x05, ++ 0x1F, 0x06, 0x1F, 0x07, 0x1F, 0x08, 0x1F, 0x09, 0x1F, 0x0A, 0x1F, 0x0B, 0x1F, 0x0C, 0x1F, 0x0D, ++ 0x1F, 0x0E, 0x1F, 0x0F, 0x1F, 0x10, 0x1F, 0x11, 0x1F, 0x12, 0x1F, 0x13, 0x1F, 0x14, 0x1F, 0x15, ++ 0x1F, 0x18, 0x1F, 0x19, 0x1F, 0x1A, 0x1F, 0x1B, 0x1F, 0x1C, 0x1F, 0x1D, 0x1F, 0x20, 0x1F, 0x21, ++ 0x1F, 0x22, 0x1F, 0x23, 0x1F, 0x24, 0x1F, 0x25, 0x1F, 0x26, 0x1F, 0x27, 0x1F, 0x28, 0x1F, 0x29, ++ 0x1F, 0x2A, 0x1F, 0x2B, 0x1F, 0x2C, 0x1F, 0x2D, 0x1F, 0x2E, 0x1F, 0x2F, 0x1F, 0x30, 0x1F, 0x31, ++ 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x36, 0x1F, 0x37, 0x1F, 0x38, 0x1F, 0x39, ++ 0x1F, 0x3A, 0x1F, 0x3B, 0x1F, 0x3C, 0x1F, 0x3D, 0x1F, 0x3E, 0x1F, 0x3F, 0x1F, 0x40, 0x1F, 0x41, ++ 0x1F, 0x42, 0x1F, 0x43, 0x1F, 0x44, 0x1F, 0x45, 0x1F, 0x48, 0x1F, 0x49, 0x1F, 0x4A, 0x1F, 0x4B, ++ 0x1F, 0x4C, 0x1F, 0x4D, 0x1F, 0x50, 0x1F, 0x51, 0x1F, 0x52, 0x1F, 0x53, 0x1F, 0x54, 0x1F, 0x55, ++ 0x1F, 0x56, 0x1F, 0x57, 0x1F, 0x59, 0x1F, 0x5B, 0x1F, 0x5D, 0x1F, 0x5F, 0x1F, 0x60, 0x1F, 0x61, ++ 0x1F, 0x62, 0x1F, 0x63, 0x1F, 0x64, 0x1F, 0x65, 0x1F, 0x66, 0x1F, 0x67, 0x1F, 0x68, 0x1F, 0x69, ++ 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x6E, 0x1F, 0x6F, 0x1F, 0x70, 0x1F, 0x72, ++ 0x1F, 0x74, 0x1F, 0x76, 0x1F, 0x78, 0x1F, 0x7A, 0x1F, 0x7C, 0x1F, 0x80, 0x1F, 0x81, 0x1F, 0x82, ++ 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, 0x1F, 0x89, 0x1F, 0x8A, ++ 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, 0x1F, 0x91, 0x1F, 0x92, ++ 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x99, 0x1F, 0x9A, ++ 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, 0x1F, 0xA1, 0x1F, 0xA2, ++ 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, 0x1F, 0xA9, 0x1F, 0xAA, ++ 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB0, 0x1F, 0xB1, 0x1F, 0xB2, ++ 0x1F, 0xB3, 0x1F, 0xB4, 0x1F, 0xB6, 0x1F, 0xB7, 0x1F, 0xB8, 0x1F, 0xB9, 0x1F, 0xBA, 0x1F, 0xBC, ++ 0x1F, 0xC1, 0x1F, 0xC2, 0x1F, 0xC3, 0x1F, 0xC4, 0x1F, 0xC6, 0x1F, 0xC7, 0x1F, 0xC8, 0x1F, 0xCA, ++ 0x1F, 0xCC, 0x1F, 0xCD, 0x1F, 0xCE, 0x1F, 0xCF, 0x1F, 0xD0, 0x1F, 0xD1, 0x1F, 0xD2, 0x1F, 0xD6, ++ 0x1F, 0xD7, 0x1F, 0xD8, 0x1F, 0xD9, 0x1F, 0xDA, 0x1F, 0xDD, 0x1F, 0xDE, 0x1F, 0xDF, 0x1F, 0xE0, ++ 0x1F, 0xE1, 0x1F, 0xE2, 0x1F, 0xE4, 0x1F, 0xE5, 0x1F, 0xE6, 0x1F, 0xE7, 0x1F, 0xE8, 0x1F, 0xE9, ++ 0x1F, 0xEA, 0x1F, 0xEC, 0x1F, 0xED, 0x1F, 0xF2, 0x1F, 0xF3, 0x1F, 0xF4, 0x1F, 0xF6, 0x1F, 0xF7, ++ 0x1F, 0xF8, 0x1F, 0xFA, 0x1F, 0xFC, 0x00, 0x01, 0x06, 0x30, 0x00, 0xC0, 0x01, 0x86, 0x01, 0x8C, ++ 0x01, 0x92, 0x01, 0x98, 0x01, 0x9E, 0x01, 0xA4, 0x01, 0xAA, 0x01, 0xB0, 0x01, 0xB6, 0x01, 0xBC, ++ 0x01, 0xC2, 0x01, 0xC8, 0x01, 0xCE, 0x01, 0xD4, 0x01, 0xDA, 0x01, 0xE0, 0x01, 0xE6, 0x01, 0xEC, ++ 0x01, 0xF2, 0x01, 0xF8, 0x01, 0xFE, 0x02, 0x04, 0x02, 0x0A, 0x02, 0x10, 0x02, 0x16, 0x02, 0x1E, ++ 0x02, 0x26, 0x02, 0x2C, 0x02, 0x32, 0x02, 0x38, 0x02, 0x3E, 0x02, 0x44, 0x02, 0x4C, 0x02, 0x54, ++ 0x02, 0x5A, 0x02, 0x60, 0x02, 0x66, 0x02, 0x6C, 0x02, 0x72, 0x02, 0x78, 0x02, 0x7E, 0x02, 0x84, ++ 0x02, 0x8A, 0x02, 0x90, 0x02, 0x96, 0x02, 0x9C, 0x02, 0xA2, 0x02, 0xA8, 0x02, 0xAE, 0x02, 0xB6, ++ 0x02, 0xBE, 0x02, 0xC4, 0x02, 0xCA, 0x02, 0xD0, 0x02, 0xD6, 0x02, 0xDC, 0x02, 0xE4, 0x02, 0xEC, ++ 0x02, 0xF2, 0x02, 0xF8, 0x02, 0xFE, 0x03, 0x04, 0x03, 0x0A, 0x03, 0x10, 0x03, 0x18, 0x03, 0x20, ++ 0x03, 0x26, 0x03, 0x2C, 0x03, 0x32, 0x03, 0x38, 0x03, 0x3E, 0x03, 0x46, 0x03, 0x4E, 0x03, 0x54, ++ 0x03, 0x5A, 0x03, 0x60, 0x03, 0x66, 0x03, 0x6C, 0x03, 0x72, 0x03, 0x78, 0x03, 0x7E, 0x03, 0x84, ++ 0x03, 0x8A, 0x03, 0x90, 0x03, 0x96, 0x03, 0x9C, 0x03, 0xA2, 0x03, 0xA8, 0x03, 0xB0, 0x03, 0xB8, ++ 0x03, 0xBE, 0x03, 0xC4, 0x03, 0xCC, 0x03, 0xD2, 0x03, 0xD8, 0x03, 0xDE, 0x03, 0xE4, 0x03, 0xEA, ++ 0x03, 0xF2, 0x03, 0xFA, 0x04, 0x00, 0x04, 0x06, 0x04, 0x0C, 0x04, 0x12, 0x04, 0x18, 0x04, 0x1E, ++ 0x04, 0x26, 0x04, 0x2E, 0x04, 0x34, 0x04, 0x3A, 0x04, 0x40, 0x04, 0x46, 0x04, 0x4C, 0x04, 0x52, ++ 0x04, 0x58, 0x04, 0x5E, 0x04, 0x64, 0x04, 0x6A, 0x04, 0x70, 0x04, 0x76, 0x04, 0x7C, 0x04, 0x82, ++ 0x04, 0x88, 0x04, 0x8E, 0x04, 0x94, 0x04, 0x9A, 0x04, 0xA0, 0x04, 0xA6, 0x04, 0xAC, 0x04, 0xB2, ++ 0x04, 0xB8, 0x04, 0xBE, 0x04, 0xC4, 0x04, 0xCA, 0x04, 0xD0, 0x04, 0xD6, 0x04, 0xDC, 0x04, 0xE2, ++ 0x04, 0xE8, 0x04, 0xEE, 0x04, 0xF4, 0x04, 0xFA, 0x05, 0x00, 0x05, 0x06, 0x05, 0x0C, 0x05, 0x12, ++ 0x05, 0x18, 0x05, 0x1E, 0x05, 0x24, 0x05, 0x2A, 0x05, 0x30, 0x05, 0x36, 0x05, 0x3C, 0x05, 0x42, ++ 0x05, 0x48, 0x05, 0x4E, 0x05, 0x54, 0x05, 0x5A, 0x05, 0x60, 0x05, 0x66, 0x05, 0x6C, 0x05, 0x72, ++ 0x05, 0x78, 0x05, 0x7E, 0x05, 0x84, 0x05, 0x8A, 0x05, 0x90, 0x05, 0x96, 0x05, 0x9C, 0x05, 0xA2, ++ 0x05, 0xA8, 0x05, 0xAE, 0x05, 0xB4, 0x05, 0xBA, 0x05, 0xC0, 0x05, 0xC6, 0x05, 0xCC, 0x05, 0xD2, ++ 0x05, 0xDA, 0x05, 0xE0, 0x05, 0xE6, 0x05, 0xEC, 0x05, 0xF2, 0x05, 0xF8, 0x06, 0x00, 0x06, 0x06, ++ 0x06, 0x0C, 0x06, 0x12, 0x06, 0x18, 0x06, 0x1E, 0x06, 0x24, 0x06, 0x2A, 0x00, 0x02, 0x00, 0xA8, ++ 0x03, 0x41, 0x00, 0x02, 0x03, 0x91, 0x03, 0x41, 0x00, 0x02, 0x03, 0x95, 0x03, 0x41, 0x00, 0x02, ++ 0x03, 0x97, 0x03, 0x41, 0x00, 0x02, 0x03, 0x99, 0x03, 0x41, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x41, ++ 0x00, 0x02, 0x03, 0xA5, 0x03, 0x41, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x41, 0x00, 0x02, 0x03, 0xCA, ++ 0x03, 0x01, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x41, 0x00, 0x02, ++ 0x03, 0xB7, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x41, 0x00, 0x02, 0x03, 0xCB, 0x03, 0x01, ++ 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x08, 0x00, 0x02, 0x03, 0xBF, 0x03, 0x41, 0x00, 0x02, 0x03, 0xC5, ++ 0x03, 0x41, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x41, 0x00, 0x02, 0x03, 0xD2, 0x03, 0x41, 0x00, 0x02, ++ 0x03, 0xB1, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x00, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x01, 0x03, 0x40, ++ 0x00, 0x02, 0x1F, 0x00, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x01, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, ++ 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0x91, ++ 0x03, 0x43, 0x00, 0x02, 0x1F, 0x08, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x09, 0x03, 0x40, 0x00, 0x02, ++ 0x1F, 0x08, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x09, 0x03, 0x41, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, ++ 0x03, 0x42, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x43, ++ 0x00, 0x02, 0x1F, 0x10, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x11, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x10, ++ 0x03, 0x41, 0x00, 0x02, 0x1F, 0x11, 0x03, 0x41, 0x00, 0x02, 0x03, 0x95, 0x03, 0x43, 0x00, 0x02, ++ 0x1F, 0x18, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x19, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x18, 0x03, 0x41, ++ 0x00, 0x02, 0x1F, 0x19, 0x03, 0x41, 0x00, 0x02, 0x03, 0xB7, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x20, ++ 0x03, 0x40, 0x00, 0x02, 0x1F, 0x21, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x20, 0x03, 0x41, 0x00, 0x02, ++ 0x1F, 0x21, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB7, ++ 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0x97, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x28, 0x03, 0x40, ++ 0x00, 0x02, 0x1F, 0x29, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x28, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x29, ++ 0x03, 0x41, 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, ++ 0x03, 0x42, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x43, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x14, 0x00, 0x02, ++ 0x1F, 0x30, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x31, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x30, 0x03, 0x41, ++ 0x00, 0x02, 0x1F, 0x31, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, ++ 0x03, 0xB9, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0x99, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x38, ++ 0x03, 0x40, 0x00, 0x02, 0x1F, 0x39, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x38, 0x03, 0x41, 0x00, 0x02, ++ 0x1F, 0x39, 0x03, 0x41, 0x00, 0x03, 0x03, 0x99, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0x99, ++ 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0xBF, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x40, 0x03, 0x40, ++ 0x00, 0x02, 0x1F, 0x41, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x40, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x41, ++ 0x03, 0x41, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x48, 0x03, 0x40, 0x00, 0x02, ++ 0x1F, 0x49, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x48, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x49, 0x03, 0x41, ++ 0x00, 0x02, 0x03, 0xC5, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x50, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x51, ++ 0x03, 0x40, 0x00, 0x02, 0x1F, 0x50, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x51, 0x03, 0x41, 0x00, 0x03, ++ 0x03, 0xC5, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0x59, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x59, 0x03, 0x41, 0x00, 0x03, 0x03, 0xA5, 0x03, 0x14, ++ 0x03, 0x42, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x43, 0x00, 0x02, 0x1F, 0x60, 0x03, 0x40, 0x00, 0x02, ++ 0x1F, 0x61, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x60, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x61, 0x03, 0x41, ++ 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x42, ++ 0x00, 0x02, 0x03, 0xA9, 0x03, 0x43, 0x00, 0x02, 0x21, 0x26, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x68, ++ 0x03, 0x40, 0x00, 0x02, 0x1F, 0x69, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x68, 0x03, 0x41, 0x00, 0x02, ++ 0x1F, 0x69, 0x03, 0x41, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0xA9, ++ 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x03, 0xB1, 0x03, 0x40, 0x00, 0x02, 0x03, 0xB5, 0x03, 0x40, ++ 0x00, 0x02, 0x03, 0xB7, 0x03, 0x40, 0x00, 0x02, 0x03, 0xB9, 0x03, 0x40, 0x00, 0x02, 0x03, 0xBF, ++ 0x03, 0x40, 0x00, 0x02, 0x03, 0xC5, 0x03, 0x40, 0x00, 0x02, 0x03, 0xC9, 0x03, 0x40, 0x00, 0x02, ++ 0x1F, 0xB3, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x80, 0x03, 0x00, ++ 0x00, 0x02, 0x1F, 0x81, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x80, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x81, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x80, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x81, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0xBC, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xBC, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x88, 0x03, 0x00, ++ 0x00, 0x02, 0x1F, 0x89, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x88, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x89, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x88, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x89, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0xC3, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x90, 0x03, 0x00, ++ 0x00, 0x02, 0x1F, 0x91, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x90, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x91, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x90, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x91, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0xCC, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xCC, 0x03, 0x14, 0x00, 0x02, 0x1F, 0x98, 0x03, 0x00, ++ 0x00, 0x02, 0x1F, 0x99, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x98, 0x03, 0x01, 0x00, 0x02, 0x1F, 0x99, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0x98, 0x03, 0x42, 0x00, 0x02, 0x1F, 0x99, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0xF3, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x14, 0x00, 0x02, 0x1F, 0xA0, 0x03, 0x00, ++ 0x00, 0x02, 0x1F, 0xA1, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xA0, 0x03, 0x01, 0x00, 0x02, 0x1F, 0xA1, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0xA0, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xA1, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0xFC, 0x03, 0x13, 0x00, 0x02, 0x1F, 0xFC, 0x03, 0x14, 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x00, ++ 0x00, 0x02, 0x1F, 0xA9, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x01, 0x00, 0x02, 0x1F, 0xA9, ++ 0x03, 0x01, 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xA9, 0x03, 0x42, 0x00, 0x02, ++ 0x1F, 0xB3, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x71, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xB6, 0x03, 0x45, ++ 0x00, 0x02, 0x03, 0x91, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x75, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0xC6, 0x03, 0x45, 0x00, 0x02, 0x03, 0x95, 0x03, 0x40, 0x00, 0x02, ++ 0x03, 0x97, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xBF, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xBF, 0x03, 0x41, ++ 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x06, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x04, 0x00, 0x02, 0x03, 0xCA, ++ 0x03, 0x40, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, 0x03, 0x42, ++ 0x00, 0x02, 0x03, 0x99, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xFE, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xFE, ++ 0x03, 0x41, 0x00, 0x02, 0x03, 0xCB, 0x03, 0x40, 0x00, 0x02, 0x03, 0xC1, 0x03, 0x43, 0x00, 0x03, ++ 0x03, 0xC5, 0x03, 0x08, 0x03, 0x42, 0x00, 0x02, 0x03, 0xA5, 0x03, 0x40, 0x00, 0x02, 0x00, 0xA8, ++ 0x03, 0x40, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x00, 0x00, 0x02, 0x1F, 0x7D, 0x03, 0x45, 0x00, 0x02, ++ 0x1F, 0xF6, 0x03, 0x45, 0x00, 0x02, 0x03, 0x9F, 0x03, 0x40, 0x00, 0x02, 0x03, 0xA9, 0x03, 0x40, ++ 0x00, 0x02, 0x21, 0x26, 0x03, 0x45, 0x00, 0x01, 0x00, 0xC0, 0x03, 0x85, 0x03, 0x86, 0x03, 0x88, ++ 0x03, 0x89, 0x03, 0x8A, 0x03, 0x8C, 0x03, 0x8E, 0x03, 0x8F, 0x03, 0x90, 0x03, 0xAC, 0x03, 0xAD, ++ 0x03, 0xAE, 0x03, 0xAF, 0x03, 0xB0, 0x03, 0xCA, 0x03, 0xCC, 0x03, 0xCD, 0x03, 0xCE, 0x03, 0xD3, ++ 0x1F, 0x00, 0x1F, 0x02, 0x1F, 0x03, 0x1F, 0x04, 0x1F, 0x05, 0x1F, 0x06, 0x1F, 0x07, 0x1F, 0x08, ++ 0x1F, 0x0A, 0x1F, 0x0B, 0x1F, 0x0C, 0x1F, 0x0D, 0x1F, 0x0E, 0x1F, 0x0F, 0x1F, 0x10, 0x1F, 0x12, ++ 0x1F, 0x13, 0x1F, 0x14, 0x1F, 0x15, 0x1F, 0x18, 0x1F, 0x1A, 0x1F, 0x1B, 0x1F, 0x1C, 0x1F, 0x1D, ++ 0x1F, 0x20, 0x1F, 0x22, 0x1F, 0x23, 0x1F, 0x24, 0x1F, 0x25, 0x1F, 0x26, 0x1F, 0x27, 0x1F, 0x28, ++ 0x1F, 0x2A, 0x1F, 0x2B, 0x1F, 0x2C, 0x1F, 0x2D, 0x1F, 0x2E, 0x1F, 0x2F, 0x1F, 0x30, 0x1F, 0x31, ++ 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x36, 0x1F, 0x37, 0x1F, 0x38, 0x1F, 0x3A, ++ 0x1F, 0x3B, 0x1F, 0x3C, 0x1F, 0x3D, 0x1F, 0x3E, 0x1F, 0x3F, 0x1F, 0x40, 0x1F, 0x42, 0x1F, 0x43, ++ 0x1F, 0x44, 0x1F, 0x45, 0x1F, 0x48, 0x1F, 0x4A, 0x1F, 0x4B, 0x1F, 0x4C, 0x1F, 0x4D, 0x1F, 0x50, ++ 0x1F, 0x52, 0x1F, 0x53, 0x1F, 0x54, 0x1F, 0x55, 0x1F, 0x56, 0x1F, 0x57, 0x1F, 0x5B, 0x1F, 0x5D, ++ 0x1F, 0x5F, 0x1F, 0x60, 0x1F, 0x62, 0x1F, 0x63, 0x1F, 0x64, 0x1F, 0x65, 0x1F, 0x66, 0x1F, 0x67, ++ 0x1F, 0x68, 0x1F, 0x69, 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x6E, 0x1F, 0x6F, ++ 0x1F, 0x70, 0x1F, 0x72, 0x1F, 0x74, 0x1F, 0x76, 0x1F, 0x78, 0x1F, 0x7A, 0x1F, 0x7C, 0x1F, 0x80, + 0x1F, 0x81, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, + 0x1F, 0x89, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, + 0x1F, 0x91, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, + 0x1F, 0x99, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, + 0x1F, 0xA1, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, + 0x1F, 0xA9, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB2, +- 0x1F, 0xB4, 0x1F, 0xB7, 0x1F, 0xBA, 0x1F, 0xBB, 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xC7, 0x1F, 0xC8, +- 0x1F, 0xC9, 0x1F, 0xCA, 0x1F, 0xCB, 0x1F, 0xCD, 0x1F, 0xCE, 0x1F, 0xD0, 0x1F, 0xD1, 0x1F, 0xD2, +- 0x1F, 0xD3, 0x1F, 0xD6, 0x1F, 0xD7, 0x1F, 0xDA, 0x1F, 0xDB, 0x1F, 0xDD, 0x1F, 0xDE, 0x1F, 0xE2, +- 0x1F, 0xE3, 0x1F, 0xE4, 0x1F, 0xE7, 0x1F, 0xEA, 0x1F, 0xEB, 0x1F, 0xED, 0x1F, 0xEE, 0x1F, 0xF2, +- 0x1F, 0xF4, 0x1F, 0xF7, 0x1F, 0xF8, 0x1F, 0xF9, 0x1F, 0xFA, 0x1F, 0xFB, 0x1F, 0xFC, 0x00, 0x01, +- 0x05, 0x00, 0x00, 0x89, 0x01, 0x18, 0x01, 0x1E, 0x01, 0x24, 0x01, 0x2A, 0x01, 0x30, 0x01, 0x38, +- 0x01, 0x40, 0x01, 0x48, 0x01, 0x50, 0x01, 0x58, 0x01, 0x60, 0x01, 0x68, 0x01, 0x70, 0x01, 0x78, +- 0x01, 0x80, 0x01, 0x88, 0x01, 0x90, 0x01, 0x98, 0x01, 0xA0, 0x01, 0xA8, 0x01, 0xB0, 0x01, 0xB8, +- 0x01, 0xC0, 0x01, 0xC8, 0x01, 0xD0, 0x01, 0xD8, 0x01, 0xE0, 0x01, 0xE8, 0x01, 0xF0, 0x01, 0xF8, +- 0x02, 0x00, 0x02, 0x08, 0x02, 0x10, 0x02, 0x16, 0x02, 0x1E, 0x02, 0x26, 0x02, 0x2E, 0x02, 0x36, +- 0x02, 0x3E, 0x02, 0x46, 0x02, 0x4E, 0x02, 0x56, 0x02, 0x5E, 0x02, 0x66, 0x02, 0x6E, 0x02, 0x76, +- 0x02, 0x7E, 0x02, 0x86, 0x02, 0x8E, 0x02, 0x96, 0x02, 0x9E, 0x02, 0xA6, 0x02, 0xAE, 0x02, 0xB6, +- 0x02, 0xBE, 0x02, 0xC6, 0x02, 0xCE, 0x02, 0xD6, 0x02, 0xDE, 0x02, 0xE6, 0x02, 0xEE, 0x02, 0xF6, +- 0x02, 0xFE, 0x03, 0x06, 0x03, 0x0E, 0x03, 0x14, 0x03, 0x1C, 0x03, 0x24, 0x03, 0x2C, 0x03, 0x34, +- 0x03, 0x3C, 0x03, 0x44, 0x03, 0x4A, 0x03, 0x50, 0x03, 0x56, 0x03, 0x5E, 0x03, 0x64, 0x03, 0x6A, +- 0x03, 0x70, 0x03, 0x76, 0x03, 0x7E, 0x03, 0x86, 0x03, 0x8C, 0x03, 0x94, 0x03, 0x9A, 0x03, 0xA0, +- 0x03, 0xA6, 0x03, 0xAC, 0x03, 0xB4, 0x03, 0xBC, 0x03, 0xC2, 0x03, 0xCA, 0x03, 0xD0, 0x03, 0xD6, +- 0x03, 0xDC, 0x03, 0xE2, 0x03, 0xEA, 0x03, 0xF2, 0x03, 0xF8, 0x04, 0x00, 0x04, 0x06, 0x04, 0x0C, +- 0x04, 0x12, 0x04, 0x18, 0x04, 0x20, 0x04, 0x28, 0x04, 0x2E, 0x04, 0x36, 0x04, 0x3C, 0x04, 0x42, +- 0x04, 0x48, 0x04, 0x4E, 0x04, 0x56, 0x04, 0x5E, 0x04, 0x64, 0x04, 0x6C, 0x04, 0x72, 0x04, 0x78, +- 0x04, 0x7E, 0x04, 0x84, 0x04, 0x8C, 0x04, 0x94, 0x04, 0x9A, 0x04, 0xA0, 0x04, 0xA8, 0x04, 0xAE, +- 0x04, 0xB4, 0x04, 0xBC, 0x04, 0xC4, 0x04, 0xCA, 0x04, 0xD2, 0x04, 0xDA, 0x04, 0xE0, 0x04, 0xE6, +- 0x04, 0xEC, 0x04, 0xF4, 0x04, 0xFA, 0x00, 0x02, 0x21, 0x26, 0x03, 0x01, 0x00, 0x02, 0x03, 0xCA, +- 0x03, 0x41, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x01, 0x00, 0x02, 0x03, 0xCB, 0x03, 0x41, 0x00, 0x03, +- 0x03, 0xB1, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, +- 0x03, 0xB1, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, +- 0x03, 0xB1, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, +- 0x03, 0x91, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, +- 0x03, 0x91, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, +- 0x03, 0xB5, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, +- 0x03, 0xB5, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, +- 0x03, 0x95, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0x95, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, +- 0x03, 0x95, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0x95, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, +- 0x03, 0xB7, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, +- 0x03, 0xB7, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, +- 0x03, 0xB7, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, +- 0x03, 0x97, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, +- 0x03, 0x97, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0x97, 0x03, 0x43, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0xBE, 0x03, 0x13, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB9, +- 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB9, +- 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xBE, +- 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0x99, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0x99, +- 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0x99, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0x99, +- 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0x99, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0xBF, +- 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xBF, +- 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0x9F, +- 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0x9F, +- 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, +- 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC5, +- 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, +- 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0xA5, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xA5, +- 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC9, +- 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, +- 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x42, 0x00, 0x02, 0x21, 0x26, +- 0x03, 0x13, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x14, +- 0x03, 0x00, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x14, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x21, 0x26, 0x03, 0x14, +- 0x03, 0x42, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x01, 0x00, 0x02, +- 0x1F, 0xB3, 0x03, 0x43, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x80, +- 0x03, 0x40, 0x00, 0x02, 0x1F, 0x81, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x80, 0x03, 0x41, 0x00, 0x02, +- 0x1F, 0x81, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x01, +- 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xBC, 0x03, 0x43, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0x88, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x89, 0x03, 0x40, 0x00, 0x02, +- 0x1F, 0x88, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x89, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x42, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x43, +- 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x90, 0x03, 0x40, 0x00, 0x02, +- 0x1F, 0x91, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x90, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x91, 0x03, 0x41, +- 0x00, 0x03, 0x1F, 0x20, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x42, 0x03, 0x45, +- 0x00, 0x02, 0x1F, 0xCC, 0x03, 0x43, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, +- 0x1F, 0x98, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x99, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x98, 0x03, 0x41, +- 0x00, 0x02, 0x1F, 0x99, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, +- 0x1F, 0x29, 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x43, 0x00, 0x03, 0x03, 0xC9, +- 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xA0, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xA1, 0x03, 0x40, +- 0x00, 0x02, 0x1F, 0xA0, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xA1, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x60, +- 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xFC, +- 0x03, 0x43, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x40, +- 0x00, 0x02, 0x1F, 0xA9, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xA9, +- 0x03, 0x41, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x42, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x01, 0x00, 0x03, +- 0x03, 0xB1, 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xC3, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, +- 0x03, 0x00, 0x00, 0x02, 0x03, 0xCA, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, 0x03, 0x42, +- 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x00, 0x00, 0x02, 0x03, 0xCB, 0x03, 0x41, 0x00, 0x02, +- 0x1F, 0xF3, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x42, +- 0x03, 0x45, 0x00, 0x02, 0x21, 0x26, 0x03, 0x00, 0x00, 0x02, 0x21, 0x26, 0x03, 0x01, 0x00, 0x01, +- 0x00, 0x89, 0x03, 0x8F, 0x03, 0x90, 0x03, 0xAF, 0x03, 0xB0, 0x1F, 0x02, 0x1F, 0x03, 0x1F, 0x04, +- 0x1F, 0x05, 0x1F, 0x06, 0x1F, 0x0A, 0x1F, 0x0B, 0x1F, 0x0C, 0x1F, 0x0D, 0x1F, 0x0E, 0x1F, 0x12, +- 0x1F, 0x13, 0x1F, 0x14, 0x1F, 0x15, 0x1F, 0x1A, 0x1F, 0x1B, 0x1F, 0x1C, 0x1F, 0x1D, 0x1F, 0x22, +- 0x1F, 0x23, 0x1F, 0x24, 0x1F, 0x25, 0x1F, 0x26, 0x1F, 0x2A, 0x1F, 0x2B, 0x1F, 0x2C, 0x1F, 0x2D, +- 0x1F, 0x2E, 0x1F, 0x30, 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x36, 0x1F, 0x37, +- 0x1F, 0x3A, 0x1F, 0x3B, 0x1F, 0x3C, 0x1F, 0x3D, 0x1F, 0x3E, 0x1F, 0x42, 0x1F, 0x43, 0x1F, 0x44, +- 0x1F, 0x45, 0x1F, 0x4A, 0x1F, 0x4B, 0x1F, 0x4C, 0x1F, 0x4D, 0x1F, 0x52, 0x1F, 0x53, 0x1F, 0x54, +- 0x1F, 0x55, 0x1F, 0x56, 0x1F, 0x5B, 0x1F, 0x5D, 0x1F, 0x62, 0x1F, 0x63, 0x1F, 0x64, 0x1F, 0x65, +- 0x1F, 0x66, 0x1F, 0x68, 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x6E, 0x1F, 0x6F, +- 0x1F, 0x76, 0x1F, 0x77, 0x1F, 0x80, 0x1F, 0x81, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, +- 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, 0x1F, 0x89, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, +- 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, 0x1F, 0x91, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, +- 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x99, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, +- 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, 0x1F, 0xA1, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, +- 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, 0x1F, 0xA9, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB2, 0x1F, 0xB4, 0x1F, 0xB7, 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xC7, +- 0x1F, 0xD2, 0x1F, 0xD3, 0x1F, 0xD7, 0x1F, 0xE2, 0x1F, 0xE3, 0x1F, 0xF2, 0x1F, 0xF4, 0x1F, 0xF7, +- 0x1F, 0xFA, 0x1F, 0xFB, 0x00, 0x01, 0x04, 0xE2, 0x00, 0x7F, 0x01, 0x04, 0x01, 0x0A, 0x01, 0x10, +- 0x01, 0x16, 0x01, 0x1E, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x36, 0x01, 0x3E, 0x01, 0x46, 0x01, 0x4E, +- 0x01, 0x56, 0x01, 0x5E, 0x01, 0x66, 0x01, 0x6E, 0x01, 0x76, 0x01, 0x7E, 0x01, 0x86, 0x01, 0x8E, +- 0x01, 0x96, 0x01, 0x9E, 0x01, 0xA6, 0x01, 0xAE, 0x01, 0xB6, 0x01, 0xBE, 0x01, 0xC6, 0x01, 0xCE, +- 0x01, 0xD6, 0x01, 0xDE, 0x01, 0xE4, 0x01, 0xEC, 0x01, 0xF4, 0x01, 0xFC, 0x02, 0x04, 0x02, 0x0C, +- 0x02, 0x14, 0x02, 0x1C, 0x02, 0x24, 0x02, 0x2C, 0x02, 0x34, 0x02, 0x3C, 0x02, 0x44, 0x02, 0x4C, +- 0x02, 0x54, 0x02, 0x5C, 0x02, 0x64, 0x02, 0x6C, 0x02, 0x74, 0x02, 0x7C, 0x02, 0x84, 0x02, 0x8C, +- 0x02, 0x94, 0x02, 0x9C, 0x02, 0xA4, 0x02, 0xAC, 0x02, 0xB4, 0x02, 0xBC, 0x02, 0xC2, 0x02, 0xCA, +- 0x02, 0xD2, 0x02, 0xDA, 0x02, 0xE2, 0x02, 0xEA, 0x02, 0xF0, 0x02, 0xF6, 0x02, 0xFE, 0x03, 0x06, +- 0x03, 0x0E, 0x03, 0x16, 0x03, 0x1E, 0x03, 0x26, 0x03, 0x2E, 0x03, 0x36, 0x03, 0x3E, 0x03, 0x46, +- 0x03, 0x4E, 0x03, 0x56, 0x03, 0x5E, 0x03, 0x66, 0x03, 0x6E, 0x03, 0x76, 0x03, 0x7E, 0x03, 0x86, +- 0x03, 0x8E, 0x03, 0x96, 0x03, 0x9E, 0x03, 0xA6, 0x03, 0xAE, 0x03, 0xB6, 0x03, 0xBE, 0x03, 0xC6, +- 0x03, 0xCE, 0x03, 0xD6, 0x03, 0xDE, 0x03, 0xE6, 0x03, 0xEE, 0x03, 0xF6, 0x03, 0xFE, 0x04, 0x06, +- 0x04, 0x0E, 0x04, 0x16, 0x04, 0x1E, 0x04, 0x26, 0x04, 0x2E, 0x04, 0x36, 0x04, 0x3E, 0x04, 0x46, +- 0x04, 0x4E, 0x04, 0x56, 0x04, 0x5E, 0x04, 0x66, 0x04, 0x6E, 0x04, 0x76, 0x04, 0x7E, 0x04, 0x84, +- 0x04, 0x8C, 0x04, 0x94, 0x04, 0x9A, 0x04, 0xA2, 0x04, 0xAA, 0x04, 0xB0, 0x04, 0xB8, 0x04, 0xC0, +- 0x04, 0xC8, 0x04, 0xCE, 0x04, 0xD6, 0x04, 0xDC, 0x00, 0x02, 0x21, 0x26, 0x03, 0x41, 0x00, 0x02, +- 0x1F, 0xBE, 0x03, 0x44, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, +- 0x03, 0x40, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, +- 0x03, 0x40, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x14, +- 0x03, 0x40, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x03, 0x03, 0x95, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x95, 0x03, 0x14, +- 0x03, 0x40, 0x00, 0x03, 0x03, 0x95, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x95, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, +- 0x03, 0x40, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, +- 0x03, 0x40, 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x43, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x40, +- 0x00, 0x03, 0x03, 0xB9, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0xB9, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x13, 0x03, 0x42, +- 0x00, 0x03, 0x03, 0x99, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x99, 0x03, 0x14, 0x03, 0x40, +- 0x00, 0x03, 0x03, 0x99, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x99, 0x03, 0x14, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0xBF, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x14, 0x03, 0x40, +- 0x00, 0x03, 0x03, 0xBF, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x14, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0x9F, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x14, 0x03, 0x40, +- 0x00, 0x03, 0x03, 0x9F, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x14, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0xC5, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x40, +- 0x00, 0x03, 0x03, 0xC5, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0xA5, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0xA5, 0x03, 0x14, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x40, +- 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x41, +- 0x00, 0x02, 0x21, 0x26, 0x03, 0x43, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, +- 0x03, 0xA9, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, +- 0x03, 0xA9, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, 0x03, 0x42, 0x00, 0x02, +- 0x1F, 0xBE, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x13, +- 0x03, 0x45, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, +- 0x03, 0x45, 0x00, 0x03, 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x13, +- 0x03, 0x45, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, +- 0x03, 0x45, 0x00, 0x03, 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, +- 0x03, 0x45, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, +- 0x03, 0x45, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x42, +- 0x00, 0x03, 0x03, 0xB7, 0x03, 0x00, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x41, 0x00, 0x03, +- 0x03, 0xB7, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, 0x03, 0x40, 0x00, 0x02, +- 0x1F, 0xBE, 0x03, 0x44, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC5, +- 0x03, 0x08, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x00, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xF3, +- 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x42, 0x00, 0x02, 0x21, 0x26, 0x03, 0x40, +- 0x00, 0x02, 0x21, 0x26, 0x03, 0x41, 0x00, 0x01, 0x00, 0x7F, 0x03, 0x8F, 0x03, 0x90, 0x03, 0xAF, +- 0x03, 0xB0, 0x1F, 0x02, 0x1F, 0x03, 0x1F, 0x04, 0x1F, 0x05, 0x1F, 0x0A, 0x1F, 0x0B, 0x1F, 0x0C, +- 0x1F, 0x0D, 0x1F, 0x12, 0x1F, 0x13, 0x1F, 0x14, 0x1F, 0x15, 0x1F, 0x1A, 0x1F, 0x1B, 0x1F, 0x1C, +- 0x1F, 0x1D, 0x1F, 0x22, 0x1F, 0x23, 0x1F, 0x24, 0x1F, 0x25, 0x1F, 0x2A, 0x1F, 0x2B, 0x1F, 0x2C, +- 0x1F, 0x2D, 0x1F, 0x30, 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x36, 0x1F, 0x3A, +- 0x1F, 0x3B, 0x1F, 0x3C, 0x1F, 0x3D, 0x1F, 0x42, 0x1F, 0x43, 0x1F, 0x44, 0x1F, 0x45, 0x1F, 0x4A, +- 0x1F, 0x4B, 0x1F, 0x4C, 0x1F, 0x4D, 0x1F, 0x52, 0x1F, 0x53, 0x1F, 0x54, 0x1F, 0x55, 0x1F, 0x5B, +- 0x1F, 0x5D, 0x1F, 0x62, 0x1F, 0x63, 0x1F, 0x64, 0x1F, 0x65, 0x1F, 0x68, 0x1F, 0x6A, 0x1F, 0x6B, +- 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x6E, 0x1F, 0x76, 0x1F, 0x77, 0x1F, 0x80, 0x1F, 0x81, 0x1F, 0x82, ++ 0x1F, 0xB4, 0x1F, 0xB7, 0x1F, 0xBA, 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xC7, 0x1F, 0xC8, 0x1F, 0xCA, ++ 0x1F, 0xCD, 0x1F, 0xCE, 0x1F, 0xD0, 0x1F, 0xD1, 0x1F, 0xD2, 0x1F, 0xD6, 0x1F, 0xD7, 0x1F, 0xDA, ++ 0x1F, 0xDD, 0x1F, 0xDE, 0x1F, 0xE2, 0x1F, 0xE4, 0x1F, 0xE7, 0x1F, 0xEA, 0x1F, 0xED, 0x1F, 0xF2, ++ 0x1F, 0xF4, 0x1F, 0xF7, 0x1F, 0xF8, 0x1F, 0xFA, 0x1F, 0xFC, 0x00, 0x01, 0x04, 0xE0, 0x00, 0x85, ++ 0x01, 0x10, 0x01, 0x16, 0x01, 0x1C, 0x01, 0x22, 0x01, 0x28, 0x01, 0x30, 0x01, 0x38, 0x01, 0x40, ++ 0x01, 0x48, 0x01, 0x50, 0x01, 0x58, 0x01, 0x60, 0x01, 0x68, 0x01, 0x70, 0x01, 0x78, 0x01, 0x80, ++ 0x01, 0x88, 0x01, 0x90, 0x01, 0x98, 0x01, 0xA0, 0x01, 0xA8, 0x01, 0xB0, 0x01, 0xB8, 0x01, 0xC0, ++ 0x01, 0xC8, 0x01, 0xD0, 0x01, 0xD8, 0x01, 0xE0, 0x01, 0xE8, 0x01, 0xF0, 0x01, 0xF8, 0x02, 0x00, ++ 0x02, 0x08, 0x02, 0x0E, 0x02, 0x16, 0x02, 0x1E, 0x02, 0x26, 0x02, 0x2E, 0x02, 0x36, 0x02, 0x3E, ++ 0x02, 0x46, 0x02, 0x4E, 0x02, 0x56, 0x02, 0x5E, 0x02, 0x66, 0x02, 0x6E, 0x02, 0x76, 0x02, 0x7E, ++ 0x02, 0x86, 0x02, 0x8E, 0x02, 0x96, 0x02, 0x9E, 0x02, 0xA6, 0x02, 0xAE, 0x02, 0xB6, 0x02, 0xBE, ++ 0x02, 0xC6, 0x02, 0xCE, 0x02, 0xD6, 0x02, 0xDE, 0x02, 0xE6, 0x02, 0xEE, 0x02, 0xF6, 0x02, 0xFE, ++ 0x03, 0x06, 0x03, 0x0C, 0x03, 0x14, 0x03, 0x1C, 0x03, 0x24, 0x03, 0x2C, 0x03, 0x34, 0x03, 0x3C, ++ 0x03, 0x42, 0x03, 0x48, 0x03, 0x50, 0x03, 0x56, 0x03, 0x5C, 0x03, 0x62, 0x03, 0x68, 0x03, 0x70, ++ 0x03, 0x78, 0x03, 0x7E, 0x03, 0x86, 0x03, 0x8C, 0x03, 0x92, 0x03, 0x98, 0x03, 0x9E, 0x03, 0xA6, ++ 0x03, 0xAE, 0x03, 0xB4, 0x03, 0xBC, 0x03, 0xC2, 0x03, 0xC8, 0x03, 0xCE, 0x03, 0xD4, 0x03, 0xDC, ++ 0x03, 0xE4, 0x03, 0xEA, 0x03, 0xF2, 0x03, 0xF8, 0x03, 0xFE, 0x04, 0x04, 0x04, 0x0A, 0x04, 0x12, ++ 0x04, 0x1A, 0x04, 0x20, 0x04, 0x28, 0x04, 0x2E, 0x04, 0x34, 0x04, 0x3A, 0x04, 0x40, 0x04, 0x48, ++ 0x04, 0x50, 0x04, 0x56, 0x04, 0x5E, 0x04, 0x64, 0x04, 0x6A, 0x04, 0x70, 0x04, 0x76, 0x04, 0x7E, ++ 0x04, 0x86, 0x04, 0x8C, 0x04, 0x92, 0x04, 0x9A, 0x04, 0xA0, 0x04, 0xA6, 0x04, 0xAE, 0x04, 0xB6, ++ 0x04, 0xBE, 0x04, 0xC6, 0x04, 0xCC, 0x04, 0xD2, 0x04, 0xDA, 0x00, 0x02, 0x21, 0x26, 0x03, 0x01, ++ 0x00, 0x02, 0x03, 0xCA, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x01, 0x00, 0x02, 0x03, 0xCB, ++ 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, ++ 0x03, 0x00, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, ++ 0x03, 0x01, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, ++ 0x03, 0x00, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, ++ 0x03, 0x01, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, ++ 0x03, 0x42, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x14, ++ 0x03, 0x00, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x14, ++ 0x03, 0x01, 0x00, 0x03, 0x03, 0x95, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0x95, 0x03, 0x14, ++ 0x03, 0x00, 0x00, 0x03, 0x03, 0x95, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0x95, 0x03, 0x14, ++ 0x03, 0x01, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, ++ 0x03, 0x00, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, ++ 0x03, 0x01, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, ++ 0x03, 0x00, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, ++ 0x03, 0x01, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0x97, 0x03, 0x43, ++ 0x03, 0x42, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x13, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xB9, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0xB9, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x43, 0x03, 0x42, ++ 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0x99, 0x03, 0x13, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0x99, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0x99, 0x03, 0x13, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0x99, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0x99, 0x03, 0x43, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0xBF, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x14, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xBF, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0x9F, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x14, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0x9F, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0xC5, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xC5, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0xC5, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0xA5, 0x03, 0x14, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xA5, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x42, ++ 0x00, 0x02, 0x21, 0x26, 0x03, 0x13, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, ++ 0x03, 0xA9, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, ++ 0x03, 0xA9, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, ++ 0x21, 0x26, 0x03, 0x14, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x00, 0x00, 0x02, 0x1F, 0xB3, ++ 0x03, 0x43, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x80, 0x03, 0x40, ++ 0x00, 0x02, 0x1F, 0x81, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x80, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x81, ++ 0x03, 0x41, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x42, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0xBC, 0x03, 0x43, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, ++ 0x00, 0x02, 0x1F, 0x88, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x89, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x88, ++ 0x03, 0x41, 0x00, 0x02, 0x1F, 0x89, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x42, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x09, 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x43, 0x00, 0x03, ++ 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x90, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x91, ++ 0x03, 0x40, 0x00, 0x02, 0x1F, 0x90, 0x03, 0x41, 0x00, 0x02, 0x1F, 0x91, 0x03, 0x41, 0x00, 0x03, ++ 0x1F, 0x20, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, ++ 0x1F, 0xCC, 0x03, 0x43, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, 0x1F, 0x98, ++ 0x03, 0x40, 0x00, 0x02, 0x1F, 0x99, 0x03, 0x40, 0x00, 0x02, 0x1F, 0x98, 0x03, 0x41, 0x00, 0x02, ++ 0x1F, 0x99, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, ++ 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x43, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, ++ 0x03, 0x45, 0x00, 0x02, 0x1F, 0xA0, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xA1, 0x03, 0x40, 0x00, 0x02, ++ 0x1F, 0xA0, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xA1, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x42, ++ 0x03, 0x45, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xFC, 0x03, 0x43, ++ 0x00, 0x03, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x40, 0x00, 0x02, ++ 0x1F, 0xA9, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xA8, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xA9, 0x03, 0x41, ++ 0x00, 0x03, 0x1F, 0x68, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x42, 0x03, 0x45, ++ 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB1, ++ 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xC3, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0xB7, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, 0x03, 0x00, ++ 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, 0x03, 0x42, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x00, ++ 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x40, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, ++ 0x03, 0x42, 0x03, 0x45, 0x00, 0x02, 0x21, 0x26, 0x03, 0x00, 0x00, 0x01, 0x00, 0x85, 0x03, 0x8F, ++ 0x03, 0x90, 0x03, 0xAF, 0x03, 0xB0, 0x1F, 0x02, 0x1F, 0x03, 0x1F, 0x04, 0x1F, 0x05, 0x1F, 0x06, ++ 0x1F, 0x0A, 0x1F, 0x0B, 0x1F, 0x0C, 0x1F, 0x0D, 0x1F, 0x0E, 0x1F, 0x12, 0x1F, 0x13, 0x1F, 0x14, ++ 0x1F, 0x15, 0x1F, 0x1A, 0x1F, 0x1B, 0x1F, 0x1C, 0x1F, 0x1D, 0x1F, 0x22, 0x1F, 0x23, 0x1F, 0x24, ++ 0x1F, 0x25, 0x1F, 0x26, 0x1F, 0x2A, 0x1F, 0x2B, 0x1F, 0x2C, 0x1F, 0x2D, 0x1F, 0x2E, 0x1F, 0x30, ++ 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x36, 0x1F, 0x37, 0x1F, 0x3A, 0x1F, 0x3B, ++ 0x1F, 0x3C, 0x1F, 0x3D, 0x1F, 0x3E, 0x1F, 0x42, 0x1F, 0x43, 0x1F, 0x44, 0x1F, 0x45, 0x1F, 0x4A, ++ 0x1F, 0x4B, 0x1F, 0x4C, 0x1F, 0x4D, 0x1F, 0x52, 0x1F, 0x53, 0x1F, 0x54, 0x1F, 0x55, 0x1F, 0x56, ++ 0x1F, 0x5B, 0x1F, 0x5D, 0x1F, 0x62, 0x1F, 0x63, 0x1F, 0x64, 0x1F, 0x65, 0x1F, 0x66, 0x1F, 0x68, ++ 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x6E, 0x1F, 0x6F, 0x1F, 0x76, 0x1F, 0x80, ++ 0x1F, 0x81, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, ++ 0x1F, 0x89, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, ++ 0x1F, 0x91, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, ++ 0x1F, 0x99, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, ++ 0x1F, 0xA1, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, ++ 0x1F, 0xA9, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB2, ++ 0x1F, 0xB4, 0x1F, 0xB7, 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xC7, 0x1F, 0xD2, 0x1F, 0xD7, 0x1F, 0xE2, ++ 0x1F, 0xF2, 0x1F, 0xF4, 0x1F, 0xF7, 0x1F, 0xFA, 0x00, 0x01, 0x04, 0xC0, 0x00, 0x7B, 0x00, 0xFC, ++ 0x01, 0x02, 0x01, 0x08, 0x01, 0x0E, 0x01, 0x16, 0x01, 0x1E, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x36, ++ 0x01, 0x3E, 0x01, 0x46, 0x01, 0x4E, 0x01, 0x56, 0x01, 0x5E, 0x01, 0x66, 0x01, 0x6E, 0x01, 0x76, ++ 0x01, 0x7E, 0x01, 0x86, 0x01, 0x8E, 0x01, 0x96, 0x01, 0x9E, 0x01, 0xA6, 0x01, 0xAE, 0x01, 0xB6, ++ 0x01, 0xBE, 0x01, 0xC6, 0x01, 0xCE, 0x01, 0xD6, 0x01, 0xDC, 0x01, 0xE4, 0x01, 0xEC, 0x01, 0xF4, ++ 0x01, 0xFC, 0x02, 0x04, 0x02, 0x0C, 0x02, 0x14, 0x02, 0x1C, 0x02, 0x24, 0x02, 0x2C, 0x02, 0x34, ++ 0x02, 0x3C, 0x02, 0x44, 0x02, 0x4C, 0x02, 0x54, 0x02, 0x5C, 0x02, 0x64, 0x02, 0x6C, 0x02, 0x74, ++ 0x02, 0x7C, 0x02, 0x84, 0x02, 0x8C, 0x02, 0x94, 0x02, 0x9C, 0x02, 0xA4, 0x02, 0xAC, 0x02, 0xB4, ++ 0x02, 0xBA, 0x02, 0xC2, 0x02, 0xCA, 0x02, 0xD2, 0x02, 0xDA, 0x02, 0xE2, 0x02, 0xE8, 0x02, 0xF0, ++ 0x02, 0xF8, 0x03, 0x00, 0x03, 0x08, 0x03, 0x10, 0x03, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x30, ++ 0x03, 0x38, 0x03, 0x40, 0x03, 0x48, 0x03, 0x50, 0x03, 0x58, 0x03, 0x60, 0x03, 0x68, 0x03, 0x70, ++ 0x03, 0x78, 0x03, 0x80, 0x03, 0x88, 0x03, 0x90, 0x03, 0x98, 0x03, 0xA0, 0x03, 0xA8, 0x03, 0xB0, ++ 0x03, 0xB8, 0x03, 0xC0, 0x03, 0xC8, 0x03, 0xD0, 0x03, 0xD8, 0x03, 0xE0, 0x03, 0xE8, 0x03, 0xF0, ++ 0x03, 0xF8, 0x04, 0x00, 0x04, 0x08, 0x04, 0x10, 0x04, 0x18, 0x04, 0x20, 0x04, 0x28, 0x04, 0x30, ++ 0x04, 0x38, 0x04, 0x40, 0x04, 0x48, 0x04, 0x50, 0x04, 0x58, 0x04, 0x60, 0x04, 0x68, 0x04, 0x70, ++ 0x04, 0x76, 0x04, 0x7E, 0x04, 0x86, 0x04, 0x8C, 0x04, 0x94, 0x04, 0x9C, 0x04, 0xA4, 0x04, 0xAC, ++ 0x04, 0xB2, 0x04, 0xBA, 0x00, 0x02, 0x21, 0x26, 0x03, 0x41, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x44, ++ 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x01, 0x00, 0x03, ++ 0x03, 0xB1, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, ++ 0x03, 0xB1, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, ++ 0x03, 0x91, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, ++ 0x03, 0x91, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x91, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, ++ 0x03, 0xB5, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, ++ 0x03, 0xB5, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, ++ 0x03, 0x95, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x95, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, ++ 0x03, 0x95, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x95, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, ++ 0x03, 0xB7, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, ++ 0x03, 0xB7, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, ++ 0x03, 0x97, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, ++ 0x03, 0x97, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x97, 0x03, 0x14, 0x03, 0x41, 0x00, 0x02, ++ 0x1F, 0xBE, 0x03, 0x43, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB9, ++ 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB9, ++ 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x03, 0x99, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x99, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0x99, ++ 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x99, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, 0x03, 0xBF, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0xBF, ++ 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, 0x03, 0x9F, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0x9F, ++ 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC5, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC5, ++ 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, 0x03, 0xA5, ++ 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0xA5, 0x03, 0x14, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC9, ++ 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x41, 0x00, 0x02, 0x21, 0x26, ++ 0x03, 0x43, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x14, ++ 0x03, 0x40, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x14, ++ 0x03, 0x41, 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, 0x03, 0x42, 0x00, 0x02, 0x1F, 0xBE, 0x03, 0x40, ++ 0x00, 0x03, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x45, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, ++ 0x00, 0x03, 0x1F, 0x00, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x00, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x00, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x45, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, 0x00, 0x03, 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, ++ 0x00, 0x03, 0x1F, 0x08, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x08, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x08, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x45, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x45, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, ++ 0x00, 0x03, 0x1F, 0x20, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x20, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x20, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x45, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, 0x00, 0x03, 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, ++ 0x00, 0x03, 0x1F, 0x28, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x28, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x28, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x45, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x45, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, ++ 0x00, 0x03, 0x1F, 0x60, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x60, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x60, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x45, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, ++ 0x00, 0x03, 0x1F, 0x68, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x68, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x68, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x45, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0xB1, 0x03, 0x00, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xB3, 0x03, 0x41, 0x00, 0x03, ++ 0x03, 0xB1, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x00, 0x03, 0x45, 0x00, 0x02, ++ 0x1F, 0xC3, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB9, ++ 0x03, 0x08, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC9, ++ 0x03, 0x00, 0x03, 0x45, 0x00, 0x02, 0x1F, 0xF3, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, ++ 0x03, 0x42, 0x00, 0x02, 0x21, 0x26, 0x03, 0x40, 0x00, 0x01, 0x00, 0x7B, 0x03, 0x8F, 0x03, 0x90, ++ 0x03, 0xAF, 0x03, 0xB0, 0x1F, 0x02, 0x1F, 0x03, 0x1F, 0x04, 0x1F, 0x05, 0x1F, 0x0A, 0x1F, 0x0B, ++ 0x1F, 0x0C, 0x1F, 0x0D, 0x1F, 0x12, 0x1F, 0x13, 0x1F, 0x14, 0x1F, 0x15, 0x1F, 0x1A, 0x1F, 0x1B, ++ 0x1F, 0x1C, 0x1F, 0x1D, 0x1F, 0x22, 0x1F, 0x23, 0x1F, 0x24, 0x1F, 0x25, 0x1F, 0x2A, 0x1F, 0x2B, ++ 0x1F, 0x2C, 0x1F, 0x2D, 0x1F, 0x30, 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x36, ++ 0x1F, 0x3A, 0x1F, 0x3B, 0x1F, 0x3C, 0x1F, 0x3D, 0x1F, 0x42, 0x1F, 0x43, 0x1F, 0x44, 0x1F, 0x45, ++ 0x1F, 0x4A, 0x1F, 0x4B, 0x1F, 0x4C, 0x1F, 0x4D, 0x1F, 0x52, 0x1F, 0x53, 0x1F, 0x54, 0x1F, 0x55, ++ 0x1F, 0x5B, 0x1F, 0x5D, 0x1F, 0x62, 0x1F, 0x63, 0x1F, 0x64, 0x1F, 0x65, 0x1F, 0x68, 0x1F, 0x6A, ++ 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x6E, 0x1F, 0x76, 0x1F, 0x80, 0x1F, 0x81, 0x1F, 0x82, + 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, 0x1F, 0x89, 0x1F, 0x8A, + 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, 0x1F, 0x91, 0x1F, 0x92, + 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x99, 0x1F, 0x9A, + 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, 0x1F, 0xA1, 0x1F, 0xA2, + 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, 0x1F, 0xA9, 0x1F, 0xAA, + 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB2, 0x1F, 0xB4, 0x1F, 0xB7, +- 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xC7, 0x1F, 0xD2, 0x1F, 0xD3, 0x1F, 0xE2, 0x1F, 0xE3, 0x1F, 0xF2, +- 0x1F, 0xF4, 0x1F, 0xF7, 0x1F, 0xFA, 0x1F, 0xFB, 0x00, 0x01, 0x03, 0x62, 0x00, 0x56, 0x00, 0xB2, +- 0x00, 0xBA, 0x00, 0xC2, 0x00, 0xCA, 0x00, 0xD2, 0x00, 0xDA, 0x00, 0xE2, 0x00, 0xEA, 0x00, 0xF2, +- 0x00, 0xFA, 0x01, 0x02, 0x01, 0x0A, 0x01, 0x12, 0x01, 0x1A, 0x01, 0x22, 0x01, 0x2A, 0x01, 0x32, +- 0x01, 0x3A, 0x01, 0x42, 0x01, 0x4A, 0x01, 0x52, 0x01, 0x5A, 0x01, 0x62, 0x01, 0x6A, 0x01, 0x72, +- 0x01, 0x7A, 0x01, 0x82, 0x01, 0x8A, 0x01, 0x92, 0x01, 0x9A, 0x01, 0xA2, 0x01, 0xAA, 0x01, 0xB2, +- 0x01, 0xBA, 0x01, 0xC2, 0x01, 0xCA, 0x01, 0xD2, 0x01, 0xDA, 0x01, 0xE2, 0x01, 0xEA, 0x01, 0xF2, +- 0x01, 0xFA, 0x02, 0x02, 0x02, 0x0A, 0x02, 0x12, 0x02, 0x1A, 0x02, 0x22, 0x02, 0x2A, 0x02, 0x32, +- 0x02, 0x3A, 0x02, 0x42, 0x02, 0x4A, 0x02, 0x52, 0x02, 0x5A, 0x02, 0x62, 0x02, 0x6A, 0x02, 0x72, +- 0x02, 0x7A, 0x02, 0x82, 0x02, 0x8A, 0x02, 0x92, 0x02, 0x9A, 0x02, 0xA2, 0x02, 0xAA, 0x02, 0xB2, +- 0x02, 0xBA, 0x02, 0xC2, 0x02, 0xCA, 0x02, 0xD2, 0x02, 0xDA, 0x02, 0xE2, 0x02, 0xEA, 0x02, 0xF2, +- 0x02, 0xFA, 0x03, 0x02, 0x03, 0x0A, 0x03, 0x12, 0x03, 0x1A, 0x03, 0x22, 0x03, 0x2A, 0x03, 0x32, +- 0x03, 0x3A, 0x03, 0x42, 0x03, 0x4A, 0x03, 0x52, 0x03, 0x5A, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0x95, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x03, 0x95, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0x97, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x03, 0x97, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x43, +- 0x03, 0x01, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, +- 0x03, 0x42, 0x00, 0x03, 0x03, 0x99, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0x99, 0x03, 0x43, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x43, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x43, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x43, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x43, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x21, 0x26, 0x03, 0x14, +- 0x03, 0x00, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x21, 0x26, 0x03, 0x14, +- 0x03, 0x01, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x43, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x40, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x41, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x14, +- 0x03, 0x42, 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x40, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x41, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x43, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x40, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x41, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x14, +- 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x43, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x40, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x41, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x43, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x40, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x41, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x14, +- 0x03, 0x42, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, 0x00, 0x03, 0x21, 0x26, 0x03, 0x14, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x40, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x41, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x14, +- 0x03, 0x42, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x40, +- 0x03, 0x45, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x01, 0x03, 0x45, 0x00, 0x01, 0x00, 0x56, 0x03, 0x90, +- 0x03, 0xB0, 0x1F, 0x02, 0x1F, 0x04, 0x1F, 0x0A, 0x1F, 0x0C, 0x1F, 0x12, 0x1F, 0x14, 0x1F, 0x1A, +- 0x1F, 0x1C, 0x1F, 0x22, 0x1F, 0x24, 0x1F, 0x2A, 0x1F, 0x2C, 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, +- 0x1F, 0x35, 0x1F, 0x36, 0x1F, 0x3A, 0x1F, 0x3C, 0x1F, 0x42, 0x1F, 0x44, 0x1F, 0x4A, 0x1F, 0x4C, +- 0x1F, 0x52, 0x1F, 0x54, 0x1F, 0x62, 0x1F, 0x64, 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, +- 0x1F, 0x6E, 0x1F, 0x80, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, +- 0x1F, 0x88, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, +- 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x9A, +- 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, 0x1F, 0xA2, 0x1F, 0xA3, +- 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, 0x1F, 0xA9, 0x1F, 0xAA, 0x1F, 0xAB, +- 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB2, 0x1F, 0xB4, 0x1F, 0xC2, 0x1F, 0xC4, +- 0x1F, 0xD2, 0x1F, 0xD3, 0x1F, 0xE3, 0x1F, 0xF2, 0x1F, 0xF4, 0x00, 0x01, 0x03, 0x46, 0x00, 0x52, +- 0x00, 0xAA, 0x00, 0xB2, 0x00, 0xBA, 0x00, 0xC2, 0x00, 0xCA, 0x00, 0xD2, 0x00, 0xDA, 0x00, 0xE2, +- 0x00, 0xEA, 0x00, 0xF2, 0x00, 0xFA, 0x01, 0x02, 0x01, 0x0A, 0x01, 0x12, 0x01, 0x1A, 0x01, 0x22, +- 0x01, 0x2A, 0x01, 0x32, 0x01, 0x3A, 0x01, 0x42, 0x01, 0x4A, 0x01, 0x52, 0x01, 0x5A, 0x01, 0x62, +- 0x01, 0x6A, 0x01, 0x72, 0x01, 0x7A, 0x01, 0x82, 0x01, 0x8A, 0x01, 0x92, 0x01, 0x9A, 0x01, 0xA2, +- 0x01, 0xAA, 0x01, 0xB2, 0x01, 0xBA, 0x01, 0xC2, 0x01, 0xCA, 0x01, 0xD2, 0x01, 0xDC, 0x01, 0xE4, +- 0x01, 0xEC, 0x01, 0xF4, 0x01, 0xFC, 0x02, 0x04, 0x02, 0x0C, 0x02, 0x16, 0x02, 0x1E, 0x02, 0x26, +- 0x02, 0x2E, 0x02, 0x36, 0x02, 0x3E, 0x02, 0x46, 0x02, 0x50, 0x02, 0x58, 0x02, 0x60, 0x02, 0x68, +- 0x02, 0x70, 0x02, 0x78, 0x02, 0x80, 0x02, 0x8A, 0x02, 0x92, 0x02, 0x9A, 0x02, 0xA2, 0x02, 0xAA, +- 0x02, 0xB2, 0x02, 0xBA, 0x02, 0xC4, 0x02, 0xCC, 0x02, 0xD4, 0x02, 0xDC, 0x02, 0xE4, 0x02, 0xEC, +- 0x02, 0xF4, 0x02, 0xFC, 0x03, 0x06, 0x03, 0x0E, 0x03, 0x16, 0x03, 0x1E, 0x03, 0x26, 0x03, 0x2E, +- 0x03, 0x36, 0x03, 0x3E, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, ++ 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xC7, 0x1F, 0xD2, 0x1F, 0xE2, 0x1F, 0xF2, 0x1F, 0xF4, 0x1F, 0xF7, ++ 0x1F, 0xFA, 0x00, 0x01, 0x03, 0x4E, 0x00, 0x54, 0x00, 0xAE, 0x00, 0xB6, 0x00, 0xBE, 0x00, 0xC6, ++ 0x00, 0xCE, 0x00, 0xD6, 0x00, 0xDE, 0x00, 0xE6, 0x00, 0xEE, 0x00, 0xF6, 0x00, 0xFE, 0x01, 0x06, ++ 0x01, 0x0E, 0x01, 0x16, 0x01, 0x1E, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x36, 0x01, 0x3E, 0x01, 0x46, ++ 0x01, 0x4E, 0x01, 0x56, 0x01, 0x5E, 0x01, 0x66, 0x01, 0x6E, 0x01, 0x76, 0x01, 0x7E, 0x01, 0x86, ++ 0x01, 0x8E, 0x01, 0x96, 0x01, 0x9E, 0x01, 0xA6, 0x01, 0xAE, 0x01, 0xB6, 0x01, 0xBE, 0x01, 0xC6, ++ 0x01, 0xCE, 0x01, 0xD6, 0x01, 0xDE, 0x01, 0xE6, 0x01, 0xEE, 0x01, 0xF6, 0x01, 0xFE, 0x02, 0x06, ++ 0x02, 0x0E, 0x02, 0x16, 0x02, 0x1E, 0x02, 0x26, 0x02, 0x2E, 0x02, 0x36, 0x02, 0x3E, 0x02, 0x46, ++ 0x02, 0x4E, 0x02, 0x56, 0x02, 0x5E, 0x02, 0x66, 0x02, 0x6E, 0x02, 0x76, 0x02, 0x7E, 0x02, 0x86, ++ 0x02, 0x8E, 0x02, 0x96, 0x02, 0x9E, 0x02, 0xA6, 0x02, 0xAE, 0x02, 0xB6, 0x02, 0xBE, 0x02, 0xC6, ++ 0x02, 0xCE, 0x02, 0xD6, 0x02, 0xDE, 0x02, 0xE6, 0x02, 0xEE, 0x02, 0xF6, 0x02, 0xFE, 0x03, 0x06, ++ 0x03, 0x0E, 0x03, 0x16, 0x03, 0x1E, 0x03, 0x26, 0x03, 0x2E, 0x03, 0x36, 0x03, 0x3E, 0x03, 0x46, ++ 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x08, 0x03, 0x41, ++ 0x00, 0x03, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0xB5, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x43, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0x95, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0x95, 0x03, 0x43, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0x97, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x03, 0x97, 0x03, 0x43, 0x03, 0x01, ++ 0x00, 0x03, 0x03, 0xB9, 0x03, 0x43, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x14, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xB9, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, 0x03, 0x42, 0x00, 0x03, 0x03, 0x99, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0x99, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0xBF, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xBF, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0x9F, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0x9F, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC5, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xC5, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x03, 0x21, 0x26, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x01, ++ 0x00, 0x03, 0x21, 0x26, 0x03, 0x14, 0x03, 0x01, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x01, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x41, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x01, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x13, 0x03, 0x42, ++ 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x08, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x08, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x41, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x14, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x21, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x41, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x21, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x13, 0x03, 0x42, ++ 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x43, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x28, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x28, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x41, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x42, ++ 0x00, 0x03, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x61, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x41, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x61, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x13, 0x03, 0x42, ++ 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, ++ 0x00, 0x03, 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x69, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x41, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0x69, 0x03, 0x41, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x42, ++ 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x03, 0x03, 0xB1, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x03, 0x03, 0xB7, 0x03, 0x01, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xC9, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x01, 0x00, 0x54, 0x03, 0x90, 0x03, 0xB0, 0x1F, 0x02, 0x1F, 0x04, 0x1F, 0x0A, 0x1F, 0x0C, ++ 0x1F, 0x12, 0x1F, 0x14, 0x1F, 0x1A, 0x1F, 0x1C, 0x1F, 0x22, 0x1F, 0x24, 0x1F, 0x2A, 0x1F, 0x2C, ++ 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x36, 0x1F, 0x3A, 0x1F, 0x3C, 0x1F, 0x42, ++ 0x1F, 0x44, 0x1F, 0x4A, 0x1F, 0x4C, 0x1F, 0x52, 0x1F, 0x54, 0x1F, 0x62, 0x1F, 0x64, 0x1F, 0x6A, ++ 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x6E, 0x1F, 0x80, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, ++ 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, ++ 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, ++ 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, ++ 0x1F, 0xA0, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, ++ 0x1F, 0xA9, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB2, ++ 0x1F, 0xB4, 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xD2, 0x1F, 0xF2, 0x1F, 0xF4, 0x00, 0x01, 0x03, 0x3C, ++ 0x00, 0x51, 0x00, 0xA8, 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xC8, 0x00, 0xD0, 0x00, 0xD8, ++ 0x00, 0xE0, 0x00, 0xE8, 0x00, 0xF0, 0x00, 0xF8, 0x01, 0x00, 0x01, 0x08, 0x01, 0x10, 0x01, 0x18, ++ 0x01, 0x20, 0x01, 0x28, 0x01, 0x30, 0x01, 0x38, 0x01, 0x40, 0x01, 0x48, 0x01, 0x50, 0x01, 0x58, ++ 0x01, 0x60, 0x01, 0x68, 0x01, 0x70, 0x01, 0x78, 0x01, 0x80, 0x01, 0x88, 0x01, 0x90, 0x01, 0x98, ++ 0x01, 0xA0, 0x01, 0xA8, 0x01, 0xB0, 0x01, 0xB8, 0x01, 0xC0, 0x01, 0xC8, 0x01, 0xD0, 0x01, 0xDA, ++ 0x01, 0xE2, 0x01, 0xEA, 0x01, 0xF2, 0x01, 0xFA, 0x02, 0x02, 0x02, 0x0A, 0x02, 0x14, 0x02, 0x1C, ++ 0x02, 0x24, 0x02, 0x2C, 0x02, 0x34, 0x02, 0x3C, 0x02, 0x44, 0x02, 0x4E, 0x02, 0x56, 0x02, 0x5E, ++ 0x02, 0x66, 0x02, 0x6E, 0x02, 0x76, 0x02, 0x7E, 0x02, 0x88, 0x02, 0x90, 0x02, 0x98, 0x02, 0xA0, ++ 0x02, 0xA8, 0x02, 0xB0, 0x02, 0xB8, 0x02, 0xC2, 0x02, 0xCA, 0x02, 0xD2, 0x02, 0xDA, 0x02, 0xE2, ++ 0x02, 0xEA, 0x02, 0xF2, 0x02, 0xFA, 0x03, 0x04, 0x03, 0x0C, 0x03, 0x14, 0x03, 0x1C, 0x03, 0x24, ++ 0x03, 0x2C, 0x03, 0x34, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB1, + 0x03, 0x43, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x41, 0x00, 0x03, 0x03, 0x91, + 0x03, 0x43, 0x03, 0x40, 0x00, 0x03, 0x03, 0x91, 0x03, 0x43, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB5, + 0x03, 0x43, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB5, 0x03, 0x43, 0x03, 0x41, 0x00, 0x03, 0x03, 0x95, +@@ -1960,1728 +1911,1637 @@ + 0x1F, 0xFC, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x42, 0x03, 0x45, + 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x41, 0x03, 0x45, + 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x41, 0x03, 0x45, +- 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB9, 0x03, 0x08, 0x03, 0x41, +- 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x41, 0x03, 0x45, +- 0x00, 0x01, 0x00, 0x52, 0x03, 0x90, 0x1F, 0x02, 0x1F, 0x04, 0x1F, 0x0A, 0x1F, 0x0C, 0x1F, 0x12, +- 0x1F, 0x14, 0x1F, 0x1A, 0x1F, 0x1C, 0x1F, 0x22, 0x1F, 0x24, 0x1F, 0x2A, 0x1F, 0x2C, 0x1F, 0x32, +- 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x3A, 0x1F, 0x3C, 0x1F, 0x42, 0x1F, 0x44, 0x1F, 0x4A, +- 0x1F, 0x4C, 0x1F, 0x52, 0x1F, 0x54, 0x1F, 0x62, 0x1F, 0x64, 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, +- 0x1F, 0x6D, 0x1F, 0x80, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, +- 0x1F, 0x88, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, +- 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x9A, +- 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, 0x1F, 0xA2, 0x1F, 0xA3, +- 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, 0x1F, 0xA9, 0x1F, 0xAA, 0x1F, 0xAB, +- 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB2, 0x1F, 0xB4, 0x1F, 0xC2, 0x1F, 0xC4, +- 0x1F, 0xD2, 0x1F, 0xD3, 0x1F, 0xF2, 0x1F, 0xF4, 0x00, 0x01, 0x02, 0x3A, 0x00, 0x36, 0x00, 0x72, +- 0x00, 0x7A, 0x00, 0x82, 0x00, 0x8A, 0x00, 0x92, 0x00, 0x9A, 0x00, 0xA2, 0x00, 0xAA, 0x00, 0xB2, +- 0x00, 0xBA, 0x00, 0xC2, 0x00, 0xCC, 0x00, 0xD6, 0x00, 0xDE, 0x00, 0xE6, 0x00, 0xEE, 0x00, 0xF6, +- 0x00, 0xFE, 0x01, 0x08, 0x01, 0x12, 0x01, 0x1A, 0x01, 0x22, 0x01, 0x2A, 0x01, 0x32, 0x01, 0x3A, +- 0x01, 0x44, 0x01, 0x4E, 0x01, 0x56, 0x01, 0x5E, 0x01, 0x66, 0x01, 0x6E, 0x01, 0x76, 0x01, 0x80, +- 0x01, 0x8A, 0x01, 0x92, 0x01, 0x9A, 0x01, 0xA2, 0x01, 0xAA, 0x01, 0xB2, 0x01, 0xBC, 0x01, 0xC6, +- 0x01, 0xCE, 0x01, 0xD6, 0x01, 0xDE, 0x01, 0xE6, 0x01, 0xEE, 0x01, 0xF8, 0x02, 0x02, 0x02, 0x0A, +- 0x02, 0x12, 0x02, 0x1A, 0x02, 0x22, 0x02, 0x2A, 0x02, 0x32, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, +- 0x03, 0x01, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x13, +- 0x03, 0x01, 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x45, +- 0x03, 0x40, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x00, 0x03, 0x45, +- 0x03, 0x41, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, +- 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, +- 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, +- 0x1F, 0x09, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, +- 0x1F, 0x09, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x42, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, +- 0x03, 0x43, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x45, +- 0x03, 0x40, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x21, 0x03, 0x45, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, +- 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, +- 0x1F, 0x28, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, +- 0x1F, 0x28, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, +- 0x03, 0x97, 0x03, 0x13, 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x45, +- 0x03, 0x40, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x60, 0x03, 0x45, +- 0x03, 0x41, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, +- 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, +- 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, +- 0x1F, 0x69, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, +- 0x1F, 0x69, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x42, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, +- 0x03, 0x40, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, +- 0x03, 0x40, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, +- 0x03, 0x01, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, +- 0x03, 0x01, 0x00, 0x01, 0x00, 0x36, 0x03, 0x90, 0x1F, 0x32, 0x1F, 0x34, 0x1F, 0x6A, 0x1F, 0x6C, +- 0x1F, 0x80, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, +- 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, 0x1F, 0x92, +- 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x9A, 0x1F, 0x9B, +- 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, +- 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB2, 0x1F, 0xB4, 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xD3, 0x1F, 0xF2, +- 0x1F, 0xF4, 0x00, 0x01, 0x01, 0xEA, 0x00, 0x2E, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x7A, +- 0x00, 0x82, 0x00, 0x8A, 0x00, 0x92, 0x00, 0x9A, 0x00, 0xA2, 0x00, 0xAA, 0x00, 0xB4, 0x00, 0xBE, +- 0x00, 0xC6, 0x00, 0xCE, 0x00, 0xD6, 0x00, 0xDE, 0x00, 0xE8, 0x00, 0xF2, 0x00, 0xFA, 0x01, 0x02, +- 0x01, 0x0A, 0x01, 0x12, 0x01, 0x1C, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x36, 0x01, 0x3E, 0x01, 0x46, +- 0x01, 0x50, 0x01, 0x5A, 0x01, 0x62, 0x01, 0x6A, 0x01, 0x72, 0x01, 0x7A, 0x01, 0x84, 0x01, 0x8E, +- 0x01, 0x96, 0x01, 0x9E, 0x01, 0xA6, 0x01, 0xAE, 0x01, 0xB6, 0x01, 0xC0, 0x01, 0xCA, 0x01, 0xD2, +- 0x01, 0xDA, 0x01, 0xE2, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xBE, +- 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x21, 0x26, +- 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xB3, +- 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xB3, +- 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB1, +- 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, +- 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x14, 0x03, 0x00, +- 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x14, 0x03, 0x01, +- 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, +- 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xC3, +- 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xC3, +- 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x00, +- 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x01, +- 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xF3, +- 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xF3, +- 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, +- 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, +- 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x00, +- 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x01, +- 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, +- 0x03, 0x42, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB1, +- 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xBE, +- 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x41, 0x00, 0x01, 0x00, 0x2E, ++ 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x08, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x00, ++ 0x00, 0x03, 0x03, 0xC9, 0x03, 0x41, 0x03, 0x45, 0x00, 0x01, 0x00, 0x51, 0x03, 0x90, 0x1F, 0x02, ++ 0x1F, 0x04, 0x1F, 0x0A, 0x1F, 0x0C, 0x1F, 0x12, 0x1F, 0x14, 0x1F, 0x1A, 0x1F, 0x1C, 0x1F, 0x22, ++ 0x1F, 0x24, 0x1F, 0x2A, 0x1F, 0x2C, 0x1F, 0x32, 0x1F, 0x33, 0x1F, 0x34, 0x1F, 0x35, 0x1F, 0x3A, ++ 0x1F, 0x3C, 0x1F, 0x42, 0x1F, 0x44, 0x1F, 0x4A, 0x1F, 0x4C, 0x1F, 0x52, 0x1F, 0x54, 0x1F, 0x62, ++ 0x1F, 0x64, 0x1F, 0x6A, 0x1F, 0x6B, 0x1F, 0x6C, 0x1F, 0x6D, 0x1F, 0x80, 0x1F, 0x82, 0x1F, 0x83, ++ 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, ++ 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, ++ 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, ++ 0x1F, 0x9F, 0x1F, 0xA0, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, ++ 0x1F, 0xA8, 0x1F, 0xA9, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, ++ 0x1F, 0xB2, 0x1F, 0xB4, 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xD2, 0x1F, 0xF2, 0x1F, 0xF4, 0x00, 0x01, ++ 0x02, 0x30, 0x00, 0x35, 0x00, 0x70, 0x00, 0x78, 0x00, 0x80, 0x00, 0x88, 0x00, 0x90, 0x00, 0x98, ++ 0x00, 0xA0, 0x00, 0xA8, 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xCA, 0x00, 0xD4, 0x00, 0xDC, ++ 0x00, 0xE4, 0x00, 0xEC, 0x00, 0xF4, 0x00, 0xFC, 0x01, 0x06, 0x01, 0x10, 0x01, 0x18, 0x01, 0x20, ++ 0x01, 0x28, 0x01, 0x30, 0x01, 0x38, 0x01, 0x42, 0x01, 0x4C, 0x01, 0x54, 0x01, 0x5C, 0x01, 0x64, ++ 0x01, 0x6C, 0x01, 0x74, 0x01, 0x7E, 0x01, 0x88, 0x01, 0x90, 0x01, 0x98, 0x01, 0xA0, 0x01, 0xA8, ++ 0x01, 0xB0, 0x01, 0xBA, 0x01, 0xC4, 0x01, 0xCC, 0x01, 0xD4, 0x01, 0xDC, 0x01, 0xE4, 0x01, 0xEC, ++ 0x01, 0xF6, 0x02, 0x00, 0x02, 0x08, 0x02, 0x10, 0x02, 0x18, 0x02, 0x20, 0x02, 0x28, 0x00, 0x03, ++ 0x1F, 0xBE, 0x03, 0x08, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, ++ 0x1F, 0xBE, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, ++ 0x21, 0x26, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, ++ 0x1F, 0x00, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, ++ 0x1F, 0x00, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x01, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0xB1, 0x03, 0x13, 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, ++ 0x03, 0x42, 0x00, 0x03, 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x45, ++ 0x03, 0x40, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x08, 0x03, 0x45, ++ 0x03, 0x41, 0x00, 0x03, 0x1F, 0x09, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, ++ 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, ++ 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, ++ 0x1F, 0x21, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x20, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, ++ 0x1F, 0x21, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x42, 0x03, 0x45, ++ 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0x97, 0x03, 0x45, ++ 0x03, 0x43, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x45, ++ 0x03, 0x40, 0x00, 0x03, 0x1F, 0x28, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x29, 0x03, 0x45, ++ 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, ++ 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, ++ 0x1F, 0x60, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, ++ 0x1F, 0x60, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x1F, 0x61, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0xC9, 0x03, 0x13, 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x45, ++ 0x03, 0x42, 0x00, 0x03, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x45, ++ 0x03, 0x40, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x1F, 0x68, 0x03, 0x45, ++ 0x03, 0x41, 0x00, 0x03, 0x1F, 0x69, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, ++ 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, ++ 0x03, 0xB1, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x01, 0x00, 0x03, ++ 0x03, 0xB7, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x01, 0x00, 0x03, ++ 0x03, 0xC9, 0x03, 0x45, 0x03, 0x40, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x01, 0x00, 0x01, ++ 0x00, 0x35, 0x03, 0x90, 0x1F, 0x32, 0x1F, 0x34, 0x1F, 0x6A, 0x1F, 0x6C, 0x1F, 0x80, 0x1F, 0x82, ++ 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x88, 0x1F, 0x8A, 0x1F, 0x8B, ++ 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x8F, 0x1F, 0x90, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, ++ 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x98, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, ++ 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA0, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, ++ 0x1F, 0xA7, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x1F, 0xAF, ++ 0x1F, 0xB2, 0x1F, 0xB4, 0x1F, 0xC2, 0x1F, 0xC4, 0x1F, 0xF2, 0x1F, 0xF4, 0x00, 0x01, 0x01, 0xE0, ++ 0x00, 0x2D, 0x00, 0x60, 0x00, 0x68, 0x00, 0x70, 0x00, 0x78, 0x00, 0x80, 0x00, 0x88, 0x00, 0x90, ++ 0x00, 0x98, 0x00, 0xA0, 0x00, 0xA8, 0x00, 0xB2, 0x00, 0xBC, 0x00, 0xC4, 0x00, 0xCC, 0x00, 0xD4, ++ 0x00, 0xDC, 0x00, 0xE6, 0x00, 0xF0, 0x00, 0xF8, 0x01, 0x00, 0x01, 0x08, 0x01, 0x10, 0x01, 0x1A, ++ 0x01, 0x24, 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x44, 0x01, 0x4E, 0x01, 0x58, 0x01, 0x60, ++ 0x01, 0x68, 0x01, 0x70, 0x01, 0x78, 0x01, 0x82, 0x01, 0x8C, 0x01, 0x94, 0x01, 0x9C, 0x01, 0xA4, ++ 0x01, 0xAC, 0x01, 0xB4, 0x01, 0xBE, 0x01, 0xC8, 0x01, 0xD0, 0x01, 0xD8, 0x00, 0x03, 0x1F, 0xBE, ++ 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xBE, ++ 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x21, 0x26, ++ 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xB3, ++ 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xB3, ++ 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, ++ 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x00, ++ 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x01, ++ 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, ++ 0x03, 0x42, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xC3, ++ 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xC3, ++ 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, ++ 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x00, ++ 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xF3, ++ 0x03, 0x14, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xF3, ++ 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, ++ 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x00, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x14, 0x03, 0x00, ++ 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x42, 0x00, 0x03, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x03, 0xB7, ++ 0x03, 0x45, 0x03, 0x41, 0x00, 0x03, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x41, 0x00, 0x01, 0x00, 0x2D, + 0x03, 0x90, 0x1F, 0x32, 0x1F, 0x34, 0x1F, 0x6A, 0x1F, 0x6C, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, + 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x87, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, + 0x1F, 0x8F, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x97, 0x1F, 0x9A, + 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0x9F, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, + 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA7, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB4, 0x1F, 0xC4, 0x1F, 0xD3, 0x1F, 0xF4, 0x00, 0x01, 0x01, 0x7C, +- 0x00, 0x24, 0x00, 0x4E, 0x00, 0x56, 0x00, 0x5E, 0x00, 0x66, 0x00, 0x6E, 0x00, 0x76, 0x00, 0x7E, +- 0x00, 0x86, 0x00, 0x8E, 0x00, 0x98, 0x00, 0xA0, 0x00, 0xA8, 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC2, +- 0x00, 0xCA, 0x00, 0xD2, 0x00, 0xDA, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF4, 0x00, 0xFC, 0x01, 0x04, +- 0x01, 0x0C, 0x01, 0x16, 0x01, 0x1E, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x36, 0x01, 0x40, 0x01, 0x48, +- 0x01, 0x50, 0x01, 0x58, 0x01, 0x60, 0x01, 0x68, 0x01, 0x72, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x13, +- 0x03, 0x40, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x13, +- 0x03, 0x41, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, +- 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xBC, +- 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xBC, +- 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, +- 0x1F, 0xC3, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, +- 0x1F, 0xC3, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x40, +- 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x41, +- 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x42, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x14, +- 0x03, 0x40, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x21, 0x26, +- 0x03, 0x43, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xFC, +- 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xFC, +- 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, +- 0x21, 0x26, 0x03, 0x14, 0x03, 0x42, 0x03, 0x45, 0x00, 0x01, 0x00, 0x24, 0x1F, 0x32, 0x1F, 0x34, +- 0x1F, 0x6A, 0x1F, 0x6C, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x8A, ++ 0x1F, 0xAE, 0x1F, 0xAF, 0x1F, 0xB4, 0x1F, 0xC4, 0x1F, 0xF4, 0x00, 0x01, 0x01, 0x7C, 0x00, 0x24, ++ 0x00, 0x4E, 0x00, 0x56, 0x00, 0x5E, 0x00, 0x66, 0x00, 0x6E, 0x00, 0x76, 0x00, 0x7E, 0x00, 0x86, ++ 0x00, 0x8E, 0x00, 0x98, 0x00, 0xA0, 0x00, 0xA8, 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC2, 0x00, 0xCA, ++ 0x00, 0xD2, 0x00, 0xDA, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF4, 0x00, 0xFC, 0x01, 0x04, 0x01, 0x0C, ++ 0x01, 0x16, 0x01, 0x1E, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x36, 0x01, 0x40, 0x01, 0x48, 0x01, 0x50, ++ 0x01, 0x58, 0x01, 0x60, 0x01, 0x68, 0x01, 0x72, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, 0x03, 0x01, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x13, 0x03, 0x40, ++ 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x13, 0x03, 0x41, ++ 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x42, ++ 0x03, 0x45, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x14, ++ 0x03, 0x40, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x14, ++ 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xC3, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xC3, ++ 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, ++ 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, ++ 0x1F, 0xCC, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x14, 0x03, 0x40, ++ 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x14, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, ++ 0x03, 0x45, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x14, ++ 0x03, 0x40, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x13, 0x03, 0x41, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x14, ++ 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x42, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, ++ 0x03, 0x14, 0x03, 0x42, 0x03, 0x45, 0x00, 0x01, 0x00, 0x24, 0x1F, 0x32, 0x1F, 0x34, 0x1F, 0x6A, ++ 0x1F, 0x6C, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x8A, 0x1F, 0x8B, ++ 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, ++ 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, ++ 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, ++ 0x1F, 0xAF, 0x00, 0x01, 0x01, 0x94, 0x00, 0x24, 0x00, 0x4E, 0x00, 0x56, 0x00, 0x5E, 0x00, 0x66, ++ 0x00, 0x6E, 0x00, 0x76, 0x00, 0x80, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA4, 0x00, 0xAE, ++ 0x00, 0xB6, 0x00, 0xC0, 0x00, 0xCA, 0x00, 0xD2, 0x00, 0xDC, 0x00, 0xE4, 0x00, 0xEE, 0x00, 0xF8, ++ 0x01, 0x00, 0x01, 0x0A, 0x01, 0x12, 0x01, 0x1C, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x38, 0x01, 0x40, ++ 0x01, 0x4A, 0x01, 0x54, 0x01, 0x5C, 0x01, 0x64, 0x01, 0x6E, 0x01, 0x76, 0x01, 0x80, 0x01, 0x8A, ++ 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, 0x03, 0x41, ++ 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, 0x03, 0x40, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, 0x03, 0x41, ++ 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x00, ++ 0x03, 0x45, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, ++ 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, ++ 0x1F, 0xBC, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x01, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xC3, ++ 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, ++ 0x1F, 0xC3, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x43, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xCC, ++ 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, ++ 0x03, 0x97, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x43, 0x03, 0x00, ++ 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x43, ++ 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, ++ 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x00, 0x03, ++ 0x1F, 0xFC, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x01, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, 0x21, 0x26, ++ 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x01, 0x00, 0x24, 0x1F, 0x32, 0x1F, 0x34, 0x1F, 0x6A, ++ 0x1F, 0x6C, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x8A, 0x1F, 0x8B, ++ 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, ++ 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, ++ 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, ++ 0x1F, 0xAF, 0x00, 0x01, 0x01, 0x6C, 0x00, 0x20, 0x00, 0x46, 0x00, 0x4E, 0x00, 0x58, 0x00, 0x60, ++ 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7C, 0x00, 0x86, 0x00, 0x8E, 0x00, 0x98, 0x00, 0xA2, 0x00, 0xAA, ++ 0x00, 0xB4, 0x00, 0xBC, 0x00, 0xC6, 0x00, 0xD0, 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEA, 0x00, 0xF4, ++ 0x00, 0xFE, 0x01, 0x06, 0x01, 0x10, 0x01, 0x18, 0x01, 0x22, 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, ++ 0x01, 0x46, 0x01, 0x4E, 0x01, 0x58, 0x01, 0x62, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x43, 0x03, 0x40, ++ 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x43, ++ 0x03, 0x41, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, ++ 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, ++ 0x03, 0x91, 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x43, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, ++ 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0xB7, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x13, ++ 0x03, 0x42, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, ++ 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, ++ 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, ++ 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x40, ++ 0x03, 0x45, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, ++ 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, ++ 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, ++ 0x03, 0xA9, 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x43, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, ++ 0x03, 0x13, 0x03, 0x42, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, 0x00, 0x01, ++ 0x00, 0x20, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x8A, 0x1F, 0x8B, ++ 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x96, ++ 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, ++ 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, ++ 0x1F, 0xAF, 0x00, 0x01, 0x01, 0x6E, 0x00, 0x1E, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, ++ 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, ++ 0x00, 0xBA, 0x00, 0xC4, 0x00, 0xCE, 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF6, 0x01, 0x00, ++ 0x01, 0x0A, 0x01, 0x14, 0x01, 0x1E, 0x01, 0x28, 0x01, 0x32, 0x01, 0x3C, 0x01, 0x46, 0x01, 0x50, ++ 0x01, 0x5A, 0x01, 0x64, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, ++ 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x01, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB1, ++ 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, ++ 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, ++ 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, ++ 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x00, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, ++ 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, ++ 0x03, 0x97, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x45, ++ 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, 0x03, 0xC9, ++ 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, ++ 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, ++ 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, ++ 0x03, 0xA9, 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x45, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, ++ 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, ++ 0x00, 0x01, 0x00, 0x1E, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x8A, + 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, + 0x1F, 0x96, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0xA2, 0x1F, 0xA3, +- 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x1F, 0xAF, 0x00, 0x01, 0x01, 0x94, 0x00, 0x24, 0x00, 0x4E, 0x00, 0x56, 0x00, 0x5E, +- 0x00, 0x66, 0x00, 0x6E, 0x00, 0x76, 0x00, 0x80, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA4, +- 0x00, 0xAE, 0x00, 0xB6, 0x00, 0xC0, 0x00, 0xCA, 0x00, 0xD2, 0x00, 0xDC, 0x00, 0xE4, 0x00, 0xEE, +- 0x00, 0xF8, 0x01, 0x00, 0x01, 0x0A, 0x01, 0x12, 0x01, 0x1C, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x38, +- 0x01, 0x40, 0x01, 0x4A, 0x01, 0x54, 0x01, 0x5C, 0x01, 0x64, 0x01, 0x6E, 0x01, 0x76, 0x01, 0x80, +- 0x01, 0x8A, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, 0x03, 0x40, 0x00, 0x03, 0x1F, 0xBE, 0x03, 0x43, +- 0x03, 0x41, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, 0x03, 0x40, 0x00, 0x03, 0x21, 0x26, 0x03, 0x43, +- 0x03, 0x41, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, +- 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB1, +- 0x03, 0x14, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, +- 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, +- 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, +- 0x1F, 0xC3, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, +- 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xCC, +- 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, +- 0x1F, 0xCC, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x01, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x43, +- 0x03, 0x00, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xF3, +- 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, +- 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x03, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, +- 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, +- 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x42, 0x00, 0x04, +- 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, 0x03, 0x42, 0x00, 0x01, 0x00, 0x24, 0x1F, 0x32, 0x1F, 0x34, +- 0x1F, 0x6A, 0x1F, 0x6C, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x8A, +- 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, +- 0x1F, 0x96, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0xA2, 0x1F, 0xA3, +- 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x1F, 0xAF, 0x00, 0x01, 0x01, 0x6C, 0x00, 0x20, 0x00, 0x46, 0x00, 0x4E, 0x00, 0x58, +- 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7C, 0x00, 0x86, 0x00, 0x8E, 0x00, 0x98, 0x00, 0xA2, +- 0x00, 0xAA, 0x00, 0xB4, 0x00, 0xBC, 0x00, 0xC6, 0x00, 0xD0, 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEA, +- 0x00, 0xF4, 0x00, 0xFE, 0x01, 0x06, 0x01, 0x10, 0x01, 0x18, 0x01, 0x22, 0x01, 0x2C, 0x01, 0x34, +- 0x01, 0x3C, 0x01, 0x46, 0x01, 0x4E, 0x01, 0x58, 0x01, 0x62, 0x00, 0x03, 0x1F, 0xB3, 0x03, 0x43, +- 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xB3, +- 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, +- 0x03, 0xB1, 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x43, 0x03, 0x40, +- 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xBC, 0x03, 0x43, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, +- 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xC3, 0x03, 0x43, 0x03, 0x41, +- 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, +- 0x03, 0x13, 0x03, 0x42, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, +- 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xCC, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, +- 0x03, 0x97, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, +- 0x03, 0x42, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, +- 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xF3, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, +- 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, +- 0x00, 0x03, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x43, 0x03, 0x40, +- 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, 0x00, 0x03, 0x1F, 0xFC, 0x03, 0x43, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, +- 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x14, 0x03, 0x42, +- 0x00, 0x01, 0x00, 0x20, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, 0x1F, 0x8A, +- 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, +- 0x1F, 0x96, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0xA2, 0x1F, 0xA3, +- 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xA8, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x1F, 0xAF, 0x00, 0x01, 0x01, 0x6E, 0x00, 0x1E, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, +- 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, +- 0x00, 0xB0, 0x00, 0xBA, 0x00, 0xC4, 0x00, 0xCE, 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF6, +- 0x01, 0x00, 0x01, 0x0A, 0x01, 0x14, 0x01, 0x1E, 0x01, 0x28, 0x01, 0x32, 0x01, 0x3C, 0x01, 0x46, +- 0x01, 0x50, 0x01, 0x5A, 0x01, 0x64, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, +- 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, +- 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x00, +- 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, +- 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, +- 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, +- 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, +- 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, 0x03, 0x97, +- 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, +- 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, +- 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x04, +- 0x03, 0xC9, 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x45, +- 0x03, 0x00, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, +- 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, +- 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, +- 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, +- 0x03, 0xA9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, +- 0x03, 0x42, 0x00, 0x01, 0x00, 0x1E, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x86, +- 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x8E, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, +- 0x1F, 0x95, 0x1F, 0x96, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0x9E, 0x1F, 0xA2, +- 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x00, 0x01, 0x01, 0x32, 0x00, 0x19, 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, +- 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, +- 0x00, 0xB0, 0x00, 0xBA, 0x00, 0xC4, 0x00, 0xCE, 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF6, +- 0x01, 0x00, 0x01, 0x0A, 0x01, 0x14, 0x01, 0x1E, 0x01, 0x28, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, +- 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0xB1, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, +- 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, +- 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, +- 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, +- 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0xC9, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x45, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, +- 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, +- 0x03, 0x42, 0x03, 0x45, 0x00, 0x01, 0x00, 0x19, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, +- 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, +- 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, +- 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x00, 0x01, 0x01, 0x32, 0x00, 0x19, +- 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, +- 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, 0x00, 0xBA, 0x00, 0xC4, 0x00, 0xCE, +- 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF6, 0x01, 0x00, 0x01, 0x0A, 0x01, 0x14, 0x01, 0x1E, +- 0x01, 0x28, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, +- 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, +- 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, +- 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, +- 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, +- 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, +- 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, +- 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, +- 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, +- 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, +- 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xC9, +- 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, +- 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, +- 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, +- 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, +- 0x03, 0x01, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x01, 0x00, 0x19, +- 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, +- 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, +- 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x00, 0x01, 0x01, 0x32, 0x00, 0x19, 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, +- 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, +- 0x00, 0xB0, 0x00, 0xBA, 0x00, 0xC4, 0x00, 0xCE, 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF6, +- 0x01, 0x00, 0x01, 0x0A, 0x01, 0x14, 0x01, 0x1E, 0x01, 0x28, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, +- 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0xB1, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, +- 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, +- 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, +- 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, +- 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, +- 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, +- 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0xC9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, +- 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, +- 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, +- 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, +- 0x03, 0x42, 0x03, 0x45, 0x00, 0x01, 0x00, 0x19, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, +- 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, +- 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, +- 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x00, 0x01, 0x00, 0xBA, 0x00, 0x0F, +- 0x00, 0x24, 0x00, 0x2E, 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, 0x00, 0x6A, +- 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, 0x00, 0x04, +- 0x03, 0xB1, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, +- 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, +- 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, +- 0x03, 0xC9, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, +- 0x03, 0x14, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, +- 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, +- 0x03, 0x45, 0x03, 0x42, 0x00, 0x01, 0x00, 0x0F, 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, +- 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAB, +- 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x00, 0x01, 0x00, 0xBA, 0x00, 0x0F, 0x00, 0x24, 0x00, 0x2E, +- 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, +- 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, +- 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, +- 0x03, 0x91, 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x41, +- 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, +- 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, +- 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, +- 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, +- 0x03, 0xA9, 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x40, +- 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, +- 0x03, 0x14, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, +- 0x00, 0x01, 0x00, 0x0F, 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, +- 0x1F, 0x9A, 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, +- 0x1F, 0xAE, 0x00, 0x01, 0x00, 0xBA, 0x00, 0x0F, 0x00, 0x24, 0x00, 0x2E, 0x00, 0x38, 0x00, 0x42, +- 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, +- 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x03, 0x00, +- 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, +- 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, +- 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, +- 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x00, +- 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, +- 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, +- 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, +- 0x03, 0x01, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x01, 0x00, 0x0F, +- 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, +- 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x00, 0x01, +- 0x00, 0xAE, 0x00, 0x0E, 0x00, 0x22, 0x00, 0x2C, 0x00, 0x36, 0x00, 0x40, 0x00, 0x4A, 0x00, 0x54, +- 0x00, 0x5E, 0x00, 0x68, 0x00, 0x72, 0x00, 0x7C, 0x00, 0x86, 0x00, 0x90, 0x00, 0x9A, 0x00, 0xA4, +- 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, +- 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, +- 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, +- 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x45, 0x03, 0x41, +- 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, +- 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, +- 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, +- 0x03, 0x41, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, 0x00, 0x01, 0x00, 0x0E, +- 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, +- 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x00, 0x01, 0x00, 0xAE, ++ 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xA6, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, ++ 0x00, 0x01, 0x01, 0x32, 0x00, 0x19, 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, ++ 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, ++ 0x00, 0xBA, 0x00, 0xC4, 0x00, 0xCE, 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF6, 0x01, 0x00, ++ 0x01, 0x0A, 0x01, 0x14, 0x01, 0x1E, 0x01, 0x28, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x40, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, ++ 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x14, ++ 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, ++ 0x03, 0x91, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x40, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x14, ++ 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, ++ 0x03, 0x97, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x40, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, ++ 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x14, ++ 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, ++ 0x03, 0xA9, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x42, ++ 0x03, 0x45, 0x00, 0x01, 0x00, 0x19, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x8A, ++ 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x9A, ++ 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xAA, ++ 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x00, 0x01, 0x01, 0x32, 0x00, 0x19, 0x00, 0x38, ++ 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, ++ 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, 0x00, 0xBA, 0x00, 0xC4, 0x00, 0xCE, 0x00, 0xD8, ++ 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF6, 0x01, 0x00, 0x01, 0x0A, 0x01, 0x14, 0x01, 0x1E, 0x01, 0x28, ++ 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, ++ 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, ++ 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, ++ 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, ++ 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, ++ 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, ++ 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, ++ 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, 0x03, 0x42, 0x00, 0x01, 0x00, 0x19, 0x1F, 0x82, ++ 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x8A, 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x92, ++ 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x9A, 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0xA2, ++ 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, ++ 0x00, 0x01, 0x01, 0x32, 0x00, 0x19, 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, ++ 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, ++ 0x00, 0xBA, 0x00, 0xC4, 0x00, 0xCE, 0x00, 0xD8, 0x00, 0xE2, 0x00, 0xEC, 0x00, 0xF6, 0x01, 0x00, ++ 0x01, 0x0A, 0x01, 0x14, 0x01, 0x1E, 0x01, 0x28, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x13, 0x03, 0x45, ++ 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, ++ 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0x91, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x13, 0x03, 0x45, ++ 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0x97, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x13, 0x03, 0x45, ++ 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, ++ 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, ++ 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0xA9, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x42, ++ 0x03, 0x45, 0x00, 0x01, 0x00, 0x19, 0x1F, 0x82, 0x1F, 0x83, 0x1F, 0x84, 0x1F, 0x85, 0x1F, 0x8A, ++ 0x1F, 0x8B, 0x1F, 0x8C, 0x1F, 0x8D, 0x1F, 0x92, 0x1F, 0x93, 0x1F, 0x94, 0x1F, 0x95, 0x1F, 0x9A, ++ 0x1F, 0x9B, 0x1F, 0x9C, 0x1F, 0x9D, 0x1F, 0xA2, 0x1F, 0xA3, 0x1F, 0xA4, 0x1F, 0xA5, 0x1F, 0xAA, ++ 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x00, 0x01, 0x00, 0xBA, 0x00, 0x0F, 0x00, 0x24, ++ 0x00, 0x2E, 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, ++ 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, 0x00, 0x04, 0x03, 0xB1, ++ 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, ++ 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, ++ 0x03, 0xB7, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x00, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, ++ 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, ++ 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, ++ 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, ++ 0x21, 0x26, 0x03, 0x14, 0x03, 0x01, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x45, ++ 0x03, 0x42, 0x00, 0x01, 0x00, 0x0F, 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, ++ 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, ++ 0x1F, 0xAD, 0x1F, 0xAE, 0x00, 0x01, 0x00, 0xBA, 0x00, 0x0F, 0x00, 0x24, 0x00, 0x2E, 0x00, 0x38, ++ 0x00, 0x42, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, ++ 0x00, 0x92, 0x00, 0x9C, 0x00, 0xA6, 0x00, 0xB0, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x40, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, ++ 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, ++ 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, ++ 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, ++ 0x03, 0x97, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x40, ++ 0x03, 0x45, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x03, 0xA9, ++ 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x40, 0x03, 0x45, ++ 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, ++ 0x03, 0x41, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x03, 0x42, 0x00, 0x01, ++ 0x00, 0x0F, 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, ++ 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, ++ 0x00, 0x01, 0x00, 0xBA, 0x00, 0x0F, 0x00, 0x24, 0x00, 0x2E, 0x00, 0x38, 0x00, 0x42, 0x00, 0x4C, ++ 0x00, 0x56, 0x00, 0x60, 0x00, 0x6A, 0x00, 0x74, 0x00, 0x7E, 0x00, 0x88, 0x00, 0x92, 0x00, 0x9C, ++ 0x00, 0xA6, 0x00, 0xB0, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, ++ 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x43, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, ++ 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, ++ 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, ++ 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, ++ 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, 0x03, 0x01, ++ 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x03, 0x42, 0x00, 0x01, 0x00, 0x0F, 0x1F, 0x82, ++ 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, 0x1F, 0xA2, ++ 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x1F, 0xAE, 0x00, 0x01, 0x00, 0xAE, + 0x00, 0x0E, 0x00, 0x22, 0x00, 0x2C, 0x00, 0x36, 0x00, 0x40, 0x00, 0x4A, 0x00, 0x54, 0x00, 0x5E, + 0x00, 0x68, 0x00, 0x72, 0x00, 0x7C, 0x00, 0x86, 0x00, 0x90, 0x00, 0x9A, 0x00, 0xA4, 0x00, 0x04, +- 0x03, 0xB1, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x13, +- 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, +- 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, +- 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, +- 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, 0x00, 0x04, +- 0x03, 0xC9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x13, +- 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, +- 0x03, 0x45, 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, +- 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, 0x00, 0x01, 0x00, 0x0E, 0x1F, 0x82, ++ 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x43, 0x03, 0x45, ++ 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, ++ 0x03, 0x43, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, ++ 0x00, 0x04, 0x03, 0xB7, 0x03, 0x43, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, ++ 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x43, 0x03, 0x45, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x43, 0x03, 0x45, ++ 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, ++ 0x03, 0x14, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x43, 0x03, 0x45, 0x03, 0x41, ++ 0x00, 0x04, 0x21, 0x26, 0x03, 0x14, 0x03, 0x45, 0x03, 0x41, 0x00, 0x01, 0x00, 0x0E, 0x1F, 0x82, + 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, 0x1F, 0xA2, + 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x00, 0x01, 0x00, 0xAE, 0x00, 0x0E, + 0x00, 0x22, 0x00, 0x2C, 0x00, 0x36, 0x00, 0x40, 0x00, 0x4A, 0x00, 0x54, 0x00, 0x5E, 0x00, 0x68, + 0x00, 0x72, 0x00, 0x7C, 0x00, 0x86, 0x00, 0x90, 0x00, 0x9A, 0x00, 0xA4, 0x00, 0x04, 0x03, 0xB1, +- 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, +- 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, +- 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, +- 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, +- 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, +- 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, +- 0x03, 0x14, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, +- 0x21, 0x26, 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, 0x00, 0x01, 0x00, 0x0E, 0x1F, 0x82, 0x1F, 0x84, ++ 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, ++ 0x03, 0x13, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, ++ 0x03, 0xB7, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, ++ 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, ++ 0x03, 0x14, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, 0x00, 0x04, ++ 0x21, 0x26, 0x03, 0x45, 0x03, 0x14, 0x03, 0x01, 0x00, 0x01, 0x00, 0x0E, 0x1F, 0x82, 0x1F, 0x84, + 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, +- 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x00, 0x01, 0x00, 0x96, 0x00, 0x0C, 0x00, 0x1E, ++ 0x1F, 0xAA, 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x00, 0x01, 0x00, 0xAE, 0x00, 0x0E, 0x00, 0x22, ++ 0x00, 0x2C, 0x00, 0x36, 0x00, 0x40, 0x00, 0x4A, 0x00, 0x54, 0x00, 0x5E, 0x00, 0x68, 0x00, 0x72, ++ 0x00, 0x7C, 0x00, 0x86, 0x00, 0x90, 0x00, 0x9A, 0x00, 0xA4, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0x91, 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x13, ++ 0x03, 0x41, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, ++ 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0xA9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x14, ++ 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x04, 0x21, 0x26, ++ 0x03, 0x45, 0x03, 0x14, 0x03, 0x41, 0x00, 0x01, 0x00, 0x0E, 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, ++ 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, ++ 0x1F, 0xAB, 0x1F, 0xAC, 0x1F, 0xAD, 0x00, 0x01, 0x00, 0x96, 0x00, 0x0C, 0x00, 0x1E, 0x00, 0x28, ++ 0x00, 0x32, 0x00, 0x3C, 0x00, 0x46, 0x00, 0x50, 0x00, 0x5A, 0x00, 0x64, 0x00, 0x6E, 0x00, 0x78, ++ 0x00, 0x82, 0x00, 0x8C, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, ++ 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xB7, ++ 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, ++ 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, ++ 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, ++ 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, ++ 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x01, 0x00, 0x0C, ++ 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, 0x1F, 0x9C, ++ 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x96, 0x00, 0x0C, 0x00, 0x1E, + 0x00, 0x28, 0x00, 0x32, 0x00, 0x3C, 0x00, 0x46, 0x00, 0x50, 0x00, 0x5A, 0x00, 0x64, 0x00, 0x6E, +- 0x00, 0x78, 0x00, 0x82, 0x00, 0x8C, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, +- 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, +- 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, +- 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, +- 0x03, 0x01, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0x97, +- 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, +- 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, +- 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x01, ++ 0x00, 0x78, 0x00, 0x82, 0x00, 0x8C, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, ++ 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, ++ 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, ++ 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, ++ 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0x97, ++ 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, ++ 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, ++ 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x01, + 0x00, 0x0C, 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, 0x1F, 0x9A, +- 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x96, 0x00, 0x0C, +- 0x00, 0x1E, 0x00, 0x28, 0x00, 0x32, 0x00, 0x3C, 0x00, 0x46, 0x00, 0x50, 0x00, 0x5A, 0x00, 0x64, +- 0x00, 0x6E, 0x00, 0x78, 0x00, 0x82, 0x00, 0x8C, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, +- 0x03, 0x40, 0x00, 0x04, 0x03, 0xB1, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0x91, +- 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0x91, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, +- 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0xB7, 0x03, 0x45, +- 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0x97, 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, +- 0x03, 0x97, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, +- 0x03, 0x40, 0x00, 0x04, 0x03, 0xC9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x04, 0x03, 0xA9, +- 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, 0x00, 0x04, 0x03, 0xA9, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, +- 0x00, 0x01, 0x00, 0x0C, 0x1F, 0x82, 0x1F, 0x84, 0x1F, 0x8A, 0x1F, 0x8C, 0x1F, 0x92, 0x1F, 0x94, +- 0x1F, 0x9A, 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, +- 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, +- 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, ++ 0x1F, 0x9C, 0x1F, 0xA2, 0x1F, 0xA4, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, ++ 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, ++ 0x21, 0x26, 0x03, 0x13, 0x03, 0x01, 0x03, 0x45, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, ++ 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, ++ 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, 0x00, 0x01, ++ 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, ++ 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, ++ 0x03, 0x45, 0x03, 0x01, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, ++ 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, 0x03, 0x40, ++ 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, + 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, +- 0x03, 0x13, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x41, 0x03, 0x45, ++ 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x01, 0x03, 0x45, + 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, +- 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, +- 0x03, 0x13, 0x03, 0x45, 0x03, 0x01, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, +- 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, +- 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, 0x03, 0x13, 0x03, 0x45, 0x03, 0x41, 0x00, 0x01, 0x00, 0x02, ++ 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, ++ 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, ++ 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x45, ++ 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x01, 0x00, 0x02, + 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, +- 0x21, 0x26, 0x03, 0x43, 0x03, 0x00, 0x03, 0x45, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x01, +- 0x03, 0x45, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, +- 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x40, 0x03, 0x45, 0x00, 0x04, +- 0x21, 0x26, 0x03, 0x43, 0x03, 0x41, 0x03, 0x45, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, +- 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, +- 0x03, 0x45, 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x45, 0x03, 0x01, 0x00, 0x01, ++ 0x21, 0x26, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x45, ++ 0x03, 0x41, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, ++ 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, 0x00, 0x04, ++ 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, ++ 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, ++ 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, 0x00, 0x01, + 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, +- 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, 0x03, 0x45, 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, 0x03, 0x43, +- 0x03, 0x45, 0x03, 0x41, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, +- 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x03, 0x00, +- 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x03, 0x01, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, +- 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, +- 0x03, 0x45, 0x03, 0x13, 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x13, 0x03, 0x41, +- 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, +- 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, +- 0x03, 0x45, 0x03, 0x43, 0x03, 0x01, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, +- 0x00, 0x1E, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, +- 0x03, 0x40, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x01, 0x00, 0x02, +- 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x4E, +- 0x00, 0x06, 0x00, 0x12, 0x00, 0x1C, 0x00, 0x26, 0x00, 0x30, 0x00, 0x3A, 0x00, 0x44, 0x00, 0x01, +- 0x00, 0x04, 0x0A, 0x59, 0x00, 0x02, 0x0A, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x0A, 0x5A, 0x00, 0x02, +- 0x0A, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x0A, 0x5B, 0x00, 0x02, 0x0A, 0x3C, 0x00, 0x01, 0x00, 0x04, +- 0x0A, 0x5E, 0x00, 0x02, 0x0A, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x0A, 0x33, 0x00, 0x02, 0x0A, 0x3C, +- 0x00, 0x01, 0x00, 0x04, 0x0A, 0x36, 0x00, 0x02, 0x0A, 0x3C, 0x00, 0x01, 0x00, 0x06, 0x0A, 0x16, +- 0x0A, 0x17, 0x0A, 0x1C, 0x0A, 0x2B, 0x0A, 0x32, 0x0A, 0x38, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x01, 0x00, 0x36, 0x00, 0x06, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, +- 0x00, 0x2A, 0x00, 0x30, 0x00, 0x02, 0x0A, 0x32, 0x0A, 0x3C, 0x00, 0x02, 0x0A, 0x38, 0x0A, 0x3C, +- 0x00, 0x02, 0x0A, 0x16, 0x0A, 0x3C, 0x00, 0x02, 0x0A, 0x17, 0x0A, 0x3C, 0x00, 0x02, 0x0A, 0x1C, +- 0x0A, 0x3C, 0x00, 0x02, 0x0A, 0x2B, 0x0A, 0x3C, 0x00, 0x01, 0x00, 0x06, 0x0A, 0x33, 0x0A, 0x36, +- 0x0A, 0x59, 0x0A, 0x5A, 0x0A, 0x5B, 0x0A, 0x5E, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, +- 0x00, 0x01, 0x01, 0xB6, 0x00, 0x1A, 0x00, 0x3A, 0x00, 0x54, 0x00, 0x66, 0x00, 0x70, 0x00, 0x7A, +- 0x00, 0x84, 0x00, 0x96, 0x00, 0xA0, 0x00, 0xAA, 0x00, 0xBC, 0x00, 0xC6, 0x00, 0xD8, 0x00, 0xE2, +- 0x00, 0xEC, 0x00, 0xF6, 0x01, 0x00, 0x01, 0x0A, 0x01, 0x1C, 0x01, 0x26, 0x01, 0x30, 0x01, 0x3A, +- 0x01, 0x7C, 0x01, 0x86, 0x01, 0x90, 0x01, 0x9A, 0x01, 0xA4, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, +- 0x00, 0x14, 0xFB, 0x2E, 0x00, 0x02, 0x05, 0xB7, 0xFB, 0x2F, 0x00, 0x02, 0x05, 0xB8, 0xFB, 0x30, +- 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFB, 0x31, 0x00, 0x02, 0x05, 0xBC, +- 0xFB, 0x4C, 0x00, 0x02, 0x05, 0xBF, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x32, 0x00, 0x02, 0x05, 0xBC, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x33, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x34, +- 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFB, 0x4B, 0x00, 0x02, 0x05, 0xB9, +- 0xFB, 0x35, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x36, 0x00, 0x02, 0x05, 0xBC, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x38, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0xFB, 0x1D, 0x00, 0x02, 0x05, 0xB4, 0xFB, 0x39, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, +- 0xFB, 0x3A, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFB, 0x3B, 0x00, 0x02, +- 0x05, 0xBC, 0xFB, 0x4D, 0x00, 0x02, 0x05, 0xBF, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x3C, 0x00, 0x02, +- 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x3E, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, +- 0xFB, 0x40, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x41, 0x00, 0x02, 0x05, 0xBC, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x43, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0xFB, 0x44, 0x00, 0x02, 0x05, 0xBC, 0xFB, 0x4E, 0x00, 0x02, 0x05, 0xBF, 0x00, 0x01, 0x00, 0x04, +- 0xFB, 0x46, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x47, 0x00, 0x02, 0x05, 0xBC, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x48, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x07, 0x00, 0x10, 0x00, 0x18, +- 0x00, 0x20, 0x00, 0x26, 0x00, 0x2E, 0x00, 0x34, 0x00, 0x3C, 0xFB, 0x2C, 0x00, 0x03, 0x05, 0xBC, +- 0x05, 0xC1, 0xFB, 0x2D, 0x00, 0x03, 0x05, 0xBC, 0x05, 0xC2, 0xFB, 0x49, 0x00, 0x02, 0x05, 0xBC, +- 0xFB, 0x2C, 0x00, 0x03, 0x05, 0xC1, 0x05, 0xBC, 0xFB, 0x2A, 0x00, 0x02, 0x05, 0xC1, 0xFB, 0x2D, +- 0x00, 0x03, 0x05, 0xC2, 0x05, 0xBC, 0xFB, 0x2B, 0x00, 0x02, 0x05, 0xC2, 0x00, 0x01, 0x00, 0x04, +- 0xFB, 0x4A, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x1F, 0x00, 0x02, 0x05, 0xB7, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x2C, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x2D, +- 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFB, 0x2C, 0x00, 0x02, 0x05, 0xC1, +- 0xFB, 0x2D, 0x00, 0x02, 0x05, 0xC2, 0x00, 0x01, 0x00, 0x1A, 0x05, 0xD0, 0x05, 0xD1, 0x05, 0xD2, +- 0x05, 0xD3, 0x05, 0xD4, 0x05, 0xD5, 0x05, 0xD6, 0x05, 0xD8, 0x05, 0xD9, 0x05, 0xDA, 0x05, 0xDB, +- 0x05, 0xDC, 0x05, 0xDE, 0x05, 0xE0, 0x05, 0xE1, 0x05, 0xE3, 0x05, 0xE4, 0x05, 0xE6, 0x05, 0xE7, +- 0x05, 0xE8, 0x05, 0xE9, 0x05, 0xEA, 0x05, 0xF2, 0xFB, 0x2A, 0xFB, 0x2B, 0xFB, 0x49, 0x00, 0x02, +- 0x00, 0x00, 0x00, 0x04, 0x00, 0x0E, 0x01, 0x6C, 0x01, 0x8A, 0x01, 0xAC, 0x00, 0x01, 0x01, 0x16, +- 0x00, 0x22, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, +- 0x00, 0x74, 0x00, 0x7A, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, 0x00, 0x92, 0x00, 0x98, 0x00, 0x9E, +- 0x00, 0xA4, 0x00, 0xAA, 0x00, 0xB0, 0x00, 0xB6, 0x00, 0xBC, 0x00, 0xC2, 0x00, 0xC8, 0x00, 0xCE, +- 0x00, 0xD4, 0x00, 0xDA, 0x00, 0xE0, 0x00, 0xE6, 0x00, 0xEC, 0x00, 0xF2, 0x00, 0xF8, 0x00, 0xFE, +- 0x01, 0x04, 0x01, 0x0A, 0x01, 0x10, 0x00, 0x02, 0x05, 0xD9, 0x05, 0xB4, 0x00, 0x02, 0x05, 0xF2, +- 0x05, 0xB7, 0x00, 0x02, 0x05, 0xE9, 0x05, 0xC1, 0x00, 0x02, 0x05, 0xE9, 0x05, 0xC2, 0x00, 0x02, +- 0xFB, 0x2A, 0x05, 0xBC, 0x00, 0x02, 0xFB, 0x2B, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xD0, 0x05, 0xB7, +- 0x00, 0x02, 0x05, 0xD0, 0x05, 0xB8, 0x00, 0x02, 0x05, 0xD0, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xD1, +- 0x05, 0xBC, 0x00, 0x02, 0x05, 0xD2, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xD3, 0x05, 0xBC, 0x00, 0x02, +- 0x05, 0xD4, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xD5, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xD6, 0x05, 0xBC, +- 0x00, 0x02, 0x05, 0xD8, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xD9, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xDA, +- 0x05, 0xBC, 0x00, 0x02, 0x05, 0xDB, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xDC, 0x05, 0xBC, 0x00, 0x02, +- 0x05, 0xDE, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xE0, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xE1, 0x05, 0xBC, +- 0x00, 0x02, 0x05, 0xE3, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xE4, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xE6, +- 0x05, 0xBC, 0x00, 0x02, 0x05, 0xE7, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xE8, 0x05, 0xBC, 0x00, 0x02, +- 0x05, 0xE9, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xEA, 0x05, 0xBC, 0x00, 0x02, 0x05, 0xD5, 0x05, 0xB9, +- 0x00, 0x02, 0x05, 0xD1, 0x05, 0xBF, 0x00, 0x02, 0x05, 0xDB, 0x05, 0xBF, 0x00, 0x02, 0x05, 0xE4, +- 0x05, 0xBF, 0x00, 0x01, 0x00, 0x22, 0xFB, 0x1D, 0xFB, 0x1F, 0xFB, 0x2A, 0xFB, 0x2B, 0xFB, 0x2C, +- 0xFB, 0x2D, 0xFB, 0x2E, 0xFB, 0x2F, 0xFB, 0x30, 0xFB, 0x31, 0xFB, 0x32, 0xFB, 0x33, 0xFB, 0x34, +- 0xFB, 0x35, 0xFB, 0x36, 0xFB, 0x38, 0xFB, 0x39, 0xFB, 0x3A, 0xFB, 0x3B, 0xFB, 0x3C, 0xFB, 0x3E, +- 0xFB, 0x40, 0xFB, 0x41, 0xFB, 0x43, 0xFB, 0x44, 0xFB, 0x46, 0xFB, 0x47, 0xFB, 0x48, 0xFB, 0x49, +- 0xFB, 0x4A, 0xFB, 0x4B, 0xFB, 0x4C, 0xFB, 0x4D, 0xFB, 0x4E, 0x00, 0x01, 0x00, 0x16, 0x00, 0x02, +- 0x00, 0x0A, 0x00, 0x10, 0x00, 0x02, 0xFB, 0x49, 0x05, 0xC1, 0x00, 0x02, 0xFB, 0x49, 0x05, 0xC2, +- 0x00, 0x01, 0x00, 0x02, 0xFB, 0x2C, 0xFB, 0x2D, 0x00, 0x01, 0x00, 0x1A, 0x00, 0x02, 0x00, 0x0A, +- 0x00, 0x12, 0x00, 0x03, 0x05, 0xE9, 0x05, 0xBC, 0x05, 0xC1, 0x00, 0x03, 0x05, 0xE9, 0x05, 0xBC, +- 0x05, 0xC2, 0x00, 0x01, 0x00, 0x02, 0xFB, 0x2C, 0xFB, 0x2D, 0x00, 0x01, 0x00, 0x1A, 0x00, 0x02, +- 0x00, 0x0A, 0x00, 0x12, 0x00, 0x03, 0x05, 0xE9, 0x05, 0xC1, 0x05, 0xBC, 0x00, 0x03, 0x05, 0xE9, +- 0x05, 0xC2, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x02, 0xFB, 0x2C, 0xFB, 0x2D, 0x00, 0x04, 0x00, 0x00, +- 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x01, 0x36, 0x00, 0x16, 0x00, 0x32, 0x00, 0x3C, 0x00, 0x46, +- 0x00, 0x50, 0x00, 0x5A, 0x00, 0x64, 0x00, 0x6E, 0x00, 0x78, 0x00, 0x82, 0x00, 0x8C, 0x00, 0x96, +- 0x00, 0xA0, 0x00, 0xAA, 0x00, 0xB4, 0x00, 0xBE, 0x00, 0xC8, 0x00, 0xD2, 0x00, 0xE4, 0x00, 0xF6, +- 0x01, 0x08, 0x01, 0x1A, 0x01, 0x2C, 0x00, 0x01, 0x00, 0x04, 0x30, 0x94, 0x00, 0x02, 0x30, 0x99, +- 0x00, 0x01, 0x00, 0x04, 0x30, 0x4C, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x4E, +- 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x50, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, +- 0x00, 0x04, 0x30, 0x52, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x54, 0x00, 0x02, +- 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x56, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, +- 0x30, 0x58, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x5A, 0x00, 0x02, 0x30, 0x99, +- 0x00, 0x01, 0x00, 0x04, 0x30, 0x5C, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x5E, +- 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x60, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, +- 0x00, 0x04, 0x30, 0x62, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x65, 0x00, 0x02, +- 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x67, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, +- 0x30, 0x69, 0x00, 0x02, 0x30, 0x99, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0x70, 0x00, 0x02, +- 0x30, 0x99, 0x30, 0x71, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0x73, +- 0x00, 0x02, 0x30, 0x99, 0x30, 0x74, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0x30, 0x76, 0x00, 0x02, 0x30, 0x99, 0x30, 0x77, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, +- 0x00, 0x0C, 0x30, 0x79, 0x00, 0x02, 0x30, 0x99, 0x30, 0x7A, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, +- 0x00, 0x06, 0x00, 0x0C, 0x30, 0x7C, 0x00, 0x02, 0x30, 0x99, 0x30, 0x7D, 0x00, 0x02, 0x30, 0x9A, +- 0x00, 0x01, 0x00, 0x04, 0x30, 0x9E, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x16, 0x30, 0x46, +- 0x30, 0x4B, 0x30, 0x4D, 0x30, 0x4F, 0x30, 0x51, 0x30, 0x53, 0x30, 0x55, 0x30, 0x57, 0x30, 0x59, +- 0x30, 0x5B, 0x30, 0x5D, 0x30, 0x5F, 0x30, 0x61, 0x30, 0x64, 0x30, 0x66, 0x30, 0x68, 0x30, 0x6F, +- 0x30, 0x72, 0x30, 0x75, 0x30, 0x78, 0x30, 0x7B, 0x30, 0x9D, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x01, 0x00, 0xDE, 0x00, 0x1B, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, +- 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, 0x00, 0x6C, 0x00, 0x72, 0x00, 0x78, 0x00, 0x7E, +- 0x00, 0x84, 0x00, 0x8A, 0x00, 0x90, 0x00, 0x96, 0x00, 0x9C, 0x00, 0xA2, 0x00, 0xA8, 0x00, 0xAE, +- 0x00, 0xB4, 0x00, 0xBA, 0x00, 0xC0, 0x00, 0xC6, 0x00, 0xCC, 0x00, 0xD2, 0x00, 0xD8, 0x00, 0x02, +- 0x30, 0x4B, 0x30, 0x99, 0x00, 0x02, 0x30, 0x4D, 0x30, 0x99, 0x00, 0x02, 0x30, 0x4F, 0x30, 0x99, +- 0x00, 0x02, 0x30, 0x51, 0x30, 0x99, 0x00, 0x02, 0x30, 0x53, 0x30, 0x99, 0x00, 0x02, 0x30, 0x55, +- 0x30, 0x99, 0x00, 0x02, 0x30, 0x57, 0x30, 0x99, 0x00, 0x02, 0x30, 0x59, 0x30, 0x99, 0x00, 0x02, +- 0x30, 0x5B, 0x30, 0x99, 0x00, 0x02, 0x30, 0x5D, 0x30, 0x99, 0x00, 0x02, 0x30, 0x5F, 0x30, 0x99, +- 0x00, 0x02, 0x30, 0x61, 0x30, 0x99, 0x00, 0x02, 0x30, 0x64, 0x30, 0x99, 0x00, 0x02, 0x30, 0x66, +- 0x30, 0x99, 0x00, 0x02, 0x30, 0x68, 0x30, 0x99, 0x00, 0x02, 0x30, 0x6F, 0x30, 0x99, 0x00, 0x02, +- 0x30, 0x6F, 0x30, 0x9A, 0x00, 0x02, 0x30, 0x72, 0x30, 0x99, 0x00, 0x02, 0x30, 0x72, 0x30, 0x9A, +- 0x00, 0x02, 0x30, 0x75, 0x30, 0x99, 0x00, 0x02, 0x30, 0x75, 0x30, 0x9A, 0x00, 0x02, 0x30, 0x78, +- 0x30, 0x99, 0x00, 0x02, 0x30, 0x78, 0x30, 0x9A, 0x00, 0x02, 0x30, 0x7B, 0x30, 0x99, 0x00, 0x02, +- 0x30, 0x7B, 0x30, 0x9A, 0x00, 0x02, 0x30, 0x46, 0x30, 0x99, 0x00, 0x02, 0x30, 0x9D, 0x30, 0x99, +- 0x00, 0x01, 0x00, 0x1B, 0x30, 0x4C, 0x30, 0x4E, 0x30, 0x50, 0x30, 0x52, 0x30, 0x54, 0x30, 0x56, +- 0x30, 0x58, 0x30, 0x5A, 0x30, 0x5C, 0x30, 0x5E, 0x30, 0x60, 0x30, 0x62, 0x30, 0x65, 0x30, 0x67, +- 0x30, 0x69, 0x30, 0x70, 0x30, 0x71, 0x30, 0x73, 0x30, 0x74, 0x30, 0x76, 0x30, 0x77, 0x30, 0x79, +- 0x30, 0x7A, 0x30, 0x7C, 0x30, 0x7D, 0x30, 0x94, 0x30, 0x9E, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x01, 0x00, 0x44, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x16, 0x00, 0x3A, 0x00, 0x01, +- 0x00, 0x04, 0x0C, 0xC0, 0x00, 0x02, 0x0C, 0xD5, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x12, 0x00, 0x18, +- 0x00, 0x1E, 0x0C, 0xCB, 0x00, 0x03, 0x0C, 0xC2, 0x0C, 0xD5, 0x0C, 0xCA, 0x00, 0x02, 0x0C, 0xC2, +- 0x0C, 0xC7, 0x00, 0x02, 0x0C, 0xD5, 0x0C, 0xC8, 0x00, 0x02, 0x0C, 0xD6, 0x00, 0x01, 0x00, 0x04, +- 0x0C, 0xCB, 0x00, 0x02, 0x0C, 0xD5, 0x00, 0x01, 0x00, 0x03, 0x0C, 0xBF, 0x0C, 0xC6, 0x0C, 0xCA, +- 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x46, 0x00, 0x01, 0x00, 0x2E, 0x00, 0x05, +- 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x02, 0x0C, 0xBF, 0x0C, 0xD5, +- 0x00, 0x02, 0x0C, 0xC6, 0x0C, 0xD5, 0x00, 0x02, 0x0C, 0xC6, 0x0C, 0xD6, 0x00, 0x02, 0x0C, 0xC6, +- 0x0C, 0xC2, 0x00, 0x02, 0x0C, 0xCA, 0x0C, 0xD5, 0x00, 0x01, 0x00, 0x05, 0x0C, 0xC0, 0x0C, 0xC7, +- 0x0C, 0xC8, 0x0C, 0xCA, 0x0C, 0xCB, 0x00, 0x01, 0x00, 0x10, 0x00, 0x01, 0x00, 0x08, 0x00, 0x03, +- 0x0C, 0xC6, 0x0C, 0xC2, 0x0C, 0xD5, 0x00, 0x01, 0x00, 0x01, 0x0C, 0xCB, 0x00, 0x04, 0x00, 0x00, +- 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x01, 0x66, 0x00, 0x1A, 0x00, 0x3A, 0x00, 0x44, 0x00, 0x4E, +- 0x00, 0x58, 0x00, 0x62, 0x00, 0x6C, 0x00, 0x76, 0x00, 0x80, 0x00, 0x8A, 0x00, 0x94, 0x00, 0x9E, +- 0x00, 0xA8, 0x00, 0xB2, 0x00, 0xBC, 0x00, 0xC6, 0x00, 0xD0, 0x00, 0xDA, 0x00, 0xEC, 0x00, 0xFE, +- 0x01, 0x10, 0x01, 0x22, 0x01, 0x34, 0x01, 0x3E, 0x01, 0x48, 0x01, 0x52, 0x01, 0x5C, 0x00, 0x01, +- 0x00, 0x04, 0x30, 0xF4, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xAC, 0x00, 0x02, +- 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xAE, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, +- 0x30, 0xB0, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xB2, 0x00, 0x02, 0x30, 0x99, +- 0x00, 0x01, 0x00, 0x04, 0x30, 0xB4, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xB6, +- 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xB8, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, +- 0x00, 0x04, 0x30, 0xBA, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xBC, 0x00, 0x02, +- 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xBE, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, +- 0x30, 0xC0, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xC2, 0x00, 0x02, 0x30, 0x99, +- 0x00, 0x01, 0x00, 0x04, 0x30, 0xC5, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xC7, +- 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xC9, 0x00, 0x02, 0x30, 0x99, 0x00, 0x02, +- 0x00, 0x06, 0x00, 0x0C, 0x30, 0xD0, 0x00, 0x02, 0x30, 0x99, 0x30, 0xD1, 0x00, 0x02, 0x30, 0x9A, +- 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0xD3, 0x00, 0x02, 0x30, 0x99, 0x30, 0xD4, 0x00, 0x02, +- 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0xD6, 0x00, 0x02, 0x30, 0x99, 0x30, 0xD7, +- 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0xD9, 0x00, 0x02, 0x30, 0x99, +- 0x30, 0xDA, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0xDC, 0x00, 0x02, +- 0x30, 0x99, 0x30, 0xDD, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x01, 0x00, 0x04, 0x30, 0xF7, 0x00, 0x02, +- 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xF8, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, +- 0x30, 0xF9, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xFA, 0x00, 0x02, 0x30, 0x99, +- 0x00, 0x01, 0x00, 0x04, 0x30, 0xFE, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x1A, 0x30, 0xA6, +- 0x30, 0xAB, 0x30, 0xAD, 0x30, 0xAF, 0x30, 0xB1, 0x30, 0xB3, 0x30, 0xB5, 0x30, 0xB7, 0x30, 0xB9, +- 0x30, 0xBB, 0x30, 0xBD, 0x30, 0xBF, 0x30, 0xC1, 0x30, 0xC4, 0x30, 0xC6, 0x30, 0xC8, 0x30, 0xCF, +- 0x30, 0xD2, 0x30, 0xD5, 0x30, 0xD8, 0x30, 0xDB, 0x30, 0xEF, 0x30, 0xF0, 0x30, 0xF1, 0x30, 0xF2, +- 0x30, 0xFD, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0xFE, 0x00, 0x1F, +- 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, +- 0x00, 0x74, 0x00, 0x7A, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, 0x00, 0x92, 0x00, 0x98, 0x00, 0x9E, +- 0x00, 0xA4, 0x00, 0xAA, 0x00, 0xB0, 0x00, 0xB6, 0x00, 0xBC, 0x00, 0xC2, 0x00, 0xC8, 0x00, 0xCE, +- 0x00, 0xD4, 0x00, 0xDA, 0x00, 0xE0, 0x00, 0xE6, 0x00, 0xEC, 0x00, 0xF2, 0x00, 0xF8, 0x00, 0x02, +- 0x30, 0xAB, 0x30, 0x99, 0x00, 0x02, 0x30, 0xAD, 0x30, 0x99, 0x00, 0x02, 0x30, 0xAF, 0x30, 0x99, +- 0x00, 0x02, 0x30, 0xB1, 0x30, 0x99, 0x00, 0x02, 0x30, 0xB3, 0x30, 0x99, 0x00, 0x02, 0x30, 0xB5, +- 0x30, 0x99, 0x00, 0x02, 0x30, 0xB7, 0x30, 0x99, 0x00, 0x02, 0x30, 0xB9, 0x30, 0x99, 0x00, 0x02, +- 0x30, 0xBB, 0x30, 0x99, 0x00, 0x02, 0x30, 0xBD, 0x30, 0x99, 0x00, 0x02, 0x30, 0xBF, 0x30, 0x99, +- 0x00, 0x02, 0x30, 0xC1, 0x30, 0x99, 0x00, 0x02, 0x30, 0xC4, 0x30, 0x99, 0x00, 0x02, 0x30, 0xC6, +- 0x30, 0x99, 0x00, 0x02, 0x30, 0xC8, 0x30, 0x99, 0x00, 0x02, 0x30, 0xCF, 0x30, 0x99, 0x00, 0x02, +- 0x30, 0xCF, 0x30, 0x9A, 0x00, 0x02, 0x30, 0xD2, 0x30, 0x99, 0x00, 0x02, 0x30, 0xD2, 0x30, 0x9A, +- 0x00, 0x02, 0x30, 0xD5, 0x30, 0x99, 0x00, 0x02, 0x30, 0xD5, 0x30, 0x9A, 0x00, 0x02, 0x30, 0xD8, +- 0x30, 0x99, 0x00, 0x02, 0x30, 0xD8, 0x30, 0x9A, 0x00, 0x02, 0x30, 0xDB, 0x30, 0x99, 0x00, 0x02, +- 0x30, 0xDB, 0x30, 0x9A, 0x00, 0x02, 0x30, 0xA6, 0x30, 0x99, 0x00, 0x02, 0x30, 0xEF, 0x30, 0x99, +- 0x00, 0x02, 0x30, 0xF0, 0x30, 0x99, 0x00, 0x02, 0x30, 0xF1, 0x30, 0x99, 0x00, 0x02, 0x30, 0xF2, +- 0x30, 0x99, 0x00, 0x02, 0x30, 0xFD, 0x30, 0x99, 0x00, 0x01, 0x00, 0x1F, 0x30, 0xAC, 0x30, 0xAE, +- 0x30, 0xB0, 0x30, 0xB2, 0x30, 0xB4, 0x30, 0xB6, 0x30, 0xB8, 0x30, 0xBA, 0x30, 0xBC, 0x30, 0xBE, +- 0x30, 0xC0, 0x30, 0xC2, 0x30, 0xC5, 0x30, 0xC7, 0x30, 0xC9, 0x30, 0xD0, 0x30, 0xD1, 0x30, 0xD3, +- 0x30, 0xD4, 0x30, 0xD6, 0x30, 0xD7, 0x30, 0xD9, 0x30, 0xDA, 0x30, 0xDC, 0x30, 0xDD, 0x30, 0xF4, +- 0x30, 0xF7, 0x30, 0xF8, 0x30, 0xF9, 0x30, 0xFA, 0x30, 0xFE, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x01, 0x1E, 0x9A, 0x00, 0x89, 0x01, 0x18, 0x02, 0x72, 0x02, 0x8C, 0x02, 0xE6, +- 0x03, 0x18, 0x04, 0x3E, 0x04, 0x48, 0x04, 0x8A, 0x04, 0xC4, 0x05, 0x6A, 0x05, 0x74, 0x05, 0xA6, +- 0x05, 0xF4, 0x06, 0x16, 0x06, 0x70, 0x08, 0x56, 0x08, 0x70, 0x08, 0xCE, 0x09, 0x42, 0x09, 0x7C, +- 0x0B, 0x14, 0x0B, 0x26, 0x0B, 0x68, 0x0B, 0x7A, 0x0B, 0xD4, 0x0C, 0x0E, 0x0D, 0x68, 0x0D, 0x82, +- 0x0D, 0xDC, 0x0E, 0x0E, 0x0F, 0x34, 0x0F, 0x3E, 0x0F, 0x80, 0x0F, 0xC2, 0x10, 0x60, 0x10, 0x72, +- 0x10, 0xA4, 0x10, 0xF2, 0x11, 0x14, 0x11, 0x6E, 0x13, 0x54, 0x13, 0x6E, 0x13, 0xCC, 0x14, 0x40, +- 0x14, 0x82, 0x16, 0x1A, 0x16, 0x2C, 0x16, 0x76, 0x16, 0x88, 0x16, 0xEA, 0x17, 0x24, 0x17, 0x5E, +- 0x17, 0x68, 0x17, 0x7A, 0x17, 0x94, 0x17, 0xA6, 0x17, 0xE0, 0x17, 0xF2, 0x17, 0xFC, 0x18, 0x06, +- 0x18, 0x40, 0x18, 0x6A, 0x18, 0x74, 0x18, 0x86, 0x18, 0x90, 0x18, 0x9A, 0x18, 0xCC, 0x19, 0x06, +- 0x19, 0x10, 0x19, 0x22, 0x19, 0x3C, 0x19, 0x4E, 0x19, 0x88, 0x19, 0x9A, 0x19, 0xA4, 0x19, 0xAE, +- 0x19, 0xE8, 0x1A, 0x12, 0x1A, 0x1C, 0x1A, 0x2E, 0x1A, 0x38, 0x1A, 0x42, 0x1A, 0x74, 0x1A, 0xAE, +- 0x1A, 0xE8, 0x1A, 0xF2, 0x1A, 0xFC, 0x1B, 0x1E, 0x1B, 0x40, 0x1B, 0x4A, 0x1B, 0x54, 0x1B, 0x7E, +- 0x1B, 0xA8, 0x1B, 0xB2, 0x1B, 0xBC, 0x1B, 0xC6, 0x1B, 0xD0, 0x1B, 0xEA, 0x1C, 0x04, 0x1C, 0x0E, +- 0x1C, 0x18, 0x1C, 0x22, 0x1C, 0x5C, 0x1C, 0x96, 0x1C, 0xD0, 0x1D, 0x0A, 0x1D, 0x14, 0x1D, 0x1E, +- 0x1D, 0x28, 0x1D, 0x32, 0x1D, 0x3C, 0x1D, 0x46, 0x1D, 0x50, 0x1D, 0x5A, 0x1D, 0x64, 0x1D, 0x6E, +- 0x1D, 0x78, 0x1D, 0x82, 0x1D, 0x8C, 0x1D, 0x96, 0x1D, 0xA0, 0x1D, 0xAA, 0x1D, 0xB4, 0x1D, 0xBE, +- 0x1D, 0xD0, 0x1D, 0xE2, 0x1D, 0xEC, 0x1D, 0xF6, 0x1E, 0x08, 0x1E, 0x1A, 0x1E, 0x24, 0x1E, 0x2E, +- 0x1E, 0x38, 0x1E, 0x42, 0x1E, 0x4C, 0x1E, 0x56, 0x1E, 0x88, 0x00, 0x26, 0x00, 0x4E, 0x00, 0x54, +- 0x00, 0x5A, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x7A, 0x00, 0x82, 0x00, 0x8A, 0x00, 0x92, +- 0x00, 0x98, 0x00, 0x9E, 0x00, 0xA4, 0x00, 0xAC, 0x00, 0xB4, 0x00, 0xBC, 0x00, 0xC4, 0x00, 0xCC, +- 0x00, 0xD4, 0x00, 0xDC, 0x00, 0xE2, 0x00, 0xEA, 0x00, 0xF0, 0x00, 0xF8, 0x00, 0xFE, 0x01, 0x04, +- 0x01, 0x0C, 0x01, 0x14, 0x01, 0x1A, 0x01, 0x20, 0x01, 0x26, 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, +- 0x01, 0x42, 0x01, 0x48, 0x01, 0x4E, 0x01, 0x54, 0x00, 0xC0, 0x00, 0x02, 0x03, 0x00, 0x00, 0xC1, +- 0x00, 0x02, 0x03, 0x01, 0x1E, 0xA6, 0x00, 0x03, 0x03, 0x02, 0x03, 0x00, 0x1E, 0xA4, 0x00, 0x03, +- 0x03, 0x02, 0x03, 0x01, 0x1E, 0xAA, 0x00, 0x03, 0x03, 0x02, 0x03, 0x03, 0x1E, 0xA8, 0x00, 0x03, +- 0x03, 0x02, 0x03, 0x09, 0x1E, 0xAC, 0x00, 0x03, 0x03, 0x02, 0x03, 0x23, 0x1E, 0xA6, 0x00, 0x03, +- 0x03, 0x02, 0x03, 0x40, 0x1E, 0xA4, 0x00, 0x03, 0x03, 0x02, 0x03, 0x41, 0x00, 0xC2, 0x00, 0x02, +- 0x03, 0x02, 0x00, 0xC3, 0x00, 0x02, 0x03, 0x03, 0x01, 0x00, 0x00, 0x02, 0x03, 0x04, 0x1E, 0xB0, +- 0x00, 0x03, 0x03, 0x06, 0x03, 0x00, 0x1E, 0xAE, 0x00, 0x03, 0x03, 0x06, 0x03, 0x01, 0x1E, 0xB4, +- 0x00, 0x03, 0x03, 0x06, 0x03, 0x03, 0x1E, 0xB2, 0x00, 0x03, 0x03, 0x06, 0x03, 0x09, 0x1E, 0xB6, +- 0x00, 0x03, 0x03, 0x06, 0x03, 0x23, 0x1E, 0xB0, 0x00, 0x03, 0x03, 0x06, 0x03, 0x40, 0x1E, 0xAE, +- 0x00, 0x03, 0x03, 0x06, 0x03, 0x41, 0x01, 0x02, 0x00, 0x02, 0x03, 0x06, 0x01, 0xE0, 0x00, 0x03, +- 0x03, 0x07, 0x03, 0x04, 0x02, 0x26, 0x00, 0x02, 0x03, 0x07, 0x01, 0xDE, 0x00, 0x03, 0x03, 0x08, +- 0x03, 0x04, 0x00, 0xC4, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xA2, 0x00, 0x02, 0x03, 0x09, 0x01, 0xFA, +- 0x00, 0x03, 0x03, 0x0A, 0x03, 0x01, 0x01, 0xFA, 0x00, 0x03, 0x03, 0x0A, 0x03, 0x41, 0x00, 0xC5, +- 0x00, 0x02, 0x03, 0x0A, 0x01, 0xCD, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x00, 0x00, 0x02, 0x03, 0x0F, +- 0x02, 0x02, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xAC, 0x00, 0x03, 0x03, 0x23, 0x03, 0x02, 0x1E, 0xB6, +- 0x00, 0x03, 0x03, 0x23, 0x03, 0x06, 0x1E, 0xA0, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x00, 0x00, 0x02, +- 0x03, 0x25, 0x01, 0x04, 0x00, 0x02, 0x03, 0x28, 0x00, 0xC0, 0x00, 0x02, 0x03, 0x40, 0x00, 0xC1, +- 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x1E, 0x02, 0x00, 0x02, +- 0x03, 0x07, 0x1E, 0x04, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x06, 0x00, 0x02, 0x03, 0x31, 0x00, 0x0A, +- 0x00, 0x16, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3E, 0x00, 0x46, +- 0x00, 0x4C, 0x00, 0x54, 0x1E, 0x08, 0x00, 0x03, 0x03, 0x01, 0x03, 0x27, 0x01, 0x06, 0x00, 0x02, +- 0x03, 0x01, 0x01, 0x08, 0x00, 0x02, 0x03, 0x02, 0x01, 0x0A, 0x00, 0x02, 0x03, 0x07, 0x01, 0x0C, +- 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x08, 0x00, 0x03, 0x03, 0x27, 0x03, 0x01, 0x1E, 0x08, 0x00, 0x03, +- 0x03, 0x27, 0x03, 0x41, 0x00, 0xC7, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x08, 0x00, 0x03, 0x03, 0x41, +- 0x03, 0x27, 0x01, 0x06, 0x00, 0x02, 0x03, 0x41, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, +- 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x1E, 0x0A, 0x00, 0x02, 0x03, 0x07, 0x01, 0x0E, 0x00, 0x02, +- 0x03, 0x0C, 0x1E, 0x0C, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x10, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x12, +- 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x0E, 0x00, 0x02, 0x03, 0x31, 0x00, 0x21, 0x00, 0x44, 0x00, 0x4A, +- 0x00, 0x50, 0x00, 0x58, 0x00, 0x60, 0x00, 0x68, 0x00, 0x70, 0x00, 0x78, 0x00, 0x80, 0x00, 0x88, +- 0x00, 0x8E, 0x00, 0x94, 0x00, 0x9C, 0x00, 0xA4, 0x00, 0xAC, 0x00, 0xB4, 0x00, 0xBA, 0x00, 0xC2, +- 0x00, 0xC8, 0x00, 0xCE, 0x00, 0xD4, 0x00, 0xDA, 0x00, 0xE0, 0x00, 0xE6, 0x00, 0xEC, 0x00, 0xF4, +- 0x00, 0xFA, 0x01, 0x02, 0x01, 0x08, 0x01, 0x0E, 0x01, 0x14, 0x01, 0x1A, 0x01, 0x20, 0x00, 0xC8, +- 0x00, 0x02, 0x03, 0x00, 0x00, 0xC9, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xC0, 0x00, 0x03, 0x03, 0x02, +- 0x03, 0x00, 0x1E, 0xBE, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, 0x1E, 0xC4, 0x00, 0x03, 0x03, 0x02, +- 0x03, 0x03, 0x1E, 0xC2, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, 0x1E, 0xC6, 0x00, 0x03, 0x03, 0x02, +- 0x03, 0x23, 0x1E, 0xC0, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, 0x1E, 0xBE, 0x00, 0x03, 0x03, 0x02, +- 0x03, 0x41, 0x00, 0xCA, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xBC, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x14, +- 0x00, 0x03, 0x03, 0x04, 0x03, 0x00, 0x1E, 0x16, 0x00, 0x03, 0x03, 0x04, 0x03, 0x01, 0x1E, 0x14, +- 0x00, 0x03, 0x03, 0x04, 0x03, 0x40, 0x1E, 0x16, 0x00, 0x03, 0x03, 0x04, 0x03, 0x41, 0x01, 0x12, +- 0x00, 0x02, 0x03, 0x04, 0x1E, 0x1C, 0x00, 0x03, 0x03, 0x06, 0x03, 0x27, 0x01, 0x14, 0x00, 0x02, +- 0x03, 0x06, 0x01, 0x16, 0x00, 0x02, 0x03, 0x07, 0x00, 0xCB, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xBA, +- 0x00, 0x02, 0x03, 0x09, 0x01, 0x1A, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x04, 0x00, 0x02, 0x03, 0x0F, +- 0x02, 0x06, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xC6, 0x00, 0x03, 0x03, 0x23, 0x03, 0x02, 0x1E, 0xB8, +- 0x00, 0x02, 0x03, 0x23, 0x1E, 0x1C, 0x00, 0x03, 0x03, 0x27, 0x03, 0x06, 0x02, 0x28, 0x00, 0x02, +- 0x03, 0x27, 0x01, 0x18, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x18, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x1A, +- 0x00, 0x02, 0x03, 0x30, 0x00, 0xC8, 0x00, 0x02, 0x03, 0x40, 0x00, 0xC9, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x01, 0x00, 0x04, 0x1E, 0x1E, 0x00, 0x02, 0x03, 0x07, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, +- 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x01, 0xF4, 0x00, 0x02, +- 0x03, 0x01, 0x01, 0x1C, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x20, 0x00, 0x02, 0x03, 0x04, 0x01, 0x1E, +- 0x00, 0x02, 0x03, 0x06, 0x01, 0x20, 0x00, 0x02, 0x03, 0x07, 0x01, 0xE6, 0x00, 0x02, 0x03, 0x0C, +- 0x01, 0x22, 0x00, 0x02, 0x03, 0x27, 0x01, 0xF4, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, +- 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x01, 0x24, 0x00, 0x02, +- 0x03, 0x02, 0x1E, 0x22, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x26, 0x00, 0x02, 0x03, 0x08, 0x02, 0x1E, +- 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x24, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x28, 0x00, 0x02, 0x03, 0x27, +- 0x1E, 0x2A, 0x00, 0x02, 0x03, 0x2E, 0x00, 0x14, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, +- 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5C, 0x00, 0x64, 0x00, 0x6A, 0x00, 0x70, +- 0x00, 0x76, 0x00, 0x7C, 0x00, 0x82, 0x00, 0x88, 0x00, 0x8E, 0x00, 0x94, 0x00, 0x9A, 0x00, 0xA0, +- 0x00, 0xCC, 0x00, 0x02, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x02, 0x03, 0x01, 0x00, 0xCE, 0x00, 0x02, +- 0x03, 0x02, 0x01, 0x28, 0x00, 0x02, 0x03, 0x03, 0x01, 0x2A, 0x00, 0x02, 0x03, 0x04, 0x01, 0x2C, +- 0x00, 0x02, 0x03, 0x06, 0x01, 0x30, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x2E, 0x00, 0x03, 0x03, 0x08, +- 0x03, 0x01, 0x1E, 0x2E, 0x00, 0x03, 0x03, 0x08, 0x03, 0x41, 0x00, 0xCF, 0x00, 0x02, 0x03, 0x08, +- 0x1E, 0xC8, 0x00, 0x02, 0x03, 0x09, 0x01, 0xCF, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x08, 0x00, 0x02, +- 0x03, 0x0F, 0x02, 0x0A, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xCA, 0x00, 0x02, 0x03, 0x23, 0x01, 0x2E, +- 0x00, 0x02, 0x03, 0x28, 0x1E, 0x2C, 0x00, 0x02, 0x03, 0x30, 0x00, 0xCC, 0x00, 0x02, 0x03, 0x40, +- 0x00, 0xCD, 0x00, 0x02, 0x03, 0x41, 0x1E, 0x2E, 0x00, 0x02, 0x03, 0x44, 0x00, 0x01, 0x00, 0x04, +- 0x01, 0x34, 0x00, 0x02, 0x03, 0x02, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, +- 0x00, 0x26, 0x00, 0x2C, 0x1E, 0x30, 0x00, 0x02, 0x03, 0x01, 0x01, 0xE8, 0x00, 0x02, 0x03, 0x0C, +- 0x1E, 0x32, 0x00, 0x02, 0x03, 0x23, 0x01, 0x36, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x34, 0x00, 0x02, +- 0x03, 0x31, 0x1E, 0x30, 0x00, 0x02, 0x03, 0x41, 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x22, +- 0x00, 0x28, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x01, 0x39, 0x00, 0x02, +- 0x03, 0x01, 0x1E, 0x38, 0x00, 0x03, 0x03, 0x04, 0x03, 0x23, 0x01, 0x3D, 0x00, 0x02, 0x03, 0x0C, +- 0x1E, 0x38, 0x00, 0x03, 0x03, 0x23, 0x03, 0x04, 0x1E, 0x36, 0x00, 0x02, 0x03, 0x23, 0x01, 0x3B, +- 0x00, 0x02, 0x03, 0x27, 0x1E, 0x3C, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x3A, 0x00, 0x02, 0x03, 0x31, +- 0x01, 0x39, 0x00, 0x02, 0x03, 0x41, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, +- 0x1E, 0x3E, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x40, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x42, 0x00, 0x02, +- 0x03, 0x23, 0x1E, 0x3E, 0x00, 0x02, 0x03, 0x41, 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, +- 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, +- 0x01, 0xF8, 0x00, 0x02, 0x03, 0x00, 0x01, 0x43, 0x00, 0x02, 0x03, 0x01, 0x00, 0xD1, 0x00, 0x02, +- 0x03, 0x03, 0x1E, 0x44, 0x00, 0x02, 0x03, 0x07, 0x01, 0x47, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x46, +- 0x00, 0x02, 0x03, 0x23, 0x01, 0x45, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x4A, 0x00, 0x02, 0x03, 0x2D, +- 0x1E, 0x48, 0x00, 0x02, 0x03, 0x31, 0x01, 0xF8, 0x00, 0x02, 0x03, 0x40, 0x01, 0x43, 0x00, 0x02, +- 0x03, 0x41, 0x00, 0x34, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x78, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8E, +- 0x00, 0x96, 0x00, 0x9E, 0x00, 0xA6, 0x00, 0xAE, 0x00, 0xB6, 0x00, 0xBE, 0x00, 0xC4, 0x00, 0xCC, +- 0x00, 0xD4, 0x00, 0xDC, 0x00, 0xE4, 0x00, 0xEC, 0x00, 0xF2, 0x00, 0xFA, 0x01, 0x02, 0x01, 0x0A, +- 0x01, 0x12, 0x01, 0x1A, 0x01, 0x20, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x42, +- 0x01, 0x4A, 0x01, 0x50, 0x01, 0x56, 0x01, 0x5C, 0x01, 0x62, 0x01, 0x68, 0x01, 0x70, 0x01, 0x78, +- 0x01, 0x80, 0x01, 0x88, 0x01, 0x90, 0x01, 0x98, 0x01, 0xA0, 0x01, 0xA6, 0x01, 0xAE, 0x01, 0xB6, +- 0x01, 0xBC, 0x01, 0xC4, 0x01, 0xCA, 0x01, 0xD2, 0x01, 0xD8, 0x01, 0xE0, 0x1E, 0xDC, 0x00, 0x03, +- 0x03, 0x00, 0x03, 0x1B, 0x00, 0xD2, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xDA, 0x00, 0x03, 0x03, 0x01, +- 0x03, 0x1B, 0x00, 0xD3, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xD2, 0x00, 0x03, 0x03, 0x02, 0x03, 0x00, +- 0x1E, 0xD0, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, 0x1E, 0xD6, 0x00, 0x03, 0x03, 0x02, 0x03, 0x03, +- 0x1E, 0xD4, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, 0x1E, 0xD8, 0x00, 0x03, 0x03, 0x02, 0x03, 0x23, +- 0x1E, 0xD2, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, 0x1E, 0xD0, 0x00, 0x03, 0x03, 0x02, 0x03, 0x41, +- 0x00, 0xD4, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x4C, 0x00, 0x03, 0x03, 0x03, 0x03, 0x01, 0x02, 0x2C, +- 0x00, 0x03, 0x03, 0x03, 0x03, 0x04, 0x1E, 0x4E, 0x00, 0x03, 0x03, 0x03, 0x03, 0x08, 0x1E, 0xE0, +- 0x00, 0x03, 0x03, 0x03, 0x03, 0x1B, 0x1E, 0x4C, 0x00, 0x03, 0x03, 0x03, 0x03, 0x41, 0x00, 0xD5, +- 0x00, 0x02, 0x03, 0x03, 0x1E, 0x50, 0x00, 0x03, 0x03, 0x04, 0x03, 0x00, 0x1E, 0x52, 0x00, 0x03, +- 0x03, 0x04, 0x03, 0x01, 0x01, 0xEC, 0x00, 0x03, 0x03, 0x04, 0x03, 0x28, 0x1E, 0x50, 0x00, 0x03, +- 0x03, 0x04, 0x03, 0x40, 0x1E, 0x52, 0x00, 0x03, 0x03, 0x04, 0x03, 0x41, 0x01, 0x4C, 0x00, 0x02, +- 0x03, 0x04, 0x01, 0x4E, 0x00, 0x02, 0x03, 0x06, 0x02, 0x30, 0x00, 0x03, 0x03, 0x07, 0x03, 0x04, +- 0x02, 0x2E, 0x00, 0x02, 0x03, 0x07, 0x02, 0x2A, 0x00, 0x03, 0x03, 0x08, 0x03, 0x04, 0x00, 0xD6, +- 0x00, 0x02, 0x03, 0x08, 0x1E, 0xDE, 0x00, 0x03, 0x03, 0x09, 0x03, 0x1B, 0x1E, 0xCE, 0x00, 0x02, +- 0x03, 0x09, 0x01, 0x50, 0x00, 0x02, 0x03, 0x0B, 0x01, 0xD1, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x0C, +- 0x00, 0x02, 0x03, 0x0F, 0x02, 0x0E, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xDC, 0x00, 0x03, 0x03, 0x1B, +- 0x03, 0x00, 0x1E, 0xDA, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x01, 0x1E, 0xE0, 0x00, 0x03, 0x03, 0x1B, +- 0x03, 0x03, 0x1E, 0xDE, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x09, 0x1E, 0xE2, 0x00, 0x03, 0x03, 0x1B, +- 0x03, 0x23, 0x1E, 0xDC, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x40, 0x1E, 0xDA, 0x00, 0x03, 0x03, 0x1B, +- 0x03, 0x41, 0x01, 0xA0, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0xD8, 0x00, 0x03, 0x03, 0x23, 0x03, 0x02, +- 0x1E, 0xE2, 0x00, 0x03, 0x03, 0x23, 0x03, 0x1B, 0x1E, 0xCC, 0x00, 0x02, 0x03, 0x23, 0x01, 0xEC, +- 0x00, 0x03, 0x03, 0x28, 0x03, 0x04, 0x01, 0xEA, 0x00, 0x02, 0x03, 0x28, 0x1E, 0xDC, 0x00, 0x03, +- 0x03, 0x40, 0x03, 0x1B, 0x00, 0xD2, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xDA, 0x00, 0x03, 0x03, 0x41, +- 0x03, 0x1B, 0x00, 0xD3, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, +- 0x1E, 0x54, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x56, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x54, 0x00, 0x02, +- 0x03, 0x41, 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, +- 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x01, 0x54, 0x00, 0x02, 0x03, 0x01, +- 0x1E, 0x5C, 0x00, 0x03, 0x03, 0x04, 0x03, 0x23, 0x1E, 0x58, 0x00, 0x02, 0x03, 0x07, 0x01, 0x58, +- 0x00, 0x02, 0x03, 0x0C, 0x02, 0x10, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x12, 0x00, 0x02, 0x03, 0x11, +- 0x1E, 0x5C, 0x00, 0x03, 0x03, 0x23, 0x03, 0x04, 0x1E, 0x5A, 0x00, 0x02, 0x03, 0x23, 0x01, 0x56, +- 0x00, 0x02, 0x03, 0x27, 0x1E, 0x5E, 0x00, 0x02, 0x03, 0x31, 0x01, 0x54, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x0D, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, +- 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, 0x00, 0x6E, 0x1E, 0x64, 0x00, 0x03, +- 0x03, 0x01, 0x03, 0x07, 0x01, 0x5A, 0x00, 0x02, 0x03, 0x01, 0x01, 0x5C, 0x00, 0x02, 0x03, 0x02, +- 0x1E, 0x68, 0x00, 0x03, 0x03, 0x07, 0x03, 0x23, 0x1E, 0x60, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x66, +- 0x00, 0x03, 0x03, 0x0C, 0x03, 0x07, 0x01, 0x60, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x68, 0x00, 0x03, +- 0x03, 0x23, 0x03, 0x07, 0x1E, 0x62, 0x00, 0x02, 0x03, 0x23, 0x02, 0x18, 0x00, 0x02, 0x03, 0x26, +- 0x01, 0x5E, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x64, 0x00, 0x03, 0x03, 0x41, 0x03, 0x07, 0x01, 0x5A, +- 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, +- 0x00, 0x2E, 0x00, 0x34, 0x1E, 0x6A, 0x00, 0x02, 0x03, 0x07, 0x01, 0x64, 0x00, 0x02, 0x03, 0x0C, +- 0x1E, 0x6C, 0x00, 0x02, 0x03, 0x23, 0x02, 0x1A, 0x00, 0x02, 0x03, 0x26, 0x01, 0x62, 0x00, 0x02, +- 0x03, 0x27, 0x1E, 0x70, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x6E, 0x00, 0x02, 0x03, 0x31, 0x00, 0x2D, +- 0x00, 0x5C, 0x00, 0x64, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x78, 0x00, 0x7E, 0x00, 0x86, 0x00, 0x8E, +- 0x00, 0x96, 0x00, 0x9C, 0x00, 0xA4, 0x00, 0xAA, 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xC8, +- 0x00, 0xD0, 0x00, 0xD8, 0x00, 0xE0, 0x00, 0xE6, 0x00, 0xEE, 0x00, 0xF4, 0x00, 0xFA, 0x01, 0x00, +- 0x01, 0x06, 0x01, 0x0C, 0x01, 0x12, 0x01, 0x1A, 0x01, 0x22, 0x01, 0x2A, 0x01, 0x32, 0x01, 0x3A, +- 0x01, 0x42, 0x01, 0x4A, 0x01, 0x50, 0x01, 0x58, 0x01, 0x5E, 0x01, 0x64, 0x01, 0x6A, 0x01, 0x70, +- 0x01, 0x76, 0x01, 0x7E, 0x01, 0x84, 0x01, 0x8C, 0x01, 0x92, 0x1E, 0xEA, 0x00, 0x03, 0x03, 0x00, +- 0x03, 0x1B, 0x00, 0xD9, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xE8, 0x00, 0x03, 0x03, 0x01, 0x03, 0x1B, +- 0x00, 0xDA, 0x00, 0x02, 0x03, 0x01, 0x00, 0xDB, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x78, 0x00, 0x03, +- 0x03, 0x03, 0x03, 0x01, 0x1E, 0xEE, 0x00, 0x03, 0x03, 0x03, 0x03, 0x1B, 0x1E, 0x78, 0x00, 0x03, +- 0x03, 0x03, 0x03, 0x41, 0x01, 0x68, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x7A, 0x00, 0x03, 0x03, 0x04, +- 0x03, 0x08, 0x01, 0x6A, 0x00, 0x02, 0x03, 0x04, 0x01, 0x6C, 0x00, 0x02, 0x03, 0x06, 0x01, 0xDB, +- 0x00, 0x03, 0x03, 0x08, 0x03, 0x00, 0x01, 0xD7, 0x00, 0x03, 0x03, 0x08, 0x03, 0x01, 0x01, 0xD5, +- 0x00, 0x03, 0x03, 0x08, 0x03, 0x04, 0x01, 0xD9, 0x00, 0x03, 0x03, 0x08, 0x03, 0x0C, 0x01, 0xDB, +- 0x00, 0x03, 0x03, 0x08, 0x03, 0x40, 0x01, 0xD7, 0x00, 0x03, 0x03, 0x08, 0x03, 0x41, 0x00, 0xDC, +- 0x00, 0x02, 0x03, 0x08, 0x1E, 0xEC, 0x00, 0x03, 0x03, 0x09, 0x03, 0x1B, 0x1E, 0xE6, 0x00, 0x02, +- 0x03, 0x09, 0x01, 0x6E, 0x00, 0x02, 0x03, 0x0A, 0x01, 0x70, 0x00, 0x02, 0x03, 0x0B, 0x01, 0xD3, +- 0x00, 0x02, 0x03, 0x0C, 0x02, 0x14, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x16, 0x00, 0x02, 0x03, 0x11, +- 0x1E, 0xEA, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x00, 0x1E, 0xE8, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x01, +- 0x1E, 0xEE, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x03, 0x1E, 0xEC, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x09, +- 0x1E, 0xF0, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x23, 0x1E, 0xEA, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x40, +- 0x1E, 0xE8, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x41, 0x01, 0xAF, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0xF0, +- 0x00, 0x03, 0x03, 0x23, 0x03, 0x1B, 0x1E, 0xE4, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x72, 0x00, 0x02, +- 0x03, 0x24, 0x01, 0x72, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x76, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x74, +- 0x00, 0x02, 0x03, 0x30, 0x1E, 0xEA, 0x00, 0x03, 0x03, 0x40, 0x03, 0x1B, 0x00, 0xD9, 0x00, 0x02, +- 0x03, 0x40, 0x1E, 0xE8, 0x00, 0x03, 0x03, 0x41, 0x03, 0x1B, 0x00, 0xDA, 0x00, 0x02, 0x03, 0x41, +- 0x01, 0xD7, 0x00, 0x02, 0x03, 0x44, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x7C, 0x00, 0x02, +- 0x03, 0x03, 0x1E, 0x7E, 0x00, 0x02, 0x03, 0x23, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, +- 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x1E, 0x80, 0x00, 0x02, 0x03, 0x00, +- 0x1E, 0x82, 0x00, 0x02, 0x03, 0x01, 0x01, 0x74, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x86, 0x00, 0x02, +- 0x03, 0x07, 0x1E, 0x84, 0x00, 0x02, 0x03, 0x08, 0x1E, 0x88, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x80, +- 0x00, 0x02, 0x03, 0x40, 0x1E, 0x82, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0x1E, 0x8A, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x8C, 0x00, 0x02, 0x03, 0x08, 0x00, 0x0B, 0x00, 0x18, +- 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, +- 0x00, 0x4E, 0x00, 0x54, 0x1E, 0xF2, 0x00, 0x02, 0x03, 0x00, 0x00, 0xDD, 0x00, 0x02, 0x03, 0x01, +- 0x01, 0x76, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xF8, 0x00, 0x02, 0x03, 0x03, 0x02, 0x32, 0x00, 0x02, +- 0x03, 0x04, 0x1E, 0x8E, 0x00, 0x02, 0x03, 0x07, 0x01, 0x78, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xF6, +- 0x00, 0x02, 0x03, 0x09, 0x1E, 0xF4, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xF2, 0x00, 0x02, 0x03, 0x40, +- 0x00, 0xDD, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, +- 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x01, 0x79, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x90, 0x00, 0x02, +- 0x03, 0x02, 0x01, 0x7B, 0x00, 0x02, 0x03, 0x07, 0x01, 0x7D, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x92, +- 0x00, 0x02, 0x03, 0x23, 0x1E, 0x94, 0x00, 0x02, 0x03, 0x31, 0x01, 0x79, 0x00, 0x02, 0x03, 0x41, ++ 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x03, 0x00, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, ++ 0x03, 0x43, 0x03, 0x01, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, 0x1F, 0xAC, 0x00, 0x01, 0x00, 0x1E, ++ 0x00, 0x02, 0x00, 0x0A, 0x00, 0x14, 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x03, 0x40, ++ 0x00, 0x04, 0x21, 0x26, 0x03, 0x45, 0x03, 0x43, 0x03, 0x41, 0x00, 0x01, 0x00, 0x02, 0x1F, 0xAA, ++ 0x1F, 0xAC, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x01, 0x36, 0x00, 0x16, ++ 0x00, 0x32, 0x00, 0x3C, 0x00, 0x46, 0x00, 0x50, 0x00, 0x5A, 0x00, 0x64, 0x00, 0x6E, 0x00, 0x78, ++ 0x00, 0x82, 0x00, 0x8C, 0x00, 0x96, 0x00, 0xA0, 0x00, 0xAA, 0x00, 0xB4, 0x00, 0xBE, 0x00, 0xC8, ++ 0x00, 0xD2, 0x00, 0xE4, 0x00, 0xF6, 0x01, 0x08, 0x01, 0x1A, 0x01, 0x2C, 0x00, 0x01, 0x00, 0x04, ++ 0x30, 0x94, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x4C, 0x00, 0x02, 0x30, 0x99, ++ 0x00, 0x01, 0x00, 0x04, 0x30, 0x4E, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x50, ++ 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x52, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, ++ 0x00, 0x04, 0x30, 0x54, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x56, 0x00, 0x02, ++ 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x58, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, ++ 0x30, 0x5A, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x5C, 0x00, 0x02, 0x30, 0x99, ++ 0x00, 0x01, 0x00, 0x04, 0x30, 0x5E, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x60, ++ 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x62, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, ++ 0x00, 0x04, 0x30, 0x65, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x67, 0x00, 0x02, ++ 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0x69, 0x00, 0x02, 0x30, 0x99, 0x00, 0x02, 0x00, 0x06, ++ 0x00, 0x0C, 0x30, 0x70, 0x00, 0x02, 0x30, 0x99, 0x30, 0x71, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, ++ 0x00, 0x06, 0x00, 0x0C, 0x30, 0x73, 0x00, 0x02, 0x30, 0x99, 0x30, 0x74, 0x00, 0x02, 0x30, 0x9A, ++ 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0x76, 0x00, 0x02, 0x30, 0x99, 0x30, 0x77, 0x00, 0x02, ++ 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0x79, 0x00, 0x02, 0x30, 0x99, 0x30, 0x7A, ++ 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0x7C, 0x00, 0x02, 0x30, 0x99, ++ 0x30, 0x7D, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x01, 0x00, 0x04, 0x30, 0x9E, 0x00, 0x02, 0x30, 0x99, ++ 0x00, 0x01, 0x00, 0x16, 0x30, 0x46, 0x30, 0x4B, 0x30, 0x4D, 0x30, 0x4F, 0x30, 0x51, 0x30, 0x53, ++ 0x30, 0x55, 0x30, 0x57, 0x30, 0x59, 0x30, 0x5B, 0x30, 0x5D, 0x30, 0x5F, 0x30, 0x61, 0x30, 0x64, ++ 0x30, 0x66, 0x30, 0x68, 0x30, 0x6F, 0x30, 0x72, 0x30, 0x75, 0x30, 0x78, 0x30, 0x7B, 0x30, 0x9D, ++ 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0xDE, 0x00, 0x1B, 0x00, 0x3C, ++ 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, 0x00, 0x6C, ++ 0x00, 0x72, 0x00, 0x78, 0x00, 0x7E, 0x00, 0x84, 0x00, 0x8A, 0x00, 0x90, 0x00, 0x96, 0x00, 0x9C, ++ 0x00, 0xA2, 0x00, 0xA8, 0x00, 0xAE, 0x00, 0xB4, 0x00, 0xBA, 0x00, 0xC0, 0x00, 0xC6, 0x00, 0xCC, ++ 0x00, 0xD2, 0x00, 0xD8, 0x00, 0x02, 0x30, 0x4B, 0x30, 0x99, 0x00, 0x02, 0x30, 0x4D, 0x30, 0x99, ++ 0x00, 0x02, 0x30, 0x4F, 0x30, 0x99, 0x00, 0x02, 0x30, 0x51, 0x30, 0x99, 0x00, 0x02, 0x30, 0x53, ++ 0x30, 0x99, 0x00, 0x02, 0x30, 0x55, 0x30, 0x99, 0x00, 0x02, 0x30, 0x57, 0x30, 0x99, 0x00, 0x02, ++ 0x30, 0x59, 0x30, 0x99, 0x00, 0x02, 0x30, 0x5B, 0x30, 0x99, 0x00, 0x02, 0x30, 0x5D, 0x30, 0x99, ++ 0x00, 0x02, 0x30, 0x5F, 0x30, 0x99, 0x00, 0x02, 0x30, 0x61, 0x30, 0x99, 0x00, 0x02, 0x30, 0x64, ++ 0x30, 0x99, 0x00, 0x02, 0x30, 0x66, 0x30, 0x99, 0x00, 0x02, 0x30, 0x68, 0x30, 0x99, 0x00, 0x02, ++ 0x30, 0x6F, 0x30, 0x99, 0x00, 0x02, 0x30, 0x6F, 0x30, 0x9A, 0x00, 0x02, 0x30, 0x72, 0x30, 0x99, ++ 0x00, 0x02, 0x30, 0x72, 0x30, 0x9A, 0x00, 0x02, 0x30, 0x75, 0x30, 0x99, 0x00, 0x02, 0x30, 0x75, ++ 0x30, 0x9A, 0x00, 0x02, 0x30, 0x78, 0x30, 0x99, 0x00, 0x02, 0x30, 0x78, 0x30, 0x9A, 0x00, 0x02, ++ 0x30, 0x7B, 0x30, 0x99, 0x00, 0x02, 0x30, 0x7B, 0x30, 0x9A, 0x00, 0x02, 0x30, 0x46, 0x30, 0x99, ++ 0x00, 0x02, 0x30, 0x9D, 0x30, 0x99, 0x00, 0x01, 0x00, 0x1B, 0x30, 0x4C, 0x30, 0x4E, 0x30, 0x50, ++ 0x30, 0x52, 0x30, 0x54, 0x30, 0x56, 0x30, 0x58, 0x30, 0x5A, 0x30, 0x5C, 0x30, 0x5E, 0x30, 0x60, ++ 0x30, 0x62, 0x30, 0x65, 0x30, 0x67, 0x30, 0x69, 0x30, 0x70, 0x30, 0x71, 0x30, 0x73, 0x30, 0x74, ++ 0x30, 0x76, 0x30, 0x77, 0x30, 0x79, 0x30, 0x7A, 0x30, 0x7C, 0x30, 0x7D, 0x30, 0x94, 0x30, 0x9E, ++ 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x44, 0x00, 0x03, 0x00, 0x0C, ++ 0x00, 0x16, 0x00, 0x3A, 0x00, 0x01, 0x00, 0x04, 0x0C, 0xC0, 0x00, 0x02, 0x0C, 0xD5, 0x00, 0x04, ++ 0x00, 0x0A, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x0C, 0xCB, 0x00, 0x03, 0x0C, 0xC2, 0x0C, 0xD5, ++ 0x0C, 0xCA, 0x00, 0x02, 0x0C, 0xC2, 0x0C, 0xC7, 0x00, 0x02, 0x0C, 0xD5, 0x0C, 0xC8, 0x00, 0x02, ++ 0x0C, 0xD6, 0x00, 0x01, 0x00, 0x04, 0x0C, 0xCB, 0x00, 0x02, 0x0C, 0xD5, 0x00, 0x01, 0x00, 0x03, ++ 0x0C, 0xBF, 0x0C, 0xC6, 0x0C, 0xCA, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x46, ++ 0x00, 0x01, 0x00, 0x2E, 0x00, 0x05, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, ++ 0x00, 0x02, 0x0C, 0xBF, 0x0C, 0xD5, 0x00, 0x02, 0x0C, 0xC6, 0x0C, 0xD5, 0x00, 0x02, 0x0C, 0xC6, ++ 0x0C, 0xD6, 0x00, 0x02, 0x0C, 0xC6, 0x0C, 0xC2, 0x00, 0x02, 0x0C, 0xCA, 0x0C, 0xD5, 0x00, 0x01, ++ 0x00, 0x05, 0x0C, 0xC0, 0x0C, 0xC7, 0x0C, 0xC8, 0x0C, 0xCA, 0x0C, 0xCB, 0x00, 0x01, 0x00, 0x10, ++ 0x00, 0x01, 0x00, 0x08, 0x00, 0x03, 0x0C, 0xC6, 0x0C, 0xC2, 0x0C, 0xD5, 0x00, 0x01, 0x00, 0x01, ++ 0x0C, 0xCB, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x01, 0x66, 0x00, 0x1A, ++ 0x00, 0x3A, 0x00, 0x44, 0x00, 0x4E, 0x00, 0x58, 0x00, 0x62, 0x00, 0x6C, 0x00, 0x76, 0x00, 0x80, ++ 0x00, 0x8A, 0x00, 0x94, 0x00, 0x9E, 0x00, 0xA8, 0x00, 0xB2, 0x00, 0xBC, 0x00, 0xC6, 0x00, 0xD0, ++ 0x00, 0xDA, 0x00, 0xEC, 0x00, 0xFE, 0x01, 0x10, 0x01, 0x22, 0x01, 0x34, 0x01, 0x3E, 0x01, 0x48, ++ 0x01, 0x52, 0x01, 0x5C, 0x00, 0x01, 0x00, 0x04, 0x30, 0xF4, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, ++ 0x00, 0x04, 0x30, 0xAC, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xAE, 0x00, 0x02, ++ 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xB0, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, ++ 0x30, 0xB2, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xB4, 0x00, 0x02, 0x30, 0x99, ++ 0x00, 0x01, 0x00, 0x04, 0x30, 0xB6, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xB8, ++ 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xBA, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, ++ 0x00, 0x04, 0x30, 0xBC, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xBE, 0x00, 0x02, ++ 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xC0, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, ++ 0x30, 0xC2, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xC5, 0x00, 0x02, 0x30, 0x99, ++ 0x00, 0x01, 0x00, 0x04, 0x30, 0xC7, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xC9, ++ 0x00, 0x02, 0x30, 0x99, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0xD0, 0x00, 0x02, 0x30, 0x99, ++ 0x30, 0xD1, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0xD3, 0x00, 0x02, ++ 0x30, 0x99, 0x30, 0xD4, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x30, 0xD6, ++ 0x00, 0x02, 0x30, 0x99, 0x30, 0xD7, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, ++ 0x30, 0xD9, 0x00, 0x02, 0x30, 0x99, 0x30, 0xDA, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x02, 0x00, 0x06, ++ 0x00, 0x0C, 0x30, 0xDC, 0x00, 0x02, 0x30, 0x99, 0x30, 0xDD, 0x00, 0x02, 0x30, 0x9A, 0x00, 0x01, ++ 0x00, 0x04, 0x30, 0xF7, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xF8, 0x00, 0x02, ++ 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xF9, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, ++ 0x30, 0xFA, 0x00, 0x02, 0x30, 0x99, 0x00, 0x01, 0x00, 0x04, 0x30, 0xFE, 0x00, 0x02, 0x30, 0x99, ++ 0x00, 0x01, 0x00, 0x1A, 0x30, 0xA6, 0x30, 0xAB, 0x30, 0xAD, 0x30, 0xAF, 0x30, 0xB1, 0x30, 0xB3, ++ 0x30, 0xB5, 0x30, 0xB7, 0x30, 0xB9, 0x30, 0xBB, 0x30, 0xBD, 0x30, 0xBF, 0x30, 0xC1, 0x30, 0xC4, ++ 0x30, 0xC6, 0x30, 0xC8, 0x30, 0xCF, 0x30, 0xD2, 0x30, 0xD5, 0x30, 0xD8, 0x30, 0xDB, 0x30, 0xEF, ++ 0x30, 0xF0, 0x30, 0xF1, 0x30, 0xF2, 0x30, 0xFD, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, ++ 0x00, 0x01, 0x00, 0xFE, 0x00, 0x1F, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, 0x00, 0x5C, ++ 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x7A, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, ++ 0x00, 0x92, 0x00, 0x98, 0x00, 0x9E, 0x00, 0xA4, 0x00, 0xAA, 0x00, 0xB0, 0x00, 0xB6, 0x00, 0xBC, ++ 0x00, 0xC2, 0x00, 0xC8, 0x00, 0xCE, 0x00, 0xD4, 0x00, 0xDA, 0x00, 0xE0, 0x00, 0xE6, 0x00, 0xEC, ++ 0x00, 0xF2, 0x00, 0xF8, 0x00, 0x02, 0x30, 0xAB, 0x30, 0x99, 0x00, 0x02, 0x30, 0xAD, 0x30, 0x99, ++ 0x00, 0x02, 0x30, 0xAF, 0x30, 0x99, 0x00, 0x02, 0x30, 0xB1, 0x30, 0x99, 0x00, 0x02, 0x30, 0xB3, ++ 0x30, 0x99, 0x00, 0x02, 0x30, 0xB5, 0x30, 0x99, 0x00, 0x02, 0x30, 0xB7, 0x30, 0x99, 0x00, 0x02, ++ 0x30, 0xB9, 0x30, 0x99, 0x00, 0x02, 0x30, 0xBB, 0x30, 0x99, 0x00, 0x02, 0x30, 0xBD, 0x30, 0x99, ++ 0x00, 0x02, 0x30, 0xBF, 0x30, 0x99, 0x00, 0x02, 0x30, 0xC1, 0x30, 0x99, 0x00, 0x02, 0x30, 0xC4, ++ 0x30, 0x99, 0x00, 0x02, 0x30, 0xC6, 0x30, 0x99, 0x00, 0x02, 0x30, 0xC8, 0x30, 0x99, 0x00, 0x02, ++ 0x30, 0xCF, 0x30, 0x99, 0x00, 0x02, 0x30, 0xCF, 0x30, 0x9A, 0x00, 0x02, 0x30, 0xD2, 0x30, 0x99, ++ 0x00, 0x02, 0x30, 0xD2, 0x30, 0x9A, 0x00, 0x02, 0x30, 0xD5, 0x30, 0x99, 0x00, 0x02, 0x30, 0xD5, ++ 0x30, 0x9A, 0x00, 0x02, 0x30, 0xD8, 0x30, 0x99, 0x00, 0x02, 0x30, 0xD8, 0x30, 0x9A, 0x00, 0x02, ++ 0x30, 0xDB, 0x30, 0x99, 0x00, 0x02, 0x30, 0xDB, 0x30, 0x9A, 0x00, 0x02, 0x30, 0xA6, 0x30, 0x99, ++ 0x00, 0x02, 0x30, 0xEF, 0x30, 0x99, 0x00, 0x02, 0x30, 0xF0, 0x30, 0x99, 0x00, 0x02, 0x30, 0xF1, ++ 0x30, 0x99, 0x00, 0x02, 0x30, 0xF2, 0x30, 0x99, 0x00, 0x02, 0x30, 0xFD, 0x30, 0x99, 0x00, 0x01, ++ 0x00, 0x1F, 0x30, 0xAC, 0x30, 0xAE, 0x30, 0xB0, 0x30, 0xB2, 0x30, 0xB4, 0x30, 0xB6, 0x30, 0xB8, ++ 0x30, 0xBA, 0x30, 0xBC, 0x30, 0xBE, 0x30, 0xC0, 0x30, 0xC2, 0x30, 0xC5, 0x30, 0xC7, 0x30, 0xC9, ++ 0x30, 0xD0, 0x30, 0xD1, 0x30, 0xD3, 0x30, 0xD4, 0x30, 0xD6, 0x30, 0xD7, 0x30, 0xD9, 0x30, 0xDA, ++ 0x30, 0xDC, 0x30, 0xDD, 0x30, 0xF4, 0x30, 0xF7, 0x30, 0xF8, 0x30, 0xF9, 0x30, 0xFA, 0x30, 0xFE, ++ 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x1E, 0x9A, 0x00, 0x89, 0x01, 0x18, ++ 0x02, 0x72, 0x02, 0x8C, 0x02, 0xE6, 0x03, 0x18, 0x04, 0x3E, 0x04, 0x48, 0x04, 0x8A, 0x04, 0xC4, ++ 0x05, 0x6A, 0x05, 0x74, 0x05, 0xA6, 0x05, 0xF4, 0x06, 0x16, 0x06, 0x70, 0x08, 0x56, 0x08, 0x70, ++ 0x08, 0xCE, 0x09, 0x42, 0x09, 0x7C, 0x0B, 0x14, 0x0B, 0x26, 0x0B, 0x68, 0x0B, 0x7A, 0x0B, 0xD4, ++ 0x0C, 0x0E, 0x0D, 0x68, 0x0D, 0x82, 0x0D, 0xDC, 0x0E, 0x0E, 0x0F, 0x34, 0x0F, 0x3E, 0x0F, 0x80, ++ 0x0F, 0xC2, 0x10, 0x60, 0x10, 0x72, 0x10, 0xA4, 0x10, 0xF2, 0x11, 0x14, 0x11, 0x6E, 0x13, 0x54, ++ 0x13, 0x6E, 0x13, 0xCC, 0x14, 0x40, 0x14, 0x82, 0x16, 0x1A, 0x16, 0x2C, 0x16, 0x76, 0x16, 0x88, ++ 0x16, 0xEA, 0x17, 0x24, 0x17, 0x5E, 0x17, 0x68, 0x17, 0x7A, 0x17, 0x94, 0x17, 0xA6, 0x17, 0xE0, ++ 0x17, 0xF2, 0x17, 0xFC, 0x18, 0x06, 0x18, 0x40, 0x18, 0x6A, 0x18, 0x74, 0x18, 0x86, 0x18, 0x90, ++ 0x18, 0x9A, 0x18, 0xCC, 0x19, 0x06, 0x19, 0x10, 0x19, 0x22, 0x19, 0x3C, 0x19, 0x4E, 0x19, 0x88, ++ 0x19, 0x9A, 0x19, 0xA4, 0x19, 0xAE, 0x19, 0xE8, 0x1A, 0x12, 0x1A, 0x1C, 0x1A, 0x2E, 0x1A, 0x38, ++ 0x1A, 0x42, 0x1A, 0x74, 0x1A, 0xAE, 0x1A, 0xE8, 0x1A, 0xF2, 0x1A, 0xFC, 0x1B, 0x1E, 0x1B, 0x40, ++ 0x1B, 0x4A, 0x1B, 0x54, 0x1B, 0x7E, 0x1B, 0xA8, 0x1B, 0xB2, 0x1B, 0xBC, 0x1B, 0xC6, 0x1B, 0xD0, ++ 0x1B, 0xEA, 0x1C, 0x04, 0x1C, 0x0E, 0x1C, 0x18, 0x1C, 0x22, 0x1C, 0x5C, 0x1C, 0x96, 0x1C, 0xD0, ++ 0x1D, 0x0A, 0x1D, 0x14, 0x1D, 0x1E, 0x1D, 0x28, 0x1D, 0x32, 0x1D, 0x3C, 0x1D, 0x46, 0x1D, 0x50, ++ 0x1D, 0x5A, 0x1D, 0x64, 0x1D, 0x6E, 0x1D, 0x78, 0x1D, 0x82, 0x1D, 0x8C, 0x1D, 0x96, 0x1D, 0xA0, ++ 0x1D, 0xAA, 0x1D, 0xB4, 0x1D, 0xBE, 0x1D, 0xD0, 0x1D, 0xE2, 0x1D, 0xEC, 0x1D, 0xF6, 0x1E, 0x08, ++ 0x1E, 0x1A, 0x1E, 0x24, 0x1E, 0x2E, 0x1E, 0x38, 0x1E, 0x42, 0x1E, 0x4C, 0x1E, 0x56, 0x1E, 0x88, + 0x00, 0x26, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x7A, + 0x00, 0x82, 0x00, 0x8A, 0x00, 0x92, 0x00, 0x98, 0x00, 0x9E, 0x00, 0xA4, 0x00, 0xAC, 0x00, 0xB4, + 0x00, 0xBC, 0x00, 0xC4, 0x00, 0xCC, 0x00, 0xD4, 0x00, 0xDC, 0x00, 0xE2, 0x00, 0xEA, 0x00, 0xF0, + 0x00, 0xF8, 0x00, 0xFE, 0x01, 0x04, 0x01, 0x0C, 0x01, 0x14, 0x01, 0x1A, 0x01, 0x20, 0x01, 0x26, +- 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x42, 0x01, 0x48, 0x01, 0x4E, 0x01, 0x54, 0x00, 0xE0, +- 0x00, 0x02, 0x03, 0x00, 0x00, 0xE1, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xA7, 0x00, 0x03, 0x03, 0x02, +- 0x03, 0x00, 0x1E, 0xA5, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, 0x1E, 0xAB, 0x00, 0x03, 0x03, 0x02, +- 0x03, 0x03, 0x1E, 0xA9, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, 0x1E, 0xAD, 0x00, 0x03, 0x03, 0x02, +- 0x03, 0x23, 0x1E, 0xA7, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, 0x1E, 0xA5, 0x00, 0x03, 0x03, 0x02, +- 0x03, 0x41, 0x00, 0xE2, 0x00, 0x02, 0x03, 0x02, 0x00, 0xE3, 0x00, 0x02, 0x03, 0x03, 0x01, 0x01, +- 0x00, 0x02, 0x03, 0x04, 0x1E, 0xB1, 0x00, 0x03, 0x03, 0x06, 0x03, 0x00, 0x1E, 0xAF, 0x00, 0x03, +- 0x03, 0x06, 0x03, 0x01, 0x1E, 0xB5, 0x00, 0x03, 0x03, 0x06, 0x03, 0x03, 0x1E, 0xB3, 0x00, 0x03, +- 0x03, 0x06, 0x03, 0x09, 0x1E, 0xB7, 0x00, 0x03, 0x03, 0x06, 0x03, 0x23, 0x1E, 0xB1, 0x00, 0x03, +- 0x03, 0x06, 0x03, 0x40, 0x1E, 0xAF, 0x00, 0x03, 0x03, 0x06, 0x03, 0x41, 0x01, 0x03, 0x00, 0x02, +- 0x03, 0x06, 0x01, 0xE1, 0x00, 0x03, 0x03, 0x07, 0x03, 0x04, 0x02, 0x27, 0x00, 0x02, 0x03, 0x07, +- 0x01, 0xDF, 0x00, 0x03, 0x03, 0x08, 0x03, 0x04, 0x00, 0xE4, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xA3, +- 0x00, 0x02, 0x03, 0x09, 0x01, 0xFB, 0x00, 0x03, 0x03, 0x0A, 0x03, 0x01, 0x01, 0xFB, 0x00, 0x03, +- 0x03, 0x0A, 0x03, 0x41, 0x00, 0xE5, 0x00, 0x02, 0x03, 0x0A, 0x01, 0xCE, 0x00, 0x02, 0x03, 0x0C, +- 0x02, 0x01, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x03, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xAD, 0x00, 0x03, +- 0x03, 0x23, 0x03, 0x02, 0x1E, 0xB7, 0x00, 0x03, 0x03, 0x23, 0x03, 0x06, 0x1E, 0xA1, 0x00, 0x02, +- 0x03, 0x23, 0x1E, 0x01, 0x00, 0x02, 0x03, 0x25, 0x01, 0x05, 0x00, 0x02, 0x03, 0x28, 0x00, 0xE0, +- 0x00, 0x02, 0x03, 0x40, 0x00, 0xE1, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, +- 0x00, 0x14, 0x1E, 0x03, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x05, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x07, ++ 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x42, 0x01, 0x48, 0x01, 0x4E, 0x01, 0x54, 0x00, 0xC0, ++ 0x00, 0x02, 0x03, 0x00, 0x00, 0xC1, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xA6, 0x00, 0x03, 0x03, 0x02, ++ 0x03, 0x00, 0x1E, 0xA4, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, 0x1E, 0xAA, 0x00, 0x03, 0x03, 0x02, ++ 0x03, 0x03, 0x1E, 0xA8, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, 0x1E, 0xAC, 0x00, 0x03, 0x03, 0x02, ++ 0x03, 0x23, 0x1E, 0xA6, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, 0x1E, 0xA4, 0x00, 0x03, 0x03, 0x02, ++ 0x03, 0x41, 0x00, 0xC2, 0x00, 0x02, 0x03, 0x02, 0x00, 0xC3, 0x00, 0x02, 0x03, 0x03, 0x01, 0x00, ++ 0x00, 0x02, 0x03, 0x04, 0x1E, 0xB0, 0x00, 0x03, 0x03, 0x06, 0x03, 0x00, 0x1E, 0xAE, 0x00, 0x03, ++ 0x03, 0x06, 0x03, 0x01, 0x1E, 0xB4, 0x00, 0x03, 0x03, 0x06, 0x03, 0x03, 0x1E, 0xB2, 0x00, 0x03, ++ 0x03, 0x06, 0x03, 0x09, 0x1E, 0xB6, 0x00, 0x03, 0x03, 0x06, 0x03, 0x23, 0x1E, 0xB0, 0x00, 0x03, ++ 0x03, 0x06, 0x03, 0x40, 0x1E, 0xAE, 0x00, 0x03, 0x03, 0x06, 0x03, 0x41, 0x01, 0x02, 0x00, 0x02, ++ 0x03, 0x06, 0x01, 0xE0, 0x00, 0x03, 0x03, 0x07, 0x03, 0x04, 0x02, 0x26, 0x00, 0x02, 0x03, 0x07, ++ 0x01, 0xDE, 0x00, 0x03, 0x03, 0x08, 0x03, 0x04, 0x00, 0xC4, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xA2, ++ 0x00, 0x02, 0x03, 0x09, 0x01, 0xFA, 0x00, 0x03, 0x03, 0x0A, 0x03, 0x01, 0x01, 0xFA, 0x00, 0x03, ++ 0x03, 0x0A, 0x03, 0x41, 0x00, 0xC5, 0x00, 0x02, 0x03, 0x0A, 0x01, 0xCD, 0x00, 0x02, 0x03, 0x0C, ++ 0x02, 0x00, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x02, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xAC, 0x00, 0x03, ++ 0x03, 0x23, 0x03, 0x02, 0x1E, 0xB6, 0x00, 0x03, 0x03, 0x23, 0x03, 0x06, 0x1E, 0xA0, 0x00, 0x02, ++ 0x03, 0x23, 0x1E, 0x00, 0x00, 0x02, 0x03, 0x25, 0x01, 0x04, 0x00, 0x02, 0x03, 0x28, 0x00, 0xC0, ++ 0x00, 0x02, 0x03, 0x40, 0x00, 0xC1, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, ++ 0x00, 0x14, 0x1E, 0x02, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x04, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x06, + 0x00, 0x02, 0x03, 0x31, 0x00, 0x0A, 0x00, 0x16, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, +- 0x00, 0x36, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x54, 0x1E, 0x09, 0x00, 0x03, 0x03, 0x01, +- 0x03, 0x27, 0x01, 0x07, 0x00, 0x02, 0x03, 0x01, 0x01, 0x09, 0x00, 0x02, 0x03, 0x02, 0x01, 0x0B, +- 0x00, 0x02, 0x03, 0x07, 0x01, 0x0D, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x09, 0x00, 0x03, 0x03, 0x27, +- 0x03, 0x01, 0x1E, 0x09, 0x00, 0x03, 0x03, 0x27, 0x03, 0x41, 0x00, 0xE7, 0x00, 0x02, 0x03, 0x27, +- 0x1E, 0x09, 0x00, 0x03, 0x03, 0x41, 0x03, 0x27, 0x01, 0x07, 0x00, 0x02, 0x03, 0x41, 0x00, 0x06, +- 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x1E, 0x0B, 0x00, 0x02, +- 0x03, 0x07, 0x01, 0x0F, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x0D, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x11, +- 0x00, 0x02, 0x03, 0x27, 0x1E, 0x13, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x0F, 0x00, 0x02, 0x03, 0x31, ++ 0x00, 0x36, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x54, 0x1E, 0x08, 0x00, 0x03, 0x03, 0x01, ++ 0x03, 0x27, 0x01, 0x06, 0x00, 0x02, 0x03, 0x01, 0x01, 0x08, 0x00, 0x02, 0x03, 0x02, 0x01, 0x0A, ++ 0x00, 0x02, 0x03, 0x07, 0x01, 0x0C, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x08, 0x00, 0x03, 0x03, 0x27, ++ 0x03, 0x01, 0x1E, 0x08, 0x00, 0x03, 0x03, 0x27, 0x03, 0x41, 0x00, 0xC7, 0x00, 0x02, 0x03, 0x27, ++ 0x1E, 0x08, 0x00, 0x03, 0x03, 0x41, 0x03, 0x27, 0x01, 0x06, 0x00, 0x02, 0x03, 0x41, 0x00, 0x06, ++ 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x1E, 0x0A, 0x00, 0x02, ++ 0x03, 0x07, 0x01, 0x0E, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x0C, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x10, ++ 0x00, 0x02, 0x03, 0x27, 0x1E, 0x12, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x0E, 0x00, 0x02, 0x03, 0x31, + 0x00, 0x21, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x58, 0x00, 0x60, 0x00, 0x68, 0x00, 0x70, + 0x00, 0x78, 0x00, 0x80, 0x00, 0x88, 0x00, 0x8E, 0x00, 0x94, 0x00, 0x9C, 0x00, 0xA4, 0x00, 0xAC, + 0x00, 0xB4, 0x00, 0xBA, 0x00, 0xC2, 0x00, 0xC8, 0x00, 0xCE, 0x00, 0xD4, 0x00, 0xDA, 0x00, 0xE0, + 0x00, 0xE6, 0x00, 0xEC, 0x00, 0xF4, 0x00, 0xFA, 0x01, 0x02, 0x01, 0x08, 0x01, 0x0E, 0x01, 0x14, +- 0x01, 0x1A, 0x01, 0x20, 0x00, 0xE8, 0x00, 0x02, 0x03, 0x00, 0x00, 0xE9, 0x00, 0x02, 0x03, 0x01, +- 0x1E, 0xC1, 0x00, 0x03, 0x03, 0x02, 0x03, 0x00, 0x1E, 0xBF, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, +- 0x1E, 0xC5, 0x00, 0x03, 0x03, 0x02, 0x03, 0x03, 0x1E, 0xC3, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, +- 0x1E, 0xC7, 0x00, 0x03, 0x03, 0x02, 0x03, 0x23, 0x1E, 0xC1, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, +- 0x1E, 0xBF, 0x00, 0x03, 0x03, 0x02, 0x03, 0x41, 0x00, 0xEA, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xBD, +- 0x00, 0x02, 0x03, 0x03, 0x1E, 0x15, 0x00, 0x03, 0x03, 0x04, 0x03, 0x00, 0x1E, 0x17, 0x00, 0x03, +- 0x03, 0x04, 0x03, 0x01, 0x1E, 0x15, 0x00, 0x03, 0x03, 0x04, 0x03, 0x40, 0x1E, 0x17, 0x00, 0x03, +- 0x03, 0x04, 0x03, 0x41, 0x01, 0x13, 0x00, 0x02, 0x03, 0x04, 0x1E, 0x1D, 0x00, 0x03, 0x03, 0x06, +- 0x03, 0x27, 0x01, 0x15, 0x00, 0x02, 0x03, 0x06, 0x01, 0x17, 0x00, 0x02, 0x03, 0x07, 0x00, 0xEB, +- 0x00, 0x02, 0x03, 0x08, 0x1E, 0xBB, 0x00, 0x02, 0x03, 0x09, 0x01, 0x1B, 0x00, 0x02, 0x03, 0x0C, +- 0x02, 0x05, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x07, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xC7, 0x00, 0x03, +- 0x03, 0x23, 0x03, 0x02, 0x1E, 0xB9, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x1D, 0x00, 0x03, 0x03, 0x27, +- 0x03, 0x06, 0x02, 0x29, 0x00, 0x02, 0x03, 0x27, 0x01, 0x19, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x19, +- 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x1B, 0x00, 0x02, 0x03, 0x30, 0x00, 0xE8, 0x00, 0x02, 0x03, 0x40, +- 0x00, 0xE9, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x1F, 0x00, 0x02, 0x03, 0x07, ++ 0x01, 0x1A, 0x01, 0x20, 0x00, 0xC8, 0x00, 0x02, 0x03, 0x00, 0x00, 0xC9, 0x00, 0x02, 0x03, 0x01, ++ 0x1E, 0xC0, 0x00, 0x03, 0x03, 0x02, 0x03, 0x00, 0x1E, 0xBE, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, ++ 0x1E, 0xC4, 0x00, 0x03, 0x03, 0x02, 0x03, 0x03, 0x1E, 0xC2, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, ++ 0x1E, 0xC6, 0x00, 0x03, 0x03, 0x02, 0x03, 0x23, 0x1E, 0xC0, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, ++ 0x1E, 0xBE, 0x00, 0x03, 0x03, 0x02, 0x03, 0x41, 0x00, 0xCA, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xBC, ++ 0x00, 0x02, 0x03, 0x03, 0x1E, 0x14, 0x00, 0x03, 0x03, 0x04, 0x03, 0x00, 0x1E, 0x16, 0x00, 0x03, ++ 0x03, 0x04, 0x03, 0x01, 0x1E, 0x14, 0x00, 0x03, 0x03, 0x04, 0x03, 0x40, 0x1E, 0x16, 0x00, 0x03, ++ 0x03, 0x04, 0x03, 0x41, 0x01, 0x12, 0x00, 0x02, 0x03, 0x04, 0x1E, 0x1C, 0x00, 0x03, 0x03, 0x06, ++ 0x03, 0x27, 0x01, 0x14, 0x00, 0x02, 0x03, 0x06, 0x01, 0x16, 0x00, 0x02, 0x03, 0x07, 0x00, 0xCB, ++ 0x00, 0x02, 0x03, 0x08, 0x1E, 0xBA, 0x00, 0x02, 0x03, 0x09, 0x01, 0x1A, 0x00, 0x02, 0x03, 0x0C, ++ 0x02, 0x04, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x06, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xC6, 0x00, 0x03, ++ 0x03, 0x23, 0x03, 0x02, 0x1E, 0xB8, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x1C, 0x00, 0x03, 0x03, 0x27, ++ 0x03, 0x06, 0x02, 0x28, 0x00, 0x02, 0x03, 0x27, 0x01, 0x18, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x18, ++ 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x1A, 0x00, 0x02, 0x03, 0x30, 0x00, 0xC8, 0x00, 0x02, 0x03, 0x40, ++ 0x00, 0xC9, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x1E, 0x00, 0x02, 0x03, 0x07, + 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, +- 0x00, 0x3C, 0x01, 0xF5, 0x00, 0x02, 0x03, 0x01, 0x01, 0x1D, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x21, +- 0x00, 0x02, 0x03, 0x04, 0x01, 0x1F, 0x00, 0x02, 0x03, 0x06, 0x01, 0x21, 0x00, 0x02, 0x03, 0x07, +- 0x01, 0xE7, 0x00, 0x02, 0x03, 0x0C, 0x01, 0x23, 0x00, 0x02, 0x03, 0x27, 0x01, 0xF5, 0x00, 0x02, +- 0x03, 0x41, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, +- 0x00, 0x36, 0x00, 0x3C, 0x01, 0x25, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x23, 0x00, 0x02, 0x03, 0x07, +- 0x1E, 0x27, 0x00, 0x02, 0x03, 0x08, 0x02, 0x1F, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x25, 0x00, 0x02, +- 0x03, 0x23, 0x1E, 0x29, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x2B, 0x00, 0x02, 0x03, 0x2E, 0x1E, 0x96, +- 0x00, 0x02, 0x03, 0x31, 0x00, 0x13, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x00, 0x3A, 0x00, 0x40, +- 0x00, 0x46, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x68, 0x00, 0x6E, 0x00, 0x74, +- 0x00, 0x7A, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, 0x00, 0x92, 0x00, 0x98, 0x00, 0xEC, 0x00, 0x02, +- 0x03, 0x00, 0x00, 0xED, 0x00, 0x02, 0x03, 0x01, 0x00, 0xEE, 0x00, 0x02, 0x03, 0x02, 0x01, 0x29, +- 0x00, 0x02, 0x03, 0x03, 0x01, 0x2B, 0x00, 0x02, 0x03, 0x04, 0x01, 0x2D, 0x00, 0x02, 0x03, 0x06, +- 0x1E, 0x2F, 0x00, 0x03, 0x03, 0x08, 0x03, 0x01, 0x1E, 0x2F, 0x00, 0x03, 0x03, 0x08, 0x03, 0x41, +- 0x00, 0xEF, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xC9, 0x00, 0x02, 0x03, 0x09, 0x01, 0xD0, 0x00, 0x02, +- 0x03, 0x0C, 0x02, 0x09, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x0B, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xCB, +- 0x00, 0x02, 0x03, 0x23, 0x01, 0x2F, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x2D, 0x00, 0x02, 0x03, 0x30, +- 0x00, 0xEC, 0x00, 0x02, 0x03, 0x40, 0x00, 0xED, 0x00, 0x02, 0x03, 0x41, 0x1E, 0x2F, 0x00, 0x02, +- 0x03, 0x44, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x01, 0x35, 0x00, 0x02, 0x03, 0x02, 0x01, 0xF0, +- 0x00, 0x02, 0x03, 0x0C, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, +- 0x00, 0x2C, 0x1E, 0x31, 0x00, 0x02, 0x03, 0x01, 0x01, 0xE9, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x33, +- 0x00, 0x02, 0x03, 0x23, 0x01, 0x37, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x35, 0x00, 0x02, 0x03, 0x31, +- 0x1E, 0x31, 0x00, 0x02, 0x03, 0x41, 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x22, 0x00, 0x28, +- 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x01, 0x3A, 0x00, 0x02, 0x03, 0x01, +- 0x1E, 0x39, 0x00, 0x03, 0x03, 0x04, 0x03, 0x23, 0x01, 0x3E, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x39, +- 0x00, 0x03, 0x03, 0x23, 0x03, 0x04, 0x1E, 0x37, 0x00, 0x02, 0x03, 0x23, 0x01, 0x3C, 0x00, 0x02, +- 0x03, 0x27, 0x1E, 0x3D, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x3B, 0x00, 0x02, 0x03, 0x31, 0x01, 0x3A, +- 0x00, 0x02, 0x03, 0x41, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x1E, 0x3F, +- 0x00, 0x02, 0x03, 0x01, 0x1E, 0x41, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x43, 0x00, 0x02, 0x03, 0x23, +- 0x1E, 0x3F, 0x00, 0x02, 0x03, 0x41, 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, +- 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x01, 0xF9, +- 0x00, 0x02, 0x03, 0x00, 0x01, 0x44, 0x00, 0x02, 0x03, 0x01, 0x00, 0xF1, 0x00, 0x02, 0x03, 0x03, +- 0x1E, 0x45, 0x00, 0x02, 0x03, 0x07, 0x01, 0x48, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x47, 0x00, 0x02, +- 0x03, 0x23, 0x01, 0x46, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x4B, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x49, +- 0x00, 0x02, 0x03, 0x31, 0x01, 0xF9, 0x00, 0x02, 0x03, 0x40, 0x01, 0x44, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x34, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x78, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8E, 0x00, 0x96, +- 0x00, 0x9E, 0x00, 0xA6, 0x00, 0xAE, 0x00, 0xB6, 0x00, 0xBE, 0x00, 0xC4, 0x00, 0xCC, 0x00, 0xD4, +- 0x00, 0xDC, 0x00, 0xE4, 0x00, 0xEC, 0x00, 0xF2, 0x00, 0xFA, 0x01, 0x02, 0x01, 0x0A, 0x01, 0x12, +- 0x01, 0x1A, 0x01, 0x20, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x42, 0x01, 0x4A, +- 0x01, 0x50, 0x01, 0x56, 0x01, 0x5C, 0x01, 0x62, 0x01, 0x68, 0x01, 0x70, 0x01, 0x78, 0x01, 0x80, +- 0x01, 0x88, 0x01, 0x90, 0x01, 0x98, 0x01, 0xA0, 0x01, 0xA6, 0x01, 0xAE, 0x01, 0xB6, 0x01, 0xBC, +- 0x01, 0xC4, 0x01, 0xCA, 0x01, 0xD2, 0x01, 0xD8, 0x01, 0xE0, 0x1E, 0xDD, 0x00, 0x03, 0x03, 0x00, +- 0x03, 0x1B, 0x00, 0xF2, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xDB, 0x00, 0x03, 0x03, 0x01, 0x03, 0x1B, +- 0x00, 0xF3, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xD3, 0x00, 0x03, 0x03, 0x02, 0x03, 0x00, 0x1E, 0xD1, +- 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, 0x1E, 0xD7, 0x00, 0x03, 0x03, 0x02, 0x03, 0x03, 0x1E, 0xD5, +- 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, 0x1E, 0xD9, 0x00, 0x03, 0x03, 0x02, 0x03, 0x23, 0x1E, 0xD3, +- 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, 0x1E, 0xD1, 0x00, 0x03, 0x03, 0x02, 0x03, 0x41, 0x00, 0xF4, +- 0x00, 0x02, 0x03, 0x02, 0x1E, 0x4D, 0x00, 0x03, 0x03, 0x03, 0x03, 0x01, 0x02, 0x2D, 0x00, 0x03, +- 0x03, 0x03, 0x03, 0x04, 0x1E, 0x4F, 0x00, 0x03, 0x03, 0x03, 0x03, 0x08, 0x1E, 0xE1, 0x00, 0x03, +- 0x03, 0x03, 0x03, 0x1B, 0x1E, 0x4D, 0x00, 0x03, 0x03, 0x03, 0x03, 0x41, 0x00, 0xF5, 0x00, 0x02, +- 0x03, 0x03, 0x1E, 0x51, 0x00, 0x03, 0x03, 0x04, 0x03, 0x00, 0x1E, 0x53, 0x00, 0x03, 0x03, 0x04, +- 0x03, 0x01, 0x01, 0xED, 0x00, 0x03, 0x03, 0x04, 0x03, 0x28, 0x1E, 0x51, 0x00, 0x03, 0x03, 0x04, +- 0x03, 0x40, 0x1E, 0x53, 0x00, 0x03, 0x03, 0x04, 0x03, 0x41, 0x01, 0x4D, 0x00, 0x02, 0x03, 0x04, +- 0x01, 0x4F, 0x00, 0x02, 0x03, 0x06, 0x02, 0x31, 0x00, 0x03, 0x03, 0x07, 0x03, 0x04, 0x02, 0x2F, +- 0x00, 0x02, 0x03, 0x07, 0x02, 0x2B, 0x00, 0x03, 0x03, 0x08, 0x03, 0x04, 0x00, 0xF6, 0x00, 0x02, +- 0x03, 0x08, 0x1E, 0xDF, 0x00, 0x03, 0x03, 0x09, 0x03, 0x1B, 0x1E, 0xCF, 0x00, 0x02, 0x03, 0x09, +- 0x01, 0x51, 0x00, 0x02, 0x03, 0x0B, 0x01, 0xD2, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x0D, 0x00, 0x02, +- 0x03, 0x0F, 0x02, 0x0F, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xDD, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x00, +- 0x1E, 0xDB, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x01, 0x1E, 0xE1, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x03, +- 0x1E, 0xDF, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x09, 0x1E, 0xE3, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x23, +- 0x1E, 0xDD, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x40, 0x1E, 0xDB, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x41, +- 0x01, 0xA1, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0xD9, 0x00, 0x03, 0x03, 0x23, 0x03, 0x02, 0x1E, 0xE3, +- 0x00, 0x03, 0x03, 0x23, 0x03, 0x1B, 0x1E, 0xCD, 0x00, 0x02, 0x03, 0x23, 0x01, 0xED, 0x00, 0x03, +- 0x03, 0x28, 0x03, 0x04, 0x01, 0xEB, 0x00, 0x02, 0x03, 0x28, 0x1E, 0xDD, 0x00, 0x03, 0x03, 0x40, +- 0x03, 0x1B, 0x00, 0xF2, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xDB, 0x00, 0x03, 0x03, 0x41, 0x03, 0x1B, +- 0x00, 0xF3, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x1E, 0x55, +- 0x00, 0x02, 0x03, 0x01, 0x1E, 0x57, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x55, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, +- 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x01, 0x55, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x5D, +- 0x00, 0x03, 0x03, 0x04, 0x03, 0x23, 0x1E, 0x59, 0x00, 0x02, 0x03, 0x07, 0x01, 0x59, 0x00, 0x02, +- 0x03, 0x0C, 0x02, 0x11, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x13, 0x00, 0x02, 0x03, 0x11, 0x1E, 0x5D, +- 0x00, 0x03, 0x03, 0x23, 0x03, 0x04, 0x1E, 0x5B, 0x00, 0x02, 0x03, 0x23, 0x01, 0x57, 0x00, 0x02, +- 0x03, 0x27, 0x1E, 0x5F, 0x00, 0x02, 0x03, 0x31, 0x01, 0x55, 0x00, 0x02, 0x03, 0x41, 0x00, 0x0D, +- 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, +- 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, 0x00, 0x6E, 0x1E, 0x65, 0x00, 0x03, 0x03, 0x01, +- 0x03, 0x07, 0x01, 0x5B, 0x00, 0x02, 0x03, 0x01, 0x01, 0x5D, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x69, +- 0x00, 0x03, 0x03, 0x07, 0x03, 0x23, 0x1E, 0x61, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x67, 0x00, 0x03, +- 0x03, 0x0C, 0x03, 0x07, 0x01, 0x61, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x69, 0x00, 0x03, 0x03, 0x23, +- 0x03, 0x07, 0x1E, 0x63, 0x00, 0x02, 0x03, 0x23, 0x02, 0x19, 0x00, 0x02, 0x03, 0x26, 0x01, 0x5F, +- 0x00, 0x02, 0x03, 0x27, 0x1E, 0x65, 0x00, 0x03, 0x03, 0x41, 0x03, 0x07, 0x01, 0x5B, 0x00, 0x02, +- 0x03, 0x41, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, +- 0x00, 0x36, 0x00, 0x3C, 0x1E, 0x6B, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x97, 0x00, 0x02, 0x03, 0x08, +- 0x01, 0x65, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x6D, 0x00, 0x02, 0x03, 0x23, 0x02, 0x1B, 0x00, 0x02, +- 0x03, 0x26, 0x01, 0x63, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x71, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x6F, ++ 0x00, 0x3C, 0x01, 0xF4, 0x00, 0x02, 0x03, 0x01, 0x01, 0x1C, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x20, ++ 0x00, 0x02, 0x03, 0x04, 0x01, 0x1E, 0x00, 0x02, 0x03, 0x06, 0x01, 0x20, 0x00, 0x02, 0x03, 0x07, ++ 0x01, 0xE6, 0x00, 0x02, 0x03, 0x0C, 0x01, 0x22, 0x00, 0x02, 0x03, 0x27, 0x01, 0xF4, 0x00, 0x02, ++ 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, ++ 0x00, 0x34, 0x01, 0x24, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x22, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x26, ++ 0x00, 0x02, 0x03, 0x08, 0x02, 0x1E, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x24, 0x00, 0x02, 0x03, 0x23, ++ 0x1E, 0x28, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x2A, 0x00, 0x02, 0x03, 0x2E, 0x00, 0x14, 0x00, 0x2A, ++ 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5C, ++ 0x00, 0x64, 0x00, 0x6A, 0x00, 0x70, 0x00, 0x76, 0x00, 0x7C, 0x00, 0x82, 0x00, 0x88, 0x00, 0x8E, ++ 0x00, 0x94, 0x00, 0x9A, 0x00, 0xA0, 0x00, 0xCC, 0x00, 0x02, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x02, ++ 0x03, 0x01, 0x00, 0xCE, 0x00, 0x02, 0x03, 0x02, 0x01, 0x28, 0x00, 0x02, 0x03, 0x03, 0x01, 0x2A, ++ 0x00, 0x02, 0x03, 0x04, 0x01, 0x2C, 0x00, 0x02, 0x03, 0x06, 0x01, 0x30, 0x00, 0x02, 0x03, 0x07, ++ 0x1E, 0x2E, 0x00, 0x03, 0x03, 0x08, 0x03, 0x01, 0x1E, 0x2E, 0x00, 0x03, 0x03, 0x08, 0x03, 0x41, ++ 0x00, 0xCF, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xC8, 0x00, 0x02, 0x03, 0x09, 0x01, 0xCF, 0x00, 0x02, ++ 0x03, 0x0C, 0x02, 0x08, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x0A, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xCA, ++ 0x00, 0x02, 0x03, 0x23, 0x01, 0x2E, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x2C, 0x00, 0x02, 0x03, 0x30, ++ 0x00, 0xCC, 0x00, 0x02, 0x03, 0x40, 0x00, 0xCD, 0x00, 0x02, 0x03, 0x41, 0x1E, 0x2E, 0x00, 0x02, ++ 0x03, 0x44, 0x00, 0x01, 0x00, 0x04, 0x01, 0x34, 0x00, 0x02, 0x03, 0x02, 0x00, 0x06, 0x00, 0x0E, ++ 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x1E, 0x30, 0x00, 0x02, 0x03, 0x01, ++ 0x01, 0xE8, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x32, 0x00, 0x02, 0x03, 0x23, 0x01, 0x36, 0x00, 0x02, ++ 0x03, 0x27, 0x1E, 0x34, 0x00, 0x02, 0x03, 0x31, 0x1E, 0x30, 0x00, 0x02, 0x03, 0x41, 0x00, 0x09, ++ 0x00, 0x14, 0x00, 0x1A, 0x00, 0x22, 0x00, 0x28, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, ++ 0x00, 0x48, 0x01, 0x39, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x38, 0x00, 0x03, 0x03, 0x04, 0x03, 0x23, ++ 0x01, 0x3D, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x38, 0x00, 0x03, 0x03, 0x23, 0x03, 0x04, 0x1E, 0x36, ++ 0x00, 0x02, 0x03, 0x23, 0x01, 0x3B, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x3C, 0x00, 0x02, 0x03, 0x2D, ++ 0x1E, 0x3A, 0x00, 0x02, 0x03, 0x31, 0x01, 0x39, 0x00, 0x02, 0x03, 0x41, 0x00, 0x04, 0x00, 0x0A, ++ 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x1E, 0x3E, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x40, 0x00, 0x02, ++ 0x03, 0x07, 0x1E, 0x42, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x3E, 0x00, 0x02, 0x03, 0x41, 0x00, 0x0B, ++ 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, ++ 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x01, 0xF8, 0x00, 0x02, 0x03, 0x00, 0x01, 0x43, 0x00, 0x02, ++ 0x03, 0x01, 0x00, 0xD1, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x44, 0x00, 0x02, 0x03, 0x07, 0x01, 0x47, ++ 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x46, 0x00, 0x02, 0x03, 0x23, 0x01, 0x45, 0x00, 0x02, 0x03, 0x27, ++ 0x1E, 0x4A, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x48, 0x00, 0x02, 0x03, 0x31, 0x01, 0xF8, 0x00, 0x02, ++ 0x03, 0x40, 0x01, 0x43, 0x00, 0x02, 0x03, 0x41, 0x00, 0x34, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x78, ++ 0x00, 0x80, 0x00, 0x86, 0x00, 0x8E, 0x00, 0x96, 0x00, 0x9E, 0x00, 0xA6, 0x00, 0xAE, 0x00, 0xB6, ++ 0x00, 0xBE, 0x00, 0xC4, 0x00, 0xCC, 0x00, 0xD4, 0x00, 0xDC, 0x00, 0xE4, 0x00, 0xEC, 0x00, 0xF2, ++ 0x00, 0xFA, 0x01, 0x02, 0x01, 0x0A, 0x01, 0x12, 0x01, 0x1A, 0x01, 0x20, 0x01, 0x26, 0x01, 0x2E, ++ 0x01, 0x34, 0x01, 0x3C, 0x01, 0x42, 0x01, 0x4A, 0x01, 0x50, 0x01, 0x56, 0x01, 0x5C, 0x01, 0x62, ++ 0x01, 0x68, 0x01, 0x70, 0x01, 0x78, 0x01, 0x80, 0x01, 0x88, 0x01, 0x90, 0x01, 0x98, 0x01, 0xA0, ++ 0x01, 0xA6, 0x01, 0xAE, 0x01, 0xB6, 0x01, 0xBC, 0x01, 0xC4, 0x01, 0xCA, 0x01, 0xD2, 0x01, 0xD8, ++ 0x01, 0xE0, 0x1E, 0xDC, 0x00, 0x03, 0x03, 0x00, 0x03, 0x1B, 0x00, 0xD2, 0x00, 0x02, 0x03, 0x00, ++ 0x1E, 0xDA, 0x00, 0x03, 0x03, 0x01, 0x03, 0x1B, 0x00, 0xD3, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xD2, ++ 0x00, 0x03, 0x03, 0x02, 0x03, 0x00, 0x1E, 0xD0, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, 0x1E, 0xD6, ++ 0x00, 0x03, 0x03, 0x02, 0x03, 0x03, 0x1E, 0xD4, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, 0x1E, 0xD8, ++ 0x00, 0x03, 0x03, 0x02, 0x03, 0x23, 0x1E, 0xD2, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, 0x1E, 0xD0, ++ 0x00, 0x03, 0x03, 0x02, 0x03, 0x41, 0x00, 0xD4, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x4C, 0x00, 0x03, ++ 0x03, 0x03, 0x03, 0x01, 0x02, 0x2C, 0x00, 0x03, 0x03, 0x03, 0x03, 0x04, 0x1E, 0x4E, 0x00, 0x03, ++ 0x03, 0x03, 0x03, 0x08, 0x1E, 0xE0, 0x00, 0x03, 0x03, 0x03, 0x03, 0x1B, 0x1E, 0x4C, 0x00, 0x03, ++ 0x03, 0x03, 0x03, 0x41, 0x00, 0xD5, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x50, 0x00, 0x03, 0x03, 0x04, ++ 0x03, 0x00, 0x1E, 0x52, 0x00, 0x03, 0x03, 0x04, 0x03, 0x01, 0x01, 0xEC, 0x00, 0x03, 0x03, 0x04, ++ 0x03, 0x28, 0x1E, 0x50, 0x00, 0x03, 0x03, 0x04, 0x03, 0x40, 0x1E, 0x52, 0x00, 0x03, 0x03, 0x04, ++ 0x03, 0x41, 0x01, 0x4C, 0x00, 0x02, 0x03, 0x04, 0x01, 0x4E, 0x00, 0x02, 0x03, 0x06, 0x02, 0x30, ++ 0x00, 0x03, 0x03, 0x07, 0x03, 0x04, 0x02, 0x2E, 0x00, 0x02, 0x03, 0x07, 0x02, 0x2A, 0x00, 0x03, ++ 0x03, 0x08, 0x03, 0x04, 0x00, 0xD6, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xDE, 0x00, 0x03, 0x03, 0x09, ++ 0x03, 0x1B, 0x1E, 0xCE, 0x00, 0x02, 0x03, 0x09, 0x01, 0x50, 0x00, 0x02, 0x03, 0x0B, 0x01, 0xD1, ++ 0x00, 0x02, 0x03, 0x0C, 0x02, 0x0C, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x0E, 0x00, 0x02, 0x03, 0x11, ++ 0x1E, 0xDC, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x00, 0x1E, 0xDA, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x01, ++ 0x1E, 0xE0, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x03, 0x1E, 0xDE, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x09, ++ 0x1E, 0xE2, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x23, 0x1E, 0xDC, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x40, ++ 0x1E, 0xDA, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x41, 0x01, 0xA0, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0xD8, ++ 0x00, 0x03, 0x03, 0x23, 0x03, 0x02, 0x1E, 0xE2, 0x00, 0x03, 0x03, 0x23, 0x03, 0x1B, 0x1E, 0xCC, ++ 0x00, 0x02, 0x03, 0x23, 0x01, 0xEC, 0x00, 0x03, 0x03, 0x28, 0x03, 0x04, 0x01, 0xEA, 0x00, 0x02, ++ 0x03, 0x28, 0x1E, 0xDC, 0x00, 0x03, 0x03, 0x40, 0x03, 0x1B, 0x00, 0xD2, 0x00, 0x02, 0x03, 0x40, ++ 0x1E, 0xDA, 0x00, 0x03, 0x03, 0x41, 0x03, 0x1B, 0x00, 0xD3, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, ++ 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x1E, 0x54, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x56, 0x00, 0x02, ++ 0x03, 0x07, 0x1E, 0x54, 0x00, 0x02, 0x03, 0x41, 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x26, ++ 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, ++ 0x01, 0x54, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x5C, 0x00, 0x03, 0x03, 0x04, 0x03, 0x23, 0x1E, 0x58, ++ 0x00, 0x02, 0x03, 0x07, 0x01, 0x58, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x10, 0x00, 0x02, 0x03, 0x0F, ++ 0x02, 0x12, 0x00, 0x02, 0x03, 0x11, 0x1E, 0x5C, 0x00, 0x03, 0x03, 0x23, 0x03, 0x04, 0x1E, 0x5A, ++ 0x00, 0x02, 0x03, 0x23, 0x01, 0x56, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x5E, 0x00, 0x02, 0x03, 0x31, ++ 0x01, 0x54, 0x00, 0x02, 0x03, 0x41, 0x00, 0x0D, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, ++ 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, ++ 0x00, 0x6E, 0x1E, 0x64, 0x00, 0x03, 0x03, 0x01, 0x03, 0x07, 0x01, 0x5A, 0x00, 0x02, 0x03, 0x01, ++ 0x01, 0x5C, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x68, 0x00, 0x03, 0x03, 0x07, 0x03, 0x23, 0x1E, 0x60, ++ 0x00, 0x02, 0x03, 0x07, 0x1E, 0x66, 0x00, 0x03, 0x03, 0x0C, 0x03, 0x07, 0x01, 0x60, 0x00, 0x02, ++ 0x03, 0x0C, 0x1E, 0x68, 0x00, 0x03, 0x03, 0x23, 0x03, 0x07, 0x1E, 0x62, 0x00, 0x02, 0x03, 0x23, ++ 0x02, 0x18, 0x00, 0x02, 0x03, 0x26, 0x01, 0x5E, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x64, 0x00, 0x03, ++ 0x03, 0x41, 0x03, 0x07, 0x01, 0x5A, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, ++ 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0x6A, 0x00, 0x02, 0x03, 0x07, ++ 0x01, 0x64, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x6C, 0x00, 0x02, 0x03, 0x23, 0x02, 0x1A, 0x00, 0x02, ++ 0x03, 0x26, 0x01, 0x62, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x70, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x6E, + 0x00, 0x02, 0x03, 0x31, 0x00, 0x2D, 0x00, 0x5C, 0x00, 0x64, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x78, + 0x00, 0x7E, 0x00, 0x86, 0x00, 0x8E, 0x00, 0x96, 0x00, 0x9C, 0x00, 0xA4, 0x00, 0xAA, 0x00, 0xB0, + 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xC8, 0x00, 0xD0, 0x00, 0xD8, 0x00, 0xE0, 0x00, 0xE6, 0x00, 0xEE, + 0x00, 0xF4, 0x00, 0xFA, 0x01, 0x00, 0x01, 0x06, 0x01, 0x0C, 0x01, 0x12, 0x01, 0x1A, 0x01, 0x22, + 0x01, 0x2A, 0x01, 0x32, 0x01, 0x3A, 0x01, 0x42, 0x01, 0x4A, 0x01, 0x50, 0x01, 0x58, 0x01, 0x5E, + 0x01, 0x64, 0x01, 0x6A, 0x01, 0x70, 0x01, 0x76, 0x01, 0x7E, 0x01, 0x84, 0x01, 0x8C, 0x01, 0x92, +- 0x1E, 0xEB, 0x00, 0x03, 0x03, 0x00, 0x03, 0x1B, 0x00, 0xF9, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xE9, +- 0x00, 0x03, 0x03, 0x01, 0x03, 0x1B, 0x00, 0xFA, 0x00, 0x02, 0x03, 0x01, 0x00, 0xFB, 0x00, 0x02, +- 0x03, 0x02, 0x1E, 0x79, 0x00, 0x03, 0x03, 0x03, 0x03, 0x01, 0x1E, 0xEF, 0x00, 0x03, 0x03, 0x03, +- 0x03, 0x1B, 0x1E, 0x79, 0x00, 0x03, 0x03, 0x03, 0x03, 0x41, 0x01, 0x69, 0x00, 0x02, 0x03, 0x03, +- 0x1E, 0x7B, 0x00, 0x03, 0x03, 0x04, 0x03, 0x08, 0x01, 0x6B, 0x00, 0x02, 0x03, 0x04, 0x01, 0x6D, +- 0x00, 0x02, 0x03, 0x06, 0x01, 0xDC, 0x00, 0x03, 0x03, 0x08, 0x03, 0x00, 0x01, 0xD8, 0x00, 0x03, +- 0x03, 0x08, 0x03, 0x01, 0x01, 0xD6, 0x00, 0x03, 0x03, 0x08, 0x03, 0x04, 0x01, 0xDA, 0x00, 0x03, +- 0x03, 0x08, 0x03, 0x0C, 0x01, 0xDC, 0x00, 0x03, 0x03, 0x08, 0x03, 0x40, 0x01, 0xD8, 0x00, 0x03, +- 0x03, 0x08, 0x03, 0x41, 0x00, 0xFC, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xED, 0x00, 0x03, 0x03, 0x09, +- 0x03, 0x1B, 0x1E, 0xE7, 0x00, 0x02, 0x03, 0x09, 0x01, 0x6F, 0x00, 0x02, 0x03, 0x0A, 0x01, 0x71, +- 0x00, 0x02, 0x03, 0x0B, 0x01, 0xD4, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x15, 0x00, 0x02, 0x03, 0x0F, +- 0x02, 0x17, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xEB, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x00, 0x1E, 0xE9, +- 0x00, 0x03, 0x03, 0x1B, 0x03, 0x01, 0x1E, 0xEF, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x03, 0x1E, 0xED, +- 0x00, 0x03, 0x03, 0x1B, 0x03, 0x09, 0x1E, 0xF1, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x23, 0x1E, 0xEB, +- 0x00, 0x03, 0x03, 0x1B, 0x03, 0x40, 0x1E, 0xE9, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x41, 0x01, 0xB0, +- 0x00, 0x02, 0x03, 0x1B, 0x1E, 0xF1, 0x00, 0x03, 0x03, 0x23, 0x03, 0x1B, 0x1E, 0xE5, 0x00, 0x02, +- 0x03, 0x23, 0x1E, 0x73, 0x00, 0x02, 0x03, 0x24, 0x01, 0x73, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x77, +- 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x75, 0x00, 0x02, 0x03, 0x30, 0x1E, 0xEB, 0x00, 0x03, 0x03, 0x40, +- 0x03, 0x1B, 0x00, 0xF9, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xE9, 0x00, 0x03, 0x03, 0x41, 0x03, 0x1B, +- 0x00, 0xFA, 0x00, 0x02, 0x03, 0x41, 0x01, 0xD8, 0x00, 0x02, 0x03, 0x44, 0x00, 0x02, 0x00, 0x06, +- 0x00, 0x0C, 0x1E, 0x7D, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x7F, 0x00, 0x02, 0x03, 0x23, 0x00, 0x09, +- 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, +- 0x00, 0x44, 0x1E, 0x81, 0x00, 0x02, 0x03, 0x00, 0x1E, 0x83, 0x00, 0x02, 0x03, 0x01, 0x01, 0x75, +- 0x00, 0x02, 0x03, 0x02, 0x1E, 0x87, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x85, 0x00, 0x02, 0x03, 0x08, +- 0x1E, 0x98, 0x00, 0x02, 0x03, 0x0A, 0x1E, 0x89, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x81, 0x00, 0x02, +- 0x03, 0x40, 0x1E, 0x83, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x8B, +- 0x00, 0x02, 0x03, 0x07, 0x1E, 0x8D, 0x00, 0x02, 0x03, 0x08, 0x00, 0x0C, 0x00, 0x1A, 0x00, 0x20, +- 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, +- 0x00, 0x56, 0x00, 0x5C, 0x1E, 0xF3, 0x00, 0x02, 0x03, 0x00, 0x00, 0xFD, 0x00, 0x02, 0x03, 0x01, +- 0x01, 0x77, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xF9, 0x00, 0x02, 0x03, 0x03, 0x02, 0x33, 0x00, 0x02, +- 0x03, 0x04, 0x1E, 0x8F, 0x00, 0x02, 0x03, 0x07, 0x00, 0xFF, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xF7, +- 0x00, 0x02, 0x03, 0x09, 0x1E, 0x99, 0x00, 0x02, 0x03, 0x0A, 0x1E, 0xF5, 0x00, 0x02, 0x03, 0x23, +- 0x1E, 0xF3, 0x00, 0x02, 0x03, 0x40, 0x00, 0xFD, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, +- 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x01, 0x7A, 0x00, 0x02, +- 0x03, 0x01, 0x1E, 0x91, 0x00, 0x02, 0x03, 0x02, 0x01, 0x7C, 0x00, 0x02, 0x03, 0x07, 0x01, 0x7E, +- 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x93, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x95, 0x00, 0x02, 0x03, 0x31, +- 0x01, 0x7A, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, +- 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xA6, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xA4, 0x00, 0x02, +- 0x03, 0x01, 0x1E, 0xAA, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xA8, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xAC, +- 0x00, 0x02, 0x03, 0x23, 0x1E, 0xA6, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xA4, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x01, 0x00, 0x04, 0x01, 0xDE, 0x00, 0x02, 0x03, 0x04, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0x01, 0xFA, 0x00, 0x02, 0x03, 0x01, 0x01, 0xFA, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, +- 0x00, 0x0E, 0x00, 0x14, 0x01, 0xFC, 0x00, 0x02, 0x03, 0x01, 0x01, 0xE2, 0x00, 0x02, 0x03, 0x04, +- 0x01, 0xFC, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x08, 0x00, 0x02, +- 0x03, 0x01, 0x1E, 0x08, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, +- 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xC0, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xBE, +- 0x00, 0x02, 0x03, 0x01, 0x1E, 0xC4, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xC2, 0x00, 0x02, 0x03, 0x09, +- 0x1E, 0xC6, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xC0, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xBE, 0x00, 0x02, +- 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x2E, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x2E, +- 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xDC, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, +- 0x00, 0x04, 0x1E, 0xDA, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, +- 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xD2, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xD0, +- 0x00, 0x02, 0x03, 0x01, 0x1E, 0xD6, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xD4, 0x00, 0x02, 0x03, 0x09, +- 0x1E, 0xD8, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xD2, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xD0, 0x00, 0x02, +- 0x03, 0x41, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x1E, 0x4C, +- 0x00, 0x02, 0x03, 0x01, 0x02, 0x2C, 0x00, 0x02, 0x03, 0x04, 0x1E, 0x4E, 0x00, 0x02, 0x03, 0x08, +- 0x1E, 0xE0, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0x4C, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, +- 0x02, 0x2A, 0x00, 0x02, 0x03, 0x04, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x01, 0xFE, 0x00, 0x02, +- 0x03, 0x01, 0x01, 0xFE, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xEA, 0x00, 0x02, +- 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xE8, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x06, 0x00, 0x0E, +- 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x01, 0xDB, 0x00, 0x02, 0x03, 0x00, +- 0x01, 0xD7, 0x00, 0x02, 0x03, 0x01, 0x01, 0xD5, 0x00, 0x02, 0x03, 0x04, 0x01, 0xD9, 0x00, 0x02, +- 0x03, 0x0C, 0x01, 0xDB, 0x00, 0x02, 0x03, 0x40, 0x01, 0xD7, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, +- 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xA7, +- 0x00, 0x02, 0x03, 0x00, 0x1E, 0xA5, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xAB, 0x00, 0x02, 0x03, 0x03, +- 0x1E, 0xA9, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xAD, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xA7, 0x00, 0x02, +- 0x03, 0x40, 0x1E, 0xA5, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x01, 0xDF, 0x00, 0x02, +- 0x03, 0x04, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x01, 0xFB, 0x00, 0x02, 0x03, 0x01, 0x01, 0xFB, +- 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x01, 0xFD, 0x00, 0x02, +- 0x03, 0x01, 0x01, 0xE3, 0x00, 0x02, 0x03, 0x04, 0x01, 0xFD, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, +- 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x09, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x09, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, +- 0x1E, 0xC1, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xBF, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xC5, 0x00, 0x02, +- 0x03, 0x03, 0x1E, 0xC3, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xC7, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xC1, +- 0x00, 0x02, 0x03, 0x40, 0x1E, 0xBF, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0x1E, 0x2F, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x2F, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, +- 0x1E, 0xDD, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xDB, 0x00, 0x02, 0x03, 0x1B, +- 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, +- 0x1E, 0xD3, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xD1, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xD7, 0x00, 0x02, +- 0x03, 0x03, 0x1E, 0xD5, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xD9, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xD3, +- 0x00, 0x02, 0x03, 0x40, 0x1E, 0xD1, 0x00, 0x02, 0x03, 0x41, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, +- 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x1E, 0x4D, 0x00, 0x02, 0x03, 0x01, 0x02, 0x2D, 0x00, 0x02, +- 0x03, 0x04, 0x1E, 0x4F, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xE1, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0x4D, +- 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x02, 0x2B, 0x00, 0x02, 0x03, 0x04, 0x00, 0x02, +- 0x00, 0x06, 0x00, 0x0C, 0x01, 0xFF, 0x00, 0x02, 0x03, 0x01, 0x01, 0xFF, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x01, 0x00, 0x04, 0x1E, 0xEB, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xE9, +- 0x00, 0x02, 0x03, 0x1B, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, +- 0x00, 0x2C, 0x01, 0xDC, 0x00, 0x02, 0x03, 0x00, 0x01, 0xD8, 0x00, 0x02, 0x03, 0x01, 0x01, 0xD6, +- 0x00, 0x02, 0x03, 0x04, 0x01, 0xDA, 0x00, 0x02, 0x03, 0x0C, 0x01, 0xDC, 0x00, 0x02, 0x03, 0x40, +- 0x01, 0xD8, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, +- 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xB0, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xAE, 0x00, 0x02, +- 0x03, 0x01, 0x1E, 0xB4, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xB2, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xB6, +- 0x00, 0x02, 0x03, 0x23, 0x1E, 0xB0, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xAE, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, +- 0x1E, 0xB1, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xAF, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xB5, 0x00, 0x02, +- 0x03, 0x03, 0x1E, 0xB3, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xB7, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xB1, +- 0x00, 0x02, 0x03, 0x40, 0x1E, 0xAF, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x08, +- 0x00, 0x02, 0x03, 0x27, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x09, 0x00, 0x02, 0x03, 0x27, 0x00, 0x04, +- 0x00, 0x0A, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x1E, 0x14, 0x00, 0x02, 0x03, 0x00, 0x1E, 0x16, +- 0x00, 0x02, 0x03, 0x01, 0x1E, 0x14, 0x00, 0x02, 0x03, 0x40, 0x1E, 0x16, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x04, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x1E, 0x15, 0x00, 0x02, 0x03, 0x00, +- 0x1E, 0x17, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x15, 0x00, 0x02, 0x03, 0x40, 0x1E, 0x17, 0x00, 0x02, +- 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x1C, 0x00, 0x02, 0x03, 0x27, 0x00, 0x01, 0x00, 0x04, +- 0x1E, 0x1D, 0x00, 0x02, 0x03, 0x27, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, +- 0x00, 0x24, 0x1E, 0x50, 0x00, 0x02, 0x03, 0x00, 0x1E, 0x52, 0x00, 0x02, 0x03, 0x01, 0x01, 0xEC, +- 0x00, 0x02, 0x03, 0x28, 0x1E, 0x50, 0x00, 0x02, 0x03, 0x40, 0x1E, 0x52, 0x00, 0x02, 0x03, 0x41, +- 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x1E, 0x51, 0x00, 0x02, +- 0x03, 0x00, 0x1E, 0x53, 0x00, 0x02, 0x03, 0x01, 0x01, 0xED, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x51, +- 0x00, 0x02, 0x03, 0x40, 0x1E, 0x53, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x64, +- 0x00, 0x02, 0x03, 0x07, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x65, 0x00, 0x02, 0x03, 0x07, 0x00, 0x01, +- 0x00, 0x04, 0x1E, 0x66, 0x00, 0x02, 0x03, 0x07, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x67, 0x00, 0x02, +- 0x03, 0x07, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x1E, 0x78, 0x00, 0x02, 0x03, 0x01, +- 0x1E, 0xEE, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0x78, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, +- 0x00, 0x0E, 0x00, 0x14, 0x1E, 0x79, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xEF, 0x00, 0x02, 0x03, 0x1B, +- 0x1E, 0x79, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x7A, 0x00, 0x02, 0x03, 0x08, +- 0x00, 0x01, 0x00, 0x04, 0x1E, 0x7B, 0x00, 0x02, 0x03, 0x08, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x9B, +- 0x00, 0x02, 0x03, 0x07, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, +- 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xDC, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xDA, 0x00, 0x02, 0x03, 0x01, +- 0x1E, 0xE0, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xDE, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xE2, 0x00, 0x02, +- 0x03, 0x23, 0x1E, 0xDC, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xDA, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, +- 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xDD, +- 0x00, 0x02, 0x03, 0x00, 0x1E, 0xDB, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xE1, 0x00, 0x02, 0x03, 0x03, +- 0x1E, 0xDF, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xE3, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xDD, 0x00, 0x02, +- 0x03, 0x40, 0x1E, 0xDB, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, +- 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xEA, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xE8, +- 0x00, 0x02, 0x03, 0x01, 0x1E, 0xEE, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xEC, 0x00, 0x02, 0x03, 0x09, +- 0x1E, 0xF0, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xEA, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xE8, 0x00, 0x02, ++ 0x1E, 0xEA, 0x00, 0x03, 0x03, 0x00, 0x03, 0x1B, 0x00, 0xD9, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xE8, ++ 0x00, 0x03, 0x03, 0x01, 0x03, 0x1B, 0x00, 0xDA, 0x00, 0x02, 0x03, 0x01, 0x00, 0xDB, 0x00, 0x02, ++ 0x03, 0x02, 0x1E, 0x78, 0x00, 0x03, 0x03, 0x03, 0x03, 0x01, 0x1E, 0xEE, 0x00, 0x03, 0x03, 0x03, ++ 0x03, 0x1B, 0x1E, 0x78, 0x00, 0x03, 0x03, 0x03, 0x03, 0x41, 0x01, 0x68, 0x00, 0x02, 0x03, 0x03, ++ 0x1E, 0x7A, 0x00, 0x03, 0x03, 0x04, 0x03, 0x08, 0x01, 0x6A, 0x00, 0x02, 0x03, 0x04, 0x01, 0x6C, ++ 0x00, 0x02, 0x03, 0x06, 0x01, 0xDB, 0x00, 0x03, 0x03, 0x08, 0x03, 0x00, 0x01, 0xD7, 0x00, 0x03, ++ 0x03, 0x08, 0x03, 0x01, 0x01, 0xD5, 0x00, 0x03, 0x03, 0x08, 0x03, 0x04, 0x01, 0xD9, 0x00, 0x03, ++ 0x03, 0x08, 0x03, 0x0C, 0x01, 0xDB, 0x00, 0x03, 0x03, 0x08, 0x03, 0x40, 0x01, 0xD7, 0x00, 0x03, ++ 0x03, 0x08, 0x03, 0x41, 0x00, 0xDC, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xEC, 0x00, 0x03, 0x03, 0x09, ++ 0x03, 0x1B, 0x1E, 0xE6, 0x00, 0x02, 0x03, 0x09, 0x01, 0x6E, 0x00, 0x02, 0x03, 0x0A, 0x01, 0x70, ++ 0x00, 0x02, 0x03, 0x0B, 0x01, 0xD3, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x14, 0x00, 0x02, 0x03, 0x0F, ++ 0x02, 0x16, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xEA, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x00, 0x1E, 0xE8, ++ 0x00, 0x03, 0x03, 0x1B, 0x03, 0x01, 0x1E, 0xEE, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x03, 0x1E, 0xEC, ++ 0x00, 0x03, 0x03, 0x1B, 0x03, 0x09, 0x1E, 0xF0, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x23, 0x1E, 0xEA, ++ 0x00, 0x03, 0x03, 0x1B, 0x03, 0x40, 0x1E, 0xE8, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x41, 0x01, 0xAF, ++ 0x00, 0x02, 0x03, 0x1B, 0x1E, 0xF0, 0x00, 0x03, 0x03, 0x23, 0x03, 0x1B, 0x1E, 0xE4, 0x00, 0x02, ++ 0x03, 0x23, 0x1E, 0x72, 0x00, 0x02, 0x03, 0x24, 0x01, 0x72, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x76, ++ 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x74, 0x00, 0x02, 0x03, 0x30, 0x1E, 0xEA, 0x00, 0x03, 0x03, 0x40, ++ 0x03, 0x1B, 0x00, 0xD9, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xE8, 0x00, 0x03, 0x03, 0x41, 0x03, 0x1B, ++ 0x00, 0xDA, 0x00, 0x02, 0x03, 0x41, 0x01, 0xD7, 0x00, 0x02, 0x03, 0x44, 0x00, 0x02, 0x00, 0x06, ++ 0x00, 0x0C, 0x1E, 0x7C, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x7E, 0x00, 0x02, 0x03, 0x23, 0x00, 0x08, ++ 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, ++ 0x1E, 0x80, 0x00, 0x02, 0x03, 0x00, 0x1E, 0x82, 0x00, 0x02, 0x03, 0x01, 0x01, 0x74, 0x00, 0x02, ++ 0x03, 0x02, 0x1E, 0x86, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x84, 0x00, 0x02, 0x03, 0x08, 0x1E, 0x88, ++ 0x00, 0x02, 0x03, 0x23, 0x1E, 0x80, 0x00, 0x02, 0x03, 0x40, 0x1E, 0x82, 0x00, 0x02, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x8A, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x8C, 0x00, 0x02, ++ 0x03, 0x08, 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, ++ 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, 0x00, 0x4E, 0x00, 0x54, 0x1E, 0xF2, 0x00, 0x02, 0x03, 0x00, ++ 0x00, 0xDD, 0x00, 0x02, 0x03, 0x01, 0x01, 0x76, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xF8, 0x00, 0x02, ++ 0x03, 0x03, 0x02, 0x32, 0x00, 0x02, 0x03, 0x04, 0x1E, 0x8E, 0x00, 0x02, 0x03, 0x07, 0x01, 0x78, ++ 0x00, 0x02, 0x03, 0x08, 0x1E, 0xF6, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xF4, 0x00, 0x02, 0x03, 0x23, ++ 0x1E, 0xF2, 0x00, 0x02, 0x03, 0x40, 0x00, 0xDD, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, ++ 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x01, 0x79, 0x00, 0x02, ++ 0x03, 0x01, 0x1E, 0x90, 0x00, 0x02, 0x03, 0x02, 0x01, 0x7B, 0x00, 0x02, 0x03, 0x07, 0x01, 0x7D, ++ 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x92, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x94, 0x00, 0x02, 0x03, 0x31, ++ 0x01, 0x79, 0x00, 0x02, 0x03, 0x41, 0x00, 0x26, 0x00, 0x4E, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x62, ++ 0x00, 0x6A, 0x00, 0x72, 0x00, 0x7A, 0x00, 0x82, 0x00, 0x8A, 0x00, 0x92, 0x00, 0x98, 0x00, 0x9E, ++ 0x00, 0xA4, 0x00, 0xAC, 0x00, 0xB4, 0x00, 0xBC, 0x00, 0xC4, 0x00, 0xCC, 0x00, 0xD4, 0x00, 0xDC, ++ 0x00, 0xE2, 0x00, 0xEA, 0x00, 0xF0, 0x00, 0xF8, 0x00, 0xFE, 0x01, 0x04, 0x01, 0x0C, 0x01, 0x14, ++ 0x01, 0x1A, 0x01, 0x20, 0x01, 0x26, 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x42, 0x01, 0x48, ++ 0x01, 0x4E, 0x01, 0x54, 0x00, 0xE0, 0x00, 0x02, 0x03, 0x00, 0x00, 0xE1, 0x00, 0x02, 0x03, 0x01, ++ 0x1E, 0xA7, 0x00, 0x03, 0x03, 0x02, 0x03, 0x00, 0x1E, 0xA5, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, ++ 0x1E, 0xAB, 0x00, 0x03, 0x03, 0x02, 0x03, 0x03, 0x1E, 0xA9, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, ++ 0x1E, 0xAD, 0x00, 0x03, 0x03, 0x02, 0x03, 0x23, 0x1E, 0xA7, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, ++ 0x1E, 0xA5, 0x00, 0x03, 0x03, 0x02, 0x03, 0x41, 0x00, 0xE2, 0x00, 0x02, 0x03, 0x02, 0x00, 0xE3, ++ 0x00, 0x02, 0x03, 0x03, 0x01, 0x01, 0x00, 0x02, 0x03, 0x04, 0x1E, 0xB1, 0x00, 0x03, 0x03, 0x06, ++ 0x03, 0x00, 0x1E, 0xAF, 0x00, 0x03, 0x03, 0x06, 0x03, 0x01, 0x1E, 0xB5, 0x00, 0x03, 0x03, 0x06, ++ 0x03, 0x03, 0x1E, 0xB3, 0x00, 0x03, 0x03, 0x06, 0x03, 0x09, 0x1E, 0xB7, 0x00, 0x03, 0x03, 0x06, ++ 0x03, 0x23, 0x1E, 0xB1, 0x00, 0x03, 0x03, 0x06, 0x03, 0x40, 0x1E, 0xAF, 0x00, 0x03, 0x03, 0x06, ++ 0x03, 0x41, 0x01, 0x03, 0x00, 0x02, 0x03, 0x06, 0x01, 0xE1, 0x00, 0x03, 0x03, 0x07, 0x03, 0x04, ++ 0x02, 0x27, 0x00, 0x02, 0x03, 0x07, 0x01, 0xDF, 0x00, 0x03, 0x03, 0x08, 0x03, 0x04, 0x00, 0xE4, ++ 0x00, 0x02, 0x03, 0x08, 0x1E, 0xA3, 0x00, 0x02, 0x03, 0x09, 0x01, 0xFB, 0x00, 0x03, 0x03, 0x0A, ++ 0x03, 0x01, 0x01, 0xFB, 0x00, 0x03, 0x03, 0x0A, 0x03, 0x41, 0x00, 0xE5, 0x00, 0x02, 0x03, 0x0A, ++ 0x01, 0xCE, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x01, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x03, 0x00, 0x02, ++ 0x03, 0x11, 0x1E, 0xAD, 0x00, 0x03, 0x03, 0x23, 0x03, 0x02, 0x1E, 0xB7, 0x00, 0x03, 0x03, 0x23, ++ 0x03, 0x06, 0x1E, 0xA1, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x01, 0x00, 0x02, 0x03, 0x25, 0x01, 0x05, ++ 0x00, 0x02, 0x03, 0x28, 0x00, 0xE0, 0x00, 0x02, 0x03, 0x40, 0x00, 0xE1, 0x00, 0x02, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x1E, 0x03, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x05, ++ 0x00, 0x02, 0x03, 0x23, 0x1E, 0x07, 0x00, 0x02, 0x03, 0x31, 0x00, 0x0A, 0x00, 0x16, 0x00, 0x1E, ++ 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x54, ++ 0x1E, 0x09, 0x00, 0x03, 0x03, 0x01, 0x03, 0x27, 0x01, 0x07, 0x00, 0x02, 0x03, 0x01, 0x01, 0x09, ++ 0x00, 0x02, 0x03, 0x02, 0x01, 0x0B, 0x00, 0x02, 0x03, 0x07, 0x01, 0x0D, 0x00, 0x02, 0x03, 0x0C, ++ 0x1E, 0x09, 0x00, 0x03, 0x03, 0x27, 0x03, 0x01, 0x1E, 0x09, 0x00, 0x03, 0x03, 0x27, 0x03, 0x41, ++ 0x00, 0xE7, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x09, 0x00, 0x03, 0x03, 0x41, 0x03, 0x27, 0x01, 0x07, ++ 0x00, 0x02, 0x03, 0x41, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, ++ 0x00, 0x2C, 0x1E, 0x0B, 0x00, 0x02, 0x03, 0x07, 0x01, 0x0F, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x0D, ++ 0x00, 0x02, 0x03, 0x23, 0x1E, 0x11, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x13, 0x00, 0x02, 0x03, 0x2D, ++ 0x1E, 0x0F, 0x00, 0x02, 0x03, 0x31, 0x00, 0x21, 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x58, ++ 0x00, 0x60, 0x00, 0x68, 0x00, 0x70, 0x00, 0x78, 0x00, 0x80, 0x00, 0x88, 0x00, 0x8E, 0x00, 0x94, ++ 0x00, 0x9C, 0x00, 0xA4, 0x00, 0xAC, 0x00, 0xB4, 0x00, 0xBA, 0x00, 0xC2, 0x00, 0xC8, 0x00, 0xCE, ++ 0x00, 0xD4, 0x00, 0xDA, 0x00, 0xE0, 0x00, 0xE6, 0x00, 0xEC, 0x00, 0xF4, 0x00, 0xFA, 0x01, 0x02, ++ 0x01, 0x08, 0x01, 0x0E, 0x01, 0x14, 0x01, 0x1A, 0x01, 0x20, 0x00, 0xE8, 0x00, 0x02, 0x03, 0x00, ++ 0x00, 0xE9, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xC1, 0x00, 0x03, 0x03, 0x02, 0x03, 0x00, 0x1E, 0xBF, ++ 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, 0x1E, 0xC5, 0x00, 0x03, 0x03, 0x02, 0x03, 0x03, 0x1E, 0xC3, ++ 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, 0x1E, 0xC7, 0x00, 0x03, 0x03, 0x02, 0x03, 0x23, 0x1E, 0xC1, ++ 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, 0x1E, 0xBF, 0x00, 0x03, 0x03, 0x02, 0x03, 0x41, 0x00, 0xEA, ++ 0x00, 0x02, 0x03, 0x02, 0x1E, 0xBD, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x15, 0x00, 0x03, 0x03, 0x04, ++ 0x03, 0x00, 0x1E, 0x17, 0x00, 0x03, 0x03, 0x04, 0x03, 0x01, 0x1E, 0x15, 0x00, 0x03, 0x03, 0x04, ++ 0x03, 0x40, 0x1E, 0x17, 0x00, 0x03, 0x03, 0x04, 0x03, 0x41, 0x01, 0x13, 0x00, 0x02, 0x03, 0x04, ++ 0x1E, 0x1D, 0x00, 0x03, 0x03, 0x06, 0x03, 0x27, 0x01, 0x15, 0x00, 0x02, 0x03, 0x06, 0x01, 0x17, ++ 0x00, 0x02, 0x03, 0x07, 0x00, 0xEB, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xBB, 0x00, 0x02, 0x03, 0x09, ++ 0x01, 0x1B, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x05, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x07, 0x00, 0x02, ++ 0x03, 0x11, 0x1E, 0xC7, 0x00, 0x03, 0x03, 0x23, 0x03, 0x02, 0x1E, 0xB9, 0x00, 0x02, 0x03, 0x23, ++ 0x1E, 0x1D, 0x00, 0x03, 0x03, 0x27, 0x03, 0x06, 0x02, 0x29, 0x00, 0x02, 0x03, 0x27, 0x01, 0x19, ++ 0x00, 0x02, 0x03, 0x28, 0x1E, 0x19, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x1B, 0x00, 0x02, 0x03, 0x30, ++ 0x00, 0xE8, 0x00, 0x02, 0x03, 0x40, 0x00, 0xE9, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, ++ 0x1E, 0x1F, 0x00, 0x02, 0x03, 0x07, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, ++ 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x01, 0xF5, 0x00, 0x02, 0x03, 0x01, 0x01, 0x1D, ++ 0x00, 0x02, 0x03, 0x02, 0x1E, 0x21, 0x00, 0x02, 0x03, 0x04, 0x01, 0x1F, 0x00, 0x02, 0x03, 0x06, ++ 0x01, 0x21, 0x00, 0x02, 0x03, 0x07, 0x01, 0xE7, 0x00, 0x02, 0x03, 0x0C, 0x01, 0x23, 0x00, 0x02, ++ 0x03, 0x27, 0x01, 0xF5, 0x00, 0x02, 0x03, 0x41, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, ++ 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x01, 0x25, 0x00, 0x02, 0x03, 0x02, ++ 0x1E, 0x23, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x27, 0x00, 0x02, 0x03, 0x08, 0x02, 0x1F, 0x00, 0x02, ++ 0x03, 0x0C, 0x1E, 0x25, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x29, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x2B, ++ 0x00, 0x02, 0x03, 0x2E, 0x1E, 0x96, 0x00, 0x02, 0x03, 0x31, 0x00, 0x13, 0x00, 0x28, 0x00, 0x2E, ++ 0x00, 0x34, 0x00, 0x3A, 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, 0x00, 0x62, ++ 0x00, 0x68, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x7A, 0x00, 0x80, 0x00, 0x86, 0x00, 0x8C, 0x00, 0x92, ++ 0x00, 0x98, 0x00, 0xEC, 0x00, 0x02, 0x03, 0x00, 0x00, 0xED, 0x00, 0x02, 0x03, 0x01, 0x00, 0xEE, ++ 0x00, 0x02, 0x03, 0x02, 0x01, 0x29, 0x00, 0x02, 0x03, 0x03, 0x01, 0x2B, 0x00, 0x02, 0x03, 0x04, ++ 0x01, 0x2D, 0x00, 0x02, 0x03, 0x06, 0x1E, 0x2F, 0x00, 0x03, 0x03, 0x08, 0x03, 0x01, 0x1E, 0x2F, ++ 0x00, 0x03, 0x03, 0x08, 0x03, 0x41, 0x00, 0xEF, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xC9, 0x00, 0x02, ++ 0x03, 0x09, 0x01, 0xD0, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x09, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x0B, ++ 0x00, 0x02, 0x03, 0x11, 0x1E, 0xCB, 0x00, 0x02, 0x03, 0x23, 0x01, 0x2F, 0x00, 0x02, 0x03, 0x28, ++ 0x1E, 0x2D, 0x00, 0x02, 0x03, 0x30, 0x00, 0xEC, 0x00, 0x02, 0x03, 0x40, 0x00, 0xED, 0x00, 0x02, ++ 0x03, 0x41, 0x1E, 0x2F, 0x00, 0x02, 0x03, 0x44, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x01, 0x35, ++ 0x00, 0x02, 0x03, 0x02, 0x01, 0xF0, 0x00, 0x02, 0x03, 0x0C, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, ++ 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x1E, 0x31, 0x00, 0x02, 0x03, 0x01, 0x01, 0xE9, ++ 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x33, 0x00, 0x02, 0x03, 0x23, 0x01, 0x37, 0x00, 0x02, 0x03, 0x27, ++ 0x1E, 0x35, 0x00, 0x02, 0x03, 0x31, 0x1E, 0x31, 0x00, 0x02, 0x03, 0x41, 0x00, 0x09, 0x00, 0x14, ++ 0x00, 0x1A, 0x00, 0x22, 0x00, 0x28, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, ++ 0x01, 0x3A, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x39, 0x00, 0x03, 0x03, 0x04, 0x03, 0x23, 0x01, 0x3E, ++ 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x39, 0x00, 0x03, 0x03, 0x23, 0x03, 0x04, 0x1E, 0x37, 0x00, 0x02, ++ 0x03, 0x23, 0x01, 0x3C, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x3D, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x3B, ++ 0x00, 0x02, 0x03, 0x31, 0x01, 0x3A, 0x00, 0x02, 0x03, 0x41, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x10, ++ 0x00, 0x16, 0x00, 0x1C, 0x1E, 0x3F, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x41, 0x00, 0x02, 0x03, 0x07, ++ 0x1E, 0x43, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x3F, 0x00, 0x02, 0x03, 0x41, 0x00, 0x0B, 0x00, 0x18, ++ 0x00, 0x1E, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x00, 0x42, 0x00, 0x48, ++ 0x00, 0x4E, 0x00, 0x54, 0x01, 0xF9, 0x00, 0x02, 0x03, 0x00, 0x01, 0x44, 0x00, 0x02, 0x03, 0x01, ++ 0x00, 0xF1, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x45, 0x00, 0x02, 0x03, 0x07, 0x01, 0x48, 0x00, 0x02, ++ 0x03, 0x0C, 0x1E, 0x47, 0x00, 0x02, 0x03, 0x23, 0x01, 0x46, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x4B, ++ 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x49, 0x00, 0x02, 0x03, 0x31, 0x01, 0xF9, 0x00, 0x02, 0x03, 0x40, ++ 0x01, 0x44, 0x00, 0x02, 0x03, 0x41, 0x00, 0x34, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x78, 0x00, 0x80, ++ 0x00, 0x86, 0x00, 0x8E, 0x00, 0x96, 0x00, 0x9E, 0x00, 0xA6, 0x00, 0xAE, 0x00, 0xB6, 0x00, 0xBE, ++ 0x00, 0xC4, 0x00, 0xCC, 0x00, 0xD4, 0x00, 0xDC, 0x00, 0xE4, 0x00, 0xEC, 0x00, 0xF2, 0x00, 0xFA, ++ 0x01, 0x02, 0x01, 0x0A, 0x01, 0x12, 0x01, 0x1A, 0x01, 0x20, 0x01, 0x26, 0x01, 0x2E, 0x01, 0x34, ++ 0x01, 0x3C, 0x01, 0x42, 0x01, 0x4A, 0x01, 0x50, 0x01, 0x56, 0x01, 0x5C, 0x01, 0x62, 0x01, 0x68, ++ 0x01, 0x70, 0x01, 0x78, 0x01, 0x80, 0x01, 0x88, 0x01, 0x90, 0x01, 0x98, 0x01, 0xA0, 0x01, 0xA6, ++ 0x01, 0xAE, 0x01, 0xB6, 0x01, 0xBC, 0x01, 0xC4, 0x01, 0xCA, 0x01, 0xD2, 0x01, 0xD8, 0x01, 0xE0, ++ 0x1E, 0xDD, 0x00, 0x03, 0x03, 0x00, 0x03, 0x1B, 0x00, 0xF2, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xDB, ++ 0x00, 0x03, 0x03, 0x01, 0x03, 0x1B, 0x00, 0xF3, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xD3, 0x00, 0x03, ++ 0x03, 0x02, 0x03, 0x00, 0x1E, 0xD1, 0x00, 0x03, 0x03, 0x02, 0x03, 0x01, 0x1E, 0xD7, 0x00, 0x03, ++ 0x03, 0x02, 0x03, 0x03, 0x1E, 0xD5, 0x00, 0x03, 0x03, 0x02, 0x03, 0x09, 0x1E, 0xD9, 0x00, 0x03, ++ 0x03, 0x02, 0x03, 0x23, 0x1E, 0xD3, 0x00, 0x03, 0x03, 0x02, 0x03, 0x40, 0x1E, 0xD1, 0x00, 0x03, ++ 0x03, 0x02, 0x03, 0x41, 0x00, 0xF4, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x4D, 0x00, 0x03, 0x03, 0x03, ++ 0x03, 0x01, 0x02, 0x2D, 0x00, 0x03, 0x03, 0x03, 0x03, 0x04, 0x1E, 0x4F, 0x00, 0x03, 0x03, 0x03, ++ 0x03, 0x08, 0x1E, 0xE1, 0x00, 0x03, 0x03, 0x03, 0x03, 0x1B, 0x1E, 0x4D, 0x00, 0x03, 0x03, 0x03, ++ 0x03, 0x41, 0x00, 0xF5, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x51, 0x00, 0x03, 0x03, 0x04, 0x03, 0x00, ++ 0x1E, 0x53, 0x00, 0x03, 0x03, 0x04, 0x03, 0x01, 0x01, 0xED, 0x00, 0x03, 0x03, 0x04, 0x03, 0x28, ++ 0x1E, 0x51, 0x00, 0x03, 0x03, 0x04, 0x03, 0x40, 0x1E, 0x53, 0x00, 0x03, 0x03, 0x04, 0x03, 0x41, ++ 0x01, 0x4D, 0x00, 0x02, 0x03, 0x04, 0x01, 0x4F, 0x00, 0x02, 0x03, 0x06, 0x02, 0x31, 0x00, 0x03, ++ 0x03, 0x07, 0x03, 0x04, 0x02, 0x2F, 0x00, 0x02, 0x03, 0x07, 0x02, 0x2B, 0x00, 0x03, 0x03, 0x08, ++ 0x03, 0x04, 0x00, 0xF6, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xDF, 0x00, 0x03, 0x03, 0x09, 0x03, 0x1B, ++ 0x1E, 0xCF, 0x00, 0x02, 0x03, 0x09, 0x01, 0x51, 0x00, 0x02, 0x03, 0x0B, 0x01, 0xD2, 0x00, 0x02, ++ 0x03, 0x0C, 0x02, 0x0D, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x0F, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xDD, ++ 0x00, 0x03, 0x03, 0x1B, 0x03, 0x00, 0x1E, 0xDB, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x01, 0x1E, 0xE1, ++ 0x00, 0x03, 0x03, 0x1B, 0x03, 0x03, 0x1E, 0xDF, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x09, 0x1E, 0xE3, ++ 0x00, 0x03, 0x03, 0x1B, 0x03, 0x23, 0x1E, 0xDD, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x40, 0x1E, 0xDB, ++ 0x00, 0x03, 0x03, 0x1B, 0x03, 0x41, 0x01, 0xA1, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0xD9, 0x00, 0x03, ++ 0x03, 0x23, 0x03, 0x02, 0x1E, 0xE3, 0x00, 0x03, 0x03, 0x23, 0x03, 0x1B, 0x1E, 0xCD, 0x00, 0x02, ++ 0x03, 0x23, 0x01, 0xED, 0x00, 0x03, 0x03, 0x28, 0x03, 0x04, 0x01, 0xEB, 0x00, 0x02, 0x03, 0x28, ++ 0x1E, 0xDD, 0x00, 0x03, 0x03, 0x40, 0x03, 0x1B, 0x00, 0xF2, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xDB, ++ 0x00, 0x03, 0x03, 0x41, 0x03, 0x1B, 0x00, 0xF3, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, ++ 0x00, 0x0E, 0x00, 0x14, 0x1E, 0x55, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x57, 0x00, 0x02, 0x03, 0x07, ++ 0x1E, 0x55, 0x00, 0x02, 0x03, 0x41, 0x00, 0x0B, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x26, 0x00, 0x2C, ++ 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x01, 0x55, ++ 0x00, 0x02, 0x03, 0x01, 0x1E, 0x5D, 0x00, 0x03, 0x03, 0x04, 0x03, 0x23, 0x1E, 0x59, 0x00, 0x02, ++ 0x03, 0x07, 0x01, 0x59, 0x00, 0x02, 0x03, 0x0C, 0x02, 0x11, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x13, ++ 0x00, 0x02, 0x03, 0x11, 0x1E, 0x5D, 0x00, 0x03, 0x03, 0x23, 0x03, 0x04, 0x1E, 0x5B, 0x00, 0x02, ++ 0x03, 0x23, 0x01, 0x57, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x5F, 0x00, 0x02, 0x03, 0x31, 0x01, 0x55, ++ 0x00, 0x02, 0x03, 0x41, 0x00, 0x0D, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x38, ++ 0x00, 0x3E, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5A, 0x00, 0x60, 0x00, 0x66, 0x00, 0x6E, ++ 0x1E, 0x65, 0x00, 0x03, 0x03, 0x01, 0x03, 0x07, 0x01, 0x5B, 0x00, 0x02, 0x03, 0x01, 0x01, 0x5D, ++ 0x00, 0x02, 0x03, 0x02, 0x1E, 0x69, 0x00, 0x03, 0x03, 0x07, 0x03, 0x23, 0x1E, 0x61, 0x00, 0x02, ++ 0x03, 0x07, 0x1E, 0x67, 0x00, 0x03, 0x03, 0x0C, 0x03, 0x07, 0x01, 0x61, 0x00, 0x02, 0x03, 0x0C, ++ 0x1E, 0x69, 0x00, 0x03, 0x03, 0x23, 0x03, 0x07, 0x1E, 0x63, 0x00, 0x02, 0x03, 0x23, 0x02, 0x19, ++ 0x00, 0x02, 0x03, 0x26, 0x01, 0x5F, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x65, 0x00, 0x03, 0x03, 0x41, ++ 0x03, 0x07, 0x01, 0x5B, 0x00, 0x02, 0x03, 0x41, 0x00, 0x08, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, ++ 0x00, 0x24, 0x00, 0x2A, 0x00, 0x30, 0x00, 0x36, 0x00, 0x3C, 0x1E, 0x6B, 0x00, 0x02, 0x03, 0x07, ++ 0x1E, 0x97, 0x00, 0x02, 0x03, 0x08, 0x01, 0x65, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x6D, 0x00, 0x02, ++ 0x03, 0x23, 0x02, 0x1B, 0x00, 0x02, 0x03, 0x26, 0x01, 0x63, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x71, ++ 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x6F, 0x00, 0x02, 0x03, 0x31, 0x00, 0x2D, 0x00, 0x5C, 0x00, 0x64, ++ 0x00, 0x6A, 0x00, 0x72, 0x00, 0x78, 0x00, 0x7E, 0x00, 0x86, 0x00, 0x8E, 0x00, 0x96, 0x00, 0x9C, ++ 0x00, 0xA4, 0x00, 0xAA, 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xC8, 0x00, 0xD0, 0x00, 0xD8, ++ 0x00, 0xE0, 0x00, 0xE6, 0x00, 0xEE, 0x00, 0xF4, 0x00, 0xFA, 0x01, 0x00, 0x01, 0x06, 0x01, 0x0C, ++ 0x01, 0x12, 0x01, 0x1A, 0x01, 0x22, 0x01, 0x2A, 0x01, 0x32, 0x01, 0x3A, 0x01, 0x42, 0x01, 0x4A, ++ 0x01, 0x50, 0x01, 0x58, 0x01, 0x5E, 0x01, 0x64, 0x01, 0x6A, 0x01, 0x70, 0x01, 0x76, 0x01, 0x7E, ++ 0x01, 0x84, 0x01, 0x8C, 0x01, 0x92, 0x1E, 0xEB, 0x00, 0x03, 0x03, 0x00, 0x03, 0x1B, 0x00, 0xF9, ++ 0x00, 0x02, 0x03, 0x00, 0x1E, 0xE9, 0x00, 0x03, 0x03, 0x01, 0x03, 0x1B, 0x00, 0xFA, 0x00, 0x02, ++ 0x03, 0x01, 0x00, 0xFB, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x79, 0x00, 0x03, 0x03, 0x03, 0x03, 0x01, ++ 0x1E, 0xEF, 0x00, 0x03, 0x03, 0x03, 0x03, 0x1B, 0x1E, 0x79, 0x00, 0x03, 0x03, 0x03, 0x03, 0x41, ++ 0x01, 0x69, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x7B, 0x00, 0x03, 0x03, 0x04, 0x03, 0x08, 0x01, 0x6B, ++ 0x00, 0x02, 0x03, 0x04, 0x01, 0x6D, 0x00, 0x02, 0x03, 0x06, 0x01, 0xDC, 0x00, 0x03, 0x03, 0x08, ++ 0x03, 0x00, 0x01, 0xD8, 0x00, 0x03, 0x03, 0x08, 0x03, 0x01, 0x01, 0xD6, 0x00, 0x03, 0x03, 0x08, ++ 0x03, 0x04, 0x01, 0xDA, 0x00, 0x03, 0x03, 0x08, 0x03, 0x0C, 0x01, 0xDC, 0x00, 0x03, 0x03, 0x08, ++ 0x03, 0x40, 0x01, 0xD8, 0x00, 0x03, 0x03, 0x08, 0x03, 0x41, 0x00, 0xFC, 0x00, 0x02, 0x03, 0x08, ++ 0x1E, 0xED, 0x00, 0x03, 0x03, 0x09, 0x03, 0x1B, 0x1E, 0xE7, 0x00, 0x02, 0x03, 0x09, 0x01, 0x6F, ++ 0x00, 0x02, 0x03, 0x0A, 0x01, 0x71, 0x00, 0x02, 0x03, 0x0B, 0x01, 0xD4, 0x00, 0x02, 0x03, 0x0C, ++ 0x02, 0x15, 0x00, 0x02, 0x03, 0x0F, 0x02, 0x17, 0x00, 0x02, 0x03, 0x11, 0x1E, 0xEB, 0x00, 0x03, ++ 0x03, 0x1B, 0x03, 0x00, 0x1E, 0xE9, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x01, 0x1E, 0xEF, 0x00, 0x03, ++ 0x03, 0x1B, 0x03, 0x03, 0x1E, 0xED, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x09, 0x1E, 0xF1, 0x00, 0x03, ++ 0x03, 0x1B, 0x03, 0x23, 0x1E, 0xEB, 0x00, 0x03, 0x03, 0x1B, 0x03, 0x40, 0x1E, 0xE9, 0x00, 0x03, ++ 0x03, 0x1B, 0x03, 0x41, 0x01, 0xB0, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0xF1, 0x00, 0x03, 0x03, 0x23, ++ 0x03, 0x1B, 0x1E, 0xE5, 0x00, 0x02, 0x03, 0x23, 0x1E, 0x73, 0x00, 0x02, 0x03, 0x24, 0x01, 0x73, ++ 0x00, 0x02, 0x03, 0x28, 0x1E, 0x77, 0x00, 0x02, 0x03, 0x2D, 0x1E, 0x75, 0x00, 0x02, 0x03, 0x30, ++ 0x1E, 0xEB, 0x00, 0x03, 0x03, 0x40, 0x03, 0x1B, 0x00, 0xF9, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xE9, ++ 0x00, 0x03, 0x03, 0x41, 0x03, 0x1B, 0x00, 0xFA, 0x00, 0x02, 0x03, 0x41, 0x01, 0xD8, 0x00, 0x02, ++ 0x03, 0x44, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x7D, 0x00, 0x02, 0x03, 0x03, 0x1E, 0x7F, ++ 0x00, 0x02, 0x03, 0x23, 0x00, 0x09, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, ++ 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, 0x00, 0x44, 0x1E, 0x81, 0x00, 0x02, 0x03, 0x00, 0x1E, 0x83, ++ 0x00, 0x02, 0x03, 0x01, 0x01, 0x75, 0x00, 0x02, 0x03, 0x02, 0x1E, 0x87, 0x00, 0x02, 0x03, 0x07, ++ 0x1E, 0x85, 0x00, 0x02, 0x03, 0x08, 0x1E, 0x98, 0x00, 0x02, 0x03, 0x0A, 0x1E, 0x89, 0x00, 0x02, ++ 0x03, 0x23, 0x1E, 0x81, 0x00, 0x02, 0x03, 0x40, 0x1E, 0x83, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, ++ 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x8B, 0x00, 0x02, 0x03, 0x07, 0x1E, 0x8D, 0x00, 0x02, 0x03, 0x08, ++ 0x00, 0x0C, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x38, 0x00, 0x3E, ++ 0x00, 0x44, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x56, 0x00, 0x5C, 0x1E, 0xF3, 0x00, 0x02, 0x03, 0x00, ++ 0x00, 0xFD, 0x00, 0x02, 0x03, 0x01, 0x01, 0x77, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xF9, 0x00, 0x02, ++ 0x03, 0x03, 0x02, 0x33, 0x00, 0x02, 0x03, 0x04, 0x1E, 0x8F, 0x00, 0x02, 0x03, 0x07, 0x00, 0xFF, ++ 0x00, 0x02, 0x03, 0x08, 0x1E, 0xF7, 0x00, 0x02, 0x03, 0x09, 0x1E, 0x99, 0x00, 0x02, 0x03, 0x0A, ++ 0x1E, 0xF5, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xF3, 0x00, 0x02, 0x03, 0x40, 0x00, 0xFD, 0x00, 0x02, + 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, +- 0x00, 0x34, 0x1E, 0xEB, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xE9, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xEF, +- 0x00, 0x02, 0x03, 0x03, 0x1E, 0xED, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xF1, 0x00, 0x02, 0x03, 0x23, +- 0x1E, 0xEB, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xE9, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, +- 0x01, 0xEE, 0x00, 0x02, 0x03, 0x0C, 0x00, 0x01, 0x00, 0x04, 0x01, 0xEC, 0x00, 0x02, 0x03, 0x04, +- 0x00, 0x01, 0x00, 0x04, 0x01, 0xED, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x01, 0xE0, +- 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x01, 0xE1, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, +- 0x00, 0x04, 0x1E, 0x1C, 0x00, 0x02, 0x03, 0x06, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x1D, 0x00, 0x02, +- 0x03, 0x06, 0x00, 0x01, 0x00, 0x04, 0x02, 0x30, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, +- 0x02, 0x31, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x01, 0xEF, 0x00, 0x02, 0x03, 0x0C, +- 0x00, 0x01, 0x00, 0x04, 0x1E, 0x38, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x39, +- 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x5C, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, +- 0x00, 0x04, 0x1E, 0x5D, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x68, 0x00, 0x02, +- 0x03, 0x23, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x69, 0x00, 0x02, 0x03, 0x23, 0x00, 0x01, 0x00, 0x04, +- 0x1E, 0x68, 0x00, 0x02, 0x03, 0x07, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x69, 0x00, 0x02, 0x03, 0x07, +- 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0xAC, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xB6, 0x00, 0x02, +- 0x03, 0x06, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0xAD, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xB7, +- 0x00, 0x02, 0x03, 0x06, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xC6, 0x00, 0x02, 0x03, 0x02, 0x00, 0x01, +- 0x00, 0x04, 0x1E, 0xC7, 0x00, 0x02, 0x03, 0x02, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0xD8, +- 0x00, 0x02, 0x03, 0x02, 0x1E, 0xE2, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0x1E, 0xD9, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xE3, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, +- 0x1E, 0xDE, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xDF, 0x00, 0x02, 0x03, 0x1B, +- 0x00, 0x01, 0x00, 0x04, 0x1E, 0xF0, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xF1, +- 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xEC, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, +- 0x00, 0x04, 0x1E, 0xED, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, +- 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x1E, 0x30, 0x00, 0x02, 0x03, 0x01, 0x01, 0xE8, 0x00, 0x02, +- 0x03, 0x0C, 0x1E, 0x32, 0x00, 0x02, 0x03, 0x23, 0x01, 0x36, 0x00, 0x02, 0x03, 0x27, 0x1E, 0x34, +- 0x00, 0x02, 0x03, 0x31, 0x1E, 0x30, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0x01, 0xFA, 0x00, 0x02, 0x03, 0x01, 0x01, 0xFA, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x89, +- 0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x47, 0x00, 0x48, +- 0x00, 0x49, 0x00, 0x4A, 0x00, 0x4B, 0x00, 0x4C, 0x00, 0x4D, 0x00, 0x4E, 0x00, 0x4F, 0x00, 0x50, +- 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0x57, 0x00, 0x58, 0x00, 0x59, +- 0x00, 0x5A, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00, 0x67, +- 0x00, 0x68, 0x00, 0x69, 0x00, 0x6A, 0x00, 0x6B, 0x00, 0x6C, 0x00, 0x6D, 0x00, 0x6E, 0x00, 0x6F, +- 0x00, 0x70, 0x00, 0x72, 0x00, 0x73, 0x00, 0x74, 0x00, 0x75, 0x00, 0x76, 0x00, 0x77, 0x00, 0x78, +- 0x00, 0x79, 0x00, 0x7A, 0x00, 0xC2, 0x00, 0xC4, 0x00, 0xC5, 0x00, 0xC6, 0x00, 0xC7, 0x00, 0xCA, +- 0x00, 0xCF, 0x00, 0xD2, 0x00, 0xD3, 0x00, 0xD4, 0x00, 0xD5, 0x00, 0xD6, 0x00, 0xD8, 0x00, 0xD9, +- 0x00, 0xDA, 0x00, 0xDC, 0x00, 0xE2, 0x00, 0xE4, 0x00, 0xE5, 0x00, 0xE6, 0x00, 0xE7, 0x00, 0xEA, +- 0x00, 0xEF, 0x00, 0xF2, 0x00, 0xF3, 0x00, 0xF4, 0x00, 0xF5, 0x00, 0xF6, 0x00, 0xF8, 0x00, 0xF9, +- 0x00, 0xFA, 0x00, 0xFC, 0x01, 0x02, 0x01, 0x03, 0x01, 0x06, 0x01, 0x07, 0x01, 0x12, 0x01, 0x13, +- 0x01, 0x14, 0x01, 0x15, 0x01, 0x4C, 0x01, 0x4D, 0x01, 0x5A, 0x01, 0x5B, 0x01, 0x60, 0x01, 0x61, +- 0x01, 0x68, 0x01, 0x69, 0x01, 0x6A, 0x01, 0x6B, 0x01, 0x7F, 0x01, 0xA0, 0x01, 0xA1, 0x01, 0xAF, +- 0x01, 0xB0, 0x01, 0xB7, 0x01, 0xEA, 0x01, 0xEB, 0x02, 0x26, 0x02, 0x27, 0x02, 0x28, 0x02, 0x29, +- 0x02, 0x2E, 0x02, 0x2F, 0x02, 0x92, 0x1E, 0x36, 0x1E, 0x37, 0x1E, 0x5A, 0x1E, 0x5B, 0x1E, 0x60, +- 0x1E, 0x61, 0x1E, 0x62, 0x1E, 0x63, 0x1E, 0xA0, 0x1E, 0xA1, 0x1E, 0xB8, 0x1E, 0xB9, 0x1E, 0xCC, +- 0x1E, 0xCD, 0x1E, 0xCE, 0x1E, 0xCF, 0x1E, 0xE4, 0x1E, 0xE5, 0x1E, 0xE6, 0x1E, 0xE7, 0x21, 0x2A, +- 0x21, 0x2B, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x14, 0x13, 0x92, 0x1A, 0xA8, 0x1E, 0x46, +- 0x21, 0xB8, 0x22, 0x76, 0x23, 0x04, 0x00, 0x01, 0x0F, 0x96, 0x01, 0xF2, 0x03, 0xEA, 0x03, 0xF0, +- 0x03, 0xF6, 0x03, 0xFC, 0x04, 0x02, 0x04, 0x08, 0x04, 0x0E, 0x04, 0x14, 0x04, 0x1A, 0x04, 0x20, +- 0x04, 0x26, 0x04, 0x2C, 0x04, 0x32, 0x04, 0x38, 0x04, 0x3E, 0x04, 0x44, 0x04, 0x4A, 0x04, 0x50, +- 0x04, 0x56, 0x04, 0x5C, 0x04, 0x62, 0x04, 0x68, 0x04, 0x6E, 0x04, 0x74, 0x04, 0x7A, 0x04, 0x80, +- 0x04, 0x86, 0x04, 0x8C, 0x04, 0x92, 0x04, 0x98, 0x04, 0x9E, 0x04, 0xA4, 0x04, 0xAA, 0x04, 0xB0, +- 0x04, 0xB6, 0x04, 0xBC, 0x04, 0xC2, 0x04, 0xC8, 0x04, 0xCE, 0x04, 0xD4, 0x04, 0xDA, 0x04, 0xE0, +- 0x04, 0xE6, 0x04, 0xEC, 0x04, 0xF2, 0x04, 0xF8, 0x04, 0xFE, 0x05, 0x04, 0x05, 0x0A, 0x05, 0x10, +- 0x05, 0x16, 0x05, 0x1C, 0x05, 0x22, 0x05, 0x28, 0x05, 0x2E, 0x05, 0x34, 0x05, 0x3A, 0x05, 0x40, +- 0x05, 0x46, 0x05, 0x4C, 0x05, 0x52, 0x05, 0x58, 0x05, 0x5E, 0x05, 0x64, 0x05, 0x6A, 0x05, 0x70, +- 0x05, 0x76, 0x05, 0x7C, 0x05, 0x82, 0x05, 0x88, 0x05, 0x8E, 0x05, 0x94, 0x05, 0x9A, 0x05, 0xA0, +- 0x05, 0xA6, 0x05, 0xAC, 0x05, 0xB2, 0x05, 0xB8, 0x05, 0xBE, 0x05, 0xC4, 0x05, 0xCA, 0x05, 0xD0, +- 0x05, 0xD6, 0x05, 0xDC, 0x05, 0xE2, 0x05, 0xE8, 0x05, 0xEE, 0x05, 0xF4, 0x05, 0xFA, 0x06, 0x00, +- 0x06, 0x06, 0x06, 0x0C, 0x06, 0x12, 0x06, 0x18, 0x06, 0x1E, 0x06, 0x24, 0x06, 0x2A, 0x06, 0x30, +- 0x06, 0x36, 0x06, 0x3C, 0x06, 0x42, 0x06, 0x48, 0x06, 0x4E, 0x06, 0x54, 0x06, 0x5A, 0x06, 0x60, +- 0x06, 0x66, 0x06, 0x6C, 0x06, 0x72, 0x06, 0x78, 0x06, 0x7E, 0x06, 0x84, 0x06, 0x8A, 0x06, 0x90, +- 0x06, 0x96, 0x06, 0x9C, 0x06, 0xA2, 0x06, 0xA8, 0x06, 0xAE, 0x06, 0xB4, 0x06, 0xBA, 0x06, 0xC0, +- 0x06, 0xC6, 0x06, 0xCC, 0x06, 0xD2, 0x06, 0xD8, 0x06, 0xDE, 0x06, 0xE4, 0x06, 0xEA, 0x06, 0xF0, +- 0x06, 0xF6, 0x06, 0xFC, 0x07, 0x02, 0x07, 0x08, 0x07, 0x0E, 0x07, 0x14, 0x07, 0x1A, 0x07, 0x20, +- 0x07, 0x26, 0x07, 0x2C, 0x07, 0x32, 0x07, 0x38, 0x07, 0x3E, 0x07, 0x44, 0x07, 0x4A, 0x07, 0x50, +- 0x07, 0x56, 0x07, 0x5C, 0x07, 0x62, 0x07, 0x68, 0x07, 0x6E, 0x07, 0x74, 0x07, 0x7A, 0x07, 0x80, +- 0x07, 0x86, 0x07, 0x8C, 0x07, 0x92, 0x07, 0x98, 0x07, 0x9E, 0x07, 0xA4, 0x07, 0xAA, 0x07, 0xB0, +- 0x07, 0xB6, 0x07, 0xBC, 0x07, 0xC2, 0x07, 0xC8, 0x07, 0xCE, 0x07, 0xD4, 0x07, 0xDA, 0x07, 0xE0, +- 0x07, 0xE6, 0x07, 0xEC, 0x07, 0xF2, 0x07, 0xF8, 0x07, 0xFE, 0x08, 0x04, 0x08, 0x0A, 0x08, 0x10, +- 0x08, 0x16, 0x08, 0x1C, 0x08, 0x22, 0x08, 0x28, 0x08, 0x2E, 0x08, 0x34, 0x08, 0x3A, 0x08, 0x40, +- 0x08, 0x46, 0x08, 0x4C, 0x08, 0x52, 0x08, 0x58, 0x08, 0x5E, 0x08, 0x64, 0x08, 0x6A, 0x08, 0x70, +- 0x08, 0x76, 0x08, 0x7C, 0x08, 0x82, 0x08, 0x88, 0x08, 0x8E, 0x08, 0x94, 0x08, 0x9A, 0x08, 0xA0, +- 0x08, 0xA6, 0x08, 0xAC, 0x08, 0xB2, 0x08, 0xB8, 0x08, 0xBE, 0x08, 0xC4, 0x08, 0xCA, 0x08, 0xD0, +- 0x08, 0xD6, 0x08, 0xDC, 0x08, 0xE2, 0x08, 0xE8, 0x08, 0xEE, 0x08, 0xF4, 0x08, 0xFA, 0x09, 0x00, +- 0x09, 0x06, 0x09, 0x0C, 0x09, 0x12, 0x09, 0x18, 0x09, 0x1E, 0x09, 0x24, 0x09, 0x2A, 0x09, 0x30, +- 0x09, 0x36, 0x09, 0x3C, 0x09, 0x42, 0x09, 0x48, 0x09, 0x4E, 0x09, 0x54, 0x09, 0x5A, 0x09, 0x60, +- 0x09, 0x66, 0x09, 0x6C, 0x09, 0x72, 0x09, 0x78, 0x09, 0x7E, 0x09, 0x84, 0x09, 0x8A, 0x09, 0x90, +- 0x09, 0x96, 0x09, 0x9C, 0x09, 0xA2, 0x09, 0xA8, 0x09, 0xAE, 0x09, 0xB4, 0x09, 0xBA, 0x09, 0xC0, +- 0x09, 0xC6, 0x09, 0xCC, 0x09, 0xD2, 0x09, 0xD8, 0x09, 0xDE, 0x09, 0xE4, 0x09, 0xEA, 0x09, 0xF0, +- 0x09, 0xF6, 0x09, 0xFC, 0x0A, 0x02, 0x0A, 0x08, 0x0A, 0x0E, 0x0A, 0x14, 0x0A, 0x1A, 0x0A, 0x20, +- 0x0A, 0x26, 0x0A, 0x2C, 0x0A, 0x32, 0x0A, 0x38, 0x0A, 0x3E, 0x0A, 0x44, 0x0A, 0x4A, 0x0A, 0x50, +- 0x0A, 0x56, 0x0A, 0x5C, 0x0A, 0x62, 0x0A, 0x68, 0x0A, 0x6E, 0x0A, 0x74, 0x0A, 0x7A, 0x0A, 0x80, +- 0x0A, 0x86, 0x0A, 0x8C, 0x0A, 0x92, 0x0A, 0x98, 0x0A, 0x9E, 0x0A, 0xA4, 0x0A, 0xAA, 0x0A, 0xB0, +- 0x0A, 0xB6, 0x0A, 0xBC, 0x0A, 0xC2, 0x0A, 0xC8, 0x0A, 0xCE, 0x0A, 0xD4, 0x0A, 0xDA, 0x0A, 0xE0, +- 0x0A, 0xE6, 0x0A, 0xEC, 0x0A, 0xF2, 0x0A, 0xF8, 0x0A, 0xFE, 0x0B, 0x04, 0x0B, 0x0A, 0x0B, 0x10, +- 0x0B, 0x16, 0x0B, 0x1C, 0x0B, 0x22, 0x0B, 0x28, 0x0B, 0x2E, 0x0B, 0x34, 0x0B, 0x3A, 0x0B, 0x40, +- 0x0B, 0x46, 0x0B, 0x4C, 0x0B, 0x52, 0x0B, 0x58, 0x0B, 0x5E, 0x0B, 0x64, 0x0B, 0x6A, 0x0B, 0x70, +- 0x0B, 0x76, 0x0B, 0x7C, 0x0B, 0x82, 0x0B, 0x88, 0x0B, 0x8E, 0x0B, 0x94, 0x0B, 0x9A, 0x0B, 0xA0, +- 0x0B, 0xA6, 0x0B, 0xAC, 0x0B, 0xB2, 0x0B, 0xB8, 0x0B, 0xBE, 0x0B, 0xC4, 0x0B, 0xCA, 0x0B, 0xD0, +- 0x0B, 0xD6, 0x0B, 0xDC, 0x0B, 0xE2, 0x0B, 0xE8, 0x0B, 0xEE, 0x0B, 0xF4, 0x0B, 0xFA, 0x0C, 0x00, +- 0x0C, 0x06, 0x0C, 0x0C, 0x0C, 0x12, 0x0C, 0x18, 0x0C, 0x1E, 0x0C, 0x24, 0x0C, 0x2A, 0x0C, 0x30, +- 0x0C, 0x36, 0x0C, 0x3C, 0x0C, 0x42, 0x0C, 0x48, 0x0C, 0x4E, 0x0C, 0x54, 0x0C, 0x5A, 0x0C, 0x60, +- 0x0C, 0x66, 0x0C, 0x6C, 0x0C, 0x72, 0x0C, 0x78, 0x0C, 0x7E, 0x0C, 0x84, 0x0C, 0x8A, 0x0C, 0x90, +- 0x0C, 0x96, 0x0C, 0x9C, 0x0C, 0xA2, 0x0C, 0xA8, 0x0C, 0xAE, 0x0C, 0xB4, 0x0C, 0xBA, 0x0C, 0xC0, +- 0x0C, 0xC6, 0x0C, 0xCC, 0x0C, 0xD2, 0x0C, 0xD8, 0x0C, 0xDE, 0x0C, 0xE4, 0x0C, 0xEA, 0x0C, 0xF0, +- 0x0C, 0xF6, 0x0C, 0xFC, 0x0D, 0x02, 0x0D, 0x08, 0x0D, 0x0E, 0x0D, 0x14, 0x0D, 0x1A, 0x0D, 0x20, +- 0x0D, 0x26, 0x0D, 0x2C, 0x0D, 0x32, 0x0D, 0x38, 0x0D, 0x3E, 0x0D, 0x44, 0x0D, 0x4A, 0x0D, 0x50, +- 0x0D, 0x56, 0x0D, 0x5C, 0x0D, 0x62, 0x0D, 0x68, 0x0D, 0x6E, 0x0D, 0x74, 0x0D, 0x7A, 0x0D, 0x80, +- 0x0D, 0x86, 0x0D, 0x8C, 0x0D, 0x92, 0x0D, 0x98, 0x0D, 0x9E, 0x0D, 0xA4, 0x0D, 0xAA, 0x0D, 0xB0, +- 0x0D, 0xB6, 0x0D, 0xBC, 0x0D, 0xC2, 0x0D, 0xC8, 0x0D, 0xCE, 0x0D, 0xD4, 0x0D, 0xDA, 0x0D, 0xE0, +- 0x0D, 0xE6, 0x0D, 0xEC, 0x0D, 0xF2, 0x0D, 0xF8, 0x0D, 0xFE, 0x0E, 0x04, 0x0E, 0x0A, 0x0E, 0x10, +- 0x0E, 0x16, 0x0E, 0x1C, 0x0E, 0x22, 0x0E, 0x28, 0x0E, 0x2E, 0x0E, 0x34, 0x0E, 0x3A, 0x0E, 0x40, +- 0x0E, 0x46, 0x0E, 0x4C, 0x0E, 0x52, 0x0E, 0x58, 0x0E, 0x5E, 0x0E, 0x64, 0x0E, 0x6A, 0x0E, 0x70, +- 0x0E, 0x76, 0x0E, 0x7C, 0x0E, 0x82, 0x0E, 0x88, 0x0E, 0x8E, 0x0E, 0x94, 0x0E, 0x9A, 0x0E, 0xA0, +- 0x0E, 0xA6, 0x0E, 0xAC, 0x0E, 0xB2, 0x0E, 0xB8, 0x0E, 0xBE, 0x0E, 0xC4, 0x0E, 0xCA, 0x0E, 0xD0, +- 0x0E, 0xD6, 0x0E, 0xDC, 0x0E, 0xE2, 0x0E, 0xE8, 0x0E, 0xEE, 0x0E, 0xF4, 0x0E, 0xFA, 0x0F, 0x00, +- 0x0F, 0x06, 0x0F, 0x0C, 0x0F, 0x12, 0x0F, 0x18, 0x0F, 0x1E, 0x0F, 0x24, 0x0F, 0x2A, 0x0F, 0x30, +- 0x0F, 0x36, 0x0F, 0x3C, 0x0F, 0x42, 0x0F, 0x48, 0x0F, 0x4E, 0x0F, 0x54, 0x0F, 0x5A, 0x0F, 0x60, +- 0x0F, 0x66, 0x0F, 0x6C, 0x0F, 0x72, 0x0F, 0x78, 0x0F, 0x7E, 0x0F, 0x84, 0x0F, 0x8A, 0x0F, 0x90, +- 0x00, 0x02, 0x00, 0x41, 0x03, 0x00, 0x00, 0x02, 0x00, 0x41, 0x03, 0x01, 0x00, 0x02, 0x00, 0x41, +- 0x03, 0x02, 0x00, 0x02, 0x00, 0x41, 0x03, 0x03, 0x00, 0x02, 0x00, 0x41, 0x03, 0x08, 0x00, 0x02, +- 0x00, 0x41, 0x03, 0x0A, 0x00, 0x02, 0x00, 0x43, 0x03, 0x27, 0x00, 0x02, 0x00, 0x45, 0x03, 0x00, +- 0x00, 0x02, 0x00, 0x45, 0x03, 0x01, 0x00, 0x02, 0x00, 0x45, 0x03, 0x02, 0x00, 0x02, 0x00, 0x45, +- 0x03, 0x08, 0x00, 0x02, 0x00, 0x49, 0x03, 0x00, 0x00, 0x02, 0x00, 0x49, 0x03, 0x01, 0x00, 0x02, +- 0x00, 0x49, 0x03, 0x02, 0x00, 0x02, 0x00, 0x49, 0x03, 0x08, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x03, +- 0x00, 0x02, 0x00, 0x4F, 0x03, 0x00, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4F, +- 0x03, 0x02, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x03, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x08, 0x00, 0x02, +- 0x00, 0x55, 0x03, 0x00, 0x00, 0x02, 0x00, 0x55, 0x03, 0x01, 0x00, 0x02, 0x00, 0x55, 0x03, 0x02, +- 0x00, 0x02, 0x00, 0x55, 0x03, 0x08, 0x00, 0x02, 0x00, 0x59, 0x03, 0x01, 0x00, 0x02, 0x00, 0x61, +- 0x03, 0x00, 0x00, 0x02, 0x00, 0x61, 0x03, 0x01, 0x00, 0x02, 0x00, 0x61, 0x03, 0x02, 0x00, 0x02, +- 0x00, 0x61, 0x03, 0x03, 0x00, 0x02, 0x00, 0x61, 0x03, 0x08, 0x00, 0x02, 0x00, 0x61, 0x03, 0x0A, +- 0x00, 0x02, 0x00, 0x63, 0x03, 0x27, 0x00, 0x02, 0x00, 0x65, 0x03, 0x00, 0x00, 0x02, 0x00, 0x65, +- 0x03, 0x01, 0x00, 0x02, 0x00, 0x65, 0x03, 0x02, 0x00, 0x02, 0x00, 0x65, 0x03, 0x08, 0x00, 0x02, +- 0x00, 0x69, 0x03, 0x00, 0x00, 0x02, 0x00, 0x69, 0x03, 0x01, 0x00, 0x02, 0x00, 0x69, 0x03, 0x02, +- 0x00, 0x02, 0x00, 0x69, 0x03, 0x08, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x03, 0x00, 0x02, 0x00, 0x6F, +- 0x03, 0x00, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x01, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x02, 0x00, 0x02, +- 0x00, 0x6F, 0x03, 0x03, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x08, 0x00, 0x02, 0x00, 0x75, 0x03, 0x00, +- 0x00, 0x02, 0x00, 0x75, 0x03, 0x01, 0x00, 0x02, 0x00, 0x75, 0x03, 0x02, 0x00, 0x02, 0x00, 0x75, +- 0x03, 0x08, 0x00, 0x02, 0x00, 0x79, 0x03, 0x01, 0x00, 0x02, 0x00, 0x79, 0x03, 0x08, 0x00, 0x02, +- 0x00, 0x41, 0x03, 0x04, 0x00, 0x02, 0x00, 0x61, 0x03, 0x04, 0x00, 0x02, 0x00, 0x41, 0x03, 0x06, +- 0x00, 0x02, 0x00, 0x61, 0x03, 0x06, 0x00, 0x02, 0x00, 0x41, 0x03, 0x28, 0x00, 0x02, 0x00, 0x61, +- 0x03, 0x28, 0x00, 0x02, 0x00, 0x43, 0x03, 0x01, 0x00, 0x02, 0x00, 0x63, 0x03, 0x01, 0x00, 0x02, +- 0x00, 0x43, 0x03, 0x02, 0x00, 0x02, 0x00, 0x63, 0x03, 0x02, 0x00, 0x02, 0x00, 0x43, 0x03, 0x07, +- 0x00, 0x02, 0x00, 0x63, 0x03, 0x07, 0x00, 0x02, 0x00, 0x43, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x63, +- 0x03, 0x0C, 0x00, 0x02, 0x00, 0x44, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x64, 0x03, 0x0C, 0x00, 0x02, +- 0x00, 0x45, 0x03, 0x04, 0x00, 0x02, 0x00, 0x65, 0x03, 0x04, 0x00, 0x02, 0x00, 0x45, 0x03, 0x06, +- 0x00, 0x02, 0x00, 0x65, 0x03, 0x06, 0x00, 0x02, 0x00, 0x45, 0x03, 0x07, 0x00, 0x02, 0x00, 0x65, +- 0x03, 0x07, 0x00, 0x02, 0x00, 0x45, 0x03, 0x28, 0x00, 0x02, 0x00, 0x65, 0x03, 0x28, 0x00, 0x02, +- 0x00, 0x45, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x65, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x47, 0x03, 0x02, +- 0x00, 0x02, 0x00, 0x67, 0x03, 0x02, 0x00, 0x02, 0x00, 0x47, 0x03, 0x06, 0x00, 0x02, 0x00, 0x67, +- 0x03, 0x06, 0x00, 0x02, 0x00, 0x47, 0x03, 0x07, 0x00, 0x02, 0x00, 0x67, 0x03, 0x07, 0x00, 0x02, +- 0x00, 0x47, 0x03, 0x27, 0x00, 0x02, 0x00, 0x67, 0x03, 0x27, 0x00, 0x02, 0x00, 0x48, 0x03, 0x02, +- 0x00, 0x02, 0x00, 0x68, 0x03, 0x02, 0x00, 0x02, 0x00, 0x49, 0x03, 0x03, 0x00, 0x02, 0x00, 0x69, +- 0x03, 0x03, 0x00, 0x02, 0x00, 0x49, 0x03, 0x04, 0x00, 0x02, 0x00, 0x69, 0x03, 0x04, 0x00, 0x02, +- 0x00, 0x49, 0x03, 0x06, 0x00, 0x02, 0x00, 0x69, 0x03, 0x06, 0x00, 0x02, 0x00, 0x49, 0x03, 0x28, +- 0x00, 0x02, 0x00, 0x69, 0x03, 0x28, 0x00, 0x02, 0x00, 0x49, 0x03, 0x07, 0x00, 0x02, 0x00, 0x4A, +- 0x03, 0x02, 0x00, 0x02, 0x00, 0x6A, 0x03, 0x02, 0x00, 0x02, 0x00, 0x4B, 0x03, 0x27, 0x00, 0x02, +- 0x00, 0x6B, 0x03, 0x27, 0x00, 0x02, 0x00, 0x4C, 0x03, 0x01, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x01, +- 0x00, 0x02, 0x00, 0x4C, 0x03, 0x27, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x27, 0x00, 0x02, 0x00, 0x4C, +- 0x03, 0x0C, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x01, 0x00, 0x02, +- 0x00, 0x6E, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x27, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x27, +- 0x00, 0x02, 0x00, 0x4E, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4F, +- 0x03, 0x04, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x04, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x06, 0x00, 0x02, +- 0x00, 0x6F, 0x03, 0x06, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x0B, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x0B, +- 0x00, 0x02, 0x00, 0x52, 0x03, 0x01, 0x00, 0x02, 0x00, 0x72, 0x03, 0x01, 0x00, 0x02, 0x00, 0x52, +- 0x03, 0x27, 0x00, 0x02, 0x00, 0x72, 0x03, 0x27, 0x00, 0x02, 0x00, 0x52, 0x03, 0x0C, 0x00, 0x02, +- 0x00, 0x72, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x53, 0x03, 0x01, 0x00, 0x02, 0x00, 0x73, 0x03, 0x01, +- 0x00, 0x02, 0x00, 0x53, 0x03, 0x02, 0x00, 0x02, 0x00, 0x73, 0x03, 0x02, 0x00, 0x02, 0x00, 0x53, +- 0x03, 0x27, 0x00, 0x02, 0x00, 0x73, 0x03, 0x27, 0x00, 0x02, 0x00, 0x53, 0x03, 0x0C, 0x00, 0x02, +- 0x00, 0x73, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x54, 0x03, 0x27, 0x00, 0x02, 0x00, 0x74, 0x03, 0x27, +- 0x00, 0x02, 0x00, 0x54, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x74, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x55, +- 0x03, 0x03, 0x00, 0x02, 0x00, 0x75, 0x03, 0x03, 0x00, 0x02, 0x00, 0x55, 0x03, 0x04, 0x00, 0x02, +- 0x00, 0x75, 0x03, 0x04, 0x00, 0x02, 0x00, 0x55, 0x03, 0x06, 0x00, 0x02, 0x00, 0x75, 0x03, 0x06, +- 0x00, 0x02, 0x00, 0x55, 0x03, 0x0A, 0x00, 0x02, 0x00, 0x75, 0x03, 0x0A, 0x00, 0x02, 0x00, 0x55, +- 0x03, 0x0B, 0x00, 0x02, 0x00, 0x75, 0x03, 0x0B, 0x00, 0x02, 0x00, 0x55, 0x03, 0x28, 0x00, 0x02, +- 0x00, 0x75, 0x03, 0x28, 0x00, 0x02, 0x00, 0x57, 0x03, 0x02, 0x00, 0x02, 0x00, 0x77, 0x03, 0x02, +- 0x00, 0x02, 0x00, 0x59, 0x03, 0x02, 0x00, 0x02, 0x00, 0x79, 0x03, 0x02, 0x00, 0x02, 0x00, 0x59, +- 0x03, 0x08, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x01, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x01, 0x00, 0x02, +- 0x00, 0x5A, 0x03, 0x07, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x07, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x0C, +- 0x00, 0x02, 0x00, 0x7A, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x1B, 0x00, 0x02, 0x00, 0x6F, +- 0x03, 0x1B, 0x00, 0x02, 0x00, 0x55, 0x03, 0x1B, 0x00, 0x02, 0x00, 0x75, 0x03, 0x1B, 0x00, 0x02, +- 0x00, 0x41, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x61, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x49, 0x03, 0x0C, +- 0x00, 0x02, 0x00, 0x69, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x6F, +- 0x03, 0x0C, 0x00, 0x02, 0x00, 0x55, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x75, 0x03, 0x0C, 0x00, 0x02, +- 0x00, 0xDC, 0x03, 0x04, 0x00, 0x02, 0x00, 0xFC, 0x03, 0x04, 0x00, 0x02, 0x00, 0x55, 0x03, 0x44, +- 0x00, 0x02, 0x00, 0x75, 0x03, 0x44, 0x00, 0x02, 0x00, 0xDC, 0x03, 0x0C, 0x00, 0x02, 0x00, 0xFC, +- 0x03, 0x0C, 0x00, 0x02, 0x00, 0xDC, 0x03, 0x00, 0x00, 0x02, 0x00, 0xFC, 0x03, 0x00, 0x00, 0x02, +- 0x00, 0xC4, 0x03, 0x04, 0x00, 0x02, 0x00, 0xE4, 0x03, 0x04, 0x00, 0x02, 0x02, 0x26, 0x03, 0x04, +- 0x00, 0x02, 0x02, 0x27, 0x03, 0x04, 0x00, 0x02, 0x00, 0xC6, 0x03, 0x04, 0x00, 0x02, 0x00, 0xE6, +- 0x03, 0x04, 0x00, 0x02, 0x00, 0x47, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x67, 0x03, 0x0C, 0x00, 0x02, +- 0x00, 0x4B, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x6B, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x28, +- 0x00, 0x02, 0x00, 0x6F, 0x03, 0x28, 0x00, 0x02, 0x01, 0x4C, 0x03, 0x28, 0x00, 0x02, 0x01, 0x4D, +- 0x03, 0x28, 0x00, 0x02, 0x01, 0xB7, 0x03, 0x0C, 0x00, 0x02, 0x02, 0x92, 0x03, 0x0C, 0x00, 0x02, +- 0x00, 0x6A, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x47, 0x03, 0x01, 0x00, 0x02, 0x00, 0x67, 0x03, 0x01, +- 0x00, 0x02, 0x00, 0x4E, 0x03, 0x00, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x00, 0x00, 0x02, 0x00, 0xC5, +- 0x03, 0x01, 0x00, 0x02, 0x00, 0xE5, 0x03, 0x01, 0x00, 0x02, 0x00, 0xC6, 0x03, 0x01, 0x00, 0x02, +- 0x00, 0xE6, 0x03, 0x01, 0x00, 0x02, 0x00, 0xD8, 0x03, 0x01, 0x00, 0x02, 0x00, 0xF8, 0x03, 0x01, +- 0x00, 0x02, 0x00, 0x41, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x61, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x41, +- 0x03, 0x11, 0x00, 0x02, 0x00, 0x61, 0x03, 0x11, 0x00, 0x02, 0x00, 0x45, 0x03, 0x0F, 0x00, 0x02, +- 0x00, 0x65, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x45, 0x03, 0x11, 0x00, 0x02, 0x00, 0x65, 0x03, 0x11, +- 0x00, 0x02, 0x00, 0x49, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x69, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x49, +- 0x03, 0x11, 0x00, 0x02, 0x00, 0x69, 0x03, 0x11, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x0F, 0x00, 0x02, +- 0x00, 0x6F, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x11, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x11, +- 0x00, 0x02, 0x00, 0x52, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x72, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x52, +- 0x03, 0x11, 0x00, 0x02, 0x00, 0x72, 0x03, 0x11, 0x00, 0x02, 0x00, 0x55, 0x03, 0x0F, 0x00, 0x02, +- 0x00, 0x75, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x55, 0x03, 0x11, 0x00, 0x02, 0x00, 0x75, 0x03, 0x11, +- 0x00, 0x02, 0x00, 0x53, 0x03, 0x26, 0x00, 0x02, 0x00, 0x73, 0x03, 0x26, 0x00, 0x02, 0x00, 0x54, +- 0x03, 0x26, 0x00, 0x02, 0x00, 0x74, 0x03, 0x26, 0x00, 0x02, 0x00, 0x48, 0x03, 0x0C, 0x00, 0x02, +- 0x00, 0x68, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x41, 0x03, 0x07, 0x00, 0x02, 0x00, 0x61, 0x03, 0x07, +- 0x00, 0x02, 0x00, 0x45, 0x03, 0x27, 0x00, 0x02, 0x00, 0x65, 0x03, 0x27, 0x00, 0x02, 0x00, 0xD6, +- 0x03, 0x04, 0x00, 0x02, 0x00, 0xF6, 0x03, 0x04, 0x00, 0x02, 0x00, 0xD5, 0x03, 0x04, 0x00, 0x02, +- 0x00, 0xF5, 0x03, 0x04, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x07, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x07, +- 0x00, 0x02, 0x02, 0x2E, 0x03, 0x04, 0x00, 0x02, 0x02, 0x2F, 0x03, 0x04, 0x00, 0x02, 0x00, 0x59, +- 0x03, 0x04, 0x00, 0x02, 0x00, 0x79, 0x03, 0x04, 0x00, 0x02, 0x00, 0x41, 0x03, 0x25, 0x00, 0x02, +- 0x00, 0x61, 0x03, 0x25, 0x00, 0x02, 0x00, 0x42, 0x03, 0x07, 0x00, 0x02, 0x00, 0x62, 0x03, 0x07, +- 0x00, 0x02, 0x00, 0x42, 0x03, 0x23, 0x00, 0x02, 0x00, 0x62, 0x03, 0x23, 0x00, 0x02, 0x00, 0x42, +- 0x03, 0x31, 0x00, 0x02, 0x00, 0x62, 0x03, 0x31, 0x00, 0x02, 0x00, 0xC7, 0x03, 0x01, 0x00, 0x02, +- 0x00, 0xE7, 0x03, 0x01, 0x00, 0x02, 0x00, 0x44, 0x03, 0x07, 0x00, 0x02, 0x00, 0x64, 0x03, 0x07, +- 0x00, 0x02, 0x00, 0x44, 0x03, 0x23, 0x00, 0x02, 0x00, 0x64, 0x03, 0x23, 0x00, 0x02, 0x00, 0x44, +- 0x03, 0x31, 0x00, 0x02, 0x00, 0x64, 0x03, 0x31, 0x00, 0x02, 0x00, 0x44, 0x03, 0x27, 0x00, 0x02, +- 0x00, 0x64, 0x03, 0x27, 0x00, 0x02, 0x00, 0x44, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x64, 0x03, 0x2D, +- 0x00, 0x02, 0x01, 0x12, 0x03, 0x00, 0x00, 0x02, 0x01, 0x13, 0x03, 0x00, 0x00, 0x02, 0x01, 0x12, +- 0x03, 0x01, 0x00, 0x02, 0x01, 0x13, 0x03, 0x01, 0x00, 0x02, 0x00, 0x45, 0x03, 0x2D, 0x00, 0x02, +- 0x00, 0x65, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x45, 0x03, 0x30, 0x00, 0x02, 0x00, 0x65, 0x03, 0x30, +- 0x00, 0x02, 0x01, 0x14, 0x03, 0x27, 0x00, 0x02, 0x01, 0x15, 0x03, 0x27, 0x00, 0x02, 0x00, 0x46, +- 0x03, 0x07, 0x00, 0x02, 0x00, 0x66, 0x03, 0x07, 0x00, 0x02, 0x00, 0x47, 0x03, 0x04, 0x00, 0x02, +- 0x00, 0x67, 0x03, 0x04, 0x00, 0x02, 0x00, 0x48, 0x03, 0x07, 0x00, 0x02, 0x00, 0x68, 0x03, 0x07, +- 0x00, 0x02, 0x00, 0x48, 0x03, 0x23, 0x00, 0x02, 0x00, 0x68, 0x03, 0x23, 0x00, 0x02, 0x00, 0x48, +- 0x03, 0x08, 0x00, 0x02, 0x00, 0x68, 0x03, 0x08, 0x00, 0x02, 0x00, 0x48, 0x03, 0x27, 0x00, 0x02, +- 0x00, 0x68, 0x03, 0x27, 0x00, 0x02, 0x00, 0x48, 0x03, 0x2E, 0x00, 0x02, 0x00, 0x68, 0x03, 0x2E, +- 0x00, 0x02, 0x00, 0x49, 0x03, 0x30, 0x00, 0x02, 0x00, 0x69, 0x03, 0x30, 0x00, 0x02, 0x00, 0x49, +- 0x03, 0x44, 0x00, 0x02, 0x00, 0x69, 0x03, 0x44, 0x00, 0x02, 0x00, 0x4B, 0x03, 0x01, 0x00, 0x02, +- 0x00, 0x6B, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4B, 0x03, 0x23, 0x00, 0x02, 0x00, 0x6B, 0x03, 0x23, +- 0x00, 0x02, 0x00, 0x4B, 0x03, 0x31, 0x00, 0x02, 0x00, 0x6B, 0x03, 0x31, 0x00, 0x02, 0x00, 0x4C, +- 0x03, 0x23, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x23, 0x00, 0x02, 0x1E, 0x36, 0x03, 0x04, 0x00, 0x02, +- 0x1E, 0x37, 0x03, 0x04, 0x00, 0x02, 0x00, 0x4C, 0x03, 0x31, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x31, +- 0x00, 0x02, 0x00, 0x4C, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x4D, +- 0x03, 0x01, 0x00, 0x02, 0x00, 0x6D, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4D, 0x03, 0x07, 0x00, 0x02, +- 0x00, 0x6D, 0x03, 0x07, 0x00, 0x02, 0x00, 0x4D, 0x03, 0x23, 0x00, 0x02, 0x00, 0x6D, 0x03, 0x23, +- 0x00, 0x02, 0x00, 0x4E, 0x03, 0x07, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x07, 0x00, 0x02, 0x00, 0x4E, +- 0x03, 0x23, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x23, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x31, 0x00, 0x02, +- 0x00, 0x6E, 0x03, 0x31, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x2D, +- 0x00, 0x02, 0x00, 0xD5, 0x03, 0x01, 0x00, 0x02, 0x00, 0xF5, 0x03, 0x01, 0x00, 0x02, 0x00, 0xD5, +- 0x03, 0x08, 0x00, 0x02, 0x00, 0xF5, 0x03, 0x08, 0x00, 0x02, 0x01, 0x4C, 0x03, 0x00, 0x00, 0x02, +- 0x01, 0x4D, 0x03, 0x00, 0x00, 0x02, 0x01, 0x4C, 0x03, 0x01, 0x00, 0x02, 0x01, 0x4D, 0x03, 0x01, +- 0x00, 0x02, 0x00, 0x50, 0x03, 0x01, 0x00, 0x02, 0x00, 0x70, 0x03, 0x01, 0x00, 0x02, 0x00, 0x50, +- 0x03, 0x07, 0x00, 0x02, 0x00, 0x70, 0x03, 0x07, 0x00, 0x02, 0x00, 0x52, 0x03, 0x07, 0x00, 0x02, +- 0x00, 0x72, 0x03, 0x07, 0x00, 0x02, 0x00, 0x52, 0x03, 0x23, 0x00, 0x02, 0x00, 0x72, 0x03, 0x23, +- 0x00, 0x02, 0x1E, 0x5A, 0x03, 0x04, 0x00, 0x02, 0x1E, 0x5B, 0x03, 0x04, 0x00, 0x02, 0x00, 0x52, +- 0x03, 0x31, 0x00, 0x02, 0x00, 0x72, 0x03, 0x31, 0x00, 0x02, 0x00, 0x53, 0x03, 0x07, 0x00, 0x02, +- 0x00, 0x73, 0x03, 0x07, 0x00, 0x02, 0x00, 0x53, 0x03, 0x23, 0x00, 0x02, 0x00, 0x73, 0x03, 0x23, +- 0x00, 0x02, 0x01, 0x5A, 0x03, 0x07, 0x00, 0x02, 0x01, 0x5B, 0x03, 0x07, 0x00, 0x02, 0x01, 0x60, +- 0x03, 0x07, 0x00, 0x02, 0x01, 0x61, 0x03, 0x07, 0x00, 0x02, 0x1E, 0x60, 0x03, 0x23, 0x00, 0x02, +- 0x1E, 0x61, 0x03, 0x23, 0x00, 0x02, 0x00, 0x54, 0x03, 0x07, 0x00, 0x02, 0x00, 0x74, 0x03, 0x07, +- 0x00, 0x02, 0x00, 0x54, 0x03, 0x23, 0x00, 0x02, 0x00, 0x74, 0x03, 0x23, 0x00, 0x02, 0x00, 0x54, +- 0x03, 0x31, 0x00, 0x02, 0x00, 0x74, 0x03, 0x31, 0x00, 0x02, 0x00, 0x54, 0x03, 0x2D, 0x00, 0x02, +- 0x00, 0x74, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x55, 0x03, 0x24, 0x00, 0x02, 0x00, 0x75, 0x03, 0x24, +- 0x00, 0x02, 0x00, 0x55, 0x03, 0x30, 0x00, 0x02, 0x00, 0x75, 0x03, 0x30, 0x00, 0x02, 0x00, 0x55, +- 0x03, 0x2D, 0x00, 0x02, 0x00, 0x75, 0x03, 0x2D, 0x00, 0x02, 0x01, 0x68, 0x03, 0x01, 0x00, 0x02, +- 0x01, 0x69, 0x03, 0x01, 0x00, 0x02, 0x01, 0x6A, 0x03, 0x08, 0x00, 0x02, 0x01, 0x6B, 0x03, 0x08, +- 0x00, 0x02, 0x00, 0x56, 0x03, 0x03, 0x00, 0x02, 0x00, 0x76, 0x03, 0x03, 0x00, 0x02, 0x00, 0x56, +- 0x03, 0x23, 0x00, 0x02, 0x00, 0x76, 0x03, 0x23, 0x00, 0x02, 0x00, 0x57, 0x03, 0x00, 0x00, 0x02, +- 0x00, 0x77, 0x03, 0x00, 0x00, 0x02, 0x00, 0x57, 0x03, 0x01, 0x00, 0x02, 0x00, 0x77, 0x03, 0x01, +- 0x00, 0x02, 0x00, 0x57, 0x03, 0x08, 0x00, 0x02, 0x00, 0x77, 0x03, 0x08, 0x00, 0x02, 0x00, 0x57, +- 0x03, 0x07, 0x00, 0x02, 0x00, 0x77, 0x03, 0x07, 0x00, 0x02, 0x00, 0x57, 0x03, 0x23, 0x00, 0x02, +- 0x00, 0x77, 0x03, 0x23, 0x00, 0x02, 0x00, 0x58, 0x03, 0x07, 0x00, 0x02, 0x00, 0x78, 0x03, 0x07, +- 0x00, 0x02, 0x00, 0x58, 0x03, 0x08, 0x00, 0x02, 0x00, 0x78, 0x03, 0x08, 0x00, 0x02, 0x00, 0x59, +- 0x03, 0x07, 0x00, 0x02, 0x00, 0x79, 0x03, 0x07, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x02, 0x00, 0x02, +- 0x00, 0x7A, 0x03, 0x02, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x23, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x23, +- 0x00, 0x02, 0x00, 0x5A, 0x03, 0x31, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x31, 0x00, 0x02, 0x00, 0x68, +- 0x03, 0x31, 0x00, 0x02, 0x00, 0x74, 0x03, 0x08, 0x00, 0x02, 0x00, 0x77, 0x03, 0x0A, 0x00, 0x02, +- 0x00, 0x79, 0x03, 0x0A, 0x00, 0x02, 0x01, 0x7F, 0x03, 0x07, 0x00, 0x02, 0x00, 0x41, 0x03, 0x23, +- 0x00, 0x02, 0x00, 0x61, 0x03, 0x23, 0x00, 0x02, 0x00, 0x41, 0x03, 0x09, 0x00, 0x02, 0x00, 0x61, +- 0x03, 0x09, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x01, 0x00, 0x02, 0x00, 0xE2, 0x03, 0x01, 0x00, 0x02, +- 0x00, 0xC2, 0x03, 0x00, 0x00, 0x02, 0x00, 0xE2, 0x03, 0x00, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x09, +- 0x00, 0x02, 0x00, 0xE2, 0x03, 0x09, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x03, 0x00, 0x02, 0x00, 0xE2, +- 0x03, 0x03, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x23, 0x00, 0x02, 0x00, 0xE2, 0x03, 0x23, 0x00, 0x02, +- 0x01, 0x02, 0x03, 0x01, 0x00, 0x02, 0x01, 0x03, 0x03, 0x01, 0x00, 0x02, 0x01, 0x02, 0x03, 0x00, +- 0x00, 0x02, 0x01, 0x03, 0x03, 0x00, 0x00, 0x02, 0x01, 0x02, 0x03, 0x09, 0x00, 0x02, 0x01, 0x03, +- 0x03, 0x09, 0x00, 0x02, 0x01, 0x02, 0x03, 0x03, 0x00, 0x02, 0x01, 0x03, 0x03, 0x03, 0x00, 0x02, +- 0x01, 0x02, 0x03, 0x23, 0x00, 0x02, 0x01, 0x03, 0x03, 0x23, 0x00, 0x02, 0x00, 0x45, 0x03, 0x23, +- 0x00, 0x02, 0x00, 0x65, 0x03, 0x23, 0x00, 0x02, 0x00, 0x45, 0x03, 0x09, 0x00, 0x02, 0x00, 0x65, +- 0x03, 0x09, 0x00, 0x02, 0x00, 0x45, 0x03, 0x03, 0x00, 0x02, 0x00, 0x65, 0x03, 0x03, 0x00, 0x02, +- 0x00, 0xCA, 0x03, 0x01, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x01, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x00, +- 0x00, 0x02, 0x00, 0xEA, 0x03, 0x00, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x09, 0x00, 0x02, 0x00, 0xEA, +- 0x03, 0x09, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x03, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x03, 0x00, 0x02, +- 0x00, 0xCA, 0x03, 0x23, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x23, 0x00, 0x02, 0x00, 0x49, 0x03, 0x09, +- 0x00, 0x02, 0x00, 0x69, 0x03, 0x09, 0x00, 0x02, 0x00, 0x49, 0x03, 0x23, 0x00, 0x02, 0x00, 0x69, +- 0x03, 0x23, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x23, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x23, 0x00, 0x02, +- 0x00, 0x4F, 0x03, 0x09, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x09, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x01, +- 0x00, 0x02, 0x00, 0xF4, 0x03, 0x01, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x00, 0x00, 0x02, 0x00, 0xF4, +- 0x03, 0x00, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x09, 0x00, 0x02, 0x00, 0xF4, 0x03, 0x09, 0x00, 0x02, +- 0x00, 0xD4, 0x03, 0x03, 0x00, 0x02, 0x00, 0xF4, 0x03, 0x03, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x23, +- 0x00, 0x02, 0x00, 0xF4, 0x03, 0x23, 0x00, 0x02, 0x00, 0xD3, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xF3, +- 0x03, 0x1B, 0x00, 0x02, 0x00, 0xD2, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xF2, 0x03, 0x1B, 0x00, 0x02, +- 0x01, 0xA0, 0x03, 0x09, 0x00, 0x02, 0x01, 0xA1, 0x03, 0x09, 0x00, 0x02, 0x00, 0xD5, 0x03, 0x1B, +- 0x00, 0x02, 0x00, 0xF5, 0x03, 0x1B, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x23, 0x00, 0x02, 0x01, 0xA1, +- 0x03, 0x23, 0x00, 0x02, 0x00, 0x55, 0x03, 0x23, 0x00, 0x02, 0x00, 0x75, 0x03, 0x23, 0x00, 0x02, +- 0x00, 0x55, 0x03, 0x09, 0x00, 0x02, 0x00, 0x75, 0x03, 0x09, 0x00, 0x02, 0x00, 0xDA, 0x03, 0x1B, +- 0x00, 0x02, 0x00, 0xFA, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xD9, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xF9, +- 0x03, 0x1B, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x09, 0x00, 0x02, 0x01, 0xB0, 0x03, 0x09, 0x00, 0x02, +- 0x01, 0x68, 0x03, 0x1B, 0x00, 0x02, 0x01, 0x69, 0x03, 0x1B, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x23, +- 0x00, 0x02, 0x01, 0xB0, 0x03, 0x23, 0x00, 0x02, 0x00, 0x59, 0x03, 0x00, 0x00, 0x02, 0x00, 0x79, +- 0x03, 0x00, 0x00, 0x02, 0x00, 0x59, 0x03, 0x23, 0x00, 0x02, 0x00, 0x79, 0x03, 0x23, 0x00, 0x02, +- 0x00, 0x59, 0x03, 0x09, 0x00, 0x02, 0x00, 0x79, 0x03, 0x09, 0x00, 0x02, 0x00, 0x59, 0x03, 0x03, +- 0x00, 0x02, 0x00, 0x79, 0x03, 0x03, 0x00, 0x02, 0x00, 0x41, 0x03, 0x0A, 0x00, 0x01, 0x01, 0xF2, +- 0x00, 0xC0, 0x00, 0xC1, 0x00, 0xC2, 0x00, 0xC3, 0x00, 0xC4, 0x00, 0xC5, 0x00, 0xC7, 0x00, 0xC8, +- 0x00, 0xC9, 0x00, 0xCA, 0x00, 0xCB, 0x00, 0xCC, 0x00, 0xCD, 0x00, 0xCE, 0x00, 0xCF, 0x00, 0xD1, +- 0x00, 0xD2, 0x00, 0xD3, 0x00, 0xD4, 0x00, 0xD5, 0x00, 0xD6, 0x00, 0xD9, 0x00, 0xDA, 0x00, 0xDB, +- 0x00, 0xDC, 0x00, 0xDD, 0x00, 0xE0, 0x00, 0xE1, 0x00, 0xE2, 0x00, 0xE3, 0x00, 0xE4, 0x00, 0xE5, +- 0x00, 0xE7, 0x00, 0xE8, 0x00, 0xE9, 0x00, 0xEA, 0x00, 0xEB, 0x00, 0xEC, 0x00, 0xED, 0x00, 0xEE, +- 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF2, 0x00, 0xF3, 0x00, 0xF4, 0x00, 0xF5, 0x00, 0xF6, 0x00, 0xF9, +- 0x00, 0xFA, 0x00, 0xFB, 0x00, 0xFC, 0x00, 0xFD, 0x00, 0xFF, 0x01, 0x00, 0x01, 0x01, 0x01, 0x02, +- 0x01, 0x03, 0x01, 0x04, 0x01, 0x05, 0x01, 0x06, 0x01, 0x07, 0x01, 0x08, 0x01, 0x09, 0x01, 0x0A, +- 0x01, 0x0B, 0x01, 0x0C, 0x01, 0x0D, 0x01, 0x0E, 0x01, 0x0F, 0x01, 0x12, 0x01, 0x13, 0x01, 0x14, +- 0x01, 0x15, 0x01, 0x16, 0x01, 0x17, 0x01, 0x18, 0x01, 0x19, 0x01, 0x1A, 0x01, 0x1B, 0x01, 0x1C, +- 0x01, 0x1D, 0x01, 0x1E, 0x01, 0x1F, 0x01, 0x20, 0x01, 0x21, 0x01, 0x22, 0x01, 0x23, 0x01, 0x24, +- 0x01, 0x25, 0x01, 0x28, 0x01, 0x29, 0x01, 0x2A, 0x01, 0x2B, 0x01, 0x2C, 0x01, 0x2D, 0x01, 0x2E, +- 0x01, 0x2F, 0x01, 0x30, 0x01, 0x34, 0x01, 0x35, 0x01, 0x36, 0x01, 0x37, 0x01, 0x39, 0x01, 0x3A, +- 0x01, 0x3B, 0x01, 0x3C, 0x01, 0x3D, 0x01, 0x3E, 0x01, 0x43, 0x01, 0x44, 0x01, 0x45, 0x01, 0x46, +- 0x01, 0x47, 0x01, 0x48, 0x01, 0x4C, 0x01, 0x4D, 0x01, 0x4E, 0x01, 0x4F, 0x01, 0x50, 0x01, 0x51, +- 0x01, 0x54, 0x01, 0x55, 0x01, 0x56, 0x01, 0x57, 0x01, 0x58, 0x01, 0x59, 0x01, 0x5A, 0x01, 0x5B, +- 0x01, 0x5C, 0x01, 0x5D, 0x01, 0x5E, 0x01, 0x5F, 0x01, 0x60, 0x01, 0x61, 0x01, 0x62, 0x01, 0x63, +- 0x01, 0x64, 0x01, 0x65, 0x01, 0x68, 0x01, 0x69, 0x01, 0x6A, 0x01, 0x6B, 0x01, 0x6C, 0x01, 0x6D, +- 0x01, 0x6E, 0x01, 0x6F, 0x01, 0x70, 0x01, 0x71, 0x01, 0x72, 0x01, 0x73, 0x01, 0x74, 0x01, 0x75, +- 0x01, 0x76, 0x01, 0x77, 0x01, 0x78, 0x01, 0x79, 0x01, 0x7A, 0x01, 0x7B, 0x01, 0x7C, 0x01, 0x7D, +- 0x01, 0x7E, 0x01, 0xA0, 0x01, 0xA1, 0x01, 0xAF, 0x01, 0xB0, 0x01, 0xCD, 0x01, 0xCE, 0x01, 0xCF, +- 0x01, 0xD0, 0x01, 0xD1, 0x01, 0xD2, 0x01, 0xD3, 0x01, 0xD4, 0x01, 0xD5, 0x01, 0xD6, 0x01, 0xD7, +- 0x01, 0xD8, 0x01, 0xD9, 0x01, 0xDA, 0x01, 0xDB, 0x01, 0xDC, 0x01, 0xDE, 0x01, 0xDF, 0x01, 0xE0, +- 0x01, 0xE1, 0x01, 0xE2, 0x01, 0xE3, 0x01, 0xE6, 0x01, 0xE7, 0x01, 0xE8, 0x01, 0xE9, 0x01, 0xEA, +- 0x01, 0xEB, 0x01, 0xEC, 0x01, 0xED, 0x01, 0xEE, 0x01, 0xEF, 0x01, 0xF0, 0x01, 0xF4, 0x01, 0xF5, +- 0x01, 0xF8, 0x01, 0xF9, 0x01, 0xFA, 0x01, 0xFB, 0x01, 0xFC, 0x01, 0xFD, 0x01, 0xFE, 0x01, 0xFF, +- 0x02, 0x00, 0x02, 0x01, 0x02, 0x02, 0x02, 0x03, 0x02, 0x04, 0x02, 0x05, 0x02, 0x06, 0x02, 0x07, +- 0x02, 0x08, 0x02, 0x09, 0x02, 0x0A, 0x02, 0x0B, 0x02, 0x0C, 0x02, 0x0D, 0x02, 0x0E, 0x02, 0x0F, +- 0x02, 0x10, 0x02, 0x11, 0x02, 0x12, 0x02, 0x13, 0x02, 0x14, 0x02, 0x15, 0x02, 0x16, 0x02, 0x17, +- 0x02, 0x18, 0x02, 0x19, 0x02, 0x1A, 0x02, 0x1B, 0x02, 0x1E, 0x02, 0x1F, 0x02, 0x26, 0x02, 0x27, +- 0x02, 0x28, 0x02, 0x29, 0x02, 0x2A, 0x02, 0x2B, 0x02, 0x2C, 0x02, 0x2D, 0x02, 0x2E, 0x02, 0x2F, +- 0x02, 0x30, 0x02, 0x31, 0x02, 0x32, 0x02, 0x33, 0x1E, 0x00, 0x1E, 0x01, 0x1E, 0x02, 0x1E, 0x03, +- 0x1E, 0x04, 0x1E, 0x05, 0x1E, 0x06, 0x1E, 0x07, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x0A, 0x1E, 0x0B, +- 0x1E, 0x0C, 0x1E, 0x0D, 0x1E, 0x0E, 0x1E, 0x0F, 0x1E, 0x10, 0x1E, 0x11, 0x1E, 0x12, 0x1E, 0x13, +- 0x1E, 0x14, 0x1E, 0x15, 0x1E, 0x16, 0x1E, 0x17, 0x1E, 0x18, 0x1E, 0x19, 0x1E, 0x1A, 0x1E, 0x1B, +- 0x1E, 0x1C, 0x1E, 0x1D, 0x1E, 0x1E, 0x1E, 0x1F, 0x1E, 0x20, 0x1E, 0x21, 0x1E, 0x22, 0x1E, 0x23, +- 0x1E, 0x24, 0x1E, 0x25, 0x1E, 0x26, 0x1E, 0x27, 0x1E, 0x28, 0x1E, 0x29, 0x1E, 0x2A, 0x1E, 0x2B, +- 0x1E, 0x2C, 0x1E, 0x2D, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0x30, 0x1E, 0x31, 0x1E, 0x32, 0x1E, 0x33, +- 0x1E, 0x34, 0x1E, 0x35, 0x1E, 0x36, 0x1E, 0x37, 0x1E, 0x38, 0x1E, 0x39, 0x1E, 0x3A, 0x1E, 0x3B, +- 0x1E, 0x3C, 0x1E, 0x3D, 0x1E, 0x3E, 0x1E, 0x3F, 0x1E, 0x40, 0x1E, 0x41, 0x1E, 0x42, 0x1E, 0x43, +- 0x1E, 0x44, 0x1E, 0x45, 0x1E, 0x46, 0x1E, 0x47, 0x1E, 0x48, 0x1E, 0x49, 0x1E, 0x4A, 0x1E, 0x4B, +- 0x1E, 0x4C, 0x1E, 0x4D, 0x1E, 0x4E, 0x1E, 0x4F, 0x1E, 0x50, 0x1E, 0x51, 0x1E, 0x52, 0x1E, 0x53, +- 0x1E, 0x54, 0x1E, 0x55, 0x1E, 0x56, 0x1E, 0x57, 0x1E, 0x58, 0x1E, 0x59, 0x1E, 0x5A, 0x1E, 0x5B, +- 0x1E, 0x5C, 0x1E, 0x5D, 0x1E, 0x5E, 0x1E, 0x5F, 0x1E, 0x60, 0x1E, 0x61, 0x1E, 0x62, 0x1E, 0x63, +- 0x1E, 0x64, 0x1E, 0x65, 0x1E, 0x66, 0x1E, 0x67, 0x1E, 0x68, 0x1E, 0x69, 0x1E, 0x6A, 0x1E, 0x6B, +- 0x1E, 0x6C, 0x1E, 0x6D, 0x1E, 0x6E, 0x1E, 0x6F, 0x1E, 0x70, 0x1E, 0x71, 0x1E, 0x72, 0x1E, 0x73, +- 0x1E, 0x74, 0x1E, 0x75, 0x1E, 0x76, 0x1E, 0x77, 0x1E, 0x78, 0x1E, 0x79, 0x1E, 0x7A, 0x1E, 0x7B, +- 0x1E, 0x7C, 0x1E, 0x7D, 0x1E, 0x7E, 0x1E, 0x7F, 0x1E, 0x80, 0x1E, 0x81, 0x1E, 0x82, 0x1E, 0x83, +- 0x1E, 0x84, 0x1E, 0x85, 0x1E, 0x86, 0x1E, 0x87, 0x1E, 0x88, 0x1E, 0x89, 0x1E, 0x8A, 0x1E, 0x8B, +- 0x1E, 0x8C, 0x1E, 0x8D, 0x1E, 0x8E, 0x1E, 0x8F, 0x1E, 0x90, 0x1E, 0x91, 0x1E, 0x92, 0x1E, 0x93, +- 0x1E, 0x94, 0x1E, 0x95, 0x1E, 0x96, 0x1E, 0x97, 0x1E, 0x98, 0x1E, 0x99, 0x1E, 0x9B, 0x1E, 0xA0, +- 0x1E, 0xA1, 0x1E, 0xA2, 0x1E, 0xA3, 0x1E, 0xA4, 0x1E, 0xA5, 0x1E, 0xA6, 0x1E, 0xA7, 0x1E, 0xA8, +- 0x1E, 0xA9, 0x1E, 0xAA, 0x1E, 0xAB, 0x1E, 0xAC, 0x1E, 0xAD, 0x1E, 0xAE, 0x1E, 0xAF, 0x1E, 0xB0, +- 0x1E, 0xB1, 0x1E, 0xB2, 0x1E, 0xB3, 0x1E, 0xB4, 0x1E, 0xB5, 0x1E, 0xB6, 0x1E, 0xB7, 0x1E, 0xB8, +- 0x1E, 0xB9, 0x1E, 0xBA, 0x1E, 0xBB, 0x1E, 0xBC, 0x1E, 0xBD, 0x1E, 0xBE, 0x1E, 0xBF, 0x1E, 0xC0, +- 0x1E, 0xC1, 0x1E, 0xC2, 0x1E, 0xC3, 0x1E, 0xC4, 0x1E, 0xC5, 0x1E, 0xC6, 0x1E, 0xC7, 0x1E, 0xC8, +- 0x1E, 0xC9, 0x1E, 0xCA, 0x1E, 0xCB, 0x1E, 0xCC, 0x1E, 0xCD, 0x1E, 0xCE, 0x1E, 0xCF, 0x1E, 0xD0, +- 0x1E, 0xD1, 0x1E, 0xD2, 0x1E, 0xD3, 0x1E, 0xD4, 0x1E, 0xD5, 0x1E, 0xD6, 0x1E, 0xD7, 0x1E, 0xD8, +- 0x1E, 0xD9, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xDE, 0x1E, 0xDF, 0x1E, 0xE0, +- 0x1E, 0xE1, 0x1E, 0xE2, 0x1E, 0xE3, 0x1E, 0xE4, 0x1E, 0xE5, 0x1E, 0xE6, 0x1E, 0xE7, 0x1E, 0xE8, ++ 0x00, 0x34, 0x01, 0x7A, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x91, 0x00, 0x02, 0x03, 0x02, 0x01, 0x7C, ++ 0x00, 0x02, 0x03, 0x07, 0x01, 0x7E, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x93, 0x00, 0x02, 0x03, 0x23, ++ 0x1E, 0x95, 0x00, 0x02, 0x03, 0x31, 0x01, 0x7A, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, ++ 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xA6, 0x00, 0x02, ++ 0x03, 0x00, 0x1E, 0xA4, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xAA, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xA8, ++ 0x00, 0x02, 0x03, 0x09, 0x1E, 0xAC, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xA6, 0x00, 0x02, 0x03, 0x40, ++ 0x1E, 0xA4, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x01, 0xDE, 0x00, 0x02, 0x03, 0x04, ++ 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x01, 0xFA, 0x00, 0x02, 0x03, 0x01, 0x01, 0xFA, 0x00, 0x02, ++ 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x01, 0xFC, 0x00, 0x02, 0x03, 0x01, ++ 0x01, 0xE2, 0x00, 0x02, 0x03, 0x04, 0x01, 0xFC, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, ++ 0x00, 0x0C, 0x1E, 0x08, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x08, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, ++ 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xC0, ++ 0x00, 0x02, 0x03, 0x00, 0x1E, 0xBE, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xC4, 0x00, 0x02, 0x03, 0x03, ++ 0x1E, 0xC2, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xC6, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xC0, 0x00, 0x02, ++ 0x03, 0x40, 0x1E, 0xBE, 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x2E, ++ 0x00, 0x02, 0x03, 0x01, 0x1E, 0x2E, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xDC, ++ 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xDA, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x07, ++ 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xD2, ++ 0x00, 0x02, 0x03, 0x00, 0x1E, 0xD0, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xD6, 0x00, 0x02, 0x03, 0x03, ++ 0x1E, 0xD4, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xD8, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xD2, 0x00, 0x02, ++ 0x03, 0x40, 0x1E, 0xD0, 0x00, 0x02, 0x03, 0x41, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, ++ 0x00, 0x1E, 0x00, 0x24, 0x1E, 0x4C, 0x00, 0x02, 0x03, 0x01, 0x02, 0x2C, 0x00, 0x02, 0x03, 0x04, ++ 0x1E, 0x4E, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xE0, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0x4C, 0x00, 0x02, ++ 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x02, 0x2A, 0x00, 0x02, 0x03, 0x04, 0x00, 0x02, 0x00, 0x06, ++ 0x00, 0x0C, 0x01, 0xFE, 0x00, 0x02, 0x03, 0x01, 0x01, 0xFE, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, ++ 0x00, 0x04, 0x1E, 0xEA, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xE8, 0x00, 0x02, ++ 0x03, 0x1B, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, ++ 0x01, 0xDB, 0x00, 0x02, 0x03, 0x00, 0x01, 0xD7, 0x00, 0x02, 0x03, 0x01, 0x01, 0xD5, 0x00, 0x02, ++ 0x03, 0x04, 0x01, 0xD9, 0x00, 0x02, 0x03, 0x0C, 0x01, 0xDB, 0x00, 0x02, 0x03, 0x40, 0x01, 0xD7, ++ 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, ++ 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xA7, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xA5, 0x00, 0x02, 0x03, 0x01, ++ 0x1E, 0xAB, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xA9, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xAD, 0x00, 0x02, ++ 0x03, 0x23, 0x1E, 0xA7, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xA5, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, ++ 0x00, 0x04, 0x01, 0xDF, 0x00, 0x02, 0x03, 0x04, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x01, 0xFB, ++ 0x00, 0x02, 0x03, 0x01, 0x01, 0xFB, 0x00, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, ++ 0x00, 0x14, 0x01, 0xFD, 0x00, 0x02, 0x03, 0x01, 0x01, 0xE3, 0x00, 0x02, 0x03, 0x04, 0x01, 0xFD, ++ 0x00, 0x02, 0x03, 0x41, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x09, 0x00, 0x02, 0x03, 0x01, ++ 0x1E, 0x09, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, ++ 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xC1, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xBF, 0x00, 0x02, ++ 0x03, 0x01, 0x1E, 0xC5, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xC3, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xC7, ++ 0x00, 0x02, 0x03, 0x23, 0x1E, 0xC1, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xBF, 0x00, 0x02, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0x2F, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x2F, 0x00, 0x02, ++ 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xDD, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, ++ 0x1E, 0xDB, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, ++ 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xD3, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xD1, 0x00, 0x02, ++ 0x03, 0x01, 0x1E, 0xD7, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xD5, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xD9, ++ 0x00, 0x02, 0x03, 0x23, 0x1E, 0xD3, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xD1, 0x00, 0x02, 0x03, 0x41, ++ 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x1E, 0x4D, 0x00, 0x02, ++ 0x03, 0x01, 0x02, 0x2D, 0x00, 0x02, 0x03, 0x04, 0x1E, 0x4F, 0x00, 0x02, 0x03, 0x08, 0x1E, 0xE1, ++ 0x00, 0x02, 0x03, 0x1B, 0x1E, 0x4D, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x02, 0x2B, ++ 0x00, 0x02, 0x03, 0x04, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x01, 0xFF, 0x00, 0x02, 0x03, 0x01, ++ 0x01, 0xFF, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xEB, 0x00, 0x02, 0x03, 0x1B, ++ 0x00, 0x01, 0x00, 0x04, 0x1E, 0xE9, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x14, ++ 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x01, 0xDC, 0x00, 0x02, 0x03, 0x00, 0x01, 0xD8, ++ 0x00, 0x02, 0x03, 0x01, 0x01, 0xD6, 0x00, 0x02, 0x03, 0x04, 0x01, 0xDA, 0x00, 0x02, 0x03, 0x0C, ++ 0x01, 0xDC, 0x00, 0x02, 0x03, 0x40, 0x01, 0xD8, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, ++ 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xB0, 0x00, 0x02, ++ 0x03, 0x00, 0x1E, 0xAE, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xB4, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xB2, ++ 0x00, 0x02, 0x03, 0x09, 0x1E, 0xB6, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xB0, 0x00, 0x02, 0x03, 0x40, ++ 0x1E, 0xAE, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, ++ 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xB1, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xAF, 0x00, 0x02, ++ 0x03, 0x01, 0x1E, 0xB5, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xB3, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xB7, ++ 0x00, 0x02, 0x03, 0x23, 0x1E, 0xB1, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xAF, 0x00, 0x02, 0x03, 0x41, ++ 0x00, 0x01, 0x00, 0x04, 0x1E, 0x08, 0x00, 0x02, 0x03, 0x27, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x09, ++ 0x00, 0x02, 0x03, 0x27, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x1E, 0x14, ++ 0x00, 0x02, 0x03, 0x00, 0x1E, 0x16, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x14, 0x00, 0x02, 0x03, 0x40, ++ 0x1E, 0x16, 0x00, 0x02, 0x03, 0x41, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, ++ 0x1E, 0x15, 0x00, 0x02, 0x03, 0x00, 0x1E, 0x17, 0x00, 0x02, 0x03, 0x01, 0x1E, 0x15, 0x00, 0x02, ++ 0x03, 0x40, 0x1E, 0x17, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x1C, 0x00, 0x02, ++ 0x03, 0x27, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x1D, 0x00, 0x02, 0x03, 0x27, 0x00, 0x05, 0x00, 0x0C, ++ 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x24, 0x1E, 0x50, 0x00, 0x02, 0x03, 0x00, 0x1E, 0x52, ++ 0x00, 0x02, 0x03, 0x01, 0x01, 0xEC, 0x00, 0x02, 0x03, 0x28, 0x1E, 0x50, 0x00, 0x02, 0x03, 0x40, ++ 0x1E, 0x52, 0x00, 0x02, 0x03, 0x41, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1E, ++ 0x00, 0x24, 0x1E, 0x51, 0x00, 0x02, 0x03, 0x00, 0x1E, 0x53, 0x00, 0x02, 0x03, 0x01, 0x01, 0xED, ++ 0x00, 0x02, 0x03, 0x28, 0x1E, 0x51, 0x00, 0x02, 0x03, 0x40, 0x1E, 0x53, 0x00, 0x02, 0x03, 0x41, ++ 0x00, 0x01, 0x00, 0x04, 0x1E, 0x64, 0x00, 0x02, 0x03, 0x07, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x65, ++ 0x00, 0x02, 0x03, 0x07, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x66, 0x00, 0x02, 0x03, 0x07, 0x00, 0x01, ++ 0x00, 0x04, 0x1E, 0x67, 0x00, 0x02, 0x03, 0x07, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, ++ 0x1E, 0x78, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xEE, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0x78, 0x00, 0x02, ++ 0x03, 0x41, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x1E, 0x79, 0x00, 0x02, 0x03, 0x01, ++ 0x1E, 0xEF, 0x00, 0x02, 0x03, 0x1B, 0x1E, 0x79, 0x00, 0x02, 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, ++ 0x1E, 0x7A, 0x00, 0x02, 0x03, 0x08, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x7B, 0x00, 0x02, 0x03, 0x08, ++ 0x00, 0x01, 0x00, 0x04, 0x1E, 0x9B, 0x00, 0x02, 0x03, 0x07, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, ++ 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xDC, 0x00, 0x02, 0x03, 0x00, ++ 0x1E, 0xDA, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xE0, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xDE, 0x00, 0x02, ++ 0x03, 0x09, 0x1E, 0xE2, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xDC, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xDA, ++ 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, ++ 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xDD, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xDB, 0x00, 0x02, 0x03, 0x01, ++ 0x1E, 0xE1, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xDF, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xE3, 0x00, 0x02, ++ 0x03, 0x23, 0x1E, 0xDD, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xDB, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, ++ 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xEA, ++ 0x00, 0x02, 0x03, 0x00, 0x1E, 0xE8, 0x00, 0x02, 0x03, 0x01, 0x1E, 0xEE, 0x00, 0x02, 0x03, 0x03, ++ 0x1E, 0xEC, 0x00, 0x02, 0x03, 0x09, 0x1E, 0xF0, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xEA, 0x00, 0x02, ++ 0x03, 0x40, 0x1E, 0xE8, 0x00, 0x02, 0x03, 0x41, 0x00, 0x07, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, ++ 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x1E, 0xEB, 0x00, 0x02, 0x03, 0x00, 0x1E, 0xE9, ++ 0x00, 0x02, 0x03, 0x01, 0x1E, 0xEF, 0x00, 0x02, 0x03, 0x03, 0x1E, 0xED, 0x00, 0x02, 0x03, 0x09, ++ 0x1E, 0xF1, 0x00, 0x02, 0x03, 0x23, 0x1E, 0xEB, 0x00, 0x02, 0x03, 0x40, 0x1E, 0xE9, 0x00, 0x02, ++ 0x03, 0x41, 0x00, 0x01, 0x00, 0x04, 0x01, 0xEE, 0x00, 0x02, 0x03, 0x0C, 0x00, 0x01, 0x00, 0x04, ++ 0x01, 0xEC, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x01, 0xED, 0x00, 0x02, 0x03, 0x04, ++ 0x00, 0x01, 0x00, 0x04, 0x01, 0xE0, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x01, 0xE1, ++ 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x1C, 0x00, 0x02, 0x03, 0x06, 0x00, 0x01, ++ 0x00, 0x04, 0x1E, 0x1D, 0x00, 0x02, 0x03, 0x06, 0x00, 0x01, 0x00, 0x04, 0x02, 0x30, 0x00, 0x02, ++ 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x02, 0x31, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, ++ 0x01, 0xEF, 0x00, 0x02, 0x03, 0x0C, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x38, 0x00, 0x02, 0x03, 0x04, ++ 0x00, 0x01, 0x00, 0x04, 0x1E, 0x39, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x5C, ++ 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x5D, 0x00, 0x02, 0x03, 0x04, 0x00, 0x01, ++ 0x00, 0x04, 0x1E, 0x68, 0x00, 0x02, 0x03, 0x23, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x69, 0x00, 0x02, ++ 0x03, 0x23, 0x00, 0x01, 0x00, 0x04, 0x1E, 0x68, 0x00, 0x02, 0x03, 0x07, 0x00, 0x01, 0x00, 0x04, ++ 0x1E, 0x69, 0x00, 0x02, 0x03, 0x07, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0xAC, 0x00, 0x02, ++ 0x03, 0x02, 0x1E, 0xB6, 0x00, 0x02, 0x03, 0x06, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0xAD, ++ 0x00, 0x02, 0x03, 0x02, 0x1E, 0xB7, 0x00, 0x02, 0x03, 0x06, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xC6, ++ 0x00, 0x02, 0x03, 0x02, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xC7, 0x00, 0x02, 0x03, 0x02, 0x00, 0x02, ++ 0x00, 0x06, 0x00, 0x0C, 0x1E, 0xD8, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xE2, 0x00, 0x02, 0x03, 0x1B, ++ 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x1E, 0xD9, 0x00, 0x02, 0x03, 0x02, 0x1E, 0xE3, 0x00, 0x02, ++ 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xDE, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, ++ 0x1E, 0xDF, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xF0, 0x00, 0x02, 0x03, 0x1B, ++ 0x00, 0x01, 0x00, 0x04, 0x1E, 0xF1, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xEC, ++ 0x00, 0x02, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x04, 0x1E, 0xED, 0x00, 0x02, 0x03, 0x1B, 0x00, 0x06, ++ 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2C, 0x1E, 0x30, 0x00, 0x02, ++ 0x03, 0x01, 0x01, 0xE8, 0x00, 0x02, 0x03, 0x0C, 0x1E, 0x32, 0x00, 0x02, 0x03, 0x23, 0x01, 0x36, ++ 0x00, 0x02, 0x03, 0x27, 0x1E, 0x34, 0x00, 0x02, 0x03, 0x31, 0x1E, 0x30, 0x00, 0x02, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x01, 0xFA, 0x00, 0x02, 0x03, 0x01, 0x01, 0xFA, 0x00, 0x02, ++ 0x03, 0x41, 0x00, 0x01, 0x00, 0x89, 0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x44, 0x00, 0x45, ++ 0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4A, 0x00, 0x4B, 0x00, 0x4C, 0x00, 0x4D, ++ 0x00, 0x4E, 0x00, 0x4F, 0x00, 0x50, 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, ++ 0x00, 0x57, 0x00, 0x58, 0x00, 0x59, 0x00, 0x5A, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, ++ 0x00, 0x65, 0x00, 0x66, 0x00, 0x67, 0x00, 0x68, 0x00, 0x69, 0x00, 0x6A, 0x00, 0x6B, 0x00, 0x6C, ++ 0x00, 0x6D, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x72, 0x00, 0x73, 0x00, 0x74, 0x00, 0x75, ++ 0x00, 0x76, 0x00, 0x77, 0x00, 0x78, 0x00, 0x79, 0x00, 0x7A, 0x00, 0xC2, 0x00, 0xC4, 0x00, 0xC5, ++ 0x00, 0xC6, 0x00, 0xC7, 0x00, 0xCA, 0x00, 0xCF, 0x00, 0xD2, 0x00, 0xD3, 0x00, 0xD4, 0x00, 0xD5, ++ 0x00, 0xD6, 0x00, 0xD8, 0x00, 0xD9, 0x00, 0xDA, 0x00, 0xDC, 0x00, 0xE2, 0x00, 0xE4, 0x00, 0xE5, ++ 0x00, 0xE6, 0x00, 0xE7, 0x00, 0xEA, 0x00, 0xEF, 0x00, 0xF2, 0x00, 0xF3, 0x00, 0xF4, 0x00, 0xF5, ++ 0x00, 0xF6, 0x00, 0xF8, 0x00, 0xF9, 0x00, 0xFA, 0x00, 0xFC, 0x01, 0x02, 0x01, 0x03, 0x01, 0x06, ++ 0x01, 0x07, 0x01, 0x12, 0x01, 0x13, 0x01, 0x14, 0x01, 0x15, 0x01, 0x4C, 0x01, 0x4D, 0x01, 0x5A, ++ 0x01, 0x5B, 0x01, 0x60, 0x01, 0x61, 0x01, 0x68, 0x01, 0x69, 0x01, 0x6A, 0x01, 0x6B, 0x01, 0x7F, ++ 0x01, 0xA0, 0x01, 0xA1, 0x01, 0xAF, 0x01, 0xB0, 0x01, 0xB7, 0x01, 0xEA, 0x01, 0xEB, 0x02, 0x26, ++ 0x02, 0x27, 0x02, 0x28, 0x02, 0x29, 0x02, 0x2E, 0x02, 0x2F, 0x02, 0x92, 0x1E, 0x36, 0x1E, 0x37, ++ 0x1E, 0x5A, 0x1E, 0x5B, 0x1E, 0x60, 0x1E, 0x61, 0x1E, 0x62, 0x1E, 0x63, 0x1E, 0xA0, 0x1E, 0xA1, ++ 0x1E, 0xB8, 0x1E, 0xB9, 0x1E, 0xCC, 0x1E, 0xCD, 0x1E, 0xCE, 0x1E, 0xCF, 0x1E, 0xE4, 0x1E, 0xE5, ++ 0x1E, 0xE6, 0x1E, 0xE7, 0x21, 0x2A, 0x21, 0x2B, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x14, ++ 0x13, 0x88, 0x1A, 0x9E, 0x1E, 0x3C, 0x21, 0xAE, 0x22, 0x6C, 0x22, 0xFA, 0x00, 0x01, 0x0F, 0x8E, ++ 0x01, 0xF1, 0x03, 0xE8, 0x03, 0xEE, 0x03, 0xF4, 0x03, 0xFA, 0x04, 0x00, 0x04, 0x06, 0x04, 0x0C, ++ 0x04, 0x12, 0x04, 0x18, 0x04, 0x1E, 0x04, 0x24, 0x04, 0x2A, 0x04, 0x30, 0x04, 0x36, 0x04, 0x3C, ++ 0x04, 0x42, 0x04, 0x48, 0x04, 0x4E, 0x04, 0x54, 0x04, 0x5A, 0x04, 0x60, 0x04, 0x66, 0x04, 0x6C, ++ 0x04, 0x72, 0x04, 0x78, 0x04, 0x7E, 0x04, 0x84, 0x04, 0x8A, 0x04, 0x90, 0x04, 0x96, 0x04, 0x9C, ++ 0x04, 0xA2, 0x04, 0xA8, 0x04, 0xAE, 0x04, 0xB4, 0x04, 0xBA, 0x04, 0xC0, 0x04, 0xC6, 0x04, 0xCC, ++ 0x04, 0xD2, 0x04, 0xD8, 0x04, 0xDE, 0x04, 0xE4, 0x04, 0xEA, 0x04, 0xF0, 0x04, 0xF6, 0x04, 0xFC, ++ 0x05, 0x02, 0x05, 0x08, 0x05, 0x0E, 0x05, 0x14, 0x05, 0x1A, 0x05, 0x20, 0x05, 0x26, 0x05, 0x2C, ++ 0x05, 0x32, 0x05, 0x38, 0x05, 0x3E, 0x05, 0x44, 0x05, 0x4A, 0x05, 0x50, 0x05, 0x56, 0x05, 0x5C, ++ 0x05, 0x62, 0x05, 0x68, 0x05, 0x6E, 0x05, 0x74, 0x05, 0x7A, 0x05, 0x80, 0x05, 0x86, 0x05, 0x8C, ++ 0x05, 0x92, 0x05, 0x98, 0x05, 0x9E, 0x05, 0xA4, 0x05, 0xAA, 0x05, 0xB0, 0x05, 0xB6, 0x05, 0xBC, ++ 0x05, 0xC2, 0x05, 0xC8, 0x05, 0xCE, 0x05, 0xD4, 0x05, 0xDA, 0x05, 0xE0, 0x05, 0xE6, 0x05, 0xEC, ++ 0x05, 0xF2, 0x05, 0xF8, 0x05, 0xFE, 0x06, 0x04, 0x06, 0x0A, 0x06, 0x10, 0x06, 0x16, 0x06, 0x1C, ++ 0x06, 0x22, 0x06, 0x28, 0x06, 0x2E, 0x06, 0x34, 0x06, 0x3A, 0x06, 0x40, 0x06, 0x46, 0x06, 0x4C, ++ 0x06, 0x52, 0x06, 0x58, 0x06, 0x5E, 0x06, 0x64, 0x06, 0x6A, 0x06, 0x70, 0x06, 0x76, 0x06, 0x7C, ++ 0x06, 0x82, 0x06, 0x88, 0x06, 0x8E, 0x06, 0x94, 0x06, 0x9A, 0x06, 0xA0, 0x06, 0xA6, 0x06, 0xAC, ++ 0x06, 0xB2, 0x06, 0xB8, 0x06, 0xBE, 0x06, 0xC4, 0x06, 0xCA, 0x06, 0xD0, 0x06, 0xD6, 0x06, 0xDC, ++ 0x06, 0xE2, 0x06, 0xE8, 0x06, 0xEE, 0x06, 0xF4, 0x06, 0xFA, 0x07, 0x00, 0x07, 0x06, 0x07, 0x0C, ++ 0x07, 0x12, 0x07, 0x18, 0x07, 0x1E, 0x07, 0x24, 0x07, 0x2A, 0x07, 0x30, 0x07, 0x36, 0x07, 0x3C, ++ 0x07, 0x42, 0x07, 0x48, 0x07, 0x4E, 0x07, 0x54, 0x07, 0x5A, 0x07, 0x60, 0x07, 0x66, 0x07, 0x6C, ++ 0x07, 0x72, 0x07, 0x78, 0x07, 0x7E, 0x07, 0x84, 0x07, 0x8A, 0x07, 0x90, 0x07, 0x96, 0x07, 0x9C, ++ 0x07, 0xA2, 0x07, 0xA8, 0x07, 0xAE, 0x07, 0xB4, 0x07, 0xBA, 0x07, 0xC0, 0x07, 0xC6, 0x07, 0xCC, ++ 0x07, 0xD2, 0x07, 0xD8, 0x07, 0xDE, 0x07, 0xE4, 0x07, 0xEA, 0x07, 0xF0, 0x07, 0xF6, 0x07, 0xFC, ++ 0x08, 0x02, 0x08, 0x08, 0x08, 0x0E, 0x08, 0x14, 0x08, 0x1A, 0x08, 0x20, 0x08, 0x26, 0x08, 0x2C, ++ 0x08, 0x32, 0x08, 0x38, 0x08, 0x3E, 0x08, 0x44, 0x08, 0x4A, 0x08, 0x50, 0x08, 0x56, 0x08, 0x5C, ++ 0x08, 0x62, 0x08, 0x68, 0x08, 0x6E, 0x08, 0x74, 0x08, 0x7A, 0x08, 0x80, 0x08, 0x86, 0x08, 0x8C, ++ 0x08, 0x92, 0x08, 0x98, 0x08, 0x9E, 0x08, 0xA4, 0x08, 0xAA, 0x08, 0xB0, 0x08, 0xB6, 0x08, 0xBC, ++ 0x08, 0xC2, 0x08, 0xC8, 0x08, 0xCE, 0x08, 0xD4, 0x08, 0xDA, 0x08, 0xE0, 0x08, 0xE6, 0x08, 0xEC, ++ 0x08, 0xF2, 0x08, 0xF8, 0x08, 0xFE, 0x09, 0x04, 0x09, 0x0A, 0x09, 0x10, 0x09, 0x16, 0x09, 0x1C, ++ 0x09, 0x22, 0x09, 0x28, 0x09, 0x2E, 0x09, 0x34, 0x09, 0x3A, 0x09, 0x40, 0x09, 0x46, 0x09, 0x4C, ++ 0x09, 0x52, 0x09, 0x58, 0x09, 0x5E, 0x09, 0x64, 0x09, 0x6A, 0x09, 0x70, 0x09, 0x76, 0x09, 0x7C, ++ 0x09, 0x82, 0x09, 0x88, 0x09, 0x8E, 0x09, 0x94, 0x09, 0x9A, 0x09, 0xA0, 0x09, 0xA6, 0x09, 0xAC, ++ 0x09, 0xB2, 0x09, 0xB8, 0x09, 0xBE, 0x09, 0xC4, 0x09, 0xCA, 0x09, 0xD0, 0x09, 0xD6, 0x09, 0xDC, ++ 0x09, 0xE2, 0x09, 0xE8, 0x09, 0xEE, 0x09, 0xF4, 0x09, 0xFA, 0x0A, 0x00, 0x0A, 0x06, 0x0A, 0x0C, ++ 0x0A, 0x12, 0x0A, 0x18, 0x0A, 0x1E, 0x0A, 0x24, 0x0A, 0x2A, 0x0A, 0x30, 0x0A, 0x36, 0x0A, 0x3C, ++ 0x0A, 0x42, 0x0A, 0x48, 0x0A, 0x4E, 0x0A, 0x54, 0x0A, 0x5A, 0x0A, 0x60, 0x0A, 0x66, 0x0A, 0x6C, ++ 0x0A, 0x72, 0x0A, 0x78, 0x0A, 0x7E, 0x0A, 0x84, 0x0A, 0x8A, 0x0A, 0x90, 0x0A, 0x96, 0x0A, 0x9C, ++ 0x0A, 0xA2, 0x0A, 0xA8, 0x0A, 0xAE, 0x0A, 0xB4, 0x0A, 0xBA, 0x0A, 0xC0, 0x0A, 0xC6, 0x0A, 0xCC, ++ 0x0A, 0xD2, 0x0A, 0xD8, 0x0A, 0xDE, 0x0A, 0xE4, 0x0A, 0xEA, 0x0A, 0xF0, 0x0A, 0xF6, 0x0A, 0xFC, ++ 0x0B, 0x02, 0x0B, 0x08, 0x0B, 0x0E, 0x0B, 0x14, 0x0B, 0x1A, 0x0B, 0x20, 0x0B, 0x26, 0x0B, 0x2C, ++ 0x0B, 0x32, 0x0B, 0x38, 0x0B, 0x3E, 0x0B, 0x44, 0x0B, 0x4A, 0x0B, 0x50, 0x0B, 0x56, 0x0B, 0x5C, ++ 0x0B, 0x62, 0x0B, 0x68, 0x0B, 0x6E, 0x0B, 0x74, 0x0B, 0x7A, 0x0B, 0x80, 0x0B, 0x86, 0x0B, 0x8C, ++ 0x0B, 0x92, 0x0B, 0x98, 0x0B, 0x9E, 0x0B, 0xA4, 0x0B, 0xAA, 0x0B, 0xB0, 0x0B, 0xB6, 0x0B, 0xBC, ++ 0x0B, 0xC2, 0x0B, 0xC8, 0x0B, 0xCE, 0x0B, 0xD4, 0x0B, 0xDA, 0x0B, 0xE0, 0x0B, 0xE6, 0x0B, 0xEC, ++ 0x0B, 0xF2, 0x0B, 0xF8, 0x0B, 0xFE, 0x0C, 0x04, 0x0C, 0x0A, 0x0C, 0x10, 0x0C, 0x16, 0x0C, 0x1C, ++ 0x0C, 0x22, 0x0C, 0x28, 0x0C, 0x2E, 0x0C, 0x34, 0x0C, 0x3A, 0x0C, 0x40, 0x0C, 0x46, 0x0C, 0x4C, ++ 0x0C, 0x52, 0x0C, 0x58, 0x0C, 0x5E, 0x0C, 0x64, 0x0C, 0x6A, 0x0C, 0x70, 0x0C, 0x76, 0x0C, 0x7C, ++ 0x0C, 0x82, 0x0C, 0x88, 0x0C, 0x8E, 0x0C, 0x94, 0x0C, 0x9A, 0x0C, 0xA0, 0x0C, 0xA6, 0x0C, 0xAC, ++ 0x0C, 0xB2, 0x0C, 0xB8, 0x0C, 0xBE, 0x0C, 0xC4, 0x0C, 0xCA, 0x0C, 0xD0, 0x0C, 0xD6, 0x0C, 0xDC, ++ 0x0C, 0xE2, 0x0C, 0xE8, 0x0C, 0xEE, 0x0C, 0xF4, 0x0C, 0xFA, 0x0D, 0x00, 0x0D, 0x06, 0x0D, 0x0C, ++ 0x0D, 0x12, 0x0D, 0x18, 0x0D, 0x1E, 0x0D, 0x24, 0x0D, 0x2A, 0x0D, 0x30, 0x0D, 0x36, 0x0D, 0x3C, ++ 0x0D, 0x42, 0x0D, 0x48, 0x0D, 0x4E, 0x0D, 0x54, 0x0D, 0x5A, 0x0D, 0x60, 0x0D, 0x66, 0x0D, 0x6C, ++ 0x0D, 0x72, 0x0D, 0x78, 0x0D, 0x7E, 0x0D, 0x84, 0x0D, 0x8A, 0x0D, 0x90, 0x0D, 0x96, 0x0D, 0x9C, ++ 0x0D, 0xA2, 0x0D, 0xA8, 0x0D, 0xAE, 0x0D, 0xB4, 0x0D, 0xBA, 0x0D, 0xC0, 0x0D, 0xC6, 0x0D, 0xCC, ++ 0x0D, 0xD2, 0x0D, 0xD8, 0x0D, 0xDE, 0x0D, 0xE4, 0x0D, 0xEA, 0x0D, 0xF0, 0x0D, 0xF6, 0x0D, 0xFC, ++ 0x0E, 0x02, 0x0E, 0x08, 0x0E, 0x0E, 0x0E, 0x14, 0x0E, 0x1A, 0x0E, 0x20, 0x0E, 0x26, 0x0E, 0x2C, ++ 0x0E, 0x32, 0x0E, 0x38, 0x0E, 0x3E, 0x0E, 0x44, 0x0E, 0x4A, 0x0E, 0x50, 0x0E, 0x56, 0x0E, 0x5C, ++ 0x0E, 0x62, 0x0E, 0x68, 0x0E, 0x6E, 0x0E, 0x74, 0x0E, 0x7A, 0x0E, 0x80, 0x0E, 0x86, 0x0E, 0x8C, ++ 0x0E, 0x92, 0x0E, 0x98, 0x0E, 0x9E, 0x0E, 0xA4, 0x0E, 0xAA, 0x0E, 0xB0, 0x0E, 0xB6, 0x0E, 0xBC, ++ 0x0E, 0xC2, 0x0E, 0xC8, 0x0E, 0xCE, 0x0E, 0xD4, 0x0E, 0xDA, 0x0E, 0xE0, 0x0E, 0xE6, 0x0E, 0xEC, ++ 0x0E, 0xF2, 0x0E, 0xF8, 0x0E, 0xFE, 0x0F, 0x04, 0x0F, 0x0A, 0x0F, 0x10, 0x0F, 0x16, 0x0F, 0x1C, ++ 0x0F, 0x22, 0x0F, 0x28, 0x0F, 0x2E, 0x0F, 0x34, 0x0F, 0x3A, 0x0F, 0x40, 0x0F, 0x46, 0x0F, 0x4C, ++ 0x0F, 0x52, 0x0F, 0x58, 0x0F, 0x5E, 0x0F, 0x64, 0x0F, 0x6A, 0x0F, 0x70, 0x0F, 0x76, 0x0F, 0x7C, ++ 0x0F, 0x82, 0x0F, 0x88, 0x00, 0x02, 0x00, 0x41, 0x03, 0x00, 0x00, 0x02, 0x00, 0x41, 0x03, 0x01, ++ 0x00, 0x02, 0x00, 0x41, 0x03, 0x02, 0x00, 0x02, 0x00, 0x41, 0x03, 0x03, 0x00, 0x02, 0x00, 0x41, ++ 0x03, 0x08, 0x00, 0x02, 0x00, 0x41, 0x03, 0x0A, 0x00, 0x02, 0x00, 0x43, 0x03, 0x27, 0x00, 0x02, ++ 0x00, 0x45, 0x03, 0x00, 0x00, 0x02, 0x00, 0x45, 0x03, 0x01, 0x00, 0x02, 0x00, 0x45, 0x03, 0x02, ++ 0x00, 0x02, 0x00, 0x45, 0x03, 0x08, 0x00, 0x02, 0x00, 0x49, 0x03, 0x00, 0x00, 0x02, 0x00, 0x49, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0x49, 0x03, 0x02, 0x00, 0x02, 0x00, 0x49, 0x03, 0x08, 0x00, 0x02, ++ 0x00, 0x4E, 0x03, 0x03, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x00, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x01, ++ 0x00, 0x02, 0x00, 0x4F, 0x03, 0x02, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x03, 0x00, 0x02, 0x00, 0x4F, ++ 0x03, 0x08, 0x00, 0x02, 0x00, 0x55, 0x03, 0x00, 0x00, 0x02, 0x00, 0x55, 0x03, 0x01, 0x00, 0x02, ++ 0x00, 0x55, 0x03, 0x02, 0x00, 0x02, 0x00, 0x55, 0x03, 0x08, 0x00, 0x02, 0x00, 0x59, 0x03, 0x01, ++ 0x00, 0x02, 0x00, 0x61, 0x03, 0x00, 0x00, 0x02, 0x00, 0x61, 0x03, 0x01, 0x00, 0x02, 0x00, 0x61, ++ 0x03, 0x02, 0x00, 0x02, 0x00, 0x61, 0x03, 0x03, 0x00, 0x02, 0x00, 0x61, 0x03, 0x08, 0x00, 0x02, ++ 0x00, 0x61, 0x03, 0x0A, 0x00, 0x02, 0x00, 0x63, 0x03, 0x27, 0x00, 0x02, 0x00, 0x65, 0x03, 0x00, ++ 0x00, 0x02, 0x00, 0x65, 0x03, 0x01, 0x00, 0x02, 0x00, 0x65, 0x03, 0x02, 0x00, 0x02, 0x00, 0x65, ++ 0x03, 0x08, 0x00, 0x02, 0x00, 0x69, 0x03, 0x00, 0x00, 0x02, 0x00, 0x69, 0x03, 0x01, 0x00, 0x02, ++ 0x00, 0x69, 0x03, 0x02, 0x00, 0x02, 0x00, 0x69, 0x03, 0x08, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x03, ++ 0x00, 0x02, 0x00, 0x6F, 0x03, 0x00, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x01, 0x00, 0x02, 0x00, 0x6F, ++ 0x03, 0x02, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x03, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x08, 0x00, 0x02, ++ 0x00, 0x75, 0x03, 0x00, 0x00, 0x02, 0x00, 0x75, 0x03, 0x01, 0x00, 0x02, 0x00, 0x75, 0x03, 0x02, ++ 0x00, 0x02, 0x00, 0x75, 0x03, 0x08, 0x00, 0x02, 0x00, 0x79, 0x03, 0x01, 0x00, 0x02, 0x00, 0x79, ++ 0x03, 0x08, 0x00, 0x02, 0x00, 0x41, 0x03, 0x04, 0x00, 0x02, 0x00, 0x61, 0x03, 0x04, 0x00, 0x02, ++ 0x00, 0x41, 0x03, 0x06, 0x00, 0x02, 0x00, 0x61, 0x03, 0x06, 0x00, 0x02, 0x00, 0x41, 0x03, 0x28, ++ 0x00, 0x02, 0x00, 0x61, 0x03, 0x28, 0x00, 0x02, 0x00, 0x43, 0x03, 0x01, 0x00, 0x02, 0x00, 0x63, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0x43, 0x03, 0x02, 0x00, 0x02, 0x00, 0x63, 0x03, 0x02, 0x00, 0x02, ++ 0x00, 0x43, 0x03, 0x07, 0x00, 0x02, 0x00, 0x63, 0x03, 0x07, 0x00, 0x02, 0x00, 0x43, 0x03, 0x0C, ++ 0x00, 0x02, 0x00, 0x63, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x44, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x64, ++ 0x03, 0x0C, 0x00, 0x02, 0x00, 0x45, 0x03, 0x04, 0x00, 0x02, 0x00, 0x65, 0x03, 0x04, 0x00, 0x02, ++ 0x00, 0x45, 0x03, 0x06, 0x00, 0x02, 0x00, 0x65, 0x03, 0x06, 0x00, 0x02, 0x00, 0x45, 0x03, 0x07, ++ 0x00, 0x02, 0x00, 0x65, 0x03, 0x07, 0x00, 0x02, 0x00, 0x45, 0x03, 0x28, 0x00, 0x02, 0x00, 0x65, ++ 0x03, 0x28, 0x00, 0x02, 0x00, 0x45, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x65, 0x03, 0x0C, 0x00, 0x02, ++ 0x00, 0x47, 0x03, 0x02, 0x00, 0x02, 0x00, 0x67, 0x03, 0x02, 0x00, 0x02, 0x00, 0x47, 0x03, 0x06, ++ 0x00, 0x02, 0x00, 0x67, 0x03, 0x06, 0x00, 0x02, 0x00, 0x47, 0x03, 0x07, 0x00, 0x02, 0x00, 0x67, ++ 0x03, 0x07, 0x00, 0x02, 0x00, 0x47, 0x03, 0x27, 0x00, 0x02, 0x00, 0x67, 0x03, 0x27, 0x00, 0x02, ++ 0x00, 0x48, 0x03, 0x02, 0x00, 0x02, 0x00, 0x68, 0x03, 0x02, 0x00, 0x02, 0x00, 0x49, 0x03, 0x03, ++ 0x00, 0x02, 0x00, 0x69, 0x03, 0x03, 0x00, 0x02, 0x00, 0x49, 0x03, 0x04, 0x00, 0x02, 0x00, 0x69, ++ 0x03, 0x04, 0x00, 0x02, 0x00, 0x49, 0x03, 0x06, 0x00, 0x02, 0x00, 0x69, 0x03, 0x06, 0x00, 0x02, ++ 0x00, 0x49, 0x03, 0x28, 0x00, 0x02, 0x00, 0x69, 0x03, 0x28, 0x00, 0x02, 0x00, 0x49, 0x03, 0x07, ++ 0x00, 0x02, 0x00, 0x4A, 0x03, 0x02, 0x00, 0x02, 0x00, 0x6A, 0x03, 0x02, 0x00, 0x02, 0x00, 0x4B, ++ 0x03, 0x27, 0x00, 0x02, 0x00, 0x6B, 0x03, 0x27, 0x00, 0x02, 0x00, 0x4C, 0x03, 0x01, 0x00, 0x02, ++ 0x00, 0x6C, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4C, 0x03, 0x27, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x27, ++ 0x00, 0x02, 0x00, 0x4C, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4E, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x27, 0x00, 0x02, ++ 0x00, 0x6E, 0x03, 0x27, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x0C, ++ 0x00, 0x02, 0x00, 0x4F, 0x03, 0x04, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x04, 0x00, 0x02, 0x00, 0x4F, ++ 0x03, 0x06, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x06, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x0B, 0x00, 0x02, ++ 0x00, 0x6F, 0x03, 0x0B, 0x00, 0x02, 0x00, 0x52, 0x03, 0x01, 0x00, 0x02, 0x00, 0x72, 0x03, 0x01, ++ 0x00, 0x02, 0x00, 0x52, 0x03, 0x27, 0x00, 0x02, 0x00, 0x72, 0x03, 0x27, 0x00, 0x02, 0x00, 0x52, ++ 0x03, 0x0C, 0x00, 0x02, 0x00, 0x72, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x53, 0x03, 0x01, 0x00, 0x02, ++ 0x00, 0x73, 0x03, 0x01, 0x00, 0x02, 0x00, 0x53, 0x03, 0x02, 0x00, 0x02, 0x00, 0x73, 0x03, 0x02, ++ 0x00, 0x02, 0x00, 0x53, 0x03, 0x27, 0x00, 0x02, 0x00, 0x73, 0x03, 0x27, 0x00, 0x02, 0x00, 0x53, ++ 0x03, 0x0C, 0x00, 0x02, 0x00, 0x73, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x54, 0x03, 0x27, 0x00, 0x02, ++ 0x00, 0x74, 0x03, 0x27, 0x00, 0x02, 0x00, 0x54, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x74, 0x03, 0x0C, ++ 0x00, 0x02, 0x00, 0x55, 0x03, 0x03, 0x00, 0x02, 0x00, 0x75, 0x03, 0x03, 0x00, 0x02, 0x00, 0x55, ++ 0x03, 0x04, 0x00, 0x02, 0x00, 0x75, 0x03, 0x04, 0x00, 0x02, 0x00, 0x55, 0x03, 0x06, 0x00, 0x02, ++ 0x00, 0x75, 0x03, 0x06, 0x00, 0x02, 0x00, 0x55, 0x03, 0x0A, 0x00, 0x02, 0x00, 0x75, 0x03, 0x0A, ++ 0x00, 0x02, 0x00, 0x55, 0x03, 0x0B, 0x00, 0x02, 0x00, 0x75, 0x03, 0x0B, 0x00, 0x02, 0x00, 0x55, ++ 0x03, 0x28, 0x00, 0x02, 0x00, 0x75, 0x03, 0x28, 0x00, 0x02, 0x00, 0x57, 0x03, 0x02, 0x00, 0x02, ++ 0x00, 0x77, 0x03, 0x02, 0x00, 0x02, 0x00, 0x59, 0x03, 0x02, 0x00, 0x02, 0x00, 0x79, 0x03, 0x02, ++ 0x00, 0x02, 0x00, 0x59, 0x03, 0x08, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x01, 0x00, 0x02, 0x00, 0x7A, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x07, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x5A, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x1B, ++ 0x00, 0x02, 0x00, 0x6F, 0x03, 0x1B, 0x00, 0x02, 0x00, 0x55, 0x03, 0x1B, 0x00, 0x02, 0x00, 0x75, ++ 0x03, 0x1B, 0x00, 0x02, 0x00, 0x41, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x61, 0x03, 0x0C, 0x00, 0x02, ++ 0x00, 0x49, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x69, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x0C, ++ 0x00, 0x02, 0x00, 0x6F, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x55, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x75, ++ 0x03, 0x0C, 0x00, 0x02, 0x00, 0xDC, 0x03, 0x04, 0x00, 0x02, 0x00, 0xFC, 0x03, 0x04, 0x00, 0x02, ++ 0x00, 0x55, 0x03, 0x44, 0x00, 0x02, 0x00, 0x75, 0x03, 0x44, 0x00, 0x02, 0x00, 0xDC, 0x03, 0x0C, ++ 0x00, 0x02, 0x00, 0xFC, 0x03, 0x0C, 0x00, 0x02, 0x00, 0xDC, 0x03, 0x00, 0x00, 0x02, 0x00, 0xFC, ++ 0x03, 0x00, 0x00, 0x02, 0x00, 0xC4, 0x03, 0x04, 0x00, 0x02, 0x00, 0xE4, 0x03, 0x04, 0x00, 0x02, ++ 0x02, 0x26, 0x03, 0x04, 0x00, 0x02, 0x02, 0x27, 0x03, 0x04, 0x00, 0x02, 0x00, 0xC6, 0x03, 0x04, ++ 0x00, 0x02, 0x00, 0xE6, 0x03, 0x04, 0x00, 0x02, 0x00, 0x47, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x67, ++ 0x03, 0x0C, 0x00, 0x02, 0x00, 0x4B, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x6B, 0x03, 0x0C, 0x00, 0x02, ++ 0x00, 0x4F, 0x03, 0x28, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x28, 0x00, 0x02, 0x01, 0x4C, 0x03, 0x28, ++ 0x00, 0x02, 0x01, 0x4D, 0x03, 0x28, 0x00, 0x02, 0x01, 0xB7, 0x03, 0x0C, 0x00, 0x02, 0x02, 0x92, ++ 0x03, 0x0C, 0x00, 0x02, 0x00, 0x6A, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x47, 0x03, 0x01, 0x00, 0x02, ++ 0x00, 0x67, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x00, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x00, ++ 0x00, 0x02, 0x00, 0xC5, 0x03, 0x01, 0x00, 0x02, 0x00, 0xE5, 0x03, 0x01, 0x00, 0x02, 0x00, 0xC6, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0xE6, 0x03, 0x01, 0x00, 0x02, 0x00, 0xD8, 0x03, 0x01, 0x00, 0x02, ++ 0x00, 0xF8, 0x03, 0x01, 0x00, 0x02, 0x00, 0x41, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x61, 0x03, 0x0F, ++ 0x00, 0x02, 0x00, 0x41, 0x03, 0x11, 0x00, 0x02, 0x00, 0x61, 0x03, 0x11, 0x00, 0x02, 0x00, 0x45, ++ 0x03, 0x0F, 0x00, 0x02, 0x00, 0x65, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x45, 0x03, 0x11, 0x00, 0x02, ++ 0x00, 0x65, 0x03, 0x11, 0x00, 0x02, 0x00, 0x49, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x69, 0x03, 0x0F, ++ 0x00, 0x02, 0x00, 0x49, 0x03, 0x11, 0x00, 0x02, 0x00, 0x69, 0x03, 0x11, 0x00, 0x02, 0x00, 0x4F, ++ 0x03, 0x0F, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x11, 0x00, 0x02, ++ 0x00, 0x6F, 0x03, 0x11, 0x00, 0x02, 0x00, 0x52, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x72, 0x03, 0x0F, ++ 0x00, 0x02, 0x00, 0x52, 0x03, 0x11, 0x00, 0x02, 0x00, 0x72, 0x03, 0x11, 0x00, 0x02, 0x00, 0x55, ++ 0x03, 0x0F, 0x00, 0x02, 0x00, 0x75, 0x03, 0x0F, 0x00, 0x02, 0x00, 0x55, 0x03, 0x11, 0x00, 0x02, ++ 0x00, 0x75, 0x03, 0x11, 0x00, 0x02, 0x00, 0x53, 0x03, 0x26, 0x00, 0x02, 0x00, 0x73, 0x03, 0x26, ++ 0x00, 0x02, 0x00, 0x54, 0x03, 0x26, 0x00, 0x02, 0x00, 0x74, 0x03, 0x26, 0x00, 0x02, 0x00, 0x48, ++ 0x03, 0x0C, 0x00, 0x02, 0x00, 0x68, 0x03, 0x0C, 0x00, 0x02, 0x00, 0x41, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x61, 0x03, 0x07, 0x00, 0x02, 0x00, 0x45, 0x03, 0x27, 0x00, 0x02, 0x00, 0x65, 0x03, 0x27, ++ 0x00, 0x02, 0x00, 0xD6, 0x03, 0x04, 0x00, 0x02, 0x00, 0xF6, 0x03, 0x04, 0x00, 0x02, 0x00, 0xD5, ++ 0x03, 0x04, 0x00, 0x02, 0x00, 0xF5, 0x03, 0x04, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x6F, 0x03, 0x07, 0x00, 0x02, 0x02, 0x2E, 0x03, 0x04, 0x00, 0x02, 0x02, 0x2F, 0x03, 0x04, ++ 0x00, 0x02, 0x00, 0x59, 0x03, 0x04, 0x00, 0x02, 0x00, 0x79, 0x03, 0x04, 0x00, 0x02, 0x00, 0x41, ++ 0x03, 0x25, 0x00, 0x02, 0x00, 0x61, 0x03, 0x25, 0x00, 0x02, 0x00, 0x42, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x62, 0x03, 0x07, 0x00, 0x02, 0x00, 0x42, 0x03, 0x23, 0x00, 0x02, 0x00, 0x62, 0x03, 0x23, ++ 0x00, 0x02, 0x00, 0x42, 0x03, 0x31, 0x00, 0x02, 0x00, 0x62, 0x03, 0x31, 0x00, 0x02, 0x00, 0xC7, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0xE7, 0x03, 0x01, 0x00, 0x02, 0x00, 0x44, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x64, 0x03, 0x07, 0x00, 0x02, 0x00, 0x44, 0x03, 0x23, 0x00, 0x02, 0x00, 0x64, 0x03, 0x23, ++ 0x00, 0x02, 0x00, 0x44, 0x03, 0x31, 0x00, 0x02, 0x00, 0x64, 0x03, 0x31, 0x00, 0x02, 0x00, 0x44, ++ 0x03, 0x27, 0x00, 0x02, 0x00, 0x64, 0x03, 0x27, 0x00, 0x02, 0x00, 0x44, 0x03, 0x2D, 0x00, 0x02, ++ 0x00, 0x64, 0x03, 0x2D, 0x00, 0x02, 0x01, 0x12, 0x03, 0x00, 0x00, 0x02, 0x01, 0x13, 0x03, 0x00, ++ 0x00, 0x02, 0x01, 0x12, 0x03, 0x01, 0x00, 0x02, 0x01, 0x13, 0x03, 0x01, 0x00, 0x02, 0x00, 0x45, ++ 0x03, 0x2D, 0x00, 0x02, 0x00, 0x65, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x45, 0x03, 0x30, 0x00, 0x02, ++ 0x00, 0x65, 0x03, 0x30, 0x00, 0x02, 0x01, 0x14, 0x03, 0x27, 0x00, 0x02, 0x01, 0x15, 0x03, 0x27, ++ 0x00, 0x02, 0x00, 0x46, 0x03, 0x07, 0x00, 0x02, 0x00, 0x66, 0x03, 0x07, 0x00, 0x02, 0x00, 0x47, ++ 0x03, 0x04, 0x00, 0x02, 0x00, 0x67, 0x03, 0x04, 0x00, 0x02, 0x00, 0x48, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x68, 0x03, 0x07, 0x00, 0x02, 0x00, 0x48, 0x03, 0x23, 0x00, 0x02, 0x00, 0x68, 0x03, 0x23, ++ 0x00, 0x02, 0x00, 0x48, 0x03, 0x08, 0x00, 0x02, 0x00, 0x68, 0x03, 0x08, 0x00, 0x02, 0x00, 0x48, ++ 0x03, 0x27, 0x00, 0x02, 0x00, 0x68, 0x03, 0x27, 0x00, 0x02, 0x00, 0x48, 0x03, 0x2E, 0x00, 0x02, ++ 0x00, 0x68, 0x03, 0x2E, 0x00, 0x02, 0x00, 0x49, 0x03, 0x30, 0x00, 0x02, 0x00, 0x69, 0x03, 0x30, ++ 0x00, 0x02, 0x00, 0x49, 0x03, 0x44, 0x00, 0x02, 0x00, 0x69, 0x03, 0x44, 0x00, 0x02, 0x00, 0x4B, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0x6B, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4B, 0x03, 0x23, 0x00, 0x02, ++ 0x00, 0x6B, 0x03, 0x23, 0x00, 0x02, 0x00, 0x4B, 0x03, 0x31, 0x00, 0x02, 0x00, 0x6B, 0x03, 0x31, ++ 0x00, 0x02, 0x00, 0x4C, 0x03, 0x23, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x23, 0x00, 0x02, 0x1E, 0x36, ++ 0x03, 0x04, 0x00, 0x02, 0x1E, 0x37, 0x03, 0x04, 0x00, 0x02, 0x00, 0x4C, 0x03, 0x31, 0x00, 0x02, ++ 0x00, 0x6C, 0x03, 0x31, 0x00, 0x02, 0x00, 0x4C, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x2D, ++ 0x00, 0x02, 0x00, 0x4D, 0x03, 0x01, 0x00, 0x02, 0x00, 0x6D, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4D, ++ 0x03, 0x07, 0x00, 0x02, 0x00, 0x6D, 0x03, 0x07, 0x00, 0x02, 0x00, 0x4D, 0x03, 0x23, 0x00, 0x02, ++ 0x00, 0x6D, 0x03, 0x23, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x07, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x07, ++ 0x00, 0x02, 0x00, 0x4E, 0x03, 0x23, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x23, 0x00, 0x02, 0x00, 0x4E, ++ 0x03, 0x31, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x31, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x2D, 0x00, 0x02, ++ 0x00, 0x6E, 0x03, 0x2D, 0x00, 0x02, 0x00, 0xD5, 0x03, 0x01, 0x00, 0x02, 0x00, 0xF5, 0x03, 0x01, ++ 0x00, 0x02, 0x00, 0xD5, 0x03, 0x08, 0x00, 0x02, 0x00, 0xF5, 0x03, 0x08, 0x00, 0x02, 0x01, 0x4C, ++ 0x03, 0x00, 0x00, 0x02, 0x01, 0x4D, 0x03, 0x00, 0x00, 0x02, 0x01, 0x4C, 0x03, 0x01, 0x00, 0x02, ++ 0x01, 0x4D, 0x03, 0x01, 0x00, 0x02, 0x00, 0x50, 0x03, 0x01, 0x00, 0x02, 0x00, 0x70, 0x03, 0x01, ++ 0x00, 0x02, 0x00, 0x50, 0x03, 0x07, 0x00, 0x02, 0x00, 0x70, 0x03, 0x07, 0x00, 0x02, 0x00, 0x52, ++ 0x03, 0x07, 0x00, 0x02, 0x00, 0x72, 0x03, 0x07, 0x00, 0x02, 0x00, 0x52, 0x03, 0x23, 0x00, 0x02, ++ 0x00, 0x72, 0x03, 0x23, 0x00, 0x02, 0x1E, 0x5A, 0x03, 0x04, 0x00, 0x02, 0x1E, 0x5B, 0x03, 0x04, ++ 0x00, 0x02, 0x00, 0x52, 0x03, 0x31, 0x00, 0x02, 0x00, 0x72, 0x03, 0x31, 0x00, 0x02, 0x00, 0x53, ++ 0x03, 0x07, 0x00, 0x02, 0x00, 0x73, 0x03, 0x07, 0x00, 0x02, 0x00, 0x53, 0x03, 0x23, 0x00, 0x02, ++ 0x00, 0x73, 0x03, 0x23, 0x00, 0x02, 0x01, 0x5A, 0x03, 0x07, 0x00, 0x02, 0x01, 0x5B, 0x03, 0x07, ++ 0x00, 0x02, 0x01, 0x60, 0x03, 0x07, 0x00, 0x02, 0x01, 0x61, 0x03, 0x07, 0x00, 0x02, 0x1E, 0x60, ++ 0x03, 0x23, 0x00, 0x02, 0x1E, 0x61, 0x03, 0x23, 0x00, 0x02, 0x00, 0x54, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x74, 0x03, 0x07, 0x00, 0x02, 0x00, 0x54, 0x03, 0x23, 0x00, 0x02, 0x00, 0x74, 0x03, 0x23, ++ 0x00, 0x02, 0x00, 0x54, 0x03, 0x31, 0x00, 0x02, 0x00, 0x74, 0x03, 0x31, 0x00, 0x02, 0x00, 0x54, ++ 0x03, 0x2D, 0x00, 0x02, 0x00, 0x74, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x55, 0x03, 0x24, 0x00, 0x02, ++ 0x00, 0x75, 0x03, 0x24, 0x00, 0x02, 0x00, 0x55, 0x03, 0x30, 0x00, 0x02, 0x00, 0x75, 0x03, 0x30, ++ 0x00, 0x02, 0x00, 0x55, 0x03, 0x2D, 0x00, 0x02, 0x00, 0x75, 0x03, 0x2D, 0x00, 0x02, 0x01, 0x68, ++ 0x03, 0x01, 0x00, 0x02, 0x01, 0x69, 0x03, 0x01, 0x00, 0x02, 0x01, 0x6A, 0x03, 0x08, 0x00, 0x02, ++ 0x01, 0x6B, 0x03, 0x08, 0x00, 0x02, 0x00, 0x56, 0x03, 0x03, 0x00, 0x02, 0x00, 0x76, 0x03, 0x03, ++ 0x00, 0x02, 0x00, 0x56, 0x03, 0x23, 0x00, 0x02, 0x00, 0x76, 0x03, 0x23, 0x00, 0x02, 0x00, 0x57, ++ 0x03, 0x00, 0x00, 0x02, 0x00, 0x77, 0x03, 0x00, 0x00, 0x02, 0x00, 0x57, 0x03, 0x01, 0x00, 0x02, ++ 0x00, 0x77, 0x03, 0x01, 0x00, 0x02, 0x00, 0x57, 0x03, 0x08, 0x00, 0x02, 0x00, 0x77, 0x03, 0x08, ++ 0x00, 0x02, 0x00, 0x57, 0x03, 0x07, 0x00, 0x02, 0x00, 0x77, 0x03, 0x07, 0x00, 0x02, 0x00, 0x57, ++ 0x03, 0x23, 0x00, 0x02, 0x00, 0x77, 0x03, 0x23, 0x00, 0x02, 0x00, 0x58, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x78, 0x03, 0x07, 0x00, 0x02, 0x00, 0x58, 0x03, 0x08, 0x00, 0x02, 0x00, 0x78, 0x03, 0x08, ++ 0x00, 0x02, 0x00, 0x59, 0x03, 0x07, 0x00, 0x02, 0x00, 0x79, 0x03, 0x07, 0x00, 0x02, 0x00, 0x5A, ++ 0x03, 0x02, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x02, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x23, 0x00, 0x02, ++ 0x00, 0x7A, 0x03, 0x23, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x31, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x31, ++ 0x00, 0x02, 0x00, 0x68, 0x03, 0x31, 0x00, 0x02, 0x00, 0x74, 0x03, 0x08, 0x00, 0x02, 0x00, 0x77, ++ 0x03, 0x0A, 0x00, 0x02, 0x00, 0x79, 0x03, 0x0A, 0x00, 0x02, 0x01, 0x7F, 0x03, 0x07, 0x00, 0x02, ++ 0x00, 0x41, 0x03, 0x23, 0x00, 0x02, 0x00, 0x61, 0x03, 0x23, 0x00, 0x02, 0x00, 0x41, 0x03, 0x09, ++ 0x00, 0x02, 0x00, 0x61, 0x03, 0x09, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x01, 0x00, 0x02, 0x00, 0xE2, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x00, 0x00, 0x02, 0x00, 0xE2, 0x03, 0x00, 0x00, 0x02, ++ 0x00, 0xC2, 0x03, 0x09, 0x00, 0x02, 0x00, 0xE2, 0x03, 0x09, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x03, ++ 0x00, 0x02, 0x00, 0xE2, 0x03, 0x03, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x23, 0x00, 0x02, 0x00, 0xE2, ++ 0x03, 0x23, 0x00, 0x02, 0x01, 0x02, 0x03, 0x01, 0x00, 0x02, 0x01, 0x03, 0x03, 0x01, 0x00, 0x02, ++ 0x01, 0x02, 0x03, 0x00, 0x00, 0x02, 0x01, 0x03, 0x03, 0x00, 0x00, 0x02, 0x01, 0x02, 0x03, 0x09, ++ 0x00, 0x02, 0x01, 0x03, 0x03, 0x09, 0x00, 0x02, 0x01, 0x02, 0x03, 0x03, 0x00, 0x02, 0x01, 0x03, ++ 0x03, 0x03, 0x00, 0x02, 0x01, 0x02, 0x03, 0x23, 0x00, 0x02, 0x01, 0x03, 0x03, 0x23, 0x00, 0x02, ++ 0x00, 0x45, 0x03, 0x23, 0x00, 0x02, 0x00, 0x65, 0x03, 0x23, 0x00, 0x02, 0x00, 0x45, 0x03, 0x09, ++ 0x00, 0x02, 0x00, 0x65, 0x03, 0x09, 0x00, 0x02, 0x00, 0x45, 0x03, 0x03, 0x00, 0x02, 0x00, 0x65, ++ 0x03, 0x03, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x01, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x01, 0x00, 0x02, ++ 0x00, 0xCA, 0x03, 0x00, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x00, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x09, ++ 0x00, 0x02, 0x00, 0xEA, 0x03, 0x09, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x03, 0x00, 0x02, 0x00, 0xEA, ++ 0x03, 0x03, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x23, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x23, 0x00, 0x02, ++ 0x00, 0x49, 0x03, 0x09, 0x00, 0x02, 0x00, 0x69, 0x03, 0x09, 0x00, 0x02, 0x00, 0x49, 0x03, 0x23, ++ 0x00, 0x02, 0x00, 0x69, 0x03, 0x23, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x23, 0x00, 0x02, 0x00, 0x6F, ++ 0x03, 0x23, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x09, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x09, 0x00, 0x02, ++ 0x00, 0xD4, 0x03, 0x01, 0x00, 0x02, 0x00, 0xF4, 0x03, 0x01, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x00, ++ 0x00, 0x02, 0x00, 0xF4, 0x03, 0x00, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x09, 0x00, 0x02, 0x00, 0xF4, ++ 0x03, 0x09, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x03, 0x00, 0x02, 0x00, 0xF4, 0x03, 0x03, 0x00, 0x02, ++ 0x00, 0xD4, 0x03, 0x23, 0x00, 0x02, 0x00, 0xF4, 0x03, 0x23, 0x00, 0x02, 0x00, 0xD3, 0x03, 0x1B, ++ 0x00, 0x02, 0x00, 0xF3, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xD2, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xF2, ++ 0x03, 0x1B, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x09, 0x00, 0x02, 0x01, 0xA1, 0x03, 0x09, 0x00, 0x02, ++ 0x00, 0xD5, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xF5, 0x03, 0x1B, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x23, ++ 0x00, 0x02, 0x01, 0xA1, 0x03, 0x23, 0x00, 0x02, 0x00, 0x55, 0x03, 0x23, 0x00, 0x02, 0x00, 0x75, ++ 0x03, 0x23, 0x00, 0x02, 0x00, 0x55, 0x03, 0x09, 0x00, 0x02, 0x00, 0x75, 0x03, 0x09, 0x00, 0x02, ++ 0x00, 0xDA, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xFA, 0x03, 0x1B, 0x00, 0x02, 0x00, 0xD9, 0x03, 0x1B, ++ 0x00, 0x02, 0x00, 0xF9, 0x03, 0x1B, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x09, 0x00, 0x02, 0x01, 0xB0, ++ 0x03, 0x09, 0x00, 0x02, 0x01, 0x68, 0x03, 0x1B, 0x00, 0x02, 0x01, 0x69, 0x03, 0x1B, 0x00, 0x02, ++ 0x01, 0xAF, 0x03, 0x23, 0x00, 0x02, 0x01, 0xB0, 0x03, 0x23, 0x00, 0x02, 0x00, 0x59, 0x03, 0x00, ++ 0x00, 0x02, 0x00, 0x79, 0x03, 0x00, 0x00, 0x02, 0x00, 0x59, 0x03, 0x23, 0x00, 0x02, 0x00, 0x79, ++ 0x03, 0x23, 0x00, 0x02, 0x00, 0x59, 0x03, 0x09, 0x00, 0x02, 0x00, 0x79, 0x03, 0x09, 0x00, 0x02, ++ 0x00, 0x59, 0x03, 0x03, 0x00, 0x02, 0x00, 0x79, 0x03, 0x03, 0x00, 0x01, 0x01, 0xF1, 0x00, 0xC0, ++ 0x00, 0xC1, 0x00, 0xC2, 0x00, 0xC3, 0x00, 0xC4, 0x00, 0xC5, 0x00, 0xC7, 0x00, 0xC8, 0x00, 0xC9, ++ 0x00, 0xCA, 0x00, 0xCB, 0x00, 0xCC, 0x00, 0xCD, 0x00, 0xCE, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD2, ++ 0x00, 0xD3, 0x00, 0xD4, 0x00, 0xD5, 0x00, 0xD6, 0x00, 0xD9, 0x00, 0xDA, 0x00, 0xDB, 0x00, 0xDC, ++ 0x00, 0xDD, 0x00, 0xE0, 0x00, 0xE1, 0x00, 0xE2, 0x00, 0xE3, 0x00, 0xE4, 0x00, 0xE5, 0x00, 0xE7, ++ 0x00, 0xE8, 0x00, 0xE9, 0x00, 0xEA, 0x00, 0xEB, 0x00, 0xEC, 0x00, 0xED, 0x00, 0xEE, 0x00, 0xEF, ++ 0x00, 0xF1, 0x00, 0xF2, 0x00, 0xF3, 0x00, 0xF4, 0x00, 0xF5, 0x00, 0xF6, 0x00, 0xF9, 0x00, 0xFA, ++ 0x00, 0xFB, 0x00, 0xFC, 0x00, 0xFD, 0x00, 0xFF, 0x01, 0x00, 0x01, 0x01, 0x01, 0x02, 0x01, 0x03, ++ 0x01, 0x04, 0x01, 0x05, 0x01, 0x06, 0x01, 0x07, 0x01, 0x08, 0x01, 0x09, 0x01, 0x0A, 0x01, 0x0B, ++ 0x01, 0x0C, 0x01, 0x0D, 0x01, 0x0E, 0x01, 0x0F, 0x01, 0x12, 0x01, 0x13, 0x01, 0x14, 0x01, 0x15, ++ 0x01, 0x16, 0x01, 0x17, 0x01, 0x18, 0x01, 0x19, 0x01, 0x1A, 0x01, 0x1B, 0x01, 0x1C, 0x01, 0x1D, ++ 0x01, 0x1E, 0x01, 0x1F, 0x01, 0x20, 0x01, 0x21, 0x01, 0x22, 0x01, 0x23, 0x01, 0x24, 0x01, 0x25, ++ 0x01, 0x28, 0x01, 0x29, 0x01, 0x2A, 0x01, 0x2B, 0x01, 0x2C, 0x01, 0x2D, 0x01, 0x2E, 0x01, 0x2F, ++ 0x01, 0x30, 0x01, 0x34, 0x01, 0x35, 0x01, 0x36, 0x01, 0x37, 0x01, 0x39, 0x01, 0x3A, 0x01, 0x3B, ++ 0x01, 0x3C, 0x01, 0x3D, 0x01, 0x3E, 0x01, 0x43, 0x01, 0x44, 0x01, 0x45, 0x01, 0x46, 0x01, 0x47, ++ 0x01, 0x48, 0x01, 0x4C, 0x01, 0x4D, 0x01, 0x4E, 0x01, 0x4F, 0x01, 0x50, 0x01, 0x51, 0x01, 0x54, ++ 0x01, 0x55, 0x01, 0x56, 0x01, 0x57, 0x01, 0x58, 0x01, 0x59, 0x01, 0x5A, 0x01, 0x5B, 0x01, 0x5C, ++ 0x01, 0x5D, 0x01, 0x5E, 0x01, 0x5F, 0x01, 0x60, 0x01, 0x61, 0x01, 0x62, 0x01, 0x63, 0x01, 0x64, ++ 0x01, 0x65, 0x01, 0x68, 0x01, 0x69, 0x01, 0x6A, 0x01, 0x6B, 0x01, 0x6C, 0x01, 0x6D, 0x01, 0x6E, ++ 0x01, 0x6F, 0x01, 0x70, 0x01, 0x71, 0x01, 0x72, 0x01, 0x73, 0x01, 0x74, 0x01, 0x75, 0x01, 0x76, ++ 0x01, 0x77, 0x01, 0x78, 0x01, 0x79, 0x01, 0x7A, 0x01, 0x7B, 0x01, 0x7C, 0x01, 0x7D, 0x01, 0x7E, ++ 0x01, 0xA0, 0x01, 0xA1, 0x01, 0xAF, 0x01, 0xB0, 0x01, 0xCD, 0x01, 0xCE, 0x01, 0xCF, 0x01, 0xD0, ++ 0x01, 0xD1, 0x01, 0xD2, 0x01, 0xD3, 0x01, 0xD4, 0x01, 0xD5, 0x01, 0xD6, 0x01, 0xD7, 0x01, 0xD8, ++ 0x01, 0xD9, 0x01, 0xDA, 0x01, 0xDB, 0x01, 0xDC, 0x01, 0xDE, 0x01, 0xDF, 0x01, 0xE0, 0x01, 0xE1, ++ 0x01, 0xE2, 0x01, 0xE3, 0x01, 0xE6, 0x01, 0xE7, 0x01, 0xE8, 0x01, 0xE9, 0x01, 0xEA, 0x01, 0xEB, ++ 0x01, 0xEC, 0x01, 0xED, 0x01, 0xEE, 0x01, 0xEF, 0x01, 0xF0, 0x01, 0xF4, 0x01, 0xF5, 0x01, 0xF8, ++ 0x01, 0xF9, 0x01, 0xFA, 0x01, 0xFB, 0x01, 0xFC, 0x01, 0xFD, 0x01, 0xFE, 0x01, 0xFF, 0x02, 0x00, ++ 0x02, 0x01, 0x02, 0x02, 0x02, 0x03, 0x02, 0x04, 0x02, 0x05, 0x02, 0x06, 0x02, 0x07, 0x02, 0x08, ++ 0x02, 0x09, 0x02, 0x0A, 0x02, 0x0B, 0x02, 0x0C, 0x02, 0x0D, 0x02, 0x0E, 0x02, 0x0F, 0x02, 0x10, ++ 0x02, 0x11, 0x02, 0x12, 0x02, 0x13, 0x02, 0x14, 0x02, 0x15, 0x02, 0x16, 0x02, 0x17, 0x02, 0x18, ++ 0x02, 0x19, 0x02, 0x1A, 0x02, 0x1B, 0x02, 0x1E, 0x02, 0x1F, 0x02, 0x26, 0x02, 0x27, 0x02, 0x28, ++ 0x02, 0x29, 0x02, 0x2A, 0x02, 0x2B, 0x02, 0x2C, 0x02, 0x2D, 0x02, 0x2E, 0x02, 0x2F, 0x02, 0x30, ++ 0x02, 0x31, 0x02, 0x32, 0x02, 0x33, 0x1E, 0x00, 0x1E, 0x01, 0x1E, 0x02, 0x1E, 0x03, 0x1E, 0x04, ++ 0x1E, 0x05, 0x1E, 0x06, 0x1E, 0x07, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x0A, 0x1E, 0x0B, 0x1E, 0x0C, ++ 0x1E, 0x0D, 0x1E, 0x0E, 0x1E, 0x0F, 0x1E, 0x10, 0x1E, 0x11, 0x1E, 0x12, 0x1E, 0x13, 0x1E, 0x14, ++ 0x1E, 0x15, 0x1E, 0x16, 0x1E, 0x17, 0x1E, 0x18, 0x1E, 0x19, 0x1E, 0x1A, 0x1E, 0x1B, 0x1E, 0x1C, ++ 0x1E, 0x1D, 0x1E, 0x1E, 0x1E, 0x1F, 0x1E, 0x20, 0x1E, 0x21, 0x1E, 0x22, 0x1E, 0x23, 0x1E, 0x24, ++ 0x1E, 0x25, 0x1E, 0x26, 0x1E, 0x27, 0x1E, 0x28, 0x1E, 0x29, 0x1E, 0x2A, 0x1E, 0x2B, 0x1E, 0x2C, ++ 0x1E, 0x2D, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0x30, 0x1E, 0x31, 0x1E, 0x32, 0x1E, 0x33, 0x1E, 0x34, ++ 0x1E, 0x35, 0x1E, 0x36, 0x1E, 0x37, 0x1E, 0x38, 0x1E, 0x39, 0x1E, 0x3A, 0x1E, 0x3B, 0x1E, 0x3C, ++ 0x1E, 0x3D, 0x1E, 0x3E, 0x1E, 0x3F, 0x1E, 0x40, 0x1E, 0x41, 0x1E, 0x42, 0x1E, 0x43, 0x1E, 0x44, ++ 0x1E, 0x45, 0x1E, 0x46, 0x1E, 0x47, 0x1E, 0x48, 0x1E, 0x49, 0x1E, 0x4A, 0x1E, 0x4B, 0x1E, 0x4C, ++ 0x1E, 0x4D, 0x1E, 0x4E, 0x1E, 0x4F, 0x1E, 0x50, 0x1E, 0x51, 0x1E, 0x52, 0x1E, 0x53, 0x1E, 0x54, ++ 0x1E, 0x55, 0x1E, 0x56, 0x1E, 0x57, 0x1E, 0x58, 0x1E, 0x59, 0x1E, 0x5A, 0x1E, 0x5B, 0x1E, 0x5C, ++ 0x1E, 0x5D, 0x1E, 0x5E, 0x1E, 0x5F, 0x1E, 0x60, 0x1E, 0x61, 0x1E, 0x62, 0x1E, 0x63, 0x1E, 0x64, ++ 0x1E, 0x65, 0x1E, 0x66, 0x1E, 0x67, 0x1E, 0x68, 0x1E, 0x69, 0x1E, 0x6A, 0x1E, 0x6B, 0x1E, 0x6C, ++ 0x1E, 0x6D, 0x1E, 0x6E, 0x1E, 0x6F, 0x1E, 0x70, 0x1E, 0x71, 0x1E, 0x72, 0x1E, 0x73, 0x1E, 0x74, ++ 0x1E, 0x75, 0x1E, 0x76, 0x1E, 0x77, 0x1E, 0x78, 0x1E, 0x79, 0x1E, 0x7A, 0x1E, 0x7B, 0x1E, 0x7C, ++ 0x1E, 0x7D, 0x1E, 0x7E, 0x1E, 0x7F, 0x1E, 0x80, 0x1E, 0x81, 0x1E, 0x82, 0x1E, 0x83, 0x1E, 0x84, ++ 0x1E, 0x85, 0x1E, 0x86, 0x1E, 0x87, 0x1E, 0x88, 0x1E, 0x89, 0x1E, 0x8A, 0x1E, 0x8B, 0x1E, 0x8C, ++ 0x1E, 0x8D, 0x1E, 0x8E, 0x1E, 0x8F, 0x1E, 0x90, 0x1E, 0x91, 0x1E, 0x92, 0x1E, 0x93, 0x1E, 0x94, ++ 0x1E, 0x95, 0x1E, 0x96, 0x1E, 0x97, 0x1E, 0x98, 0x1E, 0x99, 0x1E, 0x9B, 0x1E, 0xA0, 0x1E, 0xA1, ++ 0x1E, 0xA2, 0x1E, 0xA3, 0x1E, 0xA4, 0x1E, 0xA5, 0x1E, 0xA6, 0x1E, 0xA7, 0x1E, 0xA8, 0x1E, 0xA9, ++ 0x1E, 0xAA, 0x1E, 0xAB, 0x1E, 0xAC, 0x1E, 0xAD, 0x1E, 0xAE, 0x1E, 0xAF, 0x1E, 0xB0, 0x1E, 0xB1, ++ 0x1E, 0xB2, 0x1E, 0xB3, 0x1E, 0xB4, 0x1E, 0xB5, 0x1E, 0xB6, 0x1E, 0xB7, 0x1E, 0xB8, 0x1E, 0xB9, ++ 0x1E, 0xBA, 0x1E, 0xBB, 0x1E, 0xBC, 0x1E, 0xBD, 0x1E, 0xBE, 0x1E, 0xBF, 0x1E, 0xC0, 0x1E, 0xC1, ++ 0x1E, 0xC2, 0x1E, 0xC3, 0x1E, 0xC4, 0x1E, 0xC5, 0x1E, 0xC6, 0x1E, 0xC7, 0x1E, 0xC8, 0x1E, 0xC9, ++ 0x1E, 0xCA, 0x1E, 0xCB, 0x1E, 0xCC, 0x1E, 0xCD, 0x1E, 0xCE, 0x1E, 0xCF, 0x1E, 0xD0, 0x1E, 0xD1, ++ 0x1E, 0xD2, 0x1E, 0xD3, 0x1E, 0xD4, 0x1E, 0xD5, 0x1E, 0xD6, 0x1E, 0xD7, 0x1E, 0xD8, 0x1E, 0xD9, ++ 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xDE, 0x1E, 0xDF, 0x1E, 0xE0, 0x1E, 0xE1, ++ 0x1E, 0xE2, 0x1E, 0xE3, 0x1E, 0xE4, 0x1E, 0xE5, 0x1E, 0xE6, 0x1E, 0xE7, 0x1E, 0xE8, 0x1E, 0xE9, ++ 0x1E, 0xEA, 0x1E, 0xEB, 0x1E, 0xEC, 0x1E, 0xED, 0x1E, 0xEE, 0x1E, 0xEF, 0x1E, 0xF0, 0x1E, 0xF1, ++ 0x1E, 0xF2, 0x1E, 0xF3, 0x1E, 0xF4, 0x1E, 0xF5, 0x1E, 0xF6, 0x1E, 0xF7, 0x1E, 0xF8, 0x1E, 0xF9, ++ 0x00, 0x01, 0x05, 0xBA, 0x00, 0xAC, 0x01, 0x5E, 0x01, 0x64, 0x01, 0x6A, 0x01, 0x70, 0x01, 0x76, ++ 0x01, 0x7C, 0x01, 0x82, 0x01, 0x88, 0x01, 0x8E, 0x01, 0x94, 0x01, 0x9A, 0x01, 0xA0, 0x01, 0xA6, ++ 0x01, 0xAC, 0x01, 0xB2, 0x01, 0xB8, 0x01, 0xBE, 0x01, 0xC4, 0x01, 0xCA, 0x01, 0xD0, 0x01, 0xD6, ++ 0x01, 0xDC, 0x01, 0xE2, 0x01, 0xE8, 0x01, 0xEE, 0x01, 0xF4, 0x01, 0xFA, 0x02, 0x00, 0x02, 0x06, ++ 0x02, 0x0C, 0x02, 0x12, 0x02, 0x18, 0x02, 0x1E, 0x02, 0x24, 0x02, 0x2A, 0x02, 0x30, 0x02, 0x38, ++ 0x02, 0x40, 0x02, 0x46, 0x02, 0x4C, 0x02, 0x54, 0x02, 0x5C, 0x02, 0x62, 0x02, 0x68, 0x02, 0x70, ++ 0x02, 0x78, 0x02, 0x80, 0x02, 0x88, 0x02, 0x8E, 0x02, 0x94, 0x02, 0x9A, 0x02, 0xA0, 0x02, 0xA6, ++ 0x02, 0xAC, 0x02, 0xB2, 0x02, 0xB8, 0x02, 0xBE, 0x02, 0xC4, 0x02, 0xCA, 0x02, 0xD0, 0x02, 0xD6, ++ 0x02, 0xDE, 0x02, 0xE6, 0x02, 0xEE, 0x02, 0xF6, 0x02, 0xFE, 0x03, 0x06, 0x03, 0x0C, 0x03, 0x12, ++ 0x03, 0x18, 0x03, 0x1E, 0x03, 0x24, 0x03, 0x2A, 0x03, 0x30, 0x03, 0x36, 0x03, 0x3C, 0x03, 0x42, ++ 0x03, 0x48, 0x03, 0x4E, 0x03, 0x54, 0x03, 0x5A, 0x03, 0x62, 0x03, 0x6A, 0x03, 0x70, 0x03, 0x76, ++ 0x03, 0x7C, 0x03, 0x82, 0x03, 0x8A, 0x03, 0x92, 0x03, 0x98, 0x03, 0x9E, 0x03, 0xA4, 0x03, 0xAA, ++ 0x03, 0xB0, 0x03, 0xB6, 0x03, 0xBE, 0x03, 0xC6, 0x03, 0xCE, 0x03, 0xD6, 0x03, 0xDE, 0x03, 0xE6, ++ 0x03, 0xEC, 0x03, 0xF2, 0x03, 0xF8, 0x03, 0xFE, 0x04, 0x06, 0x04, 0x0E, 0x04, 0x14, 0x04, 0x1A, ++ 0x04, 0x20, 0x04, 0x26, 0x04, 0x2C, 0x04, 0x32, 0x04, 0x38, 0x04, 0x3E, 0x04, 0x46, 0x04, 0x4E, ++ 0x04, 0x56, 0x04, 0x5E, 0x04, 0x64, 0x04, 0x6A, 0x04, 0x70, 0x04, 0x76, 0x04, 0x7C, 0x04, 0x82, ++ 0x04, 0x8A, 0x04, 0x92, 0x04, 0x9A, 0x04, 0xA2, 0x04, 0xA8, 0x04, 0xAE, 0x04, 0xB4, 0x04, 0xBA, ++ 0x04, 0xC0, 0x04, 0xC6, 0x04, 0xCE, 0x04, 0xD6, 0x04, 0xDE, 0x04, 0xE6, 0x04, 0xEC, 0x04, 0xF2, ++ 0x04, 0xF8, 0x04, 0xFE, 0x05, 0x04, 0x05, 0x0A, 0x05, 0x12, 0x05, 0x1A, 0x05, 0x22, 0x05, 0x2A, ++ 0x05, 0x30, 0x05, 0x36, 0x05, 0x3C, 0x05, 0x42, 0x05, 0x48, 0x05, 0x4E, 0x05, 0x54, 0x05, 0x5A, ++ 0x05, 0x60, 0x05, 0x66, 0x05, 0x6C, 0x05, 0x72, 0x05, 0x78, 0x05, 0x7E, 0x05, 0x84, 0x05, 0x8A, ++ 0x05, 0x90, 0x05, 0x96, 0x05, 0x9C, 0x05, 0xA2, 0x05, 0xA8, 0x05, 0xAE, 0x05, 0xB4, 0x00, 0x02, ++ 0x00, 0x41, 0x03, 0x40, 0x00, 0x02, 0x00, 0x41, 0x03, 0x41, 0x00, 0x02, 0x00, 0x45, 0x03, 0x40, ++ 0x00, 0x02, 0x00, 0x45, 0x03, 0x41, 0x00, 0x02, 0x00, 0x49, 0x03, 0x40, 0x00, 0x02, 0x00, 0x49, ++ 0x03, 0x41, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x40, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x41, 0x00, 0x02, ++ 0x00, 0x55, 0x03, 0x40, 0x00, 0x02, 0x00, 0x55, 0x03, 0x41, 0x00, 0x02, 0x00, 0x59, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x61, 0x03, 0x40, 0x00, 0x02, 0x00, 0x61, 0x03, 0x41, 0x00, 0x02, 0x00, 0x65, ++ 0x03, 0x40, 0x00, 0x02, 0x00, 0x65, 0x03, 0x41, 0x00, 0x02, 0x00, 0x69, 0x03, 0x40, 0x00, 0x02, ++ 0x00, 0x69, 0x03, 0x41, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x40, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x75, 0x03, 0x40, 0x00, 0x02, 0x00, 0x75, 0x03, 0x41, 0x00, 0x02, 0x00, 0x79, ++ 0x03, 0x41, 0x00, 0x02, 0x00, 0x43, 0x03, 0x41, 0x00, 0x02, 0x00, 0x63, 0x03, 0x41, 0x00, 0x02, ++ 0x21, 0x2A, 0x03, 0x27, 0x00, 0x02, 0x00, 0x4C, 0x03, 0x41, 0x00, 0x02, 0x00, 0x6C, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x4E, 0x03, 0x41, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x41, 0x00, 0x02, 0x00, 0x52, ++ 0x03, 0x41, 0x00, 0x02, 0x00, 0x72, 0x03, 0x41, 0x00, 0x02, 0x00, 0x53, 0x03, 0x41, 0x00, 0x02, ++ 0x00, 0x73, 0x03, 0x41, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x41, 0x00, 0x02, 0x00, 0x7A, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x55, 0x03, 0x08, 0x03, 0x04, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x04, ++ 0x00, 0x02, 0x00, 0xDC, 0x03, 0x01, 0x00, 0x02, 0x00, 0xFC, 0x03, 0x01, 0x00, 0x03, 0x00, 0x55, ++ 0x03, 0x08, 0x03, 0x0C, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x0C, 0x00, 0x02, 0x00, 0xDC, ++ 0x03, 0x40, 0x00, 0x02, 0x00, 0xFC, 0x03, 0x40, 0x00, 0x03, 0x00, 0x41, 0x03, 0x08, 0x03, 0x04, ++ 0x00, 0x03, 0x00, 0x61, 0x03, 0x08, 0x03, 0x04, 0x00, 0x03, 0x00, 0x41, 0x03, 0x07, 0x03, 0x04, ++ 0x00, 0x03, 0x00, 0x61, 0x03, 0x07, 0x03, 0x04, 0x00, 0x02, 0x21, 0x2A, 0x03, 0x0C, 0x00, 0x02, ++ 0x01, 0xEA, 0x03, 0x04, 0x00, 0x02, 0x01, 0xEB, 0x03, 0x04, 0x00, 0x02, 0x00, 0x47, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x67, 0x03, 0x41, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x40, 0x00, 0x02, 0x00, 0x6E, ++ 0x03, 0x40, 0x00, 0x02, 0x00, 0xC5, 0x03, 0x41, 0x00, 0x02, 0x00, 0xE5, 0x03, 0x41, 0x00, 0x02, ++ 0x00, 0xC6, 0x03, 0x41, 0x00, 0x02, 0x00, 0xE6, 0x03, 0x41, 0x00, 0x02, 0x00, 0xD8, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0xF8, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x08, 0x03, 0x04, 0x00, 0x03, ++ 0x00, 0x6F, 0x03, 0x08, 0x03, 0x04, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, 0x03, 0x04, 0x00, 0x03, ++ 0x00, 0x6F, 0x03, 0x03, 0x03, 0x04, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x07, 0x03, 0x04, 0x00, 0x03, ++ 0x00, 0x6F, 0x03, 0x07, 0x03, 0x04, 0x00, 0x02, 0x00, 0xC7, 0x03, 0x41, 0x00, 0x02, 0x00, 0xE7, ++ 0x03, 0x41, 0x00, 0x02, 0x01, 0x12, 0x03, 0x40, 0x00, 0x02, 0x01, 0x13, 0x03, 0x40, 0x00, 0x02, ++ 0x01, 0x12, 0x03, 0x41, 0x00, 0x02, 0x01, 0x13, 0x03, 0x41, 0x00, 0x02, 0x02, 0x28, 0x03, 0x06, ++ 0x00, 0x02, 0x02, 0x29, 0x03, 0x06, 0x00, 0x02, 0x00, 0xCF, 0x03, 0x01, 0x00, 0x02, 0x00, 0xEF, ++ 0x03, 0x01, 0x00, 0x02, 0x00, 0x4B, 0x03, 0x41, 0x00, 0x02, 0x00, 0x6B, 0x03, 0x41, 0x00, 0x02, ++ 0x21, 0x2A, 0x03, 0x23, 0x00, 0x02, 0x21, 0x2A, 0x03, 0x31, 0x00, 0x03, 0x00, 0x4C, 0x03, 0x04, ++ 0x03, 0x23, 0x00, 0x03, 0x00, 0x6C, 0x03, 0x04, 0x03, 0x23, 0x00, 0x02, 0x00, 0x4D, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x6D, 0x03, 0x41, 0x00, 0x02, 0x00, 0xD5, 0x03, 0x41, 0x00, 0x02, 0x00, 0xF5, ++ 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, 0x03, 0x08, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x03, ++ 0x03, 0x08, 0x00, 0x02, 0x01, 0x4C, 0x03, 0x40, 0x00, 0x02, 0x01, 0x4D, 0x03, 0x40, 0x00, 0x02, ++ 0x01, 0x4C, 0x03, 0x41, 0x00, 0x02, 0x01, 0x4D, 0x03, 0x41, 0x00, 0x02, 0x00, 0x50, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x70, 0x03, 0x41, 0x00, 0x03, 0x00, 0x52, 0x03, 0x04, 0x03, 0x23, 0x00, 0x03, ++ 0x00, 0x72, 0x03, 0x04, 0x03, 0x23, 0x00, 0x03, 0x00, 0x53, 0x03, 0x01, 0x03, 0x07, 0x00, 0x03, ++ 0x00, 0x73, 0x03, 0x01, 0x03, 0x07, 0x00, 0x03, 0x00, 0x53, 0x03, 0x0C, 0x03, 0x07, 0x00, 0x03, ++ 0x00, 0x73, 0x03, 0x0C, 0x03, 0x07, 0x00, 0x02, 0x1E, 0x62, 0x03, 0x07, 0x00, 0x02, 0x1E, 0x63, ++ 0x03, 0x07, 0x00, 0x02, 0x01, 0x68, 0x03, 0x41, 0x00, 0x02, 0x01, 0x69, 0x03, 0x41, 0x00, 0x03, ++ 0x00, 0x55, 0x03, 0x04, 0x03, 0x08, 0x00, 0x03, 0x00, 0x75, 0x03, 0x04, 0x03, 0x08, 0x00, 0x02, ++ 0x00, 0x57, 0x03, 0x40, 0x00, 0x02, 0x00, 0x77, 0x03, 0x40, 0x00, 0x02, 0x00, 0x57, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0x77, 0x03, 0x41, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x41, 0x00, 0x02, 0x00, 0xE2, ++ 0x03, 0x41, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x40, 0x00, 0x02, 0x00, 0xE2, 0x03, 0x40, 0x00, 0x03, ++ 0x00, 0x41, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, ++ 0x00, 0x41, 0x03, 0x02, 0x03, 0x03, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, 0x03, 0x03, 0x00, 0x02, ++ 0x1E, 0xA0, 0x03, 0x02, 0x00, 0x02, 0x1E, 0xA1, 0x03, 0x02, 0x00, 0x02, 0x01, 0x02, 0x03, 0x41, ++ 0x00, 0x02, 0x01, 0x03, 0x03, 0x41, 0x00, 0x02, 0x01, 0x02, 0x03, 0x40, 0x00, 0x02, 0x01, 0x03, ++ 0x03, 0x40, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x09, 0x00, 0x03, 0x00, 0x61, 0x03, 0x06, ++ 0x03, 0x09, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x03, 0x00, 0x03, 0x00, 0x61, 0x03, 0x06, ++ 0x03, 0x03, 0x00, 0x02, 0x1E, 0xA0, 0x03, 0x06, 0x00, 0x02, 0x1E, 0xA1, 0x03, 0x06, 0x00, 0x02, ++ 0x00, 0xCA, 0x03, 0x41, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x41, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x40, ++ 0x00, 0x02, 0x00, 0xEA, 0x03, 0x40, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, ++ 0x00, 0x65, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x03, 0x00, 0x03, ++ 0x00, 0x65, 0x03, 0x02, 0x03, 0x03, 0x00, 0x02, 0x1E, 0xB8, 0x03, 0x02, 0x00, 0x02, 0x1E, 0xB9, ++ 0x03, 0x02, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x41, 0x00, 0x02, 0x00, 0xF4, 0x03, 0x41, 0x00, 0x02, ++ 0x00, 0xD4, 0x03, 0x40, 0x00, 0x02, 0x00, 0xF4, 0x03, 0x40, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, ++ 0x03, 0x09, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, ++ 0x03, 0x03, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, 0x03, 0x03, 0x00, 0x02, 0x1E, 0xCC, 0x03, 0x02, ++ 0x00, 0x02, 0x1E, 0xCD, 0x03, 0x02, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x01, 0x00, 0x02, 0x01, 0xA1, ++ 0x03, 0x01, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x00, 0x00, 0x02, 0x01, 0xA1, 0x03, 0x00, 0x00, 0x02, ++ 0x1E, 0xCE, 0x03, 0x1B, 0x00, 0x02, 0x1E, 0xCF, 0x03, 0x1B, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x03, ++ 0x00, 0x02, 0x01, 0xA1, 0x03, 0x03, 0x00, 0x02, 0x1E, 0xCC, 0x03, 0x1B, 0x00, 0x02, 0x1E, 0xCD, ++ 0x03, 0x1B, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x01, 0x00, 0x02, 0x01, 0xB0, 0x03, 0x01, 0x00, 0x02, ++ 0x01, 0xAF, 0x03, 0x00, 0x00, 0x02, 0x01, 0xB0, 0x03, 0x00, 0x00, 0x02, 0x1E, 0xE6, 0x03, 0x1B, ++ 0x00, 0x02, 0x1E, 0xE7, 0x03, 0x1B, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x03, 0x00, 0x02, 0x01, 0xB0, ++ 0x03, 0x03, 0x00, 0x02, 0x1E, 0xE4, 0x03, 0x1B, 0x00, 0x02, 0x1E, 0xE5, 0x03, 0x1B, 0x00, 0x02, ++ 0x00, 0x59, 0x03, 0x40, 0x00, 0x02, 0x00, 0x79, 0x03, 0x40, 0x00, 0x01, 0x00, 0xAC, 0x00, 0xC0, ++ 0x00, 0xC1, 0x00, 0xC8, 0x00, 0xC9, 0x00, 0xCC, 0x00, 0xCD, 0x00, 0xD2, 0x00, 0xD3, 0x00, 0xD9, ++ 0x00, 0xDA, 0x00, 0xDD, 0x00, 0xE0, 0x00, 0xE1, 0x00, 0xE8, 0x00, 0xE9, 0x00, 0xEC, 0x00, 0xED, ++ 0x00, 0xF2, 0x00, 0xF3, 0x00, 0xF9, 0x00, 0xFA, 0x00, 0xFD, 0x01, 0x06, 0x01, 0x07, 0x01, 0x36, ++ 0x01, 0x39, 0x01, 0x3A, 0x01, 0x43, 0x01, 0x44, 0x01, 0x54, 0x01, 0x55, 0x01, 0x5A, 0x01, 0x5B, ++ 0x01, 0x79, 0x01, 0x7A, 0x01, 0xD5, 0x01, 0xD6, 0x01, 0xD7, 0x01, 0xD8, 0x01, 0xD9, 0x01, 0xDA, ++ 0x01, 0xDB, 0x01, 0xDC, 0x01, 0xDE, 0x01, 0xDF, 0x01, 0xE0, 0x01, 0xE1, 0x01, 0xE8, 0x01, 0xEC, ++ 0x01, 0xED, 0x01, 0xF4, 0x01, 0xF5, 0x01, 0xF8, 0x01, 0xF9, 0x01, 0xFA, 0x01, 0xFB, 0x01, 0xFC, ++ 0x01, 0xFD, 0x01, 0xFE, 0x01, 0xFF, 0x02, 0x2A, 0x02, 0x2B, 0x02, 0x2C, 0x02, 0x2D, 0x02, 0x30, ++ 0x02, 0x31, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x14, 0x1E, 0x15, 0x1E, 0x16, 0x1E, 0x17, 0x1E, 0x1C, ++ 0x1E, 0x1D, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0x30, 0x1E, 0x31, 0x1E, 0x32, 0x1E, 0x34, 0x1E, 0x38, ++ 0x1E, 0x39, 0x1E, 0x3E, 0x1E, 0x3F, 0x1E, 0x4C, 0x1E, 0x4D, 0x1E, 0x4E, 0x1E, 0x4F, 0x1E, 0x50, ++ 0x1E, 0x51, 0x1E, 0x52, 0x1E, 0x53, 0x1E, 0x54, 0x1E, 0x55, 0x1E, 0x5C, 0x1E, 0x5D, 0x1E, 0x64, ++ 0x1E, 0x65, 0x1E, 0x66, 0x1E, 0x67, 0x1E, 0x68, 0x1E, 0x69, 0x1E, 0x78, 0x1E, 0x79, 0x1E, 0x7A, ++ 0x1E, 0x7B, 0x1E, 0x80, 0x1E, 0x81, 0x1E, 0x82, 0x1E, 0x83, 0x1E, 0xA4, 0x1E, 0xA5, 0x1E, 0xA6, ++ 0x1E, 0xA7, 0x1E, 0xA8, 0x1E, 0xA9, 0x1E, 0xAA, 0x1E, 0xAB, 0x1E, 0xAC, 0x1E, 0xAD, 0x1E, 0xAE, ++ 0x1E, 0xAF, 0x1E, 0xB0, 0x1E, 0xB1, 0x1E, 0xB2, 0x1E, 0xB3, 0x1E, 0xB4, 0x1E, 0xB5, 0x1E, 0xB6, ++ 0x1E, 0xB7, 0x1E, 0xBE, 0x1E, 0xBF, 0x1E, 0xC0, 0x1E, 0xC1, 0x1E, 0xC2, 0x1E, 0xC3, 0x1E, 0xC4, ++ 0x1E, 0xC5, 0x1E, 0xC6, 0x1E, 0xC7, 0x1E, 0xD0, 0x1E, 0xD1, 0x1E, 0xD2, 0x1E, 0xD3, 0x1E, 0xD4, ++ 0x1E, 0xD5, 0x1E, 0xD6, 0x1E, 0xD7, 0x1E, 0xD8, 0x1E, 0xD9, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, ++ 0x1E, 0xDD, 0x1E, 0xDE, 0x1E, 0xDF, 0x1E, 0xE0, 0x1E, 0xE1, 0x1E, 0xE2, 0x1E, 0xE3, 0x1E, 0xE8, + 0x1E, 0xE9, 0x1E, 0xEA, 0x1E, 0xEB, 0x1E, 0xEC, 0x1E, 0xED, 0x1E, 0xEE, 0x1E, 0xEF, 0x1E, 0xF0, +- 0x1E, 0xF1, 0x1E, 0xF2, 0x1E, 0xF3, 0x1E, 0xF4, 0x1E, 0xF5, 0x1E, 0xF6, 0x1E, 0xF7, 0x1E, 0xF8, +- 0x1E, 0xF9, 0x21, 0x2B, 0x00, 0x01, 0x05, 0xBA, 0x00, 0xAC, 0x01, 0x5E, 0x01, 0x64, 0x01, 0x6A, +- 0x01, 0x70, 0x01, 0x76, 0x01, 0x7C, 0x01, 0x82, 0x01, 0x88, 0x01, 0x8E, 0x01, 0x94, 0x01, 0x9A, +- 0x01, 0xA0, 0x01, 0xA6, 0x01, 0xAC, 0x01, 0xB2, 0x01, 0xB8, 0x01, 0xBE, 0x01, 0xC4, 0x01, 0xCA, +- 0x01, 0xD0, 0x01, 0xD6, 0x01, 0xDC, 0x01, 0xE2, 0x01, 0xE8, 0x01, 0xEE, 0x01, 0xF4, 0x01, 0xFA, +- 0x02, 0x00, 0x02, 0x06, 0x02, 0x0C, 0x02, 0x12, 0x02, 0x18, 0x02, 0x1E, 0x02, 0x24, 0x02, 0x2A, +- 0x02, 0x30, 0x02, 0x38, 0x02, 0x40, 0x02, 0x46, 0x02, 0x4C, 0x02, 0x54, 0x02, 0x5C, 0x02, 0x62, +- 0x02, 0x68, 0x02, 0x70, 0x02, 0x78, 0x02, 0x80, 0x02, 0x88, 0x02, 0x8E, 0x02, 0x94, 0x02, 0x9A, +- 0x02, 0xA0, 0x02, 0xA6, 0x02, 0xAC, 0x02, 0xB2, 0x02, 0xB8, 0x02, 0xBE, 0x02, 0xC4, 0x02, 0xCA, +- 0x02, 0xD0, 0x02, 0xD6, 0x02, 0xDE, 0x02, 0xE6, 0x02, 0xEE, 0x02, 0xF6, 0x02, 0xFE, 0x03, 0x06, +- 0x03, 0x0C, 0x03, 0x12, 0x03, 0x18, 0x03, 0x1E, 0x03, 0x24, 0x03, 0x2A, 0x03, 0x30, 0x03, 0x36, +- 0x03, 0x3C, 0x03, 0x42, 0x03, 0x48, 0x03, 0x4E, 0x03, 0x54, 0x03, 0x5A, 0x03, 0x62, 0x03, 0x6A, +- 0x03, 0x70, 0x03, 0x76, 0x03, 0x7C, 0x03, 0x82, 0x03, 0x8A, 0x03, 0x92, 0x03, 0x98, 0x03, 0x9E, +- 0x03, 0xA4, 0x03, 0xAA, 0x03, 0xB0, 0x03, 0xB6, 0x03, 0xBE, 0x03, 0xC6, 0x03, 0xCE, 0x03, 0xD6, +- 0x03, 0xDE, 0x03, 0xE6, 0x03, 0xEC, 0x03, 0xF2, 0x03, 0xF8, 0x03, 0xFE, 0x04, 0x06, 0x04, 0x0E, +- 0x04, 0x14, 0x04, 0x1A, 0x04, 0x20, 0x04, 0x26, 0x04, 0x2C, 0x04, 0x32, 0x04, 0x38, 0x04, 0x3E, +- 0x04, 0x46, 0x04, 0x4E, 0x04, 0x56, 0x04, 0x5E, 0x04, 0x64, 0x04, 0x6A, 0x04, 0x70, 0x04, 0x76, +- 0x04, 0x7C, 0x04, 0x82, 0x04, 0x8A, 0x04, 0x92, 0x04, 0x9A, 0x04, 0xA2, 0x04, 0xA8, 0x04, 0xAE, +- 0x04, 0xB4, 0x04, 0xBA, 0x04, 0xC0, 0x04, 0xC6, 0x04, 0xCE, 0x04, 0xD6, 0x04, 0xDE, 0x04, 0xE6, +- 0x04, 0xEC, 0x04, 0xF2, 0x04, 0xF8, 0x04, 0xFE, 0x05, 0x04, 0x05, 0x0A, 0x05, 0x12, 0x05, 0x1A, +- 0x05, 0x22, 0x05, 0x2A, 0x05, 0x30, 0x05, 0x36, 0x05, 0x3C, 0x05, 0x42, 0x05, 0x48, 0x05, 0x4E, +- 0x05, 0x54, 0x05, 0x5A, 0x05, 0x60, 0x05, 0x66, 0x05, 0x6C, 0x05, 0x72, 0x05, 0x78, 0x05, 0x7E, +- 0x05, 0x84, 0x05, 0x8A, 0x05, 0x90, 0x05, 0x96, 0x05, 0x9C, 0x05, 0xA2, 0x05, 0xA8, 0x05, 0xAE, +- 0x05, 0xB4, 0x00, 0x02, 0x00, 0x41, 0x03, 0x40, 0x00, 0x02, 0x00, 0x41, 0x03, 0x41, 0x00, 0x02, +- 0x00, 0x45, 0x03, 0x40, 0x00, 0x02, 0x00, 0x45, 0x03, 0x41, 0x00, 0x02, 0x00, 0x49, 0x03, 0x40, +- 0x00, 0x02, 0x00, 0x49, 0x03, 0x41, 0x00, 0x02, 0x00, 0x4F, 0x03, 0x40, 0x00, 0x02, 0x00, 0x4F, +- 0x03, 0x41, 0x00, 0x02, 0x00, 0x55, 0x03, 0x40, 0x00, 0x02, 0x00, 0x55, 0x03, 0x41, 0x00, 0x02, +- 0x00, 0x59, 0x03, 0x41, 0x00, 0x02, 0x00, 0x61, 0x03, 0x40, 0x00, 0x02, 0x00, 0x61, 0x03, 0x41, +- 0x00, 0x02, 0x00, 0x65, 0x03, 0x40, 0x00, 0x02, 0x00, 0x65, 0x03, 0x41, 0x00, 0x02, 0x00, 0x69, +- 0x03, 0x40, 0x00, 0x02, 0x00, 0x69, 0x03, 0x41, 0x00, 0x02, 0x00, 0x6F, 0x03, 0x40, 0x00, 0x02, +- 0x00, 0x6F, 0x03, 0x41, 0x00, 0x02, 0x00, 0x75, 0x03, 0x40, 0x00, 0x02, 0x00, 0x75, 0x03, 0x41, +- 0x00, 0x02, 0x00, 0x79, 0x03, 0x41, 0x00, 0x02, 0x00, 0x43, 0x03, 0x41, 0x00, 0x02, 0x00, 0x63, +- 0x03, 0x41, 0x00, 0x02, 0x21, 0x2A, 0x03, 0x27, 0x00, 0x02, 0x00, 0x4C, 0x03, 0x41, 0x00, 0x02, +- 0x00, 0x6C, 0x03, 0x41, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x41, 0x00, 0x02, 0x00, 0x6E, 0x03, 0x41, +- 0x00, 0x02, 0x00, 0x52, 0x03, 0x41, 0x00, 0x02, 0x00, 0x72, 0x03, 0x41, 0x00, 0x02, 0x00, 0x53, +- 0x03, 0x41, 0x00, 0x02, 0x00, 0x73, 0x03, 0x41, 0x00, 0x02, 0x00, 0x5A, 0x03, 0x41, 0x00, 0x02, +- 0x00, 0x7A, 0x03, 0x41, 0x00, 0x03, 0x00, 0x55, 0x03, 0x08, 0x03, 0x04, 0x00, 0x03, 0x00, 0x75, +- 0x03, 0x08, 0x03, 0x04, 0x00, 0x02, 0x00, 0xDC, 0x03, 0x01, 0x00, 0x02, 0x00, 0xFC, 0x03, 0x01, +- 0x00, 0x03, 0x00, 0x55, 0x03, 0x08, 0x03, 0x0C, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x0C, +- 0x00, 0x02, 0x00, 0xDC, 0x03, 0x40, 0x00, 0x02, 0x00, 0xFC, 0x03, 0x40, 0x00, 0x03, 0x00, 0x41, +- 0x03, 0x08, 0x03, 0x04, 0x00, 0x03, 0x00, 0x61, 0x03, 0x08, 0x03, 0x04, 0x00, 0x03, 0x00, 0x41, +- 0x03, 0x07, 0x03, 0x04, 0x00, 0x03, 0x00, 0x61, 0x03, 0x07, 0x03, 0x04, 0x00, 0x02, 0x21, 0x2A, +- 0x03, 0x0C, 0x00, 0x02, 0x01, 0xEA, 0x03, 0x04, 0x00, 0x02, 0x01, 0xEB, 0x03, 0x04, 0x00, 0x02, +- 0x00, 0x47, 0x03, 0x41, 0x00, 0x02, 0x00, 0x67, 0x03, 0x41, 0x00, 0x02, 0x00, 0x4E, 0x03, 0x40, +- 0x00, 0x02, 0x00, 0x6E, 0x03, 0x40, 0x00, 0x02, 0x00, 0xC5, 0x03, 0x41, 0x00, 0x02, 0x00, 0xE5, +- 0x03, 0x41, 0x00, 0x02, 0x00, 0xC6, 0x03, 0x41, 0x00, 0x02, 0x00, 0xE6, 0x03, 0x41, 0x00, 0x02, +- 0x00, 0xD8, 0x03, 0x41, 0x00, 0x02, 0x00, 0xF8, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x08, +- 0x03, 0x04, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x08, 0x03, 0x04, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, +- 0x03, 0x04, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x03, 0x03, 0x04, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x07, +- 0x03, 0x04, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x07, 0x03, 0x04, 0x00, 0x02, 0x00, 0xC7, 0x03, 0x41, +- 0x00, 0x02, 0x00, 0xE7, 0x03, 0x41, 0x00, 0x02, 0x01, 0x12, 0x03, 0x40, 0x00, 0x02, 0x01, 0x13, +- 0x03, 0x40, 0x00, 0x02, 0x01, 0x12, 0x03, 0x41, 0x00, 0x02, 0x01, 0x13, 0x03, 0x41, 0x00, 0x02, +- 0x02, 0x28, 0x03, 0x06, 0x00, 0x02, 0x02, 0x29, 0x03, 0x06, 0x00, 0x02, 0x00, 0xCF, 0x03, 0x01, +- 0x00, 0x02, 0x00, 0xEF, 0x03, 0x01, 0x00, 0x02, 0x00, 0x4B, 0x03, 0x41, 0x00, 0x02, 0x00, 0x6B, +- 0x03, 0x41, 0x00, 0x02, 0x21, 0x2A, 0x03, 0x23, 0x00, 0x02, 0x21, 0x2A, 0x03, 0x31, 0x00, 0x03, +- 0x00, 0x4C, 0x03, 0x04, 0x03, 0x23, 0x00, 0x03, 0x00, 0x6C, 0x03, 0x04, 0x03, 0x23, 0x00, 0x02, +- 0x00, 0x4D, 0x03, 0x41, 0x00, 0x02, 0x00, 0x6D, 0x03, 0x41, 0x00, 0x02, 0x00, 0xD5, 0x03, 0x41, +- 0x00, 0x02, 0x00, 0xF5, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, 0x03, 0x08, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x03, 0x03, 0x08, 0x00, 0x02, 0x01, 0x4C, 0x03, 0x40, 0x00, 0x02, 0x01, 0x4D, +- 0x03, 0x40, 0x00, 0x02, 0x01, 0x4C, 0x03, 0x41, 0x00, 0x02, 0x01, 0x4D, 0x03, 0x41, 0x00, 0x02, +- 0x00, 0x50, 0x03, 0x41, 0x00, 0x02, 0x00, 0x70, 0x03, 0x41, 0x00, 0x03, 0x00, 0x52, 0x03, 0x04, +- 0x03, 0x23, 0x00, 0x03, 0x00, 0x72, 0x03, 0x04, 0x03, 0x23, 0x00, 0x03, 0x00, 0x53, 0x03, 0x01, +- 0x03, 0x07, 0x00, 0x03, 0x00, 0x73, 0x03, 0x01, 0x03, 0x07, 0x00, 0x03, 0x00, 0x53, 0x03, 0x0C, +- 0x03, 0x07, 0x00, 0x03, 0x00, 0x73, 0x03, 0x0C, 0x03, 0x07, 0x00, 0x02, 0x1E, 0x62, 0x03, 0x07, +- 0x00, 0x02, 0x1E, 0x63, 0x03, 0x07, 0x00, 0x02, 0x01, 0x68, 0x03, 0x41, 0x00, 0x02, 0x01, 0x69, +- 0x03, 0x41, 0x00, 0x03, 0x00, 0x55, 0x03, 0x04, 0x03, 0x08, 0x00, 0x03, 0x00, 0x75, 0x03, 0x04, +- 0x03, 0x08, 0x00, 0x02, 0x00, 0x57, 0x03, 0x40, 0x00, 0x02, 0x00, 0x77, 0x03, 0x40, 0x00, 0x02, +- 0x00, 0x57, 0x03, 0x41, 0x00, 0x02, 0x00, 0x77, 0x03, 0x41, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x41, +- 0x00, 0x02, 0x00, 0xE2, 0x03, 0x41, 0x00, 0x02, 0x00, 0xC2, 0x03, 0x40, 0x00, 0x02, 0x00, 0xE2, +- 0x03, 0x40, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, +- 0x03, 0x09, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x03, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, +- 0x03, 0x03, 0x00, 0x02, 0x1E, 0xA0, 0x03, 0x02, 0x00, 0x02, 0x1E, 0xA1, 0x03, 0x02, 0x00, 0x02, +- 0x01, 0x02, 0x03, 0x41, 0x00, 0x02, 0x01, 0x03, 0x03, 0x41, 0x00, 0x02, 0x01, 0x02, 0x03, 0x40, +- 0x00, 0x02, 0x01, 0x03, 0x03, 0x40, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x09, 0x00, 0x03, +- 0x00, 0x61, 0x03, 0x06, 0x03, 0x09, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x03, 0x00, 0x03, +- 0x00, 0x61, 0x03, 0x06, 0x03, 0x03, 0x00, 0x02, 0x1E, 0xA0, 0x03, 0x06, 0x00, 0x02, 0x1E, 0xA1, +- 0x03, 0x06, 0x00, 0x02, 0x00, 0xCA, 0x03, 0x41, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x41, 0x00, 0x02, +- 0x00, 0xCA, 0x03, 0x40, 0x00, 0x02, 0x00, 0xEA, 0x03, 0x40, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, +- 0x03, 0x09, 0x00, 0x03, 0x00, 0x65, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, +- 0x03, 0x03, 0x00, 0x03, 0x00, 0x65, 0x03, 0x02, 0x03, 0x03, 0x00, 0x02, 0x1E, 0xB8, 0x03, 0x02, +- 0x00, 0x02, 0x1E, 0xB9, 0x03, 0x02, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x41, 0x00, 0x02, 0x00, 0xF4, +- 0x03, 0x41, 0x00, 0x02, 0x00, 0xD4, 0x03, 0x40, 0x00, 0x02, 0x00, 0xF4, 0x03, 0x40, 0x00, 0x03, +- 0x00, 0x4F, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, 0x03, 0x09, 0x00, 0x03, +- 0x00, 0x4F, 0x03, 0x02, 0x03, 0x03, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, 0x03, 0x03, 0x00, 0x02, +- 0x1E, 0xCC, 0x03, 0x02, 0x00, 0x02, 0x1E, 0xCD, 0x03, 0x02, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x01, +- 0x00, 0x02, 0x01, 0xA1, 0x03, 0x01, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x00, 0x00, 0x02, 0x01, 0xA1, +- 0x03, 0x00, 0x00, 0x02, 0x1E, 0xCE, 0x03, 0x1B, 0x00, 0x02, 0x1E, 0xCF, 0x03, 0x1B, 0x00, 0x02, +- 0x01, 0xA0, 0x03, 0x03, 0x00, 0x02, 0x01, 0xA1, 0x03, 0x03, 0x00, 0x02, 0x1E, 0xCC, 0x03, 0x1B, +- 0x00, 0x02, 0x1E, 0xCD, 0x03, 0x1B, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x01, 0x00, 0x02, 0x01, 0xB0, +- 0x03, 0x01, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x00, 0x00, 0x02, 0x01, 0xB0, 0x03, 0x00, 0x00, 0x02, +- 0x1E, 0xE6, 0x03, 0x1B, 0x00, 0x02, 0x1E, 0xE7, 0x03, 0x1B, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x03, +- 0x00, 0x02, 0x01, 0xB0, 0x03, 0x03, 0x00, 0x02, 0x1E, 0xE4, 0x03, 0x1B, 0x00, 0x02, 0x1E, 0xE5, +- 0x03, 0x1B, 0x00, 0x02, 0x00, 0x59, 0x03, 0x40, 0x00, 0x02, 0x00, 0x79, 0x03, 0x40, 0x00, 0x01, +- 0x00, 0xAC, 0x00, 0xC0, 0x00, 0xC1, 0x00, 0xC8, 0x00, 0xC9, 0x00, 0xCC, 0x00, 0xCD, 0x00, 0xD2, +- 0x00, 0xD3, 0x00, 0xD9, 0x00, 0xDA, 0x00, 0xDD, 0x00, 0xE0, 0x00, 0xE1, 0x00, 0xE8, 0x00, 0xE9, +- 0x00, 0xEC, 0x00, 0xED, 0x00, 0xF2, 0x00, 0xF3, 0x00, 0xF9, 0x00, 0xFA, 0x00, 0xFD, 0x01, 0x06, +- 0x01, 0x07, 0x01, 0x36, 0x01, 0x39, 0x01, 0x3A, 0x01, 0x43, 0x01, 0x44, 0x01, 0x54, 0x01, 0x55, +- 0x01, 0x5A, 0x01, 0x5B, 0x01, 0x79, 0x01, 0x7A, 0x01, 0xD5, 0x01, 0xD6, 0x01, 0xD7, 0x01, 0xD8, +- 0x01, 0xD9, 0x01, 0xDA, 0x01, 0xDB, 0x01, 0xDC, 0x01, 0xDE, 0x01, 0xDF, 0x01, 0xE0, 0x01, 0xE1, +- 0x01, 0xE8, 0x01, 0xEC, 0x01, 0xED, 0x01, 0xF4, 0x01, 0xF5, 0x01, 0xF8, 0x01, 0xF9, 0x01, 0xFA, +- 0x01, 0xFB, 0x01, 0xFC, 0x01, 0xFD, 0x01, 0xFE, 0x01, 0xFF, 0x02, 0x2A, 0x02, 0x2B, 0x02, 0x2C, +- 0x02, 0x2D, 0x02, 0x30, 0x02, 0x31, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x14, 0x1E, 0x15, 0x1E, 0x16, +- 0x1E, 0x17, 0x1E, 0x1C, 0x1E, 0x1D, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0x30, 0x1E, 0x31, 0x1E, 0x32, +- 0x1E, 0x34, 0x1E, 0x38, 0x1E, 0x39, 0x1E, 0x3E, 0x1E, 0x3F, 0x1E, 0x4C, 0x1E, 0x4D, 0x1E, 0x4E, +- 0x1E, 0x4F, 0x1E, 0x50, 0x1E, 0x51, 0x1E, 0x52, 0x1E, 0x53, 0x1E, 0x54, 0x1E, 0x55, 0x1E, 0x5C, +- 0x1E, 0x5D, 0x1E, 0x64, 0x1E, 0x65, 0x1E, 0x66, 0x1E, 0x67, 0x1E, 0x68, 0x1E, 0x69, 0x1E, 0x78, +- 0x1E, 0x79, 0x1E, 0x7A, 0x1E, 0x7B, 0x1E, 0x80, 0x1E, 0x81, 0x1E, 0x82, 0x1E, 0x83, 0x1E, 0xA4, +- 0x1E, 0xA5, 0x1E, 0xA6, 0x1E, 0xA7, 0x1E, 0xA8, 0x1E, 0xA9, 0x1E, 0xAA, 0x1E, 0xAB, 0x1E, 0xAC, +- 0x1E, 0xAD, 0x1E, 0xAE, 0x1E, 0xAF, 0x1E, 0xB0, 0x1E, 0xB1, 0x1E, 0xB2, 0x1E, 0xB3, 0x1E, 0xB4, +- 0x1E, 0xB5, 0x1E, 0xB6, 0x1E, 0xB7, 0x1E, 0xBE, 0x1E, 0xBF, 0x1E, 0xC0, 0x1E, 0xC1, 0x1E, 0xC2, +- 0x1E, 0xC3, 0x1E, 0xC4, 0x1E, 0xC5, 0x1E, 0xC6, 0x1E, 0xC7, 0x1E, 0xD0, 0x1E, 0xD1, 0x1E, 0xD2, +- 0x1E, 0xD3, 0x1E, 0xD4, 0x1E, 0xD5, 0x1E, 0xD6, 0x1E, 0xD7, 0x1E, 0xD8, 0x1E, 0xD9, 0x1E, 0xDA, ++ 0x1E, 0xF1, 0x1E, 0xF2, 0x1E, 0xF3, 0x00, 0x01, 0x02, 0xFC, 0x00, 0x4F, 0x00, 0xA4, 0x00, 0xAA, ++ 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xC8, 0x00, 0xD0, 0x00, 0xD6, 0x00, 0xDE, 0x00, 0xE4, ++ 0x00, 0xEA, 0x00, 0xF2, 0x00, 0xFA, 0x01, 0x02, 0x01, 0x0A, 0x01, 0x12, 0x01, 0x1A, 0x01, 0x20, ++ 0x01, 0x26, 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x44, 0x01, 0x4C, 0x01, 0x54, 0x01, 0x5C, ++ 0x01, 0x64, 0x01, 0x6C, 0x01, 0x74, 0x01, 0x7C, 0x01, 0x84, 0x01, 0x8C, 0x01, 0x94, 0x01, 0x9C, ++ 0x01, 0xA4, 0x01, 0xAC, 0x01, 0xB4, 0x01, 0xBC, 0x01, 0xC4, 0x01, 0xCC, 0x01, 0xD4, 0x01, 0xDC, ++ 0x01, 0xE4, 0x01, 0xEC, 0x01, 0xF4, 0x01, 0xFC, 0x02, 0x04, 0x02, 0x0C, 0x02, 0x14, 0x02, 0x1C, ++ 0x02, 0x24, 0x02, 0x2C, 0x02, 0x34, 0x02, 0x3C, 0x02, 0x44, 0x02, 0x4C, 0x02, 0x54, 0x02, 0x5C, ++ 0x02, 0x64, 0x02, 0x6C, 0x02, 0x72, 0x02, 0x78, 0x02, 0x7E, 0x02, 0x84, 0x02, 0x8C, 0x02, 0x94, ++ 0x02, 0x9C, 0x02, 0xA4, 0x02, 0xAC, 0x02, 0xB4, 0x02, 0xBA, 0x02, 0xC0, 0x02, 0xC6, 0x02, 0xCC, ++ 0x02, 0xD4, 0x02, 0xDC, 0x02, 0xE4, 0x02, 0xEC, 0x02, 0xF4, 0x00, 0x02, 0x00, 0xDC, 0x03, 0x41, ++ 0x00, 0x02, 0x00, 0xFC, 0x03, 0x41, 0x00, 0x03, 0x00, 0x55, 0x03, 0x08, 0x03, 0x00, 0x00, 0x03, ++ 0x00, 0x75, 0x03, 0x08, 0x03, 0x00, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x28, 0x00, 0x03, ++ 0x00, 0x6F, 0x03, 0x04, 0x03, 0x28, 0x00, 0x02, 0x21, 0x2B, 0x03, 0x01, 0x00, 0x03, 0x00, 0x61, ++ 0x03, 0x0A, 0x03, 0x01, 0x00, 0x02, 0x01, 0x06, 0x03, 0x27, 0x00, 0x02, 0x01, 0x07, 0x03, 0x27, ++ 0x00, 0x03, 0x00, 0x45, 0x03, 0x04, 0x03, 0x00, 0x00, 0x03, 0x00, 0x65, 0x03, 0x04, 0x03, 0x00, ++ 0x00, 0x03, 0x00, 0x45, 0x03, 0x04, 0x03, 0x01, 0x00, 0x03, 0x00, 0x65, 0x03, 0x04, 0x03, 0x01, ++ 0x00, 0x03, 0x00, 0x45, 0x03, 0x06, 0x03, 0x27, 0x00, 0x03, 0x00, 0x65, 0x03, 0x06, 0x03, 0x27, ++ 0x00, 0x02, 0x00, 0xCF, 0x03, 0x41, 0x00, 0x02, 0x00, 0xEF, 0x03, 0x41, 0x00, 0x02, 0x21, 0x2A, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x4C, 0x03, 0x23, 0x03, 0x04, 0x00, 0x03, 0x00, 0x6C, 0x03, 0x23, ++ 0x03, 0x04, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, 0x03, 0x01, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x03, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x00, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x04, ++ 0x03, 0x00, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x01, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x04, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x52, 0x03, 0x23, 0x03, 0x04, 0x00, 0x03, 0x00, 0x72, 0x03, 0x23, ++ 0x03, 0x04, 0x00, 0x03, 0x00, 0x53, 0x03, 0x41, 0x03, 0x07, 0x00, 0x03, 0x00, 0x73, 0x03, 0x41, ++ 0x03, 0x07, 0x00, 0x03, 0x00, 0x53, 0x03, 0x07, 0x03, 0x23, 0x00, 0x03, 0x00, 0x73, 0x03, 0x07, ++ 0x03, 0x23, 0x00, 0x03, 0x00, 0x55, 0x03, 0x03, 0x03, 0x01, 0x00, 0x03, 0x00, 0x75, 0x03, 0x03, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, ++ 0x03, 0x00, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x23, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, ++ 0x03, 0x23, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x01, 0x00, 0x03, 0x00, 0x61, 0x03, 0x06, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x00, 0x00, 0x03, 0x00, 0x61, 0x03, 0x06, ++ 0x03, 0x00, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x23, 0x00, 0x03, 0x00, 0x61, 0x03, 0x06, ++ 0x03, 0x23, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, 0x00, 0x65, 0x03, 0x02, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x65, 0x03, 0x02, ++ 0x03, 0x00, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x23, 0x00, 0x03, 0x00, 0x65, 0x03, 0x02, ++ 0x03, 0x23, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, ++ 0x03, 0x00, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x23, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, ++ 0x03, 0x23, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x41, 0x00, 0x02, 0x01, 0xA1, 0x03, 0x41, 0x00, 0x02, ++ 0x01, 0xA0, 0x03, 0x40, 0x00, 0x02, 0x01, 0xA1, 0x03, 0x40, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x09, ++ 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x09, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, ++ 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x03, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, ++ 0x03, 0x23, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x23, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x41, ++ 0x00, 0x02, 0x01, 0xB0, 0x03, 0x41, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x40, 0x00, 0x02, 0x01, 0xB0, ++ 0x03, 0x40, 0x00, 0x03, 0x00, 0x55, 0x03, 0x09, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x09, ++ 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, 0x03, 0x03, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x03, ++ 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x23, 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, ++ 0x03, 0x23, 0x00, 0x01, 0x00, 0x4F, 0x01, 0xD7, 0x01, 0xD8, 0x01, 0xDB, 0x01, 0xDC, 0x01, 0xEC, ++ 0x01, 0xED, 0x01, 0xFA, 0x01, 0xFB, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x14, 0x1E, 0x15, 0x1E, 0x16, ++ 0x1E, 0x17, 0x1E, 0x1C, 0x1E, 0x1D, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0x30, 0x1E, 0x38, 0x1E, 0x39, ++ 0x1E, 0x4C, 0x1E, 0x4D, 0x1E, 0x50, 0x1E, 0x51, 0x1E, 0x52, 0x1E, 0x53, 0x1E, 0x5C, 0x1E, 0x5D, ++ 0x1E, 0x64, 0x1E, 0x65, 0x1E, 0x68, 0x1E, 0x69, 0x1E, 0x78, 0x1E, 0x79, 0x1E, 0xA4, 0x1E, 0xA5, ++ 0x1E, 0xA6, 0x1E, 0xA7, 0x1E, 0xAC, 0x1E, 0xAD, 0x1E, 0xAE, 0x1E, 0xAF, 0x1E, 0xB0, 0x1E, 0xB1, ++ 0x1E, 0xB6, 0x1E, 0xB7, 0x1E, 0xBE, 0x1E, 0xBF, 0x1E, 0xC0, 0x1E, 0xC1, 0x1E, 0xC6, 0x1E, 0xC7, ++ 0x1E, 0xD0, 0x1E, 0xD1, 0x1E, 0xD2, 0x1E, 0xD3, 0x1E, 0xD8, 0x1E, 0xD9, 0x1E, 0xDA, 0x1E, 0xDB, ++ 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xDE, 0x1E, 0xDF, 0x1E, 0xE0, 0x1E, 0xE1, 0x1E, 0xE2, 0x1E, 0xE3, ++ 0x1E, 0xE8, 0x1E, 0xE9, 0x1E, 0xEA, 0x1E, 0xEB, 0x1E, 0xEC, 0x1E, 0xED, 0x1E, 0xEE, 0x1E, 0xEF, ++ 0x1E, 0xF0, 0x1E, 0xF1, 0x00, 0x01, 0x02, 0xDC, 0x00, 0x49, 0x00, 0x98, 0x00, 0xA0, 0x00, 0xA8, ++ 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xC8, 0x00, 0xCE, 0x00, 0xD6, 0x00, 0xDE, 0x00, 0xE6, ++ 0x00, 0xEE, 0x00, 0xF6, 0x00, 0xFE, 0x01, 0x06, 0x01, 0x0E, 0x01, 0x16, 0x01, 0x1E, 0x01, 0x26, ++ 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x44, 0x01, 0x4C, 0x01, 0x54, 0x01, 0x5C, 0x01, 0x64, ++ 0x01, 0x6C, 0x01, 0x74, 0x01, 0x7C, 0x01, 0x84, 0x01, 0x8C, 0x01, 0x94, 0x01, 0x9C, 0x01, 0xA4, ++ 0x01, 0xAC, 0x01, 0xB4, 0x01, 0xBC, 0x01, 0xC4, 0x01, 0xCC, 0x01, 0xD4, 0x01, 0xDC, 0x01, 0xE4, ++ 0x01, 0xEC, 0x01, 0xF4, 0x01, 0xFC, 0x02, 0x04, 0x02, 0x0C, 0x02, 0x14, 0x02, 0x1C, 0x02, 0x24, ++ 0x02, 0x2C, 0x02, 0x34, 0x02, 0x3C, 0x02, 0x44, 0x02, 0x4C, 0x02, 0x54, 0x02, 0x5C, 0x02, 0x64, ++ 0x02, 0x6C, 0x02, 0x74, 0x02, 0x7C, 0x02, 0x84, 0x02, 0x8C, 0x02, 0x94, 0x02, 0x9C, 0x02, 0xA4, ++ 0x02, 0xAC, 0x02, 0xB4, 0x02, 0xBC, 0x02, 0xC4, 0x02, 0xCC, 0x02, 0xD4, 0x00, 0x03, 0x00, 0x55, ++ 0x03, 0x08, 0x03, 0x01, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x01, 0x00, 0x03, 0x00, 0x55, ++ 0x03, 0x08, 0x03, 0x40, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x40, 0x00, 0x03, 0x00, 0x4F, ++ 0x03, 0x28, 0x03, 0x04, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x28, 0x03, 0x04, 0x00, 0x02, 0x21, 0x2B, ++ 0x03, 0x41, 0x00, 0x03, 0x00, 0x61, 0x03, 0x0A, 0x03, 0x41, 0x00, 0x03, 0x00, 0x43, 0x03, 0x01, ++ 0x03, 0x27, 0x00, 0x03, 0x00, 0x63, 0x03, 0x01, 0x03, 0x27, 0x00, 0x03, 0x00, 0x45, 0x03, 0x04, ++ 0x03, 0x40, 0x00, 0x03, 0x00, 0x65, 0x03, 0x04, 0x03, 0x40, 0x00, 0x03, 0x00, 0x45, 0x03, 0x04, ++ 0x03, 0x41, 0x00, 0x03, 0x00, 0x65, 0x03, 0x04, 0x03, 0x41, 0x00, 0x03, 0x00, 0x45, 0x03, 0x27, ++ 0x03, 0x06, 0x00, 0x03, 0x00, 0x65, 0x03, 0x27, 0x03, 0x06, 0x00, 0x03, 0x00, 0x49, 0x03, 0x08, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x69, 0x03, 0x08, 0x03, 0x01, 0x00, 0x02, 0x21, 0x2A, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, 0x03, 0x41, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x03, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x40, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x04, 0x03, 0x40, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x41, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x04, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x53, 0x03, 0x23, 0x03, 0x07, 0x00, 0x03, 0x00, 0x73, 0x03, 0x23, 0x03, 0x07, ++ 0x00, 0x03, 0x00, 0x55, 0x03, 0x03, 0x03, 0x41, 0x00, 0x03, 0x00, 0x75, 0x03, 0x03, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x61, 0x03, 0x02, 0x03, 0x40, ++ 0x00, 0x03, 0x00, 0x41, 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x61, 0x03, 0x23, 0x03, 0x02, ++ 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x41, 0x00, 0x03, 0x00, 0x61, 0x03, 0x06, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x40, 0x00, 0x03, 0x00, 0x61, 0x03, 0x06, 0x03, 0x40, ++ 0x00, 0x03, 0x00, 0x41, 0x03, 0x23, 0x03, 0x06, 0x00, 0x03, 0x00, 0x61, 0x03, 0x23, 0x03, 0x06, ++ 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x65, 0x03, 0x02, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x65, 0x03, 0x02, 0x03, 0x40, ++ 0x00, 0x03, 0x00, 0x45, 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x65, 0x03, 0x23, 0x03, 0x02, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x02, 0x03, 0x40, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x23, 0x03, 0x02, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x01, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x01, 0x03, 0x1B, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x00, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x00, 0x03, 0x1B, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x09, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x09, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x03, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x03, ++ 0x00, 0x03, 0x00, 0x4F, 0x03, 0x23, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x23, 0x03, 0x1B, ++ 0x00, 0x03, 0x00, 0x55, 0x03, 0x01, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x01, 0x03, 0x1B, ++ 0x00, 0x03, 0x00, 0x55, 0x03, 0x00, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x00, 0x03, 0x1B, ++ 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x09, 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, 0x03, 0x09, ++ 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x03, 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, 0x03, 0x03, ++ 0x00, 0x03, 0x00, 0x55, 0x03, 0x23, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x23, 0x03, 0x1B, ++ 0x00, 0x01, 0x00, 0x49, 0x01, 0xD7, 0x01, 0xD8, 0x01, 0xDB, 0x01, 0xDC, 0x01, 0xEC, 0x01, 0xED, ++ 0x01, 0xFA, 0x01, 0xFB, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x14, 0x1E, 0x15, 0x1E, 0x16, 0x1E, 0x17, ++ 0x1E, 0x1C, 0x1E, 0x1D, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0x30, 0x1E, 0x4C, 0x1E, 0x4D, 0x1E, 0x50, ++ 0x1E, 0x51, 0x1E, 0x52, 0x1E, 0x53, 0x1E, 0x68, 0x1E, 0x69, 0x1E, 0x78, 0x1E, 0x79, 0x1E, 0xA4, ++ 0x1E, 0xA5, 0x1E, 0xA6, 0x1E, 0xA7, 0x1E, 0xAC, 0x1E, 0xAD, 0x1E, 0xAE, 0x1E, 0xAF, 0x1E, 0xB0, ++ 0x1E, 0xB1, 0x1E, 0xB6, 0x1E, 0xB7, 0x1E, 0xBE, 0x1E, 0xBF, 0x1E, 0xC0, 0x1E, 0xC1, 0x1E, 0xC6, ++ 0x1E, 0xC7, 0x1E, 0xD0, 0x1E, 0xD1, 0x1E, 0xD2, 0x1E, 0xD3, 0x1E, 0xD8, 0x1E, 0xD9, 0x1E, 0xDA, + 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xDE, 0x1E, 0xDF, 0x1E, 0xE0, 0x1E, 0xE1, 0x1E, 0xE2, + 0x1E, 0xE3, 0x1E, 0xE8, 0x1E, 0xE9, 0x1E, 0xEA, 0x1E, 0xEB, 0x1E, 0xEC, 0x1E, 0xED, 0x1E, 0xEE, +- 0x1E, 0xEF, 0x1E, 0xF0, 0x1E, 0xF1, 0x1E, 0xF2, 0x1E, 0xF3, 0x00, 0x01, 0x02, 0xFC, 0x00, 0x4F, +- 0x00, 0xA4, 0x00, 0xAA, 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xC8, 0x00, 0xD0, 0x00, 0xD6, +- 0x00, 0xDE, 0x00, 0xE4, 0x00, 0xEA, 0x00, 0xF2, 0x00, 0xFA, 0x01, 0x02, 0x01, 0x0A, 0x01, 0x12, +- 0x01, 0x1A, 0x01, 0x20, 0x01, 0x26, 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x44, 0x01, 0x4C, +- 0x01, 0x54, 0x01, 0x5C, 0x01, 0x64, 0x01, 0x6C, 0x01, 0x74, 0x01, 0x7C, 0x01, 0x84, 0x01, 0x8C, +- 0x01, 0x94, 0x01, 0x9C, 0x01, 0xA4, 0x01, 0xAC, 0x01, 0xB4, 0x01, 0xBC, 0x01, 0xC4, 0x01, 0xCC, +- 0x01, 0xD4, 0x01, 0xDC, 0x01, 0xE4, 0x01, 0xEC, 0x01, 0xF4, 0x01, 0xFC, 0x02, 0x04, 0x02, 0x0C, +- 0x02, 0x14, 0x02, 0x1C, 0x02, 0x24, 0x02, 0x2C, 0x02, 0x34, 0x02, 0x3C, 0x02, 0x44, 0x02, 0x4C, +- 0x02, 0x54, 0x02, 0x5C, 0x02, 0x64, 0x02, 0x6C, 0x02, 0x72, 0x02, 0x78, 0x02, 0x7E, 0x02, 0x84, +- 0x02, 0x8C, 0x02, 0x94, 0x02, 0x9C, 0x02, 0xA4, 0x02, 0xAC, 0x02, 0xB4, 0x02, 0xBA, 0x02, 0xC0, +- 0x02, 0xC6, 0x02, 0xCC, 0x02, 0xD4, 0x02, 0xDC, 0x02, 0xE4, 0x02, 0xEC, 0x02, 0xF4, 0x00, 0x02, +- 0x00, 0xDC, 0x03, 0x41, 0x00, 0x02, 0x00, 0xFC, 0x03, 0x41, 0x00, 0x03, 0x00, 0x55, 0x03, 0x08, +- 0x03, 0x00, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x00, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, +- 0x03, 0x28, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x04, 0x03, 0x28, 0x00, 0x02, 0x21, 0x2B, 0x03, 0x01, +- 0x00, 0x03, 0x00, 0x61, 0x03, 0x0A, 0x03, 0x01, 0x00, 0x02, 0x01, 0x06, 0x03, 0x27, 0x00, 0x02, +- 0x01, 0x07, 0x03, 0x27, 0x00, 0x03, 0x00, 0x45, 0x03, 0x04, 0x03, 0x00, 0x00, 0x03, 0x00, 0x65, +- 0x03, 0x04, 0x03, 0x00, 0x00, 0x03, 0x00, 0x45, 0x03, 0x04, 0x03, 0x01, 0x00, 0x03, 0x00, 0x65, +- 0x03, 0x04, 0x03, 0x01, 0x00, 0x03, 0x00, 0x45, 0x03, 0x06, 0x03, 0x27, 0x00, 0x03, 0x00, 0x65, +- 0x03, 0x06, 0x03, 0x27, 0x00, 0x02, 0x00, 0xCF, 0x03, 0x41, 0x00, 0x02, 0x00, 0xEF, 0x03, 0x41, +- 0x00, 0x02, 0x21, 0x2A, 0x03, 0x01, 0x00, 0x03, 0x00, 0x4C, 0x03, 0x23, 0x03, 0x04, 0x00, 0x03, +- 0x00, 0x6C, 0x03, 0x23, 0x03, 0x04, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x03, 0x03, 0x01, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x00, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x04, 0x03, 0x00, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x04, 0x03, 0x01, 0x00, 0x03, 0x00, 0x52, 0x03, 0x23, 0x03, 0x04, 0x00, 0x03, +- 0x00, 0x72, 0x03, 0x23, 0x03, 0x04, 0x00, 0x03, 0x00, 0x53, 0x03, 0x41, 0x03, 0x07, 0x00, 0x03, +- 0x00, 0x73, 0x03, 0x41, 0x03, 0x07, 0x00, 0x03, 0x00, 0x53, 0x03, 0x07, 0x03, 0x23, 0x00, 0x03, +- 0x00, 0x73, 0x03, 0x07, 0x03, 0x23, 0x00, 0x03, 0x00, 0x55, 0x03, 0x03, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x75, 0x03, 0x03, 0x03, 0x01, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x61, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, +- 0x00, 0x61, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x23, 0x00, 0x03, +- 0x00, 0x61, 0x03, 0x02, 0x03, 0x23, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x61, 0x03, 0x06, 0x03, 0x01, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x00, 0x00, 0x03, +- 0x00, 0x61, 0x03, 0x06, 0x03, 0x00, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x23, 0x00, 0x03, +- 0x00, 0x61, 0x03, 0x06, 0x03, 0x23, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x65, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, +- 0x00, 0x65, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x23, 0x00, 0x03, +- 0x00, 0x65, 0x03, 0x02, 0x03, 0x23, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x02, 0x03, 0x01, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x23, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x02, 0x03, 0x23, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x41, 0x00, 0x02, 0x01, 0xA1, +- 0x03, 0x41, 0x00, 0x02, 0x01, 0xA0, 0x03, 0x40, 0x00, 0x02, 0x01, 0xA1, 0x03, 0x40, 0x00, 0x03, +- 0x00, 0x4F, 0x03, 0x09, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x09, 0x03, 0x1B, 0x00, 0x03, +- 0x00, 0x4F, 0x03, 0x03, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x03, 0x03, 0x1B, 0x00, 0x03, +- 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x23, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x23, 0x00, 0x02, +- 0x01, 0xAF, 0x03, 0x41, 0x00, 0x02, 0x01, 0xB0, 0x03, 0x41, 0x00, 0x02, 0x01, 0xAF, 0x03, 0x40, +- 0x00, 0x02, 0x01, 0xB0, 0x03, 0x40, 0x00, 0x03, 0x00, 0x55, 0x03, 0x09, 0x03, 0x1B, 0x00, 0x03, +- 0x00, 0x75, 0x03, 0x09, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, 0x03, 0x03, 0x03, 0x1B, 0x00, 0x03, +- 0x00, 0x75, 0x03, 0x03, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x23, 0x00, 0x03, +- 0x00, 0x75, 0x03, 0x1B, 0x03, 0x23, 0x00, 0x01, 0x00, 0x4F, 0x01, 0xD7, 0x01, 0xD8, 0x01, 0xDB, +- 0x01, 0xDC, 0x01, 0xEC, 0x01, 0xED, 0x01, 0xFA, 0x01, 0xFB, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x14, +- 0x1E, 0x15, 0x1E, 0x16, 0x1E, 0x17, 0x1E, 0x1C, 0x1E, 0x1D, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0x30, +- 0x1E, 0x38, 0x1E, 0x39, 0x1E, 0x4C, 0x1E, 0x4D, 0x1E, 0x50, 0x1E, 0x51, 0x1E, 0x52, 0x1E, 0x53, +- 0x1E, 0x5C, 0x1E, 0x5D, 0x1E, 0x64, 0x1E, 0x65, 0x1E, 0x68, 0x1E, 0x69, 0x1E, 0x78, 0x1E, 0x79, +- 0x1E, 0xA4, 0x1E, 0xA5, 0x1E, 0xA6, 0x1E, 0xA7, 0x1E, 0xAC, 0x1E, 0xAD, 0x1E, 0xAE, 0x1E, 0xAF, +- 0x1E, 0xB0, 0x1E, 0xB1, 0x1E, 0xB6, 0x1E, 0xB7, 0x1E, 0xBE, 0x1E, 0xBF, 0x1E, 0xC0, 0x1E, 0xC1, +- 0x1E, 0xC6, 0x1E, 0xC7, 0x1E, 0xD0, 0x1E, 0xD1, 0x1E, 0xD2, 0x1E, 0xD3, 0x1E, 0xD8, 0x1E, 0xD9, +- 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xDE, 0x1E, 0xDF, 0x1E, 0xE0, 0x1E, 0xE1, +- 0x1E, 0xE2, 0x1E, 0xE3, 0x1E, 0xE8, 0x1E, 0xE9, 0x1E, 0xEA, 0x1E, 0xEB, 0x1E, 0xEC, 0x1E, 0xED, +- 0x1E, 0xEE, 0x1E, 0xEF, 0x1E, 0xF0, 0x1E, 0xF1, 0x00, 0x01, 0x02, 0xDC, 0x00, 0x49, 0x00, 0x98, +- 0x00, 0xA0, 0x00, 0xA8, 0x00, 0xB0, 0x00, 0xB8, 0x00, 0xC0, 0x00, 0xC8, 0x00, 0xCE, 0x00, 0xD6, +- 0x00, 0xDE, 0x00, 0xE6, 0x00, 0xEE, 0x00, 0xF6, 0x00, 0xFE, 0x01, 0x06, 0x01, 0x0E, 0x01, 0x16, +- 0x01, 0x1E, 0x01, 0x26, 0x01, 0x2C, 0x01, 0x34, 0x01, 0x3C, 0x01, 0x44, 0x01, 0x4C, 0x01, 0x54, +- 0x01, 0x5C, 0x01, 0x64, 0x01, 0x6C, 0x01, 0x74, 0x01, 0x7C, 0x01, 0x84, 0x01, 0x8C, 0x01, 0x94, +- 0x01, 0x9C, 0x01, 0xA4, 0x01, 0xAC, 0x01, 0xB4, 0x01, 0xBC, 0x01, 0xC4, 0x01, 0xCC, 0x01, 0xD4, +- 0x01, 0xDC, 0x01, 0xE4, 0x01, 0xEC, 0x01, 0xF4, 0x01, 0xFC, 0x02, 0x04, 0x02, 0x0C, 0x02, 0x14, +- 0x02, 0x1C, 0x02, 0x24, 0x02, 0x2C, 0x02, 0x34, 0x02, 0x3C, 0x02, 0x44, 0x02, 0x4C, 0x02, 0x54, +- 0x02, 0x5C, 0x02, 0x64, 0x02, 0x6C, 0x02, 0x74, 0x02, 0x7C, 0x02, 0x84, 0x02, 0x8C, 0x02, 0x94, +- 0x02, 0x9C, 0x02, 0xA4, 0x02, 0xAC, 0x02, 0xB4, 0x02, 0xBC, 0x02, 0xC4, 0x02, 0xCC, 0x02, 0xD4, +- 0x00, 0x03, 0x00, 0x55, 0x03, 0x08, 0x03, 0x01, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x01, +- 0x00, 0x03, 0x00, 0x55, 0x03, 0x08, 0x03, 0x40, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x40, +- 0x00, 0x03, 0x00, 0x4F, 0x03, 0x28, 0x03, 0x04, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x28, 0x03, 0x04, +- 0x00, 0x02, 0x21, 0x2B, 0x03, 0x41, 0x00, 0x03, 0x00, 0x61, 0x03, 0x0A, 0x03, 0x41, 0x00, 0x03, +- 0x00, 0x43, 0x03, 0x01, 0x03, 0x27, 0x00, 0x03, 0x00, 0x63, 0x03, 0x01, 0x03, 0x27, 0x00, 0x03, +- 0x00, 0x45, 0x03, 0x04, 0x03, 0x40, 0x00, 0x03, 0x00, 0x65, 0x03, 0x04, 0x03, 0x40, 0x00, 0x03, +- 0x00, 0x45, 0x03, 0x04, 0x03, 0x41, 0x00, 0x03, 0x00, 0x65, 0x03, 0x04, 0x03, 0x41, 0x00, 0x03, +- 0x00, 0x45, 0x03, 0x27, 0x03, 0x06, 0x00, 0x03, 0x00, 0x65, 0x03, 0x27, 0x03, 0x06, 0x00, 0x03, +- 0x00, 0x49, 0x03, 0x08, 0x03, 0x01, 0x00, 0x03, 0x00, 0x69, 0x03, 0x08, 0x03, 0x01, 0x00, 0x02, +- 0x21, 0x2A, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x03, 0x03, 0x41, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x03, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x40, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x04, 0x03, 0x40, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x04, 0x03, 0x41, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x04, 0x03, 0x41, 0x00, 0x03, 0x00, 0x53, 0x03, 0x23, 0x03, 0x07, 0x00, 0x03, 0x00, 0x73, +- 0x03, 0x23, 0x03, 0x07, 0x00, 0x03, 0x00, 0x55, 0x03, 0x03, 0x03, 0x41, 0x00, 0x03, 0x00, 0x75, +- 0x03, 0x03, 0x03, 0x41, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x61, +- 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x41, 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x61, +- 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x41, 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x61, +- 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x41, 0x00, 0x03, 0x00, 0x61, +- 0x03, 0x06, 0x03, 0x41, 0x00, 0x03, 0x00, 0x41, 0x03, 0x06, 0x03, 0x40, 0x00, 0x03, 0x00, 0x61, +- 0x03, 0x06, 0x03, 0x40, 0x00, 0x03, 0x00, 0x41, 0x03, 0x23, 0x03, 0x06, 0x00, 0x03, 0x00, 0x61, +- 0x03, 0x23, 0x03, 0x06, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x65, +- 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x45, 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x65, +- 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x45, 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x65, +- 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x02, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x02, 0x03, 0x40, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x23, 0x03, 0x02, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x01, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x01, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x00, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x00, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x09, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x1B, 0x03, 0x09, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x03, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x1B, 0x03, 0x03, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x23, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, +- 0x03, 0x23, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, 0x03, 0x01, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, +- 0x03, 0x01, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, 0x03, 0x00, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, +- 0x03, 0x00, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x09, 0x00, 0x03, 0x00, 0x75, +- 0x03, 0x1B, 0x03, 0x09, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x03, 0x00, 0x03, 0x00, 0x75, +- 0x03, 0x1B, 0x03, 0x03, 0x00, 0x03, 0x00, 0x55, 0x03, 0x23, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, +- 0x03, 0x23, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x49, 0x01, 0xD7, 0x01, 0xD8, 0x01, 0xDB, 0x01, 0xDC, +- 0x01, 0xEC, 0x01, 0xED, 0x01, 0xFA, 0x01, 0xFB, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x14, 0x1E, 0x15, +- 0x1E, 0x16, 0x1E, 0x17, 0x1E, 0x1C, 0x1E, 0x1D, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0x30, 0x1E, 0x4C, +- 0x1E, 0x4D, 0x1E, 0x50, 0x1E, 0x51, 0x1E, 0x52, 0x1E, 0x53, 0x1E, 0x68, 0x1E, 0x69, 0x1E, 0x78, +- 0x1E, 0x79, 0x1E, 0xA4, 0x1E, 0xA5, 0x1E, 0xA6, 0x1E, 0xA7, 0x1E, 0xAC, 0x1E, 0xAD, 0x1E, 0xAE, +- 0x1E, 0xAF, 0x1E, 0xB0, 0x1E, 0xB1, 0x1E, 0xB6, 0x1E, 0xB7, 0x1E, 0xBE, 0x1E, 0xBF, 0x1E, 0xC0, +- 0x1E, 0xC1, 0x1E, 0xC6, 0x1E, 0xC7, 0x1E, 0xD0, 0x1E, 0xD1, 0x1E, 0xD2, 0x1E, 0xD3, 0x1E, 0xD8, +- 0x1E, 0xD9, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xDE, 0x1E, 0xDF, 0x1E, 0xE0, +- 0x1E, 0xE1, 0x1E, 0xE2, 0x1E, 0xE3, 0x1E, 0xE8, 0x1E, 0xE9, 0x1E, 0xEA, 0x1E, 0xEB, 0x1E, 0xEC, +- 0x1E, 0xED, 0x1E, 0xEE, 0x1E, 0xEF, 0x1E, 0xF0, 0x1E, 0xF1, 0x00, 0x01, 0x00, 0x9C, 0x00, 0x0F, +- 0x00, 0x24, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, +- 0x00, 0x64, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7C, 0x00, 0x84, 0x00, 0x8C, 0x00, 0x94, 0x00, 0x03, +- 0x00, 0x55, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, +- 0x00, 0x41, 0x03, 0x0A, 0x03, 0x01, 0x00, 0x03, 0x00, 0x43, 0x03, 0x27, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x63, 0x03, 0x27, 0x03, 0x01, 0x00, 0x03, 0x00, 0x49, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, +- 0x00, 0x69, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x01, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x00, 0x00, 0x03, +- 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x00, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x01, 0x00, 0x03, +- 0x00, 0x75, 0x03, 0x1B, 0x03, 0x01, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x00, 0x00, 0x03, +- 0x00, 0x75, 0x03, 0x1B, 0x03, 0x00, 0x00, 0x01, 0x00, 0x0F, 0x01, 0xD7, 0x01, 0xD8, 0x01, 0xFA, +- 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, +- 0x1E, 0xE8, 0x1E, 0xE9, 0x1E, 0xEA, 0x1E, 0xEB, 0x00, 0x01, 0x00, 0x74, 0x00, 0x0B, 0x00, 0x1C, +- 0x00, 0x24, 0x00, 0x2C, 0x00, 0x34, 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, +- 0x00, 0x64, 0x00, 0x6C, 0x00, 0x03, 0x00, 0x41, 0x03, 0x0A, 0x03, 0x41, 0x00, 0x03, 0x00, 0x43, +- 0x03, 0x27, 0x03, 0x41, 0x00, 0x03, 0x00, 0x63, 0x03, 0x27, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, +- 0x03, 0x1B, 0x03, 0x41, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, +- 0x03, 0x1B, 0x03, 0x40, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x40, 0x00, 0x03, 0x00, 0x55, +- 0x03, 0x1B, 0x03, 0x41, 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, 0x03, 0x41, 0x00, 0x03, 0x00, 0x55, +- 0x03, 0x1B, 0x03, 0x40, 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, 0x03, 0x40, 0x00, 0x01, 0x00, 0x0B, +- 0x01, 0xFA, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xE8, +- 0x1E, 0xE9, 0x1E, 0xEA, 0x1E, 0xEB, 0x00, 0x01, 0x00, 0x6A, 0x00, 0x0A, 0x00, 0x1A, 0x00, 0x22, +- 0x00, 0x2A, 0x00, 0x32, 0x00, 0x3A, 0x00, 0x42, 0x00, 0x4A, 0x00, 0x52, 0x00, 0x5A, 0x00, 0x62, +- 0x00, 0x03, 0x00, 0x43, 0x03, 0x41, 0x03, 0x27, 0x00, 0x03, 0x00, 0x63, 0x03, 0x41, 0x03, 0x27, +- 0x00, 0x03, 0x00, 0x4F, 0x03, 0x41, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x41, 0x03, 0x1B, +- 0x00, 0x03, 0x00, 0x4F, 0x03, 0x40, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x40, 0x03, 0x1B, +- 0x00, 0x03, 0x00, 0x55, 0x03, 0x41, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x41, 0x03, 0x1B, +- 0x00, 0x03, 0x00, 0x55, 0x03, 0x40, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x40, 0x03, 0x1B, +- 0x00, 0x01, 0x00, 0x0A, 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, +- 0x1E, 0xE8, 0x1E, 0xE9, 0x1E, 0xEA, 0x1E, 0xEB, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, +- 0x00, 0x01, 0x00, 0x26, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x1C, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, +- 0x0D, 0x4A, 0x00, 0x02, 0x0D, 0x3E, 0x0D, 0x4C, 0x00, 0x02, 0x0D, 0x57, 0x00, 0x01, 0x00, 0x04, +- 0x0D, 0x4B, 0x00, 0x02, 0x0D, 0x3E, 0x00, 0x01, 0x00, 0x02, 0x0D, 0x46, 0x0D, 0x47, 0x00, 0x02, +- 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x12, +- 0x00, 0x18, 0x00, 0x02, 0x0D, 0x46, 0x0D, 0x3E, 0x00, 0x02, 0x0D, 0x47, 0x0D, 0x3E, 0x00, 0x02, +- 0x0D, 0x46, 0x0D, 0x57, 0x00, 0x01, 0x00, 0x03, 0x0D, 0x4A, 0x0D, 0x4B, 0x0D, 0x4C, 0x00, 0x04, ++ 0x1E, 0xEF, 0x1E, 0xF0, 0x1E, 0xF1, 0x00, 0x01, 0x00, 0x9C, 0x00, 0x0F, 0x00, 0x24, 0x00, 0x2C, ++ 0x00, 0x34, 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, 0x00, 0x64, 0x00, 0x6C, ++ 0x00, 0x74, 0x00, 0x7C, 0x00, 0x84, 0x00, 0x8C, 0x00, 0x94, 0x00, 0x03, 0x00, 0x55, 0x03, 0x08, ++ 0x03, 0x41, 0x00, 0x03, 0x00, 0x75, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x00, 0x41, 0x03, 0x0A, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x43, 0x03, 0x27, 0x03, 0x01, 0x00, 0x03, 0x00, 0x63, 0x03, 0x27, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x49, 0x03, 0x08, 0x03, 0x41, 0x00, 0x03, 0x00, 0x69, 0x03, 0x08, ++ 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x01, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x00, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, ++ 0x03, 0x00, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x01, 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, ++ 0x03, 0x01, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x00, 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, ++ 0x03, 0x00, 0x00, 0x01, 0x00, 0x0F, 0x01, 0xD7, 0x01, 0xD8, 0x01, 0xFA, 0x1E, 0x08, 0x1E, 0x09, ++ 0x1E, 0x2E, 0x1E, 0x2F, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xE8, 0x1E, 0xE9, ++ 0x1E, 0xEA, 0x1E, 0xEB, 0x00, 0x01, 0x00, 0x74, 0x00, 0x0B, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x2C, ++ 0x00, 0x34, 0x00, 0x3C, 0x00, 0x44, 0x00, 0x4C, 0x00, 0x54, 0x00, 0x5C, 0x00, 0x64, 0x00, 0x6C, ++ 0x00, 0x03, 0x00, 0x41, 0x03, 0x0A, 0x03, 0x41, 0x00, 0x03, 0x00, 0x43, 0x03, 0x27, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x63, 0x03, 0x27, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x41, 0x00, 0x03, 0x00, 0x4F, 0x03, 0x1B, 0x03, 0x40, ++ 0x00, 0x03, 0x00, 0x6F, 0x03, 0x1B, 0x03, 0x40, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x41, ++ 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, 0x03, 0x41, 0x00, 0x03, 0x00, 0x55, 0x03, 0x1B, 0x03, 0x40, ++ 0x00, 0x03, 0x00, 0x75, 0x03, 0x1B, 0x03, 0x40, 0x00, 0x01, 0x00, 0x0B, 0x01, 0xFA, 0x1E, 0x08, ++ 0x1E, 0x09, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xE8, 0x1E, 0xE9, 0x1E, 0xEA, ++ 0x1E, 0xEB, 0x00, 0x01, 0x00, 0x6A, 0x00, 0x0A, 0x00, 0x1A, 0x00, 0x22, 0x00, 0x2A, 0x00, 0x32, ++ 0x00, 0x3A, 0x00, 0x42, 0x00, 0x4A, 0x00, 0x52, 0x00, 0x5A, 0x00, 0x62, 0x00, 0x03, 0x00, 0x43, ++ 0x03, 0x41, 0x03, 0x27, 0x00, 0x03, 0x00, 0x63, 0x03, 0x41, 0x03, 0x27, 0x00, 0x03, 0x00, 0x4F, ++ 0x03, 0x41, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x41, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x4F, ++ 0x03, 0x40, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x6F, 0x03, 0x40, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, ++ 0x03, 0x41, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x41, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x55, ++ 0x03, 0x40, 0x03, 0x1B, 0x00, 0x03, 0x00, 0x75, 0x03, 0x40, 0x03, 0x1B, 0x00, 0x01, 0x00, 0x0A, ++ 0x1E, 0x08, 0x1E, 0x09, 0x1E, 0xDA, 0x1E, 0xDB, 0x1E, 0xDC, 0x1E, 0xDD, 0x1E, 0xE8, 0x1E, 0xE9, ++ 0x1E, 0xEA, 0x1E, 0xEB, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x26, ++ 0x00, 0x02, 0x00, 0x0A, 0x00, 0x1C, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x0D, 0x4A, 0x00, 0x02, ++ 0x0D, 0x3E, 0x0D, 0x4C, 0x00, 0x02, 0x0D, 0x57, 0x00, 0x01, 0x00, 0x04, 0x0D, 0x4B, 0x00, 0x02, ++ 0x0D, 0x3E, 0x00, 0x01, 0x00, 0x02, 0x0D, 0x46, 0x0D, 0x47, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, ++ 0x00, 0x08, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x02, ++ 0x0D, 0x46, 0x0D, 0x3E, 0x00, 0x02, 0x0D, 0x47, 0x0D, 0x3E, 0x00, 0x02, 0x0D, 0x46, 0x0D, 0x57, ++ 0x00, 0x01, 0x00, 0x03, 0x0D, 0x4A, 0x0D, 0x4B, 0x0D, 0x4C, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, ++ 0x00, 0x08, 0x00, 0x01, 0x00, 0x12, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x04, 0x10, 0x26, ++ 0x00, 0x02, 0x10, 0x2E, 0x00, 0x01, 0x00, 0x01, 0x10, 0x25, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, ++ 0x00, 0x08, 0x00, 0x01, 0x00, 0x0E, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x10, 0x25, 0x10, 0x2E, ++ 0x00, 0x01, 0x00, 0x01, 0x10, 0x26, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, ++ 0x00, 0x22, 0x00, 0x01, 0x00, 0x08, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x0B, 0x4B, ++ 0x00, 0x02, 0x0B, 0x3E, 0x0B, 0x48, 0x00, 0x02, 0x0B, 0x56, 0x0B, 0x4C, 0x00, 0x02, 0x0B, 0x57, ++ 0x00, 0x01, 0x00, 0x01, 0x0B, 0x47, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, ++ 0x00, 0x1E, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x02, 0x0B, 0x47, 0x0B, 0x56, ++ 0x00, 0x02, 0x0B, 0x47, 0x0B, 0x3E, 0x00, 0x02, 0x0B, 0x47, 0x0B, 0x57, 0x00, 0x01, 0x00, 0x03, ++ 0x0B, 0x48, 0x0B, 0x4B, 0x0B, 0x4C, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, ++ 0x00, 0x38, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x2E, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x18, ++ 0x00, 0x1E, 0x0D, 0xDA, 0x00, 0x02, 0x0D, 0xCA, 0x0D, 0xDD, 0x00, 0x03, 0x0D, 0xCF, 0x0D, 0xCA, ++ 0x0D, 0xDC, 0x00, 0x02, 0x0D, 0xCF, 0x0D, 0xDE, 0x00, 0x02, 0x0D, 0xDF, 0x00, 0x01, 0x00, 0x04, ++ 0x0D, 0xDD, 0x00, 0x02, 0x0D, 0xCA, 0x00, 0x01, 0x00, 0x02, 0x0D, 0xD9, 0x0D, 0xDC, 0x00, 0x02, ++ 0x00, 0x00, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x3C, 0x00, 0x01, 0x00, 0x26, 0x00, 0x04, 0x00, 0x0E, ++ 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x02, 0x0D, 0xD9, 0x0D, 0xCA, 0x00, 0x02, 0x0D, 0xD9, ++ 0x0D, 0xCF, 0x00, 0x02, 0x0D, 0xDC, 0x0D, 0xCA, 0x00, 0x02, 0x0D, 0xD9, 0x0D, 0xDF, 0x00, 0x01, ++ 0x00, 0x04, 0x0D, 0xDA, 0x0D, 0xDC, 0x0D, 0xDD, 0x0D, 0xDE, 0x00, 0x01, 0x00, 0x10, 0x00, 0x01, ++ 0x00, 0x08, 0x00, 0x03, 0x0D, 0xD9, 0x0D, 0xCF, 0x0D, 0xCA, 0x00, 0x01, 0x00, 0x01, 0x0D, 0xDD, ++ 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x32, 0x00, 0x03, 0x00, 0x0C, ++ 0x00, 0x16, 0x00, 0x28, 0x00, 0x01, 0x00, 0x04, 0x0B, 0x94, 0x00, 0x02, 0x0B, 0xD7, 0x00, 0x02, ++ 0x00, 0x06, 0x00, 0x0C, 0x0B, 0xCA, 0x00, 0x02, 0x0B, 0xBE, 0x0B, 0xCC, 0x00, 0x02, 0x0B, 0xD7, ++ 0x00, 0x01, 0x00, 0x04, 0x0B, 0xCB, 0x00, 0x02, 0x0B, 0xBE, 0x00, 0x01, 0x00, 0x03, 0x0B, 0x92, ++ 0x0B, 0xC6, 0x0B, 0xC7, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x26, ++ 0x00, 0x04, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x02, 0x0B, 0x92, 0x0B, 0xD7, ++ 0x00, 0x02, 0x0B, 0xC6, 0x0B, 0xBE, 0x00, 0x02, 0x0B, 0xC7, 0x0B, 0xBE, 0x00, 0x02, 0x0B, 0xC6, ++ 0x0B, 0xD7, 0x00, 0x01, 0x00, 0x04, 0x0B, 0x94, 0x0B, 0xCA, 0x0B, 0xCB, 0x0B, 0xCC, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x12, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, +- 0x00, 0x04, 0x10, 0x26, 0x00, 0x02, 0x10, 0x2E, 0x00, 0x01, 0x00, 0x01, 0x10, 0x25, 0x00, 0x02, ++ 0x00, 0x04, 0x0C, 0x48, 0x00, 0x02, 0x0C, 0x56, 0x00, 0x01, 0x00, 0x01, 0x0C, 0x46, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x0E, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, +- 0x10, 0x25, 0x10, 0x2E, 0x00, 0x01, 0x00, 0x01, 0x10, 0x26, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x01, 0x00, 0x3A, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x16, 0x00, 0x20, 0x00, 0x01, +- 0x00, 0x04, 0x0B, 0x5C, 0x00, 0x02, 0x0B, 0x3C, 0x00, 0x01, 0x00, 0x04, 0x0B, 0x5D, 0x00, 0x02, +- 0x0B, 0x3C, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x14, 0x0B, 0x4B, 0x00, 0x02, 0x0B, 0x3E, +- 0x0B, 0x48, 0x00, 0x02, 0x0B, 0x56, 0x0B, 0x4C, 0x00, 0x02, 0x0B, 0x57, 0x00, 0x01, 0x00, 0x03, +- 0x0B, 0x21, 0x0B, 0x22, 0x0B, 0x47, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, +- 0x00, 0x2E, 0x00, 0x05, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x02, +- 0x0B, 0x47, 0x0B, 0x56, 0x00, 0x02, 0x0B, 0x47, 0x0B, 0x3E, 0x00, 0x02, 0x0B, 0x47, 0x0B, 0x57, +- 0x00, 0x02, 0x0B, 0x21, 0x0B, 0x3C, 0x00, 0x02, 0x0B, 0x22, 0x0B, 0x3C, 0x00, 0x01, 0x00, 0x05, +- 0x0B, 0x48, 0x0B, 0x4B, 0x0B, 0x4C, 0x0B, 0x5C, 0x0B, 0x5D, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x01, 0x00, 0x38, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x2E, 0x00, 0x04, 0x00, 0x0A, +- 0x00, 0x10, 0x00, 0x18, 0x00, 0x1E, 0x0D, 0xDA, 0x00, 0x02, 0x0D, 0xCA, 0x0D, 0xDD, 0x00, 0x03, +- 0x0D, 0xCF, 0x0D, 0xCA, 0x0D, 0xDC, 0x00, 0x02, 0x0D, 0xCF, 0x0D, 0xDE, 0x00, 0x02, 0x0D, 0xDF, +- 0x00, 0x01, 0x00, 0x04, 0x0D, 0xDD, 0x00, 0x02, 0x0D, 0xCA, 0x00, 0x01, 0x00, 0x02, 0x0D, 0xD9, +- 0x0D, 0xDC, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x3C, 0x00, 0x01, 0x00, 0x26, +- 0x00, 0x04, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x02, 0x0D, 0xD9, 0x0D, 0xCA, +- 0x00, 0x02, 0x0D, 0xD9, 0x0D, 0xCF, 0x00, 0x02, 0x0D, 0xDC, 0x0D, 0xCA, 0x00, 0x02, 0x0D, 0xD9, +- 0x0D, 0xDF, 0x00, 0x01, 0x00, 0x04, 0x0D, 0xDA, 0x0D, 0xDC, 0x0D, 0xDD, 0x0D, 0xDE, 0x00, 0x01, +- 0x00, 0x10, 0x00, 0x01, 0x00, 0x08, 0x00, 0x03, 0x0D, 0xD9, 0x0D, 0xCF, 0x0D, 0xCA, 0x00, 0x01, +- 0x00, 0x01, 0x0D, 0xDD, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x32, +- 0x00, 0x03, 0x00, 0x0C, 0x00, 0x16, 0x00, 0x28, 0x00, 0x01, 0x00, 0x04, 0x0B, 0x94, 0x00, 0x02, +- 0x0B, 0xD7, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0x0B, 0xCA, 0x00, 0x02, 0x0B, 0xBE, 0x0B, 0xCC, +- 0x00, 0x02, 0x0B, 0xD7, 0x00, 0x01, 0x00, 0x04, 0x0B, 0xCB, 0x00, 0x02, 0x0B, 0xBE, 0x00, 0x01, +- 0x00, 0x03, 0x0B, 0x92, 0x0B, 0xC6, 0x0B, 0xC7, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, +- 0x00, 0x01, 0x00, 0x26, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x02, +- 0x0B, 0x92, 0x0B, 0xD7, 0x00, 0x02, 0x0B, 0xC6, 0x0B, 0xBE, 0x00, 0x02, 0x0B, 0xC7, 0x0B, 0xBE, +- 0x00, 0x02, 0x0B, 0xC6, 0x0B, 0xD7, 0x00, 0x01, 0x00, 0x04, 0x0B, 0x94, 0x0B, 0xCA, 0x0B, 0xCB, +- 0x0B, 0xCC, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x12, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x01, 0x00, 0x04, 0x0C, 0x48, 0x00, 0x02, 0x0C, 0x56, 0x00, 0x01, 0x00, 0x01, +- 0x0C, 0x46, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x0E, 0x00, 0x01, +- 0x00, 0x08, 0x00, 0x02, 0x0C, 0x46, 0x0C, 0x56, 0x00, 0x01, 0x00, 0x01, 0x0C, 0x48, 0x00, 0x04, +- 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0xEE, 0x00, 0x12, 0x00, 0x2A, 0x00, 0x34, +- 0x00, 0x3E, 0x00, 0x48, 0x00, 0x52, 0x00, 0x5C, 0x00, 0x66, 0x00, 0x80, 0x00, 0x8A, 0x00, 0x94, +- 0x00, 0x9E, 0x00, 0xA8, 0x00, 0xB2, 0x00, 0xBC, 0x00, 0xC6, 0x00, 0xD0, 0x00, 0xDA, 0x00, 0xE4, +- 0x00, 0x01, 0x00, 0x04, 0x0F, 0x69, 0x00, 0x02, 0x0F, 0xB5, 0x00, 0x01, 0x00, 0x04, 0x0F, 0x43, +- 0x00, 0x02, 0x0F, 0xB7, 0x00, 0x01, 0x00, 0x04, 0x0F, 0x4D, 0x00, 0x02, 0x0F, 0xB7, 0x00, 0x01, +- 0x00, 0x04, 0x0F, 0x52, 0x00, 0x02, 0x0F, 0xB7, 0x00, 0x01, 0x00, 0x04, 0x0F, 0x57, 0x00, 0x02, +- 0x0F, 0xB7, 0x00, 0x01, 0x00, 0x04, 0x0F, 0x5C, 0x00, 0x02, 0x0F, 0xB7, 0x00, 0x03, 0x00, 0x08, +- 0x00, 0x0E, 0x00, 0x14, 0x0F, 0x73, 0x00, 0x02, 0x0F, 0x72, 0x0F, 0x75, 0x00, 0x02, 0x0F, 0x74, +- 0x0F, 0x81, 0x00, 0x02, 0x0F, 0x80, 0x00, 0x01, 0x00, 0x04, 0x0F, 0x73, 0x00, 0x02, 0x0F, 0x71, +- 0x00, 0x01, 0x00, 0x04, 0x0F, 0x75, 0x00, 0x02, 0x0F, 0x71, 0x00, 0x01, 0x00, 0x04, 0x0F, 0x81, +- 0x00, 0x02, 0x0F, 0x71, 0x00, 0x01, 0x00, 0x04, 0x0F, 0xB9, 0x00, 0x02, 0x0F, 0xB5, 0x00, 0x01, +- 0x00, 0x04, 0x0F, 0x93, 0x00, 0x02, 0x0F, 0xB7, 0x00, 0x01, 0x00, 0x04, 0x0F, 0x9D, 0x00, 0x02, +- 0x0F, 0xB7, 0x00, 0x01, 0x00, 0x04, 0x0F, 0xA2, 0x00, 0x02, 0x0F, 0xB7, 0x00, 0x01, 0x00, 0x04, +- 0x0F, 0xA7, 0x00, 0x02, 0x0F, 0xB7, 0x00, 0x01, 0x00, 0x04, 0x0F, 0xAC, 0x00, 0x02, 0x0F, 0xB7, +- 0x00, 0x01, 0x00, 0x04, 0x0F, 0x76, 0x00, 0x02, 0x0F, 0x80, 0x00, 0x01, 0x00, 0x04, 0x0F, 0x78, +- 0x00, 0x02, 0x0F, 0x80, 0x00, 0x01, 0x00, 0x12, 0x0F, 0x40, 0x0F, 0x42, 0x0F, 0x4C, 0x0F, 0x51, +- 0x0F, 0x56, 0x0F, 0x5B, 0x0F, 0x71, 0x0F, 0x72, 0x0F, 0x74, 0x0F, 0x80, 0x0F, 0x90, 0x0F, 0x92, +- 0x0F, 0x9C, 0x0F, 0xA1, 0x0F, 0xA6, 0x0F, 0xAB, 0x0F, 0xB2, 0x0F, 0xB3, 0x00, 0x02, 0x00, 0x00, +- 0x00, 0x02, 0x00, 0x0A, 0x00, 0xBE, 0x00, 0x01, 0x00, 0x8E, 0x00, 0x11, 0x00, 0x28, 0x00, 0x2E, +- 0x00, 0x34, 0x00, 0x3A, 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x5E, +- 0x00, 0x64, 0x00, 0x6A, 0x00, 0x70, 0x00, 0x76, 0x00, 0x7C, 0x00, 0x82, 0x00, 0x88, 0x00, 0x02, +- 0x0F, 0x42, 0x0F, 0xB7, 0x00, 0x02, 0x0F, 0x4C, 0x0F, 0xB7, 0x00, 0x02, 0x0F, 0x51, 0x0F, 0xB7, +- 0x00, 0x02, 0x0F, 0x56, 0x0F, 0xB7, 0x00, 0x02, 0x0F, 0x5B, 0x0F, 0xB7, 0x00, 0x02, 0x0F, 0x40, +- 0x0F, 0xB5, 0x00, 0x02, 0x0F, 0x71, 0x0F, 0x72, 0x00, 0x02, 0x0F, 0x71, 0x0F, 0x74, 0x00, 0x02, +- 0x0F, 0xB2, 0x0F, 0x80, 0x00, 0x02, 0x0F, 0xB3, 0x0F, 0x80, 0x00, 0x02, 0x0F, 0x71, 0x0F, 0x80, +- 0x00, 0x02, 0x0F, 0x92, 0x0F, 0xB7, 0x00, 0x02, 0x0F, 0x9C, 0x0F, 0xB7, 0x00, 0x02, 0x0F, 0xA1, +- 0x0F, 0xB7, 0x00, 0x02, 0x0F, 0xA6, 0x0F, 0xB7, 0x00, 0x02, 0x0F, 0xAB, 0x0F, 0xB7, 0x00, 0x02, +- 0x0F, 0x90, 0x0F, 0xB5, 0x00, 0x01, 0x00, 0x11, 0x0F, 0x43, 0x0F, 0x4D, 0x0F, 0x52, 0x0F, 0x57, +- 0x0F, 0x5C, 0x0F, 0x69, 0x0F, 0x73, 0x0F, 0x75, 0x0F, 0x76, 0x0F, 0x78, 0x0F, 0x81, 0x0F, 0x93, +- 0x0F, 0x9D, 0x0F, 0xA2, 0x0F, 0xA7, 0x0F, 0xAC, 0x0F, 0xB9, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x03, +- 0x00, 0x0C, 0x00, 0x12, 0x00, 0x18, 0x00, 0x02, 0x0F, 0x72, 0x0F, 0x71, 0x00, 0x02, 0x0F, 0x74, +- 0x0F, 0x71, 0x00, 0x02, 0x0F, 0x80, 0x0F, 0x71, 0x00, 0x01, 0x00, 0x03, 0x0F, 0x73, 0x0F, 0x75, +- 0x0F, 0x81 ++ 0x0C, 0x46, 0x0C, 0x56, 0x00, 0x01, 0x00, 0x01, 0x0C, 0x48, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, ++ 0x00, 0x08, 0x00, 0x01, 0x00, 0x8A, 0x00, 0x0B, 0x00, 0x1C, 0x00, 0x26, 0x00, 0x30, 0x00, 0x3A, ++ 0x00, 0x44, 0x00, 0x4E, 0x00, 0x58, 0x00, 0x62, 0x00, 0x6C, 0x00, 0x76, 0x00, 0x80, 0x00, 0x01, ++ 0x00, 0x04, 0x1B, 0x06, 0x00, 0x02, 0x1B, 0x35, 0x00, 0x01, 0x00, 0x04, 0x1B, 0x08, 0x00, 0x02, ++ 0x1B, 0x35, 0x00, 0x01, 0x00, 0x04, 0x1B, 0x0A, 0x00, 0x02, 0x1B, 0x35, 0x00, 0x01, 0x00, 0x04, ++ 0x1B, 0x0C, 0x00, 0x02, 0x1B, 0x35, 0x00, 0x01, 0x00, 0x04, 0x1B, 0x0E, 0x00, 0x02, 0x1B, 0x35, ++ 0x00, 0x01, 0x00, 0x04, 0x1B, 0x12, 0x00, 0x02, 0x1B, 0x35, 0x00, 0x01, 0x00, 0x04, 0x1B, 0x3B, ++ 0x00, 0x02, 0x1B, 0x35, 0x00, 0x01, 0x00, 0x04, 0x1B, 0x3D, 0x00, 0x02, 0x1B, 0x35, 0x00, 0x01, ++ 0x00, 0x04, 0x1B, 0x40, 0x00, 0x02, 0x1B, 0x35, 0x00, 0x01, 0x00, 0x04, 0x1B, 0x41, 0x00, 0x02, ++ 0x1B, 0x35, 0x00, 0x01, 0x00, 0x04, 0x1B, 0x43, 0x00, 0x02, 0x1B, 0x35, 0x00, 0x01, 0x00, 0x0B, ++ 0x1B, 0x05, 0x1B, 0x07, 0x1B, 0x09, 0x1B, 0x0B, 0x1B, 0x0D, 0x1B, 0x11, 0x1B, 0x3A, 0x1B, 0x3C, ++ 0x1B, 0x3E, 0x1B, 0x3F, 0x1B, 0x42, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, ++ 0x00, 0x5E, 0x00, 0x0B, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x34, 0x00, 0x3A, ++ 0x00, 0x40, 0x00, 0x46, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x58, 0x00, 0x02, 0x1B, 0x05, 0x1B, 0x35, ++ 0x00, 0x02, 0x1B, 0x07, 0x1B, 0x35, 0x00, 0x02, 0x1B, 0x09, 0x1B, 0x35, 0x00, 0x02, 0x1B, 0x0B, ++ 0x1B, 0x35, 0x00, 0x02, 0x1B, 0x0D, 0x1B, 0x35, 0x00, 0x02, 0x1B, 0x11, 0x1B, 0x35, 0x00, 0x02, ++ 0x1B, 0x3A, 0x1B, 0x35, 0x00, 0x02, 0x1B, 0x3C, 0x1B, 0x35, 0x00, 0x02, 0x1B, 0x3E, 0x1B, 0x35, ++ 0x00, 0x02, 0x1B, 0x3F, 0x1B, 0x35, 0x00, 0x02, 0x1B, 0x42, 0x1B, 0x35, 0x00, 0x01, 0x00, 0x0B, ++ 0x1B, 0x06, 0x1B, 0x08, 0x1B, 0x0A, 0x1B, 0x0C, 0x1B, 0x0E, 0x1B, 0x12, 0x1B, 0x3B, 0x1B, 0x3D, ++ 0x1B, 0x40, 0x1B, 0x41, 0x1B, 0x43 + }; + + const le_uint8 CanonShaping::glyphDefinitionTable[] = { +@@ -3701,7 +3561,7 @@ + 0xFC, 0x00, 0xFC, 0x5D, 0x00, 0x02, 0xFC, 0x64, 0xFC, 0xF1, 0x00, 0x02, 0xFC, 0xF5, 0xFD, 0x3D, + 0x00, 0x02, 0xFD, 0x50, 0xFD, 0x8F, 0x00, 0x02, 0xFD, 0x92, 0xFD, 0xC7, 0x00, 0x02, 0xFD, 0xF0, + 0xFD, 0xFC, 0x00, 0x02, 0xFE, 0x80, 0xFE, 0xF4, 0x00, 0x01, 0xFE, 0xF5, 0xFE, 0xFC, 0x00, 0x02, +- 0x00, 0x02, 0x00, 0xC1, 0x03, 0x00, 0x03, 0x14, 0x00, 0xE6, 0x03, 0x15, 0x03, 0x15, 0x00, 0xE8, ++ 0x00, 0x02, 0x00, 0xCE, 0x03, 0x00, 0x03, 0x14, 0x00, 0xE6, 0x03, 0x15, 0x03, 0x15, 0x00, 0xE8, + 0x03, 0x16, 0x03, 0x19, 0x00, 0xDC, 0x03, 0x1A, 0x03, 0x1A, 0x00, 0xE8, 0x03, 0x1B, 0x03, 0x1B, + 0x00, 0xD8, 0x03, 0x1C, 0x03, 0x20, 0x00, 0xDC, 0x03, 0x21, 0x03, 0x22, 0x00, 0xCA, 0x03, 0x23, + 0x03, 0x26, 0x00, 0xDC, 0x03, 0x27, 0x03, 0x28, 0x00, 0xCA, 0x03, 0x29, 0x03, 0x33, 0x00, 0xDC, +@@ -3719,61 +3579,66 @@ + 0x05, 0xA7, 0x00, 0xDC, 0x05, 0xA8, 0x05, 0xA8, 0x00, 0xE6, 0x05, 0xA9, 0x05, 0xA9, 0x00, 0xE8, + 0x05, 0xAA, 0x05, 0xAA, 0x00, 0xDC, 0x05, 0xAB, 0x05, 0xAC, 0x00, 0xE6, 0x05, 0xAD, 0x05, 0xAD, + 0x00, 0xDE, 0x05, 0xAE, 0x05, 0xAE, 0x00, 0xE8, 0x05, 0xAF, 0x05, 0xAF, 0x00, 0xE6, 0x05, 0xB0, +- 0x05, 0xB8, 0x00, 0xDC, 0x05, 0xB9, 0x05, 0xB9, 0x00, 0x1B, 0x05, 0xBB, 0x05, 0xBB, 0x00, 0xDC, +- 0x05, 0xBC, 0x05, 0xBC, 0x00, 0x15, 0x05, 0xBD, 0x05, 0xBD, 0x00, 0xDC, 0x05, 0xBF, 0x05, 0xBF, +- 0x00, 0x17, 0x05, 0xC1, 0x05, 0xC1, 0x00, 0x0A, 0x05, 0xC2, 0x05, 0xC2, 0x00, 0x0B, 0x05, 0xC4, +- 0x05, 0xC4, 0x00, 0xE6, 0x05, 0xC5, 0x05, 0xC5, 0x00, 0xDC, 0x05, 0xC7, 0x05, 0xC7, 0x00, 0x12, +- 0x06, 0x10, 0x06, 0x15, 0x00, 0xE6, 0x06, 0x4B, 0x06, 0x4C, 0x00, 0x1F, 0x06, 0x4D, 0x06, 0x4D, +- 0x00, 0x1E, 0x06, 0x4E, 0x06, 0x4F, 0x00, 0x1F, 0x06, 0x50, 0x06, 0x50, 0x00, 0x1E, 0x06, 0x51, +- 0x06, 0x51, 0x00, 0x1C, 0x06, 0x52, 0x06, 0x52, 0x00, 0x1F, 0x06, 0x53, 0x06, 0x53, 0x00, 0x20, +- 0x06, 0x54, 0x06, 0x55, 0x00, 0x1B, 0x06, 0x56, 0x06, 0x56, 0x00, 0x1D, 0x06, 0x57, 0x06, 0x58, +- 0x00, 0x1F, 0x06, 0x59, 0x06, 0x5B, 0x00, 0xE6, 0x06, 0x5C, 0x06, 0x5C, 0x00, 0xDC, 0x06, 0x5D, +- 0x06, 0x5E, 0x00, 0xE6, 0x06, 0x70, 0x06, 0x70, 0x00, 0x1D, 0x06, 0xD6, 0x06, 0xDC, 0x00, 0xE6, +- 0x06, 0xDF, 0x06, 0xE0, 0x00, 0xE6, 0x06, 0xE1, 0x06, 0xE1, 0x00, 0x1F, 0x06, 0xE2, 0x06, 0xE2, +- 0x00, 0xE6, 0x06, 0xE3, 0x06, 0xE3, 0x00, 0xDC, 0x06, 0xE4, 0x06, 0xE4, 0x00, 0xE6, 0x06, 0xE7, +- 0x06, 0xE8, 0x00, 0xE6, 0x06, 0xEA, 0x06, 0xEA, 0x00, 0xDC, 0x06, 0xEB, 0x06, 0xEC, 0x00, 0xE6, +- 0x06, 0xED, 0x06, 0xED, 0x00, 0xDC, 0x07, 0x11, 0x07, 0x11, 0x00, 0x24, 0x07, 0x30, 0x07, 0x30, +- 0x00, 0xE6, 0x07, 0x31, 0x07, 0x31, 0x00, 0xDC, 0x07, 0x32, 0x07, 0x33, 0x00, 0xE6, 0x07, 0x34, +- 0x07, 0x34, 0x00, 0xDC, 0x07, 0x35, 0x07, 0x36, 0x00, 0xE6, 0x07, 0x37, 0x07, 0x39, 0x00, 0xDC, +- 0x07, 0x3A, 0x07, 0x3A, 0x00, 0xE6, 0x07, 0x3B, 0x07, 0x3C, 0x00, 0xDC, 0x07, 0x3D, 0x07, 0x3D, +- 0x00, 0xE6, 0x07, 0x3E, 0x07, 0x3E, 0x00, 0xDC, 0x07, 0x3F, 0x07, 0x41, 0x00, 0xE6, 0x07, 0x42, +- 0x07, 0x42, 0x00, 0xDC, 0x07, 0x43, 0x07, 0x43, 0x00, 0xE6, 0x07, 0x44, 0x07, 0x44, 0x00, 0xDC, +- 0x07, 0x45, 0x07, 0x45, 0x00, 0xE6, 0x07, 0x46, 0x07, 0x46, 0x00, 0xDC, 0x07, 0x47, 0x07, 0x47, +- 0x00, 0xE6, 0x07, 0x48, 0x07, 0x48, 0x00, 0xDC, 0x07, 0x49, 0x07, 0x4A, 0x00, 0xE6, 0x09, 0x3C, +- 0x09, 0x3C, 0x00, 0x07, 0x09, 0x4D, 0x09, 0x4D, 0x00, 0x09, 0x09, 0x51, 0x09, 0x51, 0x00, 0xE6, +- 0x09, 0x52, 0x09, 0x52, 0x00, 0xDC, 0x09, 0x53, 0x09, 0x54, 0x00, 0xE6, 0x09, 0xBC, 0x09, 0xBC, +- 0x00, 0x07, 0x09, 0xCD, 0x09, 0xCD, 0x00, 0x09, 0x0A, 0x3C, 0x0A, 0x3C, 0x00, 0x07, 0x0A, 0x4D, +- 0x0A, 0x4D, 0x00, 0x09, 0x0A, 0xBC, 0x0A, 0xBC, 0x00, 0x07, 0x0A, 0xCD, 0x0A, 0xCD, 0x00, 0x09, +- 0x0B, 0x3C, 0x0B, 0x3C, 0x00, 0x07, 0x0B, 0x4D, 0x0B, 0x4D, 0x00, 0x09, 0x0B, 0xCD, 0x0B, 0xCD, +- 0x00, 0x09, 0x0C, 0x4D, 0x0C, 0x4D, 0x00, 0x09, 0x0C, 0x55, 0x0C, 0x55, 0x00, 0x54, 0x0C, 0x56, +- 0x0C, 0x56, 0x00, 0x5B, 0x0C, 0xBC, 0x0C, 0xBC, 0x00, 0x07, 0x0C, 0xCD, 0x0C, 0xCD, 0x00, 0x09, +- 0x0D, 0x4D, 0x0D, 0x4D, 0x00, 0x09, 0x0D, 0xCA, 0x0D, 0xCA, 0x00, 0x09, 0x0E, 0x38, 0x0E, 0x39, +- 0x00, 0x67, 0x0E, 0x3A, 0x0E, 0x3A, 0x00, 0x09, 0x0E, 0x48, 0x0E, 0x4B, 0x00, 0x6B, 0x0E, 0xB8, +- 0x0E, 0xB9, 0x00, 0x76, 0x0E, 0xC8, 0x0E, 0xCB, 0x00, 0x7A, 0x0F, 0x18, 0x0F, 0x19, 0x00, 0xDC, +- 0x0F, 0x35, 0x0F, 0x35, 0x00, 0xDC, 0x0F, 0x37, 0x0F, 0x37, 0x00, 0xDC, 0x0F, 0x39, 0x0F, 0x39, +- 0x00, 0xD8, 0x0F, 0x71, 0x0F, 0x71, 0x00, 0x81, 0x0F, 0x72, 0x0F, 0x72, 0x00, 0x82, 0x0F, 0x74, +- 0x0F, 0x74, 0x00, 0x84, 0x0F, 0x7A, 0x0F, 0x7D, 0x00, 0x82, 0x0F, 0x80, 0x0F, 0x80, 0x00, 0x82, +- 0x0F, 0x82, 0x0F, 0x83, 0x00, 0xE6, 0x0F, 0x84, 0x0F, 0x84, 0x00, 0x09, 0x0F, 0x86, 0x0F, 0x87, +- 0x00, 0xE6, 0x0F, 0xC6, 0x0F, 0xC6, 0x00, 0xDC, 0x10, 0x37, 0x10, 0x37, 0x00, 0x07, 0x10, 0x39, +- 0x10, 0x39, 0x00, 0x09, 0x13, 0x5F, 0x13, 0x5F, 0x00, 0xE6, 0x17, 0x14, 0x17, 0x14, 0x00, 0x09, +- 0x17, 0x34, 0x17, 0x34, 0x00, 0x09, 0x17, 0xD2, 0x17, 0xD2, 0x00, 0x09, 0x17, 0xDD, 0x17, 0xDD, +- 0x00, 0xE6, 0x18, 0xA9, 0x18, 0xA9, 0x00, 0xE4, 0x19, 0x39, 0x19, 0x39, 0x00, 0xDE, 0x19, 0x3A, +- 0x19, 0x3A, 0x00, 0xE6, 0x19, 0x3B, 0x19, 0x3B, 0x00, 0xDC, 0x1A, 0x17, 0x1A, 0x17, 0x00, 0xE6, +- 0x1A, 0x18, 0x1A, 0x18, 0x00, 0xDC, 0x1D, 0xC0, 0x1D, 0xC1, 0x00, 0xE6, 0x1D, 0xC2, 0x1D, 0xC2, +- 0x00, 0xDC, 0x1D, 0xC3, 0x1D, 0xC3, 0x00, 0xE6, 0x20, 0xD0, 0x20, 0xD1, 0x00, 0xE6, 0x20, 0xD2, +- 0x20, 0xD3, 0x00, 0x01, 0x20, 0xD4, 0x20, 0xD7, 0x00, 0xE6, 0x20, 0xD8, 0x20, 0xDA, 0x00, 0x01, +- 0x20, 0xDB, 0x20, 0xDC, 0x00, 0xE6, 0x20, 0xE1, 0x20, 0xE1, 0x00, 0xE6, 0x20, 0xE5, 0x20, 0xE6, +- 0x00, 0x01, 0x20, 0xE7, 0x20, 0xE7, 0x00, 0xE6, 0x20, 0xE8, 0x20, 0xE8, 0x00, 0xDC, 0x20, 0xE9, +- 0x20, 0xE9, 0x00, 0xE6, 0x20, 0xEA, 0x20, 0xEB, 0x00, 0x01, 0x30, 0x2A, 0x30, 0x2A, 0x00, 0xDA, +- 0x30, 0x2B, 0x30, 0x2B, 0x00, 0xE4, 0x30, 0x2C, 0x30, 0x2C, 0x00, 0xE8, 0x30, 0x2D, 0x30, 0x2D, +- 0x00, 0xDE, 0x30, 0x2E, 0x30, 0x2F, 0x00, 0xE0, 0x30, 0x99, 0x30, 0x9A, 0x00, 0x08, 0xA8, 0x06, +- 0xA8, 0x06, 0x00, 0x09, 0xFB, 0x1E, 0xFB, 0x1E, 0x00, 0x1A, 0xFE, 0x20, 0xFE, 0x23, 0x00, 0xE6, +- 0x0A, 0x0D, 0x0A, 0x0D, 0x00, 0xDC, 0x0A, 0x0F, 0x0A, 0x0F, 0x00, 0xE6, 0x0A, 0x38, 0x0A, 0x38, +- 0x00, 0xE6, 0x0A, 0x39, 0x0A, 0x39, 0x00, 0x01, 0x0A, 0x3A, 0x0A, 0x3A, 0x00, 0xDC, 0x0A, 0x3F, +- 0x0A, 0x3F, 0x00, 0x09, 0xD1, 0x65, 0xD1, 0x66, 0x00, 0xD8, 0xD1, 0x67, 0xD1, 0x69, 0x00, 0x01, +- 0xD1, 0x6D, 0xD1, 0x6D, 0x00, 0xE2, 0xD1, 0x6E, 0xD1, 0x72, 0x00, 0xD8, 0xD1, 0x7B, 0xD1, 0x82, +- 0x00, 0xDC, 0xD1, 0x85, 0xD1, 0x89, 0x00, 0xE6, 0xD1, 0x8A, 0xD1, 0x8B, 0x00, 0xDC, 0xD1, 0xAA, +- 0xD1, 0xAD, 0x00, 0xE6, 0xD2, 0x42, 0xD2, 0x44, 0x00, 0xE6 ++ 0x05, 0xB8, 0x00, 0xDC, 0x05, 0xB9, 0x05, 0xB9, 0x00, 0x1B, 0x05, 0xBA, 0x05, 0xBA, 0x00, 0x13, ++ 0x05, 0xBB, 0x05, 0xBB, 0x00, 0xDC, 0x05, 0xBC, 0x05, 0xBC, 0x00, 0x15, 0x05, 0xBD, 0x05, 0xBD, ++ 0x00, 0xDC, 0x05, 0xBF, 0x05, 0xBF, 0x00, 0x17, 0x05, 0xC1, 0x05, 0xC1, 0x00, 0x0A, 0x05, 0xC2, ++ 0x05, 0xC2, 0x00, 0x0B, 0x05, 0xC4, 0x05, 0xC4, 0x00, 0xE6, 0x05, 0xC5, 0x05, 0xC5, 0x00, 0xDC, ++ 0x05, 0xC7, 0x05, 0xC7, 0x00, 0x12, 0x06, 0x10, 0x06, 0x15, 0x00, 0xE6, 0x06, 0x4B, 0x06, 0x4C, ++ 0x00, 0x1F, 0x06, 0x4D, 0x06, 0x4D, 0x00, 0x1E, 0x06, 0x4E, 0x06, 0x4F, 0x00, 0x1F, 0x06, 0x50, ++ 0x06, 0x50, 0x00, 0x1E, 0x06, 0x51, 0x06, 0x51, 0x00, 0x1C, 0x06, 0x52, 0x06, 0x52, 0x00, 0x1F, ++ 0x06, 0x53, 0x06, 0x53, 0x00, 0x20, 0x06, 0x54, 0x06, 0x55, 0x00, 0x1B, 0x06, 0x56, 0x06, 0x56, ++ 0x00, 0x1D, 0x06, 0x57, 0x06, 0x58, 0x00, 0x1F, 0x06, 0x59, 0x06, 0x5B, 0x00, 0xE6, 0x06, 0x5C, ++ 0x06, 0x5C, 0x00, 0xDC, 0x06, 0x5D, 0x06, 0x5E, 0x00, 0xE6, 0x06, 0x70, 0x06, 0x70, 0x00, 0x1D, ++ 0x06, 0xD6, 0x06, 0xDC, 0x00, 0xE6, 0x06, 0xDF, 0x06, 0xE0, 0x00, 0xE6, 0x06, 0xE1, 0x06, 0xE1, ++ 0x00, 0x1F, 0x06, 0xE2, 0x06, 0xE2, 0x00, 0xE6, 0x06, 0xE3, 0x06, 0xE3, 0x00, 0xDC, 0x06, 0xE4, ++ 0x06, 0xE4, 0x00, 0xE6, 0x06, 0xE7, 0x06, 0xE8, 0x00, 0xE6, 0x06, 0xEA, 0x06, 0xEA, 0x00, 0xDC, ++ 0x06, 0xEB, 0x06, 0xEC, 0x00, 0xE6, 0x06, 0xED, 0x06, 0xED, 0x00, 0xDC, 0x07, 0x11, 0x07, 0x11, ++ 0x00, 0x24, 0x07, 0x30, 0x07, 0x30, 0x00, 0xE6, 0x07, 0x31, 0x07, 0x31, 0x00, 0xDC, 0x07, 0x32, ++ 0x07, 0x33, 0x00, 0xE6, 0x07, 0x34, 0x07, 0x34, 0x00, 0xDC, 0x07, 0x35, 0x07, 0x36, 0x00, 0xE6, ++ 0x07, 0x37, 0x07, 0x39, 0x00, 0xDC, 0x07, 0x3A, 0x07, 0x3A, 0x00, 0xE6, 0x07, 0x3B, 0x07, 0x3C, ++ 0x00, 0xDC, 0x07, 0x3D, 0x07, 0x3D, 0x00, 0xE6, 0x07, 0x3E, 0x07, 0x3E, 0x00, 0xDC, 0x07, 0x3F, ++ 0x07, 0x41, 0x00, 0xE6, 0x07, 0x42, 0x07, 0x42, 0x00, 0xDC, 0x07, 0x43, 0x07, 0x43, 0x00, 0xE6, ++ 0x07, 0x44, 0x07, 0x44, 0x00, 0xDC, 0x07, 0x45, 0x07, 0x45, 0x00, 0xE6, 0x07, 0x46, 0x07, 0x46, ++ 0x00, 0xDC, 0x07, 0x47, 0x07, 0x47, 0x00, 0xE6, 0x07, 0x48, 0x07, 0x48, 0x00, 0xDC, 0x07, 0x49, ++ 0x07, 0x4A, 0x00, 0xE6, 0x07, 0xEB, 0x07, 0xF1, 0x00, 0xE6, 0x07, 0xF2, 0x07, 0xF2, 0x00, 0xDC, ++ 0x07, 0xF3, 0x07, 0xF3, 0x00, 0xE6, 0x09, 0x3C, 0x09, 0x3C, 0x00, 0x07, 0x09, 0x4D, 0x09, 0x4D, ++ 0x00, 0x09, 0x09, 0x51, 0x09, 0x51, 0x00, 0xE6, 0x09, 0x52, 0x09, 0x52, 0x00, 0xDC, 0x09, 0x53, ++ 0x09, 0x54, 0x00, 0xE6, 0x09, 0xBC, 0x09, 0xBC, 0x00, 0x07, 0x09, 0xCD, 0x09, 0xCD, 0x00, 0x09, ++ 0x0A, 0x3C, 0x0A, 0x3C, 0x00, 0x07, 0x0A, 0x4D, 0x0A, 0x4D, 0x00, 0x09, 0x0A, 0xBC, 0x0A, 0xBC, ++ 0x00, 0x07, 0x0A, 0xCD, 0x0A, 0xCD, 0x00, 0x09, 0x0B, 0x3C, 0x0B, 0x3C, 0x00, 0x07, 0x0B, 0x4D, ++ 0x0B, 0x4D, 0x00, 0x09, 0x0B, 0xCD, 0x0B, 0xCD, 0x00, 0x09, 0x0C, 0x4D, 0x0C, 0x4D, 0x00, 0x09, ++ 0x0C, 0x55, 0x0C, 0x55, 0x00, 0x54, 0x0C, 0x56, 0x0C, 0x56, 0x00, 0x5B, 0x0C, 0xBC, 0x0C, 0xBC, ++ 0x00, 0x07, 0x0C, 0xCD, 0x0C, 0xCD, 0x00, 0x09, 0x0D, 0x4D, 0x0D, 0x4D, 0x00, 0x09, 0x0D, 0xCA, ++ 0x0D, 0xCA, 0x00, 0x09, 0x0E, 0x38, 0x0E, 0x39, 0x00, 0x67, 0x0E, 0x3A, 0x0E, 0x3A, 0x00, 0x09, ++ 0x0E, 0x48, 0x0E, 0x4B, 0x00, 0x6B, 0x0E, 0xB8, 0x0E, 0xB9, 0x00, 0x76, 0x0E, 0xC8, 0x0E, 0xCB, ++ 0x00, 0x7A, 0x0F, 0x18, 0x0F, 0x19, 0x00, 0xDC, 0x0F, 0x35, 0x0F, 0x35, 0x00, 0xDC, 0x0F, 0x37, ++ 0x0F, 0x37, 0x00, 0xDC, 0x0F, 0x39, 0x0F, 0x39, 0x00, 0xD8, 0x0F, 0x71, 0x0F, 0x71, 0x00, 0x81, ++ 0x0F, 0x72, 0x0F, 0x72, 0x00, 0x82, 0x0F, 0x74, 0x0F, 0x74, 0x00, 0x84, 0x0F, 0x7A, 0x0F, 0x7D, ++ 0x00, 0x82, 0x0F, 0x80, 0x0F, 0x80, 0x00, 0x82, 0x0F, 0x82, 0x0F, 0x83, 0x00, 0xE6, 0x0F, 0x84, ++ 0x0F, 0x84, 0x00, 0x09, 0x0F, 0x86, 0x0F, 0x87, 0x00, 0xE6, 0x0F, 0xC6, 0x0F, 0xC6, 0x00, 0xDC, ++ 0x10, 0x37, 0x10, 0x37, 0x00, 0x07, 0x10, 0x39, 0x10, 0x39, 0x00, 0x09, 0x13, 0x5F, 0x13, 0x5F, ++ 0x00, 0xE6, 0x17, 0x14, 0x17, 0x14, 0x00, 0x09, 0x17, 0x34, 0x17, 0x34, 0x00, 0x09, 0x17, 0xD2, ++ 0x17, 0xD2, 0x00, 0x09, 0x17, 0xDD, 0x17, 0xDD, 0x00, 0xE6, 0x18, 0xA9, 0x18, 0xA9, 0x00, 0xE4, ++ 0x19, 0x39, 0x19, 0x39, 0x00, 0xDE, 0x19, 0x3A, 0x19, 0x3A, 0x00, 0xE6, 0x19, 0x3B, 0x19, 0x3B, ++ 0x00, 0xDC, 0x1A, 0x17, 0x1A, 0x17, 0x00, 0xE6, 0x1A, 0x18, 0x1A, 0x18, 0x00, 0xDC, 0x1B, 0x34, ++ 0x1B, 0x34, 0x00, 0x07, 0x1B, 0x44, 0x1B, 0x44, 0x00, 0x09, 0x1B, 0x6B, 0x1B, 0x6B, 0x00, 0xE6, ++ 0x1B, 0x6C, 0x1B, 0x6C, 0x00, 0xDC, 0x1B, 0x6D, 0x1B, 0x73, 0x00, 0xE6, 0x1D, 0xC0, 0x1D, 0xC1, ++ 0x00, 0xE6, 0x1D, 0xC2, 0x1D, 0xC2, 0x00, 0xDC, 0x1D, 0xC3, 0x1D, 0xC9, 0x00, 0xE6, 0x1D, 0xCA, ++ 0x1D, 0xCA, 0x00, 0xDC, 0x1D, 0xFE, 0x1D, 0xFE, 0x00, 0xE6, 0x1D, 0xFF, 0x1D, 0xFF, 0x00, 0xDC, ++ 0x20, 0xD0, 0x20, 0xD1, 0x00, 0xE6, 0x20, 0xD2, 0x20, 0xD3, 0x00, 0x01, 0x20, 0xD4, 0x20, 0xD7, ++ 0x00, 0xE6, 0x20, 0xD8, 0x20, 0xDA, 0x00, 0x01, 0x20, 0xDB, 0x20, 0xDC, 0x00, 0xE6, 0x20, 0xE1, ++ 0x20, 0xE1, 0x00, 0xE6, 0x20, 0xE5, 0x20, 0xE6, 0x00, 0x01, 0x20, 0xE7, 0x20, 0xE7, 0x00, 0xE6, ++ 0x20, 0xE8, 0x20, 0xE8, 0x00, 0xDC, 0x20, 0xE9, 0x20, 0xE9, 0x00, 0xE6, 0x20, 0xEA, 0x20, 0xEB, ++ 0x00, 0x01, 0x20, 0xEC, 0x20, 0xEF, 0x00, 0xDC, 0x30, 0x2A, 0x30, 0x2A, 0x00, 0xDA, 0x30, 0x2B, ++ 0x30, 0x2B, 0x00, 0xE4, 0x30, 0x2C, 0x30, 0x2C, 0x00, 0xE8, 0x30, 0x2D, 0x30, 0x2D, 0x00, 0xDE, ++ 0x30, 0x2E, 0x30, 0x2F, 0x00, 0xE0, 0x30, 0x99, 0x30, 0x9A, 0x00, 0x08, 0xA8, 0x06, 0xA8, 0x06, ++ 0x00, 0x09, 0xFB, 0x1E, 0xFB, 0x1E, 0x00, 0x1A, 0xFE, 0x20, 0xFE, 0x23, 0x00, 0xE6, 0x0A, 0x0D, ++ 0x0A, 0x0D, 0x00, 0xDC, 0x0A, 0x0F, 0x0A, 0x0F, 0x00, 0xE6, 0x0A, 0x38, 0x0A, 0x38, 0x00, 0xE6, ++ 0x0A, 0x39, 0x0A, 0x39, 0x00, 0x01, 0x0A, 0x3A, 0x0A, 0x3A, 0x00, 0xDC, 0x0A, 0x3F, 0x0A, 0x3F, ++ 0x00, 0x09, 0xD1, 0x65, 0xD1, 0x66, 0x00, 0xD8, 0xD1, 0x67, 0xD1, 0x69, 0x00, 0x01, 0xD1, 0x6D, ++ 0xD1, 0x6D, 0x00, 0xE2, 0xD1, 0x6E, 0xD1, 0x72, 0x00, 0xD8, 0xD1, 0x7B, 0xD1, 0x82, 0x00, 0xDC, ++ 0xD1, 0x85, 0xD1, 0x89, 0x00, 0xE6, 0xD1, 0x8A, 0xD1, 0x8B, 0x00, 0xDC, 0xD1, 0xAA, 0xD1, 0xAD, ++ 0x00, 0xE6, 0xD2, 0x42, 0xD2, 0x44, 0x00, 0xE6 + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/CanonShaping.h b/src/share/native/sun/font/layout/CanonShaping.h +--- jdk/src/share/native/sun/font/layout/CanonShaping.h ++++ jdk/src/share/native/sun/font/layout/CanonShaping.h +@@ -38,7 +38,7 @@ + + class LEGlyphStorage; + +-class CanonShaping /* not : public UObject because all members are static */ ++class U_LAYOUT_API CanonShaping /* not : public UObject because all members are static */ + { + public: + static const le_uint8 glyphSubstitutionTable[]; +diff --git a/src/share/native/sun/font/layout/ClassDefinitionTables.cpp b/src/share/native/sun/font/layout/ClassDefinitionTables.cpp +--- jdk/src/share/native/sun/font/layout/ClassDefinitionTables.cpp ++++ jdk/src/share/native/sun/font/layout/ClassDefinitionTables.cpp +@@ -93,7 +93,7 @@ + TTGlyphID firstGlyph = SWAPW(startGlyph); + TTGlyphID lastGlyph = firstGlyph + SWAPW(glyphCount); + +- if (ttGlyphID > firstGlyph && ttGlyphID < lastGlyph) { ++ if (ttGlyphID >= firstGlyph && ttGlyphID < lastGlyph) { + return SWAPW(classValueArray[ttGlyphID - firstGlyph]); + } + +diff --git a/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp b/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp +--- jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp +@@ -52,18 +52,23 @@ + le_uint16 substCount, + GlyphIterator *glyphIterator, + const LEFontInstance *fontInstance, +- le_int32 position) ++ le_int32 position, ++ LEErrorCode& success) + { ++ if (LE_FAILURE(success)) { ++ return; ++ } ++ + GlyphIterator tempIterator(*glyphIterator); + +- for (le_int16 subst = 0; subst < substCount; subst += 1) { ++ for (le_int16 subst = 0; subst < substCount && LE_SUCCESS(success); subst += 1) { + le_uint16 sequenceIndex = SWAPW(substLookupRecordArray[subst].sequenceIndex); + le_uint16 lookupListIndex = SWAPW(substLookupRecordArray[subst].lookupListIndex); + + tempIterator.setCurrStreamPosition(position); + tempIterator.next(sequenceIndex); + +- lookupProcessor->applySingleLookup(lookupListIndex, &tempIterator, fontInstance); ++ lookupProcessor->applySingleLookup(lookupListIndex, &tempIterator, fontInstance, success); + } + } + +@@ -165,9 +170,15 @@ + return TRUE; + } + +-le_uint32 ContextualSubstitutionSubtable::process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++le_uint32 ContextualSubstitutionSubtable::process(const LookupProcessor *lookupProcessor, ++ GlyphIterator *glyphIterator, ++ const LEFontInstance *fontInstance, ++ LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + switch(SWAPW(subtableFormat)) + { + case 0: +@@ -176,22 +187,19 @@ + case 1: + { + const ContextualSubstitutionFormat1Subtable *subtable = (const ContextualSubstitutionFormat1Subtable *) this; +- +- return subtable->process(lookupProcessor, glyphIterator, fontInstance); ++ return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); + } + + case 2: + { + const ContextualSubstitutionFormat2Subtable *subtable = (const ContextualSubstitutionFormat2Subtable *) this; +- +- return subtable->process(lookupProcessor, glyphIterator, fontInstance); ++ return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); + } + + case 3: + { + const ContextualSubstitutionFormat3Subtable *subtable = (const ContextualSubstitutionFormat3Subtable *) this; +- +- return subtable->process(lookupProcessor, glyphIterator, fontInstance); ++ return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); + } + + default: +@@ -199,9 +207,15 @@ + } + } + +-le_uint32 ContextualSubstitutionFormat1Subtable::process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++le_uint32 ContextualSubstitutionFormat1Subtable::process(const LookupProcessor *lookupProcessor, ++ GlyphIterator *glyphIterator, ++ const LEFontInstance *fontInstance, ++ LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + LEGlyphID glyph = glyphIterator->getCurrGlyphID(); + le_int32 coverageIndex = getGlyphCoverage(glyph); + +@@ -227,7 +241,7 @@ + const SubstitutionLookupRecord *substLookupRecordArray = + (const SubstitutionLookupRecord *) &subRuleTable->inputGlyphArray[matchCount]; + +- applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position); ++ applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); + + return matchCount + 1; + } +@@ -242,9 +256,15 @@ + return 0; + } + +-le_uint32 ContextualSubstitutionFormat2Subtable::process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++le_uint32 ContextualSubstitutionFormat2Subtable::process(const LookupProcessor *lookupProcessor, ++ GlyphIterator *glyphIterator, ++ const LEFontInstance *fontInstance, ++ LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + LEGlyphID glyph = glyphIterator->getCurrGlyphID(); + le_int32 coverageIndex = getGlyphCoverage(glyph); + +@@ -273,7 +293,7 @@ + const SubstitutionLookupRecord *substLookupRecordArray = + (const SubstitutionLookupRecord *) &subClassRuleTable->classArray[matchCount]; + +- applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position); ++ applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); + + return matchCount + 1; + } +@@ -288,9 +308,15 @@ + return 0; + } + +-le_uint32 ContextualSubstitutionFormat3Subtable::process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance)const ++le_uint32 ContextualSubstitutionFormat3Subtable::process(const LookupProcessor *lookupProcessor, ++ GlyphIterator *glyphIterator, ++ const LEFontInstance *fontInstance, ++ LEErrorCode& success)const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + le_uint16 gCount = SWAPW(glyphCount); + le_uint16 subCount = SWAPW(substCount); + le_int32 position = glyphIterator->getCurrStreamPosition(); +@@ -305,7 +331,7 @@ + const SubstitutionLookupRecord *substLookupRecordArray = + (const SubstitutionLookupRecord *) &coverageTableOffsetArray[gCount]; + +- ContextualSubstitutionBase::applySubstitutionLookups(lookupProcessor, substLookupRecordArray, subCount, glyphIterator, fontInstance, position); ++ ContextualSubstitutionBase::applySubstitutionLookups(lookupProcessor, substLookupRecordArray, subCount, glyphIterator, fontInstance, position, success); + + return gCount + 1; + } +@@ -315,9 +341,15 @@ + return 0; + } + +-le_uint32 ChainingContextualSubstitutionSubtable::process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++le_uint32 ChainingContextualSubstitutionSubtable::process(const LookupProcessor *lookupProcessor, ++ GlyphIterator *glyphIterator, ++ const LEFontInstance *fontInstance, ++ LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + switch(SWAPW(subtableFormat)) + { + case 0: +@@ -326,22 +358,19 @@ + case 1: + { + const ChainingContextualSubstitutionFormat1Subtable *subtable = (const ChainingContextualSubstitutionFormat1Subtable *) this; +- +- return subtable->process(lookupProcessor, glyphIterator, fontInstance); ++ return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); + } + + case 2: + { + const ChainingContextualSubstitutionFormat2Subtable *subtable = (const ChainingContextualSubstitutionFormat2Subtable *) this; +- +- return subtable->process(lookupProcessor, glyphIterator, fontInstance); ++ return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); + } + + case 3: + { + const ChainingContextualSubstitutionFormat3Subtable *subtable = (const ChainingContextualSubstitutionFormat3Subtable *) this; +- +- return subtable->process(lookupProcessor, glyphIterator, fontInstance); ++ return subtable->process(lookupProcessor, glyphIterator, fontInstance, success); + } + + default: +@@ -355,9 +384,15 @@ + // emptyFeatureList matches an le_uint32 or an le_uint16... + static const FeatureMask emptyFeatureList = 0x00000000UL; + +-le_uint32 ChainingContextualSubstitutionFormat1Subtable::process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++le_uint32 ChainingContextualSubstitutionFormat1Subtable::process(const LookupProcessor *lookupProcessor, ++ GlyphIterator *glyphIterator, ++ const LEFontInstance *fontInstance, ++ LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + LEGlyphID glyph = glyphIterator->getCurrGlyphID(); + le_int32 coverageIndex = getGlyphCoverage(glyph); + +@@ -405,7 +440,7 @@ + const SubstitutionLookupRecord *substLookupRecordArray = + (const SubstitutionLookupRecord *) &lookaheadGlyphArray[lookaheadGlyphCount + 1]; + +- applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position); ++ applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); + + return inputGlyphCount + 1; + } +@@ -420,9 +455,15 @@ + return 0; + } + +-le_uint32 ChainingContextualSubstitutionFormat2Subtable::process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++le_uint32 ChainingContextualSubstitutionFormat2Subtable::process(const LookupProcessor *lookupProcessor, ++ GlyphIterator *glyphIterator, ++ const LEFontInstance *fontInstance, ++ LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + LEGlyphID glyph = glyphIterator->getCurrGlyphID(); + le_int32 coverageIndex = getGlyphCoverage(glyph); + +@@ -479,7 +520,7 @@ + const SubstitutionLookupRecord *substLookupRecordArray = + (const SubstitutionLookupRecord *) &lookaheadClassArray[lookaheadGlyphCount + 1]; + +- applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position); ++ applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); + + return inputGlyphCount + 1; + } +@@ -494,9 +535,15 @@ + return 0; + } + +-le_uint32 ChainingContextualSubstitutionFormat3Subtable::process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++le_uint32 ChainingContextualSubstitutionFormat3Subtable::process(const LookupProcessor *lookupProcessor, ++ GlyphIterator *glyphIterator, ++ const LEFontInstance *fontInstance, ++ LEErrorCode & success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + le_uint16 backtrkGlyphCount = SWAPW(backtrackGlyphCount); + le_uint16 inputGlyphCount = (le_uint16) SWAPW(backtrackCoverageTableOffsetArray[backtrkGlyphCount]); + const Offset *inputCoverageTableOffsetArray = &backtrackCoverageTableOffsetArray[backtrkGlyphCount + 1]; +@@ -534,7 +581,7 @@ + const SubstitutionLookupRecord *substLookupRecordArray = + (const SubstitutionLookupRecord *) &lookaheadCoverageTableOffsetArray[lookaheadGlyphCount + 1]; + +- ContextualSubstitutionBase::applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position); ++ ContextualSubstitutionBase::applySubstitutionLookups(lookupProcessor, substLookupRecordArray, substCount, glyphIterator, fontInstance, position, success); + + return inputGlyphCount; + } +diff --git a/src/share/native/sun/font/layout/ContextualSubstSubtables.h b/src/share/native/sun/font/layout/ContextualSubstSubtables.h +--- jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.h ++++ jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.h +@@ -72,12 +72,13 @@ + le_uint16 substCount, + GlyphIterator *glyphIterator, + const LEFontInstance *fontInstance, +- le_int32 position); ++ le_int32 position, ++ LEErrorCode& success); + }; + + struct ContextualSubstitutionSubtable : ContextualSubstitutionBase + { +- le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + struct ContextualSubstitutionFormat1Subtable : ContextualSubstitutionSubtable +@@ -85,7 +86,7 @@ + le_uint16 subRuleSetCount; + Offset subRuleSetTableOffsetArray[ANY_NUMBER]; + +- le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + struct SubRuleSetTable +@@ -110,7 +111,7 @@ + le_uint16 subClassSetCount; + Offset subClassSetTableOffsetArray[ANY_NUMBER]; + +- le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + struct SubClassSetTable +@@ -140,12 +141,12 @@ + Offset coverageTableOffsetArray[ANY_NUMBER]; + //SubstitutionLookupRecord substLookupRecord[ANY_NUMBER]; + +- le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + struct ChainingContextualSubstitutionSubtable : ContextualSubstitutionBase + { +- le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + struct ChainingContextualSubstitutionFormat1Subtable : ChainingContextualSubstitutionSubtable +@@ -153,7 +154,7 @@ + le_uint16 chainSubRuleSetCount; + Offset chainSubRuleSetTableOffsetArray[ANY_NUMBER]; + +- le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + struct ChainSubRuleSetTable +@@ -184,7 +185,7 @@ + le_uint16 chainSubClassSetCount; + Offset chainSubClassSetTableOffsetArray[ANY_NUMBER]; + +- le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + struct ChainSubClassSetTable +@@ -222,7 +223,7 @@ + //le_uint16 substCount; + //SubstitutionLookupRecord substLookupRecord[ANY_NUMBER]; + +- le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 process(const LookupProcessor *lookupProcessor, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/CoverageTables.cpp b/src/share/native/sun/font/layout/CoverageTables.cpp +--- jdk/src/share/native/sun/font/layout/CoverageTables.cpp ++++ jdk/src/share/native/sun/font/layout/CoverageTables.cpp +@@ -73,6 +73,10 @@ + le_uint16 probe = power; + le_uint16 index = 0; + ++ if (count == 0) { ++ return -1; ++ } ++ + if (SWAPW(glyphArray[extra]) <= ttGlyphID) { + index = extra; + } +diff --git a/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp b/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp +--- jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp +@@ -59,6 +59,8 @@ + + entryAnchorTable->getAnchor(glyphID, fontInstance, entryAnchor); + glyphIterator->setCursiveEntryPoint(entryAnchor); ++ } else { ++ //glyphIterator->clearCursiveEntryPoint(); + } + + if (exitOffset != 0) { +@@ -66,6 +68,8 @@ + + exitAnchorTable->getAnchor(glyphID, fontInstance, exitAnchor); + glyphIterator->setCursiveExitPoint(exitAnchor); ++ } else { ++ //glyphIterator->clearCursiveExitPoint(); + } + + return 1; +diff --git a/src/share/native/sun/font/layout/DeviceTables.cpp b/src/share/native/sun/font/layout/DeviceTables.cpp +--- jdk/src/share/native/sun/font/layout/DeviceTables.cpp ++++ jdk/src/share/native/sun/font/layout/DeviceTables.cpp +@@ -41,13 +41,15 @@ + const le_uint16 DeviceTable::fieldSignBits[] = {0x0002, 0x0008, 0x0080}; + const le_uint16 DeviceTable::fieldBits[] = { 2, 4, 8}; + ++#define FORMAT_COUNT LE_ARRAY_SIZE(fieldBits) ++ + le_int16 DeviceTable::getAdjustment(le_uint16 ppem) const + { + le_uint16 start = SWAPW(startSize); + le_uint16 format = SWAPW(deltaFormat) - 1; + le_int16 result = 0; + +- if (ppem >= start && ppem <= SWAPW(endSize)) { ++ if (ppem >= start && ppem <= SWAPW(endSize) && format < FORMAT_COUNT) { + le_uint16 sizeIndex = ppem - start; + le_uint16 bits = fieldBits[format]; + le_uint16 count = 16 / bits; +diff --git a/src/share/native/sun/font/layout/ExtensionSubtables.cpp b/src/share/native/sun/font/layout/ExtensionSubtables.cpp +--- jdk/src/share/native/sun/font/layout/ExtensionSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/ExtensionSubtables.cpp +@@ -40,18 +40,24 @@ + + U_NAMESPACE_BEGIN + ++// read a 32-bit value that might only be 16-bit-aligned in memory ++#define READ_LONG(code) (le_uint32)((SWAPW(*(le_uint16*)&code) << 16) + SWAPW(*(((le_uint16*)&code) + 1))) + + // FIXME: should look at the format too... maybe have a sub-class for it? + le_uint32 ExtensionSubtable::process(const LookupProcessor *lookupProcessor, le_uint16 lookupType, +- GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const ++ GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + le_uint16 elt = SWAPW(extensionLookupType); + + if (elt != lookupType) { +- le_uint32 extOffset = SWAPL(extensionOffset); ++ le_uint32 extOffset = READ_LONG(extensionOffset); + LookupSubtable *subtable = (LookupSubtable *) ((char *) this + extOffset); + +- return lookupProcessor->applySubtable(subtable, elt, glyphIterator, fontInstance); ++ return lookupProcessor->applySubtable(subtable, elt, glyphIterator, fontInstance, success); + } + + return 0; +diff --git a/src/share/native/sun/font/layout/ExtensionSubtables.h b/src/share/native/sun/font/layout/ExtensionSubtables.h +--- jdk/src/share/native/sun/font/layout/ExtensionSubtables.h ++++ jdk/src/share/native/sun/font/layout/ExtensionSubtables.h +@@ -53,7 +53,7 @@ + le_uint32 extensionOffset; + + le_uint32 process(const LookupProcessor *lookupProcessor, le_uint16 lookupType, +- GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/Features.cpp b/src/share/native/sun/font/layout/Features.cpp +--- jdk/src/share/native/sun/font/layout/Features.cpp ++++ jdk/src/share/native/sun/font/layout/Features.cpp +@@ -33,7 +33,7 @@ + #include "LETypes.h" + #include "OpenTypeUtilities.h" + #include "OpenTypeTables.h" +-#include "Features.h" ++#include "ICUFeatures.h" + #include "LESwaps.h" + + U_NAMESPACE_BEGIN +diff --git a/src/share/native/sun/font/layout/GXLayoutEngine.cpp b/src/share/native/sun/font/layout/GXLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/GXLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/GXLayoutEngine.cpp +@@ -41,8 +41,8 @@ + + UOBJECT_DEFINE_RTTI_IMPLEMENTATION(GXLayoutEngine) + +-GXLayoutEngine::GXLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, const MorphTableHeader *morphTable) +- : LayoutEngine(fontInstance, scriptCode, languageCode, 0), fMorphTable(morphTable) ++GXLayoutEngine::GXLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, const MorphTableHeader *morphTable, LEErrorCode &success) ++ : LayoutEngine(fontInstance, scriptCode, languageCode, 0, success), fMorphTable(morphTable) + { + // nothing else to do? + } +diff --git a/src/share/native/sun/font/layout/GXLayoutEngine.h b/src/share/native/sun/font/layout/GXLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/GXLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/GXLayoutEngine.h +@@ -67,13 +67,14 @@ + * @param scriptCode - the script + * @param langaugeCode - the language + * @param morphTable - the 'mort' table ++ * @param success - set to an error code if the operation fails + * + * @see LayoutEngine::layoutEngineFactory + * @see ScriptAndLangaugeTags.h for script and language codes + * + * @internal + */ +- GXLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, const MorphTableHeader *morphTable); ++ GXLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, const MorphTableHeader *morphTable, LEErrorCode &success); + + /** + * The destructor, virtual for correct polymorphic invocation. +diff --git a/src/share/native/sun/font/layout/GlyphIterator.cpp b/src/share/native/sun/font/layout/GlyphIterator.cpp +--- jdk/src/share/native/sun/font/layout/GlyphIterator.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphIterator.cpp +@@ -44,7 +44,7 @@ + FeatureMask theFeatureMask, const GlyphDefinitionTableHeader *theGlyphDefinitionTableHeader) + : direction(1), position(-1), nextLimit(-1), prevLimit(-1), + glyphStorage(theGlyphStorage), glyphPositionAdjustments(theGlyphPositionAdjustments), +- srcIndex(-1), destIndex(-1), lookupFlags(theLookupFlags), featureMask(theFeatureMask), ++ srcIndex(-1), destIndex(-1), lookupFlags(theLookupFlags), featureMask(theFeatureMask), glyphGroup(0), + glyphClassDefinitionTable(NULL), markAttachClassDefinitionTable(NULL) + + { +@@ -78,6 +78,7 @@ + destIndex = that.destIndex; + lookupFlags = that.lookupFlags; + featureMask = that.featureMask; ++ glyphGroup = that.glyphGroup; + glyphClassDefinitionTable = that.glyphClassDefinitionTable; + markAttachClassDefinitionTable = that.markAttachClassDefinitionTable; + } +@@ -95,6 +96,7 @@ + destIndex = that.destIndex; + lookupFlags = that.lookupFlags; + featureMask = newFeatureMask; ++ glyphGroup = 0; + glyphClassDefinitionTable = that.glyphClassDefinitionTable; + markAttachClassDefinitionTable = that.markAttachClassDefinitionTable; + } +@@ -112,6 +114,7 @@ + destIndex = that.destIndex; + lookupFlags = newLookupFlags; + featureMask = that.featureMask; ++ glyphGroup = that.glyphGroup; + glyphClassDefinitionTable = that.glyphClassDefinitionTable; + markAttachClassDefinitionTable = that.markAttachClassDefinitionTable; + } +@@ -125,12 +128,13 @@ + { + position = prevLimit; + featureMask = newFeatureMask; ++ glyphGroup = 0; + lookupFlags = newLookupFlags; + } + +-LEGlyphID *GlyphIterator::insertGlyphs(le_int32 count) ++LEGlyphID *GlyphIterator::insertGlyphs(le_int32 count, LEErrorCode& success) + { +- return glyphStorage.insertGlyphs(position, count); ++ return glyphStorage.insertGlyphs(position, count, success); + } + + le_int32 GlyphIterator::applyInsertions() +@@ -299,6 +303,36 @@ + glyphPositionAdjustments->setYAdvance(position, yAdvanceAdjust); + } + ++void GlyphIterator::clearCursiveEntryPoint() ++{ ++ if (direction < 0) { ++ if (position <= nextLimit || position >= prevLimit) { ++ return; ++ } ++ } else { ++ if (position <= prevLimit || position >= nextLimit) { ++ return; ++ } ++ } ++ ++ glyphPositionAdjustments->clearEntryPoint(position); ++} ++ ++void GlyphIterator::clearCursiveExitPoint() ++{ ++ if (direction < 0) { ++ if (position <= nextLimit || position >= prevLimit) { ++ return; ++ } ++ } else { ++ if (position <= prevLimit || position >= nextLimit) { ++ return; ++ } ++ } ++ ++ glyphPositionAdjustments->clearExitPoint(position); ++} ++ + void GlyphIterator::setCursiveEntryPoint(LEPoint &entryPoint) + { + if (direction < 0) { +@@ -391,7 +425,7 @@ + } + } + +-le_bool GlyphIterator::hasFeatureTag() const ++le_bool GlyphIterator::hasFeatureTag(le_bool matchGroup) const + { + if (featureMask == 0) { + return TRUE; +@@ -400,14 +434,18 @@ + LEErrorCode success = LE_NO_ERROR; + FeatureMask fm = glyphStorage.getAuxData(position, success); + +- return (fm & featureMask) != 0; ++ return ((fm & featureMask) == featureMask) && (!matchGroup || (le_int32)(fm & LE_GLYPH_GROUP_MASK) == glyphGroup); + } + + le_bool GlyphIterator::findFeatureTag() + { ++ //glyphGroup = 0; ++ + while (nextInternal()) { +- if (hasFeatureTag()) { +- prevInternal(); ++ if (hasFeatureTag(FALSE)) { ++ LEErrorCode success = LE_NO_ERROR; ++ ++ glyphGroup = (glyphStorage.getAuxData(position, success) & LE_GLYPH_GROUP_MASK); + return TRUE; + } + } +@@ -435,7 +473,7 @@ + + le_bool GlyphIterator::next(le_uint32 delta) + { +- return nextInternal(delta) && hasFeatureTag(); ++ return nextInternal(delta) && hasFeatureTag(TRUE); + } + + le_bool GlyphIterator::prevInternal(le_uint32 delta) +@@ -457,7 +495,7 @@ + + le_bool GlyphIterator::prev(le_uint32 delta) + { +- return prevInternal(delta) && hasFeatureTag(); ++ return prevInternal(delta) && hasFeatureTag(TRUE); + } + + le_int32 GlyphIterator::getMarkComponent(le_int32 markPosition) const +diff --git a/src/share/native/sun/font/layout/GlyphIterator.h b/src/share/native/sun/font/layout/GlyphIterator.h +--- jdk/src/share/native/sun/font/layout/GlyphIterator.h ++++ jdk/src/share/native/sun/font/layout/GlyphIterator.h +@@ -88,16 +88,18 @@ + void setCurrGlyphPositionAdjustment(float xPlacementAdjust, float yPlacementAdjust, + float xAdvanceAdjust, float yAdvanceAdjust); + ++ void clearCursiveEntryPoint(); ++ void clearCursiveExitPoint(); + void setCursiveEntryPoint(LEPoint &entryPoint); + void setCursiveExitPoint(LEPoint &exitPoint); + void setCursiveGlyph(); + +- LEGlyphID *insertGlyphs(le_int32 count); ++ LEGlyphID *insertGlyphs(le_int32 count, LEErrorCode& success); + le_int32 applyInsertions(); + + private: + le_bool filterGlyph(le_uint32 index) const; +- le_bool hasFeatureTag() const; ++ le_bool hasFeatureTag(le_bool matchGroup) const; + le_bool nextInternal(le_uint32 delta = 1); + le_bool prevInternal(le_uint32 delta = 1); + +@@ -113,6 +115,7 @@ + le_int32 destIndex; + le_uint16 lookupFlags; + FeatureMask featureMask; ++ le_int32 glyphGroup; + + const GlyphClassDefinitionTable *glyphClassDefinitionTable; + const MarkAttachClassDefinitionTable *markAttachClassDefinitionTable; +diff --git a/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp b/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp +--- jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp +@@ -71,6 +71,20 @@ + return fEntryExitPoints[index].getExitPoint(exitPoint); + } + ++void GlyphPositionAdjustments::clearEntryPoint(le_int32 index) ++{ ++ CHECK_ALLOCATE_ARRAY(fEntryExitPoints, EntryExitPoint, fGlyphCount); ++ ++ fEntryExitPoints[index].clearEntryPoint(); ++} ++ ++void GlyphPositionAdjustments::clearExitPoint(le_int32 index) ++{ ++ CHECK_ALLOCATE_ARRAY(fEntryExitPoints, EntryExitPoint, fGlyphCount); ++ ++ fEntryExitPoints[index].clearExitPoint(); ++} ++ + void GlyphPositionAdjustments::setEntryPoint(le_int32 index, LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd) + { + CHECK_ALLOCATE_ARRAY(fEntryExitPoints, EntryExitPoint, fGlyphCount); +@@ -152,7 +166,12 @@ + lastExitGlyphID = glyphID; + } else { + if (baselineIsLogicalEnd(i) && firstExitPoint >= 0 && lastExitPoint >= 0) { +- le_int32 limit = lastExitPoint + dir; ++ le_int32 limit = lastExitPoint /*+ dir*/; ++ LEPoint dummyAnchor; ++ ++ if (getEntryPoint(i, dummyAnchor) != NULL) { ++ limit += dir; ++ } + + for (le_int32 j = firstExitPoint; j != limit; j += dir) { + if (isCursiveGlyph(j)) { +diff --git a/src/share/native/sun/font/layout/GlyphPositionAdjustments.h b/src/share/native/sun/font/layout/GlyphPositionAdjustments.h +--- jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.h ++++ jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.h +@@ -97,6 +97,8 @@ + LEPoint *getEntryPoint(LEPoint &entryPoint) const; + LEPoint *getExitPoint(LEPoint &exitPoint) const; + ++ inline void clearEntryPoint(); ++ inline void clearExitPoint(); + inline void setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd); + inline void setExitPoint(LEPoint &newExitPoint, le_bool baselineIsLogicalEnd); + inline void setCursiveGlyph(le_bool baselineIsLogicalEnd); +@@ -151,6 +153,8 @@ + inline void adjustXAdvance(le_int32 index, float xAdjustment); + inline void adjustYAdvance(le_int32 index, float yAdjustment); + ++ void clearEntryPoint(le_int32 index); ++ void clearExitPoint(le_int32 index); + void setEntryPoint(le_int32 index, LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd); + void setExitPoint(le_int32 index, LEPoint &newExitPoint, le_bool baselineIsLogicalEnd); + void setCursiveGlyph(le_int32 index, le_bool baselineIsLogicalEnd); +@@ -266,6 +270,16 @@ + return (fFlags & EEF_BASELINE_IS_LOGICAL_END) != 0; + } + ++inline void GlyphPositionAdjustments::EntryExitPoint::clearEntryPoint() ++{ ++ fFlags &= ~EEF_HAS_ENTRY_POINT; ++} ++ ++inline void GlyphPositionAdjustments::EntryExitPoint::clearExitPoint() ++{ ++ fFlags &= ~EEF_HAS_EXIT_POINT; ++} ++ + inline void GlyphPositionAdjustments::EntryExitPoint::setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd) + { + if (baselineIsLogicalEnd) { +diff --git a/src/share/native/sun/font/layout/GlyphPositioningTables.cpp b/src/share/native/sun/font/layout/GlyphPositioningTables.cpp +--- jdk/src/share/native/sun/font/layout/GlyphPositioningTables.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphPositioningTables.cpp +@@ -43,12 +43,19 @@ + + void GlyphPositioningTableHeader::process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, le_bool rightToLeft, + LETag scriptTag, LETag languageTag, +- const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, ++ const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, LEErrorCode &success, + const LEFontInstance *fontInstance, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const + { +- GlyphPositioningLookupProcessor processor(this, scriptTag, languageTag, featureMap, featureMapCount, featureOrder); ++ if (LE_FAILURE(success)) { ++ return; ++ } + +- processor.process(glyphStorage, glyphPositionAdjustments, rightToLeft, glyphDefinitionTableHeader, fontInstance); ++ GlyphPositioningLookupProcessor processor(this, scriptTag, languageTag, featureMap, featureMapCount, featureOrder, success); ++ if (LE_FAILURE(success)) { ++ return; ++ } ++ ++ processor.process(glyphStorage, glyphPositionAdjustments, rightToLeft, glyphDefinitionTableHeader, fontInstance, success); + + glyphPositionAdjustments->applyCursiveAdjustments(glyphStorage, rightToLeft, fontInstance); + } +diff --git a/src/share/native/sun/font/layout/GlyphPositioningTables.h b/src/share/native/sun/font/layout/GlyphPositioningTables.h +--- jdk/src/share/native/sun/font/layout/GlyphPositioningTables.h ++++ jdk/src/share/native/sun/font/layout/GlyphPositioningTables.h +@@ -53,7 +53,7 @@ + { + void process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, + le_bool rightToLeft, LETag scriptTag, LETag languageTag, +- const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, ++ const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, LEErrorCode &success, + const LEFontInstance *fontInstance, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const; + }; + +diff --git a/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp b/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp +--- jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp +@@ -31,7 +31,7 @@ + #include "LETypes.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +-#include "Features.h" ++#include "ICUFeatures.h" + #include "Lookups.h" + #include "ScriptAndLanguage.h" + #include "GlyphDefinitionTables.h" +@@ -58,13 +58,24 @@ + + GlyphPositioningLookupProcessor::GlyphPositioningLookupProcessor( + const GlyphPositioningTableHeader *glyphPositioningTableHeader, +- LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) ++ LETag scriptTag, ++ LETag languageTag, ++ const FeatureMap *featureMap, ++ le_int32 featureMapCount, ++ le_bool featureOrder, ++ LEErrorCode& success) + : LookupProcessor( + (char *) glyphPositioningTableHeader, + SWAPW(glyphPositioningTableHeader->scriptListOffset), + SWAPW(glyphPositioningTableHeader->featureListOffset), + SWAPW(glyphPositioningTableHeader->lookupListOffset), +- scriptTag, languageTag, featureMap, featureMapCount, featureOrder) ++ scriptTag, ++ languageTag, ++ featureMap, ++ featureMapCount, ++ featureOrder, ++ success ++ ) + { + // anything? + } +@@ -75,8 +86,13 @@ + + le_uint32 GlyphPositioningLookupProcessor::applySubtable(const LookupSubtable *lookupSubtable, le_uint16 lookupType, + GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++ const LEFontInstance *fontInstance, ++ LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + le_uint32 delta = 0; + + switch(lookupType) +@@ -136,7 +152,7 @@ + { + const ContextualPositioningSubtable *subtable = (const ContextualPositioningSubtable *) lookupSubtable; + +- delta = subtable->process(this, glyphIterator, fontInstance); ++ delta = subtable->process(this, glyphIterator, fontInstance, success); + break; + } + +@@ -144,7 +160,7 @@ + { + const ChainingContextualPositioningSubtable *subtable = (const ChainingContextualPositioningSubtable *) lookupSubtable; + +- delta = subtable->process(this, glyphIterator, fontInstance); ++ delta = subtable->process(this, glyphIterator, fontInstance, success); + break; + } + +@@ -152,7 +168,7 @@ + { + const ExtensionSubtable *subtable = (const ExtensionSubtable *) lookupSubtable; + +- delta = subtable->process(this, lookupType, glyphIterator, fontInstance); ++ delta = subtable->process(this, lookupType, glyphIterator, fontInstance, success); + break; + } + +diff --git a/src/share/native/sun/font/layout/GlyphPosnLookupProc.h b/src/share/native/sun/font/layout/GlyphPosnLookupProc.h +--- jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.h ++++ jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.h +@@ -40,7 +40,7 @@ + #include "LEFontInstance.h" + #include "OpenTypeTables.h" + #include "Lookups.h" +-#include "Features.h" ++#include "ICUFeatures.h" + #include "GlyphDefinitionTables.h" + #include "GlyphPositioningTables.h" + #include "GlyphIterator.h" +@@ -52,12 +52,17 @@ + { + public: + GlyphPositioningLookupProcessor(const GlyphPositioningTableHeader *glyphPositioningTableHeader, +- LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder); ++ LETag scriptTag, ++ LETag languageTag, ++ const FeatureMap *featureMap, ++ le_int32 featureMapCount, ++ le_bool featureOrder, ++ LEErrorCode& success); + + virtual ~GlyphPositioningLookupProcessor(); + + virtual le_uint32 applySubtable(const LookupSubtable *lookupSubtable, le_uint16 lookupType, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const; ++ const LEFontInstance *fontInstance, LEErrorCode& success) const; + + protected: + GlyphPositioningLookupProcessor(); +diff --git a/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp b/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp +--- jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp +@@ -33,7 +33,7 @@ + #include "LEGlyphFilter.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +-#include "Features.h" ++#include "ICUFeatures.h" + #include "Lookups.h" + #include "ScriptAndLanguage.h" + #include "GlyphDefinitionTables.h" +@@ -52,13 +52,19 @@ + + GlyphSubstitutionLookupProcessor::GlyphSubstitutionLookupProcessor( + const GlyphSubstitutionTableHeader *glyphSubstitutionTableHeader, +- LETag scriptTag, LETag languageTag, const LEGlyphFilter *filter, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) ++ LETag scriptTag, ++ LETag languageTag, ++ const LEGlyphFilter *filter, ++ const FeatureMap *featureMap, ++ le_int32 featureMapCount, ++ le_bool featureOrder, ++ LEErrorCode& success) + : LookupProcessor( + (char *) glyphSubstitutionTableHeader, + SWAPW(glyphSubstitutionTableHeader->scriptListOffset), + SWAPW(glyphSubstitutionTableHeader->featureListOffset), + SWAPW(glyphSubstitutionTableHeader->lookupListOffset), +- scriptTag, languageTag, featureMap, featureMapCount, featureOrder), fFilter(filter) ++ scriptTag, languageTag, featureMap, featureMapCount, featureOrder, success), fFilter(filter) + { + // anything? + } +@@ -68,8 +74,12 @@ + } + + le_uint32 GlyphSubstitutionLookupProcessor::applySubtable(const LookupSubtable *lookupSubtable, le_uint16 lookupType, +- GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const ++ GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + le_uint32 delta = 0; + + switch(lookupType) +@@ -89,7 +99,7 @@ + { + const MultipleSubstitutionSubtable *subtable = (const MultipleSubstitutionSubtable *) lookupSubtable; + +- delta = subtable->process(glyphIterator, fFilter); ++ delta = subtable->process(glyphIterator, success, fFilter); + break; + } + +@@ -113,7 +123,7 @@ + { + const ContextualSubstitutionSubtable *subtable = (const ContextualSubstitutionSubtable *) lookupSubtable; + +- delta = subtable->process(this, glyphIterator, fontInstance); ++ delta = subtable->process(this, glyphIterator, fontInstance, success); + break; + } + +@@ -121,7 +131,7 @@ + { + const ChainingContextualSubstitutionSubtable *subtable = (const ChainingContextualSubstitutionSubtable *) lookupSubtable; + +- delta = subtable->process(this, glyphIterator, fontInstance); ++ delta = subtable->process(this, glyphIterator, fontInstance, success); + break; + } + +@@ -129,7 +139,7 @@ + { + const ExtensionSubtable *subtable = (const ExtensionSubtable *) lookupSubtable; + +- delta = subtable->process(this, lookupType, glyphIterator, fontInstance); ++ delta = subtable->process(this, lookupType, glyphIterator, fontInstance, success); + break; + } + +diff --git a/src/share/native/sun/font/layout/GlyphSubstLookupProc.h b/src/share/native/sun/font/layout/GlyphSubstLookupProc.h +--- jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.h ++++ jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.h +@@ -41,7 +41,7 @@ + #include "LEFontInstance.h" + #include "OpenTypeTables.h" + #include "Lookups.h" +-#include "Features.h" ++#include "ICUFeatures.h" + #include "GlyphDefinitionTables.h" + #include "GlyphSubstitutionTables.h" + #include "GlyphIterator.h" +@@ -53,12 +53,18 @@ + { + public: + GlyphSubstitutionLookupProcessor(const GlyphSubstitutionTableHeader *glyphSubstitutionTableHeader, +- LETag scriptTag, LETag languageTag, const LEGlyphFilter *filter, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder); ++ LETag scriptTag, ++ LETag languageTag, ++ const LEGlyphFilter *filter, ++ const FeatureMap *featureMap, ++ le_int32 featureMapCount, ++ le_bool featureOrder, ++ LEErrorCode& success); + + virtual ~GlyphSubstitutionLookupProcessor(); + + virtual le_uint32 applySubtable(const LookupSubtable *lookupSubtable, le_uint16 lookupType, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const; ++ const LEFontInstance *fontInstance, LEErrorCode& success) const; + + protected: + GlyphSubstitutionLookupProcessor(); +diff --git a/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp b/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp +--- jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp ++++ jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp +@@ -42,13 +42,23 @@ + + U_NAMESPACE_BEGIN + +-le_int32 GlyphSubstitutionTableHeader::process(LEGlyphStorage &glyphStorage, le_bool rightToLeft, LETag scriptTag, LETag languageTag, ++le_int32 GlyphSubstitutionTableHeader::process(LEGlyphStorage &glyphStorage, ++ le_bool rightToLeft, ++ LETag scriptTag, ++ LETag languageTag, + const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, +- const LEGlyphFilter *filter, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const ++ const LEGlyphFilter *filter, ++ const FeatureMap *featureMap, ++ le_int32 featureMapCount, ++ le_bool featureOrder, ++ LEErrorCode &success) const + { +- GlyphSubstitutionLookupProcessor processor(this, scriptTag, languageTag, filter, featureMap, featureMapCount, featureOrder); ++ if (LE_FAILURE(success)) { ++ return 0; ++ } + +- return processor.process(glyphStorage, NULL, rightToLeft, glyphDefinitionTableHeader, NULL); ++ GlyphSubstitutionLookupProcessor processor(this, scriptTag, languageTag, filter, featureMap, featureMapCount, featureOrder, success); ++ return processor.process(glyphStorage, NULL, rightToLeft, glyphDefinitionTableHeader, NULL, success); + } + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/GlyphSubstitutionTables.h b/src/share/native/sun/font/layout/GlyphSubstitutionTables.h +--- jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.h ++++ jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.h +@@ -50,9 +50,16 @@ + + struct GlyphSubstitutionTableHeader : public GlyphLookupTableHeader + { +- le_int32 process(LEGlyphStorage &glyphStorage, le_bool rightToLeft, LETag scriptTag, LETag languageTag, +- const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, const LEGlyphFilter *filter, +- const FeatureMap *featureMap, le_int32 featureMapCount, le_bool featureOrder) const; ++ le_int32 process(LEGlyphStorage &glyphStorage, ++ le_bool rightToLeft, ++ LETag scriptTag, ++ LETag languageTag, ++ const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, ++ const LEGlyphFilter *filter, ++ const FeatureMap *featureMap, ++ le_int32 featureMapCount, ++ le_bool featureOrder, ++ LEErrorCode &success) const; + }; + + enum GlyphSubstitutionSubtableTypes +diff --git a/src/share/native/sun/font/layout/HanLayoutEngine.cpp b/src/share/native/sun/font/layout/HanLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/HanLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/HanLayoutEngine.cpp +@@ -26,7 +26,7 @@ + /* + * HanLayoutEngine.cpp: OpenType processing for Han fonts. + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved. + */ + + #include "LETypes.h" +@@ -64,8 +64,8 @@ + #define features (loclFeatureMask) + + HanOpenTypeLayoutEngine::HanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable) ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success) + { + fFeatureMap = featureMap; + fFeatureMapCount = featureMapCount; +diff --git a/src/share/native/sun/font/layout/HanLayoutEngine.h b/src/share/native/sun/font/layout/HanLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/HanLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/HanLayoutEngine.h +@@ -27,7 +27,7 @@ + /* + * HanLayoutEngine.h: OpenType processing for Han fonts. + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved. + */ + + #ifndef __HANLAYOUTENGINE_H +@@ -64,6 +64,7 @@ + * @param scriptCode - the script + * @param langaugeCode - the language + * @param gsubTable - the GSUB table ++ * @param success - set to an error code if the operation fails + * + * @see LayoutEngine::layoutEngineFactory + * @see OpenTypeLayoutEngine +@@ -72,7 +73,7 @@ + * @internal + */ + HanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTablem, LEErrorCode &success); + + + /** +diff --git a/src/share/native/sun/font/layout/HangulLayoutEngine.cpp b/src/share/native/sun/font/layout/HangulLayoutEngine.cpp +new file mode 100644 +--- /dev/null ++++ jdk/src/share/native/sun/font/layout/HangulLayoutEngine.cpp +@@ -0,0 +1,363 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Oracle designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Oracle in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* ++ * HangulLayoutEngine.cpp: OpenType processing for Han fonts. ++ * ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved. ++ */ ++ ++#include "LETypes.h" ++#include "LEScripts.h" ++#include "LELanguages.h" ++ ++#include "LayoutEngine.h" ++#include "OpenTypeLayoutEngine.h" ++#include "HangulLayoutEngine.h" ++#include "ScriptAndLanguageTags.h" ++#include "LEGlyphStorage.h" ++#include "OpenTypeTables.h" ++ ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HangulOpenTypeLayoutEngine) ++ ++ ++#define FEATURE_MAP(name) {name ## FeatureTag, name ## FeatureMask} ++ ++#define LJMO_FIRST 0x1100 ++#define LJMO_LAST 0x1159 ++#define LJMO_FILL 0x115F ++#define LJMO_COUNT 19 ++ ++#define VJMO_FIRST 0x1161 ++#define VJMO_LAST 0x11A2 ++#define VJMO_FILL 0x1160 ++#define VJMO_COUNT 21 ++ ++#define TJMO_FIRST 0x11A7 ++#define TJMO_LAST 0x11F9 ++#define TJMO_COUNT 28 ++ ++#define HSYL_FIRST 0xAC00 ++#define HSYL_COUNT 11172 ++#define HSYL_LVCNT (VJMO_COUNT * TJMO_COUNT) ++ ++// Character classes ++enum ++{ ++ CC_L = 0, ++ CC_V, ++ CC_T, ++ CC_LV, ++ CC_LVT, ++ CC_X, ++ CC_COUNT ++}; ++ ++// Action flags ++#define AF_L 1 ++#define AF_V 2 ++#define AF_T 4 ++ ++// Actions ++#define a_N 0 ++#define a_L (AF_L) ++#define a_V (AF_V) ++#define a_T (AF_T) ++#define a_VT (AF_V | AF_T) ++#define a_LV (AF_L | AF_V) ++#define a_LVT (AF_L | AF_V | AF_T) ++ ++typedef struct ++{ ++ le_int32 newState; ++ le_int32 actionFlags; ++} StateTransition; ++ ++static const StateTransition stateTable[][CC_COUNT] = ++{ ++// L V T LV LVT X ++ { {1, a_L}, {2, a_LV}, {3, a_LVT}, {2, a_LV}, {3, a_LVT}, {4, a_T}}, // 0 - start ++ { {1, a_L}, {2, a_V}, {3, a_VT}, {2, a_LV}, {3, a_LVT}, {-1, a_V}}, // 1 - L+ ++ {{-1, a_N}, {2, a_V}, {3, a_T}, {-1, a_N}, {-1, a_N}, {-1, a_N}}, // 2 - L+V+ ++ {{-1, a_N}, {-1, a_N}, {3, a_T}, {-1, a_N}, {-1, a_N}, {-1, a_N}}, // 3 - L+V+T* ++ {{-1, a_N}, {-1, a_N}, {-1, a_N}, {-1, a_N}, {-1, a_N}, {4, a_T}} // 4 - X+ ++}; ++ ++ ++#define ccmpFeatureTag LE_CCMP_FEATURE_TAG ++#define ljmoFeatureTag LE_LJMO_FEATURE_TAG ++#define vjmoFeatureTag LE_VJMO_FEATURE_TAG ++#define tjmoFeatureTag LE_TJMO_FEATURE_TAG ++ ++#define ccmpFeatureMask 0x80000000UL ++#define ljmoFeatureMask 0x40000000UL ++#define vjmoFeatureMask 0x20000000UL ++#define tjmoFeatureMask 0x10000000UL ++ ++static const FeatureMap featureMap[] = ++{ ++ {ccmpFeatureTag, ccmpFeatureMask}, ++ {ljmoFeatureTag, ljmoFeatureMask}, ++ {vjmoFeatureTag, vjmoFeatureMask}, ++ {tjmoFeatureTag, tjmoFeatureMask} ++}; ++ ++static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap); ++ ++#define nullFeatures 0 ++#define ljmoFeatures (ccmpFeatureMask | ljmoFeatureMask) ++#define vjmoFeatures (ccmpFeatureMask | vjmoFeatureMask | ljmoFeatureMask | tjmoFeatureMask) ++#define tjmoFeatures (ccmpFeatureMask | tjmoFeatureMask | ljmoFeatureMask | vjmoFeatureMask) ++ ++static le_int32 compose(LEUnicode lead, LEUnicode vowel, LEUnicode trail, LEUnicode &syllable) ++{ ++ le_int32 lIndex = lead - LJMO_FIRST; ++ le_int32 vIndex = vowel - VJMO_FIRST; ++ le_int32 tIndex = trail - TJMO_FIRST; ++ le_int32 result = 3; ++ ++ if ((lIndex < 0 || lIndex >= LJMO_COUNT ) || (vIndex < 0 || vIndex >= VJMO_COUNT)) { ++ return 0; ++ } ++ ++ if (tIndex <= 0 || tIndex >= TJMO_COUNT) { ++ tIndex = 0; ++ result = 2; ++ } ++ ++ syllable = (LEUnicode) ((lIndex * VJMO_COUNT + vIndex) * TJMO_COUNT + tIndex + HSYL_FIRST); ++ ++ return result; ++} ++ ++static le_int32 decompose(LEUnicode syllable, LEUnicode &lead, LEUnicode &vowel, LEUnicode &trail) ++{ ++ le_int32 sIndex = syllable - HSYL_FIRST; ++ ++ if (sIndex < 0 || sIndex >= HSYL_COUNT) { ++ return 0; ++ } ++ ++ lead = LJMO_FIRST + (sIndex / HSYL_LVCNT); ++ vowel = VJMO_FIRST + (sIndex % HSYL_LVCNT) / TJMO_COUNT; ++ trail = TJMO_FIRST + (sIndex % TJMO_COUNT); ++ ++ if (trail == TJMO_FIRST) { ++ return 2; ++ } ++ ++ return 3; ++} ++ ++static le_int32 getCharClass(LEUnicode ch, LEUnicode &lead, LEUnicode &vowel, LEUnicode &trail) ++{ ++ lead = LJMO_FILL; ++ vowel = VJMO_FILL; ++ trail = TJMO_FIRST; ++ ++ if (ch >= LJMO_FIRST && ch <= LJMO_LAST) { ++ lead = ch; ++ return CC_L; ++ } ++ ++ if (ch >= VJMO_FIRST && ch <= VJMO_LAST) { ++ vowel = ch; ++ return CC_V; ++ } ++ ++ if (ch > TJMO_FIRST && ch <= TJMO_LAST) { ++ trail = ch; ++ return CC_T; ++ } ++ ++ le_int32 c = decompose(ch, lead, vowel, trail); ++ ++ if (c == 2) { ++ return CC_LV; ++ } ++ ++ if (c == 3) { ++ return CC_LVT; ++ } ++ ++ trail = ch; ++ return CC_X; ++} ++ ++HangulOpenTypeLayoutEngine::HangulOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 /*languageCode*/, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, korLanguageCode, typoFlags, gsubTable, success) ++{ ++ fFeatureMap = featureMap; ++ fFeatureMapCount = featureMapCount; ++ fFeatureOrder = TRUE; ++} ++ ++HangulOpenTypeLayoutEngine::HangulOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 /*languageCode*/, ++ le_int32 typoFlags, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, korLanguageCode, typoFlags, success) ++{ ++ fFeatureMap = featureMap; ++ fFeatureMapCount = featureMapCount; ++ fFeatureOrder = TRUE; ++} ++ ++HangulOpenTypeLayoutEngine::~HangulOpenTypeLayoutEngine() ++{ ++ // nothing to do ++} ++ ++le_int32 HangulOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++{ ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ ++ if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { ++ success = LE_ILLEGAL_ARGUMENT_ERROR; ++ return 0; ++ } ++ ++ le_int32 worstCase = count * 3; ++ ++ outChars = LE_NEW_ARRAY(LEUnicode, worstCase); ++ ++ if (outChars == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return 0; ++ } ++ ++ glyphStorage.allocateGlyphArray(worstCase, rightToLeft, success); ++ glyphStorage.allocateAuxData(success); ++ ++ if (LE_FAILURE(success)) { ++ LE_DELETE_ARRAY(outChars); ++ return 0; ++ } ++ ++ le_int32 outCharCount = 0; ++ le_int32 limit = offset + count; ++ le_int32 i = offset; ++ ++ while (i < limit) { ++ le_int32 state = 0; ++ le_int32 inStart = i; ++ le_int32 outStart = outCharCount; ++ ++ while( i < limit) { ++ LEUnicode lead = 0; ++ LEUnicode vowel = 0; ++ LEUnicode trail = 0; ++ le_int32 chClass = getCharClass(chars[i], lead, vowel, trail); ++ const StateTransition transition = stateTable[state][chClass]; ++ ++ if (chClass == CC_X) { ++ /* Any character of type X will be stored as a trail jamo */ ++ if ((transition.actionFlags & AF_T) != 0) { ++ outChars[outCharCount] = trail; ++ glyphStorage.setCharIndex(outCharCount, i-offset, success); ++ glyphStorage.setAuxData(outCharCount++, nullFeatures, success); ++ } ++ } else { ++ /* Any Hangul will be fully decomposed. Output the decomposed characters. */ ++ if ((transition.actionFlags & AF_L) != 0) { ++ outChars[outCharCount] = lead; ++ glyphStorage.setCharIndex(outCharCount, i-offset, success); ++ glyphStorage.setAuxData(outCharCount++, ljmoFeatures, success); ++ } ++ ++ if ((transition.actionFlags & AF_V) != 0) { ++ outChars[outCharCount] = vowel; ++ glyphStorage.setCharIndex(outCharCount, i-offset, success); ++ glyphStorage.setAuxData(outCharCount++, vjmoFeatures, success); ++ } ++ ++ if ((transition.actionFlags & AF_T) != 0) { ++ outChars[outCharCount] = trail; ++ glyphStorage.setCharIndex(outCharCount, i-offset, success); ++ glyphStorage.setAuxData(outCharCount++, tjmoFeatures, success); ++ } ++ } ++ ++ state = transition.newState; ++ ++ /* Negative next state means stop. */ ++ if (state < 0) { ++ break; ++ } ++ ++ i += 1; ++ } ++ ++ le_int32 inLength = i - inStart; ++ le_int32 outLength = outCharCount - outStart; ++ ++ /* ++ * See if the syllable can be composed into a single character. There are 5 ++ * possible cases: ++ * ++ * Input Decomposed to Compose to ++ * LV L, V LV ++ * LVT L, V, T LVT ++ * L, V L, V LV, DEL ++ * LV, T L, V, T LVT, DEL ++ * L, V, T L, V, T LVT, DEL, DEL ++ */ ++ if ((inLength >= 1 && inLength <= 3) && (outLength == 2 || outLength == 3)) { ++ LEUnicode syllable = 0x0000; ++ LEUnicode lead = outChars[outStart]; ++ LEUnicode vowel = outChars[outStart + 1]; ++ LEUnicode trail = outLength == 3? outChars[outStart + 2] : TJMO_FIRST; ++ ++ /* ++ * If the composition consumes the whole decomposed syllable, ++ * we can use it. ++ */ ++ if (compose(lead, vowel, trail, syllable) == outLength) { ++ outCharCount = outStart; ++ outChars[outCharCount] = syllable; ++ glyphStorage.setCharIndex(outCharCount, inStart-offset, success); ++ glyphStorage.setAuxData(outCharCount++, nullFeatures, success); ++ ++ /* ++ * Replace the rest of the input characters with DEL. ++ */ ++ for(le_int32 d = inStart + 1; d < i; d += 1) { ++ outChars[outCharCount] = 0xFFFF; ++ glyphStorage.setCharIndex(outCharCount, d - offset, success); ++ glyphStorage.setAuxData(outCharCount++, nullFeatures, success); ++ } ++ } ++ } ++ } ++ ++ glyphStorage.adoptGlyphCount(outCharCount); ++ return outCharCount; ++} ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/HangulLayoutEngine.h b/src/share/native/sun/font/layout/HangulLayoutEngine.h +new file mode 100644 +--- /dev/null ++++ jdk/src/share/native/sun/font/layout/HangulLayoutEngine.h +@@ -0,0 +1,151 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Oracle designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Oracle in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* ++ * ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved ++ * ++ */ ++ ++#ifndef __HANGULAYOUTENGINE_H ++#define __HANGULAYOUTENGINE_H ++ ++#include "LETypes.h" ++#include "LEFontInstance.h" ++#include "LEGlyphFilter.h" ++#include "LayoutEngine.h" ++#include "OpenTypeLayoutEngine.h" ++ ++#include "GlyphSubstitutionTables.h" ++#include "GlyphDefinitionTables.h" ++#include "GlyphPositioningTables.h" ++ ++U_NAMESPACE_BEGIN ++ ++class MPreFixups; ++class LEGlyphStorage; ++ ++/** ++ * This class implements OpenType layout for Old Hangul OpenType fonts, as ++ * specified by Microsoft in "Creating and Supporting OpenType Fonts for ++ * The Korean Hangul Script" (http://www.microsoft.com/typography/otfntdev/hangulot/default.htm) ++ * ++ * This class overrides the characterProcessing method to do Hangul character processing. ++ * (See the MS spec. for more details) ++ * ++ * @internal ++ */ ++class HangulOpenTypeLayoutEngine : public OpenTypeLayoutEngine ++{ ++public: ++ /** ++ * This is the main constructor. It constructs an instance of HangulOpenTypeLayoutEngine for ++ * a particular font, script and language. It takes the GSUB table as a parameter since ++ * LayoutEngine::layoutEngineFactory has to read the GSUB table to know that it has an ++ * Hangul OpenType font. ++ * ++ * @param fontInstance - the font ++ * @param scriptCode - the script ++ * @param langaugeCode - the language ++ * @param gsubTable - the GSUB table ++ * @param success - set to an error code if the operation fails ++ * ++ * @see LayoutEngine::layoutEngineFactory ++ * @see OpenTypeLayoutEngine ++ * @see ScriptAndLangaugeTags.h for script and language codes ++ * ++ * @internal ++ */ ++ HangulOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success); ++ ++ /** ++ * This constructor is used when the font requires a "canned" GSUB table which can't be known ++ * until after this constructor has been invoked. ++ * ++ * @param fontInstance - the font ++ * @param scriptCode - the script ++ * @param langaugeCode - the language ++ * @param success - set to an error code if the operation fails ++ * ++ * @see OpenTypeLayoutEngine ++ * @see ScriptAndLangaugeTags.h for script and language codes ++ * ++ * @internal ++ */ ++ HangulOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, LEErrorCode &success); ++ ++ /** ++ * The destructor, virtual for correct polymorphic invocation. ++ * ++ * @internal ++ */ ++ virtual ~HangulOpenTypeLayoutEngine(); ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @stable ICU 2.8 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @stable ICU 2.8 ++ */ ++ static UClassID getStaticClassID(); ++ ++protected: ++ ++ /** ++ * This method does Hangul OpenType character processing. It assigns the OpenType feature ++ * tags to the characters, and may compose a character sequence into a modern Hangul syllable, ++ * or decompose a modern Hangul syllable if it forms part of an old Hangul syllable. ++ * ++ * Input parameters: ++ * @param chars - the input character context ++ * @param offset - the index of the first character to process ++ * @param count - the number of characters to process ++ * @param max - the number of characters in the input context ++ * @param rightToLeft - <code>TRUE</code> if the characters are in a right to left directional run ++ * @param glyphStorage - the glyph storage object. The glyph and character index arrays will be set. ++ * the auxillary data array will be set to the feature tags. ++ * ++ * Output parameters: ++ * @param success - set to an error code if the operation fails ++ * ++ * @return the output character count ++ * ++ * @internal ++ */ ++ virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++}; ++ ++U_NAMESPACE_END ++#endif ++ +diff --git a/src/share/native/sun/font/layout/HebrewLigatureData.cpp b/src/share/native/sun/font/layout/HebrewLigatureData.cpp +deleted file mode 100644 +--- jdk/src/share/native/sun/font/layout/HebrewLigatureData.cpp ++++ /dev/null +@@ -1,80 +0,0 @@ +-/* +- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +- * +- * This code is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License version 2 only, as +- * published by the Free Software Foundation. Oracle designates this +- * particular file as subject to the "Classpath" exception as provided +- * by Oracle in the LICENSE file that accompanied this code. +- * +- * This code is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +- * version 2 for more details (a copy is included in the LICENSE file that +- * accompanied this code). +- * +- * You should have received a copy of the GNU General Public License version +- * 2 along with this work; if not, write to the Free Software Foundation, +- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +- * +- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +- * or visit www.oracle.com if you need additional information or have any +- * questions. +- * +- */ +- +-/* +- * +- * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved +- * +- * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS +- * YOU REALLY KNOW WHAT YOU'RE DOING. +- * +- */ +- +-#include "LETypes.h" +-#include "HebrewShaping.h" +- +-const le_uint8 HebrewShaping::glyphSubstitutionTable[] = { +- 0x00, 0x01, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x1E, 0x00, 0x2C, 0x00, 0x01, 0x68, 0x65, 0x62, 0x72, +- 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, +- 0x6C, 0x69, 0x67, 0x61, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04, +- 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x01, 0x62, 0x00, 0x16, 0x00, 0x32, +- 0x00, 0x4C, 0x00, 0x5E, 0x00, 0x68, 0x00, 0x72, 0x00, 0x7C, 0x00, 0x8E, 0x00, 0x98, 0x00, 0xA2, +- 0x00, 0xAC, 0x00, 0xB6, 0x00, 0xC8, 0x00, 0xD2, 0x00, 0xDC, 0x00, 0xE6, 0x00, 0xF0, 0x00, 0xFA, +- 0x01, 0x0C, 0x01, 0x16, 0x01, 0x20, 0x01, 0x2A, 0x01, 0x58, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0E, +- 0x00, 0x14, 0xFB, 0x2E, 0x00, 0x02, 0x05, 0xB7, 0xFB, 0x2F, 0x00, 0x02, 0x05, 0xB8, 0xFB, 0x30, +- 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFB, 0x31, 0x00, 0x02, 0x05, 0xBC, +- 0xFB, 0x4C, 0x00, 0x02, 0x05, 0xBF, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x32, 0x00, 0x02, 0x05, 0xBC, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x33, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x34, +- 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFB, 0x4B, 0x00, 0x02, 0x05, 0xB9, +- 0xFB, 0x35, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x36, 0x00, 0x02, 0x05, 0xBC, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x38, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x39, +- 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x3A, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x02, +- 0x00, 0x06, 0x00, 0x0C, 0xFB, 0x3B, 0x00, 0x02, 0x05, 0xBC, 0xFB, 0x4D, 0x00, 0x02, 0x05, 0xBF, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x3C, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x3E, +- 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x40, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, +- 0x00, 0x04, 0xFB, 0x41, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x43, 0x00, 0x02, +- 0x05, 0xBC, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0C, 0xFB, 0x44, 0x00, 0x02, 0x05, 0xBC, 0xFB, 0x4E, +- 0x00, 0x02, 0x05, 0xBF, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x46, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, +- 0x00, 0x04, 0xFB, 0x47, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x04, 0xFB, 0x48, 0x00, 0x02, +- 0x05, 0xBC, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x14, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x28, 0xFB, 0x2C, +- 0x00, 0x03, 0x05, 0xBC, 0x05, 0xC1, 0xFB, 0x2D, 0x00, 0x03, 0x05, 0xBC, 0x05, 0xC2, 0xFB, 0x49, +- 0x00, 0x02, 0x05, 0xBC, 0xFB, 0x2A, 0x00, 0x02, 0x05, 0xC1, 0xFB, 0x2B, 0x00, 0x02, 0x05, 0xC2, +- 0x00, 0x01, 0x00, 0x04, 0xFB, 0x4A, 0x00, 0x02, 0x05, 0xBC, 0x00, 0x01, 0x00, 0x16, 0x05, 0xD0, +- 0x05, 0xD1, 0x05, 0xD2, 0x05, 0xD3, 0x05, 0xD4, 0x05, 0xD5, 0x05, 0xD6, 0x05, 0xD8, 0x05, 0xD9, +- 0x05, 0xDA, 0x05, 0xDB, 0x05, 0xDC, 0x05, 0xDE, 0x05, 0xE0, 0x05, 0xE1, 0x05, 0xE3, 0x05, 0xE4, +- 0x05, 0xE6, 0x05, 0xE7, 0x05, 0xE8, 0x05, 0xE9, 0x05, 0xEA +-}; +- +-const le_uint8 HebrewShaping::glyphDefinitionTable[] = { +- 0x00, 0x01, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x15, +- 0x05, 0x91, 0x05, 0xA1, 0x00, 0x03, 0x05, 0xA3, 0x05, 0xB9, 0x00, 0x03, 0x05, 0xBB, 0x05, 0xBD, +- 0x00, 0x03, 0x05, 0xBE, 0x05, 0xBE, 0x00, 0x01, 0x05, 0xBF, 0x05, 0xBF, 0x00, 0x03, 0x05, 0xC0, +- 0x05, 0xC0, 0x00, 0x01, 0x05, 0xC1, 0x05, 0xC2, 0x00, 0x03, 0x05, 0xC3, 0x05, 0xC3, 0x00, 0x01, +- 0x05, 0xC4, 0x05, 0xC4, 0x00, 0x03, 0x05, 0xD0, 0x05, 0xEA, 0x00, 0x01, 0x05, 0xF0, 0x05, 0xF2, +- 0x00, 0x02, 0x05, 0xF3, 0x05, 0xF4, 0x00, 0x01, 0xFB, 0x1E, 0xFB, 0x1E, 0x00, 0x03, 0xFB, 0x1F, +- 0xFB, 0x1F, 0x00, 0x02, 0xFB, 0x20, 0xFB, 0x36, 0x00, 0x01, 0xFB, 0x38, 0xFB, 0x3C, 0x00, 0x01, +- 0xFB, 0x3E, 0xFB, 0x3E, 0x00, 0x01, 0xFB, 0x40, 0xFB, 0x41, 0x00, 0x01, 0xFB, 0x43, 0xFB, 0x44, +- 0x00, 0x01, 0xFB, 0x46, 0xFB, 0x4E, 0x00, 0x01, 0xFB, 0x4F, 0xFB, 0x4F, 0x00, 0x02 +-}; +diff --git a/src/share/native/sun/font/layout/HebrewShaping.cpp b/src/share/native/sun/font/layout/HebrewShaping.cpp +deleted file mode 100644 +--- jdk/src/share/native/sun/font/layout/HebrewShaping.cpp ++++ /dev/null +@@ -1,58 +0,0 @@ +-/* +- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +- * +- * This code is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License version 2 only, as +- * published by the Free Software Foundation. Oracle designates this +- * particular file as subject to the "Classpath" exception as provided +- * by Oracle in the LICENSE file that accompanied this code. +- * +- * This code is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +- * version 2 for more details (a copy is included in the LICENSE file that +- * accompanied this code). +- * +- * You should have received a copy of the GNU General Public License version +- * 2 along with this work; if not, write to the Free Software Foundation, +- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +- * +- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +- * or visit www.oracle.com if you need additional information or have any +- * questions. +- * +- */ +- +-/* +- * +- * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved +- * +- */ +- +-#include "LETypes.h" +-#include "OpenTypeTables.h" +-#include "HebrewShaping.h" +- +-const LETag ligaFeatureTag = 0x6C696761; // 'liga' +-const LETag emptyTag = 0x00000000; // '' +- +-const LETag hebrewTags[] = +-{ +- ligaFeatureTag, emptyTag +-}; +- +-void HebrewShaping::shape(const LEUnicode * /*chars*/, le_int32 /*offset*/, le_int32 charCount, le_int32 /*charMax*/, +- le_bool rightToLeft, const LETag **tags) +-{ +- +- le_int32 count, out = 0, dir = 1; +- +- if (rightToLeft) { +- out = charCount - 1; +- dir = -1; +- } +- +- for (count = 0; count < charCount; count += 1, out += dir) { +- tags[out] = hebrewTags; +- } +-} +diff --git a/src/share/native/sun/font/layout/HebrewShaping.h b/src/share/native/sun/font/layout/HebrewShaping.h +deleted file mode 100644 +--- jdk/src/share/native/sun/font/layout/HebrewShaping.h ++++ /dev/null +@@ -1,52 +0,0 @@ +-/* +- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +- * +- * This code is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License version 2 only, as +- * published by the Free Software Foundation. Oracle designates this +- * particular file as subject to the "Classpath" exception as provided +- * by Oracle in the LICENSE file that accompanied this code. +- * +- * This code is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +- * version 2 for more details (a copy is included in the LICENSE file that +- * accompanied this code). +- * +- * You should have received a copy of the GNU General Public License version +- * 2 along with this work; if not, write to the Free Software Foundation, +- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +- * +- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +- * or visit www.oracle.com if you need additional information or have any +- * questions. +- * +- */ +- +-/* +- * +- * (C) Copyright IBM Corp. 1998, 1999, 2000 - All Rights Reserved +- * +- */ +- +-#ifndef __HEBREWSHAPING_H +-#define __HEBREWSHAPING_H +- +-#include "LETypes.h" +-#include "OpenTypeTables.h" +- +-class HebrewShaping +-{ +-public: +- static void shape(const LEUnicode *chars, le_int32 offset, le_int32 charCount, le_int32 charMax, +- le_bool rightToLeft, const LETag **tags); +- +- static const le_uint8 glyphSubstitutionTable[]; +- static const le_uint8 glyphDefinitionTable[]; +- +-private: +- // forbid instantiation +- HebrewShaping(); +-}; +- +-#endif +diff --git a/src/share/native/sun/font/layout/ICUFeatures.h b/src/share/native/sun/font/layout/ICUFeatures.h +new file mode 100644 +--- /dev/null ++++ jdk/src/share/native/sun/font/layout/ICUFeatures.h +@@ -0,0 +1,69 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Oracle designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Oracle in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* ++ * ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved ++ * ++ */ ++ ++#ifndef __ICUFEATURES_H ++#define __ICUFEATURES_H ++ ++/** ++ * \file ++ * \internal ++ */ ++ ++#include "LETypes.h" ++#include "OpenTypeTables.h" ++ ++U_NAMESPACE_BEGIN ++ ++struct FeatureRecord ++{ ++ ATag featureTag; ++ Offset featureTableOffset; ++}; ++ ++struct FeatureTable ++{ ++ Offset featureParamsOffset; ++ le_uint16 lookupCount; ++ le_uint16 lookupListIndexArray[ANY_NUMBER]; ++}; ++ ++struct FeatureListTable ++{ ++ le_uint16 featureCount; ++ FeatureRecord featureRecordArray[ANY_NUMBER]; ++ ++ const FeatureTable *getFeatureTable(le_uint16 featureIndex, LETag *featureTag) const; ++ ++ const FeatureTable *getFeatureTable(LETag featureTag) const; ++}; ++ ++U_NAMESPACE_END ++#endif +diff --git a/src/share/native/sun/font/layout/IndicClassTables.cpp b/src/share/native/sun/font/layout/IndicClassTables.cpp +--- jdk/src/share/native/sun/font/layout/IndicClassTables.cpp ++++ jdk/src/share/native/sun/font/layout/IndicClassTables.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -73,6 +73,7 @@ + #define _m2 (CC_SPLIT_VOWEL_PIECE_2 | CF_LENGTH_MARK) + #define _m3 (CC_SPLIT_VOWEL_PIECE_3 | CF_LENGTH_MARK) + #define _vr (CC_VIRAMA) ++#define _al (CC_AL_LAKUNA) + + // split matras + #define _s1 (_dv | _x1) +@@ -90,6 +91,7 @@ + // special forms... (Bengali RA?) + #define _bb (_ct | CF_BELOW_BASE) + #define _pb (_ct | CF_POST_BASE) ++#define _fb (_ct | CF_PRE_BASE) + #define _vt (_bb | CF_VATTU) + #define _rv (_vt | CF_REPH) + #define _rp (_pb | CF_REPH) +@@ -119,7 +121,7 @@ + _dr, _db, _db, _db, _db, _xx, _xx, _l1, _dl, _xx, _xx, _s1, _s2, _vr, _xx, _xx, // 09C0 - 09CF + _xx, _xx, _xx, _xx, _xx, _xx, _xx, _m2, _xx, _xx, _xx, _xx, _cn, _cn, _xx, _cn, // 09D0 - 09DF + _iv, _iv, _dv, _dv, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 09E0 - 09EF +- _ct, _ct, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx // 09F0 - 09FA ++ _rv, _ct, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx // 09F0 - 09FA + }; + + static const IndicClassTable::CharClass punjCharClasses[] = +@@ -142,9 +144,22 @@ + _rv, _xx, _ct, _ct, _xx, _ct, _ct, _ct, _ct, _ct, _xx, _xx, _nu, _xx, _dr, _dl, // 0AB0 - 0ABF + _dr, _db, _db, _db, _db, _da, _xx, _da, _da, _dr, _xx, _dr, _dr, _vr, _xx, _xx, // 0AC0 - 0ACF + _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0AD0 - 0ADF +- _iv, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx // 0AE0 - 0AEF ++ _iv, _iv, _db, _db, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx // 0AE0 - 0AEF + }; + ++#if 1 ++static const IndicClassTable::CharClass oryaCharClasses[] = ++{ ++ _xx, _ma, _mp, _mp, _xx, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _xx, _iv, /* 0B00 - 0B0F */ ++ _iv, _xx, _xx, _iv, _iv, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _ct, _bb, /* 0B10 - 0B1F */ ++ _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _xx, _bb, _bb, _bb, _bb, _bb, _pb, /* 0B20 - 0B2F */ ++ _rb, _xx, _bb, _bb, _xx, _bb, _bb, _bb, _bb, _bb, _xx, _xx, _nu, _xx, _dr, _da, /* 0B30 - 0B3F */ ++ _dr, _db, _db, _db, _xx, _xx, _xx, _dl, _s1, _xx, _xx, _s2, _s3, _vr, _xx, _xx, /* 0B40 - 0B4F */ ++ _xx, _xx, _xx, _xx, _xx, _xx, _da, _dr, _xx, _xx, _xx, _xx, _cn, _cn, _xx, _pb, /* 0B50 - 0B5F */ ++ _iv, _iv, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, /* 0B60 - 0B6F */ ++ _xx, _bb /* 0B70 - 0B71 */ ++}; ++#else + static const IndicClassTable::CharClass oryaCharClasses[] = + { + _xx, _ma, _mp, _mp, _xx, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _xx, _iv, // 0B00 - 0B0F +@@ -156,13 +171,14 @@ + _iv, _iv, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0B60 - 0B6F + _xx, _ct // 0B70 - 0B71 + }; ++#endif + + static const IndicClassTable::CharClass tamlCharClasses[] = + { +- _xx, _xx, _ma, _mp, _xx, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _xx, _xx, _iv, _iv, // 0B80 - 0B8F ++ _xx, _xx, _ma, _xx, _xx, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _xx, _xx, _iv, _iv, // 0B80 - 0B8F + _iv, _xx, _iv, _iv, _iv, _ct, _xx, _xx, _xx, _ct, _ct, _xx, _ct, _xx, _ct, _ct, // 0B90 - 0B9F + _xx, _xx, _xx, _ct, _ct, _xx, _xx, _xx, _ct, _ct, _ct, _xx, _xx, _xx, _ct, _ct, // 0BA0 - 0BAF +- _ct, _ct, _ct, _ct, _ct, _ct, _xx, _ct, _ct, _ct, _xx, _xx, _xx, _xx, _r2, _dr, // 0BB0 - 0BBF ++ _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _xx, _xx, _xx, _xx, _r2, _dr, // 0BB0 - 0BBF + _da, _dr, _dr, _xx, _xx, _xx, _l1, _l1, _dl, _xx, _s1, _s2, _s3, _vr, _xx, _xx, // 0BC0 - 0BCF + _xx, _xx, _xx, _xx, _xx, _xx, _xx, _m2, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0BD0 - 0BDF + _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0BE0 - 0BEF +@@ -175,7 +191,7 @@ + _xx, _mp, _mp, _mp, _xx, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _iv, _iv, // 0C00 - 0C0F + _iv, _xx, _iv, _iv, _iv, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, // 0C10 - 0C1F + _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _xx, _bb, _bb, _bb, _bb, _bb, _bb, // 0C20 - 0C2F +- _bb, _ct, _bb, _bb, _xx, _bb, _bb, _bb, _bb, _bb, _xx, _xx, _xx, _xx, _da, _da, // 0C30 - 0C3F ++ _bb, _bb, _bb, _bb, _xx, _bb, _bb, _bb, _bb, _bb, _xx, _xx, _xx, _xx, _da, _da, // 0C30 - 0C3F + _da, _dr, _dr, _dr, _dr, _xx, _a1, _da, _s1, _xx, _da, _da, _da, _vr, _xx, _xx, // 0C40 - 0C4F + _xx, _xx, _xx, _xx, _xx, _da, _m2, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0C50 - 0C5F + _iv, _iv, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx // 0C60 - 0C6F +@@ -189,7 +205,7 @@ + // http://brahmi.sourceforge.net/docs/KannadaComputing.html + static const IndicClassTable::CharClass kndaCharClasses[] = + { +- _xx, _xx, _mp, _mp, _xx, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _iv, // 0C80 - 0C8F ++ _xx, _xx, _mp, _mp, _xx, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _iv, _iv, // 0C80 - 0C8F + _iv, _xx, _iv, _iv, _iv, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, // 0C90 - 0C9F + _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _bb, _xx, _bb, _bb, _bb, _bb, _bb, _bb, // 0CA0 - 0CAF + _rb, _ct, _bb, _bb, _xx, _bb, _bb, _bb, _bb, _bb, _xx, _xx, _xx, _xx, _dr, _da, // 0CB0 - 0CBF +@@ -203,9 +219,9 @@ + static const IndicClassTable::CharClass mlymCharClasses[] = + { + _xx, _xx, _mp, _mp, _xx, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _iv, _iv, // 0D00 - 0D0F +- _iv, _xx, _iv, _iv, _iv, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _bb, // 0D10 - 0D1F +- _ct, _ct, _ct, _bb, _ct, _bb, _bb, _ct, _ct, _xx, _ct, _ct, _ct, _ct, _ct, _pb, // 0D20 - 0D2F +- _pb, _cn, _bb, _ct, _ct, _pb, _ct, _ct, _ct, _ct, _xx, _xx, _xx, _xx, _r2, _dr, // 0D30 - 0D3F ++ _iv, _xx, _iv, _iv, _iv, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, // 0D10 - 0D1F ++ _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _xx, _ct, _ct, _ct, _ct, _ct, _pb, // 0D20 - 0D2F ++ _fb, _fb, _bb, _ct, _ct, _pb, _ct, _ct, _ct, _ct, _xx, _xx, _xx, _xx, _r2, _dr, // 0D30 - 0D3F + _dr, _dr, _dr, _dr, _xx, _xx, _l1, _l1, _dl, _xx, _s1, _s2, _s3, _vr, _xx, _xx, // 0D40 - 0D4F + _xx, _xx, _xx, _xx, _xx, _xx, _xx, _m2, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0D50 - 0D5F + _iv, _iv, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx // 0D60 - 0D6F +@@ -217,7 +233,7 @@ + _iv, _iv, _iv, _iv, _iv, _iv, _iv, _xx, _xx, _xx, _ct, _ct, _ct, _ct, _ct, _ct, // 0D90 - 0D9F + _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, // 0DA0 - 0DAF + _ct, _ct, _xx, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _ct, _xx, _ct, _xx, _xx, // 0DB0 - 0DBF +- _ct, _ct, _ct, _ct, _ct, _ct, _ct, _xx, _xx, _xx, _vr, _xx, _xx, _xx, _xx, _dr, // 0DC0 - 0DCF ++ _ct, _ct, _ct, _ct, _ct, _ct, _ct, _xx, _xx, _xx, _al, _xx, _xx, _xx, _xx, _dr, // 0DC0 - 0DCF + _dr, _dr, _da, _da, _db, _xx, _db, _xx, _dr, _dl, _s1, _dl, _s2, _s3, _s4, _dr, // 0DD0 - 0DDF + _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0DE0 - 0DEF + _xx, _xx, _dr, _dr, _xx // 0DF0 - 0DF4 +@@ -248,17 +264,18 @@ + + // FIXME: post 'GSUB' reordering of MATRA_PRE's for Malayalam and Tamil + // FIXME: reformed Malayalam needs to reorder VATTU to before base glyph... ++// FIXME: not sure passing ZWJ/ZWNJ is best way to render Malayalam Cillu... + // FIXME: eyelash RA only for Devanagari?? +-#define DEVA_SCRIPT_FLAGS (SF_EYELASH_RA | SF_NO_POST_BASE_LIMIT) +-#define BENG_SCRIPT_FLAGS (SF_REPH_AFTER_BELOW | SF_NO_POST_BASE_LIMIT) +-#define PUNJ_SCRIPT_FLAGS (SF_NO_POST_BASE_LIMIT) +-#define GUJR_SCRIPT_FLAGS (SF_NO_POST_BASE_LIMIT) +-#define ORYA_SCRIPT_FLAGS (SF_REPH_AFTER_BELOW | SF_NO_POST_BASE_LIMIT) +-#define TAML_SCRIPT_FLAGS (SF_MPRE_FIXUP | SF_NO_POST_BASE_LIMIT) +-#define TELU_SCRIPT_FLAGS (SF_MATRAS_AFTER_BASE | 3) +-#define KNDA_SCRIPT_FLAGS (SF_MATRAS_AFTER_BASE | 3) +-#define MLYM_SCRIPT_FLAGS (SF_MPRE_FIXUP | SF_NO_POST_BASE_LIMIT) +-#define SINH_SCRIPT_FLAGS (SF_MPRE_FIXUP | SF_NO_POST_BASE_LIMIT) ++#define DEVA_SCRIPT_FLAGS (SF_EYELASH_RA | SF_NO_POST_BASE_LIMIT | SF_FILTER_ZERO_WIDTH) ++#define BENG_SCRIPT_FLAGS (SF_REPH_AFTER_BELOW | SF_NO_POST_BASE_LIMIT | SF_FILTER_ZERO_WIDTH) ++#define PUNJ_SCRIPT_FLAGS (SF_NO_POST_BASE_LIMIT | SF_FILTER_ZERO_WIDTH) ++#define GUJR_SCRIPT_FLAGS (SF_NO_POST_BASE_LIMIT | SF_FILTER_ZERO_WIDTH) ++#define ORYA_SCRIPT_FLAGS (SF_REPH_AFTER_BELOW | SF_NO_POST_BASE_LIMIT | SF_FILTER_ZERO_WIDTH) ++#define TAML_SCRIPT_FLAGS (SF_MPRE_FIXUP | SF_NO_POST_BASE_LIMIT | SF_FILTER_ZERO_WIDTH) ++#define TELU_SCRIPT_FLAGS (SF_MATRAS_AFTER_BASE | SF_FILTER_ZERO_WIDTH | 3) ++#define KNDA_SCRIPT_FLAGS (SF_MATRAS_AFTER_BASE | SF_FILTER_ZERO_WIDTH | 3) ++#define MLYM_SCRIPT_FLAGS (SF_MPRE_FIXUP | SF_NO_POST_BASE_LIMIT /*| SF_FILTER_ZERO_WIDTH*/) ++#define SINH_SCRIPT_FLAGS (SF_NO_POST_BASE_LIMIT) + + // + // Indic Class Tables +@@ -286,7 +303,7 @@ + // + // IndicClassTable addresses + // +-static const IndicClassTable * const indicClassTables[] = { ++static const IndicClassTable * const indicClassTables[scriptCodeCount] = { + NULL, /* 'zyyy' (COMMON) */ + NULL, /* 'qaai' (INHERITED) */ + NULL, /* 'arab' (ARABIC) */ +@@ -348,7 +365,79 @@ + NULL, /* 'sylo' (SYLOTI_NAGRI) */ + NULL, /* 'talu' (NEW_TAI_LUE) */ + NULL, /* 'tfng' (TIFINAGH) */ +- NULL /* 'xpeo' (OLD_PERSIAN) */ ++ NULL, /* 'xpeo' (OLD_PERSIAN) */ ++ NULL, /* 'bali' (BALINESE) */ ++ NULL, /* 'batk' (BATK) */ ++ NULL, /* 'blis' (BLIS) */ ++ NULL, /* 'brah' (BRAH) */ ++ NULL, /* 'cham' (CHAM) */ ++ NULL, /* 'cirt' (CIRT) */ ++ NULL, /* 'cyrs' (CYRS) */ ++ NULL, /* 'egyd' (EGYD) */ ++ NULL, /* 'egyh' (EGYH) */ ++ NULL, /* 'egyp' (EGYP) */ ++ NULL, /* 'geok' (GEOK) */ ++ NULL, /* 'hans' (HANS) */ ++ NULL, /* 'hant' (HANT) */ ++ NULL, /* 'hmng' (HMNG) */ ++ NULL, /* 'hung' (HUNG) */ ++ NULL, /* 'inds' (INDS) */ ++ NULL, /* 'java' (JAVA) */ ++ NULL, /* 'kali' (KALI) */ ++ NULL, /* 'latf' (LATF) */ ++ NULL, /* 'latg' (LATG) */ ++ NULL, /* 'lepc' (LEPC) */ ++ NULL, /* 'lina' (LINA) */ ++ NULL, /* 'mand' (MAND) */ ++ NULL, /* 'maya' (MAYA) */ ++ NULL, /* 'mero' (MERO) */ ++ NULL, /* 'nko ' (NKO) */ ++ NULL, /* 'orkh' (ORKH) */ ++ NULL, /* 'perm' (PERM) */ ++ NULL, /* 'phag' (PHAGS_PA) */ ++ NULL, /* 'phnx' (PHOENICIAN) */ ++ NULL, /* 'plrd' (PLRD) */ ++ NULL, /* 'roro' (RORO) */ ++ NULL, /* 'sara' (SARA) */ ++ NULL, /* 'syre' (SYRE) */ ++ NULL, /* 'syrj' (SYRJ) */ ++ NULL, /* 'syrn' (SYRN) */ ++ NULL, /* 'teng' (TENG) */ ++ NULL, /* 'vai ' (VAII) */ ++ NULL, /* 'visp' (VISP) */ ++ NULL, /* 'xsux' (CUNEIFORM) */ ++ NULL, /* 'zxxx' (ZXXX) */ ++ NULL, /* 'zzzz' (UNKNOWN) */ ++ NULL, /* 'cari' (CARI) */ ++ NULL, /* 'jpan' (JPAN) */ ++ NULL, /* 'lana' (LANA) */ ++ NULL, /* 'lyci' (LYCI) */ ++ NULL, /* 'lydi' (LYDI) */ ++ NULL, /* 'olck' (OLCK) */ ++ NULL, /* 'rjng' (RJNG) */ ++ NULL, /* 'saur' (SAUR) */ ++ NULL, /* 'sgnw' (SGNW) */ ++ NULL, /* 'sund' (SUND) */ ++ NULL, /* 'moon' (MOON) */ ++ NULL, /* 'mtei' (MTEI) */ ++ NULL, /* 'armi' (ARMI) */ ++ NULL, /* 'avst' (AVST) */ ++ NULL, /* 'cakm' (CAKM) */ ++ NULL, /* 'kore' (KORE) */ ++ NULL, /* 'kthi' (KTHI) */ ++ NULL, /* 'mani' (MANI) */ ++ NULL, /* 'phli' (PHLI) */ ++ NULL, /* 'phlp' (PHLP) */ ++ NULL, /* 'phlv' (PHLV) */ ++ NULL, /* 'prti' (PRTI) */ ++ NULL, /* 'samr' (SAMR) */ ++ NULL, /* 'tavt' (TAVT) */ ++ NULL, /* 'zmth' (ZMTH) */ ++ NULL, /* 'zsym' (ZSYM) */ ++ NULL, /* 'bamu' (BAMUM) */ ++ NULL, /* 'lisu' (LISU) */ ++ NULL, /* 'nkgb' (NKGB) */ ++ NULL /* 'sarb' (OLD_SOUTH_ARABIAN) */ + }; + + IndicClassTable::CharClass IndicClassTable::getCharClass(LEUnicode ch) const +@@ -388,4 +477,15 @@ + return classTable->getWorstCaseExpansion(); + } + ++le_bool IndicReordering::getFilterZeroWidth(le_int32 scriptCode) ++{ ++ const IndicClassTable *classTable = IndicClassTable::getScriptClassTable(scriptCode); ++ ++ if (classTable == NULL) { ++ return TRUE; ++ } ++ ++ return classTable->getFilterZeroWidth(); ++} ++ + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/IndicLayoutEngine.cpp b/src/share/native/sun/font/layout/IndicLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/IndicLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/IndicLayoutEngine.cpp +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2009 - All Rights Reserved + * + */ + +@@ -44,24 +44,31 @@ + #include "LEGlyphStorage.h" + + #include "IndicReordering.h" +- ++#include <stdio.h> + U_NAMESPACE_BEGIN + + UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IndicOpenTypeLayoutEngine) + + IndicOpenTypeLayoutEngine::IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable), fMPreFixups(NULL) ++ le_int32 typoFlags, le_bool version2, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success), fMPreFixups(NULL) ++{ ++ if ( version2 ) { ++ fFeatureMap = IndicReordering::getv2FeatureMap(fFeatureMapCount); ++ } else { ++ fFeatureMap = IndicReordering::getFeatureMap(fFeatureMapCount); ++ } ++ fFeatureOrder = TRUE; ++ fVersion2 = version2; ++ fFilterZeroWidth = IndicReordering::getFilterZeroWidth(fScriptCode); ++} ++ ++IndicOpenTypeLayoutEngine::IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success), fMPreFixups(NULL) + { + fFeatureMap = IndicReordering::getFeatureMap(fFeatureMapCount); + fFeatureOrder = TRUE; +-} +- +-IndicOpenTypeLayoutEngine::IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), fMPreFixups(NULL) +-{ +- fFeatureMap = IndicReordering::getFeatureMap(fFeatureMapCount); +- fFeatureOrder = TRUE; ++ fVersion2 = FALSE; + } + + IndicOpenTypeLayoutEngine::~IndicOpenTypeLayoutEngine() +@@ -89,8 +96,13 @@ + return 0; + } + +- IndicReordering::adjustMPres(fMPreFixups, glyphStorage); +- ++ if (fVersion2) { ++ IndicReordering::finalReordering(glyphStorage,retCount); ++ IndicReordering::applyPresentationForms(glyphStorage,retCount); ++ OpenTypeLayoutEngine::glyphSubstitution(count,max, rightToLeft, glyphStorage, success); ++ } else { ++ IndicReordering::adjustMPres(fMPreFixups, glyphStorage, success); ++ } + return retCount; + } + +@@ -128,7 +140,18 @@ + + // NOTE: assumes this allocates featureTags... + // (probably better than doing the worst case stuff here...) +- le_int32 outCharCount = IndicReordering::reorder(&chars[offset], count, fScriptCode, outChars, glyphStorage, &fMPreFixups); ++ ++ le_int32 outCharCount; ++ if (fVersion2) { ++ outCharCount = IndicReordering::v2process(&chars[offset], count, fScriptCode, outChars, glyphStorage); ++ } else { ++ outCharCount = IndicReordering::reorder(&chars[offset], count, fScriptCode, outChars, glyphStorage, &fMPreFixups, success); ++ } ++ ++ if (LE_FAILURE(success)) { ++ LE_DELETE_ARRAY(outChars); ++ return 0; ++ } + + glyphStorage.adoptGlyphCount(outCharCount); + return outCharCount; +diff --git a/src/share/native/sun/font/layout/IndicLayoutEngine.h b/src/share/native/sun/font/layout/IndicLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/IndicLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/IndicLayoutEngine.h +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2009 - All Rights Reserved + * + */ + +@@ -72,6 +72,7 @@ + * @param scriptCode - the script + * @param langaugeCode - the language + * @param gsubTable - the GSUB table ++ * @param success - set to an error code if the operation fails + * + * @see LayoutEngine::layoutEngineFactory + * @see OpenTypeLayoutEngine +@@ -80,7 +81,7 @@ + * @internal + */ + IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ le_int32 typoFlags, le_bool version2, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success); + + /** + * This constructor is used when the font requires a "canned" GSUB table which can't be known +@@ -89,6 +90,7 @@ + * @param fontInstance - the font + * @param scriptCode - the script + * @param langaugeCode - the language ++ * @param success - set to an error code if the operation fails + * + * @see OpenTypeLayoutEngine + * @see ScriptAndLangaugeTags.h for script and language codes +@@ -96,7 +98,7 @@ + * @internal + */ + IndicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags); ++ le_int32 typoFlags, LEErrorCode &success); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -177,9 +179,12 @@ + virtual le_int32 glyphProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, + LEGlyphStorage &glyphStorage, LEErrorCode &success); + ++ le_bool fVersion2; ++ + private: + + MPreFixups *fMPreFixups; ++ + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/IndicReordering.cpp b/src/share/native/sun/font/layout/IndicReordering.cpp +--- jdk/src/share/native/sun/font/layout/IndicReordering.cpp ++++ jdk/src/share/native/sun/font/layout/IndicReordering.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2009 - All Rights Reserved + * + */ + +@@ -38,10 +38,12 @@ + + U_NAMESPACE_BEGIN + ++#define loclFeatureTag LE_LOCL_FEATURE_TAG + #define initFeatureTag LE_INIT_FEATURE_TAG + #define nuktFeatureTag LE_NUKT_FEATURE_TAG + #define akhnFeatureTag LE_AKHN_FEATURE_TAG + #define rphfFeatureTag LE_RPHF_FEATURE_TAG ++#define rkrfFeatureTag LE_RKRF_FEATURE_TAG + #define blwfFeatureTag LE_BLWF_FEATURE_TAG + #define halfFeatureTag LE_HALF_FEATURE_TAG + #define pstfFeatureTag LE_PSTF_FEATURE_TAG +@@ -51,30 +53,69 @@ + #define abvsFeatureTag LE_ABVS_FEATURE_TAG + #define pstsFeatureTag LE_PSTS_FEATURE_TAG + #define halnFeatureTag LE_HALN_FEATURE_TAG +- ++#define cjctFeatureTag LE_CJCT_FEATURE_TAG + #define blwmFeatureTag LE_BLWM_FEATURE_TAG + #define abvmFeatureTag LE_ABVM_FEATURE_TAG + #define distFeatureTag LE_DIST_FEATURE_TAG ++#define caltFeatureTag LE_CALT_FEATURE_TAG ++#define kernFeatureTag LE_KERN_FEATURE_TAG + +-#define rphfFeatureMask 0x80000000UL +-#define blwfFeatureMask 0x40000000UL +-#define halfFeatureMask 0x20000000UL +-#define pstfFeatureMask 0x10000000UL +-#define nuktFeatureMask 0x08000000UL +-#define akhnFeatureMask 0x04000000UL +-#define vatuFeatureMask 0x02000000UL +-#define presFeatureMask 0x01000000UL +-#define blwsFeatureMask 0x00800000UL +-#define abvsFeatureMask 0x00400000UL +-#define pstsFeatureMask 0x00200000UL +-#define halnFeatureMask 0x00100000UL +-#define blwmFeatureMask 0x00080000UL +-#define abvmFeatureMask 0x00040000UL +-#define distFeatureMask 0x00020000UL +-#define initFeatureMask 0x00010000UL ++#define loclFeatureMask 0x80000000UL ++#define rphfFeatureMask 0x40000000UL ++#define blwfFeatureMask 0x20000000UL ++#define halfFeatureMask 0x10000000UL ++#define pstfFeatureMask 0x08000000UL ++#define nuktFeatureMask 0x04000000UL ++#define akhnFeatureMask 0x02000000UL ++#define vatuFeatureMask 0x01000000UL ++#define presFeatureMask 0x00800000UL ++#define blwsFeatureMask 0x00400000UL ++#define abvsFeatureMask 0x00200000UL ++#define pstsFeatureMask 0x00100000UL ++#define halnFeatureMask 0x00080000UL ++#define blwmFeatureMask 0x00040000UL ++#define abvmFeatureMask 0x00020000UL ++#define distFeatureMask 0x00010000UL ++#define initFeatureMask 0x00008000UL ++#define cjctFeatureMask 0x00004000UL ++#define rkrfFeatureMask 0x00002000UL ++#define caltFeatureMask 0x00001000UL ++#define kernFeatureMask 0x00000800UL + +-class ReorderingOutput : public UMemory { ++// Syllable structure bits ++#define baseConsonantMask 0x00000400UL ++#define consonantMask 0x00000200UL ++#define halfConsonantMask 0x00000100UL ++#define rephConsonantMask 0x00000080UL ++#define matraMask 0x00000040UL ++#define vowelModifierMask 0x00000020UL ++#define markPositionMask 0x00000018UL ++ ++#define postBasePosition 0x00000000UL ++#define preBasePosition 0x00000008UL ++#define aboveBasePosition 0x00000010UL ++#define belowBasePosition 0x00000018UL ++ ++#define repositionedGlyphMask 0x00000002UL ++ ++#define basicShapingFormsMask ( loclFeatureMask | nuktFeatureMask | akhnFeatureMask | rkrfFeatureMask | blwfFeatureMask | halfFeatureMask | vatuFeatureMask | cjctFeatureMask ) ++#define positioningFormsMask ( kernFeatureMask | distFeatureMask | abvmFeatureMask | blwmFeatureMask ) ++#define presentationFormsMask ( presFeatureMask | abvsFeatureMask | blwsFeatureMask | pstsFeatureMask | halnFeatureMask | caltFeatureMask ) ++ ++ ++#define C_MALAYALAM_VOWEL_SIGN_U 0x0D41 ++#define C_DOTTED_CIRCLE 0x25CC ++#define NO_GLYPH 0xFFFF ++ ++// Some level of debate as to the proper value for MAX_CONSONANTS_PER_SYLLABLE. Ticket 5588 states that 4 ++// is the magic number according to ISCII, but 5 seems to be the more consistent with XP. ++#define MAX_CONSONANTS_PER_SYLLABLE 5 ++ ++#define INDIC_BLOCK_SIZE 0x7F ++ ++class IndicReorderingOutput : public UMemory { + private: ++ le_int32 fSyllableCount; + le_int32 fOutIndex; + LEUnicode *fOutChars; + +@@ -95,8 +136,8 @@ + LEUnicode fLengthMark; + le_int32 fLengthMarkIndex; + +- LEUnicode fVirama; +- le_int32 fViramaIndex; ++ LEUnicode fAlLakuna; ++ le_int32 fAlLakunaIndex; + + FeatureMask fMatraFeatures; + +@@ -113,15 +154,20 @@ + le_int32 fSMIndex; + FeatureMask fSMFeatures; + ++ LEUnicode fPreBaseConsonant; ++ LEUnicode fPreBaseVirama; ++ le_int32 fPBCIndex; ++ FeatureMask fPBCFeatures; ++ + void saveMatra(LEUnicode matra, le_int32 matraIndex, IndicClassTable::CharClass matraClass) + { + // FIXME: check if already set, or if not a matra... + if (IndicClassTable::isLengthMark(matraClass)) { + fLengthMark = matra; + fLengthMarkIndex = matraIndex; +- } else if (IndicClassTable::isVirama(matraClass)) { +- fVirama = matra; +- fViramaIndex = matraIndex; ++ } else if (IndicClassTable::isAlLakuna(matraClass)) { ++ fAlLakuna = matra; ++ fAlLakunaIndex = matraIndex; + } else { + switch (matraClass & CF_POS_MASK) { + case CF_POS_BEFORE: +@@ -152,29 +198,34 @@ + } + + public: +- ReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage, MPreFixups *mpreFixups) +- : fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage), ++ IndicReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage, MPreFixups *mpreFixups) ++ : fSyllableCount(0), fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage), + fMpre(0), fMpreIndex(0), fMbelow(0), fMbelowIndex(0), fMabove(0), fMaboveIndex(0), +- fMpost(0), fMpostIndex(0), fLengthMark(0), fLengthMarkIndex(0), fVirama(0), fViramaIndex(0), ++ fMpost(0), fMpostIndex(0), fLengthMark(0), fLengthMarkIndex(0), fAlLakuna(0), fAlLakunaIndex(0), + fMatraFeatures(0), fMPreOutIndex(-1), fMPreFixups(mpreFixups), + fVMabove(0), fVMpost(0), fVMIndex(0), fVMFeatures(0), +- fSMabove(0), fSMbelow(0), fSMIndex(0), fSMFeatures(0) ++ fSMabove(0), fSMbelow(0), fSMIndex(0), fSMFeatures(0), ++ fPreBaseConsonant(0), fPreBaseVirama(0), fPBCIndex(0), fPBCFeatures(0) + { + // nothing else to do... + } + +- ~ReorderingOutput() ++ ~IndicReorderingOutput() + { + // nothing to do here... + } + + void reset() + { +- fMpre = fMbelow = fMabove = fMpost = fLengthMark = fVirama = 0; ++ fSyllableCount += 1; ++ ++ fMpre = fMbelow = fMabove = fMpost = fLengthMark = fAlLakuna = 0; + fMPreOutIndex = -1; + + fVMabove = fVMpost = 0; + fSMabove = fSMbelow = 0; ++ ++ fPreBaseConsonant = fPreBaseVirama = 0; + } + + void writeChar(LEUnicode ch, le_uint32 charIndex, FeatureMask charFeatures) +@@ -184,11 +235,113 @@ + fOutChars[fOutIndex] = ch; + + fGlyphStorage.setCharIndex(fOutIndex, charIndex, success); +- fGlyphStorage.setAuxData(fOutIndex, charFeatures, success); ++ fGlyphStorage.setAuxData(fOutIndex, charFeatures | (fSyllableCount & LE_GLYPH_GROUP_MASK), success); + + fOutIndex += 1; + } + ++ void setFeatures ( le_uint32 charIndex, FeatureMask charFeatures) ++ { ++ LEErrorCode success = LE_NO_ERROR; ++ ++ fGlyphStorage.setAuxData( charIndex, charFeatures, success ); ++ ++ } ++ ++ FeatureMask getFeatures ( le_uint32 charIndex ) ++ { ++ LEErrorCode success = LE_NO_ERROR; ++ return fGlyphStorage.getAuxData(charIndex,success); ++ } ++ ++ void decomposeReorderMatras ( const IndicClassTable *classTable, le_int32 beginSyllable, le_int32 nextSyllable, le_int32 inv_count ) { ++ le_int32 i; ++ LEErrorCode success = LE_NO_ERROR; ++ ++ for ( i = beginSyllable ; i < nextSyllable ; i++ ) { ++ if ( classTable->isMatra(fOutChars[i+inv_count])) { ++ IndicClassTable::CharClass matraClass = classTable->getCharClass(fOutChars[i+inv_count]); ++ if ( classTable->isSplitMatra(matraClass)) { ++ le_int32 saveIndex = fGlyphStorage.getCharIndex(i+inv_count,success); ++ le_uint32 saveAuxData = fGlyphStorage.getAuxData(i+inv_count,success); ++ const SplitMatra *splitMatra = classTable->getSplitMatra(matraClass); ++ int j; ++ for (j = 0 ; *(splitMatra)[j] != 0 ; j++) { ++ LEUnicode piece = (*splitMatra)[j]; ++ if ( j == 0 ) { ++ fOutChars[i+inv_count] = piece; ++ matraClass = classTable->getCharClass(piece); ++ } else { ++ insertCharacter(piece,i+1+inv_count,saveIndex,saveAuxData); ++ nextSyllable++; ++ } ++ } ++ } ++ ++ if ((matraClass & CF_POS_MASK) == CF_POS_BEFORE) { ++ moveCharacter(i+inv_count,beginSyllable+inv_count); ++ } ++ } ++ } ++ } ++ ++ void moveCharacter( le_int32 fromPosition, le_int32 toPosition ) { ++ le_int32 i,saveIndex; ++ le_uint32 saveAuxData; ++ LEUnicode saveChar = fOutChars[fromPosition]; ++ LEErrorCode success = LE_NO_ERROR; ++ LEErrorCode success2 = LE_NO_ERROR; ++ saveIndex = fGlyphStorage.getCharIndex(fromPosition,success); ++ saveAuxData = fGlyphStorage.getAuxData(fromPosition,success); ++ ++ if ( fromPosition > toPosition ) { ++ for ( i = fromPosition ; i > toPosition ; i-- ) { ++ fOutChars[i] = fOutChars[i-1]; ++ fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i-1,success2),success); ++ fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i-1,success2), success); ++ ++ } ++ } else { ++ for ( i = fromPosition ; i < toPosition ; i++ ) { ++ fOutChars[i] = fOutChars[i+1]; ++ fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i+1,success2),success); ++ fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i+1,success2), success); ++ } ++ ++ } ++ fOutChars[toPosition] = saveChar; ++ fGlyphStorage.setCharIndex(toPosition,saveIndex,success); ++ fGlyphStorage.setAuxData(toPosition,saveAuxData,success); ++ ++ } ++ void insertCharacter( LEUnicode ch, le_int32 toPosition, le_int32 charIndex, le_uint32 auxData ) { ++ LEErrorCode success = LE_NO_ERROR; ++ le_int32 i; ++ fOutIndex += 1; ++ ++ for ( i = fOutIndex ; i > toPosition ; i--) { ++ fOutChars[i] = fOutChars[i-1]; ++ fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i-1,success),success); ++ fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i-1,success), success); ++ } ++ ++ fOutChars[toPosition] = ch; ++ fGlyphStorage.setCharIndex(toPosition,charIndex,success); ++ fGlyphStorage.setAuxData(toPosition,auxData,success); ++ ++ } ++ void removeCharacter( le_int32 fromPosition ) { ++ LEErrorCode success = LE_NO_ERROR; ++ le_int32 i; ++ fOutIndex -= 1; ++ ++ for ( i = fromPosition ; i < fOutIndex ; i--) { ++ fOutChars[i] = fOutChars[i+1]; ++ fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i+1,success),success); ++ fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i+1,success), success); ++ } ++ } ++ + le_bool noteMatra(const IndicClassTable *classTable, LEUnicode matra, le_uint32 matraIndex, FeatureMask matraFeatures, le_bool wordStart) + { + IndicClassTable::CharClass matraClass = classTable->getCharClass(matra); +@@ -268,6 +421,14 @@ + } + } + ++ void notePreBaseConsonant(le_uint32 index,LEUnicode PBConsonant, LEUnicode PBVirama, FeatureMask features) ++ { ++ fPBCIndex = index; ++ fPreBaseConsonant = PBConsonant; ++ fPreBaseVirama = PBVirama; ++ fPBCFeatures = features; ++ } ++ + void noteBaseConsonant() + { + if (fMPreFixups != NULL && fMPreOutIndex >= 0) { +@@ -275,11 +436,11 @@ + } + } + +- // Handles virama in Sinhala split vowels. +- void writeVirama() ++ // Handles Al-Lakuna in Sinhala split vowels. ++ void writeAlLakuna() + { +- if (fVirama != 0) { +- writeChar(fVirama, fViramaIndex, fMatraFeatures); ++ if (fAlLakuna != 0) { ++ writeChar(fAlLakuna, fAlLakunaIndex, fMatraFeatures); + } + } + +@@ -347,26 +508,39 @@ + } + } + ++ void writePreBaseConsonant() ++ { ++ // The TDIL spec says that consonant + virama + RRA should produce a rakar in Malayalam. However, ++ // it seems that almost none of the fonts for Malayalam are set up to handle this. ++ // So, we're going to force the issue here by using the rakar as defined with RA in most fonts. ++ ++ if (fPreBaseConsonant == 0x0d31) { // RRA ++ fPreBaseConsonant = 0x0d30; // RA ++ } ++ ++ if (fPreBaseConsonant != 0) { ++ writeChar(fPreBaseConsonant, fPBCIndex, fPBCFeatures); ++ writeChar(fPreBaseVirama,fPBCIndex-1,fPBCFeatures); ++ } ++ } ++ + le_int32 getOutputIndex() + { + return fOutIndex; + } + }; + +-enum +-{ +- C_DOTTED_CIRCLE = 0x25CC +-}; ++ + + // TODO: Find better names for these! +-#define tagArray4 (nuktFeatureMask | akhnFeatureMask | vatuFeatureMask | presFeatureMask | blwsFeatureMask | abvsFeatureMask | pstsFeatureMask | halnFeatureMask | blwmFeatureMask | abvmFeatureMask | distFeatureMask) ++#define tagArray4 (loclFeatureMask | nuktFeatureMask | akhnFeatureMask | vatuFeatureMask | presFeatureMask | blwsFeatureMask | abvsFeatureMask | pstsFeatureMask | halnFeatureMask | blwmFeatureMask | abvmFeatureMask | distFeatureMask) + #define tagArray3 (pstfFeatureMask | tagArray4) + #define tagArray2 (halfFeatureMask | tagArray3) + #define tagArray1 (blwfFeatureMask | tagArray2) + #define tagArray0 (rphfFeatureMask | tagArray1) + +-static const FeatureMap featureMap[] = +-{ ++static const FeatureMap featureMap[] = { ++ {loclFeatureTag, loclFeatureMask}, + {initFeatureTag, initFeatureMask}, + {nuktFeatureTag, nuktFeatureMask}, + {akhnFeatureTag, akhnFeatureMask}, +@@ -387,21 +561,47 @@ + + static const le_int32 featureCount = LE_ARRAY_SIZE(featureMap); + ++static const FeatureMap v2FeatureMap[] = { ++ {loclFeatureTag, loclFeatureMask}, ++ {nuktFeatureTag, nuktFeatureMask}, ++ {akhnFeatureTag, akhnFeatureMask}, ++ {rphfFeatureTag, rphfFeatureMask}, ++ {rkrfFeatureTag, rkrfFeatureMask}, ++ {blwfFeatureTag, blwfFeatureMask}, ++ {halfFeatureTag, halfFeatureMask}, ++ {vatuFeatureTag, vatuFeatureMask}, ++ {cjctFeatureTag, cjctFeatureMask}, ++ {presFeatureTag, presFeatureMask}, ++ {abvsFeatureTag, abvsFeatureMask}, ++ {blwsFeatureTag, blwsFeatureMask}, ++ {pstsFeatureTag, pstsFeatureMask}, ++ {halnFeatureTag, halnFeatureMask}, ++ {caltFeatureTag, caltFeatureMask}, ++ {kernFeatureTag, kernFeatureMask}, ++ {distFeatureTag, distFeatureMask}, ++ {abvmFeatureTag, abvmFeatureMask}, ++ {blwmFeatureTag, blwmFeatureMask} ++}; ++ ++static const le_int32 v2FeatureMapCount = LE_ARRAY_SIZE(v2FeatureMap); ++ + static const le_int8 stateTable[][CC_COUNT] = + { +-// xx vm sm iv i2 i3 ct cn nu dv s1 s2 s3 vr zw +- { 1, 1, 1, 5, 8, 11, 3, 2, 1, 5, 9, 5, 1, 1, 1}, // 0 - ground state +- {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 1 - exit state +- {-1, 6, 1, -1, -1, -1, -1, -1, -1, 5, 9, 5, 5, 4, -1}, // 2 - consonant with nukta +- {-1, 6, 1, -1, -1, -1, -1, -1, 2, 5, 9, 5, 5, 4, -1}, // 3 - consonant +- {-1, -1, -1, -1, -1, -1, 3, 2, -1, -1, -1, -1, -1, -1, 7}, // 4 - consonant virama +- {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 5 - dependent vowels +- {-1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 6 - vowel mark +- {-1, -1, -1, -1, -1, -1, 3, 2, -1, -1, -1, -1, -1, -1, -1}, // 7 - ZWJ, ZWNJ +- {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, -1}, // 8 - independent vowels that can take a virama +- {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 5, -1, -1}, // 9 - first part of split vowel +- {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1}, // 10 - second part of split vowel +- {-1, 6, 1, -1, -1, -1, -1, -1, -1, 5, 9, 5, 5, 4, -1} // 11 - independent vowels that can take an iv ++// xx vm sm iv i2 i3 ct cn nu dv s1 s2 s3 vr zw al ++ { 1, 6, 1, 5, 8, 11, 3, 2, 1, 5, 9, 5, 5, 1, 1, 1}, // 0 - ground state ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 1 - exit state ++ {-1, 6, 1, -1, -1, -1, -1, -1, -1, 5, 9, 5, 5, 4, 12, -1}, // 2 - consonant with nukta ++ {-1, 6, 1, -1, -1, -1, -1, -1, 2, 5, 9, 5, 5, 4, 12, 13}, // 3 - consonant ++ {-1, -1, -1, -1, -1, -1, 3, 2, -1, -1, -1, -1, -1, -1, 7, -1}, // 4 - consonant virama ++ {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 5 - dependent vowels ++ {-1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 6 - vowel mark ++ {-1, -1, -1, -1, -1, -1, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1}, // 7 - consonant virama ZWJ, consonant ZWJ virama ++ {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, -1, -1}, // 8 - independent vowels that can take a virama ++ {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 5, -1, -1, -1}, // 9 - first part of split vowel ++ {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1}, // 10 - second part of split vowel ++ {-1, 6, 1, -1, -1, -1, -1, -1, -1, 5, 9, 5, 5, 4, -1, -1}, // 11 - independent vowels that can take an iv ++ {-1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7, -1, 7}, // 12 - consonant ZWJ (TODO: Take everything else that can be after a consonant?) ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7, -1} // 13 - consonant al-lakuna ZWJ consonant + }; + + +@@ -412,14 +612,29 @@ + return featureMap; + } + ++const FeatureMap *IndicReordering::getv2FeatureMap(le_int32 &count) ++{ ++ count = v2FeatureMapCount; ++ ++ return v2FeatureMap; ++} ++ + le_int32 IndicReordering::findSyllable(const IndicClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount) + { + le_int32 cursor = prev; + le_int8 state = 0; ++ le_int8 consonant_count = 0; + + while (cursor < charCount) { + IndicClassTable::CharClass charClass = classTable->getCharClass(chars[cursor]); + ++ if ( IndicClassTable::isConsonant(charClass) ) { ++ consonant_count++; ++ if ( consonant_count > MAX_CONSONANTS_PER_SYLLABLE ) { ++ break; ++ } ++ } ++ + state = stateTable[state][charClass & CF_CLASS_MASK]; + + if (state < 0) { +@@ -434,16 +649,24 @@ + + le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 scriptCode, + LEUnicode *outChars, LEGlyphStorage &glyphStorage, +- MPreFixups **outMPreFixups) ++ MPreFixups **outMPreFixups, LEErrorCode& success) + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + MPreFixups *mpreFixups = NULL; + const IndicClassTable *classTable = IndicClassTable::getScriptClassTable(scriptCode); + + if (classTable->scriptFlags & SF_MPRE_FIXUP) { + mpreFixups = new MPreFixups(charCount); ++ if (mpreFixups == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return 0; ++ } + } + +- ReorderingOutput output(outChars, glyphStorage, mpreFixups); ++ IndicReorderingOutput output(outChars, glyphStorage, mpreFixups); + le_int32 i, prev = 0; + le_bool lastInWord = FALSE; + +@@ -458,7 +681,7 @@ + output.noteStressMark(classTable, chars[markStart], markStart, tagArray1); + } + +- if (classTable->isVowelModifier(chars[markStart - 1])) { ++ if (markStart != prev && classTable->isVowelModifier(chars[markStart - 1])) { + markStart -= 1; + output.noteVowelModifier(classTable, chars[markStart], markStart, tagArray1); + } +@@ -484,9 +707,20 @@ + + break; + ++ case CC_AL_LAKUNA: + case CC_NUKTA: ++ output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); ++ output.writeChar(chars[prev], prev, tagArray1); ++ break; ++ + case CC_VIRAMA: ++ // A lone virama is illegal unless it follows a ++ // MALAYALAM_VOWEL_SIGN_U. Such a usage is called ++ // "samvruthokaram". ++ if (chars[prev - 1] != C_MALAYALAM_VOWEL_SIGN_U) { + output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); ++ } ++ + output.writeChar(chars[prev], prev, tagArray1); + break; + +@@ -518,7 +752,7 @@ + } + + output.writeLengthMark(); +- output.writeVirama(); ++ output.writeAlLakuna(); + + if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) { + output.writeVMabove(); +@@ -538,7 +772,7 @@ + le_int32 baseLimit = prev; + + // Check for REPH at front of syllable +- if (length > 2 && classTable->isReph(chars[prev]) && classTable->isVirama(chars[prev + 1])) { ++ if (length > 2 && classTable->isReph(chars[prev]) && classTable->isVirama(chars[prev + 1]) && chars[prev + 2] != C_SIGN_ZWNJ) { + baseLimit += 2; + + // Check for eyelash RA, if the script supports it +@@ -556,35 +790,59 @@ + lastConsonant -= 1; + } + ++ ++ IndicClassTable::CharClass charClass = CC_RESERVED; ++ IndicClassTable::CharClass nextClass = CC_RESERVED; + le_int32 baseConsonant = lastConsonant; + le_int32 postBase = lastConsonant + 1; + le_int32 postBaseLimit = classTable->scriptFlags & SF_POST_BASE_LIMIT_MASK; + le_bool seenVattu = FALSE; + le_bool seenBelowBaseForm = FALSE; ++ le_bool seenPreBaseForm = FALSE; ++ le_bool hasNukta = FALSE; ++ le_bool hasBelowBaseForm = FALSE; ++ le_bool hasPostBaseForm = FALSE; ++ le_bool hasPreBaseForm = FALSE; + + if (postBase < markStart && classTable->isNukta(chars[postBase])) { ++ charClass = CC_NUKTA; + postBase += 1; + } + + while (baseConsonant > baseLimit) { +- IndicClassTable::CharClass charClass = classTable->getCharClass(chars[baseConsonant]); ++ nextClass = charClass; ++ hasNukta = IndicClassTable::isNukta(nextClass); ++ charClass = classTable->getCharClass(chars[baseConsonant]); ++ ++ hasBelowBaseForm = IndicClassTable::hasBelowBaseForm(charClass) && !hasNukta; ++ hasPostBaseForm = IndicClassTable::hasPostBaseForm(charClass) && !hasNukta; ++ hasPreBaseForm = IndicClassTable::hasPreBaseForm(charClass) && !hasNukta; + + if (IndicClassTable::isConsonant(charClass)) { + if (postBaseLimit == 0 || seenVattu || + (baseConsonant > baseLimit && !classTable->isVirama(chars[baseConsonant - 1])) || +- !IndicClassTable::hasPostOrBelowBaseForm(charClass)) { ++ !(hasBelowBaseForm || hasPostBaseForm || hasPreBaseForm)) { + break; + } + +- seenVattu = IndicClassTable::isVattu(charClass); ++ // Note any pre-base consonants ++ if ( baseConsonant == lastConsonant && lastConsonant > 0 && ++ hasPreBaseForm && classTable->isVirama(chars[baseConsonant - 1])) { ++ output.notePreBaseConsonant(lastConsonant,chars[lastConsonant],chars[lastConsonant-1],tagArray2); ++ seenPreBaseForm = TRUE; + +- if (IndicClassTable::hasPostBaseForm(charClass)) { ++ } ++ // consonants with nuktas are never vattus ++ seenVattu = IndicClassTable::isVattu(charClass) && !hasNukta; ++ ++ // consonants with nuktas never have below- or post-base forms ++ if (hasPostBaseForm) { + if (seenBelowBaseForm) { + break; + } + + postBase = baseConsonant; +- } else if (IndicClassTable::hasBelowBaseForm(charClass)) { ++ } else if (hasBelowBaseForm) { + seenBelowBaseForm = TRUE; + } + +@@ -606,20 +864,25 @@ + } + + // write any pre-base consonants ++ output.writePreBaseConsonant(); ++ + le_bool supressVattu = TRUE; + + for (i = baseLimit; i < baseConsonant; i += 1) { + LEUnicode ch = chars[i]; +- // Don't put 'blwf' on first consonant. +- FeatureMask features = (i == baseLimit? tagArray2 : tagArray1); +- IndicClassTable::CharClass charClass = classTable->getCharClass(ch); ++ // Don't put 'pstf' or 'blwf' on anything before the base consonant. ++ FeatureMask features = tagArray1 & ~( pstfFeatureMask | blwfFeatureMask ); ++ ++ charClass = classTable->getCharClass(ch); ++ nextClass = classTable->getCharClass(chars[i + 1]); ++ hasNukta = IndicClassTable::isNukta(nextClass); + + if (IndicClassTable::isConsonant(charClass)) { +- if (IndicClassTable::isVattu(charClass) && supressVattu) { ++ if (IndicClassTable::isVattu(charClass) && !hasNukta && supressVattu) { + features = tagArray4; + } + +- supressVattu = IndicClassTable::isVattu(charClass); ++ supressVattu = IndicClassTable::isVattu(charClass) && !hasNukta; + } else if (IndicClassTable::isVirama(charClass) && chars[i + 1] == C_SIGN_ZWNJ) + { + features = tagArray4; +@@ -634,7 +897,8 @@ + bcSpan += 1; + } + +- if (baseConsonant == lastConsonant && bcSpan < markStart && classTable->isVirama(chars[bcSpan])) { ++ if (baseConsonant == lastConsonant && bcSpan < markStart && ++ (classTable->isVirama(chars[bcSpan]) || classTable->isAlLakuna(chars[bcSpan]))) { + bcSpan += 1; + + if (bcSpan < markStart && chars[bcSpan] == C_SIGN_ZWNJ) { +@@ -658,7 +922,7 @@ + } + + // write below-base consonants +- if (baseConsonant != lastConsonant) { ++ if (baseConsonant != lastConsonant && !seenPreBaseForm) { + for (i = bcSpan + 1; i < postBase; i += 1) { + output.writeChar(chars[i], i, tagArray1); + } +@@ -688,7 +952,7 @@ + + // write post-base consonants + // FIXME: does this put the right tags on post-base consonants? +- if (baseConsonant != lastConsonant) { ++ if (baseConsonant != lastConsonant && !seenPreBaseForm) { + if (postBase <= lastConsonant) { + for (i = postBase; i <= lastConsonant; i += 1) { + output.writeChar(chars[i], i, tagArray3); +@@ -710,7 +974,7 @@ + } + + output.writeLengthMark(); +- output.writeVirama(); ++ output.writeAlLakuna(); + + // write reph + if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) { +@@ -740,13 +1004,250 @@ + return output.getOutputIndex(); + } + +-void IndicReordering::adjustMPres(MPreFixups *mpreFixups, LEGlyphStorage &glyphStorage) ++void IndicReordering::adjustMPres(MPreFixups *mpreFixups, LEGlyphStorage &glyphStorage, LEErrorCode& success) + { + if (mpreFixups != NULL) { +- mpreFixups->apply(glyphStorage); ++ mpreFixups->apply(glyphStorage, success); + + delete mpreFixups; + } + } + ++void IndicReordering::applyPresentationForms(LEGlyphStorage &glyphStorage, le_int32 count) ++{ ++ LEErrorCode success = LE_NO_ERROR; ++ ++// This sets us up for 2nd pass of glyph substitution as well as setting the feature masks for the ++// GPOS table lookups ++ ++ for ( le_int32 i = 0 ; i < count ; i++ ) { ++ glyphStorage.setAuxData(i, ( presentationFormsMask | positioningFormsMask ), success); ++ } ++ ++} ++void IndicReordering::finalReordering(LEGlyphStorage &glyphStorage, le_int32 count) ++{ ++ LEErrorCode success = LE_NO_ERROR; ++ ++ // Reposition REPH as appropriate ++ ++ for ( le_int32 i = 0 ; i < count ; i++ ) { ++ ++ le_int32 tmpAuxData = glyphStorage.getAuxData(i,success); ++ LEGlyphID tmpGlyph = glyphStorage.getGlyphID(i,success); ++ ++ if ( ( tmpGlyph != NO_GLYPH ) && (tmpAuxData & rephConsonantMask) && !(tmpAuxData & repositionedGlyphMask)) { ++ ++ le_bool targetPositionFound = false; ++ le_int32 targetPosition = i+1; ++ le_int32 baseConsonantData; ++ ++ while (!targetPositionFound) { ++ tmpGlyph = glyphStorage.getGlyphID(targetPosition,success); ++ tmpAuxData = glyphStorage.getAuxData(targetPosition,success); ++ ++ if ( tmpAuxData & baseConsonantMask ) { ++ baseConsonantData = tmpAuxData; ++ targetPositionFound = true; ++ } else { ++ targetPosition++; ++ } ++ } ++ ++ // Make sure we are not putting the reph into an empty hole ++ ++ le_bool targetPositionHasGlyph = false; ++ while (!targetPositionHasGlyph) { ++ tmpGlyph = glyphStorage.getGlyphID(targetPosition,success); ++ if ( tmpGlyph != NO_GLYPH ) { ++ targetPositionHasGlyph = true; ++ } else { ++ targetPosition--; ++ } ++ } ++ ++ // Make sure that REPH is positioned after any above base or post base matras ++ // ++ le_bool checkMatraDone = false; ++ le_int32 checkMatraPosition = targetPosition+1; ++ while ( !checkMatraDone ) { ++ tmpAuxData = glyphStorage.getAuxData(checkMatraPosition,success); ++ if ( checkMatraPosition >= count || ( (tmpAuxData ^ baseConsonantData) & LE_GLYPH_GROUP_MASK)) { ++ checkMatraDone = true; ++ continue; ++ } ++ if ( (tmpAuxData & matraMask) && ++ (((tmpAuxData & markPositionMask) == aboveBasePosition) || ++ ((tmpAuxData & markPositionMask) == postBasePosition))) { ++ targetPosition = checkMatraPosition; ++ } ++ checkMatraPosition++; ++ } ++ ++ glyphStorage.moveGlyph(i,targetPosition,repositionedGlyphMask); ++ } ++ } ++} ++ ++ ++le_int32 IndicReordering::v2process(const LEUnicode *chars, le_int32 charCount, le_int32 scriptCode, ++ LEUnicode *outChars, LEGlyphStorage &glyphStorage) ++{ ++ const IndicClassTable *classTable = IndicClassTable::getScriptClassTable(scriptCode); ++ ++ DynamicProperties dynProps[INDIC_BLOCK_SIZE]; ++ IndicReordering::getDynamicProperties(dynProps,classTable); ++ ++ IndicReorderingOutput output(outChars, glyphStorage, NULL); ++ le_int32 i, firstConsonant, baseConsonant, secondConsonant, inv_count = 0, beginSyllable = 0; ++ //le_bool lastInWord = FALSE; ++ ++ while (beginSyllable < charCount) { ++ le_int32 nextSyllable = findSyllable(classTable, chars, beginSyllable, charCount); ++ ++ output.reset(); ++ ++ // Find the First Consonant ++ for ( firstConsonant = beginSyllable ; firstConsonant < nextSyllable ; firstConsonant++ ) { ++ if ( classTable->isConsonant(chars[firstConsonant]) ) { ++ break; ++ } ++ } ++ ++ // Find the base consonant ++ ++ baseConsonant = nextSyllable - 1; ++ secondConsonant = firstConsonant; ++ ++ // TODO: Use Dynamic Properties for hasBelowBaseForm and hasPostBaseForm() ++ ++ while ( baseConsonant > firstConsonant ) { ++ if ( classTable->isConsonant(chars[baseConsonant]) && ++ !classTable->hasBelowBaseForm(chars[baseConsonant]) && ++ !classTable->hasPostBaseForm(chars[baseConsonant]) ) { ++ break; ++ } ++ else { ++ if ( classTable->isConsonant(chars[baseConsonant]) ) { ++ secondConsonant = baseConsonant; ++ } ++ baseConsonant--; ++ } ++ } ++ ++ // If the syllable starts with Ra + Halant ( in a script that has Reph ) and has more than one ++ // consonant, Ra is excluced from candidates for base consonants ++ ++ if ( classTable->isReph(chars[beginSyllable]) && ++ beginSyllable+1 < nextSyllable && classTable->isVirama(chars[beginSyllable+1]) && ++ secondConsonant != firstConsonant) { ++ baseConsonant = secondConsonant; ++ } ++ ++ // Populate the output ++ for ( i = beginSyllable ; i < nextSyllable ; i++ ) { ++ ++ // Handle invalid combinartions ++ ++ if ( classTable->isVirama(chars[beginSyllable]) || ++ classTable->isMatra(chars[beginSyllable]) || ++ classTable->isVowelModifier(chars[beginSyllable]) || ++ classTable->isNukta(chars[beginSyllable]) ) { ++ output.writeChar(C_DOTTED_CIRCLE,beginSyllable,basicShapingFormsMask); ++ inv_count++; ++ } ++ output.writeChar(chars[i],i, basicShapingFormsMask); ++ ++ } ++ ++ // Adjust features and set syllable structure bits ++ ++ for ( i = beginSyllable ; i < nextSyllable ; i++ ) { ++ ++ FeatureMask outMask = output.getFeatures(i+inv_count); ++ FeatureMask saveMask = outMask; ++ ++ // Since reph can only validly occur at the beginning of a syllable ++ // We only apply it to the first 2 characters in the syllable, to keep it from ++ // conflicting with other features ( i.e. rkrf ) ++ ++ // TODO : Use the dynamic property for determining isREPH ++ if ( i == beginSyllable && i < baseConsonant && classTable->isReph(chars[i]) && ++ i+1 < nextSyllable && classTable->isVirama(chars[i+1])) { ++ outMask |= rphfFeatureMask; ++ outMask |= rephConsonantMask; ++ output.setFeatures(i+1+inv_count,outMask); ++ ++ } ++ ++ if ( i == baseConsonant ) { ++ outMask |= baseConsonantMask; ++ } ++ ++ if ( classTable->isMatra(chars[i])) { ++ outMask |= matraMask; ++ if ( classTable->hasAboveBaseForm(chars[i])) { ++ outMask |= aboveBasePosition; ++ } else if ( classTable->hasBelowBaseForm(chars[i])) { ++ outMask |= belowBasePosition; ++ } ++ } ++ ++ // Don't apply half form to virama that stands alone at the end of a syllable ++ // to prevent half forms from forming when syllable ends with virama ++ ++ if ( classTable->isVirama(chars[i]) && (i+1 == nextSyllable) ) { ++ outMask ^= halfFeatureMask; ++ if ( classTable->isConsonant(chars[i-1]) ) { ++ FeatureMask tmp = output.getFeatures(i-1+inv_count); ++ tmp ^= halfFeatureMask; ++ output.setFeatures(i-1+inv_count,tmp); ++ } ++ } ++ ++ if ( outMask != saveMask ) { ++ output.setFeatures(i+inv_count,outMask); ++ } ++ } ++ ++ output.decomposeReorderMatras(classTable,beginSyllable,nextSyllable,inv_count); ++ ++ beginSyllable = nextSyllable; ++ } ++ ++ ++ return output.getOutputIndex(); ++} ++ ++ ++void IndicReordering::getDynamicProperties( DynamicProperties *, const IndicClassTable *classTable ) { ++ ++ ++ LEUnicode currentChar; ++ LEUnicode virama; ++ LEUnicode workChars[2]; ++ LEGlyphStorage workGlyphs; ++ ++ IndicReorderingOutput workOutput(workChars, workGlyphs, NULL); ++ ++ //le_int32 offset = 0; ++ ++ // First find the relevant virama for the script we are dealing with ++ ++ for ( currentChar = classTable->firstChar ; currentChar <= classTable->lastChar ; currentChar++ ) { ++ if ( classTable->isVirama(currentChar)) { ++ virama = currentChar; ++ break; ++ } ++ } ++ ++ for ( currentChar = classTable->firstChar ; currentChar <= classTable->lastChar ; currentChar++ ) { ++ if ( classTable->isConsonant(currentChar)) { ++ workOutput.reset(); ++ } ++ } ++ ++ ++} ++ + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/IndicReordering.h b/src/share/native/sun/font/layout/IndicReordering.h +--- jdk/src/share/native/sun/font/layout/IndicReordering.h ++++ jdk/src/share/native/sun/font/layout/IndicReordering.h +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2009 - All Rights Reserved + * + */ + +@@ -62,7 +62,8 @@ + #define CC_SPLIT_VOWEL_PIECE_3 12U + #define CC_VIRAMA 13U + #define CC_ZERO_WIDTH_MARK 14U +-#define CC_COUNT 15U ++#define CC_AL_LAKUNA 15U ++#define CC_COUNT 16U + + // Character class flags + #define CF_CLASS_MASK 0x0000FFFFU +@@ -74,6 +75,7 @@ + #define CF_BELOW_BASE 0x10000000U + #define CF_POST_BASE 0x08000000U + #define CF_LENGTH_MARK 0x04000000U ++#define CF_PRE_BASE 0x02000000U + + #define CF_POS_BEFORE 0x00300000U + #define CF_POS_BELOW 0x00200000U +@@ -89,6 +91,7 @@ + #define SF_REPH_AFTER_BELOW 0x40000000U + #define SF_EYELASH_RA 0x20000000U + #define SF_MPRE_FIXUP 0x10000000U ++#define SF_FILTER_ZERO_WIDTH 0x08000000U + + #define SF_POST_BASE_LIMIT_MASK 0x0000FFFFU + #define SF_NO_POST_BASE_LIMIT 0x00007FFFU +@@ -98,6 +101,15 @@ + class MPreFixups; + class LEGlyphStorage; + ++// Dynamic Properties ( v2 fonts only ) ++typedef le_uint32 DynamicProperties; ++ ++#define DP_REPH 0x80000000U ++#define DP_HALF 0x40000000U ++#define DP_PREF 0x20000000U ++#define DP_BLWF 0x10000000U ++#define DP_PSTF 0x08000000U ++ + struct IndicClassTable + { + typedef le_uint32 CharClass; +@@ -111,6 +123,7 @@ + const SplitMatra *splitMatraTable; + + inline le_int32 getWorstCaseExpansion() const; ++ inline le_bool getFilterZeroWidth() const; + + CharClass getCharClass(LEUnicode ch) const; + +@@ -121,6 +134,7 @@ + inline le_bool isConsonant(LEUnicode ch) const; + inline le_bool isReph(LEUnicode ch) const; + inline le_bool isVirama(LEUnicode ch) const; ++ inline le_bool isAlLakuna(LEUnicode ch) const; + inline le_bool isNukta(LEUnicode ch) const; + inline le_bool isVattu(LEUnicode ch) const; + inline le_bool isMatra(LEUnicode ch) const; +@@ -129,12 +143,15 @@ + inline le_bool hasPostOrBelowBaseForm(LEUnicode ch) const; + inline le_bool hasPostBaseForm(LEUnicode ch) const; + inline le_bool hasBelowBaseForm(LEUnicode ch) const; ++ inline le_bool hasAboveBaseForm(LEUnicode ch) const; ++ inline le_bool hasPreBaseForm(LEUnicode ch) const; + + inline static le_bool isVowelModifier(CharClass charClass); + inline static le_bool isStressMark(CharClass charClass); + inline static le_bool isConsonant(CharClass charClass); + inline static le_bool isReph(CharClass charClass); + inline static le_bool isVirama(CharClass charClass); ++ inline static le_bool isAlLakuna(CharClass charClass); + inline static le_bool isNukta(CharClass charClass); + inline static le_bool isVattu(CharClass charClass); + inline static le_bool isMatra(CharClass charClass); +@@ -143,6 +160,8 @@ + inline static le_bool hasPostOrBelowBaseForm(CharClass charClass); + inline static le_bool hasPostBaseForm(CharClass charClass); + inline static le_bool hasBelowBaseForm(CharClass charClass); ++ inline static le_bool hasAboveBaseForm(CharClass charClass); ++ inline static le_bool hasPreBaseForm(CharClass charClass); + + static const IndicClassTable *getScriptClassTable(le_int32 scriptCode); + }; +@@ -151,14 +170,27 @@ + public: + static le_int32 getWorstCaseExpansion(le_int32 scriptCode); + ++ static le_bool getFilterZeroWidth(le_int32 scriptCode); ++ + static le_int32 reorder(const LEUnicode *theChars, le_int32 charCount, le_int32 scriptCode, + LEUnicode *outChars, LEGlyphStorage &glyphStorage, +- MPreFixups **outMPreFixups); ++ MPreFixups **outMPreFixups, LEErrorCode& success); + +- static void adjustMPres(MPreFixups *mpreFixups, LEGlyphStorage &glyphStorage); ++ static void adjustMPres(MPreFixups *mpreFixups, LEGlyphStorage &glyphStorage, LEErrorCode& success); ++ ++ static le_int32 v2process(const LEUnicode *theChars, le_int32 charCount, le_int32 scriptCode, ++ LEUnicode *outChars, LEGlyphStorage &glyphStorage); + + static const FeatureMap *getFeatureMap(le_int32 &count); + ++ static const FeatureMap *getv2FeatureMap(le_int32 &count); ++ ++ static void applyPresentationForms(LEGlyphStorage &glyphStorage, le_int32 count); ++ ++ static void finalReordering(LEGlyphStorage &glyphStorage, le_int32 count); ++ ++ static void getDynamicProperties(DynamicProperties *dProps, const IndicClassTable *classTable); ++ + private: + // do not instantiate + IndicReordering(); +@@ -172,6 +204,11 @@ + return worstCaseExpansion; + } + ++inline le_bool IndicClassTable::getFilterZeroWidth() const ++{ ++ return (scriptFlags & SF_FILTER_ZERO_WIDTH) != 0; ++} ++ + inline const SplitMatra *IndicClassTable::getSplitMatra(CharClass charClass) const + { + le_int32 index = (charClass & CF_INDEX_MASK) >> CF_INDEX_SHIFT; +@@ -209,6 +246,11 @@ + return (charClass & CF_CLASS_MASK) == CC_VIRAMA; + } + ++inline le_bool IndicClassTable::isAlLakuna(CharClass charClass) ++{ ++ return (charClass & CF_CLASS_MASK) == CC_AL_LAKUNA; ++} ++ + inline le_bool IndicClassTable::isVattu(CharClass charClass) + { + return (charClass & CF_VATTU) != 0; +@@ -241,11 +283,21 @@ + return (charClass & CF_POST_BASE) != 0; + } + ++inline le_bool IndicClassTable::hasPreBaseForm(CharClass charClass) ++{ ++ return (charClass & CF_PRE_BASE) != 0; ++} ++ + inline le_bool IndicClassTable::hasBelowBaseForm(CharClass charClass) + { + return (charClass & CF_BELOW_BASE) != 0; + } + ++inline le_bool IndicClassTable::hasAboveBaseForm(CharClass charClass) ++{ ++ return ((charClass & CF_POS_MASK) == CF_POS_ABOVE); ++} ++ + inline le_bool IndicClassTable::isVowelModifier(LEUnicode ch) const + { + return isVowelModifier(getCharClass(ch)); +@@ -271,6 +323,11 @@ + return isVirama(getCharClass(ch)); + } + ++inline le_bool IndicClassTable::isAlLakuna(LEUnicode ch) const ++{ ++ return isAlLakuna(getCharClass(ch)); ++} ++ + inline le_bool IndicClassTable::isNukta(LEUnicode ch) const + { + return isNukta(getCharClass(ch)); +@@ -311,5 +368,14 @@ + return hasBelowBaseForm(getCharClass(ch)); + } + ++inline le_bool IndicClassTable::hasPreBaseForm(LEUnicode ch) const ++{ ++ return hasPreBaseForm(getCharClass(ch)); ++} ++ ++inline le_bool IndicClassTable::hasAboveBaseForm(LEUnicode ch) const ++{ ++ return hasAboveBaseForm(getCharClass(ch)); ++} + U_NAMESPACE_END + #endif +diff --git a/src/share/native/sun/font/layout/KernTable.cpp b/src/share/native/sun/font/layout/KernTable.cpp +--- jdk/src/share/native/sun/font/layout/KernTable.cpp ++++ jdk/src/share/native/sun/font/layout/KernTable.cpp +@@ -26,7 +26,7 @@ + /* + * + * +- * (C) Copyright IBM Corp. 2004-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 2004-2010 - All Rights Reserved + * + */ + +@@ -35,6 +35,7 @@ + #include "LEGlyphStorage.h" + + #include "LESwaps.h" ++#include "OpenTypeUtilities.h" + + #include <stdio.h> + +@@ -91,8 +92,8 @@ + * TODO: support multiple subtables + * TODO: respect header flags + */ +-KernTable::KernTable(const LEFontInstance* font, const void* tableData) +- : pairs(0), font(font) ++KernTable::KernTable(const LEFontInstance* font_, const void* tableData) ++ : pairs(0), font(font_) + { + const KernTableHeader* header = (const KernTableHeader*)tableData; + if (header == 0) { +@@ -120,10 +121,18 @@ + coverage = SWAPW(subhead->coverage); + if (coverage & COVERAGE_HORIZONTAL) { // only handle horizontal kerning + const Subtable_0* table = (const Subtable_0*)((char*)subhead + KERN_SUBTABLE_HEADER_SIZE); +- nPairs = SWAPW(table->nPairs); +- searchRange = SWAPW(table->searchRange) / KERN_PAIRINFO_SIZE ; ++ ++ nPairs = SWAPW(table->nPairs); ++ ++#if 0 // some old fonts have bad values here... ++ searchRange = SWAPW(table->searchRange); + entrySelector = SWAPW(table->entrySelector); +- rangeShift = SWAPW(table->rangeShift) / KERN_PAIRINFO_SIZE; ++ rangeShift = SWAPW(table->rangeShift); ++#else ++ entrySelector = OpenTypeUtilities::highBit(nPairs); ++ searchRange = (1 << entrySelector) * KERN_PAIRINFO_SIZE; ++ rangeShift = (nPairs * KERN_PAIRINFO_SIZE) - searchRange; ++#endif + + pairs = (PairInfo*)font->getKernPairs(); + if (pairs == NULL) { +diff --git a/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp b/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp +@@ -25,7 +25,7 @@ + + + /* +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved + * + * This file is a modification of the ICU file IndicLayoutEngine.cpp + * by Jens Herden and Javier Sola for Khmer language +@@ -43,16 +43,16 @@ + UOBJECT_DEFINE_RTTI_IMPLEMENTATION(KhmerOpenTypeLayoutEngine) + + KhmerOpenTypeLayoutEngine::KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable) ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success) + { + fFeatureMap = KhmerReordering::getFeatureMap(fFeatureMapCount); + fFeatureOrder = TRUE; + } + + KhmerOpenTypeLayoutEngine::KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags) +- : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags) ++ le_int32 typoFlags, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success) + { + fFeatureMap = KhmerReordering::getFeatureMap(fFeatureMapCount); + fFeatureOrder = TRUE; +diff --git a/src/share/native/sun/font/layout/KhmerLayoutEngine.h b/src/share/native/sun/font/layout/KhmerLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.h +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved + * + * This file is a modification of the ICU file IndicLayoutEngine.h + * by Jens Herden and Javier Sola for Khmer language +@@ -72,8 +72,9 @@ + * + * @param fontInstance - the font + * @param scriptCode - the script +- * @param languageCode - the language ++ * @param langaugeCode - the language + * @param gsubTable - the GSUB table ++ * @param success - set to an error code if the operation fails + * + * @see LayoutEngine::layoutEngineFactory + * @see OpenTypeLayoutEngine +@@ -82,7 +83,7 @@ + * @internal + */ + KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success); + + /** + * This constructor is used when the font requires a "canned" GSUB table which can't be known +@@ -91,6 +92,7 @@ + * @param fontInstance - the font + * @param scriptCode - the script + * @param langaugeCode - the language ++ * @param success - set to an error code if the operation fails + * + * @see OpenTypeLayoutEngine + * @see ScriptAndLangaugeTags.h for script and language codes +@@ -98,7 +100,7 @@ + * @internal + */ + KhmerOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags); ++ le_int32 typoFlags, LEErrorCode &success); + + /** + * The destructor, virtual for correct polymorphic invocation. +diff --git a/src/share/native/sun/font/layout/KhmerReordering.cpp b/src/share/native/sun/font/layout/KhmerReordering.cpp +--- jdk/src/share/native/sun/font/layout/KhmerReordering.cpp ++++ jdk/src/share/native/sun/font/layout/KhmerReordering.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved + * + * This file is a modification of the ICU file IndicReordering.cpp + * by Jens Herden and Javier Sola for Khmer language +@@ -149,8 +149,9 @@ + + + +-class ReorderingOutput : public UMemory { ++class KhmerReorderingOutput : public UMemory { + private: ++ le_int32 fSyllableCount; + le_int32 fOutIndex; + LEUnicode *fOutChars; + +@@ -158,17 +159,22 @@ + + + public: +- ReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage) +- : fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage) ++ KhmerReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage) ++ : fSyllableCount(0), fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage) + { + // nothing else to do... + } + +- ~ReorderingOutput() ++ ~KhmerReorderingOutput() + { + // nothing to do here... + } + ++ void reset() ++ { ++ fSyllableCount += 1; ++ } ++ + void writeChar(LEUnicode ch, le_uint32 charIndex, FeatureMask charFeatures) + { + LEErrorCode success = LE_NO_ERROR; +@@ -176,7 +182,7 @@ + fOutChars[fOutIndex] = ch; + + fGlyphStorage.setCharIndex(fOutIndex, charIndex, success); +- fGlyphStorage.setAuxData(fOutIndex, charFeatures, success); ++ fGlyphStorage.setAuxData(fOutIndex, charFeatures | (fSyllableCount & LE_GLYPH_GROUP_MASK), success); + + fOutIndex += 1; + } +@@ -328,12 +334,12 @@ + {-1, -1, -1, -1, 12, 13, -1, 10, 16, 17, 1, 14}, // 9 - First consonant or type 3 after ceong + {-1, 11, 11, 11, -1, -1, -1, -1, -1, -1, -1, -1}, // 10 - Second Coeng (no register shifter before) + {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17, 1, 14}, // 11 - Second coeng consonant (or ind. vowel) no register shifter before +- {-1, -1, 1, -1, -1, 13, -1, -1, 16, -1, -1, -1}, // 12 - Second ZWNJ before a register shifter ++ {-1, -1, -1, -1, -1, 13, -1, -1, 16, -1, -1, -1}, // 12 - Second ZWNJ before a register shifter + {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17, 1, 14}, // 13 - Second register shifter + {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 14 - ZWJ before vowel + {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 15 - ZWNJ before vowel + {-1, -1, -1, -1, -1, -1, -1, -1, -1, 17, 1, 18}, // 16 - dependent vowel +- {-1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 18}, // 17 - sign above ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 18}, // 17 - sign above + {-1, -1, -1, -1, -1, -1, -1, 19, -1, -1, -1, -1}, // 18 - ZWJ after vowel + {-1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19 - Third coeng + {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1}, // 20 - dependent vowel after a Robat +@@ -380,7 +386,7 @@ + { + const KhmerClassTable *classTable = KhmerClassTable::getKhmerClassTable(); + +- ReorderingOutput output(outChars, glyphStorage); ++ KhmerReorderingOutput output(outChars, glyphStorage); + KhmerClassTable::CharClass charClass; + le_int32 i, prev = 0, coengRo; + +@@ -390,6 +396,8 @@ + while (prev < charCount) { + le_int32 syllable = findSyllable(classTable, chars, prev, charCount); + ++ output.reset(); ++ + // write a pre vowel or the pre part of a split vowel first + // and look out for coeng + ro. RO is the only vowel of type 2, and + // therefore the only one that requires saving space before the base. +diff --git a/src/share/native/sun/font/layout/LEFontInstance.cpp b/src/share/native/sun/font/layout/LEFontInstance.cpp +--- jdk/src/share/native/sun/font/layout/LEFontInstance.cpp ++++ jdk/src/share/native/sun/font/layout/LEFontInstance.cpp +@@ -26,7 +26,7 @@ + /* + ******************************************************************************* + * +- * Copyright (C) 1999-2005, International Business Machines ++ * Copyright (C) 1999-2007, International Business Machines + * Corporation and others. All Rights Reserved. + * + ******************************************************************************* +@@ -45,6 +45,16 @@ + + UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LEFontInstance) + ++LECharMapper::~LECharMapper() ++{ ++ // nothing to do. ++} ++ ++LEFontInstance::~LEFontInstance() ++{ ++ // nothing to do ++} ++ + const LEFontInstance *LEFontInstance::getSubFont(const LEUnicode chars[], le_int32 *offset, le_int32 limit, + le_int32 script, LEErrorCode &success) const + { +@@ -62,7 +72,7 @@ + } + + void LEFontInstance::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, +- le_bool reverse, const LECharMapper *mapper, LEGlyphStorage &glyphStorage) const ++ le_bool reverse, const LECharMapper *mapper, le_bool filterZeroWidth, LEGlyphStorage &glyphStorage) const + { + le_int32 i, out = 0, dir = 1; + +@@ -83,7 +93,7 @@ + } + } + +- glyphStorage[out] = mapCharToGlyph(code, mapper); ++ glyphStorage[out] = mapCharToGlyph(code, mapper, filterZeroWidth); + + if (code >= 0x10000) { + i += 1; +@@ -94,14 +104,71 @@ + + LEGlyphID LEFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper) const + { ++ return mapCharToGlyph(ch, mapper, TRUE); ++} ++ ++LEGlyphID LEFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper, le_bool filterZeroWidth) const ++{ + LEUnicode32 mappedChar = mapper->mapChar(ch); + +- if (mappedChar == 0xFFFE || mappedChar == 0xFFFF || +- mappedChar == 0x200C || mappedChar == 0x200D) { ++ if (mappedChar == 0xFFFE || mappedChar == 0xFFFF) { + return 0xFFFF; + } + ++ if (filterZeroWidth && (mappedChar == 0x200C || mappedChar == 0x200D)) { ++ return canDisplay(mappedChar)? 0x0001 : 0xFFFF; ++ } ++ + return mapCharToGlyph(mappedChar); + } ++ ++le_bool LEFontInstance::canDisplay(LEUnicode32 ch) const ++{ ++ return LE_GET_GLYPH(mapCharToGlyph(ch)) != 0; ++} ++ ++float LEFontInstance::xUnitsToPoints(float xUnits) const ++{ ++ return (xUnits * getXPixelsPerEm()) / (float) getUnitsPerEM(); ++} ++ ++float LEFontInstance::yUnitsToPoints(float yUnits) const ++{ ++ return (yUnits * getYPixelsPerEm()) / (float) getUnitsPerEM(); ++} ++ ++void LEFontInstance::unitsToPoints(LEPoint &units, LEPoint &points) const ++{ ++ points.fX = xUnitsToPoints(units.fX); ++ points.fY = yUnitsToPoints(units.fY); ++} ++ ++float LEFontInstance::xPixelsToUnits(float xPixels) const ++{ ++ return (xPixels * getUnitsPerEM()) / (float) getXPixelsPerEm(); ++} ++ ++float LEFontInstance::yPixelsToUnits(float yPixels) const ++{ ++ return (yPixels * getUnitsPerEM()) / (float) getYPixelsPerEm(); ++} ++ ++void LEFontInstance::pixelsToUnits(LEPoint &pixels, LEPoint &units) const ++{ ++ units.fX = xPixelsToUnits(pixels.fX); ++ units.fY = yPixelsToUnits(pixels.fY); ++} ++ ++void LEFontInstance::transformFunits(float xFunits, float yFunits, LEPoint &pixels) const ++{ ++ pixels.fX = xUnitsToPoints(xFunits) * getScaleFactorX(); ++ pixels.fY = yUnitsToPoints(yFunits) * getScaleFactorY(); ++} ++ ++le_int32 LEFontInstance::getLineHeight() const ++{ ++ return getAscent() + getDescent() + getLeading(); ++} ++ + U_NAMESPACE_END + +diff --git a/src/share/native/sun/font/layout/LEFontInstance.h b/src/share/native/sun/font/layout/LEFontInstance.h +--- jdk/src/share/native/sun/font/layout/LEFontInstance.h ++++ jdk/src/share/native/sun/font/layout/LEFontInstance.h +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved + * + */ + +@@ -57,7 +57,7 @@ + * Destructor. + * @stable ICU 3.2 + */ +- virtual inline ~LECharMapper() {}; ++ virtual ~LECharMapper(); + + /** + * This method does the adjustments. +@@ -75,7 +75,7 @@ + * This is a forward reference to the class which holds the per-glyph + * storage. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + class LEGlyphStorage; + +@@ -101,7 +101,7 @@ + * methods with some default behavior such as returning constant values, or using the + * values from the first subfont. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + class U_LAYOUT_API LEFontInstance : public UObject + { +@@ -113,7 +113,7 @@ + * + * @stable ICU 2.8 + */ +- virtual inline ~LEFontInstance() {}; ++ virtual ~LEFontInstance(); + + /** + * Get a physical font which can render the given text. For composite fonts, +@@ -209,7 +209,7 @@ + * + * @stable ICU 3.2 + */ +- virtual inline le_bool canDisplay(LEUnicode32 ch) const; ++ virtual le_bool canDisplay(LEUnicode32 ch) const; + + /** + * This method returns the number of design units in +@@ -237,13 +237,31 @@ + * @param count - the number of characters + * @param reverse - if <code>TRUE</code>, store the glyph indices in reverse order. + * @param mapper - the character mapper. ++ * @param filterZeroWidth - <code>TRUE</code> if ZWJ / ZWNJ characters should map to a glyph w/ no contours. + * @param glyphStorage - the object which contains the output glyph array + * + * @see LECharMapper + * +- * @draft ICU 3.0 ++ * @stable ICU 3.6 + */ +- virtual void mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, const LECharMapper *mapper, LEGlyphStorage &glyphStorage) const; ++ virtual void mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, const LECharMapper *mapper, le_bool filterZeroWidth, LEGlyphStorage &glyphStorage) const; ++ ++ /** ++ * This method maps a single character to a glyph index, using the ++ * font's character to glyph map. The default implementation of this ++ * method calls the mapper, and then calls <code>mapCharToGlyph(mappedCh)</code>. ++ * ++ * @param ch - the character ++ * @param mapper - the character mapper ++ * @param filterZeroWidth - <code>TRUE</code> if ZWJ / ZWNJ characters should map to a glyph w/ no contours. ++ * ++ * @return the glyph index ++ * ++ * @see LECharMapper ++ * ++ * @stable ICU 3.6 ++ */ ++ virtual LEGlyphID mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper, le_bool filterZeroWidth) const; + + /** + * This method maps a single character to a glyph index, using the +@@ -335,7 +353,7 @@ + * + * @stable ICU 3.2 + */ +- virtual inline float xUnitsToPoints(float xUnits) const; ++ virtual float xUnitsToPoints(float xUnits) const; + + /** + * This method converts font design units in the +@@ -347,7 +365,7 @@ + * + * @stable ICU 3.2 + */ +- virtual inline float yUnitsToPoints(float yUnits) const; ++ virtual float yUnitsToPoints(float yUnits) const; + + /** + * This method converts font design units to points. +@@ -357,7 +375,7 @@ + * + * @stable ICU 3.2 + */ +- virtual inline void unitsToPoints(LEPoint &units, LEPoint &points) const; ++ virtual void unitsToPoints(LEPoint &units, LEPoint &points) const; + + /** + * This method converts pixels in the +@@ -369,7 +387,7 @@ + * + * @stable ICU 3.2 + */ +- virtual inline float xPixelsToUnits(float xPixels) const; ++ virtual float xPixelsToUnits(float xPixels) const; + + /** + * This method converts pixels in the +@@ -381,7 +399,7 @@ + * + * @stable ICU 3.2 + */ +- virtual inline float yPixelsToUnits(float yPixels) const; ++ virtual float yPixelsToUnits(float yPixels) const; + + /** + * This method converts pixels to font design units. +@@ -391,7 +409,7 @@ + * + * @stable ICU 3.2 + */ +- virtual inline void pixelsToUnits(LEPoint &pixels, LEPoint &units) const; ++ virtual void pixelsToUnits(LEPoint &pixels, LEPoint &units) const; + + /** + * Get the X scale factor from the font's transform. The default +@@ -433,7 +451,7 @@ + * + * @stable ICU 3.2 + */ +- virtual inline void transformFunits(float xFunits, float yFunits, LEPoint &pixels) const; ++ virtual void transformFunits(float xFunits, float yFunits, LEPoint &pixels) const; + + /** + * This is a convenience method used to convert +@@ -523,49 +541,6 @@ + + }; + +-inline le_bool LEFontInstance::canDisplay(LEUnicode32 ch) const +-{ +- return LE_GET_GLYPH(mapCharToGlyph(ch)) != 0; +-} +- +-inline float LEFontInstance::xUnitsToPoints(float xUnits) const +-{ +- return (xUnits * getXPixelsPerEm()) / (float) getUnitsPerEM(); +-} +- +-inline float LEFontInstance::yUnitsToPoints(float yUnits) const +-{ +- return (yUnits * getYPixelsPerEm()) / (float) getUnitsPerEM(); +-} +- +-inline void LEFontInstance::unitsToPoints(LEPoint &units, LEPoint &points) const +-{ +- points.fX = xUnitsToPoints(units.fX); +- points.fY = yUnitsToPoints(units.fY); +-} +- +-inline float LEFontInstance::xPixelsToUnits(float xPixels) const +-{ +- return (xPixels * getUnitsPerEM()) / (float) getXPixelsPerEm(); +-} +- +-inline float LEFontInstance::yPixelsToUnits(float yPixels) const +-{ +- return (yPixels * getUnitsPerEM()) / (float) getYPixelsPerEm(); +-} +- +-inline void LEFontInstance::pixelsToUnits(LEPoint &pixels, LEPoint &units) const +-{ +- units.fX = xPixelsToUnits(pixels.fX); +- units.fY = yPixelsToUnits(pixels.fY); +-} +- +-inline void LEFontInstance::transformFunits(float xFunits, float yFunits, LEPoint &pixels) const +-{ +- pixels.fX = xUnitsToPoints(xFunits) * getScaleFactorX(); +- pixels.fY = yUnitsToPoints(yFunits) * getScaleFactorY(); +-} +- + inline float LEFontInstance::fixedToFloat(le_int32 fixed) + { + return (float) (fixed / 65536.0); +@@ -576,11 +551,6 @@ + return (le_int32) (theFloat * 65536.0); + } + +-inline le_int32 LEFontInstance::getLineHeight() const +-{ +- return getAscent() + getDescent() + getLeading(); +-} +- + U_NAMESPACE_END + #endif + +diff --git a/src/share/native/sun/font/layout/LEGlyphStorage.cpp b/src/share/native/sun/font/layout/LEGlyphStorage.cpp +--- jdk/src/share/native/sun/font/layout/LEGlyphStorage.cpp ++++ jdk/src/share/native/sun/font/layout/LEGlyphStorage.cpp +@@ -25,7 +25,7 @@ + + /* + ********************************************************************** +- * Copyright (C) 1998-2005, International Business Machines ++ * Copyright (C) 1998-2009, International Business Machines + * Corporation and others. All Rights Reserved. + ********************************************************************** + */ +@@ -38,6 +38,11 @@ + + UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LEGlyphStorage) + ++LEInsertionCallback::~LEInsertionCallback() ++{ ++ // nothing to do... ++} ++ + LEGlyphStorage::LEGlyphStorage() + : fGlyphCount(0), fGlyphs(NULL), fCharIndices(NULL), fPositions(NULL), + fAuxData(NULL), fInsertionList(NULL), fSrcIndex(0), fDestIndex(0) +@@ -129,8 +134,18 @@ + if (fInsertionList == NULL) { + // FIXME: check this for failure? + fInsertionList = new LEInsertionList(rightToLeft); ++ if (fInsertionList == NULL) { ++ LE_DELETE_ARRAY(fCharIndices); ++ fCharIndices = NULL; ++ ++ LE_DELETE_ARRAY(fGlyphs); ++ fGlyphs = NULL; ++ ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return; + } + } ++} + + // FIXME: do we want to initialize the positions to [0, 0]? + le_int32 LEGlyphStorage::allocatePositions(LEErrorCode &success) +@@ -139,6 +154,11 @@ + return -1; + } + ++ if (fPositions != NULL) { ++ success = LE_INTERNAL_ERROR; ++ return -1; ++ } ++ + fPositions = LE_NEW_ARRAY(float, 2 * (fGlyphCount + 1)); + + if (fPositions == NULL) { +@@ -156,6 +176,11 @@ + return -1; + } + ++ if (fAuxData != NULL) { ++ success = LE_INTERNAL_ERROR; ++ return -1; ++ } ++ + fAuxData = LE_NEW_ARRAY(le_uint32, fGlyphCount); + + if (fAuxData == NULL) { +@@ -510,10 +535,49 @@ + fGlyphCount = newGlyphCount; + } + +-// FIXME: add error checking? ++// Move a glyph to a different position in the LEGlyphStorage ( used for Indic v2 processing ) ++ ++void LEGlyphStorage::moveGlyph(le_int32 fromPosition, le_int32 toPosition, le_uint32 marker ) ++{ ++ ++ LEErrorCode success = LE_NO_ERROR; ++ ++ LEGlyphID holdGlyph = getGlyphID(fromPosition,success); ++ le_int32 holdCharIndex = getCharIndex(fromPosition,success); ++ le_uint32 holdAuxData = getAuxData(fromPosition,success); ++ ++ if ( fromPosition < toPosition ) { ++ for ( le_int32 i = fromPosition ; i < toPosition ; i++ ) { ++ setGlyphID(i,getGlyphID(i+1,success),success); ++ setCharIndex(i,getCharIndex(i+1,success),success); ++ setAuxData(i,getAuxData(i+1,success),success); ++ } ++ } else { ++ for ( le_int32 i = toPosition ; i > fromPosition ; i-- ) { ++ setGlyphID(i,getGlyphID(i-1,success),success); ++ setCharIndex(i,getCharIndex(i-1,success),success); ++ setAuxData(i,getAuxData(i-1,success),success); ++ ++ } ++ } ++ ++ setGlyphID(toPosition,holdGlyph,success); ++ setCharIndex(toPosition,holdCharIndex,success); ++ setAuxData(toPosition,holdAuxData | marker,success); ++ ++} ++ ++// Glue code for existing stable API + LEGlyphID *LEGlyphStorage::insertGlyphs(le_int32 atIndex, le_int32 insertCount) + { +- return fInsertionList->insert(atIndex, insertCount); ++ LEErrorCode ignored = LE_NO_LAYOUT_ERROR; ++ return insertGlyphs(atIndex, insertCount, ignored); ++} ++ ++// FIXME: add error checking? ++LEGlyphID *LEGlyphStorage::insertGlyphs(le_int32 atIndex, le_int32 insertCount, LEErrorCode& success) ++{ ++ return fInsertionList->insert(atIndex, insertCount, success); + } + + le_int32 LEGlyphStorage::applyInsertions() +@@ -526,11 +590,27 @@ + + le_int32 newGlyphCount = fGlyphCount + growAmount; + +- fGlyphs = (LEGlyphID *) LE_GROW_ARRAY(fGlyphs, newGlyphCount); +- fCharIndices = (le_int32 *) LE_GROW_ARRAY(fCharIndices, newGlyphCount); ++ LEGlyphID *newGlyphs = (LEGlyphID *) LE_GROW_ARRAY(fGlyphs, newGlyphCount); ++ if (newGlyphs == NULL) { ++ // Could not grow the glyph array ++ return fGlyphCount; ++ } ++ fGlyphs = newGlyphs; ++ ++ le_int32 *newCharIndices = (le_int32 *) LE_GROW_ARRAY(fCharIndices, newGlyphCount); ++ if (newCharIndices == NULL) { ++ // Could not grow the glyph array ++ return fGlyphCount; ++ } ++ fCharIndices = newCharIndices; + + if (fAuxData != NULL) { +- fAuxData = (le_uint32 *) LE_GROW_ARRAY(fAuxData, newGlyphCount); ++ le_uint32 *newAuxData = (le_uint32 *) LE_GROW_ARRAY(fAuxData, newGlyphCount); ++ if (newAuxData == NULL) { ++ // could not grow the aux data array ++ return fGlyphCount; ++ } ++ fAuxData = (le_uint32 *)newAuxData; + } + + fSrcIndex = fGlyphCount - 1; +diff --git a/src/share/native/sun/font/layout/LEGlyphStorage.h b/src/share/native/sun/font/layout/LEGlyphStorage.h +--- jdk/src/share/native/sun/font/layout/LEGlyphStorage.h ++++ jdk/src/share/native/sun/font/layout/LEGlyphStorage.h +@@ -25,7 +25,7 @@ + + /* + ********************************************************************** +- * Copyright (C) 1998-2005, International Business Machines ++ * Copyright (C) 1998-2010, International Business Machines + * Corporation and others. All Rights Reserved. + ********************************************************************** + */ +@@ -54,7 +54,7 @@ + * + * @see LEInsertionList.h + * +- * @draft ICU 3.6 ++ * @stable ICU 3.6 + */ + class U_LAYOUT_API LEGlyphStorage : public UObject, protected LEInsertionCallback + { +@@ -130,7 +130,7 @@ + * + * @see LEInsertionList.h + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[]); + +@@ -141,14 +141,14 @@ + * <code>allocateGlyphArray, allocatePositions and allocateAuxData</code> + * to allocate the data. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + LEGlyphStorage(); + + /** + * The destructor. This will deallocate all of the arrays. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + ~LEGlyphStorage(); + +@@ -157,7 +157,7 @@ + * + * @return the number of glyphs in the glyph array + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + inline le_int32 getGlyphCount() const; + +@@ -169,7 +169,7 @@ + * @param glyphs - the destiniation glyph array + * @param success - set to an error code if the operation fails + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const; + +@@ -183,7 +183,7 @@ + * @param extraBits - this value will be ORed with each glyph index + * @param success - set to an error code if the operation fails + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const; + +@@ -195,7 +195,7 @@ + * @param charIndices - the destiniation character index array + * @param success - set to an error code if the operation fails + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void getCharIndices(le_int32 charIndices[], LEErrorCode &success) const; + +@@ -208,7 +208,7 @@ + * @param indexBase - an offset which will be added to each index + * @param success - set to an error code if the operation fails + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const; + +@@ -221,7 +221,7 @@ + * @param positions - the destiniation position array + * @param success - set to an error code if the operation fails + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void getGlyphPositions(float positions[], LEErrorCode &success) const; + +@@ -237,7 +237,7 @@ + * @param y - the glyph's Y position + * @param success - set to an error code if the operation fails + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const; + +@@ -251,7 +251,7 @@ + * @param success set to an error code if the storage cannot be allocated of if the initial + * glyph count is not positive. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void allocateGlyphArray(le_int32 initialGlyphCount, le_bool rightToLeft, LEErrorCode &success); + +@@ -263,7 +263,7 @@ + * + * @return the number of X, Y position pairs allocated. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + le_int32 allocatePositions(LEErrorCode &success); + +@@ -274,7 +274,7 @@ + * + * @return the size of the auxillary data array. + * +- * @draft ICU 3.6 ++ * @stable ICU 3.6 + */ + le_int32 allocateAuxData(LEErrorCode &success); + +@@ -284,7 +284,7 @@ + * @param auxData the auxillary data array will be copied to this address + * @param success set to an error code if the data cannot be copied + * +- * @draft ICU 3.6 ++ * @stable ICU 3.6 + */ + void getAuxData(le_uint32 auxData[], LEErrorCode &success) const; + +@@ -296,7 +296,7 @@ + * + * @return the glyph ID + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + LEGlyphID getGlyphID(le_int32 glyphIndex, LEErrorCode &success) const; + +@@ -308,7 +308,7 @@ + * + * @return the character index + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + le_int32 getCharIndex(le_int32 glyphIndex, LEErrorCode &success) const; + +@@ -321,7 +321,7 @@ + * + * @return the auxillary data + * +- * @draft ICU 3.6 ++ * @stable ICU 3.6 + */ + le_uint32 getAuxData(le_int32 glyphIndex, LEErrorCode &success) const; + +@@ -333,7 +333,7 @@ + * + * @return a reference to the given location in the glyph array + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + inline LEGlyphID &operator[](le_int32 glyphIndex) const; + +@@ -346,16 +346,52 @@ + * + * @param atIndex the index of the glyph to be replaced + * @param insertCount the number of glyphs to replace it with ++ * @param success set to an error code if the auxillary data cannot be retrieved. + * + * @return the address at which to store the replacement glyphs. + * +- * @see LEInsetionList.h ++ * @see LEInsertionList.h + * +- * @draft ICU 3.0 ++ * @stable ICU 4.2 ++ */ ++ LEGlyphID *insertGlyphs(le_int32 atIndex, le_int32 insertCount, LEErrorCode& success); ++ ++ /** ++ * Call this method to replace a single glyph in the glyph array ++ * with multiple glyphs. This method uses the <code>LEInsertionList</code> ++ * to do the insertion. It returns the address of storage where the new ++ * glyph IDs can be stored. They will not actually be inserted into the ++ * glyph array until <code>applyInsertions</code> is called. ++ * ++ * Note: Don't use this version, use the other version of this function which has an error code. ++ * ++ * @param atIndex the index of the glyph to be replaced ++ * @param insertCount the number of glyphs to replace it with ++ * ++ * @return the address at which to store the replacement glyphs. ++ * ++ * @see LEInsertionList.h ++ * ++ * @stable ICU 3.0 + */ + LEGlyphID *insertGlyphs(le_int32 atIndex, le_int32 insertCount); + + /** ++ * This method is used to reposition glyphs during Indic v2 processing. It moves ++ * all of the relevant glyph information ( glyph, indices, positions, and auxData ), ++ * from the source position to the target position, and also allows for a marker bit ++ * to be set in the target glyph's auxData so that it won't be reprocessed later in the ++ * cycle. ++ * ++ * @param fromPosition - position of the glyph to be moved ++ * @param toPosition - target position of the glyph ++ * @param marker marker bit ++ * ++ * @stable ICU 4.2 ++ */ ++ void moveGlyph(le_int32 fromPosition, le_int32 toPosition, le_uint32 marker); ++ ++ /** + * This method causes all of the glyph insertions recorded by + * <code>insertGlyphs</code> to be applied to the glyph array. The + * new slots in the char indices and the auxillary data arrays +@@ -365,7 +401,7 @@ + * + * @see LEInsertionList.h + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + le_int32 applyInsertions(); + +@@ -376,7 +412,7 @@ + * @param glyphID the new glyph ID + * @param success will be set to an error code if the glyph ID cannot be set. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void setGlyphID(le_int32 glyphIndex, LEGlyphID glyphID, LEErrorCode &success); + +@@ -387,7 +423,7 @@ + * @param charIndex the new char index + * @param success will be set to an error code if the char index cannot be set. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void setCharIndex(le_int32 glyphIndex, le_int32 charIndex, LEErrorCode &success); + +@@ -399,7 +435,7 @@ + * @param y the new Y position + * @param success will be set to an error code if the position cannot be set. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void setPosition(le_int32 glyphIndex, float x, float y, LEErrorCode &success); + +@@ -411,7 +447,7 @@ + * @param yAdjust the adjustment to the glyph's Y position + * @param success will be set to an error code if the glyph's position cannot be adjusted. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void adjustPosition(le_int32 glyphIndex, float xAdjust, float yAdjust, LEErrorCode &success); + +@@ -422,7 +458,7 @@ + * @param auxData the new auxillary data + * @param success will be set to an error code if the auxillary data cannot be set. + * +- * @draft ICU 3.6 ++ * @stable ICU 3.6 + */ + void setAuxData(le_int32 glyphIndex, le_uint32 auxData, LEErrorCode &success); + +@@ -434,7 +470,7 @@ + * @param from the <code>LEGlyphStorage</code> object from which + * to get the new glyph array. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void adoptGlyphArray(LEGlyphStorage &from); + +@@ -446,7 +482,7 @@ + * @param from the <code>LEGlyphStorage</code> object from which + * to get the new char indices array. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void adoptCharIndicesArray(LEGlyphStorage &from); + +@@ -458,7 +494,7 @@ + * @param from the <code>LEGlyphStorage</code> object from which + * to get the new position array. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void adoptPositionArray(LEGlyphStorage &from); + +@@ -470,7 +506,7 @@ + * @param from the <code>LEGlyphStorage</code> object from which + * to get the new auxillary data array. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void adoptAuxDataArray(LEGlyphStorage &from); + +@@ -481,7 +517,7 @@ + * @param from the <code>LEGlyphStorage</code> object from which + * to get the new glyph count. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void adoptGlyphCount(LEGlyphStorage &from); + +@@ -490,7 +526,7 @@ + * + * @param newGlyphCount the new glyph count. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void adoptGlyphCount(le_int32 newGlyphCount); + +@@ -500,21 +536,21 @@ + * to layout a different characer array. (This method is also called + * by the destructor) + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + void reset(); + + /** + * ICU "poor man's RTTI", returns a UClassID for the actual class. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + virtual UClassID getDynamicClassID() const; + + /** + * ICU "poor man's RTTI", returns a UClassID for this class. + * +- * @draft ICU 3.0 ++ * @stable ICU 3.0 + */ + static UClassID getStaticClassID(); + }; +diff --git a/src/share/native/sun/font/layout/LEInsertionList.cpp b/src/share/native/sun/font/layout/LEInsertionList.cpp +--- jdk/src/share/native/sun/font/layout/LEInsertionList.cpp ++++ jdk/src/share/native/sun/font/layout/LEInsertionList.cpp +@@ -25,7 +25,7 @@ + + /* + ********************************************************************** +- * Copyright (C) 1998-2004, International Business Machines ++ * Copyright (C) 1998-2008, International Business Machines + * Corporation and others. All Rights Reserved. + ********************************************************************** + */ +@@ -76,9 +76,17 @@ + return growAmount; + } + +-LEGlyphID *LEInsertionList::insert(le_int32 position, le_int32 count) ++LEGlyphID *LEInsertionList::insert(le_int32 position, le_int32 count, LEErrorCode &success) + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + InsertionRecord *insertion = (InsertionRecord *) LE_NEW_ARRAY(char, sizeof(InsertionRecord) + (count - ANY_NUMBER) * sizeof (LEGlyphID)); ++ if (insertion == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return 0; ++ } + + insertion->position = position; + insertion->count = count; +diff --git a/src/share/native/sun/font/layout/LEInsertionList.h b/src/share/native/sun/font/layout/LEInsertionList.h +--- jdk/src/share/native/sun/font/layout/LEInsertionList.h ++++ jdk/src/share/native/sun/font/layout/LEInsertionList.h +@@ -25,7 +25,7 @@ + + /* + ********************************************************************** +- * Copyright (C) 1998-2004, International Business Machines ++ * Copyright (C) 1998-2008, International Business Machines + * Corporation and others. All Rights Reserved. + ********************************************************************** + */ +@@ -45,7 +45,7 @@ + * + * @internal + */ +-class LEInsertionCallback ++class U_LAYOUT_API LEInsertionCallback + { + public: + /** +@@ -62,6 +62,11 @@ + * @internal + */ + virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[]) = 0; ++ ++ /** ++ * The destructor ++ */ ++ virtual ~LEInsertionCallback(); + }; + + /** +@@ -103,13 +108,14 @@ + * @param position the glyph at this position in the array will be + * replaced by the new glyphs. + * @param count the number of new glyphs ++ * @param success set to an error code if the auxillary data cannot be retrieved. + * + * @return the address of an array in which to store the new glyphs. This will + * <em>not</em> be in the glyph array. + * + * @internal + */ +- LEGlyphID *insert(le_int32 position, le_int32 count); ++ LEGlyphID *insert(le_int32 position, le_int32 count, LEErrorCode &success); + + /** + * Return the number of new glyphs that have been inserted. +diff --git a/src/share/native/sun/font/layout/LELanguages.h b/src/share/native/sun/font/layout/LELanguages.h +--- jdk/src/share/native/sun/font/layout/LELanguages.h ++++ jdk/src/share/native/sun/font/layout/LELanguages.h +@@ -25,12 +25,12 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005. All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2010. All Rights Reserved. + * + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS + * YOU REALLY KNOW WHAT YOU'RE DOING. + * +- * Generated on: 07/19/2005 01:01:08 PM PDT ++ * Generated on: 10/26/2010 02:53:33 PM PDT + */ + + #ifndef __LELANGUAGES_H +@@ -50,7 +50,7 @@ + * this is just a list of languages which the LayoutEngine + * supports. + * +- * @draft ICU 3.4 ++ * @stable ICU 2.6 + */ + + enum LanguageCodes { +@@ -85,7 +85,51 @@ + zhsLanguageCode = 28, + zhtLanguageCode = 29, + +- languageCodeCount = 30 ++ /** New language codes added 03/13/2008 @stable ICU 4.0 */ ++ afkLanguageCode = 30, ++ belLanguageCode = 31, ++ bgrLanguageCode = 32, ++ catLanguageCode = 33, ++ cheLanguageCode = 34, ++ copLanguageCode = 35, ++ csyLanguageCode = 36, ++ danLanguageCode = 37, ++ deuLanguageCode = 38, ++ dznLanguageCode = 39, ++ ellLanguageCode = 40, ++ engLanguageCode = 41, ++ espLanguageCode = 42, ++ etiLanguageCode = 43, ++ euqLanguageCode = 44, ++ finLanguageCode = 45, ++ fraLanguageCode = 46, ++ gaeLanguageCode = 47, ++ hauLanguageCode = 48, ++ hrvLanguageCode = 49, ++ hunLanguageCode = 50, ++ hyeLanguageCode = 51, ++ indLanguageCode = 52, ++ itaLanguageCode = 53, ++ khmLanguageCode = 54, ++ mngLanguageCode = 55, ++ mtsLanguageCode = 56, ++ nepLanguageCode = 57, ++ nldLanguageCode = 58, ++ pasLanguageCode = 59, ++ plkLanguageCode = 60, ++ ptgLanguageCode = 61, ++ romLanguageCode = 62, ++ rusLanguageCode = 63, ++ skyLanguageCode = 64, ++ slvLanguageCode = 65, ++ sqiLanguageCode = 66, ++ srbLanguageCode = 67, ++ sveLanguageCode = 68, ++ tibLanguageCode = 69, ++ trkLanguageCode = 70, ++ welLanguageCode = 71, ++ ++ languageCodeCount = 72 + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/LEScripts.h b/src/share/native/sun/font/layout/LEScripts.h +--- jdk/src/share/native/sun/font/layout/LEScripts.h ++++ jdk/src/share/native/sun/font/layout/LEScripts.h +@@ -25,40 +25,43 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005. All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2010. All Rights Reserved. + * + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS + * YOU REALLY KNOW WHAT YOU'RE DOING. ++ * ++ * Generated on: 10/26/2010 02:53:33 PM PDT + */ + + #ifndef __LESCRIPTS_H + #define __LESCRIPTS_H + + #include "LETypes.h" ++ + /** + * \file + * \brief C++ API: Constants for Unicode script values + */ + +- + U_NAMESPACE_BEGIN + + /** + * Constants for Unicode script values, generated using + * ICU4J's <code>UScript</code> class. + * +- * @draft ICU 3.0 ++ * @stable ICU 2.2 + */ + + enum ScriptCodes { + zyyyScriptCode = 0, +- qaaiScriptCode = 1, ++ zinhScriptCode = 1, ++ qaaiScriptCode = zinhScriptCode, /* manually added alias, for API stability */ + arabScriptCode = 2, + armnScriptCode = 3, + bengScriptCode = 4, + bopoScriptCode = 5, + cherScriptCode = 6, +- qaacScriptCode = 7, ++ coptScriptCode = 7, + cyrlScriptCode = 8, + dsrtScriptCode = 9, + devaScriptCode = 10, +@@ -91,12 +94,24 @@ + thaaScriptCode = 37, + thaiScriptCode = 38, + tibtScriptCode = 39, ++/** ++ * @stable ICU 2.6 ++ */ ++ + cansScriptCode = 40, ++/** ++ * @stable ICU 2.2 ++ */ ++ + yiiiScriptCode = 41, + tglgScriptCode = 42, + hanoScriptCode = 43, + buhdScriptCode = 44, + tagbScriptCode = 45, ++/** ++ * @stable ICU 2.6 ++ */ ++ + braiScriptCode = 46, + cprtScriptCode = 47, + limbScriptCode = 48, +@@ -105,9 +120,129 @@ + shawScriptCode = 51, + taleScriptCode = 52, + ugarScriptCode = 53, ++/** ++ * @stable ICU 3.0 ++ */ ++ + hrktScriptCode = 54, ++/** ++ * @stable ICU 3.4 ++ */ + +- scriptCodeCount = 55 ++ bugiScriptCode = 55, ++ glagScriptCode = 56, ++ kharScriptCode = 57, ++ syloScriptCode = 58, ++ taluScriptCode = 59, ++ tfngScriptCode = 60, ++ xpeoScriptCode = 61, ++/** ++ * @stable ICU 3.6 ++ */ ++ ++ baliScriptCode = 62, ++ batkScriptCode = 63, ++ blisScriptCode = 64, ++ brahScriptCode = 65, ++ chamScriptCode = 66, ++ cirtScriptCode = 67, ++ cyrsScriptCode = 68, ++ egydScriptCode = 69, ++ egyhScriptCode = 70, ++ egypScriptCode = 71, ++ geokScriptCode = 72, ++ hansScriptCode = 73, ++ hantScriptCode = 74, ++ hmngScriptCode = 75, ++ hungScriptCode = 76, ++ indsScriptCode = 77, ++ javaScriptCode = 78, ++ kaliScriptCode = 79, ++ latfScriptCode = 80, ++ latgScriptCode = 81, ++ lepcScriptCode = 82, ++ linaScriptCode = 83, ++ mandScriptCode = 84, ++ mayaScriptCode = 85, ++ meroScriptCode = 86, ++ nkooScriptCode = 87, ++ orkhScriptCode = 88, ++ permScriptCode = 89, ++ phagScriptCode = 90, ++ phnxScriptCode = 91, ++ plrdScriptCode = 92, ++ roroScriptCode = 93, ++ saraScriptCode = 94, ++ syreScriptCode = 95, ++ syrjScriptCode = 96, ++ syrnScriptCode = 97, ++ tengScriptCode = 98, ++ vaiiScriptCode = 99, ++ vispScriptCode = 100, ++ xsuxScriptCode = 101, ++ zxxxScriptCode = 102, ++ zzzzScriptCode = 103, ++/** ++ * @stable ICU 3.8 ++ */ ++ ++ cariScriptCode = 104, ++ jpanScriptCode = 105, ++ lanaScriptCode = 106, ++ lyciScriptCode = 107, ++ lydiScriptCode = 108, ++ olckScriptCode = 109, ++ rjngScriptCode = 110, ++ saurScriptCode = 111, ++ sgnwScriptCode = 112, ++ sundScriptCode = 113, ++ moonScriptCode = 114, ++ mteiScriptCode = 115, ++/** ++ * @stable ICU 4.0 ++ */ ++ ++ armiScriptCode = 116, ++ avstScriptCode = 117, ++ cakmScriptCode = 118, ++ koreScriptCode = 119, ++ kthiScriptCode = 120, ++ maniScriptCode = 121, ++ phliScriptCode = 122, ++ phlpScriptCode = 123, ++ phlvScriptCode = 124, ++ prtiScriptCode = 125, ++ samrScriptCode = 126, ++ tavtScriptCode = 127, ++ zmthScriptCode = 128, ++ zsymScriptCode = 129, ++/** ++ * @stable ICU 4.4 ++ */ ++ ++ bamuScriptCode = 130, ++ lisuScriptCode = 131, ++ nkgbScriptCode = 132, ++ sarbScriptCode = 133, ++/** ++ * @stable ICU 4.6 ++ */ ++ ++ bassScriptCode = 134, ++ duplScriptCode = 135, ++ elbaScriptCode = 136, ++ granScriptCode = 137, ++ kpelScriptCode = 138, ++ lomaScriptCode = 139, ++ mendScriptCode = 140, ++ mercScriptCode = 141, ++ narbScriptCode = 142, ++ nbatScriptCode = 143, ++ palmScriptCode = 144, ++ sindScriptCode = 145, ++ waraScriptCode = 146, ++ ++ scriptCodeCount = 147 + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/LEStandalone.h b/src/share/native/sun/font/layout/LEStandalone.h +--- jdk/src/share/native/sun/font/layout/LEStandalone.h ++++ jdk/src/share/native/sun/font/layout/LEStandalone.h +@@ -26,6 +26,15 @@ + #ifndef __LESTANDALONE + #define __LESTANDALONE + ++#ifndef U_COPYRIGHT_STRING ++#define U_COPYRIGHT_STRING " (C) Copyright IBM Corp and Others. 1998-2010 - All Rights Reserved" ++#endif ++ ++/* ICU Version number */ ++#ifndef U_ICU_VERSION ++#define U_ICU_VERSION "4.6" ++#endif ++ + /* Definitions to make Layout Engine work away from ICU. */ + #ifndef U_NAMESPACE_BEGIN + #define U_NAMESPACE_BEGIN +diff --git a/src/share/native/sun/font/layout/LESwaps.h b/src/share/native/sun/font/layout/LESwaps.h +--- jdk/src/share/native/sun/font/layout/LESwaps.h ++++ jdk/src/share/native/sun/font/layout/LESwaps.h +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +diff --git a/src/share/native/sun/font/layout/LETypes.h b/src/share/native/sun/font/layout/LETypes.h +--- jdk/src/share/native/sun/font/layout/LETypes.h ++++ jdk/src/share/native/sun/font/layout/LETypes.h +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -500,6 +500,7 @@ + LE_CALT_FEATURE_TAG = 0x63616C74UL, /**< 'calt' */ + LE_CASE_FEATURE_TAG = 0x63617365UL, /**< 'case' */ + LE_CCMP_FEATURE_TAG = 0x63636D70UL, /**< 'ccmp' */ ++ LE_CJCT_FEATURE_TAG = 0x636A6374UL, /**< 'cjct' */ + LE_CLIG_FEATURE_TAG = 0x636C6967UL, /**< 'clig' */ + LE_CPSP_FEATURE_TAG = 0x63707370UL, /**< 'cpsp' */ + LE_CSWH_FEATURE_TAG = 0x63737768UL, /**< 'cswh' */ +@@ -563,6 +564,7 @@ + LE_RAND_FEATURE_TAG = 0x72616E64UL, /**< 'rand' */ + LE_RLIG_FEATURE_TAG = 0x726C6967UL, /**< 'rlig' */ + LE_RPHF_FEATURE_TAG = 0x72706866UL, /**< 'rphf' */ ++ LE_RKRF_FEATURE_TAG = 0x726B7266UL, /**< 'rkrf' */ + LE_RTBD_FEATURE_TAG = 0x72746264UL, /**< 'rtbd' */ + LE_RTLA_FEATURE_TAG = 0x72746C61UL, /**< 'rtla' */ + LE_RUBY_FEATURE_TAG = 0x72756279UL, /**< 'ruby' */ +diff --git a/src/share/native/sun/font/layout/LayoutEngine.cpp b/src/share/native/sun/font/layout/LayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/LayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/LayoutEngine.cpp +@@ -39,10 +39,11 @@ + #include "ArabicLayoutEngine.h" + #include "CanonShaping.h" + #include "HanLayoutEngine.h" ++#include "HangulLayoutEngine.h" + #include "IndicLayoutEngine.h" + #include "KhmerLayoutEngine.h" + #include "ThaiLayoutEngine.h" +-//#include "TibetanLayoutEngine.h" ++#include "TibetanLayoutEngine.h" + #include "GXLayoutEngine.h" + #include "ScriptAndLanguageTags.h" + #include "CharSubstitutionFilter.h" +@@ -60,6 +61,9 @@ + + U_NAMESPACE_BEGIN + ++/* Leave this copyright notice here! It needs to go somewhere in this library. */ ++static const char copyright[] = U_COPYRIGHT_STRING; ++ + const LEUnicode32 DefaultCharMapper::controlChars[] = { + 0x0009, 0x000A, 0x000D, + /*0x200C, 0x200D,*/ 0x200E, 0x200F, +@@ -97,9 +101,8 @@ + } + + if (fFilterControls) { +- le_int32 index = OpenTypeUtilities::search((le_uint32)ch, +- (le_uint32 *)controlChars, +- controlCharsCount); ++ le_int32 index = OpenTypeUtilities::search((le_uint32)ch, (le_uint32 *)controlChars, controlCharsCount); ++ + if (controlChars[index] == ch) { + return 0xFFFF; + } +@@ -135,56 +138,7 @@ + // nothing to do + } + +- +-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine) +- +-#define ccmpFeatureTag LE_CCMP_FEATURE_TAG +- +-#define ccmpFeatureMask 0x80000000UL +- +-#define canonFeatures (ccmpFeatureMask) +- +-static const FeatureMap canonFeatureMap[] = +-{ +- {ccmpFeatureTag, ccmpFeatureMask} +-}; +- +-static const le_int32 canonFeatureMapCount = LE_ARRAY_SIZE(canonFeatureMap); +- +-LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) +- : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), fLanguageCode(languageCode), +- fTypoFlags(typoFlags) +-{ +- fGlyphStorage = new LEGlyphStorage(); +-} +- +-le_int32 LayoutEngine::getGlyphCount() const +-{ +- return fGlyphStorage->getGlyphCount(); +-} +- +-void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const +-{ +- fGlyphStorage->getCharIndices(charIndices, indexBase, success); +-} +- +-void LayoutEngine::getCharIndices(le_int32 charIndices[], LEErrorCode &success) const +-{ +- fGlyphStorage->getCharIndices(charIndices, success); +-} +- +-// Copy the glyphs into caller's (32-bit) glyph array, OR in extraBits +-void LayoutEngine::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const +-{ +- fGlyphStorage->getGlyphs(glyphs, extraBits, success); +-} +- +-void LayoutEngine::getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const +-{ +- fGlyphStorage->getGlyphs(glyphs, success); +-} +- +-class CanonMarkFilter : public LEGlyphFilter ++class CanonMarkFilter : public UMemory, public LEGlyphFilter + { + private: + const GlyphClassDefinitionTable *classDefTable; +@@ -216,6 +170,66 @@ + return glyphClass != 0; + } + ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine) ++ ++#define ccmpFeatureTag LE_CCMP_FEATURE_TAG ++ ++#define ccmpFeatureMask 0x80000000UL ++ ++#define canonFeatures (ccmpFeatureMask) ++ ++static const FeatureMap canonFeatureMap[] = ++{ ++ {ccmpFeatureTag, ccmpFeatureMask} ++}; ++ ++static const le_int32 canonFeatureMapCount = LE_ARRAY_SIZE(canonFeatureMap); ++ ++LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, ++ le_int32 scriptCode, ++ le_int32 languageCode, ++ le_int32 typoFlags, ++ LEErrorCode &success) ++ : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), fLanguageCode(languageCode), ++ fTypoFlags(typoFlags), fFilterZeroWidth(TRUE) ++{ ++ if (LE_FAILURE(success)) { ++ return; ++ } ++ ++ fGlyphStorage = new LEGlyphStorage(); ++ if (fGlyphStorage == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++} ++} ++ ++le_int32 LayoutEngine::getGlyphCount() const ++{ ++ return fGlyphStorage->getGlyphCount(); ++} ++ ++void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const ++{ ++ fGlyphStorage->getCharIndices(charIndices, indexBase, success); ++} ++ ++void LayoutEngine::getCharIndices(le_int32 charIndices[], LEErrorCode &success) const ++{ ++ fGlyphStorage->getCharIndices(charIndices, success); ++} ++ ++// Copy the glyphs into caller's (32-bit) glyph array, OR in extraBits ++void LayoutEngine::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const ++{ ++ fGlyphStorage->getGlyphs(glyphs, extraBits, success); ++} ++ ++void LayoutEngine::getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const ++{ ++ fGlyphStorage->getGlyphs(glyphs, success); ++} ++ ++ + void LayoutEngine::getGlyphPositions(float positions[], LEErrorCode &success) const + { + fGlyphStorage->getGlyphPositions(positions, success); +@@ -245,8 +259,21 @@ + + if (canonGSUBTable->coversScript(scriptTag)) { + CharSubstitutionFilter *substitutionFilter = new CharSubstitutionFilter(fFontInstance); ++ if (substitutionFilter == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return 0; ++ } ++ + const LEUnicode *inChars = &chars[offset]; + LEUnicode *reordered = NULL; ++ LEGlyphStorage fakeGlyphStorage; ++ ++ fakeGlyphStorage.allocateGlyphArray(count, rightToLeft, success); ++ ++ if (LE_FAILURE(success)) { ++ delete substitutionFilter; ++ return 0; ++ } + + // This is the cheapest way to get mark reordering only for Hebrew. + // We could just do the mark reordering for all scripts, but most +@@ -255,18 +282,19 @@ + reordered = LE_NEW_ARRAY(LEUnicode, count); + + if (reordered == NULL) { ++ delete substitutionFilter; + success = LE_MEMORY_ALLOCATION_ERROR; + return 0; + } + +- CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, reordered, glyphStorage); ++ CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, reordered, fakeGlyphStorage); + inChars = reordered; + } + +- glyphStorage.allocateGlyphArray(count, rightToLeft, success); +- glyphStorage.allocateAuxData(success); ++ fakeGlyphStorage.allocateAuxData(success); + + if (LE_FAILURE(success)) { ++ delete substitutionFilter; + return 0; + } + +@@ -276,21 +304,41 @@ + } + + for (i = 0; i < count; i += 1, out += dir) { +- glyphStorage[out] = (LEGlyphID) inChars[i]; +- glyphStorage.setAuxData(out, canonFeatures, success); ++ fakeGlyphStorage[out] = (LEGlyphID) inChars[i]; ++ fakeGlyphStorage.setAuxData(out, canonFeatures, success); + } + + if (reordered != NULL) { + LE_DELETE_ARRAY(reordered); + } + +- outCharCount = canonGSUBTable->process(glyphStorage, rightToLeft, scriptTag, langSysTag, NULL, substitutionFilter, canonFeatureMap, canonFeatureMapCount, FALSE); ++ outCharCount = canonGSUBTable->process(fakeGlyphStorage, rightToLeft, scriptTag, langSysTag, NULL, substitutionFilter, canonFeatureMap, canonFeatureMapCount, FALSE, success); ++ ++ if (LE_FAILURE(success)) { ++ delete substitutionFilter; ++ return 0; ++ } + + out = (rightToLeft? outCharCount - 1 : 0); + ++ /* ++ * The char indices array in fakeGlyphStorage has the correct mapping ++ * back to the original input characters. Save it in glyphStorage. The ++ * subsequent call to glyphStoratge.allocateGlyphArray will keep this ++ * array rather than allocating and initializing a new one. ++ */ ++ glyphStorage.adoptCharIndicesArray(fakeGlyphStorage); ++ + outChars = LE_NEW_ARRAY(LEUnicode, outCharCount); ++ ++ if (outChars == NULL) { ++ delete substitutionFilter; ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return 0; ++ } ++ + for (i = 0; i < outCharCount; i += 1, out += dir) { +- outChars[out] = (LEUnicode) LE_GET_GLYPH(glyphStorage[i]); ++ outChars[out] = (LEUnicode) LE_GET_GLYPH(fakeGlyphStorage[i]); + } + + delete substitutionFilter; +@@ -475,7 +523,7 @@ + + DefaultCharMapper charMapper(TRUE, mirror); + +- fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, glyphStorage); ++ fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, fFilterZeroWidth, glyphStorage); + } + + // Input: characters, font? +@@ -495,6 +543,10 @@ + + le_int32 glyphCount; + ++ if (fGlyphStorage->getGlyphCount() > 0) { ++ fGlyphStorage->reset(); ++ } ++ + glyphCount = computeGlyphs(chars, offset, count, max, rightToLeft, *fGlyphStorage, success); + positionGlyphs(*fGlyphStorage, x, y, success); + adjustGlyphPositions(chars, offset, count, rightToLeft, *fGlyphStorage, success); +@@ -526,8 +578,15 @@ + LayoutEngine *result = NULL; + LETag scriptTag = 0x00000000; + LETag languageTag = 0x00000000; ++ LETag v2ScriptTag = OpenTypeLayoutEngine::getV2ScriptTag(scriptCode); + +- if (gsubTable != NULL && gsubTable->coversScript(scriptTag = OpenTypeLayoutEngine::getScriptTag(scriptCode))) { ++ // Right now, only invoke V2 processing for Devanagari. TODO: Allow more V2 scripts as they are ++ // properly tested. ++ ++ if ( v2ScriptTag == dev2ScriptTag && gsubTable != NULL && gsubTable->coversScript( v2ScriptTag )) { ++ result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, TRUE, gsubTable, success); ++ } ++ else if (gsubTable != NULL && gsubTable->coversScript(scriptTag = OpenTypeLayoutEngine::getScriptTag(scriptCode))) { + switch (scriptCode) { + case bengScriptCode: + case devaScriptCode: +@@ -539,11 +598,15 @@ + case tamlScriptCode: + case teluScriptCode: + case sinhScriptCode: +- result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); ++ result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, FALSE, gsubTable, success); + break; + + case arabScriptCode: +- result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); ++ result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success); ++ break; ++ ++ case hangScriptCode: ++ result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success); + break; + + case haniScriptCode: +@@ -555,36 +618,35 @@ + case zhtLanguageCode: + case zhsLanguageCode: + if (gsubTable->coversScriptAndLanguage(scriptTag, languageTag, TRUE)) { +- result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); ++ result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success); + break; + } + + // note: falling through to default case. + default: +- result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); ++ result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success); + break; + } + + break; +-#if 0 ++ + case tibtScriptCode: +- result = new TibetanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); ++ result = new TibetanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success); + break; +-#endif + + case khmrScriptCode: +- result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); ++ result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success); + break; + + default: +- result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); ++ result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success); + break; + } + } else { + const MorphTableHeader *morphTable = (MorphTableHeader *) fontInstance->getFontTable(mortTableTag); + + if (morphTable != NULL && SWAPL(morphTable->version)==0x00010000) { +- result = new GXLayoutEngine(fontInstance, scriptCode, languageCode, morphTable); ++ result = new GXLayoutEngine(fontInstance, scriptCode, languageCode, morphTable, success); + } else { + switch (scriptCode) { + case bengScriptCode: +@@ -598,29 +660,38 @@ + case teluScriptCode: + case sinhScriptCode: + { +- result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); ++ result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success); + break; + } + + case arabScriptCode: + //case hebrScriptCode: +- result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); ++ result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success); + break; + + //case hebrScriptCode: + // return new HebrewOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + + case thaiScriptCode: +- result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); ++ result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success); ++ break; ++ ++ case hangScriptCode: ++ result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success); + break; + + default: +- result = new LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); ++ result = new LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success); + break; + } + } + } + ++ if (result && LE_FAILURE(success)) { ++ delete result; ++ result = NULL; ++ } ++ + if (result == NULL) { + success = LE_MEMORY_ALLOCATION_ERROR; + } +diff --git a/src/share/native/sun/font/layout/LayoutEngine.h b/src/share/native/sun/font/layout/LayoutEngine.h +--- jdk/src/share/native/sun/font/layout/LayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/LayoutEngine.h +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved + * + */ + +@@ -133,6 +133,14 @@ + le_int32 fTypoFlags; + + /** ++ * <code>TRUE</code> if <code>mapCharsToGlyphs</code> should replace ZWJ / ZWNJ with a glyph ++ * with no contours. ++ * ++ * @internal ++ */ ++ le_bool fFilterZeroWidth; ++ ++ /** + * This constructs an instance for a given font, script and language. Subclass constructors + * must call this constructor. + * +@@ -141,13 +149,18 @@ + * @param languageCode - the language for the text + * @param typoFlags - the typographic control flags for the text. Set bit 1 if kerning + * is desired, set bit 2 if ligature formation is desired. Others are reserved. ++ * @param success - set to an error code if the operation fails + * + * @see LEFontInstance + * @see ScriptAndLanguageTags.h + * + * @internal + */ +- LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags); ++ LayoutEngine(const LEFontInstance *fontInstance, ++ le_int32 scriptCode, ++ le_int32 languageCode, ++ le_int32 typoFlags, ++ LEErrorCode &success); + + /** + * This overrides the default no argument constructor to make it +@@ -338,7 +351,7 @@ + + /** + * This method will invoke the layout steps in their correct order by calling +- * the computeGlyphs, positionGlyphs and adjustGlyphPosition methods.. It will ++ * the computeGlyphs, positionGlyphs and adjustGlyphPosition methods. It will + * compute the glyph, character index and position arrays. + * + * @param chars - the input character context +@@ -352,8 +365,12 @@ + * + * @return the number of glyphs in the glyph array + * +- * Note; the glyph, character index and position array can be accessed +- * using the getter method below. ++ * Note: The glyph, character index and position array can be accessed ++ * using the getter methods below. ++ * ++ * Note: If you call this method more than once, you must call the reset() ++ * method first to free the glyph, character index and position arrays ++ * allocated by the previous call. + * + * @stable ICU 2.8 + */ +@@ -479,7 +496,7 @@ + + /** + * Override of existing call that provides flags to control typography. +- * @draft ICU 3.4 ++ * @stable ICU 3.4 + */ + static LayoutEngine *layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typo_flags, LEErrorCode &success); + +diff --git a/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp b/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp +--- jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp +@@ -26,7 +26,7 @@ + /* + * + * +- * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2006 - All Rights Reserved + * + */ + +@@ -58,10 +58,6 @@ + TTGlyphID ligGlyph = SWAPW(ligTable->ligGlyph); + le_uint16 comp; + +- if (filter != NULL && ! filter->accept(LE_SET_GLYPH(glyph, ligGlyph))) { +- continue; +- } +- + for (comp = 0; comp < compCount; comp += 1) { + if (! glyphIterator->next()) { + break; +@@ -72,7 +68,7 @@ + } + } + +- if (comp == compCount) { ++ if (comp == compCount && (filter == NULL || filter->accept(LE_SET_GLYPH(glyph, ligGlyph)))) { + GlyphIterator tempIterator(*glyphIterator); + TTGlyphID deletedGlyph = tempIterator.ignoresMarks()? 0xFFFE : 0xFFFF; + +diff --git a/src/share/native/sun/font/layout/LookupProcessor.cpp b/src/share/native/sun/font/layout/LookupProcessor.cpp +--- jdk/src/share/native/sun/font/layout/LookupProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/LookupProcessor.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -33,7 +33,7 @@ + #include "OpenTypeUtilities.h" + #include "LEFontInstance.h" + #include "OpenTypeTables.h" +-#include "Features.h" ++#include "ICUFeatures.h" + #include "Lookups.h" + #include "ScriptAndLanguage.h" + #include "GlyphDefinitionTables.h" +@@ -45,8 +45,12 @@ + U_NAMESPACE_BEGIN + + le_uint32 LookupProcessor::applyLookupTable(const LookupTable *lookupTable, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++ const LEFontInstance *fontInstance, LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + le_uint16 lookupType = SWAPW(lookupTable->lookupType); + le_uint16 subtableCount = SWAPW(lookupTable->subTableCount); + le_int32 startPosition = glyphIterator->getCurrStreamPosition(); +@@ -55,9 +59,9 @@ + for (le_uint16 subtable = 0; subtable < subtableCount; subtable += 1) { + const LookupSubtable *lookupSubtable = lookupTable->getLookupSubtable(subtable); + +- delta = applySubtable(lookupSubtable, lookupType, glyphIterator, fontInstance); ++ delta = applySubtable(lookupSubtable, lookupType, glyphIterator, fontInstance, success); + +- if (delta > 0) { ++ if (delta > 0 && LE_FAILURE(success)) { + return 1; + } + +@@ -69,8 +73,12 @@ + + le_int32 LookupProcessor::process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, + le_bool rightToLeft, const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, +- const LEFontInstance *fontInstance) const ++ const LEFontInstance *fontInstance, LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + le_int32 glyphCount = glyphStorage.getGlyphCount(); + + if (lookupSelectArray == NULL) { +@@ -96,10 +104,9 @@ + glyphIterator.reset(lookupFlags, selectMask); + + while (glyphIterator.findFeatureTag()) { +- le_uint32 delta = 1; +- +- while (glyphIterator.next(delta)) { +- delta = applyLookupTable(lookupTable, &glyphIterator, fontInstance); ++ applyLookupTable(lookupTable, &glyphIterator, fontInstance, success); ++ if (LE_FAILURE(success)) { ++ return 0; + } + } + +@@ -111,12 +118,16 @@ + } + + le_uint32 LookupProcessor::applySingleLookup(le_uint16 lookupTableIndex, GlyphIterator *glyphIterator, +- const LEFontInstance *fontInstance) const ++ const LEFontInstance *fontInstance, LEErrorCode& success) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + const LookupTable *lookupTable = lookupListTable->getLookupTable(lookupTableIndex); + le_uint16 lookupFlags = SWAPW(lookupTable->lookupFlags); + GlyphIterator tempIterator(*glyphIterator, lookupFlags); +- le_uint32 delta = applyLookupTable(lookupTable, &tempIterator, fontInstance); ++ le_uint32 delta = applyLookupTable(lookupTable, &tempIterator, fontInstance, success); + + return delta; + } +@@ -141,7 +152,8 @@ + + LookupProcessor::LookupProcessor(const char *baseAddress, + Offset scriptListOffset, Offset featureListOffset, Offset lookupListOffset, +- LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool orderFeatures) ++ LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool orderFeatures, ++ LEErrorCode& success) + : lookupListTable(NULL), featureListTable(NULL), lookupSelectArray(NULL), lookupSelectCount(0), + lookupOrderArray(NULL), lookupOrderCount(0) + { +@@ -151,6 +163,10 @@ + le_uint16 lookupListCount = 0; + le_uint16 requiredFeatureIndex; + ++ if (LE_FAILURE(success)) { ++ return; ++ } ++ + if (scriptListOffset != 0) { + scriptListTable = (const ScriptListTable *) (baseAddress + scriptListOffset); + langSysTable = scriptListTable->findLanguage(scriptTag, languageTag); +@@ -177,6 +193,10 @@ + requiredFeatureIndex = SWAPW(langSysTable->reqFeatureIndex); + + lookupSelectArray = LE_NEW_ARRAY(FeatureMask, lookupListCount); ++ if (lookupSelectArray == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return; ++ } + + for (int i = 0; i < lookupListCount; i += 1) { + lookupSelectArray[i] = 0; +@@ -213,6 +233,10 @@ + } + + lookupOrderArray = LE_NEW_ARRAY(le_uint16, featureReferences); ++ if (lookupOrderArray == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return; ++ } + + for (le_int32 f = 0; f < featureMapCount; f += 1) { + FeatureMap fm = featureMap[f]; +@@ -302,6 +326,8 @@ + + LookupProcessor::LookupProcessor() + { ++ lookupOrderArray = NULL; ++ lookupSelectArray = NULL; + } + + LookupProcessor::~LookupProcessor() +diff --git a/src/share/native/sun/font/layout/LookupProcessor.h b/src/share/native/sun/font/layout/LookupProcessor.h +--- jdk/src/share/native/sun/font/layout/LookupProcessor.h ++++ jdk/src/share/native/sun/font/layout/LookupProcessor.h +@@ -26,7 +26,7 @@ + /* + * + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved + * + */ + +@@ -59,21 +59,28 @@ + class LookupProcessor : public UMemory { + public: + le_int32 process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, +- le_bool rightToLeft, const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, const LEFontInstance *fontInstance) const; ++ le_bool rightToLeft, const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, const LEFontInstance *fontInstance, LEErrorCode& success) const; + +- le_uint32 applyLookupTable(const LookupTable *lookupTable, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 applyLookupTable(const LookupTable *lookupTable, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + +- le_uint32 applySingleLookup(le_uint16 lookupTableIndex, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const; ++ le_uint32 applySingleLookup(le_uint16 lookupTableIndex, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const; + + virtual le_uint32 applySubtable(const LookupSubtable *lookupSubtable, le_uint16 subtableType, +- GlyphIterator *glyphIterator, const LEFontInstance *fontInstance) const = 0; ++ GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode& success) const = 0; + + virtual ~LookupProcessor(); + + protected: + LookupProcessor(const char *baseAddress, +- Offset scriptListOffset, Offset featureListOffset, Offset lookupListOffset, +- LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool orderFeatures); ++ Offset scriptListOffset, ++ Offset featureListOffset, ++ Offset lookupListOffset, ++ LETag scriptTag, ++ LETag languageTag, ++ const FeatureMap *featureMap, ++ le_int32 featureMapCount, ++ le_bool orderFeatures, ++ LEErrorCode& success); + + LookupProcessor(); + +diff --git a/src/share/native/sun/font/layout/MPreFixups.cpp b/src/share/native/sun/font/layout/MPreFixups.cpp +--- jdk/src/share/native/sun/font/layout/MPreFixups.cpp ++++ jdk/src/share/native/sun/font/layout/MPreFixups.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 2002-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 2002-2008 - All Rights Reserved + * + */ + +@@ -65,8 +65,12 @@ + } + } + +-void MPreFixups::apply(LEGlyphStorage &glyphStorage) ++void MPreFixups::apply(LEGlyphStorage &glyphStorage, LEErrorCode& success) + { ++ if (LE_FAILURE(success)) { ++ return; ++ } ++ + for (le_int32 fixup = 0; fixup < fFixupCount; fixup += 1) { + le_int32 baseIndex = fFixupData[fixup].fBaseIndex; + le_int32 mpreIndex = fFixupData[fixup].fMPreIndex; +@@ -90,6 +94,14 @@ + le_int32 mpreDest = baseIndex - mpreCount; + LEGlyphID *mpreSave = LE_NEW_ARRAY(LEGlyphID, mpreCount); + le_int32 *indexSave = LE_NEW_ARRAY(le_int32, mpreCount); ++ ++ if (mpreSave == NULL || indexSave == NULL) { ++ LE_DELETE_ARRAY(mpreSave); ++ LE_DELETE_ARRAY(indexSave); ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return; ++ } ++ + le_int32 i; + + for (i = 0; i < mpreCount; i += 1) { +diff --git a/src/share/native/sun/font/layout/MPreFixups.h b/src/share/native/sun/font/layout/MPreFixups.h +--- jdk/src/share/native/sun/font/layout/MPreFixups.h ++++ jdk/src/share/native/sun/font/layout/MPreFixups.h +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 2002-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 2002-2008 - All Rights Reserved + * + */ + +@@ -54,7 +54,7 @@ + + void add(le_int32 baseIndex, le_int32 mpreIndex); + +- void apply(LEGlyphStorage &glyphStorage); ++ void apply(LEGlyphStorage &glyphStorage, LEErrorCode& success); + + private: + FixupData *fFixupData; +diff --git a/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp b/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp +--- jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -108,11 +108,27 @@ + glyphIterator->setCurrGlyphBaseOffset(baseIterator.getCurrStreamPosition()); + + if (glyphIterator->isRightToLeft()) { ++ // FIXME: need similar patch to below; also in MarkToLigature and MarkToMark ++ // (is there a better way to approach this for all the cases?) + glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX, anchorDiffY, -markAdvance.fX, -markAdvance.fY); + } else { + LEPoint baseAdvance; + + fontInstance->getGlyphAdvance(baseGlyph, pixels); ++ ++ //JK: adjustment needs to account for non-zero advance of any marks between base glyph and current mark ++ GlyphIterator gi(baseIterator, (le_uint16)0); // copy of baseIterator that won't ignore marks ++ gi.next(); // point beyond the base glyph ++ while (gi.getCurrStreamPosition() < glyphIterator->getCurrStreamPosition()) { // for all intervening glyphs (marks)... ++ LEGlyphID otherMark = gi.getCurrGlyphID(); ++ LEPoint px; ++ fontInstance->getGlyphAdvance(otherMark, px); // get advance, in case it's non-zero ++ pixels.fX += px.fX; // and add that to the base glyph's advance ++ pixels.fY += px.fY; ++ gi.next(); ++ } ++ // end of JK patch ++ + fontInstance->pixelsToUnits(pixels, baseAdvance); + + glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - baseAdvance.fX, anchorDiffY - baseAdvance.fY, -markAdvance.fX, -markAdvance.fY); +diff --git a/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp b/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp +--- jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved + * + */ + +@@ -39,8 +39,12 @@ + + U_NAMESPACE_BEGIN + +-le_uint32 MultipleSubstitutionSubtable::process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter) const ++le_uint32 MultipleSubstitutionSubtable::process(GlyphIterator *glyphIterator, LEErrorCode& success, const LEGlyphFilter *filter) const + { ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + LEGlyphID glyph = glyphIterator->getCurrGlyphID(); + + // If there's a filter, we only want to do the +@@ -87,7 +91,11 @@ + } + } + +- LEGlyphID *newGlyphs = glyphIterator->insertGlyphs(glyphCount); ++ LEGlyphID *newGlyphs = glyphIterator->insertGlyphs(glyphCount, success); ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + le_int32 insert = 0, direction = 1; + + if (glyphIterator->isRightToLeft()) { +diff --git a/src/share/native/sun/font/layout/MultipleSubstSubtables.h b/src/share/native/sun/font/layout/MultipleSubstSubtables.h +--- jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.h ++++ jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.h +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved + * + */ + +@@ -56,7 +56,7 @@ + le_uint16 sequenceCount; + Offset sequenceTableOffsetArray[ANY_NUMBER]; + +- le_uint32 process(GlyphIterator *glyphIterator, const LEGlyphFilter *filter = NULL) const; ++ le_uint32 process(GlyphIterator *glyphIterator, LEErrorCode& success, const LEGlyphFilter *filter = NULL) const; + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp b/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -35,8 +35,10 @@ + #include "LELanguages.h" + + #include "LayoutEngine.h" ++#include "CanonShaping.h" + #include "OpenTypeLayoutEngine.h" + #include "ScriptAndLanguageTags.h" ++#include "CharSubstitutionFilter.h" + + #include "GlyphSubstitutionTables.h" + #include "GlyphDefinitionTables.h" +@@ -47,6 +49,8 @@ + + #include "GDEFMarkFilter.h" + ++#include "KernTable.h" ++ + U_NAMESPACE_BEGIN + + UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OpenTypeLayoutEngine) +@@ -57,6 +61,8 @@ + #define kernFeatureTag LE_KERN_FEATURE_TAG + #define markFeatureTag LE_MARK_FEATURE_TAG + #define mkmkFeatureTag LE_MKMK_FEATURE_TAG ++#define loclFeatureTag LE_LOCL_FEATURE_TAG ++#define caltFeatureTag LE_CALT_FEATURE_TAG + + // 'dlig' not used at the moment + #define dligFeatureTag 0x646C6967 +@@ -71,8 +77,10 @@ + #define paltFeatureMask 0x08000000UL + #define markFeatureMask 0x04000000UL + #define mkmkFeatureMask 0x02000000UL ++#define loclFeatureMask 0x01000000UL ++#define caltFeatureMask 0x00800000UL + +-#define minimalFeatures (ccmpFeatureMask | markFeatureMask | mkmkFeatureMask) ++#define minimalFeatures (ccmpFeatureMask | markFeatureMask | mkmkFeatureMask | loclFeatureMask | caltFeatureMask) + #define ligaFeatures (ligaFeatureMask | cligFeatureMask | minimalFeatures) + #define kernFeatures (kernFeatureMask | paltFeatureMask | minimalFeatures) + #define kernAndLigaFeatures (ligaFeatures | kernFeatures) +@@ -85,14 +93,16 @@ + {kernFeatureTag, kernFeatureMask}, + {paltFeatureTag, paltFeatureMask}, + {markFeatureTag, markFeatureMask}, +- {mkmkFeatureTag, mkmkFeatureMask} ++ {mkmkFeatureTag, mkmkFeatureMask}, ++ {loclFeatureTag, loclFeatureMask}, ++ {caltFeatureTag, caltFeatureMask} + }; + + static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap); + + OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable) +- : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), fFeatureMask(minimalFeatures), ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success) ++ : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success), fFeatureMask(minimalFeatures), + fFeatureMap(featureMap), fFeatureMapCount(featureMapCount), fFeatureOrder(FALSE), + fGSUBTable(gsubTable), fGDEFTable(NULL), fGPOSTable(NULL), fSubstitutionFilter(NULL) + { +@@ -102,6 +112,15 @@ + + applyTypoFlags(); + ++ setScriptAndLanguageTags(); ++ ++ fGDEFTable = (const GlyphDefinitionTableHeader *) getFontTable(gdefTableTag); ++ ++// JK patch, 2008-05-30 - see Sinhala bug report and LKLUG font ++// if (gposTable != NULL && gposTable->coversScriptAndLanguage(fScriptTag, fLangSysTag)) { ++ if (gposTable != NULL && gposTable->coversScript(fScriptTag)) { ++ fGPOSTable = gposTable; ++ } + } + + void OpenTypeLayoutEngine::applyTypoFlags() { +@@ -109,7 +128,7 @@ + const LEFontInstance *fontInstance = fFontInstance; + + // todo: switch to more flags and bitfield rather than list of feature tags? +- switch (typoFlags) { ++ switch (typoFlags & ~0x80000000L) { + case 0: break; // default + case 1: fFeatureMask = kernFeatures; break; + case 2: fFeatureMask = ligaFeatures; break; +@@ -117,6 +136,10 @@ + default: break; + } + ++ if (typoFlags & LE_CHAR_FILTER_FEATURE_FLAG) { ++ fSubstitutionFilter = new CharSubstitutionFilter(fontInstance); ++ } ++ + } + + void OpenTypeLayoutEngine::reset() +@@ -129,8 +152,8 @@ + } + + OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags) +- : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), fFeatureOrder(FALSE), ++ le_int32 typoFlags, LEErrorCode &success) ++ : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success), fFeatureOrder(FALSE), + fGSUBTable(NULL), fGDEFTable(NULL), fGPOSTable(NULL), fSubstitutionFilter(NULL) + { + applyTypoFlags(); +@@ -151,8 +174,23 @@ + if (scriptCode < 0 || scriptCode >= scriptCodeCount) { + return 0xFFFFFFFF; + } ++ return scriptTags[scriptCode]; ++} + +- return scriptTags[scriptCode]; ++LETag OpenTypeLayoutEngine::getV2ScriptTag(le_int32 scriptCode) ++{ ++ switch (scriptCode) { ++ case bengScriptCode : return bng2ScriptTag; ++ case devaScriptCode : return dev2ScriptTag; ++ case gujrScriptCode : return gjr2ScriptTag; ++ case guruScriptCode : return gur2ScriptTag; ++ case kndaScriptCode : return knd2ScriptTag; ++ case mlymScriptCode : return mlm2ScriptTag; ++ case oryaScriptCode : return ory2ScriptTag; ++ case tamlScriptCode : return tml2ScriptTag; ++ case teluScriptCode : return tel2ScriptTag; ++ default: return nullScriptTag; ++ } + } + + LETag OpenTypeLayoutEngine::getLangSysTag(le_int32 languageCode) +@@ -167,6 +205,7 @@ + void OpenTypeLayoutEngine::setScriptAndLanguageTags() + { + fScriptTag = getScriptTag(fScriptCode); ++ fScriptTagV2 = getV2ScriptTag(fScriptCode); + fLangSysTag = getLangSysTag(fLanguageCode); + } + +@@ -182,20 +221,39 @@ + return 0; + } + +- le_int32 outCharCount = LayoutEngine::characterProcessing(chars, offset, count, max, rightToLeft, outChars, glyphStorage, success); ++ // This is the cheapest way to get mark reordering only for Hebrew. ++ // We could just do the mark reordering for all scripts, but most ++ // of them probably don't need it... Another option would be to ++ // add a HebrewOpenTypeLayoutEngine subclass, but the only thing it ++ // would need to do is mark reordering, so that seems like overkill. ++ if (fScriptCode == hebrScriptCode) { ++ outChars = LE_NEW_ARRAY(LEUnicode, count); ++ ++ if (outChars == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return 0; ++ } ++ ++ if (LE_FAILURE(success)) { ++ LE_DELETE_ARRAY(outChars); ++ return 0; ++ } ++ ++ CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, outChars, glyphStorage); ++ } + + if (LE_FAILURE(success)) { + return 0; + } + +- glyphStorage.allocateGlyphArray(outCharCount, rightToLeft, success); ++ glyphStorage.allocateGlyphArray(count, rightToLeft, success); + glyphStorage.allocateAuxData(success); + +- for (le_int32 i = 0; i < outCharCount; i += 1) { ++ for (le_int32 i = 0; i < count; i += 1) { + glyphStorage.setAuxData(i, fFeatureMask, success); + } + +- return outCharCount; ++ return count; + } + + // Input: characters, tags +@@ -219,13 +277,45 @@ + } + + if (fGSUBTable != NULL) { ++ if (fScriptTagV2 != nullScriptTag && fGSUBTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) { ++ count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTagV2, fLangSysTag, fGDEFTable, fSubstitutionFilter, ++ fFeatureMap, fFeatureMapCount, fFeatureOrder, success); ++ ++ } else { + count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTag, fLangSysTag, fGDEFTable, fSubstitutionFilter, +- fFeatureMap, fFeatureMapCount, fFeatureOrder); ++ fFeatureMap, fFeatureMapCount, fFeatureOrder, success); ++ } + } + + return count; + } ++// Input: characters, tags ++// Output: glyphs, char indices ++le_int32 OpenTypeLayoutEngine::glyphSubstitution(le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) ++{ ++ if (LE_FAILURE(success)) { ++ return 0; ++ } + ++ if ( count < 0 || max < 0 ) { ++ success = LE_ILLEGAL_ARGUMENT_ERROR; ++ return 0; ++ } ++ ++ if (fGSUBTable != NULL) { ++ if (fScriptTagV2 != nullScriptTag && fGSUBTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) { ++ count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTagV2, fLangSysTag, fGDEFTable, fSubstitutionFilter, ++ fFeatureMap, fFeatureMapCount, fFeatureOrder, success); ++ ++ } else { ++ count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTag, fLangSysTag, fGDEFTable, fSubstitutionFilter, ++ fFeatureMap, fFeatureMapCount, fFeatureOrder, success); ++ } ++ } ++ ++ return count; ++} + le_int32 OpenTypeLayoutEngine::glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, LEGlyphStorage &glyphStorage, LEErrorCode &success) + { + if (LE_FAILURE(success)) { +@@ -257,6 +347,10 @@ + + outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, outChars, fakeGlyphStorage, success); + ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + if (outChars != NULL) { + fakeGlyphCount = glyphProcessing(outChars, 0, outCharCount, outCharCount, rightToLeft, fakeGlyphStorage, success); + LE_DELETE_ARRAY(outChars); // FIXME: a subclass may have allocated this, in which case this delete might not work... +@@ -266,6 +360,10 @@ + //adjustGlyphs(chars, offset, count, rightToLeft, fakeGlyphs, fakeGlyphCount); + } + ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ + outGlyphCount = glyphPostProcessing(fakeGlyphStorage, glyphStorage, success); + + return outGlyphCount; +@@ -285,8 +383,11 @@ + } + + le_int32 glyphCount = glyphStorage.getGlyphCount(); ++ if (glyphCount == 0) { ++ return; ++ } + +- if (glyphCount > 0 && fGPOSTable != NULL) { ++ if (fGPOSTable != NULL) { + GlyphPositionAdjustments *adjustments = new GlyphPositionAdjustments(glyphCount); + le_int32 i; + +@@ -309,9 +410,21 @@ + } + #endif + +- fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTag, fLangSysTag, fGDEFTable, fFontInstance, ++ if (fGPOSTable != NULL) { ++ if (fScriptTagV2 != nullScriptTag && fGPOSTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) { ++ fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTagV2, fLangSysTag, fGDEFTable, success, fFontInstance, + fFeatureMap, fFeatureMapCount, fFeatureOrder); + ++ } else { ++ fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTag, fLangSysTag, fGDEFTable, success, fFontInstance, ++ fFeatureMap, fFeatureMapCount, fFeatureOrder); ++ } ++ } else if ( fTypoFlags & 0x1 ) { ++ static const le_uint32 kernTableTag = LE_KERN_TABLE_TAG; ++ KernTable kt(fFontInstance, getFontTable(kernTableTag)); ++ kt.process(glyphStorage); ++ } ++ + float xAdjust = 0, yAdjust = 0; + + for (i = 0; i < glyphCount; i += 1) { +@@ -344,6 +457,21 @@ + glyphStorage.adjustPosition(glyphCount, xAdjust, -yAdjust, success); + + delete adjustments; ++ } else { ++ // if there was no GPOS table, maybe there's non-OpenType kerning we can use ++ LayoutEngine::adjustGlyphPositions(chars, offset, count, reverse, glyphStorage, success); ++ } ++ ++ LEGlyphID zwnj = fFontInstance->mapCharToGlyph(0x200C); ++ ++ if (zwnj != 0x0000) { ++ for (le_int32 g = 0; g < glyphCount; g += 1) { ++ LEGlyphID glyph = glyphStorage[g]; ++ ++ if (glyph == zwnj) { ++ glyphStorage[g] = LE_SET_GLYPH(glyph, 0xFFFF); ++ } ++ } + } + + #if 0 +diff --git a/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h b/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h +@@ -24,7 +24,7 @@ + */ + + /* +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -67,7 +67,7 @@ + * + * @internal + */ +-class OpenTypeLayoutEngine : public LayoutEngine ++class U_LAYOUT_API OpenTypeLayoutEngine : public LayoutEngine + { + public: + /** +@@ -80,6 +80,7 @@ + * @param scriptCode - the script + * @param langaugeCode - the language + * @param gsubTable - the GSUB table ++ * @param success - set to an error code if the operation fails + * + * @see LayoutEngine::layoutEngineFactory + * @see ScriptAndLangaugeTags.h for script and language codes +@@ -87,7 +88,7 @@ + * @internal + */ + OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable); ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success); + + /** + * This constructor is used when the font requires a "canned" GSUB table which can't be known +@@ -96,11 +97,12 @@ + * @param fontInstance - the font + * @param scriptCode - the script + * @param langaugeCode - the language ++ * @param success - set to an error code if the operation fails + * + * @internal + */ + OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, +- le_int32 typoFlags); ++ le_int32 typoFlags, LEErrorCode &success); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -112,6 +114,8 @@ + /** + * A convenience method used to convert the script code into + * the four byte script tag required by OpenType. ++ * For Indic languages where multiple script tags exist, ++ * the version 1 (old style) tag is returned. + * + * @param scriptCode - the script code + * +@@ -120,6 +124,19 @@ + * @internal + */ + static LETag getScriptTag(le_int32 scriptCode); ++ /** ++ * A convenience method used to convert the script code into ++ * the four byte script tag required by OpenType. ++ * For Indic languages where multiple script tags exist, ++ * the version 2 tag is returned. ++ * ++ * @param scriptCode - the script code ++ * ++ * @return the four byte script tag ++ * ++ * @internal ++ */ ++ static LETag getV2ScriptTag(le_int32 scriptCode); + + /** + * A convenience method used to convert the langauge code into +@@ -147,6 +164,13 @@ + */ + static UClassID getStaticClassID(); + ++ /** ++ * The array of language tags, indexed by language code. ++ * ++ * @internal ++ */ ++ static const LETag languageTags[]; ++ + private: + + /** +@@ -161,11 +185,6 @@ + static const LETag scriptTags[]; + + /** +- * The array of language tags, indexed by language code. +- */ +- static const LETag languageTags[]; +- +- /** + * apply the typoflags. Only called by the c'tors. + */ + void applyTypoFlags(); +@@ -243,6 +262,13 @@ + LETag fScriptTag; + + /** ++ * The four byte script tag for V2 fonts. ++ * ++ * @internal ++ */ ++ LETag fScriptTagV2; ++ ++ /** + * The four byte language tag + * + * @internal +@@ -309,6 +335,8 @@ + virtual le_int32 glyphProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, + LEGlyphStorage &glyphStorage, LEErrorCode &success); + ++ virtual le_int32 glyphSubstitution(le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ + /** + * This method does any processing necessary to convert "fake" + * glyph indices used by the glyphProcessing method into "real" glyph +diff --git a/src/share/native/sun/font/layout/OpenTypeTables.h b/src/share/native/sun/font/layout/OpenTypeTables.h +--- jdk/src/share/native/sun/font/layout/OpenTypeTables.h ++++ jdk/src/share/native/sun/font/layout/OpenTypeTables.h +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -46,6 +46,8 @@ + typedef le_uint16 Offset; + typedef le_uint8 ATag[4]; + typedef le_uint32 fixed32; ++ ++#define LE_GLYPH_GROUP_MASK 0x00000001UL + typedef le_uint32 FeatureMask; + + #define SWAPT(atag) ((LETag) ((atag[0] << 24) + (atag[1] << 16) + (atag[2] << 8) + atag[3])) +diff --git a/src/share/native/sun/font/layout/OpenTypeUtilities.cpp b/src/share/native/sun/font/layout/OpenTypeUtilities.cpp +--- jdk/src/share/native/sun/font/layout/OpenTypeUtilities.cpp ++++ jdk/src/share/native/sun/font/layout/OpenTypeUtilities.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -111,6 +111,10 @@ + le_int32 probe = power; + le_int32 range = 0; + ++ if (recordCount == 0) { ++ return -1; ++ } ++ + if (SWAPW(records[extra].firstGlyph) <= glyphID) { + range = extra; + } +diff --git a/src/share/native/sun/font/layout/PairPositioningSubtables.cpp b/src/share/native/sun/font/layout/PairPositioningSubtables.cpp +--- jdk/src/share/native/sun/font/layout/PairPositioningSubtables.cpp ++++ jdk/src/share/native/sun/font/layout/PairPositioningSubtables.cpp +@@ -101,7 +101,10 @@ + valueRecord2->adjustPosition(SWAPW(valueFormat2), (char *) this, *glyphIterator, fontInstance); + } + +- return 2; ++ // back up glyphIterator so second glyph can be ++ // first glyph in the next pair ++ glyphIterator->prev(); ++ return 1; + } + + return 0; +@@ -137,7 +140,10 @@ + valueRecord2->adjustPosition(SWAPW(valueFormat2), (const char *) this, *glyphIterator, fontInstance); + } + +- return 2; ++ // back up glyphIterator so second glyph can be ++ // first glyph in the next pair ++ glyphIterator->prev(); ++ return 1; + } + + return 0; +@@ -145,6 +151,20 @@ + + const PairValueRecord *PairPositioningFormat1Subtable::findPairValueRecord(TTGlyphID glyphID, const PairValueRecord *records, le_uint16 recordCount, le_uint16 recordSize) const + { ++#if 1 ++ // The OpenType spec. says that the ValueRecord table is ++ // sorted by secondGlyph. Unfortunately, there are fonts ++ // around that have an unsorted ValueRecord table. ++ const PairValueRecord *record = records; ++ ++ for(le_int32 r = 0; r < recordCount; r += 1) { ++ if (SWAPW(record->secondGlyph) == glyphID) { ++ return record; ++ } ++ ++ record = (const PairValueRecord *) ((char *) record + recordSize); ++ } ++#else + le_uint8 bit = OpenTypeUtilities::highBit(recordCount); + le_uint16 power = 1 << bit; + le_uint16 extra = (recordCount - power) * recordSize; +@@ -168,6 +188,7 @@ + if (SWAPW(record->secondGlyph) == glyphID) { + return record; + } ++#endif + + return NULL; + } +diff --git a/src/share/native/sun/font/layout/ScriptAndLanguage.cpp b/src/share/native/sun/font/layout/ScriptAndLanguage.cpp +--- jdk/src/share/native/sun/font/layout/ScriptAndLanguage.cpp ++++ jdk/src/share/native/sun/font/layout/ScriptAndLanguage.cpp +@@ -26,7 +26,7 @@ + /* + * + * +- * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -56,20 +56,45 @@ + return (const LangSysTable *) ((char *)this + langSysTableOffset); + } + +- return 0; ++ return NULL; + } + + const ScriptTable *ScriptListTable::findScript(LETag scriptTag) const + { ++ /* ++ * There are some fonts that have a large, bogus value for scriptCount. To try ++ * and protect against this, we use the offset in the first scriptRecord, ++ * which we know has to be past the end of the scriptRecordArray, to compute ++ * a value which is greater than or equal to the actual script count. ++ * ++ * Note: normally, the first offset will point to just after the scriptRecordArray, ++ * but there's no guarantee of this, only that it's *after* the scriptRecordArray. ++ * Because of this, a binary serach isn't safe, because the new count may include ++ * data that's not actually in the scriptRecordArray and hence the array will appear ++ * to be unsorted. ++ */ + le_uint16 count = SWAPW(scriptCount); +- Offset scriptTableOffset = +- OpenTypeUtilities::getTagOffset(scriptTag, scriptRecordArray, count); ++ le_uint16 limit = ((SWAPW(scriptRecordArray[0].offset) - sizeof(ScriptListTable)) / sizeof(scriptRecordArray)) + ANY_NUMBER; ++ Offset scriptTableOffset = 0; ++ ++ if (count > limit) { ++ // the scriptCount value is bogus; do a linear search ++ // because limit may still be too large. ++ for(le_int32 s = 0; s < limit; s += 1) { ++ if (SWAPT(scriptRecordArray[s].tag) == scriptTag) { ++ scriptTableOffset = SWAPW(scriptRecordArray[s].offset); ++ break; ++ } ++ } ++ } else { ++ scriptTableOffset = OpenTypeUtilities::getTagOffset(scriptTag, scriptRecordArray, count); ++ } + + if (scriptTableOffset != 0) { + return (const ScriptTable *) ((char *)this + scriptTableOffset); + } + +- return 0; ++ return NULL; + } + + const LangSysTable *ScriptListTable::findLanguage(LETag scriptTag, LETag languageTag, le_bool exactMatch) const +@@ -77,7 +102,7 @@ + const ScriptTable *scriptTable = findScript(scriptTag); + + if (scriptTable == 0) { +- return 0; ++ return NULL; + } + + return scriptTable->findLanguage(languageTag, exactMatch); +diff --git a/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp b/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp +--- jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp ++++ jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp +@@ -25,10 +25,12 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004. All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2010. All Rights Reserved. + * + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS + * YOU REALLY KNOW WHAT YOU'RE DOING. ++ * ++ * Generated on: 10/26/2010 02:53:33 PM PDT + */ + + #include "LETypes.h" +@@ -39,13 +41,13 @@ + + const LETag OpenTypeLayoutEngine::scriptTags[] = { + zyyyScriptTag, /* 'zyyy' (COMMON) */ +- qaaiScriptTag, /* 'qaai' (INHERITED) */ ++ zinhScriptTag, /* 'zinh' (INHERITED) */ + arabScriptTag, /* 'arab' (ARABIC) */ + armnScriptTag, /* 'armn' (ARMENIAN) */ + bengScriptTag, /* 'beng' (BENGALI) */ + bopoScriptTag, /* 'bopo' (BOPOMOFO) */ + cherScriptTag, /* 'cher' (CHEROKEE) */ +- qaacScriptTag, /* 'qaac' (COPTIC) */ ++ coptScriptTag, /* 'copt' (COPTIC) */ + cyrlScriptTag, /* 'cyrl' (CYRILLIC) */ + dsrtScriptTag, /* 'dsrt' (DESERET) */ + devaScriptTag, /* 'deva' (DEVANAGARI) */ +@@ -62,7 +64,7 @@ + kndaScriptTag, /* 'knda' (KANNADA) */ + kanaScriptTag, /* 'kana' (KATAKANA) */ + khmrScriptTag, /* 'khmr' (KHMER) */ +- laooScriptTag, /* 'laoo' (LAO) */ ++ laooScriptTag, /* 'lao ' (LAO) */ + latnScriptTag, /* 'latn' (LATIN) */ + mlymScriptTag, /* 'mlym' (MALAYALAM) */ + mongScriptTag, /* 'mong' (MONGOLIAN) */ +@@ -79,7 +81,7 @@ + thaiScriptTag, /* 'thai' (THAI) */ + tibtScriptTag, /* 'tibt' (TIBETAN) */ + cansScriptTag, /* 'cans' (CANADIAN_ABORIGINAL) */ +- yiiiScriptTag, /* 'yiii' (YI) */ ++ yiiiScriptTag, /* 'yi ' (YI) */ + tglgScriptTag, /* 'tglg' (TAGALOG) */ + hanoScriptTag, /* 'hano' (HANUNOO) */ + buhdScriptTag, /* 'buhd' (BUHID) */ +@@ -92,7 +94,99 @@ + shawScriptTag, /* 'shaw' (SHAVIAN) */ + taleScriptTag, /* 'tale' (TAI_LE) */ + ugarScriptTag, /* 'ugar' (UGARITIC) */ +- hrktScriptTag /* 'hrkt' (KATAKANA_OR_HIRAGANA) */ ++ hrktScriptTag, /* 'hrkt' (KATAKANA_OR_HIRAGANA) */ ++ bugiScriptTag, /* 'bugi' (BUGINESE) */ ++ glagScriptTag, /* 'glag' (GLAGOLITIC) */ ++ kharScriptTag, /* 'khar' (KHAROSHTHI) */ ++ syloScriptTag, /* 'sylo' (SYLOTI_NAGRI) */ ++ taluScriptTag, /* 'talu' (NEW_TAI_LUE) */ ++ tfngScriptTag, /* 'tfng' (TIFINAGH) */ ++ xpeoScriptTag, /* 'xpeo' (OLD_PERSIAN) */ ++ baliScriptTag, /* 'bali' (BALINESE) */ ++ batkScriptTag, /* 'batk' (BATAK) */ ++ blisScriptTag, /* 'blis' (BLIS) */ ++ brahScriptTag, /* 'brah' (BRAHMI) */ ++ chamScriptTag, /* 'cham' (CHAM) */ ++ cirtScriptTag, /* 'cirt' (CIRT) */ ++ cyrsScriptTag, /* 'cyrs' (CYRS) */ ++ egydScriptTag, /* 'egyd' (EGYD) */ ++ egyhScriptTag, /* 'egyh' (EGYH) */ ++ egypScriptTag, /* 'egyp' (EGYPTIAN_HIEROGLYPHS) */ ++ geokScriptTag, /* 'geok' (GEOK) */ ++ hansScriptTag, /* 'hans' (HANS) */ ++ hantScriptTag, /* 'hant' (HANT) */ ++ hmngScriptTag, /* 'hmng' (HMNG) */ ++ hungScriptTag, /* 'hung' (HUNG) */ ++ indsScriptTag, /* 'inds' (INDS) */ ++ javaScriptTag, /* 'java' (JAVANESE) */ ++ kaliScriptTag, /* 'kali' (KAYAH_LI) */ ++ latfScriptTag, /* 'latf' (LATF) */ ++ latgScriptTag, /* 'latg' (LATG) */ ++ lepcScriptTag, /* 'lepc' (LEPCHA) */ ++ linaScriptTag, /* 'lina' (LINA) */ ++ mandScriptTag, /* 'mand' (MANDAIC) */ ++ mayaScriptTag, /* 'maya' (MAYA) */ ++ meroScriptTag, /* 'mero' (MERO) */ ++ nkooScriptTag, /* 'nko ' (NKO) */ ++ orkhScriptTag, /* 'orkh' (OLD_TURKIC) */ ++ permScriptTag, /* 'perm' (PERM) */ ++ phagScriptTag, /* 'phag' (PHAGS_PA) */ ++ phnxScriptTag, /* 'phnx' (PHOENICIAN) */ ++ plrdScriptTag, /* 'plrd' (PLRD) */ ++ roroScriptTag, /* 'roro' (RORO) */ ++ saraScriptTag, /* 'sara' (SARA) */ ++ syreScriptTag, /* 'syre' (SYRE) */ ++ syrjScriptTag, /* 'syrj' (SYRJ) */ ++ syrnScriptTag, /* 'syrn' (SYRN) */ ++ tengScriptTag, /* 'teng' (TENG) */ ++ vaiiScriptTag, /* 'vai ' (VAI) */ ++ vispScriptTag, /* 'visp' (VISP) */ ++ xsuxScriptTag, /* 'xsux' (CUNEIFORM) */ ++ zxxxScriptTag, /* 'zxxx' (ZXXX) */ ++ zzzzScriptTag, /* 'zzzz' (UNKNOWN) */ ++ cariScriptTag, /* 'cari' (CARIAN) */ ++ jpanScriptTag, /* 'jpan' (JPAN) */ ++ lanaScriptTag, /* 'lana' (TAI_THAM) */ ++ lyciScriptTag, /* 'lyci' (LYCIAN) */ ++ lydiScriptTag, /* 'lydi' (LYDIAN) */ ++ olckScriptTag, /* 'olck' (OL_CHIKI) */ ++ rjngScriptTag, /* 'rjng' (REJANG) */ ++ saurScriptTag, /* 'saur' (SAURASHTRA) */ ++ sgnwScriptTag, /* 'sgnw' (SGNW) */ ++ sundScriptTag, /* 'sund' (SUNDANESE) */ ++ moonScriptTag, /* 'moon' (MOON) */ ++ mteiScriptTag, /* 'mtei' (MEETEI_MAYEK) */ ++ armiScriptTag, /* 'armi' (IMPERIAL_ARAMAIC) */ ++ avstScriptTag, /* 'avst' (AVESTAN) */ ++ cakmScriptTag, /* 'cakm' (CAKM) */ ++ koreScriptTag, /* 'kore' (KORE) */ ++ kthiScriptTag, /* 'kthi' (KAITHI) */ ++ maniScriptTag, /* 'mani' (MANI) */ ++ phliScriptTag, /* 'phli' (INSCRIPTIONAL_PAHLAVI) */ ++ phlpScriptTag, /* 'phlp' (PHLP) */ ++ phlvScriptTag, /* 'phlv' (PHLV) */ ++ prtiScriptTag, /* 'prti' (INSCRIPTIONAL_PARTHIAN) */ ++ samrScriptTag, /* 'samr' (SAMARITAN) */ ++ tavtScriptTag, /* 'tavt' (TAI_VIET) */ ++ zmthScriptTag, /* 'zmth' (ZMTH) */ ++ zsymScriptTag, /* 'zsym' (ZSYM) */ ++ bamuScriptTag, /* 'bamu' (BAMUM) */ ++ lisuScriptTag, /* 'lisu' (LISU) */ ++ nkgbScriptTag, /* 'nkgb' (NKGB) */ ++ sarbScriptTag, /* 'sarb' (OLD_SOUTH_ARABIAN) */ ++ bassScriptTag, /* 'bass' (BASS) */ ++ duplScriptTag, /* 'dupl' (DUPL) */ ++ elbaScriptTag, /* 'elba' (ELBA) */ ++ granScriptTag, /* 'gran' (GRAN) */ ++ kpelScriptTag, /* 'kpel' (KPEL) */ ++ lomaScriptTag, /* 'loma' (LOMA) */ ++ mendScriptTag, /* 'mend' (MEND) */ ++ mercScriptTag, /* 'merc' (MERC) */ ++ narbScriptTag, /* 'narb' (NARB) */ ++ nbatScriptTag, /* 'nbat' (NBAT) */ ++ palmScriptTag, /* 'palm' (PALM) */ ++ sindScriptTag, /* 'sind' (SIND) */ ++ waraScriptTag /* 'wara' (WARA) */ + }; + + const LETag OpenTypeLayoutEngine::languageTags[] = { +@@ -125,7 +219,49 @@ + urdLanguageTag, /* 'URD' (Urdu) */ + zhpLanguageTag, /* 'ZHP' (Chinese (Phonetic)) */ + zhsLanguageTag, /* 'ZHS' (Chinese (Simplified)) */ +- zhtLanguageTag /* 'ZHT' (Chinese (Traditional)) */ ++ zhtLanguageTag, /* 'ZHT' (Chinese (Traditional)) */ ++ afkLanguageTag, /* 'AFK' (Afrikaans) */ ++ belLanguageTag, /* 'BEL' (Belarussian) */ ++ bgrLanguageTag, /* 'BGR' (Bulgarian) */ ++ catLanguageTag, /* 'CAT' (Catalan) */ ++ cheLanguageTag, /* 'CHE' (Chechen) */ ++ copLanguageTag, /* 'COP' (Coptic) */ ++ csyLanguageTag, /* 'CSY' (Czech) */ ++ danLanguageTag, /* 'DAN' (Danish) */ ++ deuLanguageTag, /* 'DEU' (German) */ ++ dznLanguageTag, /* 'DZN' (Dzongkha) */ ++ ellLanguageTag, /* 'ELL' (Greek) */ ++ engLanguageTag, /* 'ENG' (English) */ ++ espLanguageTag, /* 'ESP' (Spanish) */ ++ etiLanguageTag, /* 'ETI' (Estonian) */ ++ euqLanguageTag, /* 'EUQ' (Basque) */ ++ finLanguageTag, /* 'FIN' (Finnish) */ ++ fraLanguageTag, /* 'FRA' (French) */ ++ gaeLanguageTag, /* 'GAE' (Gaelic) */ ++ hauLanguageTag, /* 'HAU' (Hausa) */ ++ hrvLanguageTag, /* 'HRV' (Croation) */ ++ hunLanguageTag, /* 'HUN' (Hungarian) */ ++ hyeLanguageTag, /* 'HYE' (Armenian) */ ++ indLanguageTag, /* 'IND' (Indonesian) */ ++ itaLanguageTag, /* 'ITA' (Italian) */ ++ khmLanguageTag, /* 'KHM' (Khmer) */ ++ mngLanguageTag, /* 'MNG' (Mongolian) */ ++ mtsLanguageTag, /* 'MTS' (Maltese) */ ++ nepLanguageTag, /* 'NEP' (Nepali) */ ++ nldLanguageTag, /* 'NLD' (Dutch) */ ++ pasLanguageTag, /* 'PAS' (Pashto) */ ++ plkLanguageTag, /* 'PLK' (Polish) */ ++ ptgLanguageTag, /* 'PTG' (Portuguese) */ ++ romLanguageTag, /* 'ROM' (Romanian) */ ++ rusLanguageTag, /* 'RUS' (Russian) */ ++ skyLanguageTag, /* 'SKY' (Slovak) */ ++ slvLanguageTag, /* 'SLV' (Slovenian) */ ++ sqiLanguageTag, /* 'SQI' (Albanian) */ ++ srbLanguageTag, /* 'SRB' (Serbian) */ ++ sveLanguageTag, /* 'SVE' (Swedish) */ ++ tibLanguageTag, /* 'TIB' (Tibetan) */ ++ trkLanguageTag, /* 'TRK' (Turkish) */ ++ welLanguageTag /* 'WEL' (Welsh) */ + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ScriptAndLanguageTags.h b/src/share/native/sun/font/layout/ScriptAndLanguageTags.h +--- jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.h ++++ jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.h +@@ -25,10 +25,12 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004. All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2010. All Rights Reserved. + * + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS + * YOU REALLY KNOW WHAT YOU'RE DOING. ++ * ++ * Generated on: 10/26/2010 02:53:33 PM PDT + */ + + #ifndef __SCRIPTANDLANGUAGES_H +@@ -36,55 +38,64 @@ + + #include "LETypes.h" + +-U_NAMESPACE_BEGIN +- + /** + * \file + * \internal + */ + ++U_NAMESPACE_BEGIN ++ + const LETag zyyyScriptTag = 0x7A797979; /* 'zyyy' (COMMON) */ +-const LETag qaaiScriptTag = 0x71616169; /* 'qaai' (INHERITED) */ ++const LETag zinhScriptTag = 0x7A696E68; /* 'zinh' (INHERITED) */ + const LETag arabScriptTag = 0x61726162; /* 'arab' (ARABIC) */ + const LETag armnScriptTag = 0x61726D6E; /* 'armn' (ARMENIAN) */ + const LETag bengScriptTag = 0x62656E67; /* 'beng' (BENGALI) */ ++const LETag bng2ScriptTag = 0x626E6732; /* 'bng2' (BENGALI v.2) (manually added) */ + const LETag bopoScriptTag = 0x626F706F; /* 'bopo' (BOPOMOFO) */ + const LETag cherScriptTag = 0x63686572; /* 'cher' (CHEROKEE) */ +-const LETag qaacScriptTag = 0x71616163; /* 'qaac' (COPTIC) */ ++const LETag coptScriptTag = 0x636F7074; /* 'copt' (COPTIC) */ + const LETag cyrlScriptTag = 0x6379726C; /* 'cyrl' (CYRILLIC) */ + const LETag dsrtScriptTag = 0x64737274; /* 'dsrt' (DESERET) */ + const LETag devaScriptTag = 0x64657661; /* 'deva' (DEVANAGARI) */ ++const LETag dev2ScriptTag = 0x64657632; /* 'dev2' (DEVANAGARI v.2) (manually added) */ + const LETag ethiScriptTag = 0x65746869; /* 'ethi' (ETHIOPIC) */ + const LETag georScriptTag = 0x67656F72; /* 'geor' (GEORGIAN) */ + const LETag gothScriptTag = 0x676F7468; /* 'goth' (GOTHIC) */ + const LETag grekScriptTag = 0x6772656B; /* 'grek' (GREEK) */ + const LETag gujrScriptTag = 0x67756A72; /* 'gujr' (GUJARATI) */ ++const LETag gjr2ScriptTag = 0x676A7232; /* 'gjr2' (GUJARATI v.2) (manually added) */ + const LETag guruScriptTag = 0x67757275; /* 'guru' (GURMUKHI) */ ++const LETag gur2ScriptTag = 0x67757232; /* 'gur2' (GURMUKHI v.2) (manually added) */ + const LETag haniScriptTag = 0x68616E69; /* 'hani' (HAN) */ + const LETag hangScriptTag = 0x68616E67; /* 'hang' (HANGUL) */ + const LETag hebrScriptTag = 0x68656272; /* 'hebr' (HEBREW) */ + const LETag hiraScriptTag = 0x68697261; /* 'hira' (HIRAGANA) */ + const LETag kndaScriptTag = 0x6B6E6461; /* 'knda' (KANNADA) */ ++const LETag knd2ScriptTag = 0x6B6E6432; /* 'knd2' (KANNADA v.2) (manually added) */ + const LETag kanaScriptTag = 0x6B616E61; /* 'kana' (KATAKANA) */ + const LETag khmrScriptTag = 0x6B686D72; /* 'khmr' (KHMER) */ +-const LETag laooScriptTag = 0x6C616F6F; /* 'laoo' (LAO) */ ++const LETag laooScriptTag = 0x6C616F20; /* 'lao ' (LAO) */ + const LETag latnScriptTag = 0x6C61746E; /* 'latn' (LATIN) */ + const LETag mlymScriptTag = 0x6D6C796D; /* 'mlym' (MALAYALAM) */ ++const LETag mlm2ScriptTag = 0x6D6C6D32; /* 'mlm2' (MALAYALAM v.2) (manually added) */ + const LETag mongScriptTag = 0x6D6F6E67; /* 'mong' (MONGOLIAN) */ + const LETag mymrScriptTag = 0x6D796D72; /* 'mymr' (MYANMAR) */ + const LETag ogamScriptTag = 0x6F67616D; /* 'ogam' (OGHAM) */ + const LETag italScriptTag = 0x6974616C; /* 'ital' (OLD_ITALIC) */ + const LETag oryaScriptTag = 0x6F727961; /* 'orya' (ORIYA) */ ++const LETag ory2ScriptTag = 0x6F727932; /* 'ory2' (ORIYA v.2) (manually added) */ + const LETag runrScriptTag = 0x72756E72; /* 'runr' (RUNIC) */ + const LETag sinhScriptTag = 0x73696E68; /* 'sinh' (SINHALA) */ + const LETag syrcScriptTag = 0x73797263; /* 'syrc' (SYRIAC) */ + const LETag tamlScriptTag = 0x74616D6C; /* 'taml' (TAMIL) */ ++const LETag tml2ScriptTag = 0x746D6C32; /* 'tml2' (TAMIL v.2) (manually added) */ + const LETag teluScriptTag = 0x74656C75; /* 'telu' (TELUGU) */ ++const LETag tel2ScriptTag = 0x74656C32; /* 'tel2' (TELUGU v.2) (manually added) */ + const LETag thaaScriptTag = 0x74686161; /* 'thaa' (THAANA) */ + const LETag thaiScriptTag = 0x74686169; /* 'thai' (THAI) */ + const LETag tibtScriptTag = 0x74696274; /* 'tibt' (TIBETAN) */ + const LETag cansScriptTag = 0x63616E73; /* 'cans' (CANADIAN_ABORIGINAL) */ +-const LETag yiiiScriptTag = 0x79696969; /* 'yiii' (YI) */ ++const LETag yiiiScriptTag = 0x79692020; /* 'yi ' (YI) */ + const LETag tglgScriptTag = 0x74676C67; /* 'tglg' (TAGALOG) */ + const LETag hanoScriptTag = 0x68616E6F; /* 'hano' (HANUNOO) */ + const LETag buhdScriptTag = 0x62756864; /* 'buhd' (BUHID) */ +@@ -98,6 +109,98 @@ + const LETag taleScriptTag = 0x74616C65; /* 'tale' (TAI_LE) */ + const LETag ugarScriptTag = 0x75676172; /* 'ugar' (UGARITIC) */ + const LETag hrktScriptTag = 0x68726B74; /* 'hrkt' (KATAKANA_OR_HIRAGANA) */ ++const LETag bugiScriptTag = 0x62756769; /* 'bugi' (BUGINESE) */ ++const LETag glagScriptTag = 0x676C6167; /* 'glag' (GLAGOLITIC) */ ++const LETag kharScriptTag = 0x6B686172; /* 'khar' (KHAROSHTHI) */ ++const LETag syloScriptTag = 0x73796C6F; /* 'sylo' (SYLOTI_NAGRI) */ ++const LETag taluScriptTag = 0x74616C75; /* 'talu' (NEW_TAI_LUE) */ ++const LETag tfngScriptTag = 0x74666E67; /* 'tfng' (TIFINAGH) */ ++const LETag xpeoScriptTag = 0x7870656F; /* 'xpeo' (OLD_PERSIAN) */ ++const LETag baliScriptTag = 0x62616C69; /* 'bali' (BALINESE) */ ++const LETag batkScriptTag = 0x6261746B; /* 'batk' (BATAK) */ ++const LETag blisScriptTag = 0x626C6973; /* 'blis' (BLIS) */ ++const LETag brahScriptTag = 0x62726168; /* 'brah' (BRAHMI) */ ++const LETag chamScriptTag = 0x6368616D; /* 'cham' (CHAM) */ ++const LETag cirtScriptTag = 0x63697274; /* 'cirt' (CIRT) */ ++const LETag cyrsScriptTag = 0x63797273; /* 'cyrs' (CYRS) */ ++const LETag egydScriptTag = 0x65677964; /* 'egyd' (EGYD) */ ++const LETag egyhScriptTag = 0x65677968; /* 'egyh' (EGYH) */ ++const LETag egypScriptTag = 0x65677970; /* 'egyp' (EGYPTIAN_HIEROGLYPHS) */ ++const LETag geokScriptTag = 0x67656F6B; /* 'geok' (GEOK) */ ++const LETag hansScriptTag = 0x68616E73; /* 'hans' (HANS) */ ++const LETag hantScriptTag = 0x68616E74; /* 'hant' (HANT) */ ++const LETag hmngScriptTag = 0x686D6E67; /* 'hmng' (HMNG) */ ++const LETag hungScriptTag = 0x68756E67; /* 'hung' (HUNG) */ ++const LETag indsScriptTag = 0x696E6473; /* 'inds' (INDS) */ ++const LETag javaScriptTag = 0x6A617661; /* 'java' (JAVANESE) */ ++const LETag kaliScriptTag = 0x6B616C69; /* 'kali' (KAYAH_LI) */ ++const LETag latfScriptTag = 0x6C617466; /* 'latf' (LATF) */ ++const LETag latgScriptTag = 0x6C617467; /* 'latg' (LATG) */ ++const LETag lepcScriptTag = 0x6C657063; /* 'lepc' (LEPCHA) */ ++const LETag linaScriptTag = 0x6C696E61; /* 'lina' (LINA) */ ++const LETag mandScriptTag = 0x6D616E64; /* 'mand' (MANDAIC) */ ++const LETag mayaScriptTag = 0x6D617961; /* 'maya' (MAYA) */ ++const LETag meroScriptTag = 0x6D65726F; /* 'mero' (MERO) */ ++const LETag nkooScriptTag = 0x6E6B6F20; /* 'nko ' (NKO) */ ++const LETag orkhScriptTag = 0x6F726B68; /* 'orkh' (OLD_TURKIC) */ ++const LETag permScriptTag = 0x7065726D; /* 'perm' (PERM) */ ++const LETag phagScriptTag = 0x70686167; /* 'phag' (PHAGS_PA) */ ++const LETag phnxScriptTag = 0x70686E78; /* 'phnx' (PHOENICIAN) */ ++const LETag plrdScriptTag = 0x706C7264; /* 'plrd' (PLRD) */ ++const LETag roroScriptTag = 0x726F726F; /* 'roro' (RORO) */ ++const LETag saraScriptTag = 0x73617261; /* 'sara' (SARA) */ ++const LETag syreScriptTag = 0x73797265; /* 'syre' (SYRE) */ ++const LETag syrjScriptTag = 0x7379726A; /* 'syrj' (SYRJ) */ ++const LETag syrnScriptTag = 0x7379726E; /* 'syrn' (SYRN) */ ++const LETag tengScriptTag = 0x74656E67; /* 'teng' (TENG) */ ++const LETag vaiiScriptTag = 0x76616920; /* 'vai ' (VAI) */ ++const LETag vispScriptTag = 0x76697370; /* 'visp' (VISP) */ ++const LETag xsuxScriptTag = 0x78737578; /* 'xsux' (CUNEIFORM) */ ++const LETag zxxxScriptTag = 0x7A787878; /* 'zxxx' (ZXXX) */ ++const LETag zzzzScriptTag = 0x7A7A7A7A; /* 'zzzz' (UNKNOWN) */ ++const LETag cariScriptTag = 0x63617269; /* 'cari' (CARIAN) */ ++const LETag jpanScriptTag = 0x6A70616E; /* 'jpan' (JPAN) */ ++const LETag lanaScriptTag = 0x6C616E61; /* 'lana' (TAI_THAM) */ ++const LETag lyciScriptTag = 0x6C796369; /* 'lyci' (LYCIAN) */ ++const LETag lydiScriptTag = 0x6C796469; /* 'lydi' (LYDIAN) */ ++const LETag olckScriptTag = 0x6F6C636B; /* 'olck' (OL_CHIKI) */ ++const LETag rjngScriptTag = 0x726A6E67; /* 'rjng' (REJANG) */ ++const LETag saurScriptTag = 0x73617572; /* 'saur' (SAURASHTRA) */ ++const LETag sgnwScriptTag = 0x73676E77; /* 'sgnw' (SGNW) */ ++const LETag sundScriptTag = 0x73756E64; /* 'sund' (SUNDANESE) */ ++const LETag moonScriptTag = 0x6D6F6F6E; /* 'moon' (MOON) */ ++const LETag mteiScriptTag = 0x6D746569; /* 'mtei' (MEETEI_MAYEK) */ ++const LETag armiScriptTag = 0x61726D69; /* 'armi' (IMPERIAL_ARAMAIC) */ ++const LETag avstScriptTag = 0x61767374; /* 'avst' (AVESTAN) */ ++const LETag cakmScriptTag = 0x63616B6D; /* 'cakm' (CAKM) */ ++const LETag koreScriptTag = 0x6B6F7265; /* 'kore' (KORE) */ ++const LETag kthiScriptTag = 0x6B746869; /* 'kthi' (KAITHI) */ ++const LETag maniScriptTag = 0x6D616E69; /* 'mani' (MANI) */ ++const LETag phliScriptTag = 0x70686C69; /* 'phli' (INSCRIPTIONAL_PAHLAVI) */ ++const LETag phlpScriptTag = 0x70686C70; /* 'phlp' (PHLP) */ ++const LETag phlvScriptTag = 0x70686C76; /* 'phlv' (PHLV) */ ++const LETag prtiScriptTag = 0x70727469; /* 'prti' (INSCRIPTIONAL_PARTHIAN) */ ++const LETag samrScriptTag = 0x73616D72; /* 'samr' (SAMARITAN) */ ++const LETag tavtScriptTag = 0x74617674; /* 'tavt' (TAI_VIET) */ ++const LETag zmthScriptTag = 0x7A6D7468; /* 'zmth' (ZMTH) */ ++const LETag zsymScriptTag = 0x7A73796D; /* 'zsym' (ZSYM) */ ++const LETag bamuScriptTag = 0x62616D75; /* 'bamu' (BAMUM) */ ++const LETag lisuScriptTag = 0x6C697375; /* 'lisu' (LISU) */ ++const LETag nkgbScriptTag = 0x6E6B6762; /* 'nkgb' (NKGB) */ ++const LETag sarbScriptTag = 0x73617262; /* 'sarb' (OLD_SOUTH_ARABIAN) */ ++const LETag bassScriptTag = 0x62617373; /* 'bass' (BASS) */ ++const LETag duplScriptTag = 0x6475706C; /* 'dupl' (DUPL) */ ++const LETag elbaScriptTag = 0x656C6261; /* 'elba' (ELBA) */ ++const LETag granScriptTag = 0x6772616E; /* 'gran' (GRAN) */ ++const LETag kpelScriptTag = 0x6B70656C; /* 'kpel' (KPEL) */ ++const LETag lomaScriptTag = 0x6C6F6D61; /* 'loma' (LOMA) */ ++const LETag mendScriptTag = 0x6D656E64; /* 'mend' (MEND) */ ++const LETag mercScriptTag = 0x6D657263; /* 'merc' (MERC) */ ++const LETag narbScriptTag = 0x6E617262; /* 'narb' (NARB) */ ++const LETag nbatScriptTag = 0x6E626174; /* 'nbat' (NBAT) */ ++const LETag palmScriptTag = 0x70616C6D; /* 'palm' (PALM) */ ++const LETag sindScriptTag = 0x73696E64; /* 'sind' (SIND) */ ++const LETag waraScriptTag = 0x77617261; /* 'wara' (WARA) */ + + const LETag nullScriptTag = 0x00000000; /* '' (NULL) */ + +@@ -132,6 +235,48 @@ + const LETag zhpLanguageTag = 0x5A485020; /* 'ZHP' (Chinese (Phonetic)) */ + const LETag zhsLanguageTag = 0x5A485320; /* 'ZHS' (Chinese (Simplified)) */ + const LETag zhtLanguageTag = 0x5A485420; /* 'ZHT' (Chinese (Traditional)) */ ++const LETag afkLanguageTag = 0x41464B20; /* 'AFK' (Afrikaans) */ ++const LETag belLanguageTag = 0x42454C20; /* 'BEL' (Belarussian) */ ++const LETag bgrLanguageTag = 0x42475220; /* 'BGR' (Bulgarian) */ ++const LETag catLanguageTag = 0x43415420; /* 'CAT' (Catalan) */ ++const LETag cheLanguageTag = 0x43484520; /* 'CHE' (Chechen) */ ++const LETag copLanguageTag = 0x434F5020; /* 'COP' (Coptic) */ ++const LETag csyLanguageTag = 0x43535920; /* 'CSY' (Czech) */ ++const LETag danLanguageTag = 0x44414E20; /* 'DAN' (Danish) */ ++const LETag deuLanguageTag = 0x44455520; /* 'DEU' (German) */ ++const LETag dznLanguageTag = 0x445A4E20; /* 'DZN' (Dzongkha) */ ++const LETag ellLanguageTag = 0x454C4C20; /* 'ELL' (Greek) */ ++const LETag engLanguageTag = 0x454E4720; /* 'ENG' (English) */ ++const LETag espLanguageTag = 0x45535020; /* 'ESP' (Spanish) */ ++const LETag etiLanguageTag = 0x45544920; /* 'ETI' (Estonian) */ ++const LETag euqLanguageTag = 0x45555120; /* 'EUQ' (Basque) */ ++const LETag finLanguageTag = 0x46494E20; /* 'FIN' (Finnish) */ ++const LETag fraLanguageTag = 0x46524120; /* 'FRA' (French) */ ++const LETag gaeLanguageTag = 0x47414520; /* 'GAE' (Gaelic) */ ++const LETag hauLanguageTag = 0x48415520; /* 'HAU' (Hausa) */ ++const LETag hrvLanguageTag = 0x48525620; /* 'HRV' (Croation) */ ++const LETag hunLanguageTag = 0x48554E20; /* 'HUN' (Hungarian) */ ++const LETag hyeLanguageTag = 0x48594520; /* 'HYE' (Armenian) */ ++const LETag indLanguageTag = 0x494E4420; /* 'IND' (Indonesian) */ ++const LETag itaLanguageTag = 0x49544120; /* 'ITA' (Italian) */ ++const LETag khmLanguageTag = 0x4B484D20; /* 'KHM' (Khmer) */ ++const LETag mngLanguageTag = 0x4D4E4720; /* 'MNG' (Mongolian) */ ++const LETag mtsLanguageTag = 0x4D545320; /* 'MTS' (Maltese) */ ++const LETag nepLanguageTag = 0x4E455020; /* 'NEP' (Nepali) */ ++const LETag nldLanguageTag = 0x4E4C4420; /* 'NLD' (Dutch) */ ++const LETag pasLanguageTag = 0x50415320; /* 'PAS' (Pashto) */ ++const LETag plkLanguageTag = 0x504C4B20; /* 'PLK' (Polish) */ ++const LETag ptgLanguageTag = 0x50544720; /* 'PTG' (Portuguese) */ ++const LETag romLanguageTag = 0x524F4D20; /* 'ROM' (Romanian) */ ++const LETag rusLanguageTag = 0x52555320; /* 'RUS' (Russian) */ ++const LETag skyLanguageTag = 0x534B5920; /* 'SKY' (Slovak) */ ++const LETag slvLanguageTag = 0x534C5620; /* 'SLV' (Slovenian) */ ++const LETag sqiLanguageTag = 0x53514920; /* 'SQI' (Albanian) */ ++const LETag srbLanguageTag = 0x53524220; /* 'SRB' (Serbian) */ ++const LETag sveLanguageTag = 0x53564520; /* 'SVE' (Swedish) */ ++const LETag tibLanguageTag = 0x54494220; /* 'TIB' (Tibetan) */ ++const LETag trkLanguageTag = 0x54524B20; /* 'TRK' (Turkish) */ ++const LETag welLanguageTag = 0x57454C20; /* 'WEL' (Welsh) */ + + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp b/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp +--- jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp ++++ jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp +@@ -74,7 +74,7 @@ + + if (offset != 0) { + TTGlyphID *glyphArray = (TTGlyphID *) ((char *) subtableHeader + offset); +- TTGlyphID newGlyph = (TTGlyphID)SWAPW(glyphArray[LE_GET_GLYPH(thisGlyph) - firstGlyph]); ++ TTGlyphID newGlyph = SWAPW(glyphArray[LE_GET_GLYPH(thisGlyph) - firstGlyph]); + + glyphStorage[glyph] = LE_SET_GLYPH(thisGlyph, newGlyph); + } +diff --git a/src/share/native/sun/font/layout/ShapingTypeData.cpp b/src/share/native/sun/font/layout/ShapingTypeData.cpp +--- jdk/src/share/native/sun/font/layout/ShapingTypeData.cpp ++++ jdk/src/share/native/sun/font/layout/ShapingTypeData.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005. All Rights Reserved. ++ * (C) Copyright IBM Corp. 1998-2010. All Rights Reserved. + * + * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS + * YOU REALLY KNOW WHAT YOU'RE DOING. +@@ -39,72 +39,87 @@ + U_NAMESPACE_BEGIN + + const le_uint8 ArabicShaping::shapingTypeTable[] = { +- 0x00, 0x02, 0x00, 0xAD, 0x00, 0xAD, 0x00, 0xAD, 0x00, 0x05, 0x03, 0x00, 0x03, 0x6F, 0x00, 0x05, +- 0x04, 0x83, 0x04, 0x86, 0x00, 0x05, 0x04, 0x88, 0x04, 0x89, 0x00, 0x05, 0x05, 0x91, 0x05, 0xB9, +- 0x00, 0x05, 0x05, 0xBB, 0x05, 0xBD, 0x00, 0x05, 0x05, 0xBF, 0x05, 0xBF, 0x00, 0x05, 0x05, 0xC1, +- 0x05, 0xC2, 0x00, 0x05, 0x05, 0xC4, 0x05, 0xC5, 0x00, 0x05, 0x05, 0xC7, 0x05, 0xC7, 0x00, 0x05, +- 0x06, 0x10, 0x06, 0x15, 0x00, 0x05, 0x06, 0x22, 0x06, 0x25, 0x00, 0x04, 0x06, 0x26, 0x06, 0x26, +- 0x00, 0x02, 0x06, 0x27, 0x06, 0x27, 0x00, 0x04, 0x06, 0x28, 0x06, 0x28, 0x00, 0x02, 0x06, 0x29, +- 0x06, 0x29, 0x00, 0x04, 0x06, 0x2A, 0x06, 0x2E, 0x00, 0x02, 0x06, 0x2F, 0x06, 0x32, 0x00, 0x04, +- 0x06, 0x33, 0x06, 0x3A, 0x00, 0x02, 0x06, 0x40, 0x06, 0x40, 0x00, 0x01, 0x06, 0x41, 0x06, 0x47, +- 0x00, 0x02, 0x06, 0x48, 0x06, 0x48, 0x00, 0x04, 0x06, 0x49, 0x06, 0x4A, 0x00, 0x02, 0x06, 0x4B, +- 0x06, 0x5E, 0x00, 0x05, 0x06, 0x6E, 0x06, 0x6F, 0x00, 0x02, 0x06, 0x70, 0x06, 0x70, 0x00, 0x05, +- 0x06, 0x71, 0x06, 0x73, 0x00, 0x04, 0x06, 0x75, 0x06, 0x77, 0x00, 0x04, 0x06, 0x78, 0x06, 0x87, +- 0x00, 0x02, 0x06, 0x88, 0x06, 0x99, 0x00, 0x04, 0x06, 0x9A, 0x06, 0xBF, 0x00, 0x02, 0x06, 0xC0, +- 0x06, 0xC0, 0x00, 0x04, 0x06, 0xC1, 0x06, 0xC2, 0x00, 0x02, 0x06, 0xC3, 0x06, 0xCB, 0x00, 0x04, +- 0x06, 0xCC, 0x06, 0xCC, 0x00, 0x02, 0x06, 0xCD, 0x06, 0xCD, 0x00, 0x04, 0x06, 0xCE, 0x06, 0xCE, +- 0x00, 0x02, 0x06, 0xCF, 0x06, 0xCF, 0x00, 0x04, 0x06, 0xD0, 0x06, 0xD1, 0x00, 0x02, 0x06, 0xD2, +- 0x06, 0xD3, 0x00, 0x04, 0x06, 0xD5, 0x06, 0xD5, 0x00, 0x04, 0x06, 0xD6, 0x06, 0xDC, 0x00, 0x05, +- 0x06, 0xDE, 0x06, 0xE4, 0x00, 0x05, 0x06, 0xE7, 0x06, 0xE8, 0x00, 0x05, 0x06, 0xEA, 0x06, 0xED, +- 0x00, 0x05, 0x06, 0xEE, 0x06, 0xEF, 0x00, 0x04, 0x06, 0xFA, 0x06, 0xFC, 0x00, 0x02, 0x06, 0xFF, +- 0x06, 0xFF, 0x00, 0x02, 0x07, 0x0F, 0x07, 0x0F, 0x00, 0x05, 0x07, 0x10, 0x07, 0x10, 0x00, 0x04, +- 0x07, 0x11, 0x07, 0x11, 0x00, 0x05, 0x07, 0x12, 0x07, 0x14, 0x00, 0x02, 0x07, 0x15, 0x07, 0x19, +- 0x00, 0x04, 0x07, 0x1A, 0x07, 0x1D, 0x00, 0x02, 0x07, 0x1E, 0x07, 0x1E, 0x00, 0x04, 0x07, 0x1F, +- 0x07, 0x27, 0x00, 0x02, 0x07, 0x28, 0x07, 0x28, 0x00, 0x04, 0x07, 0x29, 0x07, 0x29, 0x00, 0x02, +- 0x07, 0x2A, 0x07, 0x2A, 0x00, 0x04, 0x07, 0x2B, 0x07, 0x2B, 0x00, 0x02, 0x07, 0x2C, 0x07, 0x2C, +- 0x00, 0x04, 0x07, 0x2D, 0x07, 0x2E, 0x00, 0x02, 0x07, 0x2F, 0x07, 0x2F, 0x00, 0x04, 0x07, 0x30, +- 0x07, 0x4A, 0x00, 0x05, 0x07, 0x4D, 0x07, 0x4D, 0x00, 0x04, 0x07, 0x4E, 0x07, 0x58, 0x00, 0x02, +- 0x07, 0x59, 0x07, 0x5B, 0x00, 0x04, 0x07, 0x5C, 0x07, 0x6A, 0x00, 0x02, 0x07, 0x6B, 0x07, 0x6C, +- 0x00, 0x04, 0x07, 0x6D, 0x07, 0x6D, 0x00, 0x02, 0x07, 0xA6, 0x07, 0xB0, 0x00, 0x05, 0x09, 0x01, +- 0x09, 0x02, 0x00, 0x05, 0x09, 0x3C, 0x09, 0x3C, 0x00, 0x05, 0x09, 0x41, 0x09, 0x48, 0x00, 0x05, +- 0x09, 0x4D, 0x09, 0x4D, 0x00, 0x05, 0x09, 0x51, 0x09, 0x54, 0x00, 0x05, 0x09, 0x62, 0x09, 0x63, +- 0x00, 0x05, 0x09, 0x81, 0x09, 0x81, 0x00, 0x05, 0x09, 0xBC, 0x09, 0xBC, 0x00, 0x05, 0x09, 0xC1, +- 0x09, 0xC4, 0x00, 0x05, 0x09, 0xCD, 0x09, 0xCD, 0x00, 0x05, 0x09, 0xE2, 0x09, 0xE3, 0x00, 0x05, +- 0x0A, 0x01, 0x0A, 0x02, 0x00, 0x05, 0x0A, 0x3C, 0x0A, 0x3C, 0x00, 0x05, 0x0A, 0x41, 0x0A, 0x42, +- 0x00, 0x05, 0x0A, 0x47, 0x0A, 0x48, 0x00, 0x05, 0x0A, 0x4B, 0x0A, 0x4D, 0x00, 0x05, 0x0A, 0x70, +- 0x0A, 0x71, 0x00, 0x05, 0x0A, 0x81, 0x0A, 0x82, 0x00, 0x05, 0x0A, 0xBC, 0x0A, 0xBC, 0x00, 0x05, +- 0x0A, 0xC1, 0x0A, 0xC5, 0x00, 0x05, 0x0A, 0xC7, 0x0A, 0xC8, 0x00, 0x05, 0x0A, 0xCD, 0x0A, 0xCD, +- 0x00, 0x05, 0x0A, 0xE2, 0x0A, 0xE3, 0x00, 0x05, 0x0B, 0x01, 0x0B, 0x01, 0x00, 0x05, 0x0B, 0x3C, +- 0x0B, 0x3C, 0x00, 0x05, 0x0B, 0x3F, 0x0B, 0x3F, 0x00, 0x05, 0x0B, 0x41, 0x0B, 0x43, 0x00, 0x05, +- 0x0B, 0x4D, 0x0B, 0x4D, 0x00, 0x05, 0x0B, 0x56, 0x0B, 0x56, 0x00, 0x05, 0x0B, 0x82, 0x0B, 0x82, +- 0x00, 0x05, 0x0B, 0xC0, 0x0B, 0xC0, 0x00, 0x05, 0x0B, 0xCD, 0x0B, 0xCD, 0x00, 0x05, 0x0C, 0x3E, +- 0x0C, 0x40, 0x00, 0x05, 0x0C, 0x46, 0x0C, 0x48, 0x00, 0x05, 0x0C, 0x4A, 0x0C, 0x4D, 0x00, 0x05, +- 0x0C, 0x55, 0x0C, 0x56, 0x00, 0x05, 0x0C, 0xBC, 0x0C, 0xBC, 0x00, 0x05, 0x0C, 0xBF, 0x0C, 0xBF, +- 0x00, 0x05, 0x0C, 0xC6, 0x0C, 0xC6, 0x00, 0x05, 0x0C, 0xCC, 0x0C, 0xCD, 0x00, 0x05, 0x0D, 0x41, +- 0x0D, 0x43, 0x00, 0x05, 0x0D, 0x4D, 0x0D, 0x4D, 0x00, 0x05, 0x0D, 0xCA, 0x0D, 0xCA, 0x00, 0x05, +- 0x0D, 0xD2, 0x0D, 0xD4, 0x00, 0x05, 0x0D, 0xD6, 0x0D, 0xD6, 0x00, 0x05, 0x0E, 0x31, 0x0E, 0x31, +- 0x00, 0x05, 0x0E, 0x34, 0x0E, 0x3A, 0x00, 0x05, 0x0E, 0x47, 0x0E, 0x4E, 0x00, 0x05, 0x0E, 0xB1, +- 0x0E, 0xB1, 0x00, 0x05, 0x0E, 0xB4, 0x0E, 0xB9, 0x00, 0x05, 0x0E, 0xBB, 0x0E, 0xBC, 0x00, 0x05, +- 0x0E, 0xC8, 0x0E, 0xCD, 0x00, 0x05, 0x0F, 0x18, 0x0F, 0x19, 0x00, 0x05, 0x0F, 0x35, 0x0F, 0x35, +- 0x00, 0x05, 0x0F, 0x37, 0x0F, 0x37, 0x00, 0x05, 0x0F, 0x39, 0x0F, 0x39, 0x00, 0x05, 0x0F, 0x71, +- 0x0F, 0x7E, 0x00, 0x05, 0x0F, 0x80, 0x0F, 0x84, 0x00, 0x05, 0x0F, 0x86, 0x0F, 0x87, 0x00, 0x05, +- 0x0F, 0x90, 0x0F, 0x97, 0x00, 0x05, 0x0F, 0x99, 0x0F, 0xBC, 0x00, 0x05, 0x0F, 0xC6, 0x0F, 0xC6, +- 0x00, 0x05, 0x10, 0x2D, 0x10, 0x30, 0x00, 0x05, 0x10, 0x32, 0x10, 0x32, 0x00, 0x05, 0x10, 0x36, +- 0x10, 0x37, 0x00, 0x05, 0x10, 0x39, 0x10, 0x39, 0x00, 0x05, 0x10, 0x58, 0x10, 0x59, 0x00, 0x05, +- 0x13, 0x5F, 0x13, 0x5F, 0x00, 0x05, 0x17, 0x12, 0x17, 0x14, 0x00, 0x05, 0x17, 0x32, 0x17, 0x34, +- 0x00, 0x05, 0x17, 0x52, 0x17, 0x53, 0x00, 0x05, 0x17, 0x72, 0x17, 0x73, 0x00, 0x05, 0x17, 0xB4, +- 0x17, 0xB5, 0x00, 0x05, 0x17, 0xB7, 0x17, 0xBD, 0x00, 0x05, 0x17, 0xC6, 0x17, 0xC6, 0x00, 0x05, +- 0x17, 0xC9, 0x17, 0xD3, 0x00, 0x05, 0x17, 0xDD, 0x17, 0xDD, 0x00, 0x05, 0x18, 0x0B, 0x18, 0x0D, +- 0x00, 0x05, 0x18, 0xA9, 0x18, 0xA9, 0x00, 0x05, 0x19, 0x20, 0x19, 0x22, 0x00, 0x05, 0x19, 0x27, +- 0x19, 0x28, 0x00, 0x05, 0x19, 0x32, 0x19, 0x32, 0x00, 0x05, 0x19, 0x39, 0x19, 0x3B, 0x00, 0x05, +- 0x1A, 0x17, 0x1A, 0x18, 0x00, 0x05, 0x1D, 0xC0, 0x1D, 0xC3, 0x00, 0x05, 0x20, 0x0B, 0x20, 0x0B, +- 0x00, 0x05, 0x20, 0x0D, 0x20, 0x0D, 0x00, 0x01, 0x20, 0x0E, 0x20, 0x0F, 0x00, 0x05, 0x20, 0x2A, +- 0x20, 0x2E, 0x00, 0x05, 0x20, 0x60, 0x20, 0x63, 0x00, 0x05, 0x20, 0x6A, 0x20, 0x6F, 0x00, 0x05, +- 0x20, 0xD0, 0x20, 0xEB, 0x00, 0x05, 0x30, 0x2A, 0x30, 0x2F, 0x00, 0x05, 0x30, 0x99, 0x30, 0x9A, +- 0x00, 0x05, 0xA8, 0x06, 0xA8, 0x06, 0x00, 0x05, 0xA8, 0x0B, 0xA8, 0x0B, 0x00, 0x05, 0xA8, 0x25, +- 0xA8, 0x26, 0x00, 0x05, 0xFB, 0x1E, 0xFB, 0x1E, 0x00, 0x05, 0xFE, 0x00, 0xFE, 0x0F, 0x00, 0x05, +- 0xFE, 0x20, 0xFE, 0x23, 0x00, 0x05, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x05, 0xFF, 0xF9, 0xFF, 0xFB, +- 0x00, 0x05 ++ 0x00, 0x02, 0x00, 0xD7, 0x00, 0xAD, 0x00, 0xAD, 0x00, 0x05, 0x03, 0x00, 0x03, 0x6F, 0x00, 0x05, ++ 0x04, 0x83, 0x04, 0x89, 0x00, 0x05, 0x05, 0x91, 0x05, 0xBD, 0x00, 0x05, 0x05, 0xBF, 0x05, 0xBF, ++ 0x00, 0x05, 0x05, 0xC1, 0x05, 0xC2, 0x00, 0x05, 0x05, 0xC4, 0x05, 0xC5, 0x00, 0x05, 0x05, 0xC7, ++ 0x05, 0xC7, 0x00, 0x05, 0x06, 0x10, 0x06, 0x1A, 0x00, 0x05, 0x06, 0x22, 0x06, 0x25, 0x00, 0x04, ++ 0x06, 0x26, 0x06, 0x26, 0x00, 0x02, 0x06, 0x27, 0x06, 0x27, 0x00, 0x04, 0x06, 0x28, 0x06, 0x28, ++ 0x00, 0x02, 0x06, 0x29, 0x06, 0x29, 0x00, 0x04, 0x06, 0x2A, 0x06, 0x2E, 0x00, 0x02, 0x06, 0x2F, ++ 0x06, 0x32, 0x00, 0x04, 0x06, 0x33, 0x06, 0x3F, 0x00, 0x02, 0x06, 0x40, 0x06, 0x40, 0x00, 0x01, ++ 0x06, 0x41, 0x06, 0x47, 0x00, 0x02, 0x06, 0x48, 0x06, 0x48, 0x00, 0x04, 0x06, 0x49, 0x06, 0x4A, ++ 0x00, 0x02, 0x06, 0x4B, 0x06, 0x5E, 0x00, 0x05, 0x06, 0x6E, 0x06, 0x6F, 0x00, 0x02, 0x06, 0x70, ++ 0x06, 0x70, 0x00, 0x05, 0x06, 0x71, 0x06, 0x73, 0x00, 0x04, 0x06, 0x75, 0x06, 0x77, 0x00, 0x04, ++ 0x06, 0x78, 0x06, 0x87, 0x00, 0x02, 0x06, 0x88, 0x06, 0x99, 0x00, 0x04, 0x06, 0x9A, 0x06, 0xBF, ++ 0x00, 0x02, 0x06, 0xC0, 0x06, 0xC0, 0x00, 0x04, 0x06, 0xC1, 0x06, 0xC2, 0x00, 0x02, 0x06, 0xC3, ++ 0x06, 0xCB, 0x00, 0x04, 0x06, 0xCC, 0x06, 0xCC, 0x00, 0x02, 0x06, 0xCD, 0x06, 0xCD, 0x00, 0x04, ++ 0x06, 0xCE, 0x06, 0xCE, 0x00, 0x02, 0x06, 0xCF, 0x06, 0xCF, 0x00, 0x04, 0x06, 0xD0, 0x06, 0xD1, ++ 0x00, 0x02, 0x06, 0xD2, 0x06, 0xD3, 0x00, 0x04, 0x06, 0xD5, 0x06, 0xD5, 0x00, 0x04, 0x06, 0xD6, ++ 0x06, 0xDC, 0x00, 0x05, 0x06, 0xDE, 0x06, 0xE4, 0x00, 0x05, 0x06, 0xE7, 0x06, 0xE8, 0x00, 0x05, ++ 0x06, 0xEA, 0x06, 0xED, 0x00, 0x05, 0x06, 0xEE, 0x06, 0xEF, 0x00, 0x04, 0x06, 0xFA, 0x06, 0xFC, ++ 0x00, 0x02, 0x06, 0xFF, 0x06, 0xFF, 0x00, 0x02, 0x07, 0x0F, 0x07, 0x0F, 0x00, 0x05, 0x07, 0x10, ++ 0x07, 0x10, 0x00, 0x04, 0x07, 0x11, 0x07, 0x11, 0x00, 0x05, 0x07, 0x12, 0x07, 0x14, 0x00, 0x02, ++ 0x07, 0x15, 0x07, 0x19, 0x00, 0x04, 0x07, 0x1A, 0x07, 0x1D, 0x00, 0x02, 0x07, 0x1E, 0x07, 0x1E, ++ 0x00, 0x04, 0x07, 0x1F, 0x07, 0x27, 0x00, 0x02, 0x07, 0x28, 0x07, 0x28, 0x00, 0x04, 0x07, 0x29, ++ 0x07, 0x29, 0x00, 0x02, 0x07, 0x2A, 0x07, 0x2A, 0x00, 0x04, 0x07, 0x2B, 0x07, 0x2B, 0x00, 0x02, ++ 0x07, 0x2C, 0x07, 0x2C, 0x00, 0x04, 0x07, 0x2D, 0x07, 0x2E, 0x00, 0x02, 0x07, 0x2F, 0x07, 0x2F, ++ 0x00, 0x04, 0x07, 0x30, 0x07, 0x4A, 0x00, 0x05, 0x07, 0x4D, 0x07, 0x4D, 0x00, 0x04, 0x07, 0x4E, ++ 0x07, 0x58, 0x00, 0x02, 0x07, 0x59, 0x07, 0x5B, 0x00, 0x04, 0x07, 0x5C, 0x07, 0x6A, 0x00, 0x02, ++ 0x07, 0x6B, 0x07, 0x6C, 0x00, 0x04, 0x07, 0x6D, 0x07, 0x70, 0x00, 0x02, 0x07, 0x71, 0x07, 0x71, ++ 0x00, 0x04, 0x07, 0x72, 0x07, 0x72, 0x00, 0x02, 0x07, 0x73, 0x07, 0x74, 0x00, 0x04, 0x07, 0x75, ++ 0x07, 0x77, 0x00, 0x02, 0x07, 0x78, 0x07, 0x79, 0x00, 0x04, 0x07, 0x7A, 0x07, 0x7F, 0x00, 0x02, ++ 0x07, 0xA6, 0x07, 0xB0, 0x00, 0x05, 0x07, 0xCA, 0x07, 0xEA, 0x00, 0x02, 0x07, 0xEB, 0x07, 0xF3, ++ 0x00, 0x05, 0x07, 0xFA, 0x07, 0xFA, 0x00, 0x01, 0x09, 0x01, 0x09, 0x02, 0x00, 0x05, 0x09, 0x3C, ++ 0x09, 0x3C, 0x00, 0x05, 0x09, 0x41, 0x09, 0x48, 0x00, 0x05, 0x09, 0x4D, 0x09, 0x4D, 0x00, 0x05, ++ 0x09, 0x51, 0x09, 0x54, 0x00, 0x05, 0x09, 0x62, 0x09, 0x63, 0x00, 0x05, 0x09, 0x81, 0x09, 0x81, ++ 0x00, 0x05, 0x09, 0xBC, 0x09, 0xBC, 0x00, 0x05, 0x09, 0xC1, 0x09, 0xC4, 0x00, 0x05, 0x09, 0xCD, ++ 0x09, 0xCD, 0x00, 0x05, 0x09, 0xE2, 0x09, 0xE3, 0x00, 0x05, 0x0A, 0x01, 0x0A, 0x02, 0x00, 0x05, ++ 0x0A, 0x3C, 0x0A, 0x3C, 0x00, 0x05, 0x0A, 0x41, 0x0A, 0x42, 0x00, 0x05, 0x0A, 0x47, 0x0A, 0x48, ++ 0x00, 0x05, 0x0A, 0x4B, 0x0A, 0x4D, 0x00, 0x05, 0x0A, 0x51, 0x0A, 0x51, 0x00, 0x05, 0x0A, 0x70, ++ 0x0A, 0x71, 0x00, 0x05, 0x0A, 0x75, 0x0A, 0x75, 0x00, 0x05, 0x0A, 0x81, 0x0A, 0x82, 0x00, 0x05, ++ 0x0A, 0xBC, 0x0A, 0xBC, 0x00, 0x05, 0x0A, 0xC1, 0x0A, 0xC5, 0x00, 0x05, 0x0A, 0xC7, 0x0A, 0xC8, ++ 0x00, 0x05, 0x0A, 0xCD, 0x0A, 0xCD, 0x00, 0x05, 0x0A, 0xE2, 0x0A, 0xE3, 0x00, 0x05, 0x0B, 0x01, ++ 0x0B, 0x01, 0x00, 0x05, 0x0B, 0x3C, 0x0B, 0x3C, 0x00, 0x05, 0x0B, 0x3F, 0x0B, 0x3F, 0x00, 0x05, ++ 0x0B, 0x41, 0x0B, 0x44, 0x00, 0x05, 0x0B, 0x4D, 0x0B, 0x4D, 0x00, 0x05, 0x0B, 0x56, 0x0B, 0x56, ++ 0x00, 0x05, 0x0B, 0x62, 0x0B, 0x63, 0x00, 0x05, 0x0B, 0x82, 0x0B, 0x82, 0x00, 0x05, 0x0B, 0xC0, ++ 0x0B, 0xC0, 0x00, 0x05, 0x0B, 0xCD, 0x0B, 0xCD, 0x00, 0x05, 0x0C, 0x3E, 0x0C, 0x40, 0x00, 0x05, ++ 0x0C, 0x46, 0x0C, 0x48, 0x00, 0x05, 0x0C, 0x4A, 0x0C, 0x4D, 0x00, 0x05, 0x0C, 0x55, 0x0C, 0x56, ++ 0x00, 0x05, 0x0C, 0x62, 0x0C, 0x63, 0x00, 0x05, 0x0C, 0xBC, 0x0C, 0xBC, 0x00, 0x05, 0x0C, 0xBF, ++ 0x0C, 0xBF, 0x00, 0x05, 0x0C, 0xC6, 0x0C, 0xC6, 0x00, 0x05, 0x0C, 0xCC, 0x0C, 0xCD, 0x00, 0x05, ++ 0x0C, 0xE2, 0x0C, 0xE3, 0x00, 0x05, 0x0D, 0x41, 0x0D, 0x44, 0x00, 0x05, 0x0D, 0x4D, 0x0D, 0x4D, ++ 0x00, 0x05, 0x0D, 0x62, 0x0D, 0x63, 0x00, 0x05, 0x0D, 0xCA, 0x0D, 0xCA, 0x00, 0x05, 0x0D, 0xD2, ++ 0x0D, 0xD4, 0x00, 0x05, 0x0D, 0xD6, 0x0D, 0xD6, 0x00, 0x05, 0x0E, 0x31, 0x0E, 0x31, 0x00, 0x05, ++ 0x0E, 0x34, 0x0E, 0x3A, 0x00, 0x05, 0x0E, 0x47, 0x0E, 0x4E, 0x00, 0x05, 0x0E, 0xB1, 0x0E, 0xB1, ++ 0x00, 0x05, 0x0E, 0xB4, 0x0E, 0xB9, 0x00, 0x05, 0x0E, 0xBB, 0x0E, 0xBC, 0x00, 0x05, 0x0E, 0xC8, ++ 0x0E, 0xCD, 0x00, 0x05, 0x0F, 0x18, 0x0F, 0x19, 0x00, 0x05, 0x0F, 0x35, 0x0F, 0x35, 0x00, 0x05, ++ 0x0F, 0x37, 0x0F, 0x37, 0x00, 0x05, 0x0F, 0x39, 0x0F, 0x39, 0x00, 0x05, 0x0F, 0x71, 0x0F, 0x7E, ++ 0x00, 0x05, 0x0F, 0x80, 0x0F, 0x84, 0x00, 0x05, 0x0F, 0x86, 0x0F, 0x87, 0x00, 0x05, 0x0F, 0x90, ++ 0x0F, 0x97, 0x00, 0x05, 0x0F, 0x99, 0x0F, 0xBC, 0x00, 0x05, 0x0F, 0xC6, 0x0F, 0xC6, 0x00, 0x05, ++ 0x10, 0x2D, 0x10, 0x30, 0x00, 0x05, 0x10, 0x32, 0x10, 0x37, 0x00, 0x05, 0x10, 0x39, 0x10, 0x3A, ++ 0x00, 0x05, 0x10, 0x3D, 0x10, 0x3E, 0x00, 0x05, 0x10, 0x58, 0x10, 0x59, 0x00, 0x05, 0x10, 0x5E, ++ 0x10, 0x60, 0x00, 0x05, 0x10, 0x71, 0x10, 0x74, 0x00, 0x05, 0x10, 0x82, 0x10, 0x82, 0x00, 0x05, ++ 0x10, 0x85, 0x10, 0x86, 0x00, 0x05, 0x10, 0x8D, 0x10, 0x8D, 0x00, 0x05, 0x13, 0x5F, 0x13, 0x5F, ++ 0x00, 0x05, 0x17, 0x12, 0x17, 0x14, 0x00, 0x05, 0x17, 0x32, 0x17, 0x34, 0x00, 0x05, 0x17, 0x52, ++ 0x17, 0x53, 0x00, 0x05, 0x17, 0x72, 0x17, 0x73, 0x00, 0x05, 0x17, 0xB4, 0x17, 0xB5, 0x00, 0x05, ++ 0x17, 0xB7, 0x17, 0xBD, 0x00, 0x05, 0x17, 0xC6, 0x17, 0xC6, 0x00, 0x05, 0x17, 0xC9, 0x17, 0xD3, ++ 0x00, 0x05, 0x17, 0xDD, 0x17, 0xDD, 0x00, 0x05, 0x18, 0x0B, 0x18, 0x0D, 0x00, 0x05, 0x18, 0xA9, ++ 0x18, 0xA9, 0x00, 0x05, 0x19, 0x20, 0x19, 0x22, 0x00, 0x05, 0x19, 0x27, 0x19, 0x28, 0x00, 0x05, ++ 0x19, 0x32, 0x19, 0x32, 0x00, 0x05, 0x19, 0x39, 0x19, 0x3B, 0x00, 0x05, 0x1A, 0x17, 0x1A, 0x18, ++ 0x00, 0x05, 0x1B, 0x00, 0x1B, 0x03, 0x00, 0x05, 0x1B, 0x34, 0x1B, 0x34, 0x00, 0x05, 0x1B, 0x36, ++ 0x1B, 0x3A, 0x00, 0x05, 0x1B, 0x3C, 0x1B, 0x3C, 0x00, 0x05, 0x1B, 0x42, 0x1B, 0x42, 0x00, 0x05, ++ 0x1B, 0x6B, 0x1B, 0x73, 0x00, 0x05, 0x1B, 0x80, 0x1B, 0x81, 0x00, 0x05, 0x1B, 0xA2, 0x1B, 0xA5, ++ 0x00, 0x05, 0x1B, 0xA8, 0x1B, 0xA9, 0x00, 0x05, 0x1C, 0x2C, 0x1C, 0x33, 0x00, 0x05, 0x1C, 0x36, ++ 0x1C, 0x37, 0x00, 0x05, 0x1D, 0xC0, 0x1D, 0xE6, 0x00, 0x05, 0x1D, 0xFE, 0x1D, 0xFF, 0x00, 0x05, ++ 0x20, 0x0B, 0x20, 0x0B, 0x00, 0x05, 0x20, 0x0D, 0x20, 0x0D, 0x00, 0x01, 0x20, 0x0E, 0x20, 0x0F, ++ 0x00, 0x05, 0x20, 0x2A, 0x20, 0x2E, 0x00, 0x05, 0x20, 0x60, 0x20, 0x64, 0x00, 0x05, 0x20, 0x6A, ++ 0x20, 0x6F, 0x00, 0x05, 0x20, 0xD0, 0x20, 0xF0, 0x00, 0x05, 0x2D, 0xE0, 0x2D, 0xFF, 0x00, 0x05, ++ 0x30, 0x2A, 0x30, 0x2F, 0x00, 0x05, 0x30, 0x99, 0x30, 0x9A, 0x00, 0x05, 0xA6, 0x6F, 0xA6, 0x72, ++ 0x00, 0x05, 0xA6, 0x7C, 0xA6, 0x7D, 0x00, 0x05, 0xA8, 0x02, 0xA8, 0x02, 0x00, 0x05, 0xA8, 0x06, ++ 0xA8, 0x06, 0x00, 0x05, 0xA8, 0x0B, 0xA8, 0x0B, 0x00, 0x05, 0xA8, 0x25, 0xA8, 0x26, 0x00, 0x05, ++ 0xA8, 0xC4, 0xA8, 0xC4, 0x00, 0x05, 0xA9, 0x26, 0xA9, 0x2D, 0x00, 0x05, 0xA9, 0x47, 0xA9, 0x51, ++ 0x00, 0x05, 0xAA, 0x29, 0xAA, 0x2E, 0x00, 0x05, 0xAA, 0x31, 0xAA, 0x32, 0x00, 0x05, 0xAA, 0x35, ++ 0xAA, 0x36, 0x00, 0x05, 0xAA, 0x43, 0xAA, 0x43, 0x00, 0x05, 0xAA, 0x4C, 0xAA, 0x4C, 0x00, 0x05, ++ 0xFB, 0x1E, 0xFB, 0x1E, 0x00, 0x05, 0xFE, 0x00, 0xFE, 0x0F, 0x00, 0x05, 0xFE, 0x20, 0xFE, 0x26, ++ 0x00, 0x05, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x05, 0xFF, 0xF9, 0xFF, 0xFB, 0x00, 0x05 + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/SubstitutionLookups.cpp b/src/share/native/sun/font/layout/SubstitutionLookups.cpp +--- jdk/src/share/native/sun/font/layout/SubstitutionLookups.cpp ++++ jdk/src/share/native/sun/font/layout/SubstitutionLookups.cpp +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -53,18 +53,23 @@ + le_uint16 substCount, + GlyphIterator *glyphIterator, + const LEFontInstance *fontInstance, +- le_int32 position) ++ le_int32 position, ++ LEErrorCode& success) + { ++ if (LE_FAILURE(success)) { ++ return; ++ } ++ + GlyphIterator tempIterator(*glyphIterator); + +- for (le_uint16 subst = 0; subst < substCount; subst += 1) { ++ for (le_uint16 subst = 0; subst < substCount && LE_SUCCESS(success); subst += 1) { + le_uint16 sequenceIndex = SWAPW(substLookupRecordArray[subst].sequenceIndex); + le_uint16 lookupListIndex = SWAPW(substLookupRecordArray[subst].lookupListIndex); + + tempIterator.setCurrStreamPosition(position); + tempIterator.next(sequenceIndex); + +- lookupProcessor->applySingleLookup(lookupListIndex, &tempIterator, fontInstance); ++ lookupProcessor->applySingleLookup(lookupListIndex, &tempIterator, fontInstance, success); + } + } + +diff --git a/src/share/native/sun/font/layout/SubstitutionLookups.h b/src/share/native/sun/font/layout/SubstitutionLookups.h +--- jdk/src/share/native/sun/font/layout/SubstitutionLookups.h ++++ jdk/src/share/native/sun/font/layout/SubstitutionLookups.h +@@ -25,7 +25,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -60,7 +60,8 @@ + le_uint16 substCount, + GlyphIterator *glyphIterator, + const LEFontInstance *fontInstance, +- le_int32 position); ++ le_int32 position, ++ LEErrorCode& success); + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp b/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp +--- jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp ++++ jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -36,19 +36,24 @@ + #include "ScriptAndLanguageTags.h" + #include "LEGlyphStorage.h" + ++#include "KernTable.h" ++ + #include "ThaiShaping.h" + + U_NAMESPACE_BEGIN + + UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ThaiLayoutEngine) + +-ThaiLayoutEngine::ThaiLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) +- : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags) ++ThaiLayoutEngine::ThaiLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success) ++ : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success) + { + fErrorChar = 0x25CC; + + // Figure out which presentation forms the font uses +- if (fontInstance->canDisplay(0x0E64)) { ++ if (! fontInstance->canDisplay(0x0E01)) { ++ // No Thai in font; don't use presentation forms. ++ fGlyphSet = 3; ++ } else if (fontInstance->canDisplay(0x0E64)) { + // WorldType uses reserved space in Thai block + fGlyphSet = 0; + } else if (fontInstance->canDisplay(0xF701)) { +@@ -116,4 +121,28 @@ + return glyphCount; + } + ++// This is the same as LayoutEngline::adjustGlyphPositions() except that it doesn't call adjustMarkGlyphs ++void ThaiLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool /*reverse*/, ++ LEGlyphStorage &glyphStorage, LEErrorCode &success) ++{ ++ if (LE_FAILURE(success)) { ++ return; ++ } ++ ++ if (chars == NULL || offset < 0 || count < 0) { ++ success = LE_ILLEGAL_ARGUMENT_ERROR; ++ return; ++ } ++ ++ if (fTypoFlags & 0x1) { /* kerning enabled */ ++ static const le_uint32 kernTableTag = LE_KERN_TABLE_TAG; ++ ++ KernTable kt(fFontInstance, getFontTable(kernTableTag)); ++ kt.process(glyphStorage); ++ } ++ ++ // default is no adjustments ++ return; ++} ++ + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/ThaiLayoutEngine.h b/src/share/native/sun/font/layout/ThaiLayoutEngine.h +--- jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.h ++++ jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.h +@@ -26,7 +26,7 @@ + + /* + * +- * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved + * + */ + +@@ -62,13 +62,14 @@ + * @param fontInstance - the font + * @param scriptCode - the script + * @param languageCode - the language ++ * @param success - set to an error code if the operation fails + * + * @see LEFontInstance + * @see ScriptAndLanguageTags.h for script and language codes + * + * @internal + */ +- ThaiLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags); ++ ThaiLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success); + + /** + * The destructor, virtual for correct polymorphic invocation. +@@ -139,6 +140,28 @@ + virtual le_int32 computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, + LEGlyphStorage &glyphStorage, LEErrorCode &success); + ++ /** ++ * This method does positioning adjustments like accent positioning and ++ * kerning. The default implementation does nothing. Subclasses needing ++ * position adjustments must override this method. ++ * ++ * Note that this method has both characters and glyphs as input so that ++ * it can use the character codes to determine glyph types if that information ++ * isn't directly available. (e.g. Some Arabic OpenType fonts don't have a GDEF ++ * table) ++ * ++ * @param chars - the input character context ++ * @param offset - the offset of the first character to process ++ * @param count - the number of characters to process ++ * @param reverse - <code>TRUE</code> if the glyphs in the glyph array have been reordered ++ * @param glyphStorage - the object which holds the per-glyph storage. The glyph positions will be ++ * adjusted as needed. ++ * @param success - output parameter set to an error code if the operation fails ++ * ++ * @internal ++ */ ++ virtual void adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ + }; + + U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/TibetanLayoutEngine.cpp b/src/share/native/sun/font/layout/TibetanLayoutEngine.cpp +new file mode 100644 +--- /dev/null ++++ jdk/src/share/native/sun/font/layout/TibetanLayoutEngine.cpp +@@ -0,0 +1,112 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Oracle designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Oracle in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* ++ * ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved ++ * ++ * Developed at DIT - Government of Bhutan ++ * ++ * Contact person: Pema Geyleg - <pema_geyleg@druknet.bt> ++ * ++ * This file is a modification of the ICU file KhmerReordering.cpp ++ * by Jens Herden and Javier Sola who have given all their possible rights to IBM and the Governement of Bhutan ++ * A first module for Dzongkha was developed by Karunakar under Panlocalisation funding. ++ * Assistance for this module has been received from Namgay Thinley, Christopher Fynn and Javier Sola ++ * ++ */ ++ ++ ++#include "OpenTypeLayoutEngine.h" ++#include "TibetanLayoutEngine.h" ++#include "LEGlyphStorage.h" ++#include "TibetanReordering.h" ++ ++U_NAMESPACE_BEGIN ++ ++UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TibetanOpenTypeLayoutEngine) ++ ++TibetanOpenTypeLayoutEngine::TibetanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success) ++{ ++ fFeatureMap = TibetanReordering::getFeatureMap(fFeatureMapCount); ++ fFeatureOrder = TRUE; ++} ++ ++TibetanOpenTypeLayoutEngine::TibetanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, LEErrorCode &success) ++ : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success) ++{ ++ fFeatureMap = TibetanReordering::getFeatureMap(fFeatureMapCount); ++ fFeatureOrder = TRUE; ++} ++ ++TibetanOpenTypeLayoutEngine::~TibetanOpenTypeLayoutEngine() ++{ ++ // nothing to do ++} ++ ++// Input: characters ++// Output: characters, char indices, tags ++// Returns: output character count ++le_int32 TibetanOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success) ++{ ++ if (LE_FAILURE(success)) { ++ return 0; ++ } ++ ++ if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { ++ success = LE_ILLEGAL_ARGUMENT_ERROR; ++ return 0; ++ } ++ ++ le_int32 worstCase = count * 3; // worst case is 3 for Khmer TODO check if 2 is enough ++ ++ outChars = LE_NEW_ARRAY(LEUnicode, worstCase); ++ ++ if (outChars == NULL) { ++ success = LE_MEMORY_ALLOCATION_ERROR; ++ return 0; ++ } ++ ++ glyphStorage.allocateGlyphArray(worstCase, rightToLeft, success); ++ glyphStorage.allocateAuxData(success); ++ ++ if (LE_FAILURE(success)) { ++ LE_DELETE_ARRAY(outChars); ++ return 0; ++ } ++ ++ // NOTE: assumes this allocates featureTags... ++ // (probably better than doing the worst case stuff here...) ++ le_int32 outCharCount = TibetanReordering::reorder(&chars[offset], count, fScriptCode, outChars, glyphStorage); ++ ++ glyphStorage.adoptGlyphCount(outCharCount); ++ return outCharCount; ++} ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/TibetanLayoutEngine.h b/src/share/native/sun/font/layout/TibetanLayoutEngine.h +new file mode 100644 +--- /dev/null ++++ jdk/src/share/native/sun/font/layout/TibetanLayoutEngine.h +@@ -0,0 +1,156 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Oracle designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Oracle in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* ++ * ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved ++ * ++ * Developed at DIT - Government of Bhutan ++ * ++ * Contact person: Pema Geyleg - <pema_geyleg@druknet.bt> ++ * ++ * This file is a modification of the ICU file KhmerReordering.cpp ++ * by Jens Herden and Javier Sola who have given all their possible rights to IBM and the Governement of Bhutan ++ * A first module for Dzongkha was developed by Karunakar under Panlocalisation funding. ++ * Assistance for this module has been received from Namgay Thinley, Christopher Fynn and Javier Sola ++ * ++ */ ++ ++#ifndef __TIBETANLAYOUTENGINE_H ++#define __TIBETANLAYOUTENGINE_H ++ ++// #include "LETypes.h" ++// #include "LEFontInstance.h" ++// #include "LEGlyphFilter.h" ++// #include "LayoutEngine.h" ++// #include "OpenTypeLayoutEngine.h" ++ ++// #include "GlyphSubstitutionTables.h" ++// #include "GlyphDefinitionTables.h" ++// #include "GlyphPositioningTables.h" ++ ++U_NAMESPACE_BEGIN ++ ++// class MPreFixups; ++// class LEGlyphStorage; ++ ++/** ++ * This class implements OpenType layout for Dzongkha and Tibetan OpenType fonts ++ * ++ * @internal ++ */ ++class TibetanOpenTypeLayoutEngine : public OpenTypeLayoutEngine ++{ ++public: ++ /** ++ * This is the main constructor. It constructs an instance of TibetanOpenTypeLayoutEngine for ++ * a particular font, script and language. It takes the GSUB table as a parameter since ++ * LayoutEngine::layoutEngineFactory has to read the GSUB table to know that it has an ++ * Tibetan OpenType font. ++ * ++ * @param fontInstance - the font ++ * @param scriptCode - the script ++ * @param langaugeCode - the language ++ * @param gsubTable - the GSUB table ++ * @param success - set to an error code if the operation fails ++ * ++ * @see LayoutEngine::layoutEngineFactory ++ * @see OpenTypeLayoutEngine ++ * @see ScriptAndLangaugeTags.h for script and language codes ++ * ++ * @internal ++ */ ++ TibetanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success); ++ ++ /** ++ * This constructor is used when the font requires a "canned" GSUB table which can't be known ++ * until after this constructor has been invoked. ++ * ++ * @param fontInstance - the font ++ * @param scriptCode - the script ++ * @param langaugeCode - the language ++ * @param success - set to an error code if the operation fails ++ * ++ * @see OpenTypeLayoutEngine ++ * @see ScriptAndLangaugeTags.h for script and language codes ++ * ++ * @internal ++ */ ++ TibetanOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, ++ le_int32 typoFlags, LEErrorCode &success); ++ ++ /** ++ * The destructor, virtual for correct polymorphic invocation. ++ * ++ * @internal ++ */ ++ virtual ~TibetanOpenTypeLayoutEngine(); ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for the actual class. ++ * ++ * @internal ICU 3.6 ++ */ ++ virtual UClassID getDynamicClassID() const; ++ ++ /** ++ * ICU "poor man's RTTI", returns a UClassID for this class. ++ * ++ * @internal ICU 3.6 ++ */ ++ static UClassID getStaticClassID(); ++ ++protected: ++ ++ /** ++ * This method does Tibetan OpenType character processing. It assigns the OpenType feature ++ * tags to the characters, and may generate output characters which have been reordered. ++ * It may also split some vowels, resulting in more output characters than input characters. ++ * ++ * Input parameters: ++ * @param chars - the input character context ++ * @param offset - the index of the first character to process ++ * @param count - the number of characters to process ++ * @param max - the number of characters in the input context ++ * @param rightToLeft - <code>TRUE</code> if the characters are in a right to left directional run ++ * @param glyphStorage - the glyph storage object. The glyph and character index arrays will be set. ++ * the auxillary data array will be set to the feature tags. ++ * ++ * Output parameters: ++ * @param success - set to an error code if the operation fails ++ * ++ * @return the output character count ++ * ++ * @internal ++ */ ++ virtual le_int32 characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, ++ LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success); ++ ++}; ++ ++U_NAMESPACE_END ++#endif ++ +diff --git a/src/share/native/sun/font/layout/TibetanReordering.cpp b/src/share/native/sun/font/layout/TibetanReordering.cpp +new file mode 100644 +--- /dev/null ++++ jdk/src/share/native/sun/font/layout/TibetanReordering.cpp +@@ -0,0 +1,414 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Oracle designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Oracle in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* ++ * ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved ++ * ++ * Developed at DIT - Government of Bhutan ++ * ++ * Contact person: Pema Geyleg - <pema_geyleg@druknet.bt> ++ * ++ * This file is a modification of the ICU file KhmerReordering.cpp ++ * by Jens Herden and Javier Sola who have given all their possible rights to IBM and the Governement of Bhutan ++ * A first module for Dzongkha was developed by Karunakar under Panlocalisation funding. ++ * Assistance for this module has been received from Namgay Thinley, Christopher Fynn and Javier Sola ++ * ++ */ ++ ++//#include <stdio.h> ++#include "LETypes.h" ++#include "OpenTypeTables.h" ++#include "TibetanReordering.h" ++#include "LEGlyphStorage.h" ++ ++ ++U_NAMESPACE_BEGIN ++ ++// Characters that get refered to by name... ++enum ++{ ++ C_DOTTED_CIRCLE = 0x25CC, ++ C_PRE_NUMBER_MARK = 0x0F3F ++ }; ++ ++ ++enum ++{ ++ // simple classes, they are used in the statetable (in this file) to control the length of a syllable ++ // they are also used to know where a character should be placed (location in reference to the base character) ++ // and also to know if a character, when independtly displayed, should be displayed with a dotted-circle to ++ // indicate error in syllable construction ++ _xx = TibetanClassTable::CC_RESERVED, ++ _ba = TibetanClassTable::CC_BASE, ++ _sj = TibetanClassTable::CC_SUBJOINED | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_BELOW, ++ _tp = TibetanClassTable::CC_TSA_PHRU | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_ABOVE, ++ _ac = TibetanClassTable::CC_A_CHUNG | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_BELOW, ++ _cs = TibetanClassTable::CC_COMP_SANSKRIT | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_BELOW, ++ _ha = TibetanClassTable::CC_HALANTA | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_BELOW, ++ _bv = TibetanClassTable::CC_BELOW_VOWEL | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_BELOW, ++ _av = TibetanClassTable::CC_ABOVE_VOWEL | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_ABOVE, ++ _an = TibetanClassTable::CC_ANUSVARA | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_ABOVE, ++ _cb = TibetanClassTable::CC_CANDRABINDU | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_ABOVE, ++ _vs = TibetanClassTable::CC_VISARGA | TibetanClassTable::CF_DOTTED_CIRCLE| TibetanClassTable::CF_POS_AFTER, ++ _as = TibetanClassTable::CC_ABOVE_S_MARK | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_ABOVE, ++ _bs = TibetanClassTable::CC_BELOW_S_MARK | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_BELOW, ++ _di = TibetanClassTable::CC_DIGIT | TibetanClassTable::CF_DIGIT, ++ _pd = TibetanClassTable::CC_PRE_DIGIT_MARK | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_PREDIGIT | TibetanClassTable::CF_POS_BEFORE , ++ _bd = TibetanClassTable::CC_POST_BELOW_DIGIT_M | TibetanClassTable::CF_DOTTED_CIRCLE | TibetanClassTable::CF_POS_AFTER ++}; ++ ++ ++// Character class tables ++//_xx Non Combining characters ++//_ba Base Consonants ++//_sj Subjoined consonants ++//_tp Tsa - phru ++//_ac A-chung, Vowel Lengthening mark ++//_cs Precomposed Sanskrit vowel + subjoined consonants ++//_ha Halanta/Virama ++//_bv Below vowel ++//_av above vowel ++//_an Anusvara ++//_cb Candrabindu ++//_vs Visaraga/Post mark ++//_as Upper Stress marks ++//_bs Lower Stress marks ++//_di Digit ++//_pd Number pre combining, Needs reordering ++//_bd Other number combining marks ++ ++static const TibetanClassTable::CharClass tibetanCharClasses[] = ++{ ++ // 0 1 2 3 4 5 6 7 8 9 a b c d e f ++ _xx, _ba, _xx, _xx, _ba, _ba, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0F00 - 0F0F 0 ++ _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _bd, _bd, _xx, _xx, _xx, _xx, _xx, _xx, // 0F10 - 0F1F 1 ++ _di, _di, _di, _di, _di, _di, _di, _di, _di, _di, _xx, _xx, _xx, _xx, _xx, _xx, // 0F20 - 0F2F 2 ++ _xx, _xx, _xx, _xx, _xx, _bs, _xx, _bs, _xx, _tp, _xx, _xx, _xx, _xx, _bd, _pd, // 0F30 - 0F3F 3 ++ _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _xx, _ba, _ba, _ba, _ba, _ba, _ba, _ba, // 0F40 - 0F4F 4 ++ _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, // 0F50 - 0F5F 5 ++ _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _ba, _xx, _xx, _xx, _xx, _xx, // 0F60 - 0F6F 6 ++ _xx, _ac, _av, _cs, _bv, _bv, _cs, _cs, _cs, _cs, _av, _av, _av, _av, _an, _vs, // 0F70 - 0F7F 7 ++ _av, _cs, _cb, _cb, _ha, _xx, _as, _as, _ba, _ba, _ba, _ba, _xx, _xx, _xx, _xx, // 0F80 - 0F8F 8 ++ _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _xx, _sj, _sj, _sj, _sj, _sj, _sj, _sj, // 0F90 - 0F9F 9 ++ _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, // 0FA0 - 0FAF a ++ _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _sj, _xx, _sj, _sj, // 0FB0 - 0FBF b ++ _xx, _xx, _xx, _xx, _xx, _xx, _bs, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0FC0 - 0FCF c ++ _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx,// 0FD0 - 0FDF d ++ _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0FE0 - 0FEF e ++ _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, // 0FF0 - 0FFF f ++}; ++ ++ ++// ++// Tibetan Class Tables ++// ++ ++// ++// The range of characters defined in the above table is defined here. For Tibetan 0F00 to 0FFF ++// Even if the Tibetan range is bigger, most of the characters are not combinable, and therefore treated ++// as _xx ++static const TibetanClassTable tibetanClassTable = {0x0F00, 0x0FFF, tibetanCharClasses}; ++ ++ ++// Below we define how a character in the input string is either in the tibetanCharClasses table ++// (in which case we get its type back), or an unknown object in which case we get _xx (CC_RESERVED) back ++TibetanClassTable::CharClass TibetanClassTable::getCharClass(LEUnicode ch) const ++{ ++ if (ch < firstChar || ch > lastChar) { ++ return CC_RESERVED; ++ } ++ ++ return classTable[ch - firstChar]; ++} ++ ++const TibetanClassTable *TibetanClassTable::getTibetanClassTable() ++{ ++ return &tibetanClassTable; ++} ++ ++ ++ ++class TibetanReorderingOutput : public UMemory { ++private: ++ le_int32 fSyllableCount; ++ le_int32 fOutIndex; ++ LEUnicode *fOutChars; ++ ++ LEGlyphStorage &fGlyphStorage; ++ ++ ++public: ++ TibetanReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage) ++ : fSyllableCount(0), fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage) ++ { ++ // nothing else to do... ++ } ++ ++ ~TibetanReorderingOutput() ++ { ++ // nothing to do here... ++ } ++ ++ void reset() ++ { ++ fSyllableCount += 1; ++ } ++ ++ void writeChar(LEUnicode ch, le_uint32 charIndex, FeatureMask featureMask) ++ { ++ LEErrorCode success = LE_NO_ERROR; ++ ++ fOutChars[fOutIndex] = ch; ++ ++ fGlyphStorage.setCharIndex(fOutIndex, charIndex, success); ++ fGlyphStorage.setAuxData(fOutIndex, featureMask, success); ++ ++ fOutIndex += 1; ++ } ++ ++ le_int32 getOutputIndex() ++ { ++ return fOutIndex; ++ } ++}; ++ ++ ++//TODO remove unused flags ++#define ccmpFeatureTag LE_CCMP_FEATURE_TAG ++#define blwfFeatureTag LE_BLWF_FEATURE_TAG ++#define pstfFeatureTag LE_PSTF_FEATURE_TAG ++#define presFeatureTag LE_PRES_FEATURE_TAG ++#define blwsFeatureTag LE_BLWS_FEATURE_TAG ++#define abvsFeatureTag LE_ABVS_FEATURE_TAG ++#define pstsFeatureTag LE_PSTS_FEATURE_TAG ++ ++#define blwmFeatureTag LE_BLWM_FEATURE_TAG ++#define abvmFeatureTag LE_ABVM_FEATURE_TAG ++#define distFeatureTag LE_DIST_FEATURE_TAG ++ ++#define prefFeatureTag LE_PREF_FEATURE_TAG ++#define abvfFeatureTag LE_ABVF_FEATURE_TAG ++#define cligFeatureTag LE_CLIG_FEATURE_TAG ++#define mkmkFeatureTag LE_MKMK_FEATURE_TAG ++ ++// Shaping features ++#define prefFeatureMask 0x80000000UL ++#define blwfFeatureMask 0x40000000UL ++#define abvfFeatureMask 0x20000000UL ++#define pstfFeatureMask 0x10000000UL ++#define presFeatureMask 0x08000000UL ++#define blwsFeatureMask 0x04000000UL ++#define abvsFeatureMask 0x02000000UL ++#define pstsFeatureMask 0x01000000UL ++#define cligFeatureMask 0x00800000UL ++#define ccmpFeatureMask 0x00040000UL ++ ++// Positioning features ++#define distFeatureMask 0x00400000UL ++#define blwmFeatureMask 0x00200000UL ++#define abvmFeatureMask 0x00100000UL ++#define mkmkFeatureMask 0x00080000UL ++ ++#define tagPref (ccmpFeatureMask | prefFeatureMask | presFeatureMask | cligFeatureMask | distFeatureMask) ++#define tagAbvf (ccmpFeatureMask | abvfFeatureMask | abvsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | mkmkFeatureMask) ++#define tagPstf (ccmpFeatureMask | blwfFeatureMask | blwsFeatureMask | prefFeatureMask | presFeatureMask | pstfFeatureMask | pstsFeatureMask | cligFeatureMask | distFeatureMask | blwmFeatureMask) ++#define tagBlwf (ccmpFeatureMask | blwfFeatureMask | blwsFeatureMask | cligFeatureMask | distFeatureMask | blwmFeatureMask | mkmkFeatureMask) ++#define tagDefault (ccmpFeatureMask | prefFeatureMask | blwfFeatureMask | presFeatureMask | blwsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | blwmFeatureMask | mkmkFeatureMask) ++ ++ ++ ++// These are in the order in which the features need to be applied ++// for correct processing ++static const FeatureMap featureMap[] = ++{ ++ // Shaping features ++ {ccmpFeatureTag, ccmpFeatureMask}, ++ {prefFeatureTag, prefFeatureMask}, ++ {blwfFeatureTag, blwfFeatureMask}, ++ {abvfFeatureTag, abvfFeatureMask}, ++ {pstfFeatureTag, pstfFeatureMask}, ++ {presFeatureTag, presFeatureMask}, ++ {blwsFeatureTag, blwsFeatureMask}, ++ {abvsFeatureTag, abvsFeatureMask}, ++ {pstsFeatureTag, pstsFeatureMask}, ++ {cligFeatureTag, cligFeatureMask}, ++ ++ // Positioning features ++ {distFeatureTag, distFeatureMask}, ++ {blwmFeatureTag, blwmFeatureMask}, ++ {abvmFeatureTag, abvmFeatureMask}, ++ {mkmkFeatureTag, mkmkFeatureMask}, ++}; ++ ++static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap); ++ ++// The stateTable is used to calculate the end (the length) of a well ++// formed Tibetan Syllable. ++// ++// Each horizontal line is ordered exactly the same way as the values in TibetanClassTable ++// CharClassValues in TibetanReordering.h This coincidence of values allows the ++// follow up of the table. ++// ++// Each line corresponds to a state, which does not necessarily need to be a type ++// of component... for example, state 2 is a base, with is always a first character ++// in the syllable, but the state could be produced a consonant of any type when ++// it is the first character that is analysed (in ground state). ++// ++static const le_int8 tibetanStateTable[][TibetanClassTable::CC_COUNT] = ++{ ++ ++ ++ //Dzongkha state table ++ //xx ba sj tp ac cs ha bv av an cb vs as bs di pd bd ++ { 1, 2, 4, 3, 8, 7, 9, 10, 14, 13, 17, 18, 19, 19, 20, 21, 21,}, // 0 - ground state ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,}, // 1 - exit state (or sign to the right of the syllable) ++ {-1, -1, 4, 3, 8, 7, 9, 10, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 2 - Base consonant ++ {-1, -1, 5, -1, 8, 7, -1, 10, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 3 - Tsa phru after base ++ {-1, -1, 4, 6, 8, 7, 9, 10, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 4 - Subjoined consonant after base ++ {-1, -1, 5, -1, 8, 7, -1, 10, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 5 - Subjoined consonant after tsa phru ++ {-1, -1, -1, -1, 8, 7, -1, 10, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 6 - Tsa phru after subjoined consonant ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 19, 19, -1, -1, -1,}, // 7 - Pre Composed Sanskrit ++ {-1, -1, -1, -1, -1, -1, -1, 10, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 8 - A-chung ++ {-1, -1, -1, -1, -1, -1, -1, -1, 14, 13, 17, -1, 19, 19, -1, -1, -1,}, // 9 - Halanta ++ {-1, -1, -1, -1, -1, -1, -1, 11, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 10 - below vowel 1 ++ {-1, -1, -1, -1, -1, -1, -1, 12, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 11 - below vowel 2 ++ {-1, -1, -1, -1, -1, -1, -1, -1, 14, 13, 17, 18, 19, 19, -1, -1, -1,}, // 12 - below vowel 3 ++ {-1, -1, -1, -1, -1, -1, -1, -1, 14, 17, 17, 18, 19, 19, -1, -1, -1,}, // 13 - Anusvara before vowel ++ {-1, -1, -1, -1, -1, -1, -1, -1, 15, 17, 17, 18, 19, 19, -1, -1, -1,}, // 14 - above vowel 1 ++ {-1, -1, -1, -1, -1, -1, -1, -1, 16, 17, 17, 18, 19, 19, -1, -1, -1,}, // 15 - above vowel 2 ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, 17, 17, 18, 19, 19, -1, -1, -1,}, // 16 - above vowel 3 ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 18, 19, 19, -1, -1, -1,}, // 17 - Anusvara or Candrabindu after vowel ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 19, 19, -1, -1, -1,}, // 18 - Visarga ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,}, // 19 - strss mark ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 21, 21,}, // 20 - digit ++ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,}, // 21 - digit mark ++ ++ ++}; ++ ++ ++const FeatureMap *TibetanReordering::getFeatureMap(le_int32 &count) ++{ ++ count = featureMapCount; ++ ++ return featureMap; ++} ++ ++ ++// Given an input string of characters and a location in which to start looking ++// calculate, using the state table, which one is the last character of the syllable ++// that starts in the starting position. ++le_int32 TibetanReordering::findSyllable(const TibetanClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount) ++{ ++ le_int32 cursor = prev; ++ le_int8 state = 0; ++ ++ while (cursor < charCount) { ++ TibetanClassTable::CharClass charClass = (classTable->getCharClass(chars[cursor]) & TibetanClassTable::CF_CLASS_MASK); ++ ++ state = tibetanStateTable[state][charClass]; ++ ++ if (state < 0) { ++ break; ++ } ++ ++ cursor += 1; ++ } ++ ++ return cursor; ++} ++ ++ ++// This is the real reordering function as applied to the Tibetan language ++ ++le_int32 TibetanReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32, ++ LEUnicode *outChars, LEGlyphStorage &glyphStorage) ++{ ++ const TibetanClassTable *classTable = TibetanClassTable::getTibetanClassTable(); ++ ++ TibetanReorderingOutput output(outChars, glyphStorage); ++ TibetanClassTable::CharClass charClass; ++ le_int32 i, prev = 0; ++ ++ // This loop only exits when we reach the end of a run, which may contain ++ // several syllables. ++ while (prev < charCount) { ++ le_int32 syllable = findSyllable(classTable, chars, prev, charCount); ++ ++ output.reset(); ++ ++ // shall we add a dotted circle? ++ // If in the position in which the base should be (first char in the string) there is ++ // a character that has the Dotted circle flag (a character that cannot be a base) ++ // then write a dotted circle ++ if (classTable->getCharClass(chars[prev]) & TibetanClassTable::CF_DOTTED_CIRCLE) { ++ output.writeChar(C_DOTTED_CIRCLE, prev, tagDefault); ++ } ++ ++ // copy the rest to output, inverting the pre-number mark if present after a digit. ++ for (i = prev; i < syllable; i += 1) { ++ charClass = classTable->getCharClass(chars[i]); ++ ++ if ((TibetanClassTable::CF_DIGIT & charClass) ++ && ( classTable->getCharClass(chars[i+1]) & TibetanClassTable::CF_PREDIGIT)) ++ { ++ output.writeChar(C_PRE_NUMBER_MARK, i, tagPref); ++ output.writeChar(chars[i], i+1 , tagPref); ++ i += 1; ++ } else { ++ switch (charClass & TibetanClassTable::CF_POS_MASK) { ++ ++ // If the present character is a number, and the next character is a pre-number combining mark ++ // then the two characters are reordered ++ ++ case TibetanClassTable::CF_POS_ABOVE : ++ output.writeChar(chars[i], i, tagAbvf); ++ break; ++ ++ case TibetanClassTable::CF_POS_AFTER : ++ output.writeChar(chars[i], i, tagPstf); ++ break; ++ ++ case TibetanClassTable::CF_POS_BELOW : ++ output.writeChar(chars[i], i, tagBlwf); ++ break; ++ ++ default: ++ // default - any other characters ++ output.writeChar(chars[i], i, tagDefault); ++ break; ++ } // switch ++ } // if ++ } // for ++ ++ prev = syllable; // move the pointer to the start of next syllable ++ } ++ ++ return output.getOutputIndex(); ++} ++ ++ ++U_NAMESPACE_END +diff --git a/src/share/native/sun/font/layout/TibetanReordering.h b/src/share/native/sun/font/layout/TibetanReordering.h +new file mode 100644 +--- /dev/null ++++ jdk/src/share/native/sun/font/layout/TibetanReordering.h +@@ -0,0 +1,176 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Oracle designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Oracle in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* ++ * ++ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved ++ * ++ * Developed at DIT - Government of Bhutan ++ * ++ * Contact person: Pema Geyleg - <pema_geyleg@druknet.bt> ++ * ++ * This file is a modification of the ICU file KhmerReordering.h ++ * by Jens Herden and Javier Sola who have given all their possible rights to IBM and the Governement of Bhutan ++ * A first module for Dzongkha was developed by Karunakar under Panlocalisation funding. ++ * Assistance for this module has been received from Namgay Thinley, Christopher Fynn and Javier Sola ++ * ++ */ ++ ++#ifndef __TIBETANREORDERING_H ++#define __TIBETANORDERING_H ++ ++/** ++ * \file ++ * \internal ++ */ ++ ++// #include "LETypes.h" ++// #include "OpenTypeTables.h" ++ ++U_NAMESPACE_BEGIN ++ ++class LEGlyphStorage; ++ ++// Vocabulary ++// Base -> A consonant in its full (not subscript) form. It is the ++// center of the syllable, it can be souranded by subjoined consonants, vowels, ++// signs... but there is only one base in a stack, it has to be coded as ++// the first character of the syllable.Included here are also groups of base + subjoined ++// which are represented by one single code point in unicode (e.g. 0F43) Also other characters that might take ++// subjoined consonants or other combining characters. ++// Subjoined -> Subjoined consonants and groups of subjoined consonants which have a single code-point ++// to repersent the group (even if each subjoined consonant is represented independently ++// by anothe code-point ++// Tsa Phru --> Tsa Phru character, Bhutanese people will always place it right after the base, but sometimes, due to ++// "normalization" ++// is placed after all the subjoined consonants, and it is also permitted there. ++// A Chung Vowel lengthening mark --> . 0F71 It is placed after the base and any subjoined consonants but before any vowels ++// Precomposed Sanskrit vowels --> The are combinations of subjoined consonants + vowels that have been assigned ++// a given code-point (in spite of each single part of them having also a code-point ++// They are avoided, and users are encouraged to use the combination of code-points that ++// represents the same sound instead of using this combined characters. This is included here ++// for compatibility with possible texts that use them (they are not in the Dzongkha keyboard). ++// Halanta -> The Halanta or Virama character 0F84 indicates that a consonant should not use its inheernt vowel, ++// in spite of not having other vowels present. It is usually placed immediatly after a base consonant, ++// but in some special cases it can also be placed after a subjoined consonant, so this is also ++// permitted in this algorithm. (Halanta is always displayed in Tibetan not used as a connecting char) ++// ++// Subjoined vowels -> Dependent vowels (matras) placed below the base and below all subjoined consonants. There ++// might be as much as three subjoined vowels in a given stack (only one in general text, but up ++// to three for abreviations, they have to be permitted). ++// Superscript vowels -> There are three superscript vowels, and they can be repeated or combined (up to three ++// times. They can combine with subjoined vowels, and are always coded after these. ++// Anusvara --> Nasalisation sign. Traditioinally placed in absence of vowels, but also after vowels. In some ++// special cases it can be placed before a vowel, so this is also permitted ++// Candrabindu -> Forms of the Anusvara with different glyphs (and different in identity) which can be placed ++// without vowel or after the vowel, but never before. Cannot combine with Anusvara. ++// Stress marks -> Marks placed above or below a syllable, affecting the whole syllable. They are combining ++// marks, so they have to be attached to a specific stack. The are using to emphasise a syllable. ++// ++// Digits -> Digits are not considered as non-combining characters because there are a few characters which ++// combine with them, so they have to be considered independently. ++// Digit combining marks -> dependent marks that combine with digits. ++// ++// TODO ++// There are a number of characters in the CJK block that are used in Tibetan script, two of these are symbols ++// are used as bases for combining glyphs, and have not been encoded in Tibetan. As these characters are outside ++// of the tibetan block, they have not been treated in this program. ++ ++ ++struct TibetanClassTable // This list must include all types of components that can be used inside a syllable ++{ ++ enum CharClassValues // order is important here! This order must be the same that is found in each horizontal ++ // line in the statetable for Tibetan (file TibetanReordering.cpp). It assigns one number ++ // to each type of character that has to be considered when analysing the order in which ++ // characters can be placed ++ { ++ CC_RESERVED = 0, //Non Combining Characters ++ CC_BASE = 1, // Base Consonants, Base Consonants with Subjoined attached in code point, Sanskrit base marks ++ CC_SUBJOINED = 2, // Subjoined Consonats, combination of more than Subjoined Consonants in the code point ++ CC_TSA_PHRU = 3, // Tsa-Phru character 0F39 ++ CC_A_CHUNG = 4, // Vowel Lenthening a-chung mark 0F71 ++ CC_COMP_SANSKRIT = 5, // Precomposed Sanskrit vowels including Subjoined characters and vowels ++ CC_HALANTA = 6, // Halanta Character 0F84 ++ CC_BELOW_VOWEL = 7, // Subjoined vowels ++ CC_ABOVE_VOWEL = 8, // Superscript vowels ++ CC_ANUSVARA = 9, // Tibetan sign Rjes Su Nga Ro 0F7E ++ CC_CANDRABINDU = 10, // Tibetan sign Sna Ldan and Nyi Zla Naa Da 0F82, 0F83 ++ CC_VISARGA = 11, // Tibetan sign Rnam Bcad (0F7F) ++ CC_ABOVE_S_MARK = 12, // Stress Marks placed above the text ++ CC_BELOW_S_MARK = 13, // Stress Marks placed below the text ++ CC_DIGIT = 14, // Dzongkha Digits ++ CC_PRE_DIGIT_MARK = 15, // Mark placed before the digit ++ CC_POST_BELOW_DIGIT_M = 16, // Mark placed below or after the digit ++ CC_COUNT = 17 // This is the number of character classes ++ }; ++ ++ enum CharClassFlags ++ { ++ CF_CLASS_MASK = 0x0000FFFF, ++ ++ CF_DOTTED_CIRCLE = 0x04000000, // add a dotted circle if a character with this flag is the first in a syllable ++ CF_DIGIT = 0x01000000, // flag to speed up comparaisson ++ CF_PREDIGIT = 0x02000000, // flag to detect pre-digit marks for reordering ++ ++ // position flags ++ CF_POS_BEFORE = 0x00080000, ++ CF_POS_BELOW = 0x00040000, ++ CF_POS_ABOVE = 0x00020000, ++ CF_POS_AFTER = 0x00010000, ++ CF_POS_MASK = 0x000f0000 ++ }; ++ ++ typedef le_uint32 CharClass; ++ ++ typedef le_int32 ScriptFlags; ++ ++ LEUnicode firstChar; // for Tibetan this will become xOF00 ++ LEUnicode lastChar; // and this x0FFF ++ const CharClass *classTable; ++ ++ CharClass getCharClass(LEUnicode ch) const; ++ ++ static const TibetanClassTable *getTibetanClassTable(); ++}; ++ ++ ++class TibetanReordering /* not : public UObject because all methods are static */ { ++public: ++ static le_int32 reorder(const LEUnicode *theChars, le_int32 charCount, le_int32 scriptCode, ++ LEUnicode *outChars, LEGlyphStorage &glyphStorage); ++ ++ static const FeatureMap *getFeatureMap(le_int32 &count); ++ ++private: ++ // do not instantiate ++ TibetanReordering(); ++ ++ static le_int32 findSyllable(const TibetanClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount); ++ ++}; ++ ++ ++U_NAMESPACE_END ++#endif +diff --git a/test/java/awt/font/TextLayout/TestOldHangul.java b/test/java/awt/font/TextLayout/TestOldHangul.java +new file mode 100644 +--- /dev/null ++++ jdk/test/java/awt/font/TextLayout/TestOldHangul.java +@@ -0,0 +1,83 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* @test @(#)TestOldHangul.java ++ * @summary Verify Old Hangul display ++ * @bug 6886358 ++ * @ignore Requires a special font installed. ++ */ ++ ++import javax.swing.*; ++import javax.swing.border.LineBorder; ++import java.awt.*; ++import java.awt.event.ActionEvent; ++ ++public class TestOldHangul { ++ public static void main(String[] args) { ++ SwingUtilities.invokeLater(new Runnable() { ++ public void run() { ++ new TestOldHangul().run(); ++ } ++ }); ++ } ++ public static boolean AUTOMATIC_TEST=true; // true; run test automatically, else manually at button push ++ ++ private void run() { ++ Font ourFont = null; ++ final String fontName = "UnBatangOdal.ttf"; // download from http://chem.skku.ac.kr/~wkpark/project/font/GSUB/UnbatangOdal/ and place in {user.home}/fonts/ ++ try { ++ ourFont = Font.createFont(Font.TRUETYPE_FONT, new java.io.File(new java.io.File(System.getProperty("user.home"),"fonts"), fontName)); ++ ourFont = ourFont.deriveFont((float)48.0); ++ } catch(Throwable t) { ++ t.printStackTrace(); ++ System.err.println("Fail: " + t); ++ return; ++ } ++ JFrame frame = new JFrame(System.getProperty("java.version")); ++ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ++ JPanel panel = new JPanel(); ++ final JTextArea label = new JTextArea("(empty)"); ++ label.setSize(400, 300); ++ label.setBorder(new LineBorder(Color.black)); ++ label.setFont(ourFont); ++ final String str = "\u110A\u119E\u11B7\u0020\u1112\u119E\u11AB\uAE00\u0020\u1100\u119E\u11F9\u0020\u112B\u119E\u11BC\n"; ++ ++ if(AUTOMATIC_TEST) { /* run the test automatically (else, manually) */ ++ label.setText(str); ++ } else { ++ JButton button = new JButton("Old Hangul"); ++ button.addActionListener(new AbstractAction() { ++ public void actionPerformed(ActionEvent actionEvent) { ++ label.setText(str); ++ } ++ }); ++ panel.add(button); ++ } ++ panel.add(label); ++ ++ frame.getContentPane().add(panel); ++ frame.pack(); ++ frame.setVisible(true); ++ } ++} ++ +diff --git a/test/java/awt/font/TextLayout/TestTibetan.java b/test/java/awt/font/TextLayout/TestTibetan.java +new file mode 100644 +--- /dev/null ++++ jdk/test/java/awt/font/TextLayout/TestTibetan.java +@@ -0,0 +1,87 @@ ++/* ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++/* @test @(#)TestTibetan.java ++ * @summary verify tibetan output ++ * @bug 6886358 ++ * @ignore Requires a special font installed ++ */ ++ ++import javax.swing.*; ++import javax.swing.border.LineBorder; ++import java.awt.*; ++import java.awt.event.ActionEvent; ++ ++public class TestTibetan { ++ public static void main(String[] args) { ++ SwingUtilities.invokeLater(new Runnable() { ++ public void run() { ++ new TestTibetan().run(); ++ } ++ }); ++ } ++ public static boolean AUTOMATIC_TEST=true; // true; run test automatically, else manually at button push ++ ++ private void run() { ++ Font ourFont = null; ++ try { ++ //For best results: Font from: http://download.savannah.gnu.org/releases/free-tibetan/jomolhari/ ++ // place in $(user.home)/fonts/ ++ ourFont = Font.createFont(Font.TRUETYPE_FONT, new java.io.File(new java.io.File(System.getProperty("user.home"),"fonts"), "Jomolhari-alpha3c-0605331.ttf")); ++ ++ //ourFont = new Font("serif",Font.PLAIN, 24); ++ ourFont = ourFont.deriveFont((float)24.0); ++ } catch(Throwable t) { ++ t.printStackTrace(); ++ System.err.println("Fail: " + t); ++ return; ++ } ++ JFrame frame = new JFrame(System.getProperty("java.version")); ++ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ++ JPanel panel = new JPanel(); ++ final JTextArea label = new JTextArea("(empty)"); ++ label.setSize(400, 300); ++ label.setBorder(new LineBorder(Color.black)); ++ label.setFont(ourFont); ++ ++ final String str = "\u0F04\u0F05\u0F0D\u0F0D\u0020\u0F4F\u0F72\u0F53\u0F0B\u0F4F\u0F72\u0F53\u0F0B\u0F42\u0FB1\u0F72\u0F0B\u0F51\u0F54\u0F60\u0F0B\u0F62\u0FA9\u0F63"; // TinTin. ++ ++ if(AUTOMATIC_TEST) { /* run the test automatically (else, manually) */ ++ label.setText(str); ++ } else { ++ JButton button = new JButton("Set Char x0DDD"); ++ button.addActionListener(new AbstractAction() { ++ public void actionPerformed(ActionEvent actionEvent) { ++ label.setText(str); ++ } ++ }); ++ panel.add(button); ++ } ++ panel.add(label); ++ ++ frame.getContentPane().add(panel); ++ frame.pack(); ++ frame.setVisible(true); ++ } ++} ++ diff --git a/java/openjdk6/files/icedtea/openjdk/6963811-deadlock_fix.patch b/java/openjdk6/files/icedtea/openjdk/6963811-deadlock_fix.patch new file mode 100644 index 000000000000..50e4c6d7d67a --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/6963811-deadlock_fix.patch @@ -0,0 +1,42 @@ +# HG changeset patch +# User andrew +# Date 1365711839 -3600 +# Node ID df591e0dfd349dc5986cc17949939c588d5a9690 +# Parent 06255d9f82761abc74c30f31fda00968ffef4bc3 +6963811: Deadlock-prone locking changes in Introspector +Reviewed-by: peterz, rupashka + +diff --git a/src/share/classes/java/beans/Introspector.java b/src/share/classes/java/beans/Introspector.java +--- jdk/src/share/classes/java/beans/Introspector.java ++++ jdk/src/share/classes/java/beans/Introspector.java +@@ -170,21 +170,24 @@ + if (!ReflectUtil.isPackageAccessible(beanClass)) { + return (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo(); + } ++ WeakCache<Class<?>, BeanInfo> beanInfoCache; ++ BeanInfo beanInfo; + synchronized (BEANINFO_CACHE) { +- WeakCache<Class<?>, BeanInfo> beanInfoCache = +- (WeakCache<Class<?>, BeanInfo>) AppContext.getAppContext().get(BEANINFO_CACHE); ++ beanInfoCache = (WeakCache<Class<?>, BeanInfo>) AppContext.getAppContext().get(BEANINFO_CACHE); + + if (beanInfoCache == null) { + beanInfoCache = new WeakCache<Class<?>, BeanInfo>(); + AppContext.getAppContext().put(BEANINFO_CACHE, beanInfoCache); + } +- BeanInfo beanInfo = beanInfoCache.get(beanClass); +- if (beanInfo == null) { +- beanInfo = (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo(); ++ beanInfo = beanInfoCache.get(beanClass); ++ } ++ if (beanInfo == null) { ++ beanInfo = (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo(); ++ synchronized (BEANINFO_CACHE) { + beanInfoCache.put(beanClass, beanInfo); + } +- return beanInfo; + } ++ return beanInfo; + } + + /** diff --git a/java/openjdk6/files/icedtea/openjdk/7017324-kerning_crash.patch b/java/openjdk6/files/icedtea/openjdk/7017324-kerning_crash.patch new file mode 100644 index 000000000000..1794154c83e3 --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/7017324-kerning_crash.patch @@ -0,0 +1,101 @@ +# HG changeset patch +# User andrew +# Date 1365745184 -3600 +# Node ID 5ed9acc1f6be298713f10ad71c33564d48f46555 +# Parent d79bfc0c6371d1174209585a8d2bf08e3f3625f9 +7017324: Kerning crash in JDK 7 since ICU layout update +Reviewed-by: igor, prr + +diff --git a/src/share/native/sun/font/layout/KernTable.cpp b/src/share/native/sun/font/layout/KernTable.cpp +--- jdk/src/share/native/sun/font/layout/KernTable.cpp ++++ jdk/src/share/native/sun/font/layout/KernTable.cpp +@@ -217,7 +217,7 @@ + // all the elements ahead of time and store them in the font + + const PairInfo* p = pairsSwapped; +- const PairInfo* tp = (const PairInfo*)(p + rangeShift); ++ const PairInfo* tp = (const PairInfo*)(p + (rangeShift/KERN_PAIRINFO_SIZE)); /* rangeshift is in original table bytes */ + if (key > tp->key) { + p = tp; + } +@@ -229,7 +229,7 @@ + le_uint32 probe = searchRange; + while (probe > 1) { + probe >>= 1; +- tp = (const PairInfo*)(p + probe); ++ tp = (const PairInfo*)(p + (probe/KERN_PAIRINFO_SIZE)); + le_uint32 tkey = tp->key; + #if DEBUG + fprintf(stdout, " %.3d (%0.8x)\n", (tp - pairsSwapped), tkey); +diff --git a/test/java/awt/font/TextLayout/KernCrash.java b/test/java/awt/font/TextLayout/KernCrash.java +new file mode 100644 +--- /dev/null ++++ jdk/test/java/awt/font/TextLayout/KernCrash.java +@@ -0,0 +1,67 @@ ++/* ++ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ */ ++ ++import java.io.*; ++import java.awt.*; ++import java.awt.font.*; ++import java.util.*; ++ ++/** ++ * Shows (top) with kerning, (middle) without, (bottom) also without. ++ * ++ * @bug 7017324 ++ */ ++public class KernCrash extends Frame { ++ private static Font font0; ++ private static Font font1; ++ private static Font font2; ++ ++ public static void main(String[] args) throws Exception { ++ HashMap attrs = new HashMap(); ++ font0 = Font.createFont(Font.TRUETYPE_FONT, new File("Vera.ttf")); ++ System.out.println("using " + font0); ++ attrs.put(TextAttribute.SIZE, new Float(58f)); ++ font1 = font0.deriveFont(attrs); ++ attrs.put(TextAttribute.KERNING, TextAttribute.KERNING_ON); ++ font2 = font0.deriveFont(attrs); ++ ++ KernCrash f = new KernCrash(); ++ f.setTitle("Kerning Crash"); ++ f.setSize(600, 300); ++ f.setForeground(Color.black); ++ f.show(); ++ } ++ ++ public void paint(Graphics g) { ++ Graphics2D g2 = (Graphics2D)g; ++ FontRenderContext frc = g2.getFontRenderContext(); ++ TextLayout layout = new TextLayout("text", font2, frc); ++ layout.draw(g2, 10, 150); ++ ++ String s = "WAVATastic"; ++ TextLayout layout2 = new TextLayout(s, font1, frc); ++ layout2.draw(g2, 10, 200); ++ TextLayout layout3 = new TextLayout(s, font2, frc); ++ layout3.draw(g2, 10, 100); ++ } ++} diff --git a/java/openjdk6/files/icedtea/openjdk/7032388-work_without_cmov_instruction.patch b/java/openjdk6/files/icedtea/openjdk/7032388-work_without_cmov_instruction.patch new file mode 100644 index 000000000000..532ad68b9565 --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/7032388-work_without_cmov_instruction.patch @@ -0,0 +1,178 @@ +--- hotspot/src/cpu/x86/vm/assembler_x86.cpp 2011-03-30 11:31:16.408872134 -0700 ++++ hotspot/src/cpu/x86/vm/assembler_x86.cpp 2011-03-30 11:31:16.084614406 -0700 +@@ -7769,6 +7769,28 @@ + } + } + ++void MacroAssembler::cmov32(Condition cc, Register dst, Address src) { ++ if (VM_Version::supports_cmov()) { ++ cmovl(cc, dst, src); ++ } else { ++ Label L; ++ jccb(negate_condition(cc), L); ++ movl(dst, src); ++ bind(L); ++ } ++} ++ ++void MacroAssembler::cmov32(Condition cc, Register dst, Register src) { ++ if (VM_Version::supports_cmov()) { ++ cmovl(cc, dst, src); ++ } else { ++ Label L; ++ jccb(negate_condition(cc), L); ++ movl(dst, src); ++ bind(L); ++ } ++} ++ + void MacroAssembler::verify_oop(Register reg, const char* s) { + if (!VerifyOops) return; + +@@ -9019,14 +9041,7 @@ + movl(result, cnt1); + subl(cnt1, cnt2); + push(cnt1); +- if (VM_Version::supports_cmov()) { +- cmovl(Assembler::lessEqual, cnt2, result); +- } else { +- Label GT_LABEL; +- jccb(Assembler::greater, GT_LABEL); +- movl(cnt2, result); +- bind(GT_LABEL); +- } ++ cmov32(Assembler::lessEqual, cnt2, result); + + // Is the minimum length zero? + testl(cnt2, cnt2); +--- hotspot/src/cpu/x86/vm/assembler_x86.hpp 2011-03-30 11:31:17.757655562 -0700 ++++ hotspot/src/cpu/x86/vm/assembler_x86.hpp 2011-03-30 11:31:17.553920606 -0700 +@@ -2244,10 +2244,13 @@ + + // Data + +- void cmov(Condition cc, Register dst, Register src) { LP64_ONLY(cmovq(cc, dst, src)) NOT_LP64(cmovl(cc, dst, src)); } ++ void cmov32( Condition cc, Register dst, Address src); ++ void cmov32( Condition cc, Register dst, Register src); + +- void cmovptr(Condition cc, Register dst, Address src) { LP64_ONLY(cmovq(cc, dst, src)) NOT_LP64(cmovl(cc, dst, src)); } +- void cmovptr(Condition cc, Register dst, Register src) { LP64_ONLY(cmovq(cc, dst, src)) NOT_LP64(cmovl(cc, dst, src)); } ++ void cmov( Condition cc, Register dst, Register src) { cmovptr(cc, dst, src); } ++ ++ void cmovptr(Condition cc, Register dst, Address src) { LP64_ONLY(cmovq(cc, dst, src)) NOT_LP64(cmov32(cc, dst, src)); } ++ void cmovptr(Condition cc, Register dst, Register src) { LP64_ONLY(cmovq(cc, dst, src)) NOT_LP64(cmov32(cc, dst, src)); } + + void movoop(Register dst, jobject obj); + void movoop(Address dst, jobject obj); +--- hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp 2011-03-30 11:31:18.743456717 -0700 ++++ hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp 2011-03-30 11:31:18.541656202 -0700 +@@ -23,6 +23,7 @@ + */ + + #include "precompiled.hpp" ++#include "asm/assembler.hpp" + #include "c1/c1_Compilation.hpp" + #include "c1/c1_LIRAssembler.hpp" + #include "c1/c1_MacroAssembler.hpp" +@@ -569,24 +570,13 @@ + __ lea (rdi, Address(rdi, rcx, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR))); + + // compute minimum length (in rax) and difference of lengths (on top of stack) +- if (VM_Version::supports_cmov()) { +- __ movl (rbx, Address(rbx, java_lang_String::count_offset_in_bytes())); +- __ movl (rax, Address(rax, java_lang_String::count_offset_in_bytes())); +- __ mov (rcx, rbx); +- __ subptr (rbx, rax); // subtract lengths +- __ push (rbx); // result +- __ cmov (Assembler::lessEqual, rax, rcx); +- } else { +- Label L; +- __ movl (rbx, Address(rbx, java_lang_String::count_offset_in_bytes())); +- __ movl (rcx, Address(rax, java_lang_String::count_offset_in_bytes())); +- __ mov (rax, rbx); +- __ subptr (rbx, rcx); +- __ push (rbx); +- __ jcc (Assembler::lessEqual, L); +- __ mov (rax, rcx); +- __ bind (L); +- } ++ __ movl (rbx, Address(rbx, java_lang_String::count_offset_in_bytes())); ++ __ movl (rax, Address(rax, java_lang_String::count_offset_in_bytes())); ++ __ mov (rcx, rbx); ++ __ subptr(rbx, rax); // subtract lengths ++ __ push (rbx); // result ++ __ cmov (Assembler::lessEqual, rax, rcx); ++ + // is minimum length 0? + Label noLoop, haveResult; + __ testptr (rax, rax); +--- hotspot/src/cpu/x86/vm/c1_Runtime1_x86.cpp 2011-03-30 11:31:19.824124145 -0700 ++++ hotspot/src/cpu/x86/vm/c1_Runtime1_x86.cpp 2011-03-30 11:31:19.606167752 -0700 +@@ -23,6 +23,7 @@ + */ + + #include "precompiled.hpp" ++#include "asm/assembler.hpp" + #include "c1/c1_Defs.hpp" + #include "c1/c1_MacroAssembler.hpp" + #include "c1/c1_Runtime1.hpp" +--- hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp 2011-03-30 11:31:20.910918826 -0700 ++++ hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp 2011-03-30 11:31:20.703693030 -0700 +@@ -23,6 +23,7 @@ + */ + + #include "precompiled.hpp" ++#include "asm/assembler.hpp" + #include "interpreter/interpreter.hpp" + #include "interpreter/interpreterRuntime.hpp" + #include "interpreter/templateTable.hpp" +@@ -1939,18 +1940,10 @@ + __ movl(temp, Address(array, h, Address::times_8, 0*wordSize)); + __ bswapl(temp); + __ cmpl(key, temp); +- if (VM_Version::supports_cmov()) { +- __ cmovl(Assembler::less , j, h); // j = h if (key < array[h].fast_match()) +- __ cmovl(Assembler::greaterEqual, i, h); // i = h if (key >= array[h].fast_match()) +- } else { +- Label set_i, end_of_if; +- __ jccb(Assembler::greaterEqual, set_i); // { +- __ mov(j, h); // j = h; +- __ jmp(end_of_if); // } +- __ bind(set_i); // else { +- __ mov(i, h); // i = h; +- __ bind(end_of_if); // } +- } ++ // j = h if (key < array[h].fast_match()) ++ __ cmov32(Assembler::less , j, h); ++ // i = h if (key >= array[h].fast_match()) ++ __ cmov32(Assembler::greaterEqual, i, h); + // while (i+1 < j) + __ bind(entry); + __ leal(h, Address(i, 1)); // i+1 +@@ -3478,22 +3471,14 @@ + + // find a free slot in the monitor block (result in rdx) + { Label entry, loop, exit; +- __ movptr(rcx, monitor_block_top); // points to current entry, starting with top-most entry +- __ lea(rbx, monitor_block_bot); // points to word before bottom of monitor block ++ __ movptr(rcx, monitor_block_top); // points to current entry, starting with top-most entry ++ ++ __ lea(rbx, monitor_block_bot); // points to word before bottom of monitor block + __ jmpb(entry); + + __ bind(loop); + __ cmpptr(Address(rcx, BasicObjectLock::obj_offset_in_bytes()), (int32_t)NULL_WORD); // check if current entry is used +- +-// TODO - need new func here - kbt +- if (VM_Version::supports_cmov()) { +- __ cmov(Assembler::equal, rdx, rcx); // if not used then remember entry in rdx +- } else { +- Label L; +- __ jccb(Assembler::notEqual, L); +- __ mov(rdx, rcx); // if not used then remember entry in rdx +- __ bind(L); +- } ++ __ cmovptr(Assembler::equal, rdx, rcx); // if not used then remember entry in rdx + __ cmpptr(rax, Address(rcx, BasicObjectLock::obj_offset_in_bytes())); // check if current entry is for same object + __ jccb(Assembler::equal, exit); // if same object then stop searching + __ addptr(rcx, entry_size); // otherwise advance to next entry diff --git a/java/openjdk6/files/icedtea/openjdk/7036559-concurrenthashmap_improvements.patch b/java/openjdk6/files/icedtea/openjdk/7036559-concurrenthashmap_improvements.patch new file mode 100644 index 000000000000..f710737912ef --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/7036559-concurrenthashmap_improvements.patch @@ -0,0 +1,1436 @@ +# HG changeset patch +# User dl +# Date 1303139440 -3600 +# Node ID 005c0c85b0decf18a90ff6c9601d1b9a2c0a3fa4 +# Parent 603e70836e74e5c18fc32279f7e4df5b4c63e0b6 +7036559: ConcurrentHashMap footprint and contention improvements +Reviewed-by: chegar + +diff --git a/src/share/classes/java/util/concurrent/ConcurrentHashMap.java b/src/share/classes/java/util/concurrent/ConcurrentHashMap.java +--- jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java ++++ jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java +@@ -105,7 +105,25 @@ + + /* + * The basic strategy is to subdivide the table among Segments, +- * each of which itself is a concurrently readable hash table. ++ * each of which itself is a concurrently readable hash table. To ++ * reduce footprint, all but one segments are constructed only ++ * when first needed (see ensureSegment). To maintain visibility ++ * in the presence of lazy construction, accesses to segments as ++ * well as elements of segment's table must use volatile access, ++ * which is done via Unsafe within methods segmentAt etc ++ * below. These provide the functionality of AtomicReferenceArrays ++ * but reduce the levels of indirection. Additionally, ++ * volatile-writes of table elements and entry "next" fields ++ * within locked operations use the cheaper "lazySet" forms of ++ * writes (via putOrderedObject) because these writes are always ++ * followed by lock releases that maintain sequential consistency ++ * of table updates. ++ * ++ * Historical note: The previous version of this class relied ++ * heavily on "final" fields, which avoided some volatile reads at ++ * the expense of a large initial footprint. Some remnants of ++ * that design (including forced construction of segment 0) exist ++ * to ensure serialization compatibility. + */ + + /* ---------------- Constants -------------- */ +@@ -137,8 +155,15 @@ + static final int MAXIMUM_CAPACITY = 1 << 30; + + /** ++ * The minimum capacity for per-segment tables. Must be a power ++ * of two, at least two to avoid immediate resizing on next use ++ * after lazy construction. ++ */ ++ static final int MIN_SEGMENT_TABLE_CAPACITY = 2; ++ ++ /** + * The maximum number of segments to allow; used to bound +- * constructor arguments. ++ * constructor arguments. Must be power of two less than 1 << 24. + */ + static final int MAX_SEGMENTS = 1 << 16; // slightly conservative + +@@ -164,7 +189,7 @@ + final int segmentShift; + + /** +- * The segments, each of which is a specialized hash table ++ * The segments, each of which is a specialized hash table. + */ + final Segment<K,V>[] segments; + +@@ -172,7 +197,65 @@ + transient Set<Map.Entry<K,V>> entrySet; + transient Collection<V> values; + +- /* ---------------- Small Utilities -------------- */ ++ /** ++ * ConcurrentHashMap list entry. Note that this is never exported ++ * out as a user-visible Map.Entry. ++ */ ++ static final class HashEntry<K,V> { ++ final int hash; ++ final K key; ++ volatile V value; ++ volatile HashEntry<K,V> next; ++ ++ HashEntry(int hash, K key, V value, HashEntry<K,V> next) { ++ this.hash = hash; ++ this.key = key; ++ this.value = value; ++ this.next = next; ++ } ++ ++ /** ++ * Sets next field with volatile write semantics. (See above ++ * about use of putOrderedObject.) ++ */ ++ final void setNext(HashEntry<K,V> n) { ++ UNSAFE.putOrderedObject(this, nextOffset, n); ++ } ++ ++ // Unsafe mechanics ++ static final sun.misc.Unsafe UNSAFE; ++ static final long nextOffset; ++ static { ++ try { ++ UNSAFE = sun.misc.Unsafe.getUnsafe(); ++ Class k = HashEntry.class; ++ nextOffset = UNSAFE.objectFieldOffset ++ (k.getDeclaredField("next")); ++ } catch (Exception e) { ++ throw new Error(e); ++ } ++ } ++ } ++ ++ /** ++ * Gets the ith element of given table (if nonnull) with volatile ++ * read semantics. ++ */ ++ @SuppressWarnings("unchecked") ++ static final <K,V> HashEntry<K,V> entryAt(HashEntry<K,V>[] tab, int i) { ++ return (tab == null) ? null : ++ (HashEntry<K,V>) UNSAFE.getObjectVolatile ++ (tab, ((long)i << TSHIFT) + TBASE); ++ } ++ ++ /** ++ * Sets the ith element of given table, with volatile write ++ * semantics. (See above about use of putOrderedObject.) ++ */ ++ static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i, ++ HashEntry<K,V> e) { ++ UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e); ++ } + + /** + * Applies a supplemental hash function to a given hashCode, which +@@ -193,104 +276,67 @@ + } + + /** +- * Returns the segment that should be used for key with given hash +- * @param hash the hash code for the key +- * @return the segment +- */ +- final Segment<K,V> segmentFor(int hash) { +- return segments[(hash >>> segmentShift) & segmentMask]; +- } +- +- /* ---------------- Inner Classes -------------- */ +- +- /** +- * ConcurrentHashMap list entry. Note that this is never exported +- * out as a user-visible Map.Entry. +- * +- * Because the value field is volatile, not final, it is legal wrt +- * the Java Memory Model for an unsynchronized reader to see null +- * instead of initial value when read via a data race. Although a +- * reordering leading to this is not likely to ever actually +- * occur, the Segment.readValueUnderLock method is used as a +- * backup in case a null (pre-initialized) value is ever seen in +- * an unsynchronized access method. +- */ +- static final class HashEntry<K,V> { +- final K key; +- final int hash; +- volatile V value; +- final HashEntry<K,V> next; +- +- HashEntry(K key, int hash, HashEntry<K,V> next, V value) { +- this.key = key; +- this.hash = hash; +- this.next = next; +- this.value = value; +- } +- +- @SuppressWarnings("unchecked") +- static final <K,V> HashEntry<K,V>[] newArray(int i) { +- return new HashEntry[i]; +- } +- } +- +- /** + * Segments are specialized versions of hash tables. This + * subclasses from ReentrantLock opportunistically, just to + * simplify some locking and avoid separate construction. + */ + static final class Segment<K,V> extends ReentrantLock implements Serializable { + /* +- * Segments maintain a table of entry lists that are ALWAYS +- * kept in a consistent state, so can be read without locking. +- * Next fields of nodes are immutable (final). All list +- * additions are performed at the front of each bin. This +- * makes it easy to check changes, and also fast to traverse. +- * When nodes would otherwise be changed, new nodes are +- * created to replace them. This works well for hash tables +- * since the bin lists tend to be short. (The average length +- * is less than two for the default load factor threshold.) ++ * Segments maintain a table of entry lists that are always ++ * kept in a consistent state, so can be read (via volatile ++ * reads of segments and tables) without locking. This ++ * requires replicating nodes when necessary during table ++ * resizing, so the old lists can be traversed by readers ++ * still using old version of table. + * +- * Read operations can thus proceed without locking, but rely +- * on selected uses of volatiles to ensure that completed +- * write operations performed by other threads are +- * noticed. For most purposes, the "count" field, tracking the +- * number of elements, serves as that volatile variable +- * ensuring visibility. This is convenient because this field +- * needs to be read in many read operations anyway: +- * +- * - All (unsynchronized) read operations must first read the +- * "count" field, and should not look at table entries if +- * it is 0. +- * +- * - All (synchronized) write operations should write to +- * the "count" field after structurally changing any bin. +- * The operations must not take any action that could even +- * momentarily cause a concurrent read operation to see +- * inconsistent data. This is made easier by the nature of +- * the read operations in Map. For example, no operation +- * can reveal that the table has grown but the threshold +- * has not yet been updated, so there are no atomicity +- * requirements for this with respect to reads. +- * +- * As a guide, all critical volatile reads and writes to the +- * count field are marked in code comments. ++ * This class defines only mutative methods requiring locking. ++ * Except as noted, the methods of this class perform the ++ * per-segment versions of ConcurrentHashMap methods. (Other ++ * methods are integrated directly into ConcurrentHashMap ++ * methods.) These mutative methods use a form of controlled ++ * spinning on contention via methods scanAndLock and ++ * scanAndLockForPut. These intersperse tryLocks with ++ * traversals to locate nodes. The main benefit is to absorb ++ * cache misses (which are very common for hash tables) while ++ * obtaining locks so that traversal is faster once ++ * acquired. We do not actually use the found nodes since they ++ * must be re-acquired under lock anyway to ensure sequential ++ * consistency of updates (and in any case may be undetectably ++ * stale), but they will normally be much faster to re-locate. ++ * Also, scanAndLockForPut speculatively creates a fresh node ++ * to use in put if no node is found. + */ + + private static final long serialVersionUID = 2249069246763182397L; + + /** +- * The number of elements in this segment's region. ++ * The maximum number of times to tryLock in a prescan before ++ * possibly blocking on acquire in preparation for a locked ++ * segment operation. On multiprocessors, using a bounded ++ * number of retries maintains cache acquired while locating ++ * nodes. + */ +- transient volatile int count; ++ static final int MAX_SCAN_RETRIES = ++ Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1; + + /** +- * Number of updates that alter the size of the table. This is +- * used during bulk-read methods to make sure they see a +- * consistent snapshot: If modCounts change during a traversal +- * of segments computing size or checking containsValue, then +- * we might have an inconsistent view of state so (usually) +- * must retry. ++ * The per-segment table. Elements are accessed via ++ * entryAt/setEntryAt providing volatile semantics. ++ */ ++ transient volatile HashEntry<K,V>[] table; ++ ++ /** ++ * The number of elements. Accessed only either within locks ++ * or among other volatile reads that maintain visibility. ++ */ ++ transient int count; ++ ++ /** ++ * The total number of mutative operations in this segment. ++ * Even though this may overflows 32 bits, it provides ++ * sufficient accuracy for stability checks in CHM isEmpty() ++ * and size() methods. Accessed only either within locks or ++ * among other volatile reads that maintain visibility. + */ + transient int modCount; + +@@ -302,11 +348,6 @@ + transient int threshold; + + /** +- * The per-segment table. +- */ +- transient volatile HashEntry<K,V>[] table; +- +- /** + * The load factor for the hash table. Even though this value + * is same for all segments, it is replicated to avoid needing + * links to outer object. +@@ -314,202 +355,94 @@ + */ + final float loadFactor; + +- Segment(int initialCapacity, float lf) { +- loadFactor = lf; +- setTable(HashEntry.<K,V>newArray(initialCapacity)); ++ Segment(float lf, int threshold, HashEntry<K,V>[] tab) { ++ this.loadFactor = lf; ++ this.threshold = threshold; ++ this.table = tab; + } + +- @SuppressWarnings("unchecked") +- static final <K,V> Segment<K,V>[] newArray(int i) { +- return new Segment[i]; ++ final V put(K key, int hash, V value, boolean onlyIfAbsent) { ++ HashEntry<K,V> node = tryLock() ? null : ++ scanAndLockForPut(key, hash, value); ++ V oldValue; ++ try { ++ HashEntry<K,V>[] tab = table; ++ int index = (tab.length - 1) & hash; ++ HashEntry<K,V> first = entryAt(tab, index); ++ for (HashEntry<K,V> e = first;;) { ++ if (e != null) { ++ K k; ++ if ((k = e.key) == key || ++ (e.hash == hash && key.equals(k))) { ++ oldValue = e.value; ++ if (!onlyIfAbsent) { ++ e.value = value; ++ ++modCount; ++ } ++ break; ++ } ++ e = e.next; ++ } ++ else { ++ if (node != null) ++ node.setNext(first); ++ else ++ node = new HashEntry<K,V>(hash, key, value, first); ++ int c = count + 1; ++ if (c > threshold && first != null && ++ tab.length < MAXIMUM_CAPACITY) ++ rehash(node); ++ else ++ setEntryAt(tab, index, node); ++ ++modCount; ++ count = c; ++ oldValue = null; ++ break; ++ } ++ } ++ } finally { ++ unlock(); ++ } ++ return oldValue; + } + + /** +- * Sets table to new HashEntry array. +- * Call only while holding lock or in constructor. ++ * Doubles size of table and repacks entries, also adding the ++ * given node to new table + */ +- void setTable(HashEntry<K,V>[] newTable) { +- threshold = (int)(newTable.length * loadFactor); +- table = newTable; +- } +- +- /** +- * Returns properly casted first entry of bin for given hash. +- */ +- HashEntry<K,V> getFirst(int hash) { +- HashEntry<K,V>[] tab = table; +- return tab[hash & (tab.length - 1)]; +- } +- +- /** +- * Reads value field of an entry under lock. Called if value +- * field ever appears to be null. This is possible only if a +- * compiler happens to reorder a HashEntry initialization with +- * its table assignment, which is legal under memory model +- * but is not known to ever occur. +- */ +- V readValueUnderLock(HashEntry<K,V> e) { +- lock(); +- try { +- return e.value; +- } finally { +- unlock(); +- } +- } +- +- /* Specialized implementations of map methods */ +- +- V get(Object key, int hash) { +- if (count != 0) { // read-volatile +- HashEntry<K,V> e = getFirst(hash); +- while (e != null) { +- if (e.hash == hash && key.equals(e.key)) { +- V v = e.value; +- if (v != null) +- return v; +- return readValueUnderLock(e); // recheck +- } +- e = e.next; +- } +- } +- return null; +- } +- +- boolean containsKey(Object key, int hash) { +- if (count != 0) { // read-volatile +- HashEntry<K,V> e = getFirst(hash); +- while (e != null) { +- if (e.hash == hash && key.equals(e.key)) +- return true; +- e = e.next; +- } +- } +- return false; +- } +- +- boolean containsValue(Object value) { +- if (count != 0) { // read-volatile +- HashEntry<K,V>[] tab = table; +- int len = tab.length; +- for (int i = 0 ; i < len; i++) { +- for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) { +- V v = e.value; +- if (v == null) // recheck +- v = readValueUnderLock(e); +- if (value.equals(v)) +- return true; +- } +- } +- } +- return false; +- } +- +- boolean replace(K key, int hash, V oldValue, V newValue) { +- lock(); +- try { +- HashEntry<K,V> e = getFirst(hash); +- while (e != null && (e.hash != hash || !key.equals(e.key))) +- e = e.next; +- +- boolean replaced = false; +- if (e != null && oldValue.equals(e.value)) { +- replaced = true; +- e.value = newValue; +- } +- return replaced; +- } finally { +- unlock(); +- } +- } +- +- V replace(K key, int hash, V newValue) { +- lock(); +- try { +- HashEntry<K,V> e = getFirst(hash); +- while (e != null && (e.hash != hash || !key.equals(e.key))) +- e = e.next; +- +- V oldValue = null; +- if (e != null) { +- oldValue = e.value; +- e.value = newValue; +- } +- return oldValue; +- } finally { +- unlock(); +- } +- } +- +- +- V put(K key, int hash, V value, boolean onlyIfAbsent) { +- lock(); +- try { +- int c = count; +- if (c++ > threshold) // ensure capacity +- rehash(); +- HashEntry<K,V>[] tab = table; +- int index = hash & (tab.length - 1); +- HashEntry<K,V> first = tab[index]; +- HashEntry<K,V> e = first; +- while (e != null && (e.hash != hash || !key.equals(e.key))) +- e = e.next; +- +- V oldValue; +- if (e != null) { +- oldValue = e.value; +- if (!onlyIfAbsent) +- e.value = value; +- } +- else { +- oldValue = null; +- ++modCount; +- tab[index] = new HashEntry<K,V>(key, hash, first, value); +- count = c; // write-volatile +- } +- return oldValue; +- } finally { +- unlock(); +- } +- } +- +- void rehash() { ++ @SuppressWarnings("unchecked") ++ private void rehash(HashEntry<K,V> node) { ++ /* ++ * Reclassify nodes in each list to new table. Because we ++ * are using power-of-two expansion, the elements from ++ * each bin must either stay at same index, or move with a ++ * power of two offset. We eliminate unnecessary node ++ * creation by catching cases where old nodes can be ++ * reused because their next fields won't change. ++ * Statistically, at the default threshold, only about ++ * one-sixth of them need cloning when a table ++ * doubles. The nodes they replace will be garbage ++ * collectable as soon as they are no longer referenced by ++ * any reader thread that may be in the midst of ++ * concurrently traversing table. Entry accesses use plain ++ * array indexing because they are followed by volatile ++ * table write. ++ */ + HashEntry<K,V>[] oldTable = table; + int oldCapacity = oldTable.length; +- if (oldCapacity >= MAXIMUM_CAPACITY) +- return; +- +- /* +- * Reclassify nodes in each list to new Map. Because we are +- * using power-of-two expansion, the elements from each bin +- * must either stay at same index, or move with a power of two +- * offset. We eliminate unnecessary node creation by catching +- * cases where old nodes can be reused because their next +- * fields won't change. Statistically, at the default +- * threshold, only about one-sixth of them need cloning when +- * a table doubles. The nodes they replace will be garbage +- * collectable as soon as they are no longer referenced by any +- * reader thread that may be in the midst of traversing table +- * right now. +- */ +- +- HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1); +- threshold = (int)(newTable.length * loadFactor); +- int sizeMask = newTable.length - 1; ++ int newCapacity = oldCapacity << 1; ++ threshold = (int)(newCapacity * loadFactor); ++ HashEntry<K,V>[] newTable = ++ (HashEntry<K,V>[]) new HashEntry[newCapacity]; ++ int sizeMask = newCapacity - 1; + for (int i = 0; i < oldCapacity ; i++) { +- // We need to guarantee that any existing reads of old Map can +- // proceed. So we cannot yet null out each bin. + HashEntry<K,V> e = oldTable[i]; +- + if (e != null) { + HashEntry<K,V> next = e.next; + int idx = e.hash & sizeMask; +- +- // Single node on list +- if (next == null) ++ if (next == null) // Single node on list + newTable[idx] = e; +- +- else { +- // Reuse trailing consecutive sequence at same slot ++ else { // Reuse consecutive sequence at same slot + HashEntry<K,V> lastRun = e; + int lastIdx = idx; + for (HashEntry<K,V> last = next; +@@ -522,74 +455,259 @@ + } + } + newTable[lastIdx] = lastRun; +- +- // Clone all remaining nodes ++ // Clone remaining nodes + for (HashEntry<K,V> p = e; p != lastRun; p = p.next) { +- int k = p.hash & sizeMask; ++ V v = p.value; ++ int h = p.hash; ++ int k = h & sizeMask; + HashEntry<K,V> n = newTable[k]; +- newTable[k] = new HashEntry<K,V>(p.key, p.hash, +- n, p.value); ++ newTable[k] = new HashEntry<K,V>(h, p.key, v, n); + } + } + } + } ++ int nodeIndex = node.hash & sizeMask; // add the new node ++ node.setNext(newTable[nodeIndex]); ++ newTable[nodeIndex] = node; + table = newTable; + } + + /** ++ * Scans for a node containing given key while trying to ++ * acquire lock, creating and returning one if not found. Upon ++ * return, guarantees that lock is held. UNlike in most ++ * methods, calls to method equals are not screened: Since ++ * traversal speed doesn't matter, we might as well help warm ++ * up the associated code and accesses as well. ++ * ++ * @return a new node if key not found, else null ++ */ ++ private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) { ++ HashEntry<K,V> first = entryForHash(this, hash); ++ HashEntry<K,V> e = first; ++ HashEntry<K,V> node = null; ++ int retries = -1; // negative while locating node ++ while (!tryLock()) { ++ HashEntry<K,V> f; // to recheck first below ++ if (retries < 0) { ++ if (e == null) { ++ if (node == null) // speculatively create node ++ node = new HashEntry<K,V>(hash, key, value, null); ++ retries = 0; ++ } ++ else if (key.equals(e.key)) ++ retries = 0; ++ else ++ e = e.next; ++ } ++ else if (++retries > MAX_SCAN_RETRIES) { ++ lock(); ++ break; ++ } ++ else if ((retries & 1) == 0 && ++ (f = entryForHash(this, hash)) != first) { ++ e = first = f; // re-traverse if entry changed ++ retries = -1; ++ } ++ } ++ return node; ++ } ++ ++ /** ++ * Scans for a node containing the given key while trying to ++ * acquire lock for a remove or replace operation. Upon ++ * return, guarantees that lock is held. Note that we must ++ * lock even if the key is not found, to ensure sequential ++ * consistency of updates. ++ */ ++ private void scanAndLock(Object key, int hash) { ++ // similar to but simpler than scanAndLockForPut ++ HashEntry<K,V> first = entryForHash(this, hash); ++ HashEntry<K,V> e = first; ++ int retries = -1; ++ while (!tryLock()) { ++ HashEntry<K,V> f; ++ if (retries < 0) { ++ if (e == null || key.equals(e.key)) ++ retries = 0; ++ else ++ e = e.next; ++ } ++ else if (++retries > MAX_SCAN_RETRIES) { ++ lock(); ++ break; ++ } ++ else if ((retries & 1) == 0 && ++ (f = entryForHash(this, hash)) != first) { ++ e = first = f; ++ retries = -1; ++ } ++ } ++ } ++ ++ /** + * Remove; match on key only if value null, else match both. + */ +- V remove(Object key, int hash, Object value) { ++ final V remove(Object key, int hash, Object value) { ++ if (!tryLock()) ++ scanAndLock(key, hash); ++ V oldValue = null; ++ try { ++ HashEntry<K,V>[] tab = table; ++ int index = (tab.length - 1) & hash; ++ HashEntry<K,V> e = entryAt(tab, index); ++ HashEntry<K,V> pred = null; ++ while (e != null) { ++ K k; ++ HashEntry<K,V> next = e.next; ++ if ((k = e.key) == key || ++ (e.hash == hash && key.equals(k))) { ++ V v = e.value; ++ if (value == null || value == v || value.equals(v)) { ++ if (pred == null) ++ setEntryAt(tab, index, next); ++ else ++ pred.setNext(next); ++ ++modCount; ++ --count; ++ oldValue = v; ++ } ++ break; ++ } ++ pred = e; ++ e = next; ++ } ++ } finally { ++ unlock(); ++ } ++ return oldValue; ++ } ++ ++ final boolean replace(K key, int hash, V oldValue, V newValue) { ++ if (!tryLock()) ++ scanAndLock(key, hash); ++ boolean replaced = false; ++ try { ++ HashEntry<K,V> e; ++ for (e = entryForHash(this, hash); e != null; e = e.next) { ++ K k; ++ if ((k = e.key) == key || ++ (e.hash == hash && key.equals(k))) { ++ if (oldValue.equals(e.value)) { ++ e.value = newValue; ++ ++modCount; ++ replaced = true; ++ } ++ break; ++ } ++ } ++ } finally { ++ unlock(); ++ } ++ return replaced; ++ } ++ ++ final V replace(K key, int hash, V value) { ++ if (!tryLock()) ++ scanAndLock(key, hash); ++ V oldValue = null; ++ try { ++ HashEntry<K,V> e; ++ for (e = entryForHash(this, hash); e != null; e = e.next) { ++ K k; ++ if ((k = e.key) == key || ++ (e.hash == hash && key.equals(k))) { ++ oldValue = e.value; ++ e.value = value; ++ ++modCount; ++ break; ++ } ++ } ++ } finally { ++ unlock(); ++ } ++ return oldValue; ++ } ++ ++ final void clear() { + lock(); + try { +- int c = count - 1; + HashEntry<K,V>[] tab = table; +- int index = hash & (tab.length - 1); +- HashEntry<K,V> first = tab[index]; +- HashEntry<K,V> e = first; +- while (e != null && (e.hash != hash || !key.equals(e.key))) +- e = e.next; +- +- V oldValue = null; +- if (e != null) { +- V v = e.value; +- if (value == null || value.equals(v)) { +- oldValue = v; +- // All entries following removed node can stay +- // in list, but all preceding ones need to be +- // cloned. +- ++modCount; +- HashEntry<K,V> newFirst = e.next; +- for (HashEntry<K,V> p = first; p != e; p = p.next) +- newFirst = new HashEntry<K,V>(p.key, p.hash, +- newFirst, p.value); +- tab[index] = newFirst; +- count = c; // write-volatile +- } +- } +- return oldValue; ++ for (int i = 0; i < tab.length ; i++) ++ setEntryAt(tab, i, null); ++ ++modCount; ++ count = 0; + } finally { + unlock(); + } + } ++ } + +- void clear() { +- if (count != 0) { +- lock(); +- try { +- HashEntry<K,V>[] tab = table; +- for (int i = 0; i < tab.length ; i++) +- tab[i] = null; +- ++modCount; +- count = 0; // write-volatile +- } finally { +- unlock(); ++ // Accessing segments ++ ++ /** ++ * Gets the jth element of given segment array (if nonnull) with ++ * volatile element access semantics via Unsafe. ++ */ ++ @SuppressWarnings("unchecked") ++ static final <K,V> Segment<K,V> segmentAt(Segment<K,V>[] ss, int j) { ++ long u = (j << SSHIFT) + SBASE; ++ return ss == null ? null : ++ (Segment<K,V>) UNSAFE.getObjectVolatile(ss, u); ++ } ++ ++ /** ++ * Returns the segment for the given index, creating it and ++ * recording in segment table (via CAS) if not already present. ++ * ++ * @param k the index ++ * @return the segment ++ */ ++ @SuppressWarnings("unchecked") ++ private Segment<K,V> ensureSegment(int k) { ++ final Segment<K,V>[] ss = this.segments; ++ long u = (k << SSHIFT) + SBASE; // raw offset ++ Segment<K,V> seg; ++ if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) { ++ Segment<K,V> proto = ss[0]; // use segment 0 as prototype ++ int cap = proto.table.length; ++ float lf = proto.loadFactor; ++ int threshold = (int)(cap * lf); ++ HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap]; ++ if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) ++ == null) { // recheck ++ Segment<K,V> s = new Segment<K,V>(lf, threshold, tab); ++ while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) ++ == null) { ++ if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s)) ++ break; + } + } + } ++ return seg; + } + ++ // Hash-based segment and entry accesses + ++ /** ++ * Get the segment for the given hash ++ */ ++ @SuppressWarnings("unchecked") ++ private Segment<K,V> segmentForHash(int h) { ++ long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE; ++ return (Segment<K,V>) UNSAFE.getObjectVolatile(segments, u); ++ } ++ ++ /** ++ * Gets the table entry for the given segment and hash ++ */ ++ @SuppressWarnings("unchecked") ++ static final <K,V> HashEntry<K,V> entryForHash(Segment<K,V> seg, int h) { ++ HashEntry<K,V>[] tab; ++ return (seg == null || (tab = seg.table) == null) ? null : ++ (HashEntry<K,V>) UNSAFE.getObjectVolatile ++ (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE); ++ } + + /* ---------------- Public operations -------------- */ + +@@ -609,14 +727,13 @@ + * negative or the load factor or concurrencyLevel are + * nonpositive. + */ ++ @SuppressWarnings("unchecked") + public ConcurrentHashMap(int initialCapacity, + float loadFactor, int concurrencyLevel) { + if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) + throw new IllegalArgumentException(); +- + if (concurrencyLevel > MAX_SEGMENTS) + concurrencyLevel = MAX_SEGMENTS; +- + // Find power-of-two sizes best matching arguments + int sshift = 0; + int ssize = 1; +@@ -624,21 +741,23 @@ + ++sshift; + ssize <<= 1; + } +- segmentShift = 32 - sshift; +- segmentMask = ssize - 1; +- this.segments = Segment.newArray(ssize); +- ++ this.segmentShift = 32 - sshift; ++ this.segmentMask = ssize - 1; + if (initialCapacity > MAXIMUM_CAPACITY) + initialCapacity = MAXIMUM_CAPACITY; + int c = initialCapacity / ssize; + if (c * ssize < initialCapacity) + ++c; +- int cap = 1; ++ int cap = MIN_SEGMENT_TABLE_CAPACITY; + while (cap < c) + cap <<= 1; +- +- for (int i = 0; i < this.segments.length; ++i) +- this.segments[i] = new Segment<K,V>(cap, loadFactor); ++ // create segments and segments[0] ++ Segment<K,V> s0 = ++ new Segment<K,V>(loadFactor, (int)(cap * loadFactor), ++ (HashEntry<K,V>[])new HashEntry[cap]); ++ Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize]; ++ UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0] ++ this.segments = ss; + } + + /** +@@ -701,33 +820,36 @@ + * @return <tt>true</tt> if this map contains no key-value mappings + */ + public boolean isEmpty() { ++ /* ++ * Sum per-segment modCounts to avoid mis-reporting when ++ * elements are concurrently added and removed in one segment ++ * while checking another, in which case the table was never ++ * actually empty at any point. (The sum ensures accuracy up ++ * through at least 1<<31 per-segment modifications before ++ * recheck.) Methods size() and containsValue() use similar ++ * constructions for stability checks. ++ */ ++ long sum = 0L; + final Segment<K,V>[] segments = this.segments; +- /* +- * We keep track of per-segment modCounts to avoid ABA +- * problems in which an element in one segment was added and +- * in another removed during traversal, in which case the +- * table was never actually empty at any point. Note the +- * similar use of modCounts in the size() and containsValue() +- * methods, which are the only other methods also susceptible +- * to ABA problems. +- */ +- int[] mc = new int[segments.length]; +- int mcsum = 0; +- for (int i = 0; i < segments.length; ++i) { +- if (segments[i].count != 0) ++ for (int j = 0; j < segments.length; ++j) { ++ Segment<K,V> seg = segmentAt(segments, j); ++ if (seg != null) { ++ if (seg.count != 0) ++ return false; ++ sum += seg.modCount; ++ } ++ } ++ if (sum != 0L) { // recheck unless no modifications ++ for (int j = 0; j < segments.length; ++j) { ++ Segment<K,V> seg = segmentAt(segments, j); ++ if (seg != null) { ++ if (seg.count != 0) ++ return false; ++ sum -= seg.modCount; ++ } ++ } ++ if (sum != 0L) + return false; +- else +- mcsum += mc[i] = segments[i].modCount; +- } +- // If mcsum happens to be zero, then we know we got a snapshot +- // before any modifications at all were made. This is +- // probably common enough to bother tracking. +- if (mcsum != 0) { +- for (int i = 0; i < segments.length; ++i) { +- if (segments[i].count != 0 || +- mc[i] != segments[i].modCount) +- return false; +- } + } + return true; + } +@@ -740,45 +862,43 @@ + * @return the number of key-value mappings in this map + */ + public int size() { +- final Segment<K,V>[] segments = this.segments; +- long sum = 0; +- long check = 0; +- int[] mc = new int[segments.length]; + // Try a few times to get accurate count. On failure due to + // continuous async changes in table, resort to locking. +- for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) { +- check = 0; +- sum = 0; +- int mcsum = 0; +- for (int i = 0; i < segments.length; ++i) { +- sum += segments[i].count; +- mcsum += mc[i] = segments[i].modCount; +- } +- if (mcsum != 0) { +- for (int i = 0; i < segments.length; ++i) { +- check += segments[i].count; +- if (mc[i] != segments[i].modCount) { +- check = -1; // force retry +- break; ++ final Segment<K,V>[] segments = this.segments; ++ int size; ++ boolean overflow; // true if size overflows 32 bits ++ long sum; // sum of modCounts ++ long last = 0L; // previous sum ++ int retries = -1; // first iteration isn't retry ++ try { ++ for (;;) { ++ if (retries++ == RETRIES_BEFORE_LOCK) { ++ for (int j = 0; j < segments.length; ++j) ++ ensureSegment(j).lock(); // force creation ++ } ++ sum = 0L; ++ size = 0; ++ overflow = false; ++ for (int j = 0; j < segments.length; ++j) { ++ Segment<K,V> seg = segmentAt(segments, j); ++ if (seg != null) { ++ sum += seg.modCount; ++ int c = seg.count; ++ if (c < 0 || (size += c) < 0) ++ overflow = true; + } + } ++ if (sum == last) ++ break; ++ last = sum; + } +- if (check == sum) +- break; ++ } finally { ++ if (retries > RETRIES_BEFORE_LOCK) { ++ for (int j = 0; j < segments.length; ++j) ++ segmentAt(segments, j).unlock(); ++ } + } +- if (check != sum) { // Resort to locking all segments +- sum = 0; +- for (int i = 0; i < segments.length; ++i) +- segments[i].lock(); +- for (int i = 0; i < segments.length; ++i) +- sum += segments[i].count; +- for (int i = 0; i < segments.length; ++i) +- segments[i].unlock(); +- } +- if (sum > Integer.MAX_VALUE) +- return Integer.MAX_VALUE; +- else +- return (int)sum; ++ return overflow ? Integer.MAX_VALUE : size; + } + + /** +@@ -794,7 +914,13 @@ + */ + public V get(Object key) { + int hash = hash(key.hashCode()); +- return segmentFor(hash).get(key, hash); ++ for (HashEntry<K,V> e = entryForHash(segmentForHash(hash), hash); ++ e != null; e = e.next) { ++ K k; ++ if ((k = e.key) == key || (e.hash == hash && key.equals(k))) ++ return e.value; ++ } ++ return null; + } + + /** +@@ -808,7 +934,13 @@ + */ + public boolean containsKey(Object key) { + int hash = hash(key.hashCode()); +- return segmentFor(hash).containsKey(key, hash); ++ for (HashEntry<K,V> e = entryForHash(segmentForHash(hash), hash); ++ e != null; e = e.next) { ++ K k; ++ if ((k = e.key) == key || (e.hash == hash && key.equals(k))) ++ return true; ++ } ++ return false; + } + + /** +@@ -823,51 +955,47 @@ + * @throws NullPointerException if the specified value is null + */ + public boolean containsValue(Object value) { ++ // Same idea as size() + if (value == null) + throw new NullPointerException(); +- +- // See explanation of modCount use above +- + final Segment<K,V>[] segments = this.segments; +- int[] mc = new int[segments.length]; +- +- // Try a few times without locking +- for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) { +- int sum = 0; +- int mcsum = 0; +- for (int i = 0; i < segments.length; ++i) { +- int c = segments[i].count; +- mcsum += mc[i] = segments[i].modCount; +- if (segments[i].containsValue(value)) +- return true; +- } +- boolean cleanSweep = true; +- if (mcsum != 0) { +- for (int i = 0; i < segments.length; ++i) { +- int c = segments[i].count; +- if (mc[i] != segments[i].modCount) { +- cleanSweep = false; +- break; ++ boolean found = false; ++ long last = 0; ++ int retries = -1; ++ try { ++ outer: for (;;) { ++ if (retries++ == RETRIES_BEFORE_LOCK) { ++ for (int j = 0; j < segments.length; ++j) ++ ensureSegment(j).lock(); // force creation ++ } ++ long hashSum = 0L; ++ int sum = 0; ++ for (int j = 0; j < segments.length; ++j) { ++ HashEntry<K,V>[] tab; ++ Segment<K,V> seg = segmentAt(segments, j); ++ if (seg != null && (tab = seg.table) != null) { ++ for (int i = 0 ; i < tab.length; i++) { ++ HashEntry<K,V> e; ++ for (e = entryAt(tab, i); e != null; e = e.next) { ++ V v = e.value; ++ if (v != null && value.equals(v)) { ++ found = true; ++ break outer; ++ } ++ } ++ } ++ sum += seg.modCount; + } + } +- } +- if (cleanSweep) +- return false; +- } +- // Resort to locking all segments +- for (int i = 0; i < segments.length; ++i) +- segments[i].lock(); +- boolean found = false; +- try { +- for (int i = 0; i < segments.length; ++i) { +- if (segments[i].containsValue(value)) { +- found = true; ++ if (retries > 0 && sum == last) + break; +- } ++ last = sum; + } + } finally { +- for (int i = 0; i < segments.length; ++i) +- segments[i].unlock(); ++ if (retries > RETRIES_BEFORE_LOCK) { ++ for (int j = 0; j < segments.length; ++j) ++ segmentAt(segments, j).unlock(); ++ } + } + return found; + } +@@ -908,7 +1036,11 @@ + if (value == null) + throw new NullPointerException(); + int hash = hash(key.hashCode()); +- return segmentFor(hash).put(key, hash, value, false); ++ int j = (hash >>> segmentShift) & segmentMask; ++ Segment<K,V> s = segmentAt(segments, j); ++ if (s == null) ++ s = ensureSegment(j); ++ return s.put(key, hash, value, false); + } + + /** +@@ -922,7 +1054,11 @@ + if (value == null) + throw new NullPointerException(); + int hash = hash(key.hashCode()); +- return segmentFor(hash).put(key, hash, value, true); ++ int j = (hash >>> segmentShift) & segmentMask; ++ Segment<K,V> s = segmentAt(segments, j); ++ if (s == null) ++ s = ensureSegment(j); ++ return s.put(key, hash, value, true); + } + + /** +@@ -948,7 +1084,8 @@ + */ + public V remove(Object key) { + int hash = hash(key.hashCode()); +- return segmentFor(hash).remove(key, hash, null); ++ Segment<K,V> s = segmentForHash(hash); ++ return s == null ? null : s.remove(key, hash, null); + } + + /** +@@ -958,9 +1095,9 @@ + */ + public boolean remove(Object key, Object value) { + int hash = hash(key.hashCode()); +- if (value == null) +- return false; +- return segmentFor(hash).remove(key, hash, value) != null; ++ Segment<K,V> s; ++ return value != null && (s = segmentForHash(hash)) != null && ++ s.remove(key, hash, value) != null; + } + + /** +@@ -969,10 +1106,11 @@ + * @throws NullPointerException if any of the arguments are null + */ + public boolean replace(K key, V oldValue, V newValue) { ++ int hash = hash(key.hashCode()); + if (oldValue == null || newValue == null) + throw new NullPointerException(); +- int hash = hash(key.hashCode()); +- return segmentFor(hash).replace(key, hash, oldValue, newValue); ++ Segment<K,V> s = segmentForHash(hash); ++ return s != null && s.replace(key, hash, oldValue, newValue); + } + + /** +@@ -983,18 +1121,23 @@ + * @throws NullPointerException if the specified key or value is null + */ + public V replace(K key, V value) { ++ int hash = hash(key.hashCode()); + if (value == null) + throw new NullPointerException(); +- int hash = hash(key.hashCode()); +- return segmentFor(hash).replace(key, hash, value); ++ Segment<K,V> s = segmentForHash(hash); ++ return s == null ? null : s.replace(key, hash, value); + } + + /** + * Removes all of the mappings from this map. + */ + public void clear() { +- for (int i = 0; i < segments.length; ++i) +- segments[i].clear(); ++ final Segment<K,V>[] segments = this.segments; ++ for (int j = 0; j < segments.length; ++j) { ++ Segment<K,V> s = segmentAt(segments, j); ++ if (s != null) ++ s.clear(); ++ } + } + + /** +@@ -1095,42 +1238,41 @@ + advance(); + } + +- public boolean hasMoreElements() { return hasNext(); } +- ++ /** ++ * Set nextEntry to first node of next non-empty table ++ * (in backwards order, to simplify checks). ++ */ + final void advance() { +- if (nextEntry != null && (nextEntry = nextEntry.next) != null) +- return; +- +- while (nextTableIndex >= 0) { +- if ( (nextEntry = currentTable[nextTableIndex--]) != null) +- return; +- } +- +- while (nextSegmentIndex >= 0) { +- Segment<K,V> seg = segments[nextSegmentIndex--]; +- if (seg.count != 0) { +- currentTable = seg.table; +- for (int j = currentTable.length - 1; j >= 0; --j) { +- if ( (nextEntry = currentTable[j]) != null) { +- nextTableIndex = j - 1; +- return; +- } +- } ++ for (;;) { ++ if (nextTableIndex >= 0) { ++ if ((nextEntry = entryAt(currentTable, ++ nextTableIndex--)) != null) ++ break; + } ++ else if (nextSegmentIndex >= 0) { ++ Segment<K,V> seg = segmentAt(segments, nextSegmentIndex--); ++ if (seg != null && (currentTable = seg.table) != null) ++ nextTableIndex = currentTable.length - 1; ++ } ++ else ++ break; + } + } + +- public boolean hasNext() { return nextEntry != null; } +- +- HashEntry<K,V> nextEntry() { +- if (nextEntry == null) ++ final HashEntry<K,V> nextEntry() { ++ HashEntry<K,V> e = nextEntry; ++ if (e == null) + throw new NoSuchElementException(); +- lastReturned = nextEntry; +- advance(); +- return lastReturned; ++ lastReturned = e; // cannot assign until after null check ++ if ((nextEntry = e.next) == null) ++ advance(); ++ return e; + } + +- public void remove() { ++ public final boolean hasNext() { return nextEntry != null; } ++ public final boolean hasMoreElements() { return nextEntry != null; } ++ ++ public final void remove() { + if (lastReturned == null) + throw new IllegalStateException(); + ConcurrentHashMap.this.remove(lastReturned.key); +@@ -1142,16 +1284,16 @@ + extends HashIterator + implements Iterator<K>, Enumeration<K> + { +- public K next() { return super.nextEntry().key; } +- public K nextElement() { return super.nextEntry().key; } ++ public final K next() { return super.nextEntry().key; } ++ public final K nextElement() { return super.nextEntry().key; } + } + + final class ValueIterator + extends HashIterator + implements Iterator<V>, Enumeration<V> + { +- public V next() { return super.nextEntry().value; } +- public V nextElement() { return super.nextEntry().value; } ++ public final V next() { return super.nextEntry().value; } ++ public final V nextElement() { return super.nextEntry().value; } + } + + /** +@@ -1271,15 +1413,20 @@ + * The key-value mappings are emitted in no particular order. + */ + private void writeObject(java.io.ObjectOutputStream s) throws IOException { ++ // force all segments for serialization compatibility ++ for (int k = 0; k < segments.length; ++k) ++ ensureSegment(k); + s.defaultWriteObject(); + ++ final Segment<K,V>[] segments = this.segments; + for (int k = 0; k < segments.length; ++k) { +- Segment<K,V> seg = segments[k]; ++ Segment<K,V> seg = segmentAt(segments, k); + seg.lock(); + try { + HashEntry<K,V>[] tab = seg.table; + for (int i = 0; i < tab.length; ++i) { +- for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) { ++ HashEntry<K,V> e; ++ for (e = entryAt(tab, i); e != null; e = e.next) { + s.writeObject(e.key); + s.writeObject(e.value); + } +@@ -1297,13 +1444,20 @@ + * stream (i.e., deserialize it). + * @param s the stream + */ ++ @SuppressWarnings("unchecked") + private void readObject(java.io.ObjectInputStream s) + throws IOException, ClassNotFoundException { + s.defaultReadObject(); + +- // Initialize each segment to be minimally sized, and let grow. +- for (int i = 0; i < segments.length; ++i) { +- segments[i].setTable(new HashEntry[1]); ++ // Re-initialize segments to be minimally sized, and let grow. ++ int cap = MIN_SEGMENT_TABLE_CAPACITY; ++ final Segment<K,V>[] segments = this.segments; ++ for (int k = 0; k < segments.length; ++k) { ++ Segment<K,V> seg = segments[k]; ++ if (seg != null) { ++ seg.threshold = (int)(cap * seg.loadFactor); ++ seg.table = (HashEntry<K,V>[]) new HashEntry[cap]; ++ } + } + + // Read the keys and values, and put the mappings in the table +@@ -1315,4 +1469,31 @@ + put(key, value); + } + } ++ ++ // Unsafe mechanics ++ private static final sun.misc.Unsafe UNSAFE; ++ private static final long SBASE; ++ private static final int SSHIFT; ++ private static final long TBASE; ++ private static final int TSHIFT; ++ ++ static { ++ int ss, ts; ++ try { ++ UNSAFE = sun.misc.Unsafe.getUnsafe(); ++ Class tc = HashEntry[].class; ++ Class sc = Segment[].class; ++ TBASE = UNSAFE.arrayBaseOffset(tc); ++ SBASE = UNSAFE.arrayBaseOffset(sc); ++ ts = UNSAFE.arrayIndexScale(tc); ++ ss = UNSAFE.arrayIndexScale(sc); ++ } catch (Exception e) { ++ throw new Error(e); ++ } ++ if ((ss & (ss-1)) != 0 || (ts & (ts-1)) != 0) ++ throw new Error("data type scale not a power of two"); ++ SSHIFT = 31 - Integer.numberOfLeadingZeros(ss); ++ TSHIFT = 31 - Integer.numberOfLeadingZeros(ts); ++ } ++ + } diff --git a/java/openjdk6/files/icedtea/openjdk/7064279-fixup.patch b/java/openjdk6/files/icedtea/openjdk/7064279-fixup.patch new file mode 100644 index 000000000000..9c90bae5ed0b --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/7064279-fixup.patch @@ -0,0 +1,71 @@ +diff -Nru openjdk.orig/jdk/src/share/classes/java/beans/Introspector.java openjdk/jdk/src/share/classes/java/beans/Introspector.java +--- jdk/src/share/classes/java/beans/Introspector.java 2013-04-16 14:35:31.707279166 +0100 ++++ jdk/src/share/classes/java/beans/Introspector.java 2013-04-16 14:39:23.715018865 +0100 +@@ -102,7 +102,7 @@ + public final static int IGNORE_ALL_BEANINFO = 3; + + // Static Caches to speed up introspection. +- private static final WeakCache<Class<?>, Method[]> declaredMethodCache = new WeakCache<>(); ++ private static final WeakCache<Class<?>, Method[]> declaredMethodCache = new WeakCache<Class<?>, Method[]>(); + + private Class beanClass; + private BeanInfo explicitBeanInfo; +diff -Nru openjdk.orig/jdk/src/share/classes/java/beans/ThreadGroupContext.java openjdk/jdk/src/share/classes/java/beans/ThreadGroupContext.java +--- jdk/src/share/classes/java/beans/ThreadGroupContext.java 2013-04-16 14:35:31.707279166 +0100 ++++ jdk/src/share/classes/java/beans/ThreadGroupContext.java 2013-04-16 14:40:01.243623831 +0100 +@@ -25,9 +25,6 @@ + + package java.beans; + +-import com.sun.beans.finder.BeanInfoFinder; +-import com.sun.beans.finder.PropertyEditorFinder; +- + import java.awt.GraphicsEnvironment; + import java.util.HashMap; + import java.util.Map; +@@ -42,7 +39,7 @@ + */ + final class ThreadGroupContext { + +- private static final Map<ThreadGroup, ThreadGroupContext> contexts = new WeakHashMap<>(); ++ private static final Map<ThreadGroup, ThreadGroupContext> contexts = new WeakHashMap<ThreadGroup, ThreadGroupContext>(); + + /** + * Returns the appropriate {@code AppContext} for the caller, +@@ -66,8 +63,6 @@ + private volatile Boolean isGuiAvailable; + + private Map<Class<?>, BeanInfo> beanInfoCache; +- private BeanInfoFinder beanInfoFinder; +- private PropertyEditorFinder propertyEditorFinder; + + + boolean isDesignTime() { +@@ -99,7 +94,7 @@ + + BeanInfo putBeanInfo(Class<?> type, BeanInfo info) { + if (this.beanInfoCache == null) { +- this.beanInfoCache = new WeakHashMap<>(); ++ this.beanInfoCache = new WeakHashMap<Class<?>, BeanInfo>(); + } + return this.beanInfoCache.put(type, info); + } +@@ -116,18 +111,4 @@ + } + } + +- +- synchronized BeanInfoFinder getBeanInfoFinder() { +- if (this.beanInfoFinder == null) { +- this.beanInfoFinder = new BeanInfoFinder(); +- } +- return this.beanInfoFinder; +- } +- +- synchronized PropertyEditorFinder getPropertyEditorFinder() { +- if (this.propertyEditorFinder == null) { +- this.propertyEditorFinder = new PropertyEditorFinder(); +- } +- return this.propertyEditorFinder; +- } + } diff --git a/java/openjdk6/files/icedtea/openjdk/7064279-resource_release.patch b/java/openjdk6/files/icedtea/openjdk/7064279-resource_release.patch new file mode 100644 index 000000000000..22d0e2caecd4 --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/7064279-resource_release.patch @@ -0,0 +1,436 @@ +# HG changeset patch +# User andrew +# Date 1365712268 -3600 +# Node ID 4d66f7ebcf99c1b322f47ff0aa6adadcd995f8f4 +# Parent df591e0dfd349dc5986cc17949939c588d5a9690 +7064279: Introspector.getBeanInfo() should release some resources in timely manner +Reviewed-by: art, alexp + +diff --git a/src/share/classes/java/beans/Beans.java b/src/share/classes/java/beans/Beans.java +--- jdk/src/share/classes/java/beans/Beans.java ++++ jdk/src/share/classes/java/beans/Beans.java +@@ -32,7 +32,6 @@ + import java.applet.AppletStub; + import java.applet.AudioClip; + +-import java.awt.GraphicsEnvironment; + import java.awt.Image; + + import java.beans.beancontext.BeanContext; +@@ -53,15 +52,11 @@ + import java.util.Iterator; + import java.util.Vector; + +-import sun.awt.AppContext; +- + /** + * This class provides some general purpose beans control methods. + */ + + public class Beans { +- private static final Object DESIGN_TIME = new Object(); +- private static final Object GUI_AVAILABLE = new Object(); + + /** + * <p> +@@ -395,8 +390,7 @@ + * @see DesignMode + */ + public static boolean isDesignTime() { +- Object value = AppContext.getAppContext().get(DESIGN_TIME); +- return (value instanceof Boolean) && (Boolean) value; ++ return ThreadGroupContext.getContext().isDesignTime(); + } + + /** +@@ -413,8 +407,7 @@ + * + */ + public static boolean isGuiAvailable() { +- Object value = AppContext.getAppContext().get(GUI_AVAILABLE); +- return (value instanceof Boolean) ? (Boolean) value : !GraphicsEnvironment.isHeadless(); ++ return ThreadGroupContext.getContext().isGuiAvailable(); + } + + /** +@@ -440,7 +433,7 @@ + if (sm != null) { + sm.checkPropertiesAccess(); + } +- AppContext.getAppContext().put(DESIGN_TIME, Boolean.valueOf(isDesignTime)); ++ ThreadGroupContext.getContext().setDesignTime(isDesignTime); + } + + /** +@@ -466,7 +459,7 @@ + if (sm != null) { + sm.checkPropertiesAccess(); + } +- AppContext.getAppContext().put(GUI_AVAILABLE, Boolean.valueOf(isGuiAvailable)); ++ ThreadGroupContext.getContext().setGuiAvailable(isGuiAvailable); + } + } + +diff --git a/src/share/classes/java/beans/Introspector.java b/src/share/classes/java/beans/Introspector.java +--- jdk/src/share/classes/java/beans/Introspector.java ++++ jdk/src/share/classes/java/beans/Introspector.java +@@ -38,7 +38,6 @@ + import java.util.EventListener; + import java.util.List; + import java.util.TreeMap; +-import sun.awt.AppContext; + import sun.reflect.misc.ReflectUtil; + + /** +@@ -103,10 +102,7 @@ + public final static int IGNORE_ALL_BEANINFO = 3; + + // Static Caches to speed up introspection. +- private static WeakCache<Class<?>, Method[]> declaredMethodCache = +- new WeakCache<Class<?>, Method[]>(); +- +- private static final Object BEANINFO_CACHE = new Object(); ++ private static final WeakCache<Class<?>, Method[]> declaredMethodCache = new WeakCache<>(); + + private Class beanClass; + private BeanInfo explicitBeanInfo; +@@ -170,21 +166,15 @@ + if (!ReflectUtil.isPackageAccessible(beanClass)) { + return (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo(); + } +- WeakCache<Class<?>, BeanInfo> beanInfoCache; ++ ThreadGroupContext context = ThreadGroupContext.getContext(); + BeanInfo beanInfo; +- synchronized (BEANINFO_CACHE) { +- beanInfoCache = (WeakCache<Class<?>, BeanInfo>) AppContext.getAppContext().get(BEANINFO_CACHE); +- +- if (beanInfoCache == null) { +- beanInfoCache = new WeakCache<Class<?>, BeanInfo>(); +- AppContext.getAppContext().put(BEANINFO_CACHE, beanInfoCache); +- } +- beanInfo = beanInfoCache.get(beanClass); ++ synchronized (declaredMethodCache) { ++ beanInfo = context.getBeanInfo(beanClass); + } + if (beanInfo == null) { + beanInfo = (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo(); +- synchronized (BEANINFO_CACHE) { +- beanInfoCache.put(beanClass, beanInfo); ++ synchronized (declaredMethodCache) { ++ context.putBeanInfo(beanClass, beanInfo); + } + } + return beanInfo; +@@ -334,11 +324,8 @@ + */ + + public static void flushCaches() { +- synchronized (BEANINFO_CACHE) { +- WeakCache beanInfoCache = (WeakCache) AppContext.getAppContext().get(BEANINFO_CACHE); +- if (beanInfoCache != null) { +- beanInfoCache.clear(); +- } ++ synchronized (declaredMethodCache) { ++ ThreadGroupContext.getContext().clearBeanInfoCache(); + declaredMethodCache.clear(); + } + } +@@ -362,11 +349,8 @@ + if (clz == null) { + throw new NullPointerException(); + } +- synchronized (BEANINFO_CACHE) { +- WeakCache beanInfoCache = (WeakCache) AppContext.getAppContext().get(BEANINFO_CACHE); +- if (beanInfoCache != null) { +- beanInfoCache.put(clz, null); +- } ++ synchronized (declaredMethodCache) { ++ ThreadGroupContext.getContext().removeBeanInfo(clz); + declaredMethodCache.put(clz, null); + } + } +@@ -1313,7 +1297,7 @@ + if (!ReflectUtil.isPackageAccessible(clz)) { + return new Method[0]; + } +- synchronized (BEANINFO_CACHE) { ++ synchronized (declaredMethodCache) { + Method[] result = declaredMethodCache.get(clz); + if (result == null) { + result = clz.getMethods(); +diff --git a/src/share/classes/java/beans/ThreadGroupContext.java b/src/share/classes/java/beans/ThreadGroupContext.java +new file mode 100644 +--- /dev/null ++++ jdk/src/share/classes/java/beans/ThreadGroupContext.java +@@ -0,0 +1,133 @@ ++/* ++ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. Oracle designates this ++ * particular file as subject to the "Classpath" exception as provided ++ * by Oracle in the LICENSE file that accompanied this code. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ */ ++ ++package java.beans; ++ ++import com.sun.beans.finder.BeanInfoFinder; ++import com.sun.beans.finder.PropertyEditorFinder; ++ ++import java.awt.GraphicsEnvironment; ++import java.util.HashMap; ++import java.util.Map; ++import java.util.WeakHashMap; ++ ++/** ++ * The {@code ThreadGroupContext} is an application-dependent ++ * context referenced by the specific {@link ThreadGroup}. ++ * This is a replacement for the {@link sun.awt.AppContext}. ++ * ++ * @author Sergey Malenkov ++ */ ++final class ThreadGroupContext { ++ ++ private static final Map<ThreadGroup, ThreadGroupContext> contexts = new WeakHashMap<>(); ++ ++ /** ++ * Returns the appropriate {@code AppContext} for the caller, ++ * as determined by its {@code ThreadGroup}. ++ * ++ * @return the application-dependent context ++ */ ++ static ThreadGroupContext getContext() { ++ ThreadGroup group = Thread.currentThread().getThreadGroup(); ++ synchronized (contexts) { ++ ThreadGroupContext context = contexts.get(group); ++ if (context == null) { ++ context = new ThreadGroupContext(); ++ contexts.put(group, context); ++ } ++ return context; ++ } ++ } ++ ++ private volatile boolean isDesignTime; ++ private volatile Boolean isGuiAvailable; ++ ++ private Map<Class<?>, BeanInfo> beanInfoCache; ++ private BeanInfoFinder beanInfoFinder; ++ private PropertyEditorFinder propertyEditorFinder; ++ ++ ++ boolean isDesignTime() { ++ return this.isDesignTime; ++ } ++ ++ void setDesignTime(boolean isDesignTime) { ++ this.isDesignTime = isDesignTime; ++ } ++ ++ ++ boolean isGuiAvailable() { ++ Boolean isGuiAvailable = this.isGuiAvailable; ++ return (isGuiAvailable != null) ++ ? isGuiAvailable.booleanValue() ++ : !GraphicsEnvironment.isHeadless(); ++ } ++ ++ void setGuiAvailable(boolean isGuiAvailable) { ++ this.isGuiAvailable = Boolean.valueOf(isGuiAvailable); ++ } ++ ++ ++ BeanInfo getBeanInfo(Class<?> type) { ++ return (this.beanInfoCache != null) ++ ? this.beanInfoCache.get(type) ++ : null; ++ } ++ ++ BeanInfo putBeanInfo(Class<?> type, BeanInfo info) { ++ if (this.beanInfoCache == null) { ++ this.beanInfoCache = new WeakHashMap<>(); ++ } ++ return this.beanInfoCache.put(type, info); ++ } ++ ++ void removeBeanInfo(Class<?> type) { ++ if (this.beanInfoCache != null) { ++ this.beanInfoCache.remove(type); ++ } ++ } ++ ++ void clearBeanInfoCache() { ++ if (this.beanInfoCache != null) { ++ this.beanInfoCache.clear(); ++ } ++ } ++ ++ ++ synchronized BeanInfoFinder getBeanInfoFinder() { ++ if (this.beanInfoFinder == null) { ++ this.beanInfoFinder = new BeanInfoFinder(); ++ } ++ return this.beanInfoFinder; ++ } ++ ++ synchronized PropertyEditorFinder getPropertyEditorFinder() { ++ if (this.propertyEditorFinder == null) { ++ this.propertyEditorFinder = new PropertyEditorFinder(); ++ } ++ return this.propertyEditorFinder; ++ } ++} +diff --git a/test/java/beans/Beans/6669869/TestDesignTime.java b/test/java/beans/Beans/6669869/TestDesignTime.java +--- jdk/test/java/beans/Beans/6669869/TestDesignTime.java ++++ jdk/test/java/beans/Beans/6669869/TestDesignTime.java +@@ -29,7 +29,6 @@ + */ + + import java.beans.Beans; +-import sun.awt.SunToolkit; + + public class TestDesignTime implements Runnable { + public static void main(String[] args) throws InterruptedException { +@@ -44,7 +43,6 @@ + } + + public void run() { +- SunToolkit.createNewAppContext(); + if (Beans.isDesignTime()) { + throw new Error("shared DesignTime property"); + } +diff --git a/test/java/beans/Beans/6669869/TestGuiAvailable.java b/test/java/beans/Beans/6669869/TestGuiAvailable.java +--- jdk/test/java/beans/Beans/6669869/TestGuiAvailable.java ++++ jdk/test/java/beans/Beans/6669869/TestGuiAvailable.java +@@ -30,7 +30,6 @@ + + import java.awt.GraphicsEnvironment; + import java.beans.Beans; +-import sun.awt.SunToolkit; + + public class TestGuiAvailable implements Runnable { + public static void main(String[] args) throws InterruptedException { +@@ -45,7 +44,6 @@ + } + + public void run() { +- SunToolkit.createNewAppContext(); + if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) { + throw new Error("shared GuiAvailable property"); + } +diff --git a/test/java/beans/Introspector/7064279/Test7064279.java b/test/java/beans/Introspector/7064279/Test7064279.java +new file mode 100644 +--- /dev/null ++++ jdk/test/java/beans/Introspector/7064279/Test7064279.java +@@ -0,0 +1,75 @@ ++/* ++ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ */ ++ ++/* ++ * @test ++ * @bug 7064279 ++ * @summary Tests that Introspector does not have strong references to context class loader ++ * @author Sergey Malenkov ++ */ ++ ++import java.beans.Introspector; ++import java.io.File; ++import java.lang.ref.WeakReference; ++import java.net.URL; ++import java.net.URLClassLoader; ++ ++public class Test7064279 { ++ ++ public static void main(String[] args) throws Exception { ++ WeakReference ref = new WeakReference(test("test.jar", "test.Test")); ++ try { ++ int[] array = new int[1024]; ++ while (true) { ++ array = new int[array.length << 1]; ++ } ++ } ++ catch (OutOfMemoryError error) { ++ System.gc(); ++ } ++ if (null != ref.get()) { ++ throw new Error("ClassLoader is not released"); ++ } ++ } ++ ++ private static Object test(String jarName, String className) throws Exception { ++ StringBuilder sb = new StringBuilder(256); ++ sb.append("file:"); ++ sb.append(System.getProperty("test.src", ".")); ++ sb.append(File.separatorChar); ++ sb.append(jarName); ++ ++ ClassLoader newLoader = new URLClassLoader(new URL[] { new URL(sb.toString()) }); ++ ClassLoader oldLoader = Thread.currentThread().getContextClassLoader(); ++ ++ Thread.currentThread().setContextClassLoader(newLoader); ++ test(newLoader.loadClass(className)); ++ Thread.currentThread().setContextClassLoader(oldLoader); ++ ++ return newLoader; ++ } ++ ++ private static void test(Class type) throws Exception { ++ Introspector.getBeanInfo(type); ++ } ++} +diff --git a/test/java/beans/Introspector/Test6660539.java b/test/java/beans/Introspector/Test6660539.java +--- jdk/test/java/beans/Introspector/Test6660539.java ++++ jdk/test/java/beans/Introspector/Test6660539.java +@@ -28,8 +28,6 @@ + * @author Sergey Malenkov + */ + +-import sun.awt.SunToolkit; +- + import java.beans.BeanInfo; + import java.beans.IntrospectionException; + import java.beans.Introspector; +@@ -49,7 +47,6 @@ + } + + public void run() { +- SunToolkit.createNewAppContext(); + for (PropertyDescriptor pd : getPropertyDescriptors()) { + if (pd.getDisplayName().equals(NAME)) + throw new Error("shared BeanInfo cache"); diff --git a/java/openjdk6/files/icedtea/openjdk/7133220-factory_finder_parser_transform_useBSClassLoader.patch b/java/openjdk6/files/icedtea/openjdk/7133220-factory_finder_parser_transform_useBSClassLoader.patch new file mode 100644 index 000000000000..9b61dd6a6d73 --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/7133220-factory_finder_parser_transform_useBSClassLoader.patch @@ -0,0 +1,299 @@ +--- /dev/null 2013-04-25 14:11:00.000000000 -0400 ++++ jaxp/patches/jaxp_src/7133220-factory_finder_parser_transform_useBSClassLoader.patch 2013-04-25 14:19:44.000000000 -0400 +@@ -0,0 +1,296 @@ ++--- src/javax/xml/parsers/FactoryFinder.java 2013-04-22 12:37:39.305820912 -0400 +++++ src/javax/xml/parsers/FactoryFinder.java 2013-04-22 12:28:52.947388255 -0400 ++@@ -25,15 +25,12 @@ ++ ++ package javax.xml.parsers; ++ ++-import java.io.File; ++-import java.io.FileInputStream; ++- ++-import java.util.Properties; ++ import java.io.BufferedReader; +++import java.io.File; ++ import java.io.IOException; ++ import java.io.InputStream; ++ import java.io.InputStreamReader; ++-import java.net.URL; +++import java.util.Properties; ++ ++ /** ++ * <p>Implements pluggable Datatypes.</p> ++@@ -42,6 +39,7 @@ ++ * sync. It is package private for secure class loading.</p> ++ * ++ * @author Santiago.PericasGeertsen@sun.com +++ * @author Huizhe.Wang@oracle.com ++ */ ++ class FactoryFinder { ++ ++@@ -95,18 +93,24 @@ ++ * If the class loader supplied is <code>null</code>, first try using the ++ * context class loader followed by the current (i.e. bootstrap) class ++ * loader. +++ * +++ * Use bootstrap classLoader if cl = null and useBSClsLoader is true ++ */ ++ static private Class getProviderClass(String className, ClassLoader cl, ++- boolean doFallback) throws ClassNotFoundException +++ boolean doFallback, boolean useBSClsLoader) throws ClassNotFoundException ++ { ++ try { ++ if (cl == null) { ++- cl = ss.getContextClassLoader(); ++- if (cl == null) { ++- throw new ClassNotFoundException(); ++- } ++- else { ++- return cl.loadClass(className); +++ if (useBSClsLoader) { +++ return Class.forName(className, true, FactoryFinder.class.getClassLoader()); +++ } else { +++ cl = ss.getContextClassLoader(); +++ if (cl == null) { +++ throw new ClassNotFoundException(); +++ } +++ else { +++ return cl.loadClass(className); +++ } ++ } ++ } ++ else { ++@@ -131,8 +135,8 @@ ++ * @param className Name of the concrete class corresponding to the ++ * service provider ++ * ++- * @param cl ClassLoader to use to load the class, null means to use ++- * the bootstrap ClassLoader +++ * @param cl <code>ClassLoader</code> used to load the factory class. If <code>null</code> +++ * current <code>Thread</code>'s context classLoader is used to load the factory class. ++ * ++ * @param doFallback True if the current ClassLoader should be tried as ++ * a fallback if the class is not found using cl ++@@ -140,8 +144,30 @@ ++ static Object newInstance(String className, ClassLoader cl, boolean doFallback) ++ throws ConfigurationError ++ { +++ return newInstance(className, cl, doFallback, false); +++ } +++ +++ /** +++ * Create an instance of a class. Delegates to method +++ * <code>getProviderClass()</code> in order to load the class. +++ * +++ * @param className Name of the concrete class corresponding to the +++ * service provider +++ * +++ * @param cl <code>ClassLoader</code> used to load the factory class. If <code>null</code> +++ * current <code>Thread</code>'s context classLoader is used to load the factory class. +++ * +++ * @param doFallback True if the current ClassLoader should be tried as +++ * a fallback if the class is not found using cl +++ * +++ * @param useBSClsLoader True if cl=null actually meant bootstrap classLoader. This parameter +++ * is needed since DocumentBuilderFactory/SAXParserFactory defined null as context classLoader. +++ */ +++ static Object newInstance(String className, ClassLoader cl, boolean doFallback, boolean useBSClsLoader) +++ throws ConfigurationError +++ { ++ try { ++- Class providerClass = getProviderClass(className, cl, doFallback); +++ Class providerClass = getProviderClass(className, cl, doFallback, useBSClsLoader); ++ Object instance = providerClass.newInstance(); ++ if (debug) { // Extra check to avoid computing cl strings ++ dPrint("created new instance of " + providerClass + ++@@ -244,6 +270,7 @@ ++ ++ // First try the Context ClassLoader ++ ClassLoader cl = ss.getContextClassLoader(); +++ boolean useBSClsLoader = false; ++ if (cl != null) { ++ is = ss.getResourceAsStream(cl, serviceId); ++ ++@@ -251,11 +278,13 @@ ++ if (is == null) { ++ cl = FactoryFinder.class.getClassLoader(); ++ is = ss.getResourceAsStream(cl, serviceId); +++ useBSClsLoader = true; ++ } ++ } else { ++ // No Context ClassLoader, try the current ClassLoader ++ cl = FactoryFinder.class.getClassLoader(); ++ is = ss.getResourceAsStream(cl, serviceId); +++ useBSClsLoader = true; ++ } ++ ++ if (is == null) { ++@@ -293,7 +322,7 @@ ++ // ClassLoader because we want to avoid the case where the ++ // resource file was found using one ClassLoader and the ++ // provider class was instantiated using a different one. ++- return newInstance(factoryClassName, cl, false); +++ return newInstance(factoryClassName, cl, false, useBSClsLoader); ++ } ++ ++ // No provider found ++--- src/javax/xml/transform/FactoryFinder.java 2013-04-22 12:37:39.312820966 -0400 +++++ src/javax/xml/transform/FactoryFinder.java 2013-04-22 12:35:08.715478293 -0400 ++@@ -25,15 +25,12 @@ ++ ++ package javax.xml.transform; ++ ++-import java.io.File; ++-import java.io.FileInputStream; ++- ++-import java.util.Properties; ++ import java.io.BufferedReader; +++import java.io.File; ++ import java.io.IOException; ++ import java.io.InputStream; ++ import java.io.InputStreamReader; ++-import java.net.URL; +++import java.util.Properties; ++ ++ /** ++ * <p>Implements pluggable Datatypes.</p> ++@@ -42,6 +39,7 @@ ++ * sync. It is package private for secure class loading.</p> ++ * ++ * @author Santiago.PericasGeertsen@sun.com +++ * @author Huizhe.Wang@oracle.com ++ */ ++ class FactoryFinder { ++ ++@@ -95,18 +93,24 @@ ++ * If the class loader supplied is <code>null</code>, first try using the ++ * context class loader followed by the current (i.e. bootstrap) class ++ * loader. +++ * +++ * Use bootstrap classLoader if cl = null and useBSClsLoader is true ++ */ ++ static private Class getProviderClass(String className, ClassLoader cl, ++- boolean doFallback) throws ClassNotFoundException +++ boolean doFallback, boolean useBSClsLoader) throws ClassNotFoundException ++ { ++ try { ++ if (cl == null) { ++- cl = ss.getContextClassLoader(); ++- if (cl == null) { ++- throw new ClassNotFoundException(); ++- } ++- else { ++- return cl.loadClass(className); +++ if (useBSClsLoader) { +++ return Class.forName(className, true, FactoryFinder.class.getClassLoader()); +++ } else { +++ cl = ss.getContextClassLoader(); +++ if (cl == null) { +++ throw new ClassNotFoundException(); +++ } +++ else { +++ return cl.loadClass(className); +++ } ++ } ++ } ++ else { ++@@ -131,8 +135,8 @@ ++ * @param className Name of the concrete class corresponding to the ++ * service provider ++ * ++- * @param cl ClassLoader to use to load the class, null means to use ++- * the bootstrap ClassLoader +++ * @param cl <code>ClassLoader</code> used to load the factory class. If <code>null</code> +++ * current <code>Thread</code>'s context classLoader is used to load the factory class. ++ * ++ * @param doFallback True if the current ClassLoader should be tried as ++ * a fallback if the class is not found using cl ++@@ -140,8 +144,30 @@ ++ static Object newInstance(String className, ClassLoader cl, boolean doFallback) ++ throws ConfigurationError ++ { +++ return newInstance(className, cl, doFallback, false); +++ } +++ +++ /** +++ * Create an instance of a class. Delegates to method +++ * <code>getProviderClass()</code> in order to load the class. +++ * +++ * @param className Name of the concrete class corresponding to the +++ * service provider +++ * +++ * @param cl <code>ClassLoader</code> used to load the factory class. If <code>null</code> +++ * current <code>Thread</code>'s context classLoader is used to load the factory class. +++ * +++ * @param doFallback True if the current ClassLoader should be tried as +++ * a fallback if the class is not found using cl +++ * +++ * @param useBSClsLoader True if cl=null actually meant bootstrap classLoader. This parameter +++ * is needed since DocumentBuilderFactory/SAXParserFactory defined null as context classLoader. +++ */ +++ static Object newInstance(String className, ClassLoader cl, boolean doFallback, boolean useBSClsLoader) +++ throws ConfigurationError +++ { ++ try { ++- Class providerClass = getProviderClass(className, cl, doFallback); +++ Class providerClass = getProviderClass(className, cl, doFallback, useBSClsLoader); ++ Object instance = providerClass.newInstance(); ++ if (debug) { // Extra check to avoid computing cl strings ++ dPrint("created new instance of " + providerClass + ++@@ -182,7 +208,7 @@ ++ String systemProp = ss.getSystemProperty(factoryId); ++ if (systemProp != null) { ++ dPrint("found system property, value=" + systemProp); ++- return newInstance(systemProp, null, true); +++ return newInstance(systemProp, null, true, false); ++ } ++ } ++ catch (SecurityException se) { ++@@ -210,7 +236,7 @@ ++ ++ if (factoryClassName != null) { ++ dPrint("found in $java.home/jaxp.properties, value=" + factoryClassName); ++- return newInstance(factoryClassName, null, true); +++ return newInstance(factoryClassName, null, true, false); ++ } ++ } ++ catch (Exception ex) { ++@@ -228,7 +254,7 @@ ++ } ++ ++ dPrint("loaded from fallback value: " + fallbackClassName); ++- return newInstance(fallbackClassName, null, true); +++ return newInstance(fallbackClassName, null, true, false); ++ } ++ ++ /* ++@@ -244,6 +270,7 @@ ++ ++ // First try the Context ClassLoader ++ ClassLoader cl = ss.getContextClassLoader(); +++ boolean useBSClsLoader = false; ++ if (cl != null) { ++ is = ss.getResourceAsStream(cl, serviceId); ++ ++@@ -251,11 +278,13 @@ ++ if (is == null) { ++ cl = FactoryFinder.class.getClassLoader(); ++ is = ss.getResourceAsStream(cl, serviceId); ++- } +++ useBSClsLoader = true; +++ } ++ } else { ++ // No Context ClassLoader, try the current ClassLoader ++ cl = FactoryFinder.class.getClassLoader(); ++ is = ss.getResourceAsStream(cl, serviceId); +++ useBSClsLoader = true; ++ } ++ ++ if (is == null) { ++@@ -293,7 +322,7 @@ ++ // ClassLoader because we want to avoid the case where the ++ // resource file was found using one ClassLoader and the ++ // provider class was instantiated using a different one. ++- return newInstance(factoryClassName, cl, false); +++ return newInstance(factoryClassName, cl, false, useBSClsLoader); ++ } ++ ++ // No provider found diff --git a/java/openjdk6/files/icedtea/openjdk/8004302-soap_test_failure.patch b/java/openjdk6/files/icedtea/openjdk/8004302-soap_test_failure.patch new file mode 100644 index 000000000000..9102d48d1cad --- /dev/null +++ b/java/openjdk6/files/icedtea/openjdk/8004302-soap_test_failure.patch @@ -0,0 +1,75 @@ +diff -Nru openjdk.orig/jdk/src/share/lib/security/java.security openjdk/jdk/src/share/lib/security/java.security +--- jdk/src/share/lib/security/java.security 2013-04-16 14:23:48.623949921 +0100 ++++ jdk/src/share/lib/security/java.security 2013-04-16 14:26:07.318184299 +0100 +@@ -128,7 +128,9 @@ + # corresponding RuntimePermission ("accessClassInPackage."+package) has + # been granted. + package.access=sun.,\ +- com.sun.xml.internal.,\ ++ com.sun.xml.internal.bind.,\ ++ com.sun.xml.internal.org.jvnet.staxex.,\ ++ com.sun.xml.internal.ws.,\ + com.sun.imageio.,\ + com.sun.istack.internal.,\ + com.sun.jmx. +@@ -144,7 +146,9 @@ + # checkPackageDefinition. + # + package.definition=sun.,\ +- com.sun.xml.internal.,\ ++ com.sun.xml.internal.bind.,\ ++ com.sun.xml.internal.org.jvnet.staxex.,\ ++ com.sun.xml.internal.ws.,\ + com.sun.imageio.,\ + com.sun.istack.internal.,\ + com.sun.jmx. +diff -Nru openjdk.orig/jdk/src/share/lib/security/java.security-solaris openjdk/jdk/src/share/lib/security/java.security-solaris +--- jdk/src/share/lib/security/java.security-solaris 2013-04-16 14:23:48.623949921 +0100 ++++ jdk/src/share/lib/security/java.security-solaris 2013-04-16 14:26:30.082551058 +0100 +@@ -129,7 +129,9 @@ + # corresponding RuntimePermission ("accessClassInPackage."+package) has + # been granted. + package.access=sun.,\ +- com.sun.xml.internal.,\ ++ com.sun.xml.internal.bind.,\ ++ com.sun.xml.internal.org.jvnet.staxex.,\ ++ com.sun.xml.internal.ws.,\ + com.sun.imageio. + com.sun.istack.internal.,\ + com.sun.jmx. +@@ -145,7 +147,9 @@ + # checkPackageDefinition. + # + package.definition=sun.,\ +- com.sun.xml.internal.,\ ++ com.sun.xml.internal.bind.,\ ++ com.sun.xml.internal.org.jvnet.staxex.,\ ++ com.sun.xml.internal.ws.,\ + com.sun.imageio. + com.sun.istack.internal.,\ + com.sun.jmx. +diff -Nru openjdk.orig/jdk/src/share/lib/security/java.security-windows openjdk/jdk/src/share/lib/security/java.security-windows +--- jdk/src/share/lib/security/java.security-windows 2013-04-16 14:23:48.623949921 +0100 ++++ jdk/src/share/lib/security/java.security-windows 2013-04-16 14:26:51.170890824 +0100 +@@ -129,7 +129,9 @@ + # corresponding RuntimePermission ("accessClassInPackage."+package) has + # been granted. + package.access=sun.,\ +- com.sun.xml.internal.,\ ++ com.sun.xml.internal.bind.,\ ++ com.sun.xml.internal.org.jvnet.staxex.,\ ++ com.sun.xml.internal.ws.,\ + com.sun.imageio. + com.sun.istack.internal.,\ + com.sun.jmx. +@@ -145,7 +147,9 @@ + # checkPackageDefinition. + # + package.definition=sun.,\ +- com.sun.xml.internal.,\ ++ com.sun.xml.internal.bind.,\ ++ com.sun.xml.internal.org.jvnet.staxex.,\ ++ com.sun.xml.internal.ws.,\ + com.sun.imageio. + com.sun.istack.internal.,\ + com.sun.jmx. |