diff --git a/.hgtags-top-repo b/.hgtags-top-repo index 9180b32f19c0184d3a13d420a238964527c78c71..86759295812f2aada0625225a10d8baef58671f9 100644 --- a/.hgtags-top-repo +++ b/.hgtags-top-repo @@ -96,3 +96,4 @@ a12a9e78df8a9d534da0b4a244ed68f0de0bd58e jdk7-b118 661360bef6ccad6c119f067f5829b207de80c936 jdk7-b119 366ff0b6d2151595629806b033e2e1497e3a55d4 jdk7-b120 2c2d4f88637b488014c37e1a2eb401f68bca8838 jdk7-b121 +f1591eed71f64f6eba79fb7426f5616cc4dfea73 jdk7-b122 diff --git a/README b/README index 5dd05f46abefdf69464563b0d67f45bdaa19f1b7..eef68df24a7e265498e5144bb21e9bc720bbf7a4 100644 --- a/README +++ b/README @@ -26,6 +26,6 @@ Simple Build Instructions: gnumake all The resulting JDK image should be found in build/*/j2sdk-image -where gnumake is GNU make 3.78.1 or newer, /usr/bin/make on Linux and +where gnumake is GNU make 3.81 or newer, /usr/bin/make on Linux and /usr/sfw/bin/gmake or /opt/sfw/bin/gmake on Solaris. diff --git a/README-builds.html b/README-builds.html index 81ada58e303b1a7534002ba0b23d072e18025522..1c2504c4dc5fcde19167ee8f8df5bee506773e6e 100644 --- a/README-builds.html +++ b/README-builds.html @@ -524,7 +524,7 @@ A few notes about using GNU make: - * The invoker will spread the varargs array, apply - * reference casts as necessary, and unbox primitive arguments. + *

+ * The invoker will behave like a call to {@link MethodHandle.invokeGeneric} with + * the indicated {@code type}. + * That is, if the target is exactly of the given {@code type}, it will behave + * like {@code invokeExact}; otherwise it behave as if {@link MethodHandle.asType} + * is used to convert the target to the required {@code type}. + *

+ * The type of the returned invoker will not be the given {@code type}, but rather + * will have all parameter and return types replaced by {@code Object}, except for + * the last parameter type, which will be the array type {@code Object[]}. + *

+ * Before invoking its target, the invoker will spread the varargs array, apply + * reference casts as necessary, and unbox and widen primitive arguments. * The return value of the invoker will be an {@code Object} reference, * boxing a primitive value if the original type returns a primitive, * and always null if the original type returns void. *

* This method is equivalent to the following code (though it may be more efficient): * 

-     * MethodHandle invoker = exactInvoker(type);
-     * MethodType vaType = MethodType.makeGeneric(objectArgCount, true);
+     * MethodHandle invoker = lookup().findVirtual(MethodHandle.class, "invokeGeneric", type);
+     * MethodType vaType = MethodType.genericMethodType(objectArgCount, true);
      * vaType = vaType.insertParameterType(0, MethodHandle.class);
-     * return spreadArguments(invoker, vaType);
+     * int spreadArgCount = type.parameterCount - objectArgCount;
+     * invoker = invoker.asSpreader(Object.class, spreadArgCount);
+     * return invoker.asType(vaType);
      *
* @param type the desired target type * @param objectArgCount number of fixed (non-varargs) {@code Object} arguments @@ -881,7 +928,6 @@ public class MethodHandles { } /** - * PROVISIONAL API, WORK IN PROGRESS: * Produce a method handle which will take a invoke any method handle of the * given type. The resulting invoker will have a type which is * exactly equal to the desired type, except that it will accept @@ -889,7 +935,7 @@ public class MethodHandles { *

* This method is equivalent to the following code (though it may be more efficient): * 

-     * lookup().findVirtual(MethodHandle.class, "invoke", type);
+     * lookup().findVirtual(MethodHandle.class, "invokeExact", type);
      *
* @param type the desired target type * @return a method handle suitable for invoking any method handle of the given type @@ -899,39 +945,6 @@ public class MethodHandles { return invokers(type).exactInvoker(); } - /** - * PROVISIONAL API, WORK IN PROGRESS: - * Produce a method handle equivalent to an invokedynamic instruction - * which has been linked to the given call site. - * Along with {@link Lookup#findVirtual}, {@link Lookup#findStatic}, - * and {@link Lookup#findSpecial}, this completes the emulation - * of the JVM's {@code invoke} instructions. - *

This method is equivalent to the following code: - * 

-     * MethodHandle getTarget, invoker, result;
-     * getTarget = lookup().bind(site, "getTarget", methodType(MethodHandle.class));
-     * invoker = exactInvoker(site.type());
-     * result = foldArguments(invoker, getTarget)
-     *
- * @return a method handle which always invokes the call site's target - */ - public static - MethodHandle dynamicInvoker(CallSite site) throws NoAccessException { - MethodHandle getCSTarget = GET_TARGET; - if (getCSTarget == null) { - try { - GET_TARGET = getCSTarget = Lookup.IMPL_LOOKUP. - findVirtual(CallSite.class, "getTarget", MethodType.methodType(MethodHandle.class)); - } catch (NoAccessException ex) { - throw new InternalError(); - } - } - MethodHandle getTarget = MethodHandleImpl.bindReceiver(IMPL_TOKEN, getCSTarget, site); - MethodHandle invoker = exactInvoker(site.type()); - return foldArguments(invoker, getTarget); - } - private static MethodHandle GET_TARGET = null; // link this lazily, not eagerly - static Invokers invokers(MethodType type) { return MethodTypeImpl.invokers(IMPL_TOKEN, type); } @@ -974,23 +987,23 @@ public class MethodHandles { if (t0.isPrimitive()) return Wrapper.asPrimitiveType(t1).cast(value); else - return Wrapper.OBJECT.cast(value, t1); + return Wrapper.OBJECT.convert(value, t1); } boolean prim0 = t0.isPrimitive(), prim1 = t1.isPrimitive(); if (!prim0) { // check contract with caller - Wrapper.OBJECT.cast(value, t0); + Wrapper.OBJECT.convert(value, t0); if (!prim1) { - return Wrapper.OBJECT.cast(value, t1); + return Wrapper.OBJECT.convert(value, t1); } // convert reference to primitive by unboxing Wrapper w1 = Wrapper.forPrimitiveType(t1); - return w1.cast(value, t1); + return w1.convert(value, t1); } // check contract with caller: Wrapper.asWrapperType(t0).cast(value); Wrapper w1 = Wrapper.forPrimitiveType(t1); - return w1.cast(value, t1); + return w1.convert(value, t1); } static @@ -1011,7 +1024,7 @@ public class MethodHandles { * Produce a method handle which adapts the type of the * given method handle to a new type by pairwise argument conversion. * The original type and new type must have the same number of arguments. - * The resulting method handle is guaranteed to confess a type + * The resulting method handle is guaranteed to report a type * which is equal to the desired new type. *

* If the original type and new type are equal, returns target. @@ -1023,34 +1036,21 @@ public class MethodHandles { * Given those types T0, T1, one of the following conversions is applied * if possible: *

*

+ * (Note: When determining the unique abstract method of a SAM interface, + * the public {@code Object} methods ({@code toString}, {@code equals}, {@code hashCode}) + * are disregarded. For example, {@link java.util.Comparator} is a SAM interface, + * even though it re-declares the {@code Object.equals} method.) + *

* No stable mapping is promised between the SAM type and * the implementation class C. Over time, several implementation * classes might be used for the same SAM type. *

* This method is not guaranteed to return a distinct - * wrapper object for each separate call. If the JVM is able - * to prove that a wrapper has already been created for a given + * wrapper object for each separate call. If the implementation is able + * to prove that a wrapper of the required SAM type + * has already been created for a given * method handle, or for another method handle with the - * same behavior, the JVM may return that wrapper in place of + * same behavior, the implementation may return that wrapper in place of * a new wrapper. + *

+ * This method is designed to apply to common use cases + * where a single method handle must interoperate with + * a type (class or interface) that implements a function-like + * API. Additional variations, such as SAM classes with + * private constructors, or interfaces with multiple but related + * entry points, must be covered by hand-written or automatically + * generated adapter classes. In those cases, consider implementing + * {@link java.dyn.MethodHandles.AsInstanceObject AsInstanceObject} + * in the adapters, so that generic code can extract the underlying + * method handle without knowing where the SAM adapter came from. * @param target the method handle to invoke from the wrapper * @param samType the desired type of the wrapper, a SAM type * @return a correctly-typed wrapper for the given {@code target} @@ -1639,38 +1882,93 @@ public class MethodHandles { */ // ISSUE: Should we delegate equals/hashCode to the targets? // Not useful unless there is a stable equals/hashCode behavior - // for MethodHandle, and for MethodHandleProvider.asMethodHandle. + // for MethodHandle, but there isn't. public static - T asInstance(MethodHandle target, Class samType) { + T asInstance(final MethodHandle target, final Class samType) { // POC implementation only; violates the above contract several ways final Method sam = getSamMethod(samType); if (sam == null) throw new IllegalArgumentException("not a SAM type: "+samType.getName()); MethodType samMT = MethodType.methodType(sam.getReturnType(), sam.getParameterTypes()); if (!samMT.equals(target.type())) - throw new IllegalArgumentException("wrong method type"); - final MethodHandle mh = target; + throw new IllegalArgumentException("wrong method type: "+target+" should match "+sam); return samType.cast(Proxy.newProxyInstance( samType.getClassLoader(), - new Class[]{ samType, MethodHandleProvider.class }, + new Class[]{ samType, AsInstanceObject.class }, new InvocationHandler() { + private Object getArg(String name) { + if ((Object)name == "getAsInstanceTarget") return target; + if ((Object)name == "getAsInstanceType") return samType; + throw new AssertionError(); + } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if (method.getDeclaringClass() == MethodHandleProvider.class) { - return method.invoke(mh, args); - } - assert method.equals(sam) : method; - return mh.invokeVarargs(args); + if (method.getDeclaringClass() == AsInstanceObject.class) + return getArg(method.getName()); + if (method.equals(sam)) + return target.invokeVarargs(args); + if (isObjectMethod(method)) + return callObjectMethod(this, method, args); + throw new InternalError(); } })); } + /** + * PROVISIONAL API, WORK IN PROGRESS: + * Interface implemented by every object which is produced by {@link #asInstance asInstance}. + * The methods of this interface allow a caller to recover the parameters + * to {@code asInstance}. + * This allows applications to repeatedly convert between method handles + * and SAM objects, without the risk of creating unbounded delegation chains. + */ + public interface AsInstanceObject { + /** Produce or recover a target method handle which is behaviorally + * equivalent to the SAM method of this object. + */ + public MethodHandle getAsInstanceTarget(); + /** Recover the SAM type for which this object was created. + */ + public Class getAsInstanceType(); + } + + private static + boolean isObjectMethod(Method m) { + switch (m.getName()) { + case "toString": + return (m.getReturnType() == String.class + && m.getParameterTypes().length == 0); + case "hashCode": + return (m.getReturnType() == int.class + && m.getParameterTypes().length == 0); + case "equals": + return (m.getReturnType() == boolean.class + && m.getParameterTypes().length == 1 + && m.getParameterTypes()[0] == Object.class); + } + return false; + } + + private static + Object callObjectMethod(Object self, Method m, Object[] args) { + assert(isObjectMethod(m)) : m; + switch (m.getName()) { + case "toString": + return self.getClass().getName() + "@" + Integer.toHexString(self.hashCode()); + case "hashCode": + return System.identityHashCode(self); + case "equals": + return (self == args[0]); + } + return null; + } + private static Method getSamMethod(Class samType) { Method sam = null; for (Method m : samType.getMethods()) { int mod = m.getModifiers(); if (Modifier.isAbstract(mod)) { - if (sam != null) + if (sam != null && !isObjectMethod(sam)) return null; // too many abstract methods sam = m; } @@ -1691,4 +1989,9 @@ public class MethodHandles { } return null; } + + /*non-public*/ + static MethodHandle withTypeHandler(MethodHandle target, MethodHandle typeHandler) { + return MethodHandleImpl.withTypeHandler(IMPL_TOKEN, target, typeHandler); + } } diff --git a/jdk/src/share/classes/java/dyn/MethodType.java b/jdk/src/share/classes/java/dyn/MethodType.java index e7e948bdb7e789e14a537457eb245815db102a9f..9045c8319a707d375dd658e7260d870b1e1544ab 100644 --- a/jdk/src/share/classes/java/dyn/MethodType.java +++ b/jdk/src/share/classes/java/dyn/MethodType.java @@ -56,21 +56,33 @@ import static sun.dyn.MemberName.newIllegalArgumentException; *

* This type can be created only by factory methods. * All factory methods may cache values, though caching is not guaranteed. + * Some factory methods are static, while others are virtual methods which + * modify precursor method types, e.g., by changing a selected parameter. + *

+ * Factory methods which operate on groups of parameter types + * are systematically presented in two versions, so that both Java arrays and + * Java lists can be used to work with groups of parameter types. + * The query methods {@code parameterArray} and {@code parameterList} + * also provide a choice between arrays and lists. *

* {@code MethodType} objects are sometimes derived from bytecode instructions * such as {@code invokedynamic}, specifically from the type descriptor strings associated * with the instructions in a class file's constant pool. - * When this occurs, any classes named in the descriptor strings must be loaded. - * (But they need not be initialized.) - * This loading may occur at any time before the {@code MethodType} object is first derived. *

- * Like classes and strings, method types can be represented directly - * in a class file's constant pool as constants to be loaded by {@code ldc} bytecodes. - * Loading such a constant causes its component classes to be loaded as necessary. + * Like classes and strings, method types can also be represented directly + * in a class file's constant pool as constants. The may be loaded by an {@code ldc} + * instruction which refers to a suitable {@code CONSTANT_MethodType} constant pool entry. + * The entry refers to a {@code CONSTANT_Utf8} spelling for the descriptor string. + * For more details, see the package summary. + *

+ * When the JVM materializes a {@code MethodType} from a descriptor string, + * all classes named in the descriptor must be accessible, and will be loaded. + * (But the classes need not be initialized, as is the case with a {@code CONSTANT_Class}.) + * This loading may occur at any time before the {@code MethodType} object is first derived. * @author John Rose, JSR 292 EG */ public final -class MethodType implements java.lang.reflect.Type { +class MethodType { private final Class rtype; private final Class[] ptypes; private MethodTypeForm form; // erased form, plus cached data about primitives @@ -119,7 +131,7 @@ class MethodType implements java.lang.reflect.Type { for (Class ptype : ptypes) { ptype.equals(ptype); // null check if (ptype == void.class) - throw newIllegalArgumentException("void parameter: "+this); + throw newIllegalArgumentException("parameter type cannot be void"); } } @@ -139,10 +151,6 @@ class MethodType implements java.lang.reflect.Type { MethodType methodType(Class rtype, Class[] ptypes) { return makeImpl(rtype, ptypes, false); } - @Deprecated public static - MethodType make(Class rtype, Class[] ptypes) { - return methodType(rtype, ptypes); - } /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. */ public static @@ -150,10 +158,6 @@ class MethodType implements java.lang.reflect.Type { boolean notrust = false; // random List impl. could return evil ptypes array return makeImpl(rtype, ptypes.toArray(NO_PTYPES), notrust); } - @Deprecated public static - MethodType make(Class rtype, List> ptypes) { - return methodType(rtype, ptypes); - } /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. * The leading parameter type is prepended to the remaining array. @@ -165,10 +169,6 @@ class MethodType implements java.lang.reflect.Type { System.arraycopy(ptypes, 0, ptypes1, 1, ptypes.length); return makeImpl(rtype, ptypes1, true); } - @Deprecated public static - MethodType make(Class rtype, Class ptype0, Class... ptypes) { - return methodType(rtype, ptype0, ptypes); - } /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. * The resulting method has no parameter types. @@ -177,10 +177,6 @@ class MethodType implements java.lang.reflect.Type { MethodType methodType(Class rtype) { return makeImpl(rtype, NO_PTYPES, true); } - @Deprecated public static - MethodType make(Class rtype) { - return methodType(rtype); - } /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. * The resulting method has the single given parameter type. @@ -189,10 +185,6 @@ class MethodType implements java.lang.reflect.Type { MethodType methodType(Class rtype, Class ptype0) { return makeImpl(rtype, new Class[]{ ptype0 }, true); } - @Deprecated public static - MethodType make(Class rtype, Class ptype0) { - return methodType(rtype, ptype0); - } /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. * The resulting method has the same parameter types as {@code ptypes}, @@ -202,10 +194,6 @@ class MethodType implements java.lang.reflect.Type { MethodType methodType(Class rtype, MethodType ptypes) { return makeImpl(rtype, ptypes.ptypes, true); } - @Deprecated public static - MethodType make(Class rtype, MethodType ptypes) { - return methodType(rtype, ptypes); - } /** * Sole factory method to find or create an interned method type. @@ -275,10 +263,6 @@ class MethodType implements java.lang.reflect.Type { } return mt; } - @Deprecated public static - MethodType makeGeneric(int objectArgCount, boolean varargs) { - return genericMethodType(objectArgCount, varargs); - } /** * All parameters and the return type will be Object. @@ -290,10 +274,6 @@ class MethodType implements java.lang.reflect.Type { MethodType genericMethodType(int objectArgCount) { return genericMethodType(objectArgCount, false); } - @Deprecated public static - MethodType makeGeneric(int objectArgCount) { - return genericMethodType(objectArgCount); - } /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. * @param num the index (zero-based) of the parameter type to change @@ -307,18 +287,6 @@ class MethodType implements java.lang.reflect.Type { return makeImpl(rtype, nptypes, true); } - /** Convenience method for {@link #insertParameterTypes}. - * @deprecated Use {@link #insertParameterTypes} instead. - */ - @Deprecated - public MethodType insertParameterType(int num, Class nptype) { - int len = ptypes.length; - Class[] nptypes = Arrays.copyOfRange(ptypes, 0, len+1); - System.arraycopy(nptypes, num, nptypes, num+1, len-num); - nptypes[num] = nptype; - return makeImpl(rtype, nptypes, true); - } - /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. * @param num the position (zero-based) of the inserted parameter type(s) * @param ptypesToInsert zero or more a new parameter types to insert into the parameter list @@ -336,6 +304,22 @@ class MethodType implements java.lang.reflect.Type { return makeImpl(rtype, nptypes, true); } + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. + * @param ptypesToInsert zero or more a new parameter types to insert after the end of the parameter list + * @return the same type, except with the selected parameter(s) appended + */ + public MethodType appendParameterTypes(Class... ptypesToInsert) { + return insertParameterTypes(parameterCount(), ptypesToInsert); + } + + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. + * @param ptypesToInsert zero or more a new parameter types to insert after the end of the parameter list + * @return the same type, except with the selected parameter(s) appended + */ + public MethodType appendParameterTypes(List> ptypesToInsert) { + return insertParameterTypes(parameterCount(), ptypesToInsert); + } + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. * @param num the position (zero-based) of the inserted parameter type(s) * @param ptypesToInsert zero or more a new parameter types to insert into the parameter list @@ -377,14 +361,6 @@ class MethodType implements java.lang.reflect.Type { return makeImpl(rtype, nptypes, true); } - /** Convenience method for {@link #dropParameterTypes}. - * @deprecated Use {@link #dropParameterTypes} instead. - */ - @Deprecated - public MethodType dropParameterType(int num) { - return dropParameterTypes(num, num+1); - } - /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. * @param nrtype a return parameter type to replace the old one with * @return the same type, except with the return type change @@ -552,7 +528,9 @@ class MethodType implements java.lang.reflect.Type { * parenthesis enclosed, comma separated list of type names, * followed immediately by the return type. *

- * If a type name is array, it the base type followed + * Each type is represented by its + * {@link java.lang.Class#getSimpleName simple name}. + * If a type name name is array, it the base type followed * by [], rather than the Class.getName of the array type. */ @Override @@ -561,35 +539,13 @@ class MethodType implements java.lang.reflect.Type { sb.append("("); for (int i = 0; i < ptypes.length; i++) { if (i > 0) sb.append(","); - putName(sb, ptypes[i]); + sb.append(ptypes[i].getSimpleName()); } sb.append(")"); - putName(sb, rtype); + sb.append(rtype.getSimpleName()); return sb.toString(); } - static void putName(StringBuilder sb, Class cls) { - int brackets = 0; - while (cls.isArray()) { - cls = cls.getComponentType(); - brackets++; - } - String n = cls.getName(); - /* - if (n.startsWith("java.lang.")) { - String nb = n.substring("java.lang.".length()); - if (nb.indexOf('.') < 0) n = nb; - } else if (n.indexOf('.') < 0) { - n = "."+n; // anonymous package - } - */ - sb.append(n); - while (brackets > 0) { - sb.append("[]"); - brackets--; - } - } - /// Queries which have to do with the bytecode architecture /** The number of JVM stack slots required to invoke a method @@ -690,14 +646,4 @@ class MethodType implements java.lang.reflect.Type { public String toMethodDescriptorString() { return BytecodeDescriptor.unparse(this); } - - /** Temporary alias for toMethodDescriptorString; delete after M3. */ - public String toBytecodeString() { - return toMethodDescriptorString(); - } - /** Temporary alias for fromMethodDescriptorString; delete after M3. */ - public static MethodType fromBytecodeString(String descriptor, ClassLoader loader) - throws IllegalArgumentException, TypeNotPresentException { - return fromMethodDescriptorString(descriptor, loader); - } } diff --git a/jdk/src/share/classes/java/dyn/MutableCallSite.java b/jdk/src/share/classes/java/dyn/MutableCallSite.java new file mode 100644 index 0000000000000000000000000000000000000000..b33c41c1a5ad6bd059e2ccdb2ff8a4b7b303da55 --- /dev/null +++ b/jdk/src/share/classes/java/dyn/MutableCallSite.java @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2008, 2010, 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.dyn; + +import sun.dyn.*; +import sun.dyn.empty.Empty; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * A {@code MutableCallSite} is a {@link CallSite} whose target variable + * behaves like an ordinary field. + * An {@code invokedynamic} instruction linked to a {@code MutableCallSite} delegates + * all calls to the site's current target. + * The {@linkplain CallSite#dynamicInvoker dynamic invoker} of a mutable call site + * also delegates each call to the site's current target. + *

+ * Here is an example of a mutable call site which introduces a + * state variable into a method handle chain. + * 

+MutableCallSite name = new MutableCallSite(MethodType.methodType(String.class));
+MethodHandle MH_name = name.dynamicInvoker();
+MethodType MT_str2 = MethodType.methodType(String.class, String.class);
+MethodHandle MH_upcase = MethodHandles.lookup()
+    .findVirtual(String.class, "toUpperCase", MT_str2);
+MethodHandle worker1 = MethodHandles.filterReturnValue(MH_name, MH_upcase);
+name.setTarget(MethodHandles.constant(String.class, "Rocky"));
+assertEquals("ROCKY", (String) worker1.invokeExact());
+name.setTarget(MethodHandles.constant(String.class, "Fred"));
+assertEquals("FRED", (String) worker1.invokeExact());
+// (mutation can be continued indefinitely)
+ *
+ *

+ * The same call site may be used in several places at once. + * 

+MethodHandle MH_dear = MethodHandles.lookup()
+    .findVirtual(String.class, "concat", MT_str2).bindTo(", dear?");
+MethodHandle worker2 = MethodHandles.filterReturnValue(MH_name, MH_dear);
+assertEquals("Fred, dear?", (String) worker2.invokeExact());
+name.setTarget(MethodHandles.constant(String.class, "Wilma"));
+assertEquals("WILMA", (String) worker1.invokeExact());
+assertEquals("Wilma, dear?", (String) worker2.invokeExact());
+ *
+ *

+ * Non-synchronization of target values: + * A write to a mutable call site's target does not force other threads + * to become aware of the updated value. Threads which do not perform + * suitable synchronization actions relative to the updated call site + * may cache the old target value and delay their use of the new target + * value indefinitely. + * (This is a normal consequence of the Java Memory Model as applied + * to object fields.) + *

+ * The {@link #sync sync} operation provides a way to force threads + * to accept a new target value, even if there is no other synchronization. + *

+ * For target values which will be frequently updated, consider using + * a {@linkplain VolatileCallSite volatile call site} instead. + * @author John Rose, JSR 292 EG + */ +public class MutableCallSite extends CallSite { + /** + * Make a blank call site object with the given method type. + * An initial target method is supplied which will throw + * an {@link IllegalStateException} if called. + *

+ * Before this {@code CallSite} object is returned from a bootstrap method, + * it is usually provided with a more useful target method, + * via a call to {@link CallSite#setTarget(MethodHandle) setTarget}. + * @throws NullPointerException if the proposed type is null + */ + public MutableCallSite(MethodType type) { + super(type); + } + + /** + * Make a blank call site object, possibly equipped with an initial target method handle. + * @param target the method handle which will be the initial target of the call site + * @throws NullPointerException if the proposed target is null + */ + public MutableCallSite(MethodHandle target) { + super(target); + } + + /** + * Perform a synchronization operation on each call site in the given array, + * forcing all other threads to throw away any cached values previously + * loaded from the target of any of the call sites. + *

+ * This operation does not reverse any calls that have already started + * on an old target value. + * (Java supports {@linkplain java.lang.Object#wait() forward time travel} only.) + *

+ * The overall effect is to force all future readers of each call site's target + * to accept the most recently stored value. + * ("Most recently" is reckoned relative to the {@code sync} itself.) + * Conversely, the {@code sync} call may block until all readers have + * (somehow) decached all previous versions of each call site's target. + *

+ * To avoid race conditions, calls to {@code setTarget} and {@code sync} + * should generally be performed under some sort of mutual exclusion. + * Note that reader threads may observe an updated target as early + * as the {@code setTarget} call that install the value + * (and before the {@code sync} that confirms the value). + * On the other hand, reader threads may observe previous versions of + * the target until the {@code sync} call returns + * (and after the {@code setTarget} that attempts to convey the updated version). + *

+ * In terms of the Java Memory Model, this operation performs a synchronization + * action which is comparable in effect to the writing of a volatile variable + * by the current thread, and an eventual volatile read by every other thread + * that may access one of the affected call sites. + *

+ * The following effects are apparent, for each individual call site {@code S}: + *

+ * Because of the last point, the implementation behaves as if a + * volatile read of {@code V} were performed by {@code T} + * immediately after its action {@code A}. In the local ordering + * of actions in {@code T}, this read happens before any future + * read of the target of {@code S}. It is as if the + * implementation arbitrarily picked a read of {@code S}'s target + * by {@code T}, and forced a read of {@code V} to precede it, + * thereby ensuring communication of the new target value. + *

+ * As long as the constraints of the Java Memory Model are obeyed, + * implementations may delay the completion of a {@code sync} + * operation while other threads ({@code T} above) continue to + * use previous values of {@code S}'s target. + * However, implementations are (as always) encouraged to avoid + * livelock, and to eventually require all threads to take account + * of the updated target. + *

+ * This operation is likely to be expensive and should be used sparingly. + * If possible, it should be buffered for batch processing on sets of call sites. + *

+ * (This is a static method on a set of call sites, not a + * virtual method on a single call site, for performance reasons. + * Some implementations may incur a large fixed overhead cost + * for processing one or more synchronization operations, + * but a small incremental cost for each additional call site. + * In any case, this operation is likely to be costly, since + * other threads may have to be somehow interrupted + * in order to make them notice the updated target value. + * However, it may be observed that a single call to synchronize + * several sites has the same formal effect as many calls, + * each on just one of the sites.) + *

+ * Simple implementations of {@code MutableCallSite} may use + * a volatile variable for the target of a mutable call site. + * In such an implementation, the {@code sync} method can be a no-op, + * and yet it will conform to the JMM behavior documented above. + */ + public static void sync(MutableCallSite[] sites) { + STORE_BARRIER.lazySet(0); + // FIXME: NYI + } + private static final AtomicInteger STORE_BARRIER = new AtomicInteger(); +} diff --git a/jdk/src/share/classes/java/dyn/Switcher.java b/jdk/src/share/classes/java/dyn/Switcher.java new file mode 100644 index 0000000000000000000000000000000000000000..b0838764b4417a68bda5dbde1d2418feceb600ce --- /dev/null +++ b/jdk/src/share/classes/java/dyn/Switcher.java @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2010, 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.dyn; + +/** + *

+ * A {@code Switcher} is an object which can publish state transitions to other threads. + * A switcher is initially in the valid state, but may at any time be + * changed to the invalid state. Invalidation cannot be reversed. + *

+ * A single switcher may be used to create any number of guarded method handle pairs. + * Each guarded pair is wrapped in a new method handle {@code M}, + * which is permanently associated with the switcher that created it. + * Each pair consists of a target {@code T} and a fallback {@code F}. + * While the switcher is valid, invocations to {@code M} are delegated to {@code T}. + * After it is invalidated, invocations are delegated to {@code F}. + *

+ * Invalidation is global and immediate, as if the switcher contained a + * volatile boolean variable consulted on every call to {@code M}. + * The invalidation is also permanent, which means the switcher + * can change state only once. + *

+ * Here is an example of a switcher in action: + * 

+MethodType MT_str2 = MethodType.methodType(String.class, String.class);
+MethodHandle MH_strcat = MethodHandles.lookup()
+    .findVirtual(String.class, "concat", MT_str2);
+Switcher switcher = new Switcher();
+// the following steps may be repeated to re-use the same switcher:
+MethodHandle worker1 = strcat;
+MethodHandle worker2 = MethodHandles.permuteArguments(strcat, MT_str2, 1, 0);
+MethodHandle worker = switcher.guardWithTest(worker1, worker2);
+assertEquals("method", (String) worker.invokeExact("met", "hod"));
+switcher.invalidate();
+assertEquals("hodmet", (String) worker.invokeExact("met", "hod"));
+ *
+ *

+ * Implementation Note: + * A switcher behaves as if implemented on top of {@link MutableCallSite}, + * approximately as follows: + * 

+public class Switcher {
+  private static final MethodHandle
+    K_true  = MethodHandles.constant(boolean.class, true),
+    K_false = MethodHandles.constant(boolean.class, false);
+  private final MutableCallSite mcs;
+  private final MethodHandle mcsInvoker;
+  public Switcher() {
+    this.mcs = new MutableCallSite(K_true);
+    this.mcsInvoker = mcs.dynamicInvoker();
+  }
+  public MethodHandle guardWithTest(
+                MethodHandle target, MethodHandle fallback) {
+    // Note:  mcsInvoker is of type boolean().
+    // Target and fallback may take any arguments, but must have the same type.
+    return MethodHandles.guardWithTest(this.mcsInvoker, target, fallback);
+  }
+  public static void invalidateAll(Switcher[] switchers) {
+    List mcss = new ArrayList<>();
+    for (Switcher s : switchers)  mcss.add(s.mcs);
+    for (MutableCallSite mcs : mcss)  mcs.setTarget(K_false);
+    MutableCallSite.sync(mcss.toArray(new MutableCallSite[0]));
+  }
+}
+ *
+ * @author Remi Forax, JSR 292 EG + */ +public class Switcher { + private static final MethodHandle + K_true = MethodHandles.constant(boolean.class, true), + K_false = MethodHandles.constant(boolean.class, false); + + private final MutableCallSite mcs; + private final MethodHandle mcsInvoker; + + /** Create a switcher. */ + public Switcher() { + this.mcs = new MutableCallSite(K_true); + this.mcsInvoker = mcs.dynamicInvoker(); + } + + /** + * Return a method handle which always delegates either to the target or the fallback. + * The method handle will delegate to the target exactly as long as the switcher is valid. + * After that, it will permanently delegate to the fallback. + *

+ * The target and fallback must be of exactly the same method type, + * and the resulting combined method handle will also be of this type. + * @see MethodHandles#guardWithTest + */ + public MethodHandle guardWithTest(MethodHandle target, MethodHandle fallback) { + if (mcs.getTarget() == K_false) + return fallback; // already invalid + return MethodHandles.guardWithTest(mcsInvoker, target, fallback); + } + + /** Set all of the given switchers into the invalid state. */ + public static void invalidateAll(Switcher[] switchers) { + MutableCallSite[] sites = new MutableCallSite[switchers.length]; + int fillp = 0; + for (Switcher switcher : switchers) { + sites[fillp++] = switcher.mcs; + switcher.mcs.setTarget(K_false); + } + MutableCallSite.sync(sites); + } +} diff --git a/jdk/src/share/classes/java/dyn/VolatileCallSite.java b/jdk/src/share/classes/java/dyn/VolatileCallSite.java new file mode 100644 index 0000000000000000000000000000000000000000..8c603b9191593991b7b0c9fd911d8f8a8d43056e --- /dev/null +++ b/jdk/src/share/classes/java/dyn/VolatileCallSite.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2010, 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.dyn; + +import java.util.List; + +/** + * A {@code VolatileCallSite} is a {@link CallSite} whose target acts like a volatile variable. + * An {@code invokedynamic} instruction linked to a {@code VolatileCallSite} sees updates + * to its call site target immediately, even if the update occurs in another thread. + * There may be a performance penalty for such tight coupling between threads. + *

+ * Unlike {@code MutableCallSite}, there is no + * {@linkplain MutableCallSite#sync sync operation} on volatile + * call sites, since every write to a volatile variable is implicitly + * synchronized with reader threads. + *

+ * In other respects, a {@code VolatileCallSite} is interchangeable + * with {@code MutableCallSite}. + * @see MutableCallSite + * @author John Rose, JSR 292 EG + */ +public class VolatileCallSite extends CallSite { + /** Create a call site with a volatile target. + * The initial target is set to a method handle + * of the given type which will throw {@code IllegalStateException}. + * @throws NullPointerException if the proposed type is null + */ + public VolatileCallSite(MethodType type) { + super(type); + } + + /** Create a call site with a volatile target. + * The target is set to the given value. + * @throws NullPointerException if the proposed target is null + */ + public VolatileCallSite(MethodHandle target) { + super(target); + } + + /** Internal override to nominally final getTarget. */ + @Override + MethodHandle getTarget0() { + return getTargetVolatile(); + } + + /** + * Set the target method of this call site, as a volatile variable. + * Has the same effect as {@link CallSite#setTarget CallSite.setTarget}, with the additional + * effects associated with volatiles, in the Java Memory Model. + */ + @Override public void setTarget(MethodHandle newTarget) { + checkTargetChange(getTargetVolatile(), newTarget); + setTargetVolatile(newTarget); + } +} diff --git a/jdk/src/share/classes/java/dyn/package-info.java b/jdk/src/share/classes/java/dyn/package-info.java index 37555be14b4044dafaf6dc56ceb2c239bc3b41cd..41d97b8b15545060bfaf5123570d6904980a9129 100644 --- a/jdk/src/share/classes/java/dyn/package-info.java +++ b/jdk/src/share/classes/java/dyn/package-info.java @@ -24,7 +24,6 @@ */ /** - * PROVISIONAL API, WORK IN PROGRESS: * This package contains dynamic language support provided directly by * the Java core class libraries and virtual machine. *

@@ -42,13 +41,6 @@ * argument and return value conversions are applied. * * - *

  • In source code, the class {@link java.dyn.InvokeDynamic InvokeDynamic} appears to accept - * any static method invocation, of any name and any signature. - * But instead of emitting - * an {@code invokestatic} instruction for such a call, the Java compiler emits - * an {@code invokedynamic} instruction with the given name and signature. - *
    • - * *
  • The JVM bytecode format supports immediate constants of * the classes {@link java.dyn.MethodHandle MethodHandle} and {@link java.dyn.MethodType MethodType}. *
    • @@ -56,51 +48,68 @@ * *

    Corresponding JVM bytecode format changes

    * The following low-level information is presented here as a preview of - * changes being made to the Java Virtual Machine specification for JSR 292. + * changes being made to the Java Virtual Machine specification for JSR 292. + * This information will be incorporated in a future version of the JVM specification. * - *

    {@code invokedynamic} instruction format

    + *

    {@code invokedynamic} instruction format

    * In bytecode, an {@code invokedynamic} instruction is formatted as five bytes. * The first byte is the opcode 186 (hexadecimal {@code BA}). * The next two bytes are a constant pool index (in the same format as for the other {@code invoke} instructions). * The final two bytes are reserved for future use and required to be zero. * The constant pool reference of an {@code invokedynamic} instruction is to a entry - * with tag {@code CONSTANT_InvokeDynamic} (decimal 17). See below for its format. - * The entry specifies the bootstrap method (a {@link java.dyn.MethodHandle MethodHandle} constant), - * the dynamic invocation name, and the argument types and return type of the call. + * with tag {@code CONSTANT_InvokeDynamic} (decimal 18). See below for its format. + * (The tag value 17 is also temporarily allowed. See below.) + * The entry specifies the following information: + * *

    * Each instance of an {@code invokedynamic} instruction is called a dynamic call site. * Multiple instances of an {@code invokedynamic} instruction can share a single * {@code CONSTANT_InvokeDynamic} entry. * In any case, distinct call sites always have distinct linkage state. *

    - * Moreover, for the purpose of distinguishing dynamic call sites, - * the JVM is allowed (but not required) to make internal copies - * of {@code invokedynamic} instructions, each one - * constituting a separate dynamic call site with its own linkage state. - * Such copying, if it occurs, cannot be observed except indirectly via - * execution of bootstrap methods and target methods. - *

    * A dynamic call site is originally in an unlinked state. In this state, there is * no target method for the call site to invoke. * A dynamic call site is linked by means of a bootstrap method, * as described below. - *

    - * (Historic Note: Some older JVMs may allow the index of a {@code CONSTANT_NameAndType} + * + *

    + * (Historic Note: Some older JVMs may allow the index of a {@code CONSTANT_NameAndType} * instead of a {@code CONSTANT_InvokeDynamic}. In earlier, obsolete versions of this API, the - * bootstrap method was specified dynamically, in a per-class basis, during class initialization.) + * bootstrap method was specified dynamically, in a per-class basis, during class initialization.) * - *

    constant pool entries for {@code invokedynamic} instructions

    - * If a constant pool entry has the tag {@code CONSTANT_InvokeDynamic} (decimal 17), - * it must contain exactly four more bytes. - * The first two bytes after the tag must be an index to a {@code CONSTANT_MethodHandle} - * entry, and the second two bytes must be an index to a {@code CONSTANT_NameAndType}. + *

    constant pool entries for {@code invokedynamic} instructions

    + * If a constant pool entry has the tag {@code CONSTANT_InvokeDynamic} (decimal 18), + * it must contain exactly four more bytes after the tag. + * These bytes are interpreted as two 16-bit indexes, in the usual {@code u2} format. + * The first pair of bytes after the tag must be an index into a side table called the + * bootstrap method table, which is stored in the {@code BootstrapMethods} + * attribute as described below. + * The second pair of bytes must be an index to a {@code CONSTANT_NameAndType}. + * This table is not part of the constant pool. Instead, it is stored + * in a class attribute named {@code BootstrapMethods}, described below. + *

    * The first index specifies a bootstrap method used by the associated dynamic call sites. * The second index specifies the method name, argument types, and return type of the dynamic call site. * The structure of such an entry is therefore analogous to a {@code CONSTANT_Methodref}, - * except that the {@code CONSTANT_Class} reference in a {@code CONSTANT_Methodref} entry - * is replaced by a bootstrap method reference. + * except that the bootstrap method specifier reference replaces + * the {@code CONSTANT_Class} reference of a {@code CONSTANT_Methodref} entry. + *

    + * Some older JVMs may allow an older constant pool entry tag of decimal 17. + * The format and behavior of a constant pool entry with this tag is identical to + * an entry with a tag of decimal 18, except that the first index refers directly + * to a {@code CONSTANT_MethodHandle} to use as the bootstrap method. + * This format does not require the bootstrap method table. * - *

    constant pool entries for {@code MethodType}s

    + *

    + * (Note: The Proposed Final Draft of this specification is likely to support + * only the tag 18, not the tag 17.) + * + *

    constant pool entries for {@linkplain java.dyn.MethodType method types}

    * If a constant pool entry has the tag {@code CONSTANT_MethodType} (decimal 16), * it must contain exactly two more bytes, which must be an index to a {@code CONSTANT_Utf8} * entry which represents a method type signature. @@ -113,7 +122,7 @@ * Access checking and error reporting is performed exactly as it is for * references by {@code ldc} instructions to {@code CONSTANT_Class} constants. * - *

    constant pool entries for {@code MethodHandle}s

    + *

    constant pool entries for {@linkplain java.dyn.MethodHandle method handles}

    * If a constant pool entry has the tag {@code CONSTANT_MethodHandle} (decimal 15), * it must contain exactly three more bytes. The first byte after the tag is a subtag * value which must be in the range 1 through 9, and the last two must be an index to a @@ -129,7 +138,7 @@ *

    * As with {@code CONSTANT_Class} and {@code CONSTANT_MethodType} constants, * the {@code Class} or {@code MethodType} object which reifies the field or method's - * type is created. Any classes mentioned in this reificaiton will be loaded if necessary, + * type is created. Any classes mentioned in this reification will be loaded if necessary, * but not initialized, and access checking and error reporting performed as usual. *

    * The method handle itself will have a type and behavior determined by the subtag as follows: @@ -148,16 +157,45 @@ * * *

    - * The special names {@code } and {@code } are not allowed except for subtag 8 as shown. + * The special name {@code } is not allowed. + * The special name {@code } is not allowed except for subtag 8 as shown. *

    - * The verifier applies the same access checks and restrictions for these references as for the hypothetical + * The JVM verifier and linker apply the same access checks and restrictions for these references as for the hypothetical * bytecode instructions specified in the last column of the table. In particular, method handles to * private and protected members can be created in exactly those classes for which the corresponding * normal accesses are legal. *

    - * None of these constant types force class initialization. - * Method handles for subtags {@code REF_getStatic}, {@code REF_putStatic}, and {@code REF_invokeStatic} + * A constant may refer to a method or constructor with the {@code varargs} + * bit (hexadecimal {@code 80}) set in its modifier bitmask. + * The method handle constant produced for such a method behaves the same + * as if the {@code varargs} bit were not set. + * The argument-collecting behavior of {@code varargs} can be emulated by + * adapting the method handle constant with + * {@link java.dyn.MethodHandle#asCollector asCollector}. + * There is no provision for doing this automatically. + *

    + * Although the {@code CONSTANT_MethodHandle} and {@code CONSTANT_MethodType} constant types + * resolve class names, they do not force class initialization. + * Method handle constants for subtags {@code REF_getStatic}, {@code REF_putStatic}, and {@code REF_invokeStatic} * may force class initialization on their first invocation, just like the corresponding bytecodes. + *

    + * The rules of section 5.4.3 of the + * JVM Specification + * apply to the resolution of {@code CONSTANT_MethodType}, {@code CONSTANT_MethodHandle}, + * and {@code CONSTANT_InvokeDynamic} constants, + * by the execution of {@code invokedynamic} and {@code ldc} instructions. + * (Roughly speaking, this means that every use of a constant pool entry + * must lead to the same outcome. + * If the resoultion succeeds, the same object reference is produced + * by every subsequent execution of the same instruction. + * If the resolution of the constant causes an error to occur, + * the same error will be re-thrown on every subsequent attempt + * to use this particular constant.) + *

    + * Constants created by the resolution of these constant pool types are not necessarily + * interned. Except for {@link CONSTANT_Class} and {@link CONSTANT_String} entries, + * two distinct constant pool entries might not resolve to the same reference + * even if they contain the same symbolic reference. * *

    Bootstrap Methods

    * Before the JVM can execute a dynamic call site (an {@code invokedynamic} instruction), @@ -181,24 +219,36 @@ * call site execution. * Linkage does not trigger class initialization. *

    - * Next, the bootstrap method call is started, with four values being stacked: + * Next, the bootstrap method call is started, with four or five values being stacked: *

    * The method handle is then applied to the other values as if by - * {@linkplain java.dyn.MethodHandle#invokeGeneric the invokeGeneric method}. - * The returned result must be a {@link java.dyn.CallSite CallSite}, a {@link java.dyn.MethodHandle MethodHandle}, - * or another {@link java.dyn.MethodHandleProvider MethodHandleProvider} value. - * The method {@linkplain java.dyn.MethodHandleProvider#asMethodHandle asMethodHandle} - * is then called on the returned value. The result of that second - * call is the {@code MethodHandle} which becomes the - * permanent binding for the dynamic call site. - * That method handle's type must be exactly equal to the type + * {@link java.dyn.MethodHandle#invokeGeneric invokeGeneric}. + * The returned result must be a {@link java.dyn.CallSite CallSite} (or a subclass). + * The type of the call site's target must be exactly equal to the type * derived from the dynamic call site signature and passed to * the bootstrap method. + * The call site then becomes permanently linked to the dynamic call site. + *

    + * As long as each bootstrap method can be correctly invoked + * by invokeGeneric, its detailed type is arbitrary. + * For example, the first argument could be {@code Object} + * instead of {@code MethodHandles.Lookup}, and the return type + * could also be {@code Object} instead of {@code CallSite}. + *

    + * As with any method handle constant, a {@code varargs} modifier bit + * on the bootstrap method is ignored. + *

    + * Note that the first argument of the bootstrap method cannot be + * a simple {@code Class} reference. (This is a change from earlier + * versions of this specification. If the caller class is needed, + * it is easy to {@linkplain java.dyn.MethodHandles.Lookup#lookupClass() extract it} + * from the {@code Lookup} object.) *

    * After resolution, the linkage process may fail in a variety of ways. * All failures are reported by an {@link java.dyn.InvokeDynamicBootstrapError InvokeDynamicBootstrapError}, @@ -206,81 +256,209 @@ * site execution. * The following circumstances will cause this: *

    - *

    timing of linkage

    + * + *

    timing of linkage

    * A dynamic call site is linked just before its first execution. * The bootstrap method call implementing the linkage occurs within * a thread that is attempting a first execution. *

    - * If there are several such threads, the JVM picks one thread - * and runs the bootstrap method while the others wait for the - * invocation to terminate normally or abnormally. - *

    - * After a bootstrap method is called and a method handle target - * successfully extracted, the JVM attempts to link the instruction - * being executed to the target method handle. - * This may fail if there has been intervening linkage - * or invalidation event for the same instruction. - * If such a failure occurs, the dynamic call site must be - * re-executed from the beginning, either re-linking it - * (if it has been invalidated) or invoking the target - * (if it the instruction has been linked by some other means). - *

    - * If the instruction is linked successfully, the target method - * handle is invoked to complete the instruction execution. - * The state of linkage continues until the method containing the - * dynamic call site is garbage collected, or the dynamic call site - * is invalidated by an explicit request, - * such as {@link java.dyn.Linkage#invalidateCallerClass Linkage.invalidateCallerClass}. + * If there are several such threads, the bootstrap method may be + * invoked in several threads concurrently. + * Therefore, bootstrap methods which access global application + * data must take the usual precautions against race conditions. + * In any case, every {@code invokedynamic} instruction is either + * unlinked or linked to a unique {@code CallSite} object. *

    * In an application which requires dynamic call sites with individually * mutable behaviors, their bootstrap methods should produce distinct * {@link java.dyn.CallSite CallSite} objects, one for each linkage request. - *

    - * If a class containing {@code invokedynamic} instructions - * is {@linkplain java.dyn.Linkage#invalidateCallerClass(Class) invalidated}, - * subsequent execution of those {@code invokedynamic} instructions - * will require linking. - * It is as if they had never been executed in the first place. - * (However, invalidation does not cause constant pool entries to be - * resolved a second time.) - *

    - * Invalidation events and bootstrap method calls for a particular - * dynamic call site are globally ordered relative to each other. - * When an invokedynamic instruction is invalidated, if there is - * simultaneously a bootstrap method invocation in process - * (in the same thread or a different thread), the result - * eventually returned must not be used to link the call site. - * Put another way, when a call site is invalidated, its - * subsequent linkage (if any) must be performed by a bootstrap method - * call initiated after the invalidation occurred. + * Alternatively, an application can link a single {@code CallSite} object + * to several {@code invokedynamic} instructions, in which case + * a change to the target method will become visible at each of + * the instructions. *

    * If several threads simultaneously execute a bootstrap method for a single dynamic - * call site, the JVM must choose one target object and installs it visibly to + * call site, the JVM must choose one {@code CallSite} object and install it visibly to * all threads. Any other bootstrap method calls are allowed to complete, but their * results are ignored, and their dynamic call site invocations proceed with the originally * chosen target object. + * + *

    + * (Historic Note: Unlike some previous versions of this specification, + * these rules do not enable the JVM to duplicate dynamic call sites, + * or to issue “causeless” bootstrap method calls. + * Every dynamic call site transitions at most once from unlinked to linked, + * just before its first invocation.) + * + *

    the {@code BootstrapMethods} attribute

    + * Each {@code CONSTANT_InvokeDynamic} entry contains an index which references + * a bootstrap method specifier; all such specifiers are contained in a separate array. + * This array is defined by a class attribute named {@code BootstrapMethods}. + * The body of this attribute consists of a sequence of byte pairs, all interpreted as + * as 16-bit counts or constant pool indexes, in the {@code u2} format. + * The attribute body starts with a count of bootstrap method specifiers, + * which is immediately followed by the sequence of specifiers. + *

    + * Each bootstrap method specifier contains an index to a + * {@code CONSTANT_MethodHandle} constant, which is the bootstrap + * method itself. + * This is followed by a count, and then a sequence (perhaps empty) of + * indexes to additional static arguments + * for the bootstrap method. + *

    + * During class loading, the verifier must check the structure of the + * {@code BootstrapMethods} attribute. In particular, each constant + * pool index must be of the correct type. A bootstrap method index + * must refer to a {@code CONSTANT_MethodHandle} (tag 15). + * Every other index must refer to a valid operand of an + * {@code ldc_w} or {@code ldc2_w} instruction (tag 3..8 or 15..16). + * + *

    static arguments to the bootstrap method

    + * An {@code invokedynamic} instruction specifies at least three arguments + * to pass to its bootstrap method: + * The caller class (expressed as a {@link java.dyn.MethodHandles.Lookup Lookup object}, + * the name (extracted from the {@code CONSTANT_NameAndType} entry), + * and the type (also extracted from the {@code CONSTANT_NameAndType} entry). + * The {@code invokedynamic} instruction may specify additional metadata values + * to pass to its bootstrap method. + * Collectively, these values are called static arguments to the + * {@code invokedynamic} instruction, because they are used once at link + * time to determine the instruction's behavior on subsequent sets of + * dynamic arguments. + *

    + * Static arguments are used to communicate application-specific meta-data + * to the bootstrap method. + * Drawn from the constant pool, they may include references to classes, method handles, + * strings, or numeric data that may be relevant to the task of linking that particular call site. + *

    + * Static arguments are specified constant pool indexes stored in the {@code BootstrapMethods} attribute. + * Before the bootstrap method is invoked, each index is used to compute an {@code Object} + * reference to the indexed value in the constant pool. + * If the value is a primitive type, it is converted to a reference by boxing conversion. + * The valid constant pool entries are listed in this table: + * + * + * + * + * + * + * + * + * + * + * + *
    entry typeargument typeargument value
    CONSTANT_Stringjava.lang.Stringthe indexed string literal
    CONSTANT_Classjava.lang.Classthe indexed class, resolved
    CONSTANT_Integerjava.lang.Integerthe indexed int value
    CONSTANT_Longjava.lang.Longthe indexed long value
    CONSTANT_Floatjava.lang.Floatthe indexed float value
    CONSTANT_Doublejava.lang.Doublethe indexed double value
    CONSTANT_MethodHandlejava.dyn.MethodHandlethe indexed method handle constant
    CONSTANT_MethodTypejava.dyn.MethodTypethe indexed method type constant
    + *     + *

    + * If a given {@code invokedynamic} instruction specifies no static arguments, + * the instruction's bootstrap method will be invoked on three arguments, + * conveying the instruction's caller class, name, and method type. + * If the {@code invokedynamic} instruction specifies one or more static arguments, + * a fourth argument will be passed to the bootstrap argument, + * either an {@code Object} reference to the sole extra argument (if there is one) + * or an {@code Object} array of references to all the arguments (if there are two or more), + * as if the bootstrap method is a variable-arity method. + * + * + * + * + * + * + *
    Nsample bootstrap method
    0CallSite bootstrap(Lookup caller, String name, MethodType type)
    1CallSite bootstrap(Lookup caller, String name, MethodType type, Object arg)
    2CallSite bootstrap(Lookup caller, String name, MethodType type, Object... args)
    + *     + *

    + * The argument and return types listed here are used by the {@code invokeGeneric} + * call to the bootstrap method. + * As noted above, the actual method type of the bootstrap method can vary. + * For example, the fourth argument could be {@code MethodHandle}, + * if that is the type of the corresponding constant in + * the {@code CONSTANT_InvokeDynamic} entry. + * In that case, the {@code invokeGeneric} call will pass the extra method handle + * constant as an {@code Object}, but the type matching machinery of {@code invokeGeneric} + * will cast the reference back to {@code MethodHandle} before invoking the bootstrap method. + * (If a string constant were passed instead, by badly generated code, that cast would then fail.) + *

    + * If the fourth argument is an array, the array element type must be {@code Object}, + * since object arrays (as produced by the JVM at this point) cannot be converted + * to other array types. + *

    + * If an array is provided, it will appear to be freshly allocated. + * That is, the same array will not appear to two bootstrap method calls. + *

    + * Extra bootstrap method arguments are intended to allow language implementors + * to safely and compactly encode metadata. + * In principle, the name and extra arguments are redundant, + * since each call site could be given its own unique bootstrap method. + * Such a practice is likely to produce large class files and constant pools. + * + *

    + * PROVISIONAL API, WORK IN PROGRESS: + * (Usage Note: There is no mechanism for specifying five or more positional arguments to the bootstrap method. + * If there are two or more arguments, the Java code of the bootstrap method is required to extract them from + * a varargs-style object array. + * This design uses varargs because it anticipates some use cases where bootstrap arguments + * contribute components of variable-length structures, such as virtual function tables + * or interpreter token streams. + * Such parameters would be awkward or impossible to manage if represented + * as normal positional method arguments, + * since there would need to be one Java method per length. + * On balance, leaving out the varargs feature would cause more trouble to users than keeping it. + * Also, this design allows bootstrap methods to be called in a limited JVM stack depth. + * At both the user and JVM level, the difference between varargs and non-varargs + * calling sequences can easily be bridged via the + * {@link java.dyn.MethodHandle#asSpreader asSpreader} + * and {@link java.dyn.MethodHandle#asSpreader asCollector} methods.) + * + *

    Structure Summary

    + * 
    // summary of constant and attribute structures
+struct CONSTANT_MethodHandle_info {
+  u1 tag = 15;
+  u1 reference_kind;       // 1..8 (one of REF_invokeVirtual, etc.)
+  u2 reference_index;      // index to CONSTANT_Fieldref or *Methodref
+}
+struct CONSTANT_MethodType_info {
+  u1 tag = 16;
+  u2 descriptor_index;    // index to CONSTANT_Utf8, as in NameAndType
+}
+struct CONSTANT_InvokeDynamic_17_info {
+  u1 tag = 17;
+  u2 bootstrap_method_index;   // index to CONSTANT_MethodHandle
+  u2 name_and_type_index;      // same as for CONSTANT_Methodref, etc.
+}
+struct CONSTANT_InvokeDynamic_info {
+  u1 tag = 18;
+  u2 bootstrap_method_attr_index;  // index into BootstrapMethods_attr
+  u2 name_and_type_index;          // index to CONSTANT_NameAndType, as in Methodref
+}
+struct BootstrapMethods_attr {
+ u2 name;  // CONSTANT_Utf8 = "BootstrapMethods"
+ u4 size;
+ u2 bootstrap_method_count;
+ struct bootstrap_method_specifier {
+   u2 bootstrap_method_ref;  // index to CONSTANT_MethodHandle
+   u2 bootstrap_argument_count;
+   u2 bootstrap_arguments[bootstrap_argument_count];  // constant pool indexes
+ } bootstrap_methods[bootstrap_method_count];
+}
+ *
    *

    - * The JVM is free to duplicate dynamic call sites. - * This means that, even if a class contains just one {@code invokedynamic} - * instruction, its bootstrap method may be executed several times, - * once for each duplicate. Thus, bootstrap method code should not - * assume an exclusive one-to-one correspondence between particular occurrences - * of {@code invokedynamic} bytecodes in class files and linkage events. - *

    - * In principle, each individual execution of an {@code invokedynamic} - * instruction could be deemed (by a conforming implementation) to be a separate - * duplicate, requiring its own execution of the bootstrap method. - * However, implementations are expected to perform code duplication - * (if at all) in order to improve performance, not make it worse. + * Note: The Proposed Final Draft of JSR 292 may remove the constant tag 17, + * for the sake of simplicity. * * @author John Rose, JSR 292 EG */ diff --git a/jdk/src/share/classes/java/io/FileOutputStream.java b/jdk/src/share/classes/java/io/FileOutputStream.java index 71bdee89f3b148384e6b87530d446559b83a32d7..70f6851d7326bad52313067151657171ab7a386e 100644 --- a/jdk/src/share/classes/java/io/FileOutputStream.java +++ b/jdk/src/share/classes/java/io/FileOutputStream.java @@ -56,7 +56,15 @@ class FileOutputStream extends OutputStream */ private final FileDescriptor fd; - private FileChannel channel= null; + /** + * True if the file is opened for append. + */ + private final boolean append; + + /** + * The associated channel, initalized lazily. + */ + private FileChannel channel; private final Object closeLock = new Object(); private volatile boolean closed = false; @@ -196,7 +204,9 @@ class FileOutputStream extends OutputStream if (name == null) { throw new NullPointerException(); } - fd = new FileDescriptor(); + this.fd = new FileDescriptor(); + this.append = append; + fd.incrementAndGetUseCount(); open(name, append); } @@ -232,7 +242,8 @@ class FileOutputStream extends OutputStream if (security != null) { security.checkWrite(fdObj); } - fd = fdObj; + this.fd = fdObj; + this.append = false; /* * FileDescriptor is being shared by streams. @@ -250,6 +261,15 @@ class FileOutputStream extends OutputStream private native void open(String name, boolean append) throws FileNotFoundException; + /** + * Writes the specified byte to this file output stream. + * + * @param b the byte to be written. + * @param append {@code true} if the write operation first + * advances the position to the end of file + */ + private native void write(int b, boolean append) throws IOException; + /** * Writes the specified byte to this file output stream. Implements * the write method of OutputStream. @@ -257,16 +277,21 @@ class FileOutputStream extends OutputStream * @param b the byte to be written. * @exception IOException if an I/O error occurs. */ - public native void write(int b) throws IOException; + public void write(int b) throws IOException { + write(b, append); + } /** * Writes a sub array as a sequence of bytes. * @param b the data to be written * @param off the start offset in the data * @param len the number of bytes that are written + * @param append {@code true} to first advance the position to the + * end of file * @exception IOException If an I/O error has occurred. */ - private native void writeBytes(byte b[], int off, int len) throws IOException; + private native void writeBytes(byte b[], int off, int len, boolean append) + throws IOException; /** * Writes b.length bytes from the specified byte array @@ -276,7 +301,7 @@ class FileOutputStream extends OutputStream * @exception IOException if an I/O error occurs. */ public void write(byte b[]) throws IOException { - writeBytes(b, 0, b.length); + writeBytes(b, 0, b.length, append); } /** @@ -289,7 +314,7 @@ class FileOutputStream extends OutputStream * @exception IOException if an I/O error occurs. */ public void write(byte b[], int off, int len) throws IOException { - writeBytes(b, off, len); + writeBytes(b, off, len, append); } /** @@ -372,7 +397,7 @@ class FileOutputStream extends OutputStream public FileChannel getChannel() { synchronized (this) { if (channel == null) { - channel = FileChannelImpl.open(fd, false, true, this); + channel = FileChannelImpl.open(fd, false, true, append, this); /* * Increment fd's use count. Invoking the channel's close() diff --git a/jdk/src/share/classes/java/io/ObjectInputStream.java b/jdk/src/share/classes/java/io/ObjectInputStream.java index 2ed505f3b07c6cd940bb632037e8e854f9cf4cd9..3ec3cd4fbdc763057db8b6ee4366ffd389164305 100644 --- a/jdk/src/share/classes/java/io/ObjectInputStream.java +++ b/jdk/src/share/classes/java/io/ObjectInputStream.java @@ -3498,8 +3498,8 @@ public class ObjectInputStream return ((int[]) array).clone(); } else if (array instanceof long[]) { return ((long[]) array).clone(); - } else if (array instanceof double[]) { - return ((double[]) array).clone(); + } else if (array instanceof short[]) { + return ((short[]) array).clone(); } else { throw new AssertionError(); } diff --git a/jdk/src/share/classes/java/lang/Character.java b/jdk/src/share/classes/java/lang/Character.java index b833dab838e2ee021a37def94562a57701edf1a1..f8be10ec5c383362ad9e2c9b096d122c04da4f9f 100644 --- a/jdk/src/share/classes/java/lang/Character.java +++ b/jdk/src/share/classes/java/lang/Character.java @@ -6371,15 +6371,15 @@ class Character implements java.io.Serializable, Comparable { * This method returns true for the following five * characters only: * - * + * * - * + * * - * + * * - * + * * - * + * * *
    '\t' '\u0009'
    '\t' U+0009HORIZONTAL TABULATION
    '\n' '\u000A'
    '\n' U+000ANEW LINE
    '\f' '\u000C'
    '\f' U+000CFORM FEED
    '\r' '\u000D'
    '\r' U+000DCARRIAGE RETURN
    ' ' '\u0020'
    ' ' U+0020SPACE
    * @@ -6463,15 +6463,15 @@ class Character implements java.io.Serializable, Comparable { * LINE_SEPARATOR, or PARAGRAPH_SEPARATOR) * but is not also a non-breaking space ('\u00A0', * '\u2007', '\u202F'). - *

  • It is '\u0009', HORIZONTAL TABULATION. - *
  • It is '\u000A', LINE FEED. - *
  • It is '\u000B', VERTICAL TABULATION. - *
  • It is '\u000C', FORM FEED. - *
  • It is '\u000D', CARRIAGE RETURN. - *
  • It is '\u001C', FILE SEPARATOR. - *
  • It is '\u001D', GROUP SEPARATOR. - *
  • It is '\u001E', RECORD SEPARATOR. - *
  • It is '\u001F', UNIT SEPARATOR. + *
  • It is '\t', U+0009 HORIZONTAL TABULATION. + *
  • It is '\n', U+000A LINE FEED. + *
  • It is '\u000B', U+000B VERTICAL TABULATION. + *
  • It is '\f', U+000C FORM FEED. + *
  • It is '\r', U+000D CARRIAGE RETURN. + *
  • It is '\u001C', U+001C FILE SEPARATOR. + *
  • It is '\u001D', U+001D GROUP SEPARATOR. + *
  • It is '\u001E', U+001E RECORD SEPARATOR. + *
  • It is '\u001F', U+001F UNIT SEPARATOR. * * *

    Note: This method cannot handle { * {@link #LINE_SEPARATOR}, or {@link #PARAGRAPH_SEPARATOR}) * but is not also a non-breaking space ('\u00A0', * '\u2007', '\u202F'). - *

  • It is '\u0009', HORIZONTAL TABULATION. - *
  • It is '\u000A', LINE FEED. - *
  • It is '\u000B', VERTICAL TABULATION. - *
  • It is '\u000C', FORM FEED. - *
  • It is '\u000D', CARRIAGE RETURN. - *
  • It is '\u001C', FILE SEPARATOR. - *
  • It is '\u001D', GROUP SEPARATOR. - *
  • It is '\u001E', RECORD SEPARATOR. - *
  • It is '\u001F', UNIT SEPARATOR. + *
  • It is '\t', U+0009 HORIZONTAL TABULATION. + *
  • It is '\n', U+000A LINE FEED. + *
  • It is '\u000B', U+000B VERTICAL TABULATION. + *
  • It is '\f', U+000C FORM FEED. + *
  • It is '\r', U+000D CARRIAGE RETURN. + *
  • It is '\u001C', U+001C FILE SEPARATOR. + *
  • It is '\u001D', U+001D GROUP SEPARATOR. + *
  • It is '\u001E', U+001E RECORD SEPARATOR. + *
  • It is '\u001F', U+001F UNIT SEPARATOR. * *

    * diff --git a/jdk/src/share/classes/java/lang/Double.java b/jdk/src/share/classes/java/lang/Double.java index ab732d3851be4df667481ab6908d378b8212b745..2957f0b541db044ad3a7852548667fbc8dde3595 100644 --- a/jdk/src/share/classes/java/lang/Double.java +++ b/jdk/src/share/classes/java/lang/Double.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1994, 2009, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1994, 2010, 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 @@ -973,7 +973,8 @@ public final class Double extends Number implements Comparable { if (d1 > d2) return 1; // Neither val is NaN, thisVal is larger - long thisBits = Double.doubleToLongBits(d1); + // Cannot use doubleToRawLongBits because of possibility of NaNs. + long thisBits = Double.doubleToLongBits(d1); long anotherBits = Double.doubleToLongBits(d2); return (thisBits == anotherBits ? 0 : // Values are equal diff --git a/jdk/src/share/classes/java/lang/Float.java b/jdk/src/share/classes/java/lang/Float.java index acd96d38e4423b3adf1bb8a7fa7d8da0378efd00..f725def1d0affcb8ac31fa0f5da224648d4814e6 100644 --- a/jdk/src/share/classes/java/lang/Float.java +++ b/jdk/src/share/classes/java/lang/Float.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1994, 2009, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1994, 2010, 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 @@ -872,12 +872,13 @@ public final class Float extends Number implements Comparable { * @since 1.4 */ public static int compare(float f1, float f2) { - if (f1 < f2) + if (f1 < f2) return -1; // Neither val is NaN, thisVal is smaller if (f1 > f2) return 1; // Neither val is NaN, thisVal is larger - int thisBits = Float.floatToIntBits(f1); + // Cannot use floatToRawIntBits because of possibility of NaNs. + int thisBits = Float.floatToIntBits(f1); int anotherBits = Float.floatToIntBits(f2); return (thisBits == anotherBits ? 0 : // Values are equal diff --git a/jdk/src/share/classes/java/lang/ProcessBuilder.java b/jdk/src/share/classes/java/lang/ProcessBuilder.java index 97ce45cdf658eccb2d0e29119d4c82c98cae0c40..ebc372380bba446f4817dd88bbec61fb4e8d79c5 100644 --- a/jdk/src/share/classes/java/lang/ProcessBuilder.java +++ b/jdk/src/share/classes/java/lang/ProcessBuilder.java @@ -537,7 +537,11 @@ public final class ProcessBuilder */ public File file() { return null; } - FileOutputStream toFileOutputStream() throws IOException { + /** + * When redirected to a destination file, indicates if the output + * is to be written to the end of the file. + */ + boolean append() { throw new UnsupportedOperationException(); } @@ -588,9 +592,7 @@ public final class ProcessBuilder public String toString() { return "redirect to write to file \"" + file + "\""; } - FileOutputStream toFileOutputStream() throws IOException { - return new FileOutputStream(file, false); - } + boolean append() { return false; } }; } @@ -620,9 +622,7 @@ public final class ProcessBuilder public String toString() { return "redirect to append to file \"" + file + "\""; } - FileOutputStream toFileOutputStream() throws IOException { - return new FileOutputStream(file, true); - } + boolean append() { return true; } }; } diff --git a/jdk/src/share/classes/java/lang/SafeVarargs.java b/jdk/src/share/classes/java/lang/SafeVarargs.java new file mode 100644 index 0000000000000000000000000000000000000000..1477b50c985c8adceeed2e51efb80ec128a9a0ec --- /dev/null +++ b/jdk/src/share/classes/java/lang/SafeVarargs.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2010, 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.lang; + +import java.lang.annotation.*; + +/** + * A programmer assertion that the body of the annotated method or + * constructor does not perform potentially unsafe operations on its + * varargs parameter. Applying this annotation to a method or + * constructor suppresses unchecked warnings about a + * non-reifiable variable-arity (vararg) type and suppresses + * unchecked warnings about parameterized array creation at call + * sites. + * + *

    In addition to the usage restrictions imposed by its {@link + * Target @Target} meta-annotation, compilers are required to implement + * additional usage restrictions on this annotation type; it is a + * compile-time error if a method or constructor declaration is + * annotated with a {@code @SafeVarargs} annotation, and either: + + *

    + * + *

    Compilers are encouraged to issue warnings when this annotation + * type is applied to a method or constructor declaration where: + * + *

    + * + * @jls3 4.7 Reifiable Types + * @jls3 8.4.1 Formal Parameters + */ +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.CONSTRUCTOR, ElementType.METHOD}) +public @interface SafeVarargs {} diff --git a/jdk/src/share/classes/java/lang/StrictMath.java b/jdk/src/share/classes/java/lang/StrictMath.java index 916b82ff9d043e30076d0063fe783d7d68d6f3e4..56be3c5f17abeb912339cc4361a6abb7fecfc3f2 100644 --- a/jdk/src/share/classes/java/lang/StrictMath.java +++ b/jdk/src/share/classes/java/lang/StrictMath.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2006, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2010, 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 @@ -801,8 +801,9 @@ public final class StrictMath { return (a >= b) ? a : b; } - private static long negativeZeroFloatBits = Float.floatToIntBits(-0.0f); - private static long negativeZeroDoubleBits = Double.doubleToLongBits(-0.0d); + // Use raw bit-wise conversions on guaranteed non-NaN arguments. + private static long negativeZeroFloatBits = Float.floatToRawIntBits(-0.0f); + private static long negativeZeroDoubleBits = Double.doubleToRawLongBits(-0.0d); /** * Returns the greater of two {@code float} values. That is, @@ -819,9 +820,12 @@ public final class StrictMath { * @return the larger of {@code a} and {@code b}. */ public static float max(float a, float b) { - if (a != a) return a; // a is NaN - if ((a == 0.0f) && (b == 0.0f) - && (Float.floatToIntBits(a) == negativeZeroFloatBits)) { + if (a != a) + return a; // a is NaN + if ((a == 0.0f) && + (b == 0.0f) && + (Float.floatToRawIntBits(a) == negativeZeroFloatBits)) { + // Raw conversion ok since NaN can't map to -0.0. return b; } return (a >= b) ? a : b; @@ -842,9 +846,12 @@ public final class StrictMath { * @return the larger of {@code a} and {@code b}. */ public static double max(double a, double b) { - if (a != a) return a; // a is NaN - if ((a == 0.0d) && (b == 0.0d) - && (Double.doubleToLongBits(a) == negativeZeroDoubleBits)) { + if (a != a) + return a; // a is NaN + if ((a == 0.0d) && + (b == 0.0d) && + (Double.doubleToRawLongBits(a) == negativeZeroDoubleBits)) { + // Raw conversion ok since NaN can't map to -0.0. return b; } return (a >= b) ? a : b; @@ -893,9 +900,12 @@ public final class StrictMath { * @return the smaller of {@code a} and {@code b.} */ public static float min(float a, float b) { - if (a != a) return a; // a is NaN - if ((a == 0.0f) && (b == 0.0f) - && (Float.floatToIntBits(b) == negativeZeroFloatBits)) { + if (a != a) + return a; // a is NaN + if ((a == 0.0f) && + (b == 0.0f) && + (Float.floatToRawIntBits(b) == negativeZeroFloatBits)) { + // Raw conversion ok since NaN can't map to -0.0. return b; } return (a <= b) ? a : b; @@ -916,9 +926,12 @@ public final class StrictMath { * @return the smaller of {@code a} and {@code b}. */ public static double min(double a, double b) { - if (a != a) return a; // a is NaN - if ((a == 0.0d) && (b == 0.0d) - && (Double.doubleToLongBits(b) == negativeZeroDoubleBits)) { + if (a != a) + return a; // a is NaN + if ((a == 0.0d) && + (b == 0.0d) && + (Double.doubleToRawLongBits(b) == negativeZeroDoubleBits)) { + // Raw conversion ok since NaN can't map to -0.0. return b; } return (a <= b) ? a : b; diff --git a/jdk/src/share/classes/java/lang/Thread.java b/jdk/src/share/classes/java/lang/Thread.java index 545cef6fcef9ec0f8853a826f2939a6d1ad8e905..f6fb01362c66e1853fe985ba22ce7efc4bbd9558 100644 --- a/jdk/src/share/classes/java/lang/Thread.java +++ b/jdk/src/share/classes/java/lang/Thread.java @@ -209,7 +209,7 @@ class Thread implements Runnable { * initialized to indicate thread 'not yet started' */ - private int threadStatus = 0; + private volatile int threadStatus = 0; private static synchronized long nextThreadID() { diff --git a/jdk/src/share/classes/java/nio/charset/Charset.java b/jdk/src/share/classes/java/nio/charset/Charset.java index 1ede4b8d475d40662df4282967a3b3a5239ea010..2c5eeda5af8281654625dfba5c01dcb292fffe7e 100644 --- a/jdk/src/share/classes/java/nio/charset/Charset.java +++ b/jdk/src/share/classes/java/nio/charset/Charset.java @@ -275,18 +275,17 @@ public abstract class Charset /* -- Static methods -- */ - private static String bugLevel = null; + private static volatile String bugLevel = null; static boolean atBugLevel(String bl) { // package-private - if (bugLevel == null) { + String level = bugLevel; + if (level == null) { if (!sun.misc.VM.isBooted()) return false; - bugLevel = AccessController.doPrivileged( - new GetPropertyAction("sun.nio.cs.bugLevel")); - if (bugLevel == null) - bugLevel = ""; + bugLevel = level = AccessController.doPrivileged( + new GetPropertyAction("sun.nio.cs.bugLevel", "")); } - return (bugLevel != null) && bugLevel.equals(bl); + return level.equals(bl); } /** diff --git a/jdk/src/share/classes/java/security/CodeSigner.java b/jdk/src/share/classes/java/security/CodeSigner.java index 204f71970dbb99048b6c8542bae3ac51849720b5..75a9df9d24ba1844ebf7d9e6abb3939b09d76f73 100644 --- a/jdk/src/share/classes/java/security/CodeSigner.java +++ b/jdk/src/share/classes/java/security/CodeSigner.java @@ -25,7 +25,7 @@ package java.security; -import java.io.Serializable; +import java.io.*; import java.security.cert.CRL; import java.security.cert.CertPath; import sun.misc.JavaSecurityCodeSignerAccess; @@ -205,4 +205,10 @@ public final class CodeSigner implements Serializable { }); } + // Explicitly reset hash code value to -1 + private void readObject(ObjectInputStream ois) + throws IOException, ClassNotFoundException { + ois.defaultReadObject(); + myhash = -1; + } } diff --git a/jdk/src/share/classes/java/security/Timestamp.java b/jdk/src/share/classes/java/security/Timestamp.java index 33d7b4a30c3a06c3ef0b0fee62642cd2c274a99a..1629d9bbff9836eca415527e5b9f0de07f0ed6f1 100644 --- a/jdk/src/share/classes/java/security/Timestamp.java +++ b/jdk/src/share/classes/java/security/Timestamp.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2010, 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 @@ -25,10 +25,12 @@ package java.security; -import java.io.Serializable; +import java.io.*; +import java.security.cert.Certificate; import java.security.cert.CertPath; import java.security.cert.X509Extension; import java.util.Date; +import java.util.List; /** * This class encapsulates information about a signed timestamp. @@ -142,8 +144,20 @@ public final class Timestamp implements Serializable { StringBuffer sb = new StringBuffer(); sb.append("("); sb.append("timestamp: " + timestamp); - sb.append("TSA: " + signerCertPath.getCertificates().get(0)); + List certs = signerCertPath.getCertificates(); + if (!certs.isEmpty()) { + sb.append("TSA: " + certs.get(0)); + } else { + sb.append("TSA: "); + } sb.append(")"); return sb.toString(); } + + // Explicitly reset hash code value to -1 + private void readObject(ObjectInputStream ois) + throws IOException, ClassNotFoundException { + ois.defaultReadObject(); + myhash = -1; + } } diff --git a/jdk/src/share/classes/java/text/AttributedCharacterIterator.java b/jdk/src/share/classes/java/text/AttributedCharacterIterator.java index a3d50fcceebe205ab72bfee88fce838d48e4f07d..86597bfec4a0382443d733c1eb696845316e702c 100644 --- a/jdk/src/share/classes/java/text/AttributedCharacterIterator.java +++ b/jdk/src/share/classes/java/text/AttributedCharacterIterator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, 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 @@ -32,7 +32,7 @@ import java.util.Map; import java.util.Set; /** - * An AttributedCharacterIterator allows iteration through both text and + * An {@code AttributedCharacterIterator} allows iteration through both text and * related attribute information. * *

    @@ -46,22 +46,28 @@ import java.util.Set; *

    A run with respect to an attribute is a maximum text range for * which: *

      - *
    • the attribute is undefined or null for the entire range, or - *
    • the attribute value is defined and has the same non-null value for the + *
    • the attribute is undefined or {@code null} for the entire range, or + *
    • the attribute value is defined and has the same non-{@code null} value for the * entire range. *
    * *

    A run with respect to a set of attributes is a maximum text range for * which this condition is met for each member attribute. * + *

    When getting a run with no explicit attributes specified (i.e., + * calling {@link #getRunStart()} and {@link #getRunLimit()}), any + * contiguous text segments having the same attributes (the same set + * of attribute/value pairs) are treated as separate runs if the + * attributes have been given to those text segments separately. + * *

    The returned indexes are limited to the range of the iterator. * *

    The returned attribute information is limited to runs that contain * the current character. * *

    - * Attribute keys are instances of AttributedCharacterIterator.Attribute and its - * subclasses, such as java.awt.font.TextAttribute. + * Attribute keys are instances of {@link AttributedCharacterIterator.Attribute} and its + * subclasses, such as {@link java.awt.font.TextAttribute}. * * @see AttributedCharacterIterator.Attribute * @see java.awt.font.TextAttribute @@ -74,7 +80,7 @@ public interface AttributedCharacterIterator extends CharacterIterator { /** * Defines attribute keys that are used to identify text attributes. These - * keys are used in AttributedCharacterIterator and AttributedString. + * keys are used in {@code AttributedCharacterIterator} and {@code AttributedString}. * @see AttributedCharacterIterator * @see AttributedString * @since 1.2 @@ -83,7 +89,7 @@ public interface AttributedCharacterIterator extends CharacterIterator { public static class Attribute implements Serializable { /** - * The name of this Attribute. The name is used primarily by readResolve + * The name of this {@code Attribute}. The name is used primarily by {@code readResolve} * to look up the corresponding predefined instance when deserializing * an instance. * @serial @@ -94,7 +100,7 @@ public interface AttributedCharacterIterator extends CharacterIterator { private static final Map instanceMap = new HashMap(7); /** - * Constructs an Attribute with the given name. + * Constructs an {@code Attribute} with the given name. */ protected Attribute(String name) { this.name = name; @@ -114,7 +120,7 @@ public interface AttributedCharacterIterator extends CharacterIterator { /** * Returns a hash code value for the object. This version is identical to - * the one in Object, but is also final. + * the one in {@code Object}, but is also final. */ public final int hashCode() { return super.hashCode(); @@ -122,7 +128,8 @@ public interface AttributedCharacterIterator extends CharacterIterator { /** * Returns a string representation of the object. This version returns the - * concatenation of class name, "(", a name identifying the attribute and ")". + * concatenation of class name, {@code "("}, a name identifying the attribute + * and {@code ")"}. */ public String toString() { return getClass().getName() + "(" + name + ")"; @@ -153,7 +160,7 @@ public interface AttributedCharacterIterator extends CharacterIterator { /** * Attribute key for the language of some text. - *

    Values are instances of Locale. + *

    Values are instances of {@link java.util.Locale Locale}. * @see java.util.Locale */ public static final Attribute LANGUAGE = new Attribute("language"); @@ -163,7 +170,7 @@ public interface AttributedCharacterIterator extends CharacterIterator { * and the pronunciation of a word are only loosely related (such as Japanese), * it is often necessary to store the reading (pronunciation) along with the * written form. - *

    Values are instances of Annotation holding instances of String. + *

    Values are instances of {@link Annotation} holding instances of {@link String}. * @see Annotation * @see java.lang.String */ @@ -172,7 +179,7 @@ public interface AttributedCharacterIterator extends CharacterIterator { /** * Attribute key for input method segments. Input methods often break * up text into segments, which usually correspond to words. - *

    Values are instances of Annotation holding a null reference. + *

    Values are instances of {@link Annotation} holding a {@code null} reference. * @see Annotation */ public static final Attribute INPUT_METHOD_SEGMENT = new Attribute("input_method_segment"); @@ -185,36 +192,44 @@ public interface AttributedCharacterIterator extends CharacterIterator { /** * Returns the index of the first character of the run * with respect to all attributes containing the current character. + * + *

    Any contiguous text segments having the same attributes (the + * same set of attribute/value pairs) are treated as separate runs + * if the attributes have been given to those text segments separately. */ public int getRunStart(); /** * Returns the index of the first character of the run - * with respect to the given attribute containing the current character. + * with respect to the given {@code attribute} containing the current character. */ public int getRunStart(Attribute attribute); /** * Returns the index of the first character of the run - * with respect to the given attributes containing the current character. + * with respect to the given {@code attributes} containing the current character. */ public int getRunStart(Set attributes); /** * Returns the index of the first character following the run * with respect to all attributes containing the current character. + * + *

    Any contiguous text segments having the same attributes (the + * same set of attribute/value pairs) are treated as separate runs + * if the attributes have been given to those text segments separately. */ public int getRunLimit(); /** * Returns the index of the first character following the run - * with respect to the given attribute containing the current character. + * with respect to the given {@code attribute} containing the current character. */ public int getRunLimit(Attribute attribute); /** * Returns the index of the first character following the run - * with respect to the given attributes containing the current character. + * with respect to the given {@code attributes} containing the current character. */ public int getRunLimit(Set attributes); @@ -225,9 +240,8 @@ public interface AttributedCharacterIterator extends CharacterIterator { public Map getAttributes(); /** - * Returns the value of the named attribute for the current character. - * Returns null if the attribute is not defined. - * @param attribute the key of the attribute whose value is requested. + * Returns the value of the named {@code attribute} for the current character. + * Returns {@code null} if the {@code attribute} is not defined. */ public Object getAttribute(Attribute attribute); diff --git a/jdk/src/share/classes/java/text/CollationElementIterator.java b/jdk/src/share/classes/java/text/CollationElementIterator.java index 4fb294d423a9bb115985d07f0825487f41d53828..6bdd0d04a7e60cad4e4255f32ea863ee2612030b 100644 --- a/jdk/src/share/classes/java/text/CollationElementIterator.java +++ b/jdk/src/share/classes/java/text/CollationElementIterator.java @@ -79,9 +79,13 @@ import sun.text.normalizer.NormalizerBase; * 

      *
  *  String testString = "This is a test";
- *  RuleBasedCollator ruleBasedCollator = (RuleBasedCollator)Collator.getInstance();
- *  CollationElementIterator collationElementIterator = ruleBasedCollator.getCollationElementIterator(testString);
- *  int primaryOrder = CollationElementIterator.primaryOrder(collationElementIterator.next());
+ *  Collator col = Collator.getInstance();
+ *  if (col instanceof RuleBasedCollator) {
+ *      RuleBasedCollator ruleBasedCollator = (RuleBasedCollator)col;
+ *      CollationElementIterator collationElementIterator = ruleBasedCollator.getCollationElementIterator(testString);
+ *      int primaryOrder = CollationElementIterator.primaryOrder(collationElementIterator.next());
+ *          :
+ *  }
  *
    * * @@ -93,6 +97,10 @@ import sun.text.normalizer.NormalizerBase; * is its primary order; the next 8 bits is the secondary order and the * last 8 bits is the tertiary order. * + *

    Note: CollationElementIterator is a part of + * RuleBasedCollator implementation. It is only usable + * with RuleBasedCollator instances. + * * @see Collator * @see RuleBasedCollator * @author Helena Shih, Laura Werner, Richard Gillam diff --git a/jdk/src/share/classes/java/text/RuleBasedCollator.java b/jdk/src/share/classes/java/text/RuleBasedCollator.java index 495ca917992564f28777b11c42859e276ce92cca..ef32cc64ef23bc5a4a31c255769c1125889c1d3b 100644 --- a/jdk/src/share/classes/java/text/RuleBasedCollator.java +++ b/jdk/src/share/classes/java/text/RuleBasedCollator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, 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 @@ -180,11 +180,15 @@ import java.util.Locale; * *

    Examples *

    Simple: "< a < b < c < d" - *

    Norwegian: "< a,A< b,B< c,C< d,D< e,E< f,F< g,G< h,H< i,I< j,J - * < k,K< l,L< m,M< n,N< o,O< p,P< q,Q< r,R< s,S< t,T - * < u,U< v,V< w,W< x,X< y,Y< z,Z - * < \u00E5=a\u030A,\u00C5=A\u030A - * ;aa,AA< \u00E6,\u00C6< \u00F8,\u00D8" + *

    Norwegian: "< a, A < b, B < c, C < d, D < e, E < f, F + * < g, G < h, H < i, I < j, J < k, K < l, L + * < m, M < n, N < o, O < p, P < q, Q < r, R + * < s, S < t, T < u, U < v, V < w, W < x, X + * < y, Y < z, Z + * < \u00E6, \u00C6 + * < \u00F8, \u00D8 + * < \u00E5 = a\u030A, \u00C5 = A\u030A; + * aa, AA" * *

    * To create a RuleBasedCollator object with specialized @@ -199,11 +203,14 @@ import java.util.Locale; * Or: *

    * 
    - * String Norwegian = "< a,A< b,B< c,C< d,D< e,E< f,F< g,G< h,H< i,I< j,J" +
- *                 "< k,K< l,L< m,M< n,N< o,O< p,P< q,Q< r,R< s,S< t,T" +
- *                 "< u,U< v,V< w,W< x,X< y,Y< z,Z" +
- *                 "< \u00E5=a\u030A,\u00C5=A\u030A" +
- *                 ";aa,AA< \u00E6,\u00C6< \u00F8,\u00D8";
+ * String Norwegian = "< a, A < b, B < c, C < d, D < e, E < f, F < g, G < h, H < i, I" +
+ *                    "< j, J < k, K < l, L < m, M < n, N < o, O < p, P < q, Q < r, R" +
+ *                    "< s, S < t, T < u, U < v, V < w, W < x, X < y, Y < z, Z" +
+ *                    "< \u00E6, \u00C6" +     // Latin letter ae & AE
+ *                    "< \u00F8, \u00D8" +     // Latin letter o & O with stroke
+ *                    "< \u00E5 = a\u030A," +  // Latin letter a with ring above
+ *                    "  \u00C5 = A\u030A;" +  // Latin letter A with ring above
+ *                    "  aa, AA";
  * RuleBasedCollator myNorwegian = new RuleBasedCollator(Norwegian);
  *
    *
    diff --git a/jdk/src/share/classes/java/text/SimpleDateFormat.java b/jdk/src/share/classes/java/text/SimpleDateFormat.java index 5f1c6601099569ab56dc7c40f4db246f2350e39a..9ae84f828d08bca6a3e43fd20b5e86ef2ef2eae8 100644 --- a/jdk/src/share/classes/java/text/SimpleDateFormat.java +++ b/jdk/src/share/classes/java/text/SimpleDateFormat.java @@ -1839,8 +1839,15 @@ public class SimpleDateFormat extends DateFormat { break parsing; case PATTERN_HOUR_OF_DAY1: // 'k' 1-based. eg, 23:59 + 1 hour =>> 24:59 + if (!isLenient()) { + // Validate the hour value in non-lenient + if (value < 1 || value > 24) { + break parsing; + } + } // [We computed 'value' above.] - if (value == calendar.getMaximum(Calendar.HOUR_OF_DAY)+1) value = 0; + if (value == calendar.getMaximum(Calendar.HOUR_OF_DAY)+1) + value = 0; calb.set(Calendar.HOUR_OF_DAY, value); return pos.index; @@ -1886,8 +1893,15 @@ public class SimpleDateFormat extends DateFormat { break parsing; case PATTERN_HOUR1: // 'h' 1-based. eg, 11PM + 1 hour =>> 12 AM + if (!isLenient()) { + // Validate the hour value in non-lenient + if (value < 1 || value > 12) { + break parsing; + } + } // [We computed 'value' above.] - if (value == calendar.getLeastMaximum(Calendar.HOUR)+1) value = 0; + if (value == calendar.getLeastMaximum(Calendar.HOUR)+1) + value = 0; calb.set(Calendar.HOUR, value); return pos.index; diff --git a/jdk/src/share/classes/java/util/AbstractCollection.java b/jdk/src/share/classes/java/util/AbstractCollection.java index 427f42739b227eeca4b11e6b48503261240ac211..9b675d756e6d86b0120e5d399ca19ed4049d271f 100644 --- a/jdk/src/share/classes/java/util/AbstractCollection.java +++ b/jdk/src/share/classes/java/util/AbstractCollection.java @@ -96,14 +96,14 @@ public abstract class AbstractCollection implements Collection { * @throws NullPointerException {@inheritDoc} */ public boolean contains(Object o) { - Iterator e = iterator(); + Iterator it = iterator(); if (o==null) { - while (e.hasNext()) - if (e.next()==null) + while (it.hasNext()) + if (it.next()==null) return true; } else { - while (e.hasNext()) - if (o.equals(e.next())) + while (it.hasNext()) + if (o.equals(it.next())) return true; } return false; @@ -269,18 +269,18 @@ public abstract class AbstractCollection implements Collection { * @throws NullPointerException {@inheritDoc} */ public boolean remove(Object o) { - Iterator e = iterator(); + Iterator it = iterator(); if (o==null) { - while (e.hasNext()) { - if (e.next()==null) { - e.remove(); + while (it.hasNext()) { + if (it.next()==null) { + it.remove(); return true; } } } else { - while (e.hasNext()) { - if (o.equals(e.next())) { - e.remove(); + while (it.hasNext()) { + if (o.equals(it.next())) { + it.remove(); return true; } } @@ -304,9 +304,8 @@ public abstract class AbstractCollection implements Collection { * @see #contains(Object) */ public boolean containsAll(Collection c) { - Iterator e = c.iterator(); - while (e.hasNext()) - if (!contains(e.next())) + for (Object e : c) + if (!contains(e)) return false; return true; } @@ -331,11 +330,9 @@ public abstract class AbstractCollection implements Collection { */ public boolean addAll(Collection c) { boolean modified = false; - Iterator e = c.iterator(); - while (e.hasNext()) { - if (add(e.next())) + for (E e : c) + if (add(e)) modified = true; - } return modified; } @@ -362,10 +359,10 @@ public abstract class AbstractCollection implements Collection { */ public boolean removeAll(Collection c) { boolean modified = false; - Iterator e = iterator(); - while (e.hasNext()) { - if (c.contains(e.next())) { - e.remove(); + Iterator it = iterator(); + while (it.hasNext()) { + if (c.contains(it.next())) { + it.remove(); modified = true; } } @@ -395,10 +392,10 @@ public abstract class AbstractCollection implements Collection { */ public boolean retainAll(Collection c) { boolean modified = false; - Iterator e = iterator(); - while (e.hasNext()) { - if (!c.contains(e.next())) { - e.remove(); + Iterator it = iterator(); + while (it.hasNext()) { + if (!c.contains(it.next())) { + it.remove(); modified = true; } } @@ -421,10 +418,10 @@ public abstract class AbstractCollection implements Collection { * @throws UnsupportedOperationException {@inheritDoc} */ public void clear() { - Iterator e = iterator(); - while (e.hasNext()) { - e.next(); - e.remove(); + Iterator it = iterator(); + while (it.hasNext()) { + it.next(); + it.remove(); } } @@ -442,18 +439,18 @@ public abstract class AbstractCollection implements Collection { * @return a string representation of this collection */ public String toString() { - Iterator i = iterator(); - if (! i.hasNext()) + Iterator it = iterator(); + if (! it.hasNext()) return "[]"; StringBuilder sb = new StringBuilder(); sb.append('['); for (;;) { - E e = i.next(); + E e = it.next(); sb.append(e == this ? "(this Collection)" : e); - if (! i.hasNext()) + if (! it.hasNext()) return sb.append(']').toString(); - sb.append(", "); + sb.append(',').append(' '); } } diff --git a/jdk/src/share/classes/java/util/AbstractList.java b/jdk/src/share/classes/java/util/AbstractList.java index c0304df1561b6ef0d3f3b228100c5a3b2d30efd4..9752de1d08f027480eebecfced1c50ece40fd20e 100644 --- a/jdk/src/share/classes/java/util/AbstractList.java +++ b/jdk/src/share/classes/java/util/AbstractList.java @@ -175,15 +175,15 @@ public abstract class AbstractList extends AbstractCollection implements L * @throws NullPointerException {@inheritDoc} */ public int indexOf(Object o) { - ListIterator e = listIterator(); + ListIterator it = listIterator(); if (o==null) { - while (e.hasNext()) - if (e.next()==null) - return e.previousIndex(); + while (it.hasNext()) + if (it.next()==null) + return it.previousIndex(); } else { - while (e.hasNext()) - if (o.equals(e.next())) - return e.previousIndex(); + while (it.hasNext()) + if (o.equals(it.next())) + return it.previousIndex(); } return -1; } @@ -200,15 +200,15 @@ public abstract class AbstractList extends AbstractCollection implements L * @throws NullPointerException {@inheritDoc} */ public int lastIndexOf(Object o) { - ListIterator e = listIterator(size()); + ListIterator it = listIterator(size()); if (o==null) { - while (e.hasPrevious()) - if (e.previous()==null) - return e.nextIndex(); + while (it.hasPrevious()) + if (it.previous()==null) + return it.nextIndex(); } else { - while (e.hasPrevious()) - if (o.equals(e.previous())) - return e.nextIndex(); + while (it.hasPrevious()) + if (o.equals(it.previous())) + return it.nextIndex(); } return -1; } @@ -517,7 +517,7 @@ public abstract class AbstractList extends AbstractCollection implements L ListIterator e1 = listIterator(); ListIterator e2 = ((List) o).listIterator(); - while(e1.hasNext() && e2.hasNext()) { + while (e1.hasNext() && e2.hasNext()) { E o1 = e1.next(); Object o2 = e2.next(); if (!(o1==null ? o2==null : o1.equals(o2))) diff --git a/jdk/src/share/classes/java/util/AbstractMap.java b/jdk/src/share/classes/java/util/AbstractMap.java index 43c801a8093ece3e3d890677a9c164a03de37b5f..431313e8ff4b3ba4a259a67159743dbf5d09415f 100644 --- a/jdk/src/share/classes/java/util/AbstractMap.java +++ b/jdk/src/share/classes/java/util/AbstractMap.java @@ -523,7 +523,7 @@ public abstract class AbstractMap implements Map { sb.append(value == this ? "(this Map)" : value); if (! i.hasNext()) return sb.append('}').toString(); - sb.append(", "); + sb.append(',').append(' '); } } diff --git a/jdk/src/share/classes/java/util/ArrayList.java b/jdk/src/share/classes/java/util/ArrayList.java index 7c6eded3a830094f02f422bb6a2945e3c4efc494..45ca44296ca42882b6ef7268a6ca7d27b07cb1b9 100644 --- a/jdk/src/share/classes/java/util/ArrayList.java +++ b/jdk/src/share/classes/java/util/ArrayList.java @@ -120,9 +120,9 @@ public class ArrayList extends AbstractList /** * Constructs an empty list with the specified initial capacity. * - * @param initialCapacity the initial capacity of the list - * @exception IllegalArgumentException if the specified initial capacity - * is negative + * @param initialCapacity the initial capacity of the list + * @throws IllegalArgumentException if the specified initial capacity + * is negative */ public ArrayList(int initialCapacity) { super(); @@ -173,7 +173,7 @@ public class ArrayList extends AbstractList * necessary, to ensure that it can hold at least the number of elements * specified by the minimum capacity argument. * - * @param minCapacity the desired minimum capacity + * @param minCapacity the desired minimum capacity */ public void ensureCapacity(int minCapacity) { if (minCapacity > 0) diff --git a/jdk/src/share/classes/java/util/Collections.java b/jdk/src/share/classes/java/util/Collections.java index e4329dc0e43d83295acf48d6918aa927aae94af8..c5d8476c8a35613fe4ec4f6bc3991a667861335d 100644 --- a/jdk/src/share/classes/java/util/Collections.java +++ b/jdk/src/share/classes/java/util/Collections.java @@ -124,7 +124,7 @@ public class Collections { * *

    The implementation takes equal advantage of ascending and * descending order in its input array, and can take advantage of - * ascending and descending order in different parts of the the same + * ascending and descending order in different parts of the same * input array. It is well-suited to merging two or more sorted arrays: * simply concatenate the arrays and sort the resulting array. * @@ -184,7 +184,7 @@ public class Collections { * *

    The implementation takes equal advantage of ascending and * descending order in its input array, and can take advantage of - * ascending and descending order in different parts of the the same + * ascending and descending order in different parts of the same * input array. It is well-suited to merging two or more sorted arrays: * simply concatenate the arrays and sort the resulting array. * @@ -823,7 +823,7 @@ public class Collections { i -= size; displaced = list.set(i, displaced); nMoved ++; - } while(i != cycleStart); + } while (i != cycleStart); } } @@ -1452,9 +1452,9 @@ public class Collections { * when o is a Map.Entry, and calls o.setValue. */ public boolean containsAll(Collection coll) { - Iterator e = coll.iterator(); - while (e.hasNext()) - if (!contains(e.next())) // Invokes safe contains() above + Iterator it = coll.iterator(); + while (it.hasNext()) + if (!contains(it.next())) // Invokes safe contains() above return false; return true; } @@ -1482,12 +1482,12 @@ public class Collections { UnmodifiableEntry(Map.Entry e) {this.e = e;} - public K getKey() {return e.getKey();} - public V getValue() {return e.getValue();} + public K getKey() {return e.getKey();} + public V getValue() {return e.getValue();} public V setValue(V value) { throw new UnsupportedOperationException(); } - public int hashCode() {return e.hashCode();} + public int hashCode() {return e.hashCode();} public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; @@ -1495,7 +1495,7 @@ public class Collections { return eq(e.getKey(), t.getKey()) && eq(e.getValue(), t.getValue()); } - public String toString() {return e.toString();} + public String toString() {return e.toString();} } } } @@ -1562,7 +1562,7 @@ public class Collections { * 

          *  Collection c = Collections.synchronizedCollection(myCollection);
      *     ...
-     *  synchronized(c) {
+     *  synchronized (c) {
      *      Iterator i = c.iterator(); // Must be in the synchronized block
      *      while (i.hasNext())
      *         foo(i.next());
@@ -1611,19 +1611,19 @@ public class Collections {
         }
 
         public int size() {
-            synchronized(mutex) {return c.size();}
+            synchronized (mutex) {return c.size();}
         }
         public boolean isEmpty() {
-            synchronized(mutex) {return c.isEmpty();}
+            synchronized (mutex) {return c.isEmpty();}
         }
         public boolean contains(Object o) {
-            synchronized(mutex) {return c.contains(o);}
+            synchronized (mutex) {return c.contains(o);}
         }
         public Object[] toArray() {
-            synchronized(mutex) {return c.toArray();}
+            synchronized (mutex) {return c.toArray();}
         }
         public  T[] toArray(T[] a) {
-            synchronized(mutex) {return c.toArray(a);}
+            synchronized (mutex) {return c.toArray(a);}
         }
 
         public Iterator iterator() {
@@ -1631,32 +1631,32 @@ public class Collections {
         }
 
         public boolean add(E e) {
-            synchronized(mutex) {return c.add(e);}
+            synchronized (mutex) {return c.add(e);}
         }
         public boolean remove(Object o) {
-            synchronized(mutex) {return c.remove(o);}
+            synchronized (mutex) {return c.remove(o);}
         }
 
         public boolean containsAll(Collection coll) {
-            synchronized(mutex) {return c.containsAll(coll);}
+            synchronized (mutex) {return c.containsAll(coll);}
         }
         public boolean addAll(Collection coll) {
-            synchronized(mutex) {return c.addAll(coll);}
+            synchronized (mutex) {return c.addAll(coll);}
         }
         public boolean removeAll(Collection coll) {
-            synchronized(mutex) {return c.removeAll(coll);}
+            synchronized (mutex) {return c.removeAll(coll);}
         }
         public boolean retainAll(Collection coll) {
-            synchronized(mutex) {return c.retainAll(coll);}
+            synchronized (mutex) {return c.retainAll(coll);}
         }
         public void clear() {
-            synchronized(mutex) {c.clear();}
+            synchronized (mutex) {c.clear();}
         }
         public String toString() {
-            synchronized(mutex) {return c.toString();}
+            synchronized (mutex) {return c.toString();}
         }
         private void writeObject(ObjectOutputStream s) throws IOException {
-            synchronized(mutex) {s.defaultWriteObject();}
+            synchronized (mutex) {s.defaultWriteObject();}
         }
     }
 
@@ -1671,7 +1671,7 @@ public class Collections {
      * 
          *  Set s = Collections.synchronizedSet(new HashSet());
      *      ...
-     *  synchronized(s) {
+     *  synchronized (s) {
      *      Iterator i = s.iterator(); // Must be in the synchronized block
      *      while (i.hasNext())
      *          foo(i.next());
@@ -1709,10 +1709,10 @@ public class Collections {
         }
 
         public boolean equals(Object o) {
-            synchronized(mutex) {return c.equals(o);}
+            synchronized (mutex) {return c.equals(o);}
         }
         public int hashCode() {
-            synchronized(mutex) {return c.hashCode();}
+            synchronized (mutex) {return c.hashCode();}
         }
     }
 
@@ -1728,7 +1728,7 @@ public class Collections {
      * 
          *  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
      *      ...
-     *  synchronized(s) {
+     *  synchronized (s) {
      *      Iterator i = s.iterator(); // Must be in the synchronized block
      *      while (i.hasNext())
      *          foo(i.next());
@@ -1739,7 +1739,7 @@ public class Collections {
      *  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
      *  SortedSet s2 = s.headSet(foo);
      *      ...
-     *  synchronized(s) {  // Note: s, not s2!!!
+     *  synchronized (s) {  // Note: s, not s2!!!
      *      Iterator i = s2.iterator(); // Must be in the synchronized block
      *      while (i.hasNext())
      *          foo(i.next());
@@ -1766,7 +1766,7 @@ public class Collections {
     {
         private static final long serialVersionUID = 8695801310862127406L;
 
-        final private SortedSet ss;
+        private final SortedSet ss;
 
         SynchronizedSortedSet(SortedSet s) {
             super(s);
@@ -1778,31 +1778,31 @@ public class Collections {
         }
 
         public Comparator comparator() {
-            synchronized(mutex) {return ss.comparator();}
+            synchronized (mutex) {return ss.comparator();}
         }
 
         public SortedSet subSet(E fromElement, E toElement) {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 return new SynchronizedSortedSet(
                     ss.subSet(fromElement, toElement), mutex);
             }
         }
         public SortedSet headSet(E toElement) {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 return new SynchronizedSortedSet(ss.headSet(toElement), mutex);
             }
         }
         public SortedSet tailSet(E fromElement) {
-            synchronized(mutex) {
+            synchronized (mutex) {
                return new SynchronizedSortedSet(ss.tailSet(fromElement),mutex);
             }
         }
 
         public E first() {
-            synchronized(mutex) {return ss.first();}
+            synchronized (mutex) {return ss.first();}
         }
         public E last() {
-            synchronized(mutex) {return ss.last();}
+            synchronized (mutex) {return ss.last();}
         }
     }
 
@@ -1817,7 +1817,7 @@ public class Collections {
      * 
          *  List list = Collections.synchronizedList(new ArrayList());
      *      ...
-     *  synchronized(list) {
+     *  synchronized (list) {
      *      Iterator i = list.iterator(); // Must be in synchronized block
      *      while (i.hasNext())
      *          foo(i.next());
@@ -1863,34 +1863,34 @@ public class Collections {
         }
 
         public boolean equals(Object o) {
-            synchronized(mutex) {return list.equals(o);}
+            synchronized (mutex) {return list.equals(o);}
         }
         public int hashCode() {
-            synchronized(mutex) {return list.hashCode();}
+            synchronized (mutex) {return list.hashCode();}
         }
 
         public E get(int index) {
-            synchronized(mutex) {return list.get(index);}
+            synchronized (mutex) {return list.get(index);}
         }
         public E set(int index, E element) {
-            synchronized(mutex) {return list.set(index, element);}
+            synchronized (mutex) {return list.set(index, element);}
         }
         public void add(int index, E element) {
-            synchronized(mutex) {list.add(index, element);}
+            synchronized (mutex) {list.add(index, element);}
         }
         public E remove(int index) {
-            synchronized(mutex) {return list.remove(index);}
+            synchronized (mutex) {return list.remove(index);}
         }
 
         public int indexOf(Object o) {
-            synchronized(mutex) {return list.indexOf(o);}
+            synchronized (mutex) {return list.indexOf(o);}
         }
         public int lastIndexOf(Object o) {
-            synchronized(mutex) {return list.lastIndexOf(o);}
+            synchronized (mutex) {return list.lastIndexOf(o);}
         }
 
         public boolean addAll(int index, Collection c) {
-            synchronized(mutex) {return list.addAll(index, c);}
+            synchronized (mutex) {return list.addAll(index, c);}
         }
 
         public ListIterator listIterator() {
@@ -1902,7 +1902,7 @@ public class Collections {
         }
 
         public List subList(int fromIndex, int toIndex) {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 return new SynchronizedList(list.subList(fromIndex, toIndex),
                                             mutex);
             }
@@ -1943,7 +1943,7 @@ public class Collections {
         }
 
         public List subList(int fromIndex, int toIndex) {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 return new SynchronizedRandomAccessList(
                     list.subList(fromIndex, toIndex), mutex);
             }
@@ -1975,7 +1975,7 @@ public class Collections {
      *      ...
      *  Set s = m.keySet();  // Needn't be in synchronized block
      *      ...
-     *  synchronized(m) {  // Synchronizing on m, not s!
+     *  synchronized (m) {  // Synchronizing on m, not s!
      *      Iterator i = s.iterator(); // Must be in synchronized block
      *      while (i.hasNext())
      *          foo(i.next());
@@ -2016,32 +2016,32 @@ public class Collections {
         }
 
         public int size() {
-            synchronized(mutex) {return m.size();}
+            synchronized (mutex) {return m.size();}
         }
         public boolean isEmpty() {
-            synchronized(mutex) {return m.isEmpty();}
+            synchronized (mutex) {return m.isEmpty();}
         }
         public boolean containsKey(Object key) {
-            synchronized(mutex) {return m.containsKey(key);}
+            synchronized (mutex) {return m.containsKey(key);}
         }
         public boolean containsValue(Object value) {
-            synchronized(mutex) {return m.containsValue(value);}
+            synchronized (mutex) {return m.containsValue(value);}
         }
         public V get(Object key) {
-            synchronized(mutex) {return m.get(key);}
+            synchronized (mutex) {return m.get(key);}
         }
 
         public V put(K key, V value) {
-            synchronized(mutex) {return m.put(key, value);}
+            synchronized (mutex) {return m.put(key, value);}
         }
         public V remove(Object key) {
-            synchronized(mutex) {return m.remove(key);}
+            synchronized (mutex) {return m.remove(key);}
         }
         public void putAll(Map map) {
-            synchronized(mutex) {m.putAll(map);}
+            synchronized (mutex) {m.putAll(map);}
         }
         public void clear() {
-            synchronized(mutex) {m.clear();}
+            synchronized (mutex) {m.clear();}
         }
 
         private transient Set keySet = null;
@@ -2049,7 +2049,7 @@ public class Collections {
         private transient Collection values = null;
 
         public Set keySet() {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 if (keySet==null)
                     keySet = new SynchronizedSet(m.keySet(), mutex);
                 return keySet;
@@ -2057,7 +2057,7 @@ public class Collections {
         }
 
         public Set> entrySet() {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 if (entrySet==null)
                     entrySet = new SynchronizedSet>(m.entrySet(), mutex);
                 return entrySet;
@@ -2065,7 +2065,7 @@ public class Collections {
         }
 
         public Collection values() {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 if (values==null)
                     values = new SynchronizedCollection(m.values(), mutex);
                 return values;
@@ -2073,16 +2073,16 @@ public class Collections {
         }
 
         public boolean equals(Object o) {
-            synchronized(mutex) {return m.equals(o);}
+            synchronized (mutex) {return m.equals(o);}
         }
         public int hashCode() {
-            synchronized(mutex) {return m.hashCode();}
+            synchronized (mutex) {return m.hashCode();}
         }
         public String toString() {
-            synchronized(mutex) {return m.toString();}
+            synchronized (mutex) {return m.toString();}
         }
         private void writeObject(ObjectOutputStream s) throws IOException {
-            synchronized(mutex) {s.defaultWriteObject();}
+            synchronized (mutex) {s.defaultWriteObject();}
         }
     }
 
@@ -2101,7 +2101,7 @@ public class Collections {
      *      ...
      *  Set s = m.keySet();  // Needn't be in synchronized block
      *      ...
-     *  synchronized(m) {  // Synchronizing on m, not s!
+     *  synchronized (m) {  // Synchronizing on m, not s!
      *      Iterator i = s.iterator(); // Must be in synchronized block
      *      while (i.hasNext())
      *          foo(i.next());
@@ -2114,7 +2114,7 @@ public class Collections {
      *      ...
      *  Set s2 = m2.keySet();  // Needn't be in synchronized block
      *      ...
-     *  synchronized(m) {  // Synchronizing on m, not m2 or s2!
+     *  synchronized (m) {  // Synchronizing on m, not m2 or s2!
      *      Iterator i = s.iterator(); // Must be in synchronized block
      *      while (i.hasNext())
      *          foo(i.next());
@@ -2154,31 +2154,31 @@ public class Collections {
         }
 
         public Comparator comparator() {
-            synchronized(mutex) {return sm.comparator();}
+            synchronized (mutex) {return sm.comparator();}
         }
 
         public SortedMap subMap(K fromKey, K toKey) {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 return new SynchronizedSortedMap(
                     sm.subMap(fromKey, toKey), mutex);
             }
         }
         public SortedMap headMap(K toKey) {
-            synchronized(mutex) {
+            synchronized (mutex) {
                 return new SynchronizedSortedMap(sm.headMap(toKey), mutex);
             }
         }
         public SortedMap tailMap(K fromKey) {
-            synchronized(mutex) {
+            synchronized (mutex) {
                return new SynchronizedSortedMap(sm.tailMap(fromKey),mutex);
             }
         }
 
         public K firstKey() {
-            synchronized(mutex) {return sm.firstKey();}
+            synchronized (mutex) {return sm.firstKey();}
         }
         public K lastKey() {
-            synchronized(mutex) {return sm.lastKey();}
+            synchronized (mutex) {return sm.lastKey();}
         }
     }
 
@@ -3317,7 +3317,7 @@ public class Collections {
     {
         private static final long serialVersionUID = 3193687207550431679L;
 
-        final private E element;
+        private final E element;
 
         SingletonSet(E e) {element = e;}
 
@@ -3448,7 +3448,7 @@ public class Collections {
      * @param  o the element to appear repeatedly in the returned list.
      * @return an immutable list consisting of n copies of the
      *         specified object.
-     * @throws IllegalArgumentException if n < 0.
+     * @throws IllegalArgumentException if {@code n < 0}
      * @see    List#addAll(Collection)
      * @see    List#addAll(int, Collection)
      */
diff --git a/jdk/src/share/classes/java/util/ComparableTimSort.java b/jdk/src/share/classes/java/util/ComparableTimSort.java
index 4907a0f5bcd0935d3aeebaf9bda10bccf9450597..f78ee9a2efc711bf0e1dde89eed9a5fe38976548 100644
--- a/jdk/src/share/classes/java/util/ComparableTimSort.java
+++ b/jdk/src/share/classes/java/util/ComparableTimSort.java
@@ -207,7 +207,7 @@ class ComparableTimSort {
      * @param lo the index of the first element in the range to be sorted
      * @param hi the index after the last element in the range to be sorted
      * @param start the index of the first element in the range that is
-     *        not already known to be sorted (@code lo <= start <= hi}
+     *        not already known to be sorted ({@code lo <= start <= hi})
      */
     @SuppressWarnings("fallthrough")
     private static void binarySort(Object[] a, int lo, int hi, int start) {
@@ -245,7 +245,7 @@ class ComparableTimSort {
              */
             int n = start - left;  // The number of elements to move
             // Switch is just an optimization for arraycopy in default case
-            switch(n) {
+            switch (n) {
                 case 2:  a[left + 2] = a[left + 1];
                 case 1:  a[left + 1] = a[left];
                          break;
@@ -275,7 +275,7 @@ class ComparableTimSort {
      * @param a the array in which a run is to be counted and possibly reversed
      * @param lo index of the first element in the run
      * @param hi index after the last element that may be contained in the run.
-              It is required that @code{lo < hi}.
+              It is required that {@code lo < hi}.
      * @return  the length of the run beginning at the specified position in
      *          the specified array
      */
@@ -288,7 +288,7 @@ class ComparableTimSort {
 
         // Find end of run, and reverse range if descending
         if (((Comparable) a[runHi++]).compareTo(a[lo]) < 0) { // Descending
-            while(runHi < hi && ((Comparable) a[runHi]).compareTo(a[runHi - 1]) < 0)
+            while (runHi < hi && ((Comparable) a[runHi]).compareTo(a[runHi - 1]) < 0)
                 runHi++;
             reverseRange(a, lo, runHi);
         } else {                              // Ascending
diff --git a/jdk/src/share/classes/java/util/FormattableFlags.java b/jdk/src/share/classes/java/util/FormattableFlags.java
index 763a99b98153e89cd653450e5b92e4da0244c1b0..279a5a22e8790b21938b53d4b6cce0aae50aa4e6 100644
--- a/jdk/src/share/classes/java/util/FormattableFlags.java
+++ b/jdk/src/share/classes/java/util/FormattableFlags.java
@@ -59,10 +59,10 @@ public class FormattableFlags {
      * 
          *     out.toUpperCase() 
    
      *
-     * 
     This flag corresponds to '^' ('\u005e') in
+     * 
     This flag corresponds to 'S' ('\u0053') in
      * the format specifier.
      */
-    public static final int UPPERCASE = 1<<1;    // '^'
+    public static final int UPPERCASE = 1<<1;    // 'S'
 
     /**
      * Requires the output to use an alternate form.  The definition of the
diff --git a/jdk/src/share/classes/java/util/ListResourceBundle.java b/jdk/src/share/classes/java/util/ListResourceBundle.java
index 84b8ea082249a8bc89796f9da0ea3b33723e21f7..b933d9c83d2b306da8ca2c371d0c9a4d33959513 100644
--- a/jdk/src/share/classes/java/util/ListResourceBundle.java
+++ b/jdk/src/share/classes/java/util/ListResourceBundle.java
@@ -72,7 +72,7 @@ import sun.util.ResourceBundleEnumeration;
  *
  * public class MyResources extends ListResourceBundle {
  *     protected Object[][] getContents() {
- *         return new Object[][] = {
+ *         return new Object[][] {
  *         // LOCALIZE THIS
  *             {"s1", "The disk \"{1}\" contains {0}."},  // MessageFormat pattern
  *             {"s2", "1"},                               // location of {0} in pattern
diff --git a/jdk/src/share/classes/java/util/Locale.java b/jdk/src/share/classes/java/util/Locale.java
index 3947f00d7a5ebbaf9c6ced362b960056440ad685..ecaa9cca68a4a35feeb266d6f06194e2a4949e53 100644
--- a/jdk/src/share/classes/java/util/Locale.java
+++ b/jdk/src/share/classes/java/util/Locale.java
@@ -870,7 +870,7 @@ public final class Locale implements Cloneable, Serializable {
      * @throws SecurityException - if a security manager exists and its
      *     checkPermission method doesn't allow the operation.
      * @throws NullPointerException - if category and/or newLocale is null
-     * @see SecurityManager.checkPermission(java.security.Permission)
+     * @see SecurityManager#checkPermission(java.security.Permission)
      * @see PropertyPermission
      * @see #getDefault(Locale.Category)
      * @since 1.7
@@ -1232,20 +1232,18 @@ public final class Locale implements Cloneable, Serializable {
      * "Solaris_isjustthecoolestthing" is emitted as
      * "x-lvariant-Solaris", not as "solaris".
    • * - *

    Compatibility special cases:

    * *

    Note: Although the language tag created by this * method is well-formed (satisfies the syntax requirements @@ -1327,7 +1325,7 @@ public final class Locale implements Cloneable, Serializable { * * 

          *     Locale loc;
-     *     loc = Locale.forLanguageTag("en-US-x-lvariant-POSIX);
+     *     loc = Locale.forLanguageTag("en-US-x-lvariant-POSIX");
      *     loc.getVariant(); // returns "POSIX"
      *     loc.getExtension('x'); // returns null
      *
@@ -1355,10 +1353,10 @@ public final class Locale implements Cloneable, Serializable {
      * extensions are added as though the constructor had been called:
      *
      * 
    -     *    Locale.forLanguageTag("ja-JP-x-lvariant-JP).toLanguageTag();
-     *    // returns ja-JP-u-ca-japanese-x-lvariant-JP
-     *    Locale.forLanguageTag("th-TH-x-lvariant-TH).toLanguageTag();
-     *    // returns th-TH-u-nu-thai-x-lvariant-TH
+     *    Locale.forLanguageTag("ja-JP-x-lvariant-JP").toLanguageTag();
+     *    // returns "ja-JP-u-ca-japanese-x-lvariant-JP"
+     *    Locale.forLanguageTag("th-TH-x-lvariant-TH").toLanguageTag();
+     *    // returns "th-TH-u-nu-thai-x-lvariant-TH"
      * 
    
      *
      * 
    This implements the 'Language-Tag' production of BCP47, and
@@ -1428,7 +1426,12 @@ public final class Locale implements Cloneable, Serializable {
         LanguageTag tag = LanguageTag.parse(languageTag, null);
         InternalLocaleBuilder bldr = new InternalLocaleBuilder();
         bldr.setLanguageTag(tag);
-        return getInstance(bldr.getBaseLocale(), bldr.getLocaleExtensions());
+        BaseLocale base = bldr.getBaseLocale();
+        LocaleExtensions exts = bldr.getLocaleExtensions();
+        if (exts.isEmpty() && base.getVariant().length() > 0) {
+            exts = getCompatibilityExtensions(base.getLanguage(), base.getScript(), base.getRegion(), base.getVariant());
+        }
+        return getInstance(base, exts);
     }
 
     /**
@@ -2487,6 +2490,10 @@ public final class Locale implements Cloneable, Serializable {
         public Locale build() {
             BaseLocale baseloc = _locbld.getBaseLocale();
             LocaleExtensions extensions = _locbld.getLocaleExtensions();
+            if (extensions.isEmpty() && baseloc.getVariant().length() > 0) {
+                extensions = getCompatibilityExtensions(baseloc.getLanguage(), baseloc.getScript(),
+                        baseloc.getRegion(), baseloc.getVariant());
+            }
             return Locale.getInstance(baseloc, extensions);
         }
     }
diff --git a/jdk/src/share/classes/java/util/Random.java b/jdk/src/share/classes/java/util/Random.java
index 833cfbbe256cf0eb68b35ecee4abed0160147497..8f217833bfe260e3053fb3c5ad6437bda97f50f9 100644
--- a/jdk/src/share/classes/java/util/Random.java
+++ b/jdk/src/share/classes/java/util/Random.java
@@ -77,9 +77,9 @@ class Random implements java.io.Serializable {
      */
     private final AtomicLong seed;
 
-    private final static long multiplier = 0x5DEECE66DL;
-    private final static long addend = 0xBL;
-    private final static long mask = (1L << 48) - 1;
+    private static final long multiplier = 0x5DEECE66DL;
+    private static final long addend = 0xBL;
+    private static final long mask = (1L << 48) - 1;
 
     /**
      * Creates a new random number generator. This constructor sets
@@ -285,7 +285,7 @@ class Random implements java.io.Serializable {
      * @return the next pseudorandom, uniformly distributed {@code int}
      *         value between {@code 0} (inclusive) and {@code n} (exclusive)
      *         from this random number generator's sequence
-     * @exception IllegalArgumentException if n is not positive
+     * @throws IllegalArgumentException if n is not positive
      * @since 1.2
      */
 
diff --git a/jdk/src/share/classes/java/util/Stack.java b/jdk/src/share/classes/java/util/Stack.java
index 9c17b31a75bc145ab266c5ed4cfa4043f549735d..8dd2ebddbbe3df2d85cbca86fec1f876c1e41177 100644
--- a/jdk/src/share/classes/java/util/Stack.java
+++ b/jdk/src/share/classes/java/util/Stack.java
@@ -73,9 +73,9 @@ class Stack extends Vector {
      * Removes the object at the top of this stack and returns that
      * object as the value of this function.
      *
-     * @return     The object at the top of this stack (the last item
-     *             of the Vector object).
-     * @exception  EmptyStackException  if this stack is empty.
+     * @return  The object at the top of this stack (the last item
+     *          of the Vector object).
+     * @throws  EmptyStackException  if this stack is empty.
      */
     public synchronized E pop() {
         E       obj;
@@ -91,9 +91,9 @@ class Stack extends Vector {
      * Looks at the object at the top of this stack without removing it
      * from the stack.
      *
-     * @return     the object at the top of this stack (the last item
-     *             of the Vector object).
-     * @exception  EmptyStackException  if this stack is empty.
+     * @return  the object at the top of this stack (the last item
+     *          of the Vector object).
+     * @throws  EmptyStackException  if this stack is empty.
      */
     public synchronized E peek() {
         int     len = size();
diff --git a/jdk/src/share/classes/java/util/TimSort.java b/jdk/src/share/classes/java/util/TimSort.java
index 6940883d02a98a0a68513da9b8e7245a03ff1ae8..6d4727ac4e7a574aeb7df1f786357f3c3e5d55ca 100644
--- a/jdk/src/share/classes/java/util/TimSort.java
+++ b/jdk/src/share/classes/java/util/TimSort.java
@@ -239,7 +239,7 @@ class TimSort {
      * @param lo the index of the first element in the range to be sorted
      * @param hi the index after the last element in the range to be sorted
      * @param start the index of the first element in the range that is
-     *        not already known to be sorted (@code lo <= start <= hi}
+     *        not already known to be sorted ({@code lo <= start <= hi})
      * @param c comparator to used for the sort
      */
     @SuppressWarnings("fallthrough")
@@ -278,7 +278,7 @@ class TimSort {
              */
             int n = start - left;  // The number of elements to move
             // Switch is just an optimization for arraycopy in default case
-            switch(n) {
+            switch (n) {
                 case 2:  a[left + 2] = a[left + 1];
                 case 1:  a[left + 1] = a[left];
                          break;
@@ -308,7 +308,7 @@ class TimSort {
      * @param a the array in which a run is to be counted and possibly reversed
      * @param lo index of the first element in the run
      * @param hi index after the last element that may be contained in the run.
-              It is required that @code{lo < hi}.
+              It is required that {@code lo < hi}.
      * @param c the comparator to used for the sort
      * @return  the length of the run beginning at the specified position in
      *          the specified array
@@ -322,7 +322,7 @@ class TimSort {
 
         // Find end of run, and reverse range if descending
         if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
-            while(runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
+            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                 runHi++;
             reverseRange(a, lo, runHi);
         } else {                              // Ascending
diff --git a/jdk/src/share/classes/java/util/TreeMap.java b/jdk/src/share/classes/java/util/TreeMap.java
index b0c9aa7d67a781c473e38c1576bbcaf8b8962eb6..8c055d8ce98607a965c26e781dc6a8c224c06f07 100644
--- a/jdk/src/share/classes/java/util/TreeMap.java
+++ b/jdk/src/share/classes/java/util/TreeMap.java
@@ -1056,11 +1056,11 @@ public class TreeMap
         public Comparator comparator() { return m.comparator(); }
         public E pollFirst() {
             Map.Entry e = m.pollFirstEntry();
-            return e == null? null : e.getKey();
+            return (e == null) ? null : e.getKey();
         }
         public E pollLast() {
             Map.Entry e = m.pollLastEntry();
-            return e == null? null : e.getKey();
+            return (e == null) ? null : e.getKey();
         }
         public boolean remove(Object o) {
             int oldSize = size();
@@ -1196,7 +1196,7 @@ public class TreeMap
      * Test two values for equality.  Differs from o1.equals(o2) only in
      * that it copes with {@code null} o1 properly.
      */
-    final static boolean valEquals(Object o1, Object o2) {
+    static final boolean valEquals(Object o1, Object o2) {
         return (o1==null ? o2==null : o1.equals(o2));
     }
 
@@ -1204,7 +1204,7 @@ public class TreeMap
      * Return SimpleImmutableEntry for entry, or null if null
      */
     static  Map.Entry exportEntry(TreeMap.Entry e) {
-        return e == null? null :
+        return (e == null) ? null :
             new AbstractMap.SimpleImmutableEntry(e);
     }
 
@@ -1212,7 +1212,7 @@ public class TreeMap
      * Return key for entry, or null if null
      */
     static  K keyOrNull(TreeMap.Entry e) {
-        return e == null? null : e.key;
+        return (e == null) ? null : e.key;
     }
 
     /**
@@ -1237,7 +1237,7 @@ public class TreeMap
     /**
      * @serial include
      */
-    static abstract class NavigableSubMap extends AbstractMap
+    abstract static class NavigableSubMap extends AbstractMap
         implements NavigableMap, java.io.Serializable {
         /**
          * The backing map.
@@ -1412,11 +1412,11 @@ public class TreeMap
         }
 
         public final V get(Object key) {
-            return !inRange(key)? null :  m.get(key);
+            return !inRange(key) ? null :  m.get(key);
         }
 
         public final V remove(Object key) {
-            return !inRange(key)? null  : m.remove(key);
+            return !inRange(key) ? null : m.remove(key);
         }
 
         public final Map.Entry ceilingEntry(K key) {
@@ -1559,7 +1559,8 @@ public class TreeMap
                 if (!inRange(key))
                     return false;
                 TreeMap.Entry node = m.getEntry(key);
-                if (node!=null && valEquals(node.getValue(),entry.getValue())){
+                if (node!=null && valEquals(node.getValue(),
+                                            entry.getValue())) {
                     m.deleteEntry(node);
                     return true;
                 }
@@ -1724,7 +1725,7 @@ public class TreeMap
                                        false,     toKey, inclusive);
         }
 
-        public NavigableMap tailMap(K fromKey, boolean inclusive){
+        public NavigableMap tailMap(K fromKey, boolean inclusive) {
             if (!inRange(fromKey, inclusive))
                 throw new IllegalArgumentException("fromKey out of range");
             return new AscendingSubMap(m,
@@ -1805,7 +1806,7 @@ public class TreeMap
                                         toEnd, hi,    hiInclusive);
         }
 
-        public NavigableMap tailMap(K fromKey, boolean inclusive){
+        public NavigableMap tailMap(K fromKey, boolean inclusive) {
             if (!inRange(fromKey, inclusive))
                 throw new IllegalArgumentException("fromKey out of range");
             return new DescendingSubMap(m,
@@ -2143,7 +2144,7 @@ public class TreeMap
         // If strictly internal, copy successor's element to p and then make p
         // point to successor.
         if (p.left != null && p.right != null) {
-            Entry s = successor (p);
+            Entry s = successor(p);
             p.key = s.key;
             p.value = s.value;
             p = s;
diff --git a/jdk/src/share/classes/java/util/TreeSet.java b/jdk/src/share/classes/java/util/TreeSet.java
index 99e3f313ad681213e99e19ca050270d14c2b04c0..c2e2bdf8ffd1af21c38eae27960b019da2a363fd 100644
--- a/jdk/src/share/classes/java/util/TreeSet.java
+++ b/jdk/src/share/classes/java/util/TreeSet.java
@@ -452,7 +452,7 @@ public class TreeSet extends AbstractSet
      */
     public E pollFirst() {
         Map.Entry e = m.pollFirstEntry();
-        return (e == null)? null : e.getKey();
+        return (e == null) ? null : e.getKey();
     }
 
     /**
@@ -460,7 +460,7 @@ public class TreeSet extends AbstractSet
      */
     public E pollLast() {
         Map.Entry e = m.pollLastEntry();
-        return (e == null)? null : e.getKey();
+        return (e == null) ? null : e.getKey();
     }
 
     /**
diff --git a/jdk/src/share/classes/java/util/Vector.java b/jdk/src/share/classes/java/util/Vector.java
index e508aa5b5c00180054275766c9d6ff64044ae5fc..f1a9c172a278cd3ad40ee06ea4dc6e8e06361ed6 100644
--- a/jdk/src/share/classes/java/util/Vector.java
+++ b/jdk/src/share/classes/java/util/Vector.java
@@ -919,7 +919,7 @@ public class Vector
      *         elements (optional), or if the specified collection is null
      * @since 1.2
      */
-    public synchronized boolean retainAll(Collection c)  {
+    public synchronized boolean retainAll(Collection c) {
         return super.retainAll(c);
     }
 
diff --git a/jdk/src/share/classes/java/util/concurrent/AbstractExecutorService.java b/jdk/src/share/classes/java/util/concurrent/AbstractExecutorService.java
index 3a43617b0be61f44b6156910b90f7863b79d9e14..0322289e52e6f069e42c12bc57fe0331215c2173 100644
--- a/jdk/src/share/classes/java/util/concurrent/AbstractExecutorService.java
+++ b/jdk/src/share/classes/java/util/concurrent/AbstractExecutorService.java
@@ -51,20 +51,20 @@ import java.util.*;
  * 
     Extension example. Here is a sketch of a class
  * that customizes {@link ThreadPoolExecutor} to use
  * a CustomTask class instead of the default FutureTask:
- * 
    + *  
     {@code
  * public class CustomThreadPoolExecutor extends ThreadPoolExecutor {
  *
- *   static class CustomTask<V> implements RunnableFuture<V> {...}
+ *   static class CustomTask implements RunnableFuture {...}
  *
- *   protected <V> RunnableFuture<V> newTaskFor(Callable<V> c) {
- *       return new CustomTask<V>(c);
+ *   protected  RunnableFuture newTaskFor(Callable c) {
+ *       return new CustomTask(c);
  *   }
- *   protected <V> RunnableFuture<V> newTaskFor(Runnable r, V v) {
- *       return new CustomTask<V>(r, v);
+ *   protected  RunnableFuture newTaskFor(Runnable r, V v) {
+ *       return new CustomTask(r, v);
  *   }
  *   // ... add constructors, etc.
- * }
- * 
    
+ * }}
    
+ *
  * @since 1.5
  * @author Doug Lea
  */
@@ -106,7 +106,7 @@ public abstract class AbstractExecutorService implements ExecutorService {
      */
     public Future submit(Runnable task) {
         if (task == null) throw new NullPointerException();
-        RunnableFuture ftask = newTaskFor(task, null);
+        RunnableFuture ftask = newTaskFor(task, null);
         execute(ftask);
         return ftask;
     }
@@ -158,7 +158,7 @@ public abstract class AbstractExecutorService implements ExecutorService {
             // Record exceptions so that if we fail to obtain any
             // result, we can throw the last exception we got.
             ExecutionException ee = null;
-            long lastTime = (timed)? System.nanoTime() : 0;
+            long lastTime = timed ? System.nanoTime() : 0;
             Iterator> it = tasks.iterator();
 
             // Start one task for sure; the rest incrementally
@@ -191,8 +191,6 @@ public abstract class AbstractExecutorService implements ExecutorService {
                     --active;
                     try {
                         return f.get();
-                    } catch (InterruptedException ie) {
-                        throw ie;
                     } catch (ExecutionException eex) {
                         ee = eex;
                     } catch (RuntimeException rex) {
diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java
index 7fb9b07c872bd3f0b66ffb7a7bc9239f660aef32..8074669654c5a0b9de2cbcce2524374a8bac6382 100644
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java
@@ -1270,7 +1270,7 @@ public class ConcurrentHashMap extends AbstractMap
      * for each key-value mapping, followed by a null pair.
      * The key-value mappings are emitted in no particular order.
      */
-    private void writeObject(java.io.ObjectOutputStream s) throws IOException  {
+    private void writeObject(java.io.ObjectOutputStream s) throws IOException {
         s.defaultWriteObject();
 
         for (int k = 0; k < segments.length; ++k) {
@@ -1298,7 +1298,7 @@ public class ConcurrentHashMap extends AbstractMap
      * @param s the stream
      */
     private void readObject(java.io.ObjectInputStream s)
-        throws IOException, ClassNotFoundException  {
+        throws IOException, ClassNotFoundException {
         s.defaultReadObject();
 
         // Initialize each segment to be minimally sized, and let grow.
diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java
index 4837661a4416028e8a3e5a12a98150b8f1229be0..72133fedad7691db6cd64c944b17251fe3156bb0 100644
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java
@@ -38,7 +38,6 @@ package java.util.concurrent;
 import java.util.AbstractCollection;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.ConcurrentModificationException;
 import java.util.Deque;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
@@ -212,7 +211,7 @@ public class ConcurrentLinkedDeque
      * The actual representation we use is that p.next == p means to
      * goto the first node (which in turn is reached by following prev
      * pointers from head), and p.next == null && p.prev == p means
-     * that the iteration is at an end and that p is a (final static)
+     * that the iteration is at an end and that p is a (static final)
      * dummy node, NEXT_TERMINATOR, and not the last active node.
      * Finishing the iteration when encountering such a TERMINATOR is
      * good enough for read-only traversals, so such traversals can use
@@ -271,7 +270,7 @@ public class ConcurrentLinkedDeque
      */
     private transient volatile Node tail;
 
-    private final static Node PREV_TERMINATOR, NEXT_TERMINATOR;
+    private static final Node PREV_TERMINATOR, NEXT_TERMINATOR;
 
     static {
         PREV_TERMINATOR = new Node(null);
@@ -401,7 +400,7 @@ public class ConcurrentLinkedDeque
             }
     }
 
-    private final static int HOPS = 2;
+    private static final int HOPS = 2;
 
     /**
      * Unlinks non-null node x.
@@ -871,7 +870,7 @@ public class ConcurrentLinkedDeque
     /**
      * Inserts the specified element at the front of this deque.
      *
-     * @throws NullPointerException {@inheritDoc}
+     * @throws NullPointerException if the specified element is null
      */
     public void addFirst(E e) {
         linkFirst(e);
@@ -882,7 +881,7 @@ public class ConcurrentLinkedDeque
      *
      * 
    This method is equivalent to {@link #add}.
      *
-     * @throws NullPointerException {@inheritDoc}
+     * @throws NullPointerException if the specified element is null
      */
     public void addLast(E e) {
         linkLast(e);
@@ -892,7 +891,7 @@ public class ConcurrentLinkedDeque
      * Inserts the specified element at the front of this deque.
      *
      * @return {@code true} always
-     * @throws NullPointerException {@inheritDoc}
+     * @throws NullPointerException if the specified element is null
      */
     public boolean offerFirst(E e) {
         linkFirst(e);
@@ -905,7 +904,7 @@ public class ConcurrentLinkedDeque
      * 
    This method is equivalent to {@link #add}.
      *
      * @return {@code true} always
-     * @throws NullPointerException {@inheritDoc}
+     * @throws NullPointerException if the specified element is null
      */
     public boolean offerLast(E e) {
         linkLast(e);
@@ -940,7 +939,7 @@ public class ConcurrentLinkedDeque
     /**
      * @throws NoSuchElementException {@inheritDoc}
      */
-    public E getLast()  {
+    public E getLast() {
         return screenNullResult(peekLast());
     }
 
@@ -1016,7 +1015,7 @@ public class ConcurrentLinkedDeque
      *
      * @param o element to be removed from this deque, if present
      * @return {@code true} if the deque contained the specified element
-     * @throws NullPointerException if the specified element is {@code null}
+     * @throws NullPointerException if the specified element is null
      */
     public boolean removeFirstOccurrence(Object o) {
         checkNotNull(o);
@@ -1037,7 +1036,7 @@ public class ConcurrentLinkedDeque
      *
      * @param o element to be removed from this deque, if present
      * @return {@code true} if the deque contained the specified element
-     * @throws NullPointerException if the specified element is {@code null}
+     * @throws NullPointerException if the specified element is null
      */
     public boolean removeLastOccurrence(Object o) {
         checkNotNull(o);
@@ -1110,7 +1109,7 @@ public class ConcurrentLinkedDeque
      *
      * @param o element to be removed from this deque, if present
      * @return {@code true} if the deque contained the specified element
-     * @throws NullPointerException if the specified element is {@code null}
+     * @throws NullPointerException if the specified element is null
      */
     public boolean remove(Object o) {
         return removeFirstOccurrence(o);
@@ -1165,7 +1164,7 @@ public class ConcurrentLinkedDeque
                     beginningOfTheEnd.lazySetPrev(p); // CAS piggyback
                     if (p.casNext(null, beginningOfTheEnd)) {
                         // Successful CAS is the linearization point
-                        // for all elements to be added to this queue.
+                        // for all elements to be added to this deque.
                         if (!casTail(t, last)) {
                             // Try a little harder to update tail,
                             // since we may be adding many elements.
@@ -1251,12 +1250,12 @@ public class ConcurrentLinkedDeque
      * Returns an iterator over the elements in this deque in proper sequence.
      * The elements will be returned in order from first (head) to last (tail).
      *
-     * 
    The returned {@code Iterator} is a "weakly consistent" iterator that
+     * 
    The returned iterator is a "weakly consistent" iterator that
      * will never throw {@link java.util.ConcurrentModificationException
-     * ConcurrentModificationException},
-     * and guarantees to traverse elements as they existed upon
-     * construction of the iterator, and may (but is not guaranteed to)
-     * reflect any modifications subsequent to construction.
+     * ConcurrentModificationException}, and guarantees to traverse
+     * elements as they existed upon construction of the iterator, and
+     * may (but is not guaranteed to) reflect any modifications
+     * subsequent to construction.
      *
      * @return an iterator over the elements in this deque in proper sequence
      */
@@ -1269,12 +1268,12 @@ public class ConcurrentLinkedDeque
      * sequential order.  The elements will be returned in order from
      * last (tail) to first (head).
      *
-     * 
    The returned {@code Iterator} is a "weakly consistent" iterator that
+     * 
    The returned iterator is a "weakly consistent" iterator that
      * will never throw {@link java.util.ConcurrentModificationException
-     * ConcurrentModificationException},
-     * and guarantees to traverse elements as they existed upon
-     * construction of the iterator, and may (but is not guaranteed to)
-     * reflect any modifications subsequent to construction.
+     * ConcurrentModificationException}, and guarantees to traverse
+     * elements as they existed upon construction of the iterator, and
+     * may (but is not guaranteed to) reflect any modifications
+     * subsequent to construction.
      *
      * @return an iterator over the elements in this deque in reverse order
      */
diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java
index 0d6381cd971e7c632f914a6aed936dee63a2fd36..6ff1b8a5119b9b25c837f4856424647ed95c9a83 100644
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java
@@ -65,8 +65,8 @@ import java.util.Queue;
  * 
    Iterators are weakly consistent, returning elements
  * reflecting the state of the queue at some point at or since the
  * creation of the iterator.  They do not throw {@link
- * ConcurrentModificationException}, and may proceed concurrently with
- * other operations.  Elements contained in the queue since the creation
+ * java.util.ConcurrentModificationException}, and may proceed concurrently
+ * with other operations.  Elements contained in the queue since the creation
  * of the iterator will be returned exactly once.
  *
  * 
    Beware that, unlike in most collections, the {@code size} method
@@ -634,12 +634,12 @@ public class ConcurrentLinkedQueue extends AbstractQueue
      * Returns an iterator over the elements in this queue in proper sequence.
      * The elements will be returned in order from first (head) to last (tail).
      *
-     * 
    The returned {@code Iterator} is a "weakly consistent" iterator that
+     * 
    The returned iterator is a "weakly consistent" iterator that
      * will never throw {@link java.util.ConcurrentModificationException
-     * ConcurrentModificationException},
-     * and guarantees to traverse elements as they existed upon
-     * construction of the iterator, and may (but is not guaranteed to)
-     * reflect any modifications subsequent to construction.
+     * ConcurrentModificationException}, and guarantees to traverse
+     * elements as they existed upon construction of the iterator, and
+     * may (but is not guaranteed to) reflect any modifications
+     * subsequent to construction.
      *
      * @return an iterator over the elements in this queue in proper sequence
      */
diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java
index d129564acebe71c2d82577f6511e76c11ee0624c..09f8dc6f5b2309bfb10f62bbc2c9bc5c829dd7e6 100644
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java
@@ -362,12 +362,12 @@ public class ConcurrentSkipListSet
 
     public E pollFirst() {
         Map.Entry e = m.pollFirstEntry();
-        return e == null? null : e.getKey();
+        return (e == null) ? null : e.getKey();
     }
 
     public E pollLast() {
         Map.Entry e = m.pollLastEntry();
-        return e == null? null : e.getKey();
+        return (e == null) ? null : e.getKey();
     }
 
 
diff --git a/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java b/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java
index 97d27cbe6a43143f393265cc04cbfb5b51011845..73b9df32269d23cdd41e5c7b369a3bd43e05a4ea 100644
--- a/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java
+++ b/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java
@@ -547,7 +547,7 @@ public class CopyOnWriteArrayList
      * @param fromIndex index of first element to be removed
      * @param toIndex index after last element to be removed
      * @throws IndexOutOfBoundsException if fromIndex or toIndex out of range
-     *         (@code{fromIndex < 0 || toIndex > size() || toIndex < fromIndex})
+     *         ({@code{fromIndex < 0 || toIndex > size() || toIndex < fromIndex})
      */
     private void removeRange(int fromIndex, int toIndex) {
         final ReentrantLock lock = this.lock;
@@ -989,7 +989,7 @@ public class CopyOnWriteArrayList
     }
 
     private static class COWIterator implements ListIterator {
-        /** Snapshot of the array **/
+        /** Snapshot of the array */
         private final Object[] snapshot;
         /** Index of element to be returned by subsequent call to next.  */
         private int cursor;
diff --git a/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArraySet.java b/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArraySet.java
index 9114d45fb9a054eedb603198783367b5583780d8..1d2de1d85c9073d564470fd896cb62b24711a332 100644
--- a/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArraySet.java
+++ b/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArraySet.java
@@ -59,24 +59,23 @@ import java.util.*;
  * copy-on-write set to maintain a set of Handler objects that
  * perform some action upon state updates.
  *
- * 
    + *  
     {@code
  * class Handler { void handle(); ... }
  *
  * class X {
- *    private final CopyOnWriteArraySet<Handler> handlers
- *       = new CopyOnWriteArraySet<Handler>();
- *    public void addHandler(Handler h) { handlers.add(h); }
+ *   private final CopyOnWriteArraySet handlers
+ *     = new CopyOnWriteArraySet();
+ *   public void addHandler(Handler h) { handlers.add(h); }
  *
- *    private long internalState;
- *    private synchronized void changeState() { internalState = ...; }
+ *   private long internalState;
+ *   private synchronized void changeState() { internalState = ...; }
  *
- *    public void update() {
- *       changeState();
- *       for (Handler handler : handlers)
- *          handler.handle();
- *    }
- * }
- * 
    
+ *   public void update() {
+ *     changeState();
+ *     for (Handler handler : handlers)
+ *        handler.handle();
+ *   }
+ * }}
    
  *
  * 
    This class is a member of the
  * 
diff --git a/jdk/src/share/classes/java/util/concurrent/CountDownLatch.java b/jdk/src/share/classes/java/util/concurrent/CountDownLatch.java
index ec39cea44d83d78626c9500cb3feb28298bb835a..1c8a0253c149a137a913aa74dfe060bb11b9424b 100644
--- a/jdk/src/share/classes/java/util/concurrent/CountDownLatch.java
+++ b/jdk/src/share/classes/java/util/concurrent/CountDownLatch.java
@@ -175,7 +175,7 @@ public class CountDownLatch {
         }
 
         protected int tryAcquireShared(int acquires) {
-            return getState() == 0? 1 : -1;
+            return (getState() == 0) ? 1 : -1;
         }
 
         protected boolean tryReleaseShared(int releases) {
diff --git a/jdk/src/share/classes/java/util/concurrent/DelayQueue.java b/jdk/src/share/classes/java/util/concurrent/DelayQueue.java
index 6ce3471b18c2bb5569a181b21f57bbdf0147af33..ecb9eefc6e26be12cf3b65e0d19cb061a311df7c 100644
--- a/jdk/src/share/classes/java/util/concurrent/DelayQueue.java
+++ b/jdk/src/share/classes/java/util/concurrent/DelayQueue.java
@@ -482,12 +482,14 @@ public class DelayQueue extends AbstractQueue
     /**
      * Returns an iterator over all the elements (both expired and
      * unexpired) in this queue. The iterator does not return the
-     * elements in any particular order.  The returned
-     * Iterator is a "weakly consistent" iterator that will
-     * never throw {@link ConcurrentModificationException}, and
-     * guarantees to traverse elements as they existed upon
-     * construction of the iterator, and may (but is not guaranteed
-     * to) reflect any modifications subsequent to construction.
+     * elements in any particular order.
+     *
+     * 
    The returned iterator is a "weakly consistent" iterator that
+     * will never throw {@link java.util.ConcurrentModificationException
+     * ConcurrentModificationException}, and guarantees to traverse
+     * elements as they existed upon construction of the iterator, and
+     * may (but is not guaranteed to) reflect any modifications
+     * subsequent to construction.
      *
      * @return an iterator over the elements in this queue
      */
diff --git a/jdk/src/share/classes/java/util/concurrent/Exchanger.java b/jdk/src/share/classes/java/util/concurrent/Exchanger.java
index c4563a8ae9b695c10eac43e63bcf1fceb1dcaaa8..8648278b75566f5363986e84551a16a8c1acff8b 100644
--- a/jdk/src/share/classes/java/util/concurrent/Exchanger.java
+++ b/jdk/src/share/classes/java/util/concurrent/Exchanger.java
@@ -355,7 +355,9 @@ public class Exchanger {
             else if (y == null &&                 // Try to occupy
                      slot.compareAndSet(null, me)) {
                 if (index == 0)                   // Blocking wait for slot 0
-                    return timed? awaitNanos(me, slot, nanos): await(me, slot);
+                    return timed ?
+                        awaitNanos(me, slot, nanos) :
+                        await(me, slot);
                 Object v = spinWait(me, slot);    // Spin wait for non-0
                 if (v != CANCEL)
                     return v;
@@ -597,8 +599,8 @@ public class Exchanger {
      * dormant until one of two things happens:
      * 
    
      * 
    If the current thread:
      * 
      
@@ -616,7 +618,7 @@ public class Exchanger {
      */
     public V exchange(V x) throws InterruptedException {
         if (!Thread.interrupted()) {
-            Object v = doExchange(x == null? NULL_ITEM : x, false, 0);
+            Object v = doExchange((x == null) ? NULL_ITEM : x, false, 0);
             if (v == NULL_ITEM)
                 return null;
             if (v != CANCEL)
@@ -671,7 +673,7 @@ public class Exchanger {
     public V exchange(V x, long timeout, TimeUnit unit)
         throws InterruptedException, TimeoutException {
         if (!Thread.interrupted()) {
-            Object v = doExchange(x == null? NULL_ITEM : x,
+            Object v = doExchange((x == null) ? NULL_ITEM : x,
                                   true, unit.toNanos(timeout));
             if (v == NULL_ITEM)
                 return null;
diff --git a/jdk/src/share/classes/java/util/concurrent/Executor.java b/jdk/src/share/classes/java/util/concurrent/Executor.java
index 85b3277f43d57e38ca1668422c7253cf31289697..5e67fbcdd08fe60aa75f4281d7fc8b2f4b42796d 100644
--- a/jdk/src/share/classes/java/util/concurrent/Executor.java
+++ b/jdk/src/share/classes/java/util/concurrent/Executor.java
@@ -79,37 +79,37 @@ package java.util.concurrent;
  * serializes the submission of tasks to a second executor,
  * illustrating a composite executor.
  *
- * 
      + *  
       {@code
  * class SerialExecutor implements Executor {
- *     final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
- *     final Executor executor;
- *     Runnable active;
- *
- *     SerialExecutor(Executor executor) {
- *         this.executor = executor;
- *     }
- *
- *     public synchronized void execute(final Runnable r) {
- *         tasks.offer(new Runnable() {
- *             public void run() {
- *                 try {
- *                     r.run();
- *                 } finally {
- *                     scheduleNext();
- *                 }
- *             }
- *         });
- *         if (active == null) {
- *             scheduleNext();
+ *   final Queue tasks = new ArrayDeque();
+ *   final Executor executor;
+ *   Runnable active;
+ *
+ *   SerialExecutor(Executor executor) {
+ *     this.executor = executor;
+ *   }
+ *
+ *   public synchronized void execute(final Runnable r) {
+ *     tasks.offer(new Runnable() {
+ *       public void run() {
+ *         try {
+ *           r.run();
+ *         } finally {
+ *           scheduleNext();
  *         }
+ *       }
+ *     });
+ *     if (active == null) {
+ *       scheduleNext();
  *     }
+ *   }
  *
- *     protected synchronized void scheduleNext() {
- *         if ((active = tasks.poll()) != null) {
- *             executor.execute(active);
- *         }
+ *   protected synchronized void scheduleNext() {
+ *     if ((active = tasks.poll()) != null) {
+ *       executor.execute(active);
  *     }
- * }
      
+ *   }
+ * }}
      
  *
  * The Executor implementations provided in this package
  * implement {@link ExecutorService}, which is a more extensive
diff --git a/jdk/src/share/classes/java/util/concurrent/ExecutorCompletionService.java b/jdk/src/share/classes/java/util/concurrent/ExecutorCompletionService.java
index 4d37c999018f6bf4b1ab469498cac82e68c0fff9..9908a8cfcdd2e45098a7692ebfe92247406d54a0 100644
--- a/jdk/src/share/classes/java/util/concurrent/ExecutorCompletionService.java
+++ b/jdk/src/share/classes/java/util/concurrent/ExecutorCompletionService.java
@@ -197,7 +197,8 @@ public class ExecutorCompletionService implements CompletionService {
         return completionQueue.poll();
     }
 
-    public Future poll(long timeout, TimeUnit unit) throws InterruptedException {
+    public Future poll(long timeout, TimeUnit unit)
+            throws InterruptedException {
         return completionQueue.poll(timeout, unit);
     }
 
diff --git a/jdk/src/share/classes/java/util/concurrent/Executors.java b/jdk/src/share/classes/java/util/concurrent/Executors.java
index efa2f78f86f34533a0b154370bbabb2284f31586..75a490086ae6c828c3dc83dbc7ab475c33f66803 100644
--- a/jdk/src/share/classes/java/util/concurrent/Executors.java
+++ b/jdk/src/share/classes/java/util/concurrent/Executors.java
@@ -83,7 +83,7 @@ public class Executors {
      *
      * @param nThreads the number of threads in the pool
      * @return the newly created thread pool
-     * @throws IllegalArgumentException if nThreads <= 0
+     * @throws IllegalArgumentException if {@code nThreads <= 0}
      */
     public static ExecutorService newFixedThreadPool(int nThreads) {
         return new ThreadPoolExecutor(nThreads, nThreads,
@@ -108,7 +108,7 @@ public class Executors {
      * @param threadFactory the factory to use when creating new threads
      * @return the newly created thread pool
      * @throws NullPointerException if threadFactory is null
-     * @throws IllegalArgumentException if nThreads <= 0
+     * @throws IllegalArgumentException if {@code nThreads <= 0}
      */
     public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
         return new ThreadPoolExecutor(nThreads, nThreads,
@@ -242,7 +242,7 @@ public class Executors {
      * @param corePoolSize the number of threads to keep in the pool,
      * even if they are idle.
      * @return a newly created scheduled thread pool
-     * @throws IllegalArgumentException if corePoolSize < 0
+     * @throws IllegalArgumentException if {@code corePoolSize < 0}
      */
     public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
         return new ScheduledThreadPoolExecutor(corePoolSize);
@@ -256,7 +256,7 @@ public class Executors {
      * @param threadFactory the factory to use when the executor
      * creates a new thread.
      * @return a newly created scheduled thread pool
-     * @throws IllegalArgumentException if corePoolSize < 0
+     * @throws IllegalArgumentException if {@code corePoolSize < 0}
      * @throws NullPointerException if threadFactory is null
      */
     public static ScheduledExecutorService newScheduledThreadPool(
@@ -562,8 +562,8 @@ public class Executors {
 
         DefaultThreadFactory() {
             SecurityManager s = System.getSecurityManager();
-            group = (s != null)? s.getThreadGroup() :
-                                 Thread.currentThread().getThreadGroup();
+            group = (s != null) ? s.getThreadGroup() :
+                                  Thread.currentThread().getThreadGroup();
             namePrefix = "pool-" +
                           poolNumber.getAndIncrement() +
                          "-thread-";
@@ -669,7 +669,7 @@ public class Executors {
         FinalizableDelegatedExecutorService(ExecutorService executor) {
             super(executor);
         }
-        protected void finalize()  {
+        protected void finalize() {
             super.shutdown();
         }
     }
diff --git a/jdk/src/share/classes/java/util/concurrent/Future.java b/jdk/src/share/classes/java/util/concurrent/Future.java
index 9d3d1ff741b72dd6153c95da0b47c01071c96f94..4abd3f4e1741ad577f05f56f0c6f3f64cacf5d31 100644
--- a/jdk/src/share/classes/java/util/concurrent/Future.java
+++ b/jdk/src/share/classes/java/util/concurrent/Future.java
@@ -47,21 +47,21 @@ package java.util.concurrent;
  * computation has completed, the computation cannot be cancelled.
  * If you would like to use a Future for the sake
  * of cancellability but not provide a usable result, you can
- * declare types of the form Future<?> and
+ * declare types of the form {@code Future} and
  * return null as a result of the underlying task.
  *
  * 
      
  * Sample Usage (Note that the following classes are all
  * made-up.) 
      
- * 
      + *  
       {@code
  * interface ArchiveSearcher { String search(String target); }
  * class App {
  *   ExecutorService executor = ...
  *   ArchiveSearcher searcher = ...
  *   void showSearch(final String target)
  *       throws InterruptedException {
- *     Future<String> future
- *       = executor.submit(new Callable<String>() {
+ *     Future future
+ *       = executor.submit(new Callable() {
  *         public String call() {
  *             return searcher.search(target);
  *         }});
@@ -70,20 +70,18 @@ package java.util.concurrent;
  *       displayText(future.get()); // use future
  *     } catch (ExecutionException ex) { cleanup(); return; }
  *   }
- * }
- * 
      
+ * }}
      
  *
  * The {@link FutureTask} class is an implementation of Future that
  * implements Runnable, and so may be executed by an Executor.
  * For example, the above construction with submit could be replaced by:
- * 
      - *     FutureTask<String> future =
- *       new FutureTask<String>(new Callable<String>() {
+ *  
       {@code
+ *     FutureTask future =
+ *       new FutureTask(new Callable() {
  *         public String call() {
  *           return searcher.search(target);
  *       }});
- *     executor.execute(future);
- * 
      
+ *     executor.execute(future);}
      
  *
  * 
      Memory consistency effects: Actions taken by the asynchronous computation
  *  happen-before
diff --git a/jdk/src/share/classes/java/util/concurrent/FutureTask.java b/jdk/src/share/classes/java/util/concurrent/FutureTask.java
index c77b6d3ced4205eafabc77f82da4a94dcbd0a4dd..dd7a51edf712686fa929d2a249893bed12f9ec38 100644
--- a/jdk/src/share/classes/java/util/concurrent/FutureTask.java
+++ b/jdk/src/share/classes/java/util/concurrent/FutureTask.java
@@ -85,7 +85,7 @@ public class FutureTask implements RunnableFuture {
      * @param result the result to return on successful completion. If
      * you don't need a particular result, consider using
      * constructions of the form:
-     * Future<?> f = new FutureTask<Object>(runnable, null)
+     * {@code Future f = new FutureTask(runnable, null)}
      * @throws NullPointerException if runnable is null
      */
     public FutureTask(Runnable runnable, V result) {
diff --git a/jdk/src/share/classes/java/util/concurrent/LinkedBlockingDeque.java b/jdk/src/share/classes/java/util/concurrent/LinkedBlockingDeque.java
index 13901e842f72a910e1d4c42aab9770741e6b9e36..8051ccaa8483f71f0f873515a27f1880b051ab6f 100644
--- a/jdk/src/share/classes/java/util/concurrent/LinkedBlockingDeque.java
+++ b/jdk/src/share/classes/java/util/concurrent/LinkedBlockingDeque.java
@@ -1004,12 +1004,13 @@ public class LinkedBlockingDeque
     /**
      * Returns an iterator over the elements in this deque in proper sequence.
      * The elements will be returned in order from first (head) to last (tail).
-     * The returned {@code Iterator} is a "weakly consistent" iterator that
+     *
+     * 
      The returned iterator is a "weakly consistent" iterator that
      * will never throw {@link java.util.ConcurrentModificationException
-     * ConcurrentModificationException},
-     * and guarantees to traverse elements as they existed upon
-     * construction of the iterator, and may (but is not guaranteed to)
-     * reflect any modifications subsequent to construction.
+     * ConcurrentModificationException}, and guarantees to traverse
+     * elements as they existed upon construction of the iterator, and
+     * may (but is not guaranteed to) reflect any modifications
+     * subsequent to construction.
      *
      * @return an iterator over the elements in this deque in proper sequence
      */
@@ -1021,12 +1022,13 @@ public class LinkedBlockingDeque
      * Returns an iterator over the elements in this deque in reverse
      * sequential order.  The elements will be returned in order from
      * last (tail) to first (head).
-     * The returned {@code Iterator} is a "weakly consistent" iterator that
+     *
+     * 
      The returned iterator is a "weakly consistent" iterator that
      * will never throw {@link java.util.ConcurrentModificationException
-     * ConcurrentModificationException},
-     * and guarantees to traverse elements as they existed upon
-     * construction of the iterator, and may (but is not guaranteed to)
-     * reflect any modifications subsequent to construction.
+     * ConcurrentModificationException}, and guarantees to traverse
+     * elements as they existed upon construction of the iterator, and
+     * may (but is not guaranteed to) reflect any modifications
+     * subsequent to construction.
      */
     public Iterator descendingIterator() {
         return new DescendingItr();
diff --git a/jdk/src/share/classes/java/util/concurrent/RecursiveAction.java b/jdk/src/share/classes/java/util/concurrent/RecursiveAction.java
index 40bcc88f0f8fe4a29fa48d8dd514b74a6ecdb5ff..e13bc4b55781dd332a23163e8d4c4ae7d306af0a 100644
--- a/jdk/src/share/classes/java/util/concurrent/RecursiveAction.java
+++ b/jdk/src/share/classes/java/util/concurrent/RecursiveAction.java
@@ -159,7 +159,9 @@ public abstract class RecursiveAction extends ForkJoinTask {
     protected abstract void compute();
 
     /**
-     * Always returns null.
+     * Always returns {@code null}.
+     *
+     * @return {@code null} always
      */
     public final Void getRawResult() { return null; }
 
diff --git a/jdk/src/share/classes/java/util/concurrent/ScheduledExecutorService.java b/jdk/src/share/classes/java/util/concurrent/ScheduledExecutorService.java
index a8d2f4041831f29b625998e7d48176779927fa32..e9d5d150afc99067c534d7405449507e6f8aa9f1 100644
--- a/jdk/src/share/classes/java/util/concurrent/ScheduledExecutorService.java
+++ b/jdk/src/share/classes/java/util/concurrent/ScheduledExecutorService.java
@@ -72,24 +72,23 @@ import java.util.*;
  * Here is a class with a method that sets up a ScheduledExecutorService
  * to beep every ten seconds for an hour:
  *
- * 
      + *  
       {@code
  * import static java.util.concurrent.TimeUnit.*;
  * class BeeperControl {
- *    private final ScheduledExecutorService scheduler =
- *       Executors.newScheduledThreadPool(1);
+ *   private final ScheduledExecutorService scheduler =
+ *     Executors.newScheduledThreadPool(1);
  *
- *    public void beepForAnHour() {
- *        final Runnable beeper = new Runnable() {
- *                public void run() { System.out.println("beep"); }
- *            };
- *        final ScheduledFuture<?> beeperHandle =
- *            scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
- *        scheduler.schedule(new Runnable() {
- *                public void run() { beeperHandle.cancel(true); }
- *            }, 60 * 60, SECONDS);
- *    }
- * }
- * 
      
+ *   public void beepForAnHour() {
+ *     final Runnable beeper = new Runnable() {
+ *       public void run() { System.out.println("beep"); }
+ *     };
+ *     final ScheduledFuture beeperHandle =
+ *       scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
+ *     scheduler.schedule(new Runnable() {
+ *       public void run() { beeperHandle.cancel(true); }
+ *     }, 60 * 60, SECONDS);
+ *   }
+ * }}
      
  *
  * @since 1.5
  * @author Doug Lea
diff --git a/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java b/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java
index 67c23fe99d79351d2bf83318761f4baf521ac3e2..46961b7aa40a43bf01bd9c0107b1ea618e4d6cb5 100644
--- a/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java
+++ b/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java
@@ -62,8 +62,8 @@ import java.util.*;
  * time of cancellation.
  *
  * 
      Successive executions of a task scheduled via
- * scheduleAtFixedRate or
- * scheduleWithFixedDelay do not overlap. While different
+ * {@code scheduleAtFixedRate} or
+ * {@code scheduleWithFixedDelay} do not overlap. While different
  * executions may be performed by different threads, the effects of
  * prior executions happen-before
@@ -436,7 +436,7 @@ public class ScheduledThreadPoolExecutor
      * @throws NullPointerException if {@code threadFactory} is null
      */
     public ScheduledThreadPoolExecutor(int corePoolSize,
-                             ThreadFactory threadFactory) {
+                                       ThreadFactory threadFactory) {
         super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
               new DelayedWorkQueue(), threadFactory);
     }
@@ -453,7 +453,7 @@ public class ScheduledThreadPoolExecutor
      * @throws NullPointerException if {@code handler} is null
      */
     public ScheduledThreadPoolExecutor(int corePoolSize,
-                              RejectedExecutionHandler handler) {
+                                       RejectedExecutionHandler handler) {
         super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
               new DelayedWorkQueue(), handler);
     }
@@ -473,8 +473,8 @@ public class ScheduledThreadPoolExecutor
      *         {@code handler} is null
      */
     public ScheduledThreadPoolExecutor(int corePoolSize,
-                              ThreadFactory threadFactory,
-                              RejectedExecutionHandler handler) {
+                                       ThreadFactory threadFactory,
+                                       RejectedExecutionHandler handler) {
         super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
               new DelayedWorkQueue(), threadFactory, handler);
     }
diff --git a/jdk/src/share/classes/java/util/concurrent/Semaphore.java b/jdk/src/share/classes/java/util/concurrent/Semaphore.java
index 96a4719148d7397f8469ab773beb1e1be2671959..56c233fb3a7ba7ede0fe838fa78f8a5c7d495185 100644
--- a/jdk/src/share/classes/java/util/concurrent/Semaphore.java
+++ b/jdk/src/share/classes/java/util/concurrent/Semaphore.java
@@ -223,7 +223,7 @@ public class Semaphore implements java.io.Serializable {
     /**
      * NonFair version
      */
-    final static class NonfairSync extends Sync {
+    static final class NonfairSync extends Sync {
         private static final long serialVersionUID = -2694183684443567898L;
 
         NonfairSync(int permits) {
@@ -238,7 +238,7 @@ public class Semaphore implements java.io.Serializable {
     /**
      * Fair version
      */
-    final static class FairSync extends Sync {
+    static final class FairSync extends Sync {
         private static final long serialVersionUID = 2014338818796000944L;
 
         FairSync(int permits) {
@@ -282,7 +282,7 @@ public class Semaphore implements java.io.Serializable {
      *        else {@code false}
      */
     public Semaphore(int permits, boolean fair) {
-        sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
+        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
     }
 
     /**
diff --git a/jdk/src/share/classes/java/util/concurrent/ThreadLocalRandom.java b/jdk/src/share/classes/java/util/concurrent/ThreadLocalRandom.java
index c8a67dd651022703ce4bddcf8235fbbbedec4b2f..69f5fbcb40481b1350ba7921f8c7a9f7e260096e 100644
--- a/jdk/src/share/classes/java/util/concurrent/ThreadLocalRandom.java
+++ b/jdk/src/share/classes/java/util/concurrent/ThreadLocalRandom.java
@@ -63,9 +63,9 @@ import java.util.Random;
  */
 public class ThreadLocalRandom extends Random {
     // same constants as Random, but must be redeclared because private
-    private final static long multiplier = 0x5DEECE66DL;
-    private final static long addend = 0xBL;
-    private final static long mask = (1L << 48) - 1;
+    private static final long multiplier = 0x5DEECE66DL;
+    private static final long addend = 0xBL;
+    private static final long mask = (1L << 48) - 1;
 
     /**
      * The random seed. We can't use super.seed.
diff --git a/jdk/src/share/classes/java/util/concurrent/TimeUnit.java b/jdk/src/share/classes/java/util/concurrent/TimeUnit.java
index 5a18a5b01c01c45c0675213f35d44be898199b35..236e553bc6c6b773971bcee742822c0645200476 100644
--- a/jdk/src/share/classes/java/util/concurrent/TimeUnit.java
+++ b/jdk/src/share/classes/java/util/concurrent/TimeUnit.java
@@ -53,12 +53,12 @@ package java.util.concurrent;
  * java.util.concurrent.locks.Lock lock} is not available:
  *
  * 
        Lock lock = ...;
- *  if ( lock.tryLock(50L, TimeUnit.MILLISECONDS) ) ...
+ *  if (lock.tryLock(50L, TimeUnit.MILLISECONDS)) ...
  * 
      
  * while this code will timeout in 50 seconds:
  * 
        *  Lock lock = ...;
- *  if ( lock.tryLock(50L, TimeUnit.SECONDS) ) ...
+ *  if (lock.tryLock(50L, TimeUnit.SECONDS)) ...
  * 
      
  *
  * Note however, that there is no guarantee that a particular timeout
@@ -291,7 +291,8 @@ public enum TimeUnit {
     abstract int excessNanos(long d, long m);
 
     /**
-     * Performs a timed Object.wait using this time unit.
+     * Performs a timed {@link Object#wait(long, int) Object.wait}
+     * using this time unit.
      * This is a convenience method that converts timeout arguments
      * into the form required by the Object.wait method.
      *
@@ -299,21 +300,22 @@ public enum TimeUnit {
      * method (see {@link BlockingQueue#poll BlockingQueue.poll})
      * using:
      *
-     * 
        public synchronized Object poll(long timeout, TimeUnit unit) throws InterruptedException {
-     *    while (empty) {
-     *      unit.timedWait(this, timeout);
-     *      ...
-     *    }
-     *  }
      
+     *  
       {@code
+     * public synchronized Object poll(long timeout, TimeUnit unit)
+     *     throws InterruptedException {
+     *   while (empty) {
+     *     unit.timedWait(this, timeout);
+     *     ...
+     *   }
+     * }}
      
      *
      * @param obj the object to wait on
      * @param timeout the maximum time to wait. If less than
      * or equal to zero, do not wait at all.
-     * @throws InterruptedException if interrupted while waiting.
-     * @see Object#wait(long, int)
+     * @throws InterruptedException if interrupted while waiting
      */
     public void timedWait(Object obj, long timeout)
-    throws InterruptedException {
+            throws InterruptedException {
         if (timeout > 0) {
             long ms = toMillis(timeout);
             int ns = excessNanos(timeout, ms);
@@ -322,17 +324,18 @@ public enum TimeUnit {
     }
 
     /**
-     * Performs a timed Thread.join using this time unit.
+     * Performs a timed {@link Thread#join(long, int) Thread.join}
+     * using this time unit.
      * This is a convenience method that converts time arguments into the
      * form required by the Thread.join method.
+     *
      * @param thread the thread to wait for
      * @param timeout the maximum time to wait. If less than
      * or equal to zero, do not wait at all.
-     * @throws InterruptedException if interrupted while waiting.
-     * @see Thread#join(long, int)
+     * @throws InterruptedException if interrupted while waiting
      */
     public void timedJoin(Thread thread, long timeout)
-    throws InterruptedException {
+            throws InterruptedException {
         if (timeout > 0) {
             long ms = toMillis(timeout);
             int ns = excessNanos(timeout, ms);
@@ -341,13 +344,14 @@ public enum TimeUnit {
     }
 
     /**
-     * Performs a Thread.sleep using this unit.
+     * Performs a {@link Thread#sleep(long, int) Thread.sleep} using
+     * this time unit.
      * This is a convenience method that converts time arguments into the
      * form required by the Thread.sleep method.
+     *
      * @param timeout the minimum time to sleep. If less than
      * or equal to zero, do not sleep at all.
-     * @throws InterruptedException if interrupted while sleeping.
-     * @see Thread#sleep
+     * @throws InterruptedException if interrupted while sleeping
      */
     public void sleep(long timeout) throws InterruptedException {
         if (timeout > 0) {
diff --git a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
index 9073254b12264bf163b55716d1fb8ec7818db4f6..7ea3a8012d5f40712be2a7804adecdebd6ac01b5 100644
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
@@ -55,7 +55,7 @@ import java.lang.reflect.*;
  * @author Doug Lea
  * @param  The type of the object holding the updatable field
  */
-public abstract class  AtomicIntegerFieldUpdater  {
+public abstract class  AtomicIntegerFieldUpdater {
     /**
      * Creates and returns an updater for objects with the given field.
      * The Class argument is needed to check that reflective types and
@@ -279,7 +279,7 @@ public abstract class  AtomicIntegerFieldUpdater  {
                 sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                     caller, tclass, null, modifiers);
                 sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
-            } catch(Exception ex) {
+            } catch (Exception ex) {
                 throw new RuntimeException(ex);
             }
 
diff --git a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
index 8a81dbc9a8834e59a5eba639c40bca989a6f2cd2..22a1d5eecbea767bc38f5891d91a6e8b23c9bef4 100644
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
@@ -55,7 +55,7 @@ import java.lang.reflect.*;
  * @author Doug Lea
  * @param  The type of the object holding the updatable field
  */
-public abstract class  AtomicLongFieldUpdater  {
+public abstract class  AtomicLongFieldUpdater {
     /**
      * Creates and returns an updater for objects with the given field.
      * The Class argument is needed to check that reflective types and
@@ -278,7 +278,7 @@ public abstract class  AtomicLongFieldUpdater  {
                 sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                     caller, tclass, null, modifiers);
                 sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
-            } catch(Exception ex) {
+            } catch (Exception ex) {
                 throw new RuntimeException(ex);
             }
 
@@ -331,7 +331,7 @@ public abstract class  AtomicLongFieldUpdater  {
             if (cclass.isInstance(obj)) {
                 return;
             }
-            throw new RuntimeException (
+            throw new RuntimeException(
                 new IllegalAccessException("Class " +
                     cclass.getName() +
                     " can not access a protected member of class " +
@@ -361,7 +361,7 @@ public abstract class  AtomicLongFieldUpdater  {
                 sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                     caller, tclass, null, modifiers);
                 sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
-            } catch(Exception ex) {
+            } catch (Exception ex) {
                 throw new RuntimeException(ex);
             }
 
@@ -387,7 +387,7 @@ public abstract class  AtomicLongFieldUpdater  {
 
         public boolean compareAndSet(T obj, long expect, long update) {
             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
-            synchronized(this) {
+            synchronized (this) {
                 long v = unsafe.getLong(obj, offset);
                 if (v != expect)
                     return false;
@@ -402,7 +402,7 @@ public abstract class  AtomicLongFieldUpdater  {
 
         public void set(T obj, long newValue) {
             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
-            synchronized(this) {
+            synchronized (this) {
                 unsafe.putLong(obj, offset, newValue);
             }
         }
@@ -413,7 +413,7 @@ public abstract class  AtomicLongFieldUpdater  {
 
         public long get(T obj) {
             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
-            synchronized(this) {
+            synchronized (this) {
                 return unsafe.getLong(obj, offset);
             }
         }
@@ -422,7 +422,7 @@ public abstract class  AtomicLongFieldUpdater  {
             if (cclass.isInstance(obj)) {
                 return;
             }
-            throw new RuntimeException (
+            throw new RuntimeException(
                 new IllegalAccessException("Class " +
                     cclass.getName() +
                     " can not access a protected member of class " +
diff --git a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
index ec2083294707cb00d7f5abd6b768516b20d5364f..c58fd30139f487bb7392a11d8ad04a913e6cc37a 100644
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
@@ -45,13 +45,13 @@ import java.lang.reflect.*;
  * independently subject to atomic updates. For example, a tree node
  * might be declared as
  *
- * 
      + *  
       {@code
  * class Node {
  *   private volatile Node left, right;
  *
- *   private static final AtomicReferenceFieldUpdater<Node, Node> leftUpdater =
+ *   private static final AtomicReferenceFieldUpdater leftUpdater =
  *     AtomicReferenceFieldUpdater.newUpdater(Node.class, Node.class, "left");
- *   private static AtomicReferenceFieldUpdater<Node, Node> rightUpdater =
+ *   private static AtomicReferenceFieldUpdater rightUpdater =
  *     AtomicReferenceFieldUpdater.newUpdater(Node.class, Node.class, "right");
  *
  *   Node getLeft() { return left;  }
@@ -59,8 +59,7 @@ import java.lang.reflect.*;
  *     return leftUpdater.compareAndSet(this, expect, update);
  *   }
  *   // ... and so on
- * }
- * 
      
+ * }}
      
  *
  * 
      Note that the guarantees of the {@code compareAndSet}
  * method in this class are weaker than in other atomic classes.
@@ -74,7 +73,7 @@ import java.lang.reflect.*;
  * @param  The type of the object holding the updatable field
  * @param  The type of the field
  */
-public abstract class AtomicReferenceFieldUpdater  {
+public abstract class AtomicReferenceFieldUpdater {
 
     /**
      * Creates and returns an updater for objects with the given field.
@@ -291,7 +290,7 @@ public abstract class AtomicReferenceFieldUpdater  {
             if (cclass.isInstance(obj)) {
                 return;
             }
-            throw new RuntimeException (
+            throw new RuntimeException(
                 new IllegalAccessException("Class " +
                     cclass.getName() +
                     " can not access a protected member of class " +
diff --git a/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java b/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java
index c45c2cef1f4739f085ffdc86aada4f3f25dbbecf..605276e27b517b60c40b4dd3b0e0fed03653d14c 100644
--- a/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java
+++ b/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java
@@ -990,7 +990,8 @@ public abstract class AbstractQueuedLongSynchronizer
      *        can represent anything you like.
      * @throws InterruptedException if the current thread is interrupted
      */
-    public final void acquireInterruptibly(long arg) throws InterruptedException {
+    public final void acquireInterruptibly(long arg)
+            throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
         if (!tryAcquire(arg))
@@ -1014,7 +1015,8 @@ public abstract class AbstractQueuedLongSynchronizer
      * @return {@code true} if acquired; {@code false} if timed out
      * @throws InterruptedException if the current thread is interrupted
      */
-    public final boolean tryAcquireNanos(long arg, long nanosTimeout) throws InterruptedException {
+    public final boolean tryAcquireNanos(long arg, long nanosTimeout)
+            throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
         return tryAcquire(arg) ||
@@ -1070,7 +1072,8 @@ public abstract class AbstractQueuedLongSynchronizer
      * you like.
      * @throws InterruptedException if the current thread is interrupted
      */
-    public final void acquireSharedInterruptibly(long arg) throws InterruptedException {
+    public final void acquireSharedInterruptibly(long arg)
+            throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
         if (tryAcquireShared(arg) < 0)
@@ -1093,7 +1096,8 @@ public abstract class AbstractQueuedLongSynchronizer
      * @return {@code true} if acquired; {@code false} if timed out
      * @throws InterruptedException if the current thread is interrupted
      */
-    public final boolean tryAcquireSharedNanos(long arg, long nanosTimeout) throws InterruptedException {
+    public final boolean tryAcquireSharedNanos(long arg, long nanosTimeout)
+            throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
         return tryAcquireShared(arg) >= 0 ||
@@ -1841,7 +1845,8 @@ public abstract class AbstractQueuedLongSynchronizer
          * 
    •  If interrupted while blocked in step 4, throw InterruptedException.
          * 
          */
-        public final long awaitNanos(long nanosTimeout) throws InterruptedException {
+        public final long awaitNanos(long nanosTimeout)
+                throws InterruptedException {
             if (Thread.interrupted())
                 throw new InterruptedException();
             Node node = addConditionWaiter();
@@ -1885,7 +1890,8 @@ public abstract class AbstractQueuedLongSynchronizer
          * 
    •  If timed out while blocked in step 4, return false, else true.
          * 
          */
-        public final boolean awaitUntil(Date deadline) throws InterruptedException {
+        public final boolean awaitUntil(Date deadline)
+                throws InterruptedException {
             if (deadline == null)
                 throw new NullPointerException();
             long abstime = deadline.getTime();
@@ -1928,7 +1934,8 @@ public abstract class AbstractQueuedLongSynchronizer
          * 
    •  If timed out while blocked in step 4, return false, else true.
          * 
          */
-        public final boolean await(long time, TimeUnit unit) throws InterruptedException {
+        public final boolean await(long time, TimeUnit unit)
+                throws InterruptedException {
             if (unit == null)
                 throw new NullPointerException();
             long nanosTimeout = unit.toNanos(time);
@@ -2084,7 +2091,7 @@ public abstract class AbstractQueuedLongSynchronizer
     /**
      * CAS waitStatus field of a node.
      */
-    private final static boolean compareAndSetWaitStatus(Node node,
+    private static final boolean compareAndSetWaitStatus(Node node,
                                                          int expect,
                                                          int update) {
         return unsafe.compareAndSwapInt(node, waitStatusOffset,
@@ -2094,7 +2101,7 @@ public abstract class AbstractQueuedLongSynchronizer
     /**
      * CAS next field of a node.
      */
-    private final static boolean compareAndSetNext(Node node,
+    private static final boolean compareAndSetNext(Node node,
                                                    Node expect,
                                                    Node update) {
         return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
diff --git a/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedSynchronizer.java b/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedSynchronizer.java
index d17c5d08d0ea11723e93fdd1c24d8c53d9acc035..8075aea7dea47df3fa62fd0b2e2d95ea76dc6a6c 100644
--- a/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedSynchronizer.java
+++ b/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedSynchronizer.java
@@ -265,7 +265,7 @@ import sun.misc.Unsafe;
  *     boolean isSignalled() { return getState() != 0; }
  *
  *     protected int tryAcquireShared(int ignore) {
- *       return isSignalled()? 1 : -1;
+ *       return isSignalled() ? 1 : -1;
  *     }
  *
  *     protected boolean tryReleaseShared(int ignore) {
@@ -1213,7 +1213,8 @@ public abstract class AbstractQueuedSynchronizer
      *        can represent anything you like.
      * @throws InterruptedException if the current thread is interrupted
      */
-    public final void acquireInterruptibly(int arg) throws InterruptedException {
+    public final void acquireInterruptibly(int arg)
+            throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
         if (!tryAcquire(arg))
@@ -1237,7 +1238,8 @@ public abstract class AbstractQueuedSynchronizer
      * @return {@code true} if acquired; {@code false} if timed out
      * @throws InterruptedException if the current thread is interrupted
      */
-    public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
+    public final boolean tryAcquireNanos(int arg, long nanosTimeout)
+            throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
         return tryAcquire(arg) ||
@@ -1293,7 +1295,8 @@ public abstract class AbstractQueuedSynchronizer
      * you like.
      * @throws InterruptedException if the current thread is interrupted
      */
-    public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
+    public final void acquireSharedInterruptibly(int arg)
+            throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
         if (tryAcquireShared(arg) < 0)
@@ -1316,7 +1319,8 @@ public abstract class AbstractQueuedSynchronizer
      * @return {@code true} if acquired; {@code false} if timed out
      * @throws InterruptedException if the current thread is interrupted
      */
-    public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
+    public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
+            throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
         return tryAcquireShared(arg) >= 0 ||
@@ -2062,7 +2066,8 @@ public abstract class AbstractQueuedSynchronizer
          * 
    •  If interrupted while blocked in step 4, throw InterruptedException.
          * 
          */
-        public final long awaitNanos(long nanosTimeout) throws InterruptedException {
+        public final long awaitNanos(long nanosTimeout)
+                throws InterruptedException {
             if (Thread.interrupted())
                 throw new InterruptedException();
             Node node = addConditionWaiter();
@@ -2106,7 +2111,8 @@ public abstract class AbstractQueuedSynchronizer
          * 
    •  If timed out while blocked in step 4, return false, else true.
          * 
          */
-        public final boolean awaitUntil(Date deadline) throws InterruptedException {
+        public final boolean awaitUntil(Date deadline)
+                throws InterruptedException {
             if (deadline == null)
                 throw new NullPointerException();
             long abstime = deadline.getTime();
@@ -2149,7 +2155,8 @@ public abstract class AbstractQueuedSynchronizer
          * 
    •  If timed out while blocked in step 4, return false, else true.
          * 
          */
-        public final boolean await(long time, TimeUnit unit) throws InterruptedException {
+        public final boolean await(long time, TimeUnit unit)
+                throws InterruptedException {
             if (unit == null)
                 throw new NullPointerException();
             long nanosTimeout = unit.toNanos(time);
@@ -2305,7 +2312,7 @@ public abstract class AbstractQueuedSynchronizer
     /**
      * CAS waitStatus field of a node.
      */
-    private final static boolean compareAndSetWaitStatus(Node node,
+    private static final boolean compareAndSetWaitStatus(Node node,
                                                          int expect,
                                                          int update) {
         return unsafe.compareAndSwapInt(node, waitStatusOffset,
@@ -2315,7 +2322,7 @@ public abstract class AbstractQueuedSynchronizer
     /**
      * CAS next field of a node.
      */
-    private final static boolean compareAndSetNext(Node node,
+    private static final boolean compareAndSetNext(Node node,
                                                    Node expect,
                                                    Node update) {
         return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
diff --git a/jdk/src/share/classes/java/util/concurrent/locks/LockSupport.java b/jdk/src/share/classes/java/util/concurrent/locks/LockSupport.java
index 9751f418c17270ced5511dcf844f7c2470b4f107..9c966406b313d0ab39c0c60cc83a127bceb34a9f 100644
--- a/jdk/src/share/classes/java/util/concurrent/locks/LockSupport.java
+++ b/jdk/src/share/classes/java/util/concurrent/locks/LockSupport.java
@@ -200,8 +200,8 @@ public class LockSupport {
      * 
    • Some other thread invokes {@link #unpark unpark} with the
      * current thread as the target; or
      *
-     * 
    • Some other thread {@linkplain Thread#interrupt interrupts} the current
-     * thread; or
+     * 
    • Some other thread {@linkplain Thread#interrupt interrupts}
+     * the current thread; or
      *
      * 
    • The specified waiting time elapses; or
      *
diff --git a/jdk/src/share/classes/java/util/concurrent/locks/ReentrantLock.java b/jdk/src/share/classes/java/util/concurrent/locks/ReentrantLock.java
index 9cc3bf4d011159dae01f1ebd73090c1a1002100e..4cbc562b82015113a30083570f71c442ea966e44 100644
--- a/jdk/src/share/classes/java/util/concurrent/locks/ReentrantLock.java
+++ b/jdk/src/share/classes/java/util/concurrent/locks/ReentrantLock.java
@@ -116,7 +116,7 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      * into fair and nonfair versions below. Uses AQS state to
      * represent the number of holds on the lock.
      */
-    static abstract class Sync extends AbstractQueuedSynchronizer {
+    abstract static class Sync extends AbstractQueuedSynchronizer {
         private static final long serialVersionUID = -5179523762034025860L;
 
         /**
@@ -200,7 +200,7 @@ public class ReentrantLock implements Lock, java.io.Serializable {
     /**
      * Sync object for non-fair locks
      */
-    final static class NonfairSync extends Sync {
+    static final class NonfairSync extends Sync {
         private static final long serialVersionUID = 7316153563782823691L;
 
         /**
@@ -222,7 +222,7 @@ public class ReentrantLock implements Lock, java.io.Serializable {
     /**
      * Sync object for fair locks
      */
-    final static class FairSync extends Sync {
+    static final class FairSync extends Sync {
         private static final long serialVersionUID = -3000897897090466540L;
 
         final void lock() {
@@ -269,7 +269,7 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      * @param fair {@code true} if this lock should use a fair ordering policy
      */
     public ReentrantLock(boolean fair) {
-        sync = (fair)? new FairSync() : new NonfairSync();
+        sync = fair ? new FairSync() : new NonfairSync();
     }
 
     /**
@@ -440,7 +440,8 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      * @throws NullPointerException if the time unit is null
      *
      */
-    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
+    public boolean tryLock(long timeout, TimeUnit unit)
+            throws InterruptedException {
         return sync.tryAcquireNanos(1, unit.toNanos(timeout));
     }
 
diff --git a/jdk/src/share/classes/java/util/concurrent/locks/ReentrantReadWriteLock.java b/jdk/src/share/classes/java/util/concurrent/locks/ReentrantReadWriteLock.java
index b327b65c4de00b85693c4dc6a0a37eb63aefdbbd..39b9c0e894dfaf8080e20ba2d9a2cb8b2da14035 100644
--- a/jdk/src/share/classes/java/util/concurrent/locks/ReentrantReadWriteLock.java
+++ b/jdk/src/share/classes/java/util/concurrent/locks/ReentrantReadWriteLock.java
@@ -155,7 +155,7 @@ import java.util.*;
  *          }
  *          // Downgrade by acquiring read lock before releasing write lock
  *          rwl.readLock().lock();
- *        } finally  {
+ *        } finally {
  *          rwl.writeLock().unlock(); // Unlock write, still hold read
  *        }
  *     }
@@ -215,7 +215,8 @@ import java.util.*;
  * @author Doug Lea
  *
  */
-public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable  {
+public class ReentrantReadWriteLock
+        implements ReadWriteLock, java.io.Serializable {
     private static final long serialVersionUID = -6992448646407690164L;
     /** Inner class providing readlock */
     private final ReentrantReadWriteLock.ReadLock readerLock;
@@ -251,7 +252,7 @@ public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializab
      * Synchronization implementation for ReentrantReadWriteLock.
      * Subclassed into fair and nonfair versions.
      */
-    static abstract class Sync extends AbstractQueuedSynchronizer {
+    abstract static class Sync extends AbstractQueuedSynchronizer {
         private static final long serialVersionUID = 6317671515068378041L;
 
         /*
@@ -618,7 +619,7 @@ public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializab
 
         final Thread getOwner() {
             // Must read state before owner to ensure memory consistency
-            return ((exclusiveCount(getState()) == 0)?
+            return ((exclusiveCount(getState()) == 0) ?
                     null :
                     getExclusiveOwnerThread());
         }
@@ -669,7 +670,7 @@ public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializab
     /**
      * Nonfair version of Sync
      */
-    final static class NonfairSync extends Sync {
+    static final class NonfairSync extends Sync {
         private static final long serialVersionUID = -8159625535654395037L;
         final boolean writerShouldBlock() {
             return false; // writers can always barge
@@ -689,7 +690,7 @@ public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializab
     /**
      * Fair version of Sync
      */
-    final static class FairSync extends Sync {
+    static final class FairSync extends Sync {
         private static final long serialVersionUID = -2274990926593161451L;
         final boolean writerShouldBlock() {
             return hasQueuedPredecessors();
@@ -702,7 +703,7 @@ public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializab
     /**
      * The lock returned by method {@link ReentrantReadWriteLock#readLock}.
      */
-    public static class ReadLock implements Lock, java.io.Serializable  {
+    public static class ReadLock implements Lock, java.io.Serializable {
         private static final long serialVersionUID = -5992448646407690164L;
         private final Sync sync;
 
@@ -867,7 +868,8 @@ public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializab
          * @throws NullPointerException if the time unit is null
          *
          */
-        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
+        public boolean tryLock(long timeout, TimeUnit unit)
+                throws InterruptedException {
             return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
         }
 
@@ -908,7 +910,7 @@ public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializab
     /**
      * The lock returned by method {@link ReentrantReadWriteLock#writeLock}.
      */
-    public static class WriteLock implements Lock, java.io.Serializable  {
+    public static class WriteLock implements Lock, java.io.Serializable {
         private static final long serialVersionUID = -4992448646407690164L;
         private final Sync sync;
 
@@ -1108,7 +1110,8 @@ public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializab
          * @throws NullPointerException if the time unit is null
          *
          */
-        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
+        public boolean tryLock(long timeout, TimeUnit unit)
+                throws InterruptedException {
             return sync.tryAcquireNanos(1, unit.toNanos(timeout));
         }
 
diff --git a/jdk/src/share/classes/java/util/zip/ZipFile.java b/jdk/src/share/classes/java/util/zip/ZipFile.java
index e995c4e89eec6fa770ec7571c23841c5c3842b1c..92bda7fb93a69a088d4997c739f42dcc25ed5a8a 100644
--- a/jdk/src/share/classes/java/util/zip/ZipFile.java
+++ b/jdk/src/share/classes/java/util/zip/ZipFile.java
@@ -315,7 +315,7 @@ class ZipFile implements ZipConstants, Closeable {
     private static native void freeEntry(long jzfile, long jzentry);
 
     // the outstanding inputstreams that need to be closed.
-    private Set streams = new HashSet();
+    private Set streams = new HashSet<>();
 
     /**
      * Returns an input stream for reading the contents of the specified
@@ -348,55 +348,58 @@ class ZipFile implements ZipConstants, Closeable {
                 return null;
             }
             in = new ZipFileInputStream(jzentry);
-            streams.add(in);
-        }
-        final ZipFileInputStream zfin = in;
-        switch (getEntryMethod(jzentry)) {
-        case STORED:
-            return zfin;
-        case DEFLATED:
-            // MORE: Compute good size for inflater stream:
-            long size = getEntrySize(jzentry) + 2; // Inflater likes a bit of slack
-            if (size > 65536) size = 8192;
-            if (size <= 0) size = 4096;
-            return new InflaterInputStream(zfin, getInflater(), (int)size) {
-                private boolean isClosed = false;
-
-                public void close() throws IOException {
-                    if (!isClosed) {
-                        releaseInflater(inf);
-                        this.in.close();
-                        isClosed = true;
+
+            switch (getEntryMethod(jzentry)) {
+            case STORED:
+                streams.add(in);
+                return in;
+            case DEFLATED:
+                final ZipFileInputStream zfin = in;
+                // MORE: Compute good size for inflater stream:
+                long size = getEntrySize(jzentry) + 2; // Inflater likes a bit of slack
+                if (size > 65536) size = 8192;
+                if (size <= 0) size = 4096;
+                InputStream is = new InflaterInputStream(zfin, getInflater(), (int)size) {
+                    private boolean isClosed = false;
+
+                    public void close() throws IOException {
+                        if (!isClosed) {
+                            super.close();
+                            releaseInflater(inf);
+                            isClosed = true;
+                        }
                     }
-                }
-                // Override fill() method to provide an extra "dummy" byte
-                // at the end of the input stream. This is required when
-                // using the "nowrap" Inflater option.
-                protected void fill() throws IOException {
-                    if (eof) {
-                        throw new EOFException(
-                            "Unexpected end of ZLIB input stream");
+                    // Override fill() method to provide an extra "dummy" byte
+                    // at the end of the input stream. This is required when
+                    // using the "nowrap" Inflater option.
+                    protected void fill() throws IOException {
+                        if (eof) {
+                            throw new EOFException(
+                                "Unexpected end of ZLIB input stream");
+                        }
+                        len = this.in.read(buf, 0, buf.length);
+                        if (len == -1) {
+                            buf[0] = 0;
+                            len = 1;
+                            eof = true;
+                        }
+                        inf.setInput(buf, 0, len);
                     }
-                    len = this.in.read(buf, 0, buf.length);
-                    if (len == -1) {
-                        buf[0] = 0;
-                        len = 1;
-                        eof = true;
+                    private boolean eof;
+
+                    public int available() throws IOException {
+                        if (isClosed)
+                            return 0;
+                        long avail = zfin.size() - inf.getBytesWritten();
+                        return avail > (long) Integer.MAX_VALUE ?
+                            Integer.MAX_VALUE : (int) avail;
                     }
-                    inf.setInput(buf, 0, len);
-                }
-                private boolean eof;
-
-                public int available() throws IOException {
-                    if (isClosed)
-                        return 0;
-                    long avail = zfin.size() - inf.getBytesWritten();
-                    return avail > (long) Integer.MAX_VALUE ?
-                        Integer.MAX_VALUE : (int) avail;
-                }
-            };
-        default:
-            throw new ZipException("invalid compression method");
+                };
+                streams.add(is);
+                return is;
+            default:
+                throw new ZipException("invalid compression method");
+            }
         }
     }
 
@@ -539,9 +542,9 @@ class ZipFile implements ZipConstants, Closeable {
             closeRequested = true;
 
             if (streams.size() !=0) {
-                Set copy = streams;
-                streams = new HashSet();
-                for (ZipFileInputStream is: copy)
+                Set copy = streams;
+                streams = new HashSet();
+                for (InputStream is: copy)
                     is.close();
             }
 
diff --git a/jdk/src/share/classes/javax/sql/rowset/serial/SerialBlob.java b/jdk/src/share/classes/javax/sql/rowset/serial/SerialBlob.java
index f8614e2478f57eb10525d4e39c3ddf2bad056d92..aed11246dde0b7d5628f8285b5b306ce7a8f3cda 100644
--- a/jdk/src/share/classes/javax/sql/rowset/serial/SerialBlob.java
+++ b/jdk/src/share/classes/javax/sql/rowset/serial/SerialBlob.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, 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
@@ -166,8 +166,9 @@ public class SerialBlob implements Blob, Serializable, Cloneable {
             length = (int)len;
         }
 
-        if (pos < 1 || length - pos < 0 ) {
-            throw new SerialException("Invalid arguments: position cannot be less that 1");
+        if (pos < 1 || len - pos < 0 ) {
+            throw new SerialException("Invalid arguments: position cannot be "
+                    + "less than 1 or greater than the length of the SerialBlob");
         }
 
         pos--; // correct pos to array index
diff --git a/jdk/src/share/classes/javax/swing/JDialog.java b/jdk/src/share/classes/javax/swing/JDialog.java
index 89e764d36578b5f6ebc4bd93520036baf5f5311b..a4e35b66351b38b86343b88da34c44b001aaa9f7 100644
--- a/jdk/src/share/classes/javax/swing/JDialog.java
+++ b/jdk/src/share/classes/javax/swing/JDialog.java
@@ -154,8 +154,8 @@ public class JDialog extends Dialog implements WindowConstants,
     }
 
     /**
-     * Creates a modeless dialog without a title with the
-     * specified {@code Frame} as its owner.  If {@code owner}
+     * Creates a modeless dialog with the specified {@code Frame}
+     * as its owner and an empty title. If {@code owner}
      * is {@code null}, a shared, hidden frame will be set as the
      * owner of the dialog.
      * 
      
@@ -179,8 +179,8 @@ public class JDialog extends Dialog implements WindowConstants,
     }
 
     /**
-     * Creates a dialog with the specified owner {@code Frame}, modality
-     * and an empty title. If {@code owner} is {@code null},
+     * Creates a dialog with an empty title and the specified modality and
+     * {@code Frame} as its owner. If {@code owner} is {@code null},
      * a shared, hidden frame will be set as the owner of the dialog.
      * 
      
      * This constructor sets the component's locale property to the value
@@ -202,7 +202,7 @@ public class JDialog extends Dialog implements WindowConstants,
      * @see JComponent#getDefaultLocale
      */
     public JDialog(Frame owner, boolean modal) {
-        this(owner, null, modal);
+        this(owner, "", modal);
     }
 
     /**
@@ -330,8 +330,8 @@ public class JDialog extends Dialog implements WindowConstants,
     }
 
     /**
-     * Creates a modeless dialog without a title with the
-     * specified {@code Dialog} as its owner.
+     * Creates a modeless dialog with the specified {@code Dialog}
+     * as its owner and an empty title.
      * 
      
      * This constructor sets the component's locale property to the value
      * returned by {@code JComponent.getDefaultLocale}.
@@ -348,7 +348,8 @@ public class JDialog extends Dialog implements WindowConstants,
     }
 
     /**
-     * Creates a dialog with the specified owner {@code Dialog} and modality.
+     * Creates a dialog with an empty title and the specified modality and
+     * {@code Dialog} as its owner.
      * 
      
      * This constructor sets the component's locale property to the value
      * returned by {@code JComponent.getDefaultLocale}.
@@ -369,7 +370,7 @@ public class JDialog extends Dialog implements WindowConstants,
      * @see JComponent#getDefaultLocale
      */
     public JDialog(Dialog owner, boolean modal) {
-        this(owner, null, modal);
+        this(owner, "", modal);
     }
 
     /**
@@ -461,8 +462,8 @@ public class JDialog extends Dialog implements WindowConstants,
     }
 
     /**
-     * Creates a modeless dialog with the specified owner {@code Window} and
-     * an empty title.
+     * Creates a modeless dialog with the specified {@code Window}
+     * as its owner and an empty title.
      * 
      
      * This constructor sets the component's locale property to the value
      * returned by {@code JComponent.getDefaultLocale}.
@@ -488,8 +489,8 @@ public class JDialog extends Dialog implements WindowConstants,
     }
 
     /**
-     * Creates a dialog with the specified owner {@code Window}, modality
-     * and an empty title.
+     * Creates a dialog with an empty title and the specified modality and
+     * {@code Window} as its owner.
      * 
      
      * This constructor sets the component's locale property to the value
      * returned by {@code JComponent.getDefaultLocale}.
@@ -520,7 +521,7 @@ public class JDialog extends Dialog implements WindowConstants,
      * @since 1.6
      */
     public JDialog(Window owner, ModalityType modalityType) {
-        this(owner, null, modalityType);
+        this(owner, "", modalityType);
     }
 
     /**
diff --git a/jdk/src/share/classes/sun/applet/Main.java b/jdk/src/share/classes/sun/applet/Main.java
index 5b08a929a7996bda10e76616ddf0ed03f9270b85..e5ef4fda3c3deed73a8e9f2a88382b55dee44353 100644
--- a/jdk/src/share/classes/sun/applet/Main.java
+++ b/jdk/src/share/classes/sun/applet/Main.java
@@ -339,7 +339,7 @@ public class Main {
         // Standard browser properties
         avProps.put("browser", "sun.applet.AppletViewer");
         avProps.put("browser.version", "1.06");
-        avProps.put("browser.vendor", "Sun Microsystems Inc.");
+        avProps.put("browser.vendor", "Oracle Corporation");
         avProps.put("http.agent", "Java(tm) 2 SDK, Standard Edition v" + theVersion);
 
         // Define which packages can be extended by applets
diff --git a/jdk/src/share/classes/sun/applet/resources/MsgAppletViewer_pt_BR.java b/jdk/src/share/classes/sun/applet/resources/MsgAppletViewer_pt_BR.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa64d71692008bc135f63b3268784c0cd64df667
--- /dev/null
+++ b/jdk/src/share/classes/sun/applet/resources/MsgAppletViewer_pt_BR.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 1996, 2005, 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 sun.applet.resources;
+
+import java.util.ListResourceBundle;
+
+public class MsgAppletViewer_pt_BR extends ListResourceBundle {
+
+    public Object[][] getContents() {
+        return new Object[][] {
+            {"textframe.button.dismiss", "Rejeitar"},
+            {"appletviewer.tool.title", "Visualizador de applet: {0}"},
+            {"appletviewer.menu.applet", "Applet"},
+            {"appletviewer.menuitem.restart", "Reiniciar"},
+            {"appletviewer.menuitem.reload", "Recarregar"},
+            {"appletviewer.menuitem.stop", "Parar"},
+            {"appletviewer.menuitem.save", "Salvar..."},
+            {"appletviewer.menuitem.start", "Iniciar"},
+            {"appletviewer.menuitem.clone", "Clonar..."},
+            {"appletviewer.menuitem.tag", "Marca..."},
+            {"appletviewer.menuitem.info", "Info..."},
+            {"appletviewer.menuitem.edit", "Editar"},
+            {"appletviewer.menuitem.encoding", "Codifica\u00e7\u00e3o de caracteres"},
+            {"appletviewer.menuitem.print", "Imprimir..."},
+            {"appletviewer.menuitem.props", "Propriedades..."},
+            {"appletviewer.menuitem.close", "Fechar"},
+            {"appletviewer.menuitem.quit", "Sair"},
+            {"appletviewer.label.hello", "Ol\u00e1..."},
+            {"appletviewer.status.start", "iniciando applet..."},
+            {"appletviewer.appletsave.filedialogtitle","Serializar applet no arquivo"},
+            {"appletviewer.appletsave.err1", "serializando um {0} para {1}"},
+            {"appletviewer.appletsave.err2", "em appletSave: {0}"},
+            {"appletviewer.applettag", "Marca exibida"},
+            {"appletviewer.applettag.textframe", "Marca HTML do applet"},
+            {"appletviewer.appletinfo.applet", "-- sem informa\u00e7\u00f5es do applet --"},
+            {"appletviewer.appletinfo.param", "-- sem informa\u00e7\u00f5es do par\u00e2metro --"},
+            {"appletviewer.appletinfo.textframe", "Informa\u00e7\u00f5es do applet"},
+            {"appletviewer.appletprint.fail", "Falha na impress\u00e3o."},
+            {"appletviewer.appletprint.finish", "Impress\u00e3o finalizada."},
+            {"appletviewer.appletprint.cancel", "Impress\u00e3o cancelada."},
+            {"appletviewer.appletencoding", "Codifica\u00e7\u00e3o de caracteres: {0}"},
+            {"appletviewer.parse.warning.requiresname", "Aviso: a marca  requer nome do atributo."},
+            {"appletviewer.parse.warning.paramoutside", "Aviso: marca  fora de  ... ."},
+            {"appletviewer.parse.warning.applet.requirescode", "Aviso: marca  requer c\u00f3digo de atributo."},
+            {"appletviewer.parse.warning.applet.requiresheight", "Aviso: marca  requer atributo de altura."},
+            {"appletviewer.parse.warning.applet.requireswidth", "Aviso: marca  requer atributo de largura."},
+            {"appletviewer.parse.warning.object.requirescode", "Aviso: marca  requer c\u00f3digo de atributo."},
+            {"appletviewer.parse.warning.object.requiresheight", "Aviso: marca  requer atributo de altura."},
+            {"appletviewer.parse.warning.object.requireswidth", "Aviso: marca  requer atributo de largura."},
+            {"appletviewer.parse.warning.embed.requirescode", "Aviso: marca  requer c\u00f3digo de atributo."},
+            {"appletviewer.parse.warning.embed.requiresheight", "Aviso: marca  requer atributo de altura."},
+            {"appletviewer.parse.warning.embed.requireswidth", "Aviso: marca  requer atributo de largura."},
+            {"appletviewer.parse.warning.appnotLongersupported", "Aviso: marca  n\u00e3o mais suportada, usar  em seu lugar:"},
+            {"appletviewer.usage", "Uso: url(s) de  do visualizador de applets\n\nem que  inclui:\n  -debug                  inicia o visualizador de applet no depurador Java\n  -encoding     especifica a codifica\u00e7\u00e3o de caracteres usada pelos arquivos HTML\n  -J        passa o argumento para o int\u00e9rprete de java\n\nA op\u00e7\u00e3o -J n\u00e3o \u00e9 padr\u00e3o e est\u00e1 sujeita a altera\u00e7\u00f5es sem aviso."},
+            {"appletviewer.main.err.unsupportedopt", "Op\u00e7\u00e3o n\u00e3o suportada: {0}"},
+            {"appletviewer.main.err.unrecognizedarg", "Argumento n\u00e3o reconhecido: {0}"},
+            {"appletviewer.main.err.dupoption", "Uso duplicado da op\u00e7\u00e3o: {0}"},
+        {"appletviewer.main.err.inputfile", "Nenhum arquivo de entrada especificado."},
+            {"appletviewer.main.err.badurl", "URL incorreto: {0} ( {1} )"},
+            {"appletviewer.main.err.io", "Exce\u00e7\u00e3o de E/S durante a leitura: {0}"},
+            {"appletviewer.main.err.readablefile", "Certifique-se de que {0} seja um arquivo e seja leg\u00edvel."},
+            {"appletviewer.main.err.correcturl", "{0} \u00e9 o URL correto?"},
+            {"appletviewer.main.prop.store", "Propriedades espec\u00edficas do usu\u00e1rio para AppletViewer"},
+        {"appletviewer.main.err.prop.cantread", "N\u00e3o \u00e9 poss\u00edvel ler o arquivo de propriedades do usu\u00e1rio: {0}"},
+            {"appletviewer.main.err.prop.cantsave", "N\u00e3o \u00e9 poss\u00edvel salvar o arquivo de propriedades do usu\u00e1rio: {0}"},
+            {"appletviewer.main.warn.nosecmgr", "Aviso: desabilitando a seguran\u00e7a."},
+        {"appletviewer.main.debug.cantfinddebug", "N\u00e3o \u00e9 poss\u00edvel localizar o depurador!"},
+        {"appletviewer.main.debug.cantfindmain", "N\u00e3o \u00e9 poss\u00edvel localizar o m\u00e9todo principal no depurador!"},
+            {"appletviewer.main.debug.exceptionindebug", "Exce\u00e7\u00e3o no depurador!"},
+        {"appletviewer.main.debug.cantaccess", "N\u00e3o \u00e9 poss\u00edvel acessar o depurador!"},
+            {"appletviewer.main.nosecmgr", "Aviso: SecurityManager n\u00e3o instalado!"},
+            {"appletviewer.main.warning", "Aviso: nenhum applet foi iniciado. Certifique-se de que a entrada contenha uma marca ."},
+            {"appletviewer.main.warn.prop.overwrite", "Aviso: substituindo temporariamente a propriedade do sistema em solicita\u00e7\u00e3o do usu\u00e1rio: chave: {0} valor antigo: {1} valor novo: {2}"},
+            {"appletviewer.main.warn.cantreadprops", "Aviso: n\u00e3o \u00e9 poss\u00edvel ler o arquivo de propriedades do AppletViewer: {0} usando padr\u00f5es."},
+        {"appletioexception.loadclass.throw.interrupted", "carregamento de classe interrompido: {0}"},
+            {"appletioexception.loadclass.throw.notloaded", "classe n\u00e3o carregada: {0}"},
+            {"appletclassloader.loadcode.verbose", "Abrindo fluxo para: {0} para obter {1}"},
+            {"appletclassloader.filenotfound", "Arquivo n\u00e3o encontrado ao procurar por: {0}"},
+            {"appletclassloader.fileformat", "Exce\u00e7\u00e3o de formato de arquivo ao carregar: {0}"},
+            {"appletclassloader.fileioexception", "Exce\u00e7\u00e3o de E/S ao carregar: {0}"},
+            {"appletclassloader.fileexception", "Exce\u00e7\u00e3o {0} ao carregar: {0}"},
+            {"appletclassloader.filedeath", "{0} eliminado ao carregar: {1}"},
+            {"appletclassloader.fileerror", "Erro {0} ao carregar: {1}"},
+            {"appletclassloader.findclass.verbose.findclass", "{0} encontra classe {1}"},
+            {"appletclassloader.findclass.verbose.openstream", "Abrindo fluxo para: {0} para obter {1}"},
+            {"appletclassloader.getresource.verbose.forname", "AppletClassLoader.getResource do nome: {0}"},
+            {"appletclassloader.getresource.verbose.found", "Recurso encontrado: {0} como um recurso do sistema"},
+            {"appletclassloader.getresourceasstream.verbose", "Recurso encontrado: {0} como um recurso do sistema"},
+            {"appletpanel.runloader.err", "Par\u00e2metro de c\u00f3digo ou objeto!"},
+            {"appletpanel.runloader.exception", "exce\u00e7\u00e3o ao desserializar {0}"},
+            {"appletpanel.destroyed", "Applet destru\u00eddo."},
+            {"appletpanel.loaded", "Applet carregado."},
+            {"appletpanel.started", "Applet iniciado."},
+            {"appletpanel.inited", "Applet inicializado."},
+            {"appletpanel.stopped", "Applet interrompido."},
+            {"appletpanel.disposed", "Applet descartado."},
+            {"appletpanel.nocode", "Marca APPLET ausente no par\u00e2metro CODE."},
+            {"appletpanel.notfound", "carregar: classe {0} n\u00e3o encontrada."},
+            {"appletpanel.nocreate", "carregar: {0} n\u00e3o pode ser instanciado."},
+            {"appletpanel.noconstruct", "carregar: {0} n\u00e3o \u00e9 p\u00fablico ou n\u00e3o possui um construtor p\u00fablico."},
+            {"appletpanel.death", "eliminado"},
+            {"appletpanel.exception", "exce\u00e7\u00e3o: {0}."},
+            {"appletpanel.exception2", "exce\u00e7\u00e3o: {0}: {1}."},
+            {"appletpanel.error", "erro: {0}."},
+            {"appletpanel.error2", "erro: {0}: {1}."},
+            {"appletpanel.notloaded", "Inicializar: applet n\u00e3o carregado."},
+            {"appletpanel.notinited", "Iniciar: applet n\u00e3o inicializado."},
+            {"appletpanel.notstarted", "Parar: applet n\u00e3o iniciado."},
+            {"appletpanel.notstopped", "Destruir: applet n\u00e3o interrompido."},
+            {"appletpanel.notdestroyed", "Descartar: applet n\u00e3o destru\u00eddo."},
+            {"appletpanel.notdisposed", "Carregar: applet n\u00e3o descartado."},
+            {"appletpanel.bail", "Interrompido: salvando."},
+            {"appletpanel.filenotfound", "Arquivo n\u00e3o encontrado ao procurar por: {0}"},
+            {"appletpanel.fileformat", "Exce\u00e7\u00e3o de formato de arquivo ao carregar: {0}"},
+            {"appletpanel.fileioexception", "Exce\u00e7\u00e3o de E/S ao carregar: {0}"},
+            {"appletpanel.fileexception", "Exce\u00e7\u00e3o {0} ao carregar: {0}"},
+            {"appletpanel.filedeath", "{0} eliminado ao carregar: {1}"},
+            {"appletpanel.fileerror", "Erro {0} ao carregar: {1}"},
+            {"appletpanel.badattribute.exception", "An\u00e1lise de HTML: valor incorreto do atributo de largura/altura"},
+            {"appletillegalargumentexception.objectinputstream", "AppletObjectInputStream requer carregador n\u00e3o nulo"},
+            {"appletprops.title", "Propriedades do AppletViewer"},
+            {"appletprops.label.http.server", "Servidor proxy de http:"},
+            {"appletprops.label.http.proxy", "Porta do proxy de http:"},
+            {"appletprops.label.network", "Acesso \u00e0 rede:"},
+            {"appletprops.choice.network.item.none", "Nenhum"},
+            {"appletprops.choice.network.item.applethost", "Host do applet"},
+            {"appletprops.choice.network.item.unrestricted", "N\u00e3o registrado"},
+            {"appletprops.label.class", "Acesso \u00e0 classe:"},
+            {"appletprops.choice.class.item.restricted", "Restrito"},
+            {"appletprops.choice.class.item.unrestricted", "N\u00e3o registrado"},
+            {"appletprops.label.unsignedapplet", "Permitir applets n\u00e3o assinados:"},
+            {"appletprops.choice.unsignedapplet.no", "N\u00e3o"},
+            {"appletprops.choice.unsignedapplet.yes", "Sim"},
+            {"appletprops.button.apply", "Aplicar"},
+            {"appletprops.button.cancel", "Cancelar"},
+            {"appletprops.button.reset", "Redefinir"},
+            {"appletprops.apply.exception", "Falha ao salvar propriedades: {0}"},
+            /* 4066432 */
+        {"appletprops.title.invalidproxy", "Entrada inv\u00e1lida"},
+        {"appletprops.label.invalidproxy", "A porta do proxy deve ser um valor inteiro positivo."},
+        {"appletprops.button.ok", "OK"},
+        /* end 4066432 */
+            {"appletprops.prop.store", "Propriedades espec\u00edficas do usu\u00e1rio para AppletViewer"},
+            {"appletsecurityexception.checkcreateclassloader", "Exce\u00e7\u00e3o de seguran\u00e7a: classloader"},
+            {"appletsecurityexception.checkaccess.thread", "Exce\u00e7\u00e3o de seguran\u00e7a: thread"},
+            {"appletsecurityexception.checkaccess.threadgroup", "Exce\u00e7\u00e3o de seguran\u00e7a: threadgroup: {0}"},
+            {"appletsecurityexception.checkexit", "Exce\u00e7\u00e3o de seguran\u00e7a: exit: {0}"},
+            {"appletsecurityexception.checkexec", "Exce\u00e7\u00e3o de seguran\u00e7a: exec: {0}"},
+            {"appletsecurityexception.checklink", "Exce\u00e7\u00e3o de seguran\u00e7a: link: {0}"},
+            {"appletsecurityexception.checkpropsaccess", "Exce\u00e7\u00e3o de seguran\u00e7a: properties"},
+            {"appletsecurityexception.checkpropsaccess.key", "Exce\u00e7\u00e3o de seguran\u00e7a: properties access {0}"},
+            {"appletsecurityexception.checkread.exception1", "Exce\u00e7\u00e3o de seguran\u00e7a: {0}, {1}"},
+            {"appletsecurityexception.checkread.exception2", "Exce\u00e7\u00e3o de seguran\u00e7a: file.read: {0}"},
+            {"appletsecurityexception.checkread", "Exce\u00e7\u00e3o de seguran\u00e7a: file.read: {0} == {1}"},
+            {"appletsecurityexception.checkwrite.exception", "Exce\u00e7\u00e3o de seguran\u00e7a: {0}, {1}"},
+            {"appletsecurityexception.checkwrite", "Exce\u00e7\u00e3o de seguran\u00e7a: file.write: {0} == {1}"},
+            {"appletsecurityexception.checkread.fd", "Exce\u00e7\u00e3o de seguran\u00e7a: fd.read"},
+            {"appletsecurityexception.checkwrite.fd", "Exce\u00e7\u00e3o de seguran\u00e7a: fd.write"},
+            {"appletsecurityexception.checklisten", "Exce\u00e7\u00e3o de seguran\u00e7a: socket.listen: {0}"},
+            {"appletsecurityexception.checkaccept", "Exce\u00e7\u00e3o de seguran\u00e7a: socket.accept: {0} == {1}"},
+            {"appletsecurityexception.checkconnect.networknone", "Exce\u00e7\u00e3o de seguran\u00e7a: socket.connect: {0} == {1}"},
+            {"appletsecurityexception.checkconnect.networkhost1", "Exce\u00e7\u00e3o de seguran\u00e7a: n\u00e3o foi poss\u00edvel conectar a {0} com a origem de {1}."},
+            {"appletsecurityexception.checkconnect.networkhost2", "Exce\u00e7\u00e3o de seguran\u00e7a: n\u00e3o foi poss\u00edvel resolver o IP para o host {0} ou para {1}. "},
+            {"appletsecurityexception.checkconnect.networkhost3", "Exce\u00e7\u00e3o de seguran\u00e7a: n\u00e3o foi poss\u00edvel resolver o IP para o host {0}. Consulte a propriedade trustProxy."},
+            {"appletsecurityexception.checkconnect", "Exce\u00e7\u00e3o de seguran\u00e7a: connect: {0}->{1}"},
+            {"appletsecurityexception.checkpackageaccess", "Exce\u00e7\u00e3o de seguran\u00e7a: n\u00e3o \u00e9 poss\u00edvel acessar o pacote: {0}"},
+            {"appletsecurityexception.checkpackagedefinition", "Exce\u00e7\u00e3o de seguran\u00e7a: n\u00e3o \u00e9 poss\u00edvel definir o pacote: {0}"},
+            {"appletsecurityexception.cannotsetfactory", "Exce\u00e7\u00e3o de seguran\u00e7a: n\u00e3o \u00e9 poss\u00edvel definir a f\u00e1brica"},
+            {"appletsecurityexception.checkmemberaccess", "Exce\u00e7\u00e3o de seguran\u00e7a: verificar acesso de membro"},
+            {"appletsecurityexception.checkgetprintjob", "Exce\u00e7\u00e3o de seguran\u00e7a: getPrintJob"},
+            {"appletsecurityexception.checksystemclipboardaccess", "Exce\u00e7\u00e3o de seguran\u00e7a: getSystemClipboard"},
+            {"appletsecurityexception.checkawteventqueueaccess", "Exce\u00e7\u00e3o de seguran\u00e7a: getEventQueue"},
+            {"appletsecurityexception.checksecurityaccess", "Exce\u00e7\u00e3o de seguran\u00e7a: opera\u00e7\u00e3o de seguran\u00e7a: {0}"},
+            {"appletsecurityexception.getsecuritycontext.unknown", "tipo desconhecido de carregador de classe. n\u00e3o \u00e9 poss\u00edvel verificar para getContext"},
+            {"appletsecurityexception.checkread.unknown", "tipo desconhecido de carregador de classe. n\u00e3o \u00e9 poss\u00edvel verificar para verifica\u00e7\u00e3o de leitura  {0}"},
+            {"appletsecurityexception.checkconnect.unknown", "tipo desconhecido de carregador de classe. n\u00e3o \u00e9 poss\u00edvel verificar para verifica\u00e7\u00e3o de conex\u00e3o"},
+        };
+    }
+}
diff --git a/jdk/src/share/classes/sun/applet/resources/MsgAppletViewer_zh_CN.java b/jdk/src/share/classes/sun/applet/resources/MsgAppletViewer_zh_CN.java
index b13df742da2aae8ef0e680482531b47f32c5d007..7eef93754d9cf141161ccbdb28b4da35e53d2750 100644
--- a/jdk/src/share/classes/sun/applet/resources/MsgAppletViewer_zh_CN.java
+++ b/jdk/src/share/classes/sun/applet/resources/MsgAppletViewer_zh_CN.java
@@ -32,7 +32,7 @@ public class MsgAppletViewer_zh_CN extends ListResourceBundle {
         return new Object[][] {
             {"textframe.button.dismiss", "\u5173\u95ed"},
             {"appletviewer.tool.title", "\u5c0f\u7a0b\u5e8f\u67e5\u770b\u5668\uff1a{0}"},
-            {"appletviewer.menu.applet", "Applet"},
+            {"appletviewer.menu.applet", "\u5c0f\u7a0b\u5e8f"},
             {"appletviewer.menuitem.restart", "\u91cd\u65b0\u542f\u52a8"},
             {"appletviewer.menuitem.reload", "\u91cd\u65b0\u8f7d\u5165"},
             {"appletviewer.menuitem.stop", "\u505c\u6b62"},
diff --git a/jdk/src/share/classes/sun/awt/dnd/SunDropTargetContextPeer.java b/jdk/src/share/classes/sun/awt/dnd/SunDropTargetContextPeer.java
index db92e68ffd9a0b7c64400f8a95c9817851222567..19c2206fe934631b9efe068ab8603074f5676aa8 100644
--- a/jdk/src/share/classes/sun/awt/dnd/SunDropTargetContextPeer.java
+++ b/jdk/src/share/classes/sun/awt/dnd/SunDropTargetContextPeer.java
@@ -94,6 +94,11 @@ public abstract class SunDropTargetContextPeer implements DropTargetContextPeer,
     protected int                     dropStatus   = STATUS_NONE;
     protected boolean                 dropComplete = false;
 
+    // The flag is used to monitor whether the drop action is
+    // handled by a user. That allows to distinct during
+    // which operation getTransferData() method is invoked.
+    boolean                           dropInProcess = false;
+
     /*
      * global lock
      */
@@ -220,7 +225,7 @@ public abstract class SunDropTargetContextPeer implements DropTargetContextPeer,
 
         SecurityManager sm = System.getSecurityManager();
         try {
-            if (!dropComplete && sm != null) {
+            if (!dropInProcess && sm != null) {
                 sm.checkSystemClipboardAccess();
             }
         } catch (Exception e) {
@@ -526,6 +531,8 @@ public abstract class SunDropTargetContextPeer implements DropTargetContextPeer,
                     setCurrentJVMLocalSourceTransferable(null);
             }
 
+            dropInProcess = true;
+
             try {
                 ((DropTargetListener)dt).drop(new DropTargetDropEvent(dtc,
                                                                       hots,
@@ -538,6 +545,7 @@ public abstract class SunDropTargetContextPeer implements DropTargetContextPeer,
                 } else if (dropComplete == false) {
                     dropComplete(false);
                 }
+                dropInProcess = false;
             }
         } else {
             rejectDrop();
diff --git a/jdk/src/share/classes/sun/awt/resources/awt_pt_BR.properties b/jdk/src/share/classes/sun/awt/resources/awt_pt_BR.properties
new file mode 100644
index 0000000000000000000000000000000000000000..f7808b2ed2b76610c62f8eb3d4da3cf4c1066b33
--- /dev/null
+++ b/jdk/src/share/classes/sun/awt/resources/awt_pt_BR.properties
@@ -0,0 +1,191 @@
+#
+# AWT-specific properties
+#
+
+# Modifier names
+AWT.shift=Shift
+AWT.control=Ctrl
+AWT.alt=Alt
+AWT.meta=Meta
+AWT.altGraph=Alt Graph
+
+# Key names
+AWT.enter=Enter
+AWT.backSpace=Backspace
+AWT.tab=Tab
+AWT.cancel=Cancelar
+AWT.clear=Limpar
+AWT.pause=Pausar
+AWT.capsLock=Caps Lock
+AWT.escape=Escape
+AWT.space=Barra de espa\u00e7o
+AWT.pgup=P\u00e1gina acima
+AWT.pgdn=P\u00e1gina abaixo
+AWT.end=Fim
+AWT.home=In\u00edcio
+AWT.left=Esquerda
+AWT.up=Acima
+AWT.right=Direita
+AWT.down=Abaixo
+AWT.begin=Come\u00e7ar
+AWT.comma=V\u00edrgula
+AWT.period=Ponto final
+AWT.slash=Barra
+AWT.semicolon=Ponto-e-v\u00edrgula
+AWT.equals=Igual
+AWT.openBracket=Abrir par\u00eantese
+AWT.backSlash=Barra invertida
+AWT.closeBracket=Fechar par\u00eantese
+AWT.multiply=Teclado num\u00e9rico *
+AWT.add=Teclado num\u00e9rico +
+AWT.separator=Teclado num\u00e9rico ,
+AWT.separater=Teclado num\u00e9rico ,
+AWT.subtract=Teclado num\u00e9rico -
+AWT.decimal=Teclado num\u00e9rico .
+AWT.divide=Teclado num\u00e9rico /
+AWT.delete=Excluir
+AWT.numLock=Num Lock
+AWT.scrollLock=Scroll Lock
+AWT.f1=F1
+AWT.f2=F2
+AWT.f3=F3
+AWT.f4=F4
+AWT.f5=F5
+AWT.f6=F6
+AWT.f7=F7
+AWT.f8=F8
+AWT.f9=F9
+AWT.f10=F10
+AWT.f11=F11
+AWT.f12=F12
+AWT.f13=F13
+AWT.f14=F14
+AWT.f15=F15
+AWT.f16=F16
+AWT.f17=F17
+AWT.f18=F18
+AWT.f19=F19
+AWT.f20=F20
+AWT.f21=F21
+AWT.f22=F22
+AWT.f23=F23
+AWT.f24=F24
+AWT.printScreen=Imprimir tela
+AWT.insert=Inserir
+AWT.help=Ajuda
+AWT.windows=Windows
+AWT.context=Menu de contexto
+AWT.backQuote=Crase
+AWT.quote=Aspas
+AWT.deadGrave=Acento grave
+AWT.deadAcute=Acento agudo
+AWT.deadCircumflex=Acento circunflexo
+AWT.deadTilde=Til
+AWT.deadMacron=M\u00e1cron
+AWT.deadBreve=Braquia
+AWT.deadAboveDot=Ponto em cima
+AWT.deadDiaeresis=Trema
+AWT.deadAboveRing=S\u00edmbolo do grau
+AWT.deadDoubleAcute=Acento agudo duplo
+AWT.deadCaron=Acento circunflexo invertido
+AWT.deadCedilla=Cedilha
+AWT.deadOgonek=Ogonek
+AWT.deadIota=Iota
+AWT.deadVoicedSound=Som sonoro
+AWT.deadSemivoicedSound=Som surdo
+AWT.ampersand=E comercial
+AWT.asterisk=Asterisco
+AWT.quoteDbl=Aspas duplas
+AWT.Less=Menos
+AWT.greater=Maior
+AWT.braceLeft=Chave esquerda
+AWT.braceRight=Chave direta
+AWT.at=Arroba
+AWT.colon=V\u00edrgula
+AWT.circumflex=Circunflexo
+AWT.dollar=D\u00f3lar
+AWT.euro=Euro
+AWT.exclamationMark=Ponto de exclama\u00e7\u00e3o
+AWT.invertedExclamationMark=Ponto de exclama\u00e7\u00e3o invertido
+AWT.leftParenthesis=Par\u00eantese esquerdo
+AWT.numberSign=Sinal num\u00e9rico
+AWT.plus=Mais
+AWT.minus=Menos
+AWT.rightParenthesis=Par\u00eantese direito
+AWT.underscore=Sublinhado
+AWT.final=Final
+AWT.convert=Converter
+AWT.noconvert=N\u00e3o converter
+AWT.accept=Aceitar
+AWT.modechange=Altera\u00e7\u00e3o de modo
+AWT.kana=Kana
+AWT.kanji=Kanji
+AWT.alphanumeric=Alfanum\u00e9rico
+AWT.katakana=Katakana
+AWT.hiragana=Hiragana
+AWT.fullWidth=Largura total
+AWT.halfWidth=Meia largura
+AWT.romanCharacters=Caracteres romanos
+AWT.allCandidates=Todos os candidatos
+AWT.previousCandidate=Candidato anterior
+AWT.codeInput=Entrada de c\u00f3digo
+AWT.japaneseKatakana=Katakana japon\u00eas
+AWT.japaneseHiragana=Hiragana japon\u00eas
+AWT.japaneseRoman=Romano japon\u00eas
+AWT.kanaLock=Kana Lock
+AWT.inputMethodOnOff=M\u00e9todo de entrada ativado/desativado
+AWT.again=Novamente
+AWT.undo=Desfazer
+AWT.copy=Copiar
+AWT.paste=Colar
+AWT.cut=Recortar
+AWT.find=Localizar
+AWT.props=Props
+AWT.stop=Parar
+AWT.compose=Compor
+
+# Numeric Keypad
+AWT.numpad=Teclado num\u00e9rico
+AWT.unknown=Desconhecido
+AWT.undefined=Indefinido
+
+# Predefined cursor names
+AWT.DefaultCursor=Cursor padr\u00e3o
+AWT.CrosshairCursor=Cursor em forma de cruz
+AWT.TextCursor=Cursor de texto
+AWT.WaitCursor=Cursor em forma de ampulheta
+AWT.SWResizeCursor=Cursor de seta que aponta para sudoeste
+AWT.SEResizeCursor=Cursor de seta que aponta para sudeste
+AWT.NWResizeCursor=Cursor de seta que aponta para noroeste
+AWT.NEResizeCursor=Cursor de seta que aponta para nordeste
+AWT.NResizeCursor=Cursor de seta que aponta para cima
+AWT.SResizeCursor=Cursor de seta que aponta para baixo
+AWT.WResizeCursor=Cursor de seta que aponta \u00e0 esquerda
+AWT.EResizeCursor=Cursor de seta que aponta \u00e0 direita
+AWT.HandCursor=Cursor em forma de m\u00e3o
+AWT.MoveCursor=Cursor de movimento
+AWT.DefaultDragCursor=Cursor padr\u00e3o de arrastar
+AWT.DefaultNoDropCursor=Cursor padr\u00e3o sem arrasto
+AWT.DefaultDropCursor=Cursor padr\u00e3o de soltar
+
+# Input method related strings
+AWT.CompositionWindowTitle=Janela de entrada
+AWT.InputMethodSelectionMenu=Selecionar m\u00e9todo de entrada
+AWT.HostInputMethodDisplayName=M\u00e9todos de entrada do sistema
+AWT.InputMethodLanguage.ja=Japon\u00eas
+AWT.InputMethodLanguage.ko=Coreano
+AWT.InputMethodLanguage.zh=Chin\u00eas
+AWT.InputMethodLanguage.zh_CN=Chin\u00eas simplificado
+AWT.InputMethodLanguage.zh_TW=Chin\u00eas tradicional
+AWT.InputMethodCreationFailed=N\u00e3o foi poss\u00edvel criar {0}.  Raz\u00e3o: {1}
+
+# Property to select between on-the-spot and below-the-spot
+# composition with input methods. Valid values:
+# "on-the-spot", "below-the-spot".
+# May be overridden from command line.
+java.awt.im.style=no momento
+java.awt.def.delay=30
+
+# Warnings
+AWT.InconsistentDLLsWarning=As opera\u00e7\u00f5es baseadas em texto podem n\u00e3o funcionar corretamente devido a um conjunto incoerente de bibliotecas de vincula\u00e7\u00e3o din\u00e2mica (DLLs) instalado no seu sistema. Para obter mais informa\u00e7\u00f5es sobre este problema e uma solu\u00e7\u00e3o recomendada, consulte as Notas de vers\u00e3o do Java(TM) 2 SDK, Standard Edition em java.sun.com.
+
diff --git a/jdk/src/share/classes/sun/dyn/AdapterMethodHandle.java b/jdk/src/share/classes/sun/dyn/AdapterMethodHandle.java
index fb9b7fa26c26b3e6a056c24df4b22f58e97b4edb..c23699b948cd2560a7c98029ce89bca63d573026 100644
--- a/jdk/src/share/classes/sun/dyn/AdapterMethodHandle.java
+++ b/jdk/src/share/classes/sun/dyn/AdapterMethodHandle.java
@@ -478,6 +478,39 @@ public class AdapterMethodHandle extends BoundMethodHandle {
         return new AdapterMethodHandle(target, newType, makeConv(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY));
     }
 
+    static MethodHandle makeTypeHandler(Access token,
+                MethodHandle target, MethodHandle typeHandler) {
+        Access.check(token);
+        return new WithTypeHandler(target, typeHandler);
+    }
+
+    static class WithTypeHandler extends AdapterMethodHandle {
+        final MethodHandle target, typeHandler;
+        WithTypeHandler(MethodHandle target, MethodHandle typeHandler) {
+            super(target, target.type(), makeConv(OP_RETYPE_ONLY));
+            this.target = target;
+            this.typeHandler = typeHandler.asType(TYPE_HANDLER_TYPE);
+        }
+
+        public MethodHandle asType(MethodType newType) {
+            if (this.type() == newType)
+                return this;
+            try {
+                MethodHandle retyped = (MethodHandle) typeHandler.invokeExact(target, newType);
+                // Contract:  Must return the desired type, or throw WMT
+                if (retyped.type() != newType)
+                    throw new WrongMethodTypeException(retyped.toString());
+                return retyped;
+            } catch (Throwable ex) {
+                if (ex instanceof Error)  throw (Error)ex;
+                if (ex instanceof RuntimeException)  throw (RuntimeException)ex;
+                throw new RuntimeException(ex);
+            }
+        }
+        private static final MethodType TYPE_HANDLER_TYPE
+            = MethodType.methodType(MethodHandle.class, MethodHandle.class, MethodType.class);
+    }
+
     /** Can a checkcast adapter validly convert the target to newType?
      *  The JVM supports all kind of reference casts, even silly ones.
      */
diff --git a/jdk/src/share/classes/sun/dyn/BoundMethodHandle.java b/jdk/src/share/classes/sun/dyn/BoundMethodHandle.java
index f2ae32efbc95b7f845bb90e2acc55314cf6ff118..cfe19663a276a1a47fcebea29fe027f2c028beff 100644
--- a/jdk/src/share/classes/sun/dyn/BoundMethodHandle.java
+++ b/jdk/src/share/classes/sun/dyn/BoundMethodHandle.java
@@ -103,21 +103,20 @@ public class BoundMethodHandle extends MethodHandle {
         super(Access.TOKEN, type);
         this.argument = argument;
         this.vmargslot = vmargslot;
-        assert(this.getClass() == AdapterMethodHandle.class);
+        assert(this instanceof AdapterMethodHandle);
     }
 
-    /** Initialize the current object as a Java method handle, binding it
+    /** Initialize the current object as a self-bound method handle, binding it
      *  as the first argument of the method handle {@code entryPoint}.
      *  The invocation type of the resulting method handle will be the
      *  same as {@code entryPoint},  except that the first argument
      *  type will be dropped.
      */
-    protected BoundMethodHandle(MethodHandle entryPoint) {
-        super(Access.TOKEN, entryPoint.type().dropParameterTypes(0, 1));
+    protected BoundMethodHandle(Access token, MethodHandle entryPoint) {
+        super(token, entryPoint.type().dropParameterTypes(0, 1));
         this.argument = this; // kludge; get rid of
         this.vmargslot = this.type().parameterSlotDepth(0);
         initTarget(entryPoint, 0);
-        assert(this instanceof JavaMethodHandle);
     }
 
     /** Make sure the given {@code argument} can be used as {@code argnum}-th
@@ -173,6 +172,11 @@ public class BoundMethodHandle extends MethodHandle {
 
     @Override
     public String toString() {
+        return MethodHandleImpl.addTypeString(baseName(), this);
+    }
+
+    /** Component of toString() before the type string. */
+    protected String baseName() {
         MethodHandle mh = this;
         while (mh instanceof BoundMethodHandle) {
             Object info = MethodHandleNatives.getTargetInfo(mh);
@@ -185,12 +189,16 @@ public class BoundMethodHandle extends MethodHandle {
                 if (name != null)
                     return name;
                 else
-                    return super.toString(); // , probably
+                    return noParens(super.toString()); // "invoke", probably
             }
             assert(mh != this);
-            if (mh instanceof JavaMethodHandle)
-                break;  // access JMH.toString(), not BMH.toString()
         }
-        return mh.toString();
+        return noParens(mh.toString());
+    }
+
+    private static String noParens(String str) {
+        int paren = str.indexOf('(');
+        if (paren >= 0) str = str.substring(0, paren);
+        return str;
     }
 }
diff --git a/jdk/src/share/classes/sun/dyn/CallSiteImpl.java b/jdk/src/share/classes/sun/dyn/CallSiteImpl.java
index f7c2d7099a78cd2406b62148e40f8adfef58c33d..eb5abf7488255a6f7fae20456ff885be609e0027 100644
--- a/jdk/src/share/classes/sun/dyn/CallSiteImpl.java
+++ b/jdk/src/share/classes/sun/dyn/CallSiteImpl.java
@@ -41,31 +41,45 @@ public class CallSiteImpl {
                              Object info,
                              // Caller information:
                              MemberName callerMethod, int callerBCI) {
-        Class caller = callerMethod.getDeclaringClass();
+        Class callerClass = callerMethod.getDeclaringClass();
+        Object caller;
+        if (bootstrapMethod.type().parameterType(0) == Class.class)
+            caller = callerClass;  // remove for PFD
+        else
+            caller = MethodHandleImpl.IMPL_LOOKUP.in(callerClass);
         if (bootstrapMethod == null) {
             // If there is no bootstrap method, throw IncompatibleClassChangeError.
             // This is a valid generic error type for resolution (JLS 12.3.3).
             throw new IncompatibleClassChangeError
-                ("Class "+caller.getName()+" has not declared a bootstrap method for invokedynamic");
+                ("Class "+callerClass.getName()+" has not declared a bootstrap method for invokedynamic");
         }
         CallSite site;
         try {
             Object binding;
-            if (false)  // switch when invokeGeneric works
-                binding = bootstrapMethod.invokeGeneric(caller, name, type);
-            else
-                binding = bootstrapMethod.invokeVarargs(new Object[]{ caller, name, type });
+            if (info == null) {
+                if (false)  // switch when invokeGeneric works
+                    binding = bootstrapMethod.invokeGeneric(caller, name, type);
+                else
+                    binding = bootstrapMethod.invokeVarargs(new Object[]{ caller, name, type });
+            } else {
+                info = maybeReBox(info);
+                if (false)  // switch when invokeGeneric works
+                    binding = bootstrapMethod.invokeGeneric(caller, name, type, info);
+                else
+                    binding = bootstrapMethod.invokeVarargs(new Object[]{ caller, name, type, info });
+            }
             //System.out.println("BSM for "+name+type+" => "+binding);
             if (binding instanceof CallSite) {
                 site = (CallSite) binding;
-            } else if (binding instanceof MethodHandleProvider) {
-                MethodHandle target = ((MethodHandleProvider) binding).asMethodHandle();
+            } else if (binding instanceof MethodHandle) {
+                // Transitional!
+                MethodHandle target = (MethodHandle) binding;
                 site = new ConstantCallSite(target);
             } else {
                 throw new ClassCastException("bootstrap method failed to produce a MethodHandle or CallSite");
             }
-            PRIVATE_INITIALIZE_CALL_SITE.invokeExact(site, name, type,
-                                                           callerMethod, callerBCI);
+            PRIVATE_INITIALIZE_CALL_SITE.invokeExact(site, name, type,
+                                                     callerMethod, callerBCI);
             assert(site.getTarget() != null);
             assert(site.getTarget().type().equals(type));
         } catch (Throwable ex) {
@@ -79,6 +93,24 @@ public class CallSiteImpl {
         return site;
     }
 
+    private static Object maybeReBox(Object x) {
+        if (x instanceof Integer) {
+            int xi = (int) x;
+            if (xi == (byte) xi)
+                x = xi;  // must rebox; see JLS 5.1.7
+            return x;
+        } else if (x instanceof Object[]) {
+            Object[] xa = (Object[]) x;
+            for (int i = 0; i < xa.length; i++) {
+                if (xa[i] instanceof Integer)
+                    xa[i] = maybeReBox(xa[i]);
+            }
+            return xa;
+        } else {
+            return x;
+        }
+    }
+
     // This method is private in CallSite because it touches private fields in CallSite.
     // These private fields (vmmethod, vmindex) are specific to the JVM.
     private static final MethodHandle PRIVATE_INITIALIZE_CALL_SITE;
diff --git a/jdk/src/share/classes/sun/dyn/FilterGeneric.java b/jdk/src/share/classes/sun/dyn/FilterGeneric.java
index 1e7b594dd93cb2db0cf2db4a53a2dc3cdf9a51b6..b593588c6e9d471f694fd56992946eeba549e7d2 100644
--- a/jdk/src/share/classes/sun/dyn/FilterGeneric.java
+++ b/jdk/src/share/classes/sun/dyn/FilterGeneric.java
@@ -115,7 +115,7 @@ class FilterGeneric {
 
     static MethodHandle make(Kind kind, int pos, MethodHandle filter, MethodHandle target) {
         FilterGeneric fgen = of(kind, pos, filter.type(), target.type());
-        return fgen.makeInstance(kind, pos, filter, target).asMethodHandle();
+        return fgen.makeInstance(kind, pos, filter, target);
     }
 
     /** Return the adapter information for this target and filter type. */
@@ -225,13 +225,13 @@ class FilterGeneric {
      * The invoker is kept separate from the target because it can be
      * generated once per type erasure family, and reused across adapters.
      */
-    static abstract class Adapter extends JavaMethodHandle {
+    static abstract class Adapter extends BoundMethodHandle {
         protected final MethodHandle filter; // transforms one or more arguments
         protected final MethodHandle target; // ultimate target
 
         @Override
         public String toString() {
-            return target.toString();
+            return MethodHandleImpl.addTypeString(target, this);
         }
 
         protected boolean isPrototype() { return target == null; }
@@ -246,7 +246,7 @@ class FilterGeneric {
 
         protected Adapter(MethodHandle entryPoint,
                           MethodHandle filter, MethodHandle target) {
-            super(entryPoint);
+            super(Access.TOKEN, entryPoint);
             this.filter = filter;
             this.target = target;
         }
@@ -303,7 +303,7 @@ class FilterGeneric {
         protected Object invoke_C0(Object a0) { return target.invokeExact(filter.invokeExact(a0)); }
         protected Object invoke_C1(Object a0) { return target.invokeExact(a0, filter.invokeExact()); }
         protected Object invoke_Y0(Object a0) { Object[] av = { a0 };
-                       filter.invokeExact(av); return target.invokeExact(av[0]); }
+                       filter.invokeExact(av); return target.invokeExact(av[0]); }
     }
     static class F2X extends Adapter {
         protected F2X(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -320,7 +320,7 @@ class FilterGeneric {
         protected Object invoke_C1(Object a0, Object a1) { return target.invokeExact(a0, filter.invokeExact(a1)); }
         protected Object invoke_C2(Object a0, Object a1) { return target.invokeExact(a0, a1, filter.invokeExact()); }
         protected Object invoke_Y0(Object a0, Object a1) { Object[] av = { a0, a1 };
-                       filter.invokeExact(av); return target.invokeExact(av[0], av[1]); }
+                       filter.invokeExact(av); return target.invokeExact(av[0], av[1]); }
     }
     // */
 
@@ -337,7 +337,7 @@ class FilterGeneric {
             return target.invokeExact(filter.invokeExact()); }
         static final Object[] NO_ARGS = { };
         protected Object invoke_Y0() throws Throwable {
-            filter.invokeExact(NO_ARGS); // make the flyby
+            filter.invokeExact(NO_ARGS); // make the flyby
             return target.invokeExact(); }
     }
 
@@ -375,7 +375,7 @@ class genclasses {
         "            return target.invokeExact(@av@, filter.invokeExact()); }",
         "        protected Object invoke_Y0(@Tvav@) throws Throwable {",
         "            Object[] av = { @av@ };",
-        "            filter.invokeExact(av); // make the flyby",
+        "            filter.invokeExact(av); // make the flyby",
         "            return target.invokeExact(@av[i]@); }",
         "    }",
     } };
@@ -518,7 +518,7 @@ class genclasses {
             return target.invokeExact(a0, filter.invokeExact()); }
         protected Object invoke_Y0(Object a0) throws Throwable {
             Object[] av = { a0 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0]); }
     }
     static class F2 extends Adapter {
@@ -548,7 +548,7 @@ class genclasses {
             return target.invokeExact(a0, a1, filter.invokeExact()); }
         protected Object invoke_Y0(Object a0, Object a1) throws Throwable {
             Object[] av = { a0, a1 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1]); }
     }
     static class F3 extends Adapter {
@@ -585,7 +585,7 @@ class genclasses {
             return target.invokeExact(a0, a1, a2, filter.invokeExact()); }
         protected Object invoke_Y0(Object a0, Object a1, Object a2) throws Throwable {
             Object[] av = { a0, a1, a2 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2]); }
     }
     static class F4 extends Adapter {
@@ -629,7 +629,7 @@ class genclasses {
             return target.invokeExact(a0, a1, a2, a3, filter.invokeExact()); }
         protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
             Object[] av = { a0, a1, a2, a3 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3]); }
     }
     static class F5 extends Adapter {
@@ -698,7 +698,7 @@ class genclasses {
         protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
                                    Object a4) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4]); }
     }
     static class F6 extends Adapter {
@@ -777,7 +777,7 @@ class genclasses {
         protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
                                    Object a4, Object a5) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5]); }
     }
     static class F7 extends Adapter {
@@ -866,7 +866,7 @@ class genclasses {
         protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
                                    Object a4, Object a5, Object a6) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6]); }
     }
     static class F8 extends Adapter {
@@ -965,7 +965,7 @@ class genclasses {
         protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
                                    Object a4, Object a5, Object a6, Object a7) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7]); }
     }
     static class F9 extends Adapter {
@@ -1104,7 +1104,7 @@ class genclasses {
                                    Object a4, Object a5, Object a6, Object a7,
                                    Object a8) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8]); }
     }
     static class F10 extends Adapter {
@@ -1256,7 +1256,7 @@ class genclasses {
                                    Object a4, Object a5, Object a6, Object a7,
                                    Object a8, Object a9) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9]); }
     }
     static class F11 extends Adapter {
@@ -1442,7 +1442,7 @@ class genclasses {
                                    Object a4, Object a5, Object a6, Object a7,
                                    Object a8, Object a9, Object a10) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10]); }
     }
     static class F12 extends Adapter {
@@ -1644,7 +1644,7 @@ class genclasses {
                                    Object a4, Object a5, Object a6, Object a7,
                                    Object a8, Object a9, Object a10, Object a11) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11]); }
     }
     static class F13 extends Adapter {
@@ -1904,7 +1904,7 @@ class genclasses {
                                    Object a8, Object a9, Object a10, Object a11,
                                    Object a12) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12]); }
     }
     static class F14 extends Adapter {
@@ -2183,7 +2183,7 @@ class genclasses {
                                    Object a8, Object a9, Object a10, Object a11,
                                    Object a12, Object a13) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13]); }
     }
     static class F15 extends Adapter {
@@ -2481,7 +2481,7 @@ class genclasses {
                                    Object a8, Object a9, Object a10, Object a11,
                                    Object a12, Object a13, Object a14) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14]); }
     }
     static class F16 extends Adapter {
@@ -2798,7 +2798,7 @@ class genclasses {
                                    Object a8, Object a9, Object a10, Object a11,
                                    Object a12, Object a13, Object a14, Object a15) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15]); }
     }
     static class F17 extends Adapter {
@@ -3188,7 +3188,7 @@ class genclasses {
                                    Object a12, Object a13, Object a14, Object a15,
                                    Object a16) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16]); }
     }
     static class F18 extends Adapter {
@@ -3600,7 +3600,7 @@ class genclasses {
                                    Object a12, Object a13, Object a14, Object a15,
                                    Object a16, Object a17) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17]); }
     }
     static class F19 extends Adapter {
@@ -4034,7 +4034,7 @@ class genclasses {
                                    Object a12, Object a13, Object a14, Object a15,
                                    Object a16, Object a17, Object a18) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17], av[18]); }
     }
     static class F20 extends Adapter {
@@ -4490,7 +4490,7 @@ class genclasses {
                                    Object a12, Object a13, Object a14, Object a15,
                                    Object a16, Object a17, Object a18, Object a19) throws Throwable {
             Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19 };
-            filter.invokeExact(av); // make the flyby
+            filter.invokeExact(av); // make the flyby
             return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17], av[18], av[19]); }
     }
 }
diff --git a/jdk/src/share/classes/sun/dyn/FilterOneArgument.java b/jdk/src/share/classes/sun/dyn/FilterOneArgument.java
index cc8ecf66d190ff61c84478812efaacf194b1b593..2712242c289f47063b1a021ce678239d8d123062 100644
--- a/jdk/src/share/classes/sun/dyn/FilterOneArgument.java
+++ b/jdk/src/share/classes/sun/dyn/FilterOneArgument.java
@@ -36,7 +36,7 @@ import static sun.dyn.MemberName.uncaughtException;
  * final method type is the responsibility of a JVM-level adapter.
  * @author jrose
  */
-public class FilterOneArgument extends JavaMethodHandle {
+public class FilterOneArgument extends BoundMethodHandle {
     protected final MethodHandle filter;  // Object -> Object
     protected final MethodHandle target;  // Object -> Object
 
@@ -62,7 +62,7 @@ public class FilterOneArgument extends JavaMethodHandle {
     }
 
     protected FilterOneArgument(MethodHandle filter, MethodHandle target) {
-        super(INVOKE);
+        super(Access.TOKEN, INVOKE);
         this.filter = filter;
         this.target = target;
     }
diff --git a/jdk/src/share/classes/sun/dyn/FromGeneric.java b/jdk/src/share/classes/sun/dyn/FromGeneric.java
index 24f40c0c1acaf27a972ee750b97e5e45c0ffbd88..4651d449faa70e25d53823a4820aa3752e28b340 100644
--- a/jdk/src/share/classes/sun/dyn/FromGeneric.java
+++ b/jdk/src/share/classes/sun/dyn/FromGeneric.java
@@ -241,7 +241,7 @@ class FromGeneric {
      * The invoker is kept separate from the target because it can be
      * generated once per type erasure family, and reused across adapters.
      */
-    static abstract class Adapter extends JavaMethodHandle {
+    static abstract class Adapter extends BoundMethodHandle {
         /*
          * class X<> extends Adapter {
          *   (MH, Object**N)=>raw(R) invoker;
@@ -256,7 +256,7 @@ class FromGeneric {
 
         @Override
         public String toString() {
-            return target.toString();
+            return MethodHandleImpl.addTypeString(target, this);
         }
 
         protected boolean isPrototype() { return target == null; }
@@ -271,7 +271,7 @@ class FromGeneric {
 
         protected Adapter(MethodHandle entryPoint,
                           MethodHandle invoker, MethodHandle convert, MethodHandle target) {
-            super(entryPoint);
+            super(Access.TOKEN, entryPoint);
             this.invoker = invoker;
             this.convert = convert;
             this.target  = target;
@@ -283,11 +283,11 @@ class FromGeneric {
         // { return new ThisType(entryPoint, convert, target); }
 
         /// Conversions on the value returned from the target.
-        protected Object convert_L(Object result) throws Throwable { return convert.invokeExact(result); }
-        protected Object convert_I(int    result) throws Throwable { return convert.invokeExact(result); }
-        protected Object convert_J(long   result) throws Throwable { return convert.invokeExact(result); }
-        protected Object convert_F(float  result) throws Throwable { return convert.invokeExact(result); }
-        protected Object convert_D(double result) throws Throwable { return convert.invokeExact(result); }
+        protected Object convert_L(Object result) throws Throwable { return convert.invokeExact(result); }
+        protected Object convert_I(int    result) throws Throwable { return convert.invokeExact(result); }
+        protected Object convert_J(long   result) throws Throwable { return convert.invokeExact(result); }
+        protected Object convert_F(float  result) throws Throwable { return convert.invokeExact(result); }
+        protected Object convert_D(double result) throws Throwable { return convert.invokeExact(result); }
 
         static private final String CLASS_PREFIX; // "sun.dyn.FromGeneric$"
         static {
@@ -316,11 +316,11 @@ class FromGeneric {
                         { super(e, i, c, t); }
         protected xA2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new xA2(e, i, c, t); }
-        protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1)); }
-        protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1)); }
-        protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1)); }
-        protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1)); }
-        protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1)); }
     }
     // */
 
@@ -329,7 +329,8 @@ class FromGeneric {
 //{{{
 import java.util.*;
 class genclasses {
-    static String[] TYPES = { "Object", "int   ", "long  ", "float ", "double" };
+    static String[] TYPES = { "Object",    "int   ",    "long  ",    "float ",    "double" };
+    static String[] WRAPS = { "         ", "(Integer)", "(Long)   ", "(Float)  ", "(Double) " };
     static String[] TCHARS = { "L",     "I",      "J",      "F",      "D",     "A" };
     static String[][] TEMPLATES = { {
         "@for@ arity=0..10  rcat<=4 nrefs<=99 nints=0   nlongs=0",
@@ -341,13 +342,13 @@ class genclasses {
         "        protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)",
         "                        { return new @cat@(e, i, c, t); }",
         "        //@each-R@",
-        "        protected Object invoke_@catN@(@Tvav@) throws Throwable { return convert_@Rc@(invoker.<@R@>invokeExact(target@av@)); }",
+        "        protected Object invoke_@catN@(@Tvav@) throws Throwable { return convert_@Rc@((@R@)@W@invoker.invokeExact(target@av@)); }",
         "        //@end-R@",
         "    }",
     } };
     static final String NEWLINE_INDENT = "\n                ";
     enum VAR {
-        cat, catN, R, Rc, av, Tvav, Ovav;
+        cat, catN, R, Rc, W, av, Tvav, Ovav;
         public final String pattern = "@"+toString().replace('_','.')+"@";
         public String binding;
         static void makeBindings(boolean topLevel, int rcat, int nrefs, int nints, int nlongs) {
@@ -357,6 +358,7 @@ class genclasses {
             VAR.catN.binding = catstr(rcat, nrefs, nints, nlongs);
             VAR.R.binding = TYPES[rcat];
             VAR.Rc.binding = TCHARS[rcat];
+            VAR.W.binding = WRAPS[rcat];
             String[] Tv = new String[nargs];
             String[] av = new String[nargs];
             String[] Tvav = new String[nargs];
@@ -497,11 +499,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A0(e, i, c, t); }
-        protected Object invoke_L0() throws Throwable { return convert_L(invoker.invokeExact(target)); }
-        protected Object invoke_I0() throws Throwable { return convert_I(invoker.invokeExact(target)); }
-        protected Object invoke_J0() throws Throwable { return convert_J(invoker.invokeExact(target)); }
-        protected Object invoke_F0() throws Throwable { return convert_F(invoker.invokeExact(target)); }
-        protected Object invoke_D0() throws Throwable { return convert_D(invoker.invokeExact(target)); }
+        protected Object invoke_L0() throws Throwable { return convert_L((Object)invoker.invokeExact(target)); }
+        protected Object invoke_I0() throws Throwable { return convert_I((int)   invoker.invokeExact(target)); }
+        protected Object invoke_J0() throws Throwable { return convert_J((long)  invoker.invokeExact(target)); }
+        protected Object invoke_F0() throws Throwable { return convert_F((float) invoker.invokeExact(target)); }
+        protected Object invoke_D0() throws Throwable { return convert_D((double)invoker.invokeExact(target)); }
     }
     static class A1 extends Adapter {
         protected A1(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -509,11 +511,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A1(e, i, c, t); }
-        protected Object invoke_L1(Object a0) throws Throwable { return convert_L(invoker.invokeExact(target, a0)); }
-        protected Object invoke_I1(Object a0) throws Throwable { return convert_I(invoker.invokeExact(target, a0)); }
-        protected Object invoke_J1(Object a0) throws Throwable { return convert_J(invoker.invokeExact(target, a0)); }
-        protected Object invoke_F1(Object a0) throws Throwable { return convert_F(invoker.invokeExact(target, a0)); }
-        protected Object invoke_D1(Object a0) throws Throwable { return convert_D(invoker.invokeExact(target, a0)); }
+        protected Object invoke_L1(Object a0) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0)); }
+        protected Object invoke_I1(Object a0) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0)); }
+        protected Object invoke_J1(Object a0) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0)); }
+        protected Object invoke_F1(Object a0) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0)); }
+        protected Object invoke_D1(Object a0) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0)); }
     }
     static class A2 extends Adapter {
         protected A2(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -521,11 +523,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A2(e, i, c, t); }
-        protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1)); }
-        protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1)); }
-        protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1)); }
-        protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1)); }
-        protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1)); }
+        protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1)); }
     }
     static class A3 extends Adapter {
         protected A3(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -533,11 +535,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A3(e, i, c, t); }
-        protected Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1, a2)); }
-        protected Object invoke_I3(Object a0, Object a1, Object a2) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1, a2)); }
-        protected Object invoke_J3(Object a0, Object a1, Object a2) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1, a2)); }
-        protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1, a2)); }
-        protected Object invoke_D3(Object a0, Object a1, Object a2) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1, a2)); }
+        protected Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2)); }
+        protected Object invoke_I3(Object a0, Object a1, Object a2) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2)); }
+        protected Object invoke_J3(Object a0, Object a1, Object a2) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2)); }
+        protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2)); }
+        protected Object invoke_D3(Object a0, Object a1, Object a2) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2)); }
     }
     static class A4 extends Adapter {
         protected A4(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -545,11 +547,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A4(e, i, c, t); }
-        protected Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1, a2, a3)); }
-        protected Object invoke_I4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1, a2, a3)); }
-        protected Object invoke_J4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1, a2, a3)); }
-        protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1, a2, a3)); }
-        protected Object invoke_D4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1, a2, a3)); }
+        protected Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3)); }
+        protected Object invoke_I4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3)); }
+        protected Object invoke_J4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3)); }
+        protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3)); }
+        protected Object invoke_D4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3)); }
     }
     static class A5 extends Adapter {
         protected A5(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -557,11 +559,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A5(e, i, c, t); }
-        protected Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
-        protected Object invoke_I5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
-        protected Object invoke_J5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
-        protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
-        protected Object invoke_D5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+        protected Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+        protected Object invoke_I5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+        protected Object invoke_J5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+        protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+        protected Object invoke_D5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
     }
     static class A6 extends Adapter {
         protected A6(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -569,11 +571,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A6(e, i, c, t); }
-        protected Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
-        protected Object invoke_I6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
-        protected Object invoke_J6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
-        protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
-        protected Object invoke_D6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+        protected Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+        protected Object invoke_I6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+        protected Object invoke_J6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+        protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+        protected Object invoke_D6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
     }
     static class A7 extends Adapter {
         protected A7(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -581,11 +583,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A7(e, i, c, t); }
-        protected Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
-        protected Object invoke_I7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
-        protected Object invoke_J7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
-        protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
-        protected Object invoke_D7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+        protected Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+        protected Object invoke_I7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+        protected Object invoke_J7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+        protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+        protected Object invoke_D7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
     }
     static class A8 extends Adapter {
         protected A8(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -593,11 +595,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A8(e, i, c, t); }
-        protected Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
-        protected Object invoke_I8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
-        protected Object invoke_J8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
-        protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
-        protected Object invoke_D8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+        protected Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+        protected Object invoke_I8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+        protected Object invoke_J8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+        protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+        protected Object invoke_D8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
     }
     static class A9 extends Adapter {
         protected A9(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -605,11 +607,11 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A9(e, i, c, t); }
-        protected Object invoke_L9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
-        protected Object invoke_I9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
-        protected Object invoke_J9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
-        protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
-        protected Object invoke_D9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+        protected Object invoke_L9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+        protected Object invoke_I9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+        protected Object invoke_J9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+        protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+        protected Object invoke_D9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
     }
     static class A10 extends Adapter {
         protected A10(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
@@ -617,10 +619,10 @@ class genclasses {
                         { super(e, i, c, t); }
         protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
                         { return new A10(e, i, c, t); }
-        protected Object invoke_L10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_L(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
-        protected Object invoke_I10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_I(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
-        protected Object invoke_J10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_J(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
-        protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_F(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
-        protected Object invoke_D10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_D(invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+        protected Object invoke_L10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+        protected Object invoke_I10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+        protected Object invoke_J10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+        protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+        protected Object invoke_D10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
     }
 }
diff --git a/jdk/src/share/classes/sun/dyn/InvokeGeneric.java b/jdk/src/share/classes/sun/dyn/InvokeGeneric.java
new file mode 100644
index 0000000000000000000000000000000000000000..8137bb4a67aa83157903c18d4cc8bb7bd84c3654
--- /dev/null
+++ b/jdk/src/share/classes/sun/dyn/InvokeGeneric.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2009, 2010, 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 sun.dyn;
+
+import java.dyn.*;
+import java.lang.reflect.*;
+import sun.dyn.util.*;
+
+/**
+ * Adapters which manage MethodHanndle.invokeGeneric calls.
+ * The JVM calls one of these when the exact type match fails.
+ * @author jrose
+ */
+class InvokeGeneric {
+    // erased type for the call, which originates from an invokeGeneric site
+    private final MethodType erasedCallerType;
+    // an invoker of type (MT, MH; A...) -> R
+    private final MethodHandle initialInvoker;
+
+    /** Compute and cache information for this adapter, so that it can
+     *  call out to targets of the erasure-family of the given erased type.
+     */
+    private InvokeGeneric(MethodType erasedCallerType) throws NoAccessException {
+        this.erasedCallerType = erasedCallerType;
+        this.initialInvoker = makeInitialInvoker();
+        assert initialInvoker.type().equals(erasedCallerType
+                                            .insertParameterTypes(0, MethodType.class, MethodHandle.class))
+            : initialInvoker.type();
+    }
+
+    private static MethodHandles.Lookup lookup() {
+        return MethodHandleImpl.IMPL_LOOKUP;
+    }
+
+    /** Return the adapter information for this type's erasure. */
+    static MethodHandle genericInvokerOf(MethodType type) {
+        MethodTypeImpl form = MethodTypeImpl.of(type);
+        MethodHandle genericInvoker = form.genericInvoker;
+        if (genericInvoker == null) {
+            try {
+                InvokeGeneric gen = new InvokeGeneric(form.erasedType());
+                form.genericInvoker = genericInvoker = gen.initialInvoker;
+            } catch (NoAccessException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+        return genericInvoker;
+    }
+
+    private MethodHandle makeInitialInvoker() throws NoAccessException {
+        // postDispatch = #(MH'; MT, MH; A...){MH'(MT, MH; A)}
+        MethodHandle postDispatch = makePostDispatchInvoker();
+        MethodHandle invoker;
+        if (returnConversionPossible()) {
+            invoker = MethodHandles.foldArguments(postDispatch,
+                                                  dispatcher("dispatchWithConversion"));
+        } else {
+            invoker = MethodHandles.foldArguments(postDispatch, dispatcher("dispatch"));
+        }
+        return invoker;
+    }
+
+    private static final Class[] EXTRA_ARGS = { MethodType.class, MethodHandle.class };
+    private MethodHandle makePostDispatchInvoker() {
+        // Take (MH'; MT, MH; A...) and run MH'(MT, MH; A...).
+        MethodType invokerType = erasedCallerType.insertParameterTypes(0, EXTRA_ARGS);
+        return MethodHandles.exactInvoker(invokerType);
+    }
+    private MethodHandle dropDispatchArguments(MethodHandle targetInvoker) {
+        assert(targetInvoker.type().parameterType(0) == MethodHandle.class);
+        return MethodHandles.dropArguments(targetInvoker, 1, EXTRA_ARGS);
+    }
+
+    private MethodHandle dispatcher(String dispatchName) throws NoAccessException {
+        return lookup().bind(this, dispatchName,
+                             MethodType.methodType(MethodHandle.class,
+                                                   MethodType.class, MethodHandle.class));
+    }
+
+    static final boolean USE_AS_TYPE_PATH = true;
+
+    /** Return a method handle to invoke on the callerType, target, and remaining arguments.
+     *  The method handle must finish the call.
+     *  This is the first look at the caller type and target.
+     */
+    private MethodHandle dispatch(MethodType callerType, MethodHandle target) {
+        MethodType targetType = target.type();
+        if (USE_AS_TYPE_PATH || target instanceof AdapterMethodHandle.WithTypeHandler) {
+            MethodHandle newTarget = target.asType(callerType);
+            targetType = callerType;
+            Invokers invokers = MethodTypeImpl.invokers(Access.TOKEN, targetType);
+            MethodHandle invoker = invokers.erasedInvokerWithDrops;
+            if (invoker == null) {
+                invokers.erasedInvokerWithDrops = invoker =
+                    dropDispatchArguments(invokers.erasedInvoker());
+            }
+            return invoker.bindTo(newTarget);
+        }
+        throw new RuntimeException("NYI");
+    }
+
+    private MethodHandle dispatchWithConversion(MethodType callerType, MethodHandle target) {
+        MethodHandle finisher = dispatch(callerType, target);
+        if (returnConversionNeeded(callerType, target))
+            finisher = addReturnConversion(finisher, callerType.returnType());  //FIXME: slow
+        return finisher;
+    }
+
+    private boolean returnConversionPossible() {
+        Class needType = erasedCallerType.returnType();
+        return !needType.isPrimitive();
+    }
+    private boolean returnConversionNeeded(MethodType callerType, MethodHandle target) {
+        Class needType = callerType.returnType();
+        if (needType == erasedCallerType.returnType())
+            return false;  // no conversions possible, since must be primitive or Object
+        Class haveType = target.type().returnType();
+        if (VerifyType.isNullConversion(haveType, needType))
+            return false;
+        return true;
+    }
+    private MethodHandle addReturnConversion(MethodHandle target, Class type) {
+        if (true) throw new RuntimeException("NYI");
+        // FIXME: This is slow because it creates a closure node on every call that requires a return cast.
+        MethodType targetType = target.type();
+        MethodHandle caster = ValueConversions.identity(type);
+        caster = caster.asType(MethodType.methodType(type, targetType.returnType()));
+        // Drop irrelevant arguments, because we only care about the return value:
+        caster = MethodHandles.dropArguments(caster, 1, targetType.parameterList());
+        MethodHandle result = MethodHandles.foldArguments(caster, target);
+        return result.asType(target.type());
+    }
+
+    public String toString() {
+        return "InvokeGeneric"+erasedCallerType;
+    }
+}
diff --git a/jdk/src/share/classes/sun/dyn/Invokers.java b/jdk/src/share/classes/sun/dyn/Invokers.java
index b3d2823d02423de7fc9767f62ce41125dc91c165..123dd53fb946aa4da6f8ef73d361fa3be1e342ac 100644
--- a/jdk/src/share/classes/sun/dyn/Invokers.java
+++ b/jdk/src/share/classes/sun/dyn/Invokers.java
@@ -26,6 +26,7 @@
 package sun.dyn;
 
 import java.dyn.*;
+import sun.dyn.empty.Empty;
 
 /**
  * Construction and caching of often-used invokers.
@@ -38,12 +39,19 @@ public class Invokers {
     // exact invoker for the outgoing call
     private /*lazy*/ MethodHandle exactInvoker;
 
+    // erased (partially untyped but with primitives) invoker for the outgoing call
+    private /*lazy*/ MethodHandle erasedInvoker;
+    /*lazy*/ MethodHandle erasedInvokerWithDrops;  // for InvokeGeneric
+
     // generic (untyped) invoker for the outgoing call
     private /*lazy*/ MethodHandle genericInvoker;
 
     // generic (untyped) invoker for the outgoing call; accepts a single Object[]
     private final /*lazy*/ MethodHandle[] varargsInvokers;
 
+    // invoker for an unbound callsite
+    private /*lazy*/ MethodHandle uninitializedCallSite;
+
     /** Compute and cache information common to all collecting adapters
      *  that implement members of the erasure-family of the given erased type.
      */
@@ -80,6 +88,19 @@ public class Invokers {
         return invoker;
     }
 
+    public MethodHandle erasedInvoker() {
+        MethodHandle invoker1 = exactInvoker();
+        MethodHandle invoker = erasedInvoker;
+        if (invoker != null)  return invoker;
+        MethodType erasedType = targetType.erase();
+        if (erasedType == targetType.generic())
+            invoker = genericInvoker();
+        else
+            invoker = MethodHandles.convertArguments(invoker1, invokerType(erasedType));
+        erasedInvoker = invoker;
+        return invoker;
+    }
+
     public MethodHandle varargsInvoker(int objectArgCount) {
         MethodHandle vaInvoker = varargsInvokers[objectArgCount];
         if (vaInvoker != null)  return vaInvoker;
@@ -90,6 +111,35 @@ public class Invokers {
         return vaInvoker;
     }
 
+    private static MethodHandle THROW_UCS = null;
+
+    public MethodHandle uninitializedCallSite() {
+        MethodHandle invoker = uninitializedCallSite;
+        if (invoker != null)  return invoker;
+        if (targetType.parameterCount() > 0) {
+            MethodType type0 = targetType.dropParameterTypes(0, targetType.parameterCount());
+            Invokers invokers0 = MethodTypeImpl.invokers(Access.TOKEN, type0);
+            invoker = MethodHandles.dropArguments(invokers0.uninitializedCallSite(),
+                                                  0, targetType.parameterList());
+            assert(invoker.type().equals(targetType));
+            uninitializedCallSite = invoker;
+            return invoker;
+        }
+        if (THROW_UCS == null) {
+            try {
+                THROW_UCS = MethodHandleImpl.IMPL_LOOKUP
+                    .findStatic(CallSite.class, "uninitializedCallSite",
+                                MethodType.methodType(Empty.class));
+            } catch (NoAccessException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+        invoker = AdapterMethodHandle.makeRetypeRaw(Access.TOKEN, targetType, THROW_UCS);
+        assert(invoker.type().equals(targetType));
+        uninitializedCallSite = invoker;
+        return invoker;
+    }
+
     public String toString() {
         return "Invokers"+targetType;
     }
diff --git a/jdk/src/share/classes/sun/dyn/JavaMethodHandle.java b/jdk/src/share/classes/sun/dyn/JavaMethodHandle.java
deleted file mode 100644
index 2ce44d1d89eb38049b9804c52b64bc52823ed384..0000000000000000000000000000000000000000
--- a/jdk/src/share/classes/sun/dyn/JavaMethodHandle.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * Copyright (c) 2008, 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
- * 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 sun.dyn;
-
-import java.dyn.*;
-import sun.dyn.Access;
-
-/**
- * A Java method handle is a deprecated proposal for extending
- * the basic method handle type with additional
- * programmer defined methods and fields.
- * Its behavior as a method handle is determined at instance creation time,
- * by providing the new instance with an "entry point" method handle
- * to handle calls.  This entry point must accept a leading argument
- * whose type is the Java method handle itself or a supertype, and the
- * entry point is always called with the Java method handle itself as
- * the first argument.  This is similar to ordinary virtual methods, which also
- * accept the receiver object {@code this} as an implicit leading argument.
- * The {@code MethodType} of the Java method handle is the same as that
- * of the entry point method handle, with the leading parameter type
- * omitted.
- * 
      
- * Here is an example of usage, creating a hybrid object/functional datum:
- * 
      - * class Greeter extends JavaMethodHandle {
- *     private String greeting = "hello";
- *     public void setGreeting(String s) { greeting = s; }
- *     public void run() { System.out.println(greeting+", "+greetee); }
- *     private final String greetee;
- *     Greeter(String greetee) {
- *         super(RUN); // alternatively, super("run")
- *         this.greetee = greetee;
- *     }
- *     // the entry point function is computed once:
- *     private static final MethodHandle RUN
- *         = MethodHandles.lookup().findVirtual(Greeter.class, "run",
- *               MethodType.make(void.class));
- * }
- * // class Main { public static void main(String... av) { ...
- * Greeter greeter = new Greeter("world");
- * greeter.run();  // prints "hello, world"
- * // Statically typed method handle invocation (most direct):
- * MethodHandle mh = greeter;
- * mh.<void>invokeExact();  // also prints "hello, world"
- * // Dynamically typed method handle invocation:
- * MethodHandles.invokeExact(greeter);  // also prints "hello, world"
- * greeter.setGreeting("howdy");
- * mh.invokeExact();  // prints "howdy, world" (object-like mutable behavior)
- * 
      
- * 
      
- * In the example of {@code Greeter}, the method {@code run} provides the entry point.
- * The entry point need not be a constant value; it may be independently
- * computed in each call to the constructor.  The entry point does not
- * even need to be a method on the {@code Greeter} class, though
- * that is the typical case.
- * 
      
- * The entry point may also be provided symbolically, in which case the the
- * {@code JavaMethodHandle} constructor performs the lookup of the entry point.
- * This makes it possible to use {@code JavaMethodHandle} to create an anonymous
- * inner class:
- * 
      - * // We can also do this with symbolic names and/or inner classes:
- * MethodHandles.invokeExact(new JavaMethodHandle("yow") {
- *     void yow() { System.out.println("yow, world"); }
- * });
- * 
      
- * 
      
- * Here is similar lower-level code which works in terms of a bound method handle.
- * 
      - *     class Greeter {
- *         public void run() { System.out.println("hello, "+greetee); }
- *         private final String greetee;
- *         Greeter(String greetee) { this.greetee = greetee; }
- *         // the entry point function is computed once:
- *         private static final MethodHandle RUN
- *             = MethodHandles.findVirtual(Greeter.class, "run",
- *                   MethodType.make(void.class));
- *     }
- *     // class Main { public static void main(String... av) { ...
- *     Greeter greeter = new Greeter("world");
- *     greeter.run();  // prints "hello, world"
- *     MethodHandle mh = MethodHanndles.insertArgument(Greeter.RUN, 0, greeter);
- *     mh.invokeExact();  // also prints "hello, world"
- * 
      
- * Note that the method handle must be separately created as a view on the base object.
- * This increases footprint, complexity, and dynamic indirections.
- * 
      
- * Here is a pure functional value expressed most concisely as an anonymous inner class:
- * 
      - *     // class Main { public static void main(String... av) { ...
- *     final String greetee = "world";
- *     MethodHandle greeter = new JavaMethodHandle("run") {
- *         private void run() { System.out.println("hello, "+greetee); }
- *     }
- *     greeter.invokeExact();  // prints "hello, world"
- * 
      
- * 
      
- * Here is an abstract parameterized lvalue, efficiently expressed as a subtype of MethodHandle,
- * and instantiated as an anonymous class.  The data structure is a handle to 1-D array,
- * with a specialized index type (long).  It is created by inner class, and uses
- * signature-polymorphic APIs throughout.
- * 
      - *     abstract class AssignableMethodHandle extends JavaMethodHandle {
- *       private final MethodHandle setter;
- *       public MethodHandle setter() { return setter; }
- *       public AssignableMethodHandle(String get, String set) {
- *         super(get);
- *         MethodType getType = this.type();
- *         MethodType setType = getType.insertParameterType(getType.parameterCount(), getType.returnType()).changeReturnType(void.class);
- *         this.setter = MethodHandles.publicLookup().bind(this, set, setType);
- *       }
- *     }
- *     // class Main { public static void main(String... av) { ...
- *     final Number[] stuff = { 123, 456 };
- *     AssignableMethodHandle stuffPtr = new AssignableMethodHandle("get", "set") {
- *         public Number get(long i)           { return stuff[(int)i]; }
- *         public void   set(long i, Object x) {        stuff[(int)i] = x; }
- *     }
- *     int x = (Integer) stuffPtr.<Number>invokeExact(1L);  // 456
- *     stuffPtr.setter().<void>invokeExact(0L, (Number) 789);  // replaces 123 with 789
- * 
      
- * @see MethodHandle
- * @deprecated The JSR 292 EG intends to replace {@code JavaMethodHandle} with
- * an interface-based API for mixing method handle behavior with other classes.
- * @author John Rose, JSR 292 EG
- */
-public abstract class JavaMethodHandle
-        // Note: This is an implementation inheritance hack, and will be removed
-        // with a JVM change which moves the required hidden behavior onto this class.
-        extends sun.dyn.BoundMethodHandle
-{
-    private static final Access IMPL_TOKEN = Access.getToken();
-
-    /**
-     * When creating a {@code JavaMethodHandle}, the actual method handle
-     * invocation behavior will be delegated to the specified {@code entryPoint}.
-     * This may be any method handle which can take the newly constructed object
-     * as a leading parameter.
-     * 
      
-     * The method handle type of {@code this} (i.e, the fully constructed object)
-     * will be {@code entryPoint}, minus the leading argument.
-     * The leading argument will be bound to {@code this} on every method
-     * handle invocation.
-     * @param entryPoint the method handle to handle calls
-     */
-    protected JavaMethodHandle(MethodHandle entryPoint) {
-        super(entryPoint);
-    }
-}
diff --git a/jdk/src/share/classes/sun/dyn/MethodHandleImpl.java b/jdk/src/share/classes/sun/dyn/MethodHandleImpl.java
index caa96b90d69642fc99cc8561d06c1f876f7c5d3c..24f7aae73a9d2fa68dc33816a16e64b861ba3d01 100644
--- a/jdk/src/share/classes/sun/dyn/MethodHandleImpl.java
+++ b/jdk/src/share/classes/sun/dyn/MethodHandleImpl.java
@@ -199,7 +199,7 @@ public abstract class MethodHandleImpl {
         return allocator;
     }
 
-    static final class AllocateObject extends JavaMethodHandle {
+    static final class AllocateObject extends BoundMethodHandle {
         private static final Unsafe unsafe = Unsafe.getUnsafe();
 
         private final Class allocateClass;
@@ -207,7 +207,7 @@ public abstract class MethodHandleImpl {
 
         private AllocateObject(MethodHandle invoker,
                                Class allocateClass, MethodHandle rawConstructor) {
-            super(invoker);
+            super(Access.TOKEN, invoker);
             this.allocateClass = allocateClass;
             this.rawConstructor = rawConstructor;
         }
@@ -237,7 +237,7 @@ public abstract class MethodHandleImpl {
         }
         @Override
         public String toString() {
-            return allocateClass.getSimpleName();
+            return addTypeString(allocateClass.getSimpleName(), this);
         }
         @SuppressWarnings("unchecked")
         private C allocate() throws InstantiationException {
@@ -245,52 +245,52 @@ public abstract class MethodHandleImpl {
         }
         private C invoke_V(Object... av) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, av);
+            rawConstructor.invokeExact((Object)obj, av);
             return obj;
         }
         private C invoke_L0() throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj);
+            rawConstructor.invokeExact((Object)obj);
             return obj;
         }
         private C invoke_L1(Object a0) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, a0);
+            rawConstructor.invokeExact((Object)obj, a0);
             return obj;
         }
         private C invoke_L2(Object a0, Object a1) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, a0, a1);
+            rawConstructor.invokeExact((Object)obj, a0, a1);
             return obj;
         }
         private C invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, a0, a1, a2);
+            rawConstructor.invokeExact((Object)obj, a0, a1, a2);
             return obj;
         }
         private C invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3);
+            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3);
             return obj;
         }
         private C invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4);
+            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4);
             return obj;
         }
         private C invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5);
+            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5);
             return obj;
         }
         private C invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6);
+            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6);
             return obj;
         }
         private C invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
             C obj = allocate();
-            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6, a7);
+            rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6, a7);
             return obj;
         }
         static MethodHandle[] makeInvokes() {
@@ -369,19 +369,19 @@ public abstract class MethodHandleImpl {
         return mhs[isSetter ? 1 : 0];
     }
 
-    static final class FieldAccessor extends JavaMethodHandle {
+    static final class FieldAccessor extends BoundMethodHandle {
         private static final Unsafe unsafe = Unsafe.getUnsafe();
         final Object base;  // for static refs only
         final long offset;
         final String name;
 
         public FieldAccessor(Access token, MemberName field, boolean isSetter) {
-            super(fhandle(field.getDeclaringClass(), field.getFieldType(), isSetter, field.isStatic()));
+            super(Access.TOKEN, fhandle(field.getDeclaringClass(), field.getFieldType(), isSetter, field.isStatic()));
             this.offset = (long) field.getVMIndex(token);
             this.name = field.getName();
             this.base = staticBase(field);
         }
-        public String toString() { return name; }
+        public String toString() { return addTypeString(name, this); }
 
         int getFieldI(C obj) { return unsafe.getInt(obj, offset); }
         void setFieldI(C obj, int x) { unsafe.putInt(obj, offset, x); }
@@ -560,7 +560,9 @@ public abstract class MethodHandleImpl {
     MethodHandle bindReceiver(Access token,
                               MethodHandle target, Object receiver) {
         Access.check(token);
-        if (target instanceof AdapterMethodHandle) {
+        if (target instanceof AdapterMethodHandle &&
+            ((AdapterMethodHandle)target).conversionOp() == MethodHandleNatives.Constants.OP_RETYPE_ONLY
+            ) {
             Object info = MethodHandleNatives.getTargetInfo(target);
             if (info instanceof DirectMethodHandle) {
                 DirectMethodHandle dmh = (DirectMethodHandle) info;
@@ -908,11 +910,11 @@ public abstract class MethodHandleImpl {
         throw new UnsupportedOperationException("NYI");
     }
 
-    private static class GuardWithTest extends JavaMethodHandle {
+    private static class GuardWithTest extends BoundMethodHandle {
         private final MethodHandle test, target, fallback;
         private GuardWithTest(MethodHandle invoker,
                               MethodHandle test, MethodHandle target, MethodHandle fallback) {
-            super(invoker);
+            super(Access.TOKEN, invoker);
             this.test = test;
             this.target = target;
             this.fallback = fallback;
@@ -946,57 +948,57 @@ public abstract class MethodHandleImpl {
         }
         @Override
         public String toString() {
-            return target.toString();
+            return addTypeString(target, this);
         }
         private Object invoke_V(Object... av) throws Throwable {
-            if (test.invokeExact(av))
-                return target.invokeExact(av);
-            return fallback.invokeExact(av);
+            if ((boolean) test.invokeExact(av))
+                return target.invokeExact(av);
+            return fallback.invokeExact(av);
         }
         private Object invoke_L0() throws Throwable {
-            if (test.invokeExact())
-                return target.invokeExact();
-            return fallback.invokeExact();
+            if ((boolean) test.invokeExact())
+                return target.invokeExact();
+            return fallback.invokeExact();
         }
         private Object invoke_L1(Object a0) throws Throwable {
-            if (test.invokeExact(a0))
-                return target.invokeExact(a0);
-            return fallback.invokeExact(a0);
+            if ((boolean) test.invokeExact(a0))
+                return target.invokeExact(a0);
+            return fallback.invokeExact(a0);
         }
         private Object invoke_L2(Object a0, Object a1) throws Throwable {
-            if (test.invokeExact(a0, a1))
-                return target.invokeExact(a0, a1);
-            return fallback.invokeExact(a0, a1);
+            if ((boolean) test.invokeExact(a0, a1))
+                return target.invokeExact(a0, a1);
+            return fallback.invokeExact(a0, a1);
         }
         private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
-            if (test.invokeExact(a0, a1, a2))
-                return target.invokeExact(a0, a1, a2);
-            return fallback.invokeExact(a0, a1, a2);
+            if ((boolean) test.invokeExact(a0, a1, a2))
+                return target.invokeExact(a0, a1, a2);
+            return fallback.invokeExact(a0, a1, a2);
         }
         private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
-            if (test.invokeExact(a0, a1, a2, a3))
-                return target.invokeExact(a0, a1, a2, a3);
-            return fallback.invokeExact(a0, a1, a2, a3);
+            if ((boolean) test.invokeExact(a0, a1, a2, a3))
+                return target.invokeExact(a0, a1, a2, a3);
+            return fallback.invokeExact(a0, a1, a2, a3);
         }
         private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
-            if (test.invokeExact(a0, a1, a2, a3, a4))
-                return target.invokeExact(a0, a1, a2, a3, a4);
-            return fallback.invokeExact(a0, a1, a2, a3, a4);
+            if ((boolean) test.invokeExact(a0, a1, a2, a3, a4))
+                return target.invokeExact(a0, a1, a2, a3, a4);
+            return fallback.invokeExact(a0, a1, a2, a3, a4);
         }
         private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
-            if (test.invokeExact(a0, a1, a2, a3, a4, a5))
-                return target.invokeExact(a0, a1, a2, a3, a4, a5);
-            return fallback.invokeExact(a0, a1, a2, a3, a4, a5);
+            if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5))
+                return target.invokeExact(a0, a1, a2, a3, a4, a5);
+            return fallback.invokeExact(a0, a1, a2, a3, a4, a5);
         }
         private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
-            if (test.invokeExact(a0, a1, a2, a3, a4, a5, a6))
-                return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
-            return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6);
+            if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5, a6))
+                return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
+            return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6);
         }
         private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
-            if (test.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7))
-                return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
-            return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
+            if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7))
+                return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
+            return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
         }
         static MethodHandle[] makeInvokes() {
             ArrayList invokes = new ArrayList();
@@ -1036,7 +1038,7 @@ public abstract class MethodHandleImpl {
         return GuardWithTest.make(token, test, target, fallback);
     }
 
-    private static class GuardWithCatch extends JavaMethodHandle {
+    private static class GuardWithCatch extends BoundMethodHandle {
         private final MethodHandle target;
         private final Class exType;
         private final MethodHandle catcher;
@@ -1045,93 +1047,93 @@ public abstract class MethodHandleImpl {
         }
         public GuardWithCatch(MethodHandle invoker,
                               MethodHandle target, Class exType, MethodHandle catcher) {
-            super(invoker);
+            super(Access.TOKEN, invoker);
             this.target = target;
             this.exType = exType;
             this.catcher = catcher;
         }
         @Override
         public String toString() {
-            return target.toString();
+            return addTypeString(target, this);
         }
         private Object invoke_V(Object... av) throws Throwable {
             try {
-                return target.invokeExact(av);
+                return target.invokeExact(av);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, av);
+                return catcher.invokeExact(t, av);
             }
         }
         private Object invoke_L0() throws Throwable {
             try {
-                return target.invokeExact();
+                return target.invokeExact();
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t);
+                return catcher.invokeExact(t);
             }
         }
         private Object invoke_L1(Object a0) throws Throwable {
             try {
-                return target.invokeExact(a0);
+                return target.invokeExact(a0);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, a0);
+                return catcher.invokeExact(t, a0);
             }
         }
         private Object invoke_L2(Object a0, Object a1) throws Throwable {
             try {
-                return target.invokeExact(a0, a1);
+                return target.invokeExact(a0, a1);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, a0, a1);
+                return catcher.invokeExact(t, a0, a1);
             }
         }
         private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
             try {
-                return target.invokeExact(a0, a1, a2);
+                return target.invokeExact(a0, a1, a2);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, a0, a1, a2);
+                return catcher.invokeExact(t, a0, a1, a2);
             }
         }
         private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
             try {
-                return target.invokeExact(a0, a1, a2, a3);
+                return target.invokeExact(a0, a1, a2, a3);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, a0, a1, a2, a3);
+                return catcher.invokeExact(t, a0, a1, a2, a3);
             }
         }
         private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
             try {
-                return target.invokeExact(a0, a1, a2, a3, a4);
+                return target.invokeExact(a0, a1, a2, a3, a4);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, a0, a1, a2, a3, a4);
+                return catcher.invokeExact(t, a0, a1, a2, a3, a4);
             }
         }
         private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
             try {
-                return target.invokeExact(a0, a1, a2, a3, a4, a5);
+                return target.invokeExact(a0, a1, a2, a3, a4, a5);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5);
+                return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5);
             }
         }
         private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
             try {
-                return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
+                return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6);
+                return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6);
             }
         }
         private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
             try {
-                return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
+                return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
             } catch (Throwable t) {
                 if (!exType.isInstance(t))  throw t;
-                return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6, a7);
+                return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6, a7);
             }
         }
         static MethodHandle[] makeInvokes() {
@@ -1217,21 +1219,24 @@ public abstract class MethodHandleImpl {
         if (target != null)
             name = MethodHandleNatives.getMethodName(target);
         if (name == null)
-            return "";
-        return name.getName();
+            return "invoke" + target.type();
+        return name.getName() + target.type();
     }
 
-    public static String addTypeString(MethodHandle target) {
-        if (target == null)  return "null";
-        return target.toString() + target.type();
+    static String addTypeString(Object obj, MethodHandle target) {
+        String str = String.valueOf(obj);
+        if (target == null)  return str;
+        int paren = str.indexOf('(');
+        if (paren >= 0) str = str.substring(0, paren);
+        return str + target.type();
     }
 
-    public static void checkSpreadArgument(Object av, int n) {
+    static void checkSpreadArgument(Object av, int n) {
         if (av == null ? n != 0 : ((Object[])av).length != n)
             throw newIllegalArgumentException("Array is not of length "+n);
     }
 
-    public static void raiseException(int code, Object actual, Object required) {
+    static void raiseException(int code, Object actual, Object required) {
         String message;
         // disregard the identity of the actual object, if it is not a class:
         if (!(actual instanceof Class) && !(actual instanceof MethodType))
@@ -1257,4 +1262,9 @@ public abstract class MethodHandleImpl {
         Access.check(token);
         return MethodHandleNatives.getBootstrap(callerClass);
     }
+
+    public static MethodHandle withTypeHandler(Access token, MethodHandle target, MethodHandle typeHandler) {
+        Access.check(token);
+        return AdapterMethodHandle.makeTypeHandler(token, target, typeHandler);
+    }
 }
diff --git a/jdk/src/share/classes/sun/dyn/MethodHandleNatives.java b/jdk/src/share/classes/sun/dyn/MethodHandleNatives.java
index 47a9a2d3de124e4dbd3eeedce90f80f32c850111..3d0629dd034455cfe662dbbcda686fe0903835cb 100644
--- a/jdk/src/share/classes/sun/dyn/MethodHandleNatives.java
+++ b/jdk/src/share/classes/sun/dyn/MethodHandleNatives.java
@@ -316,6 +316,20 @@ class MethodHandleNatives {
         return MethodTypeImpl.makeImpl(Access.TOKEN, rtype, ptypes, true);
     }
 
+    /**
+     * The JVM wants to use a MethodType with invokeGeneric.  Give the runtime fair warning.
+     */
+    static void notifyGenericMethodType(MethodType type) {
+        try {
+            // Trigger adapter creation.
+            InvokeGeneric.genericInvokerOf(type);
+        } catch (Exception ex) {
+            Error err = new InternalError("Exception while resolving invokeGeneric");
+            err.initCause(ex);
+            throw err;
+        }
+    }
+
     /**
      * The JVM is resolving a CONSTANT_MethodHandle CP entry.  And it wants our help.
      * It will make an up-call to this method.  (Do not change the name or signature.)
diff --git a/jdk/src/share/classes/sun/dyn/MethodTypeImpl.java b/jdk/src/share/classes/sun/dyn/MethodTypeImpl.java
index 0a318148a7315835ae18b7ec27a44fc46d4d1768..059f26975426461977f5aab91cbda7d34842c310 100644
--- a/jdk/src/share/classes/sun/dyn/MethodTypeImpl.java
+++ b/jdk/src/share/classes/sun/dyn/MethodTypeImpl.java
@@ -48,6 +48,7 @@ public class MethodTypeImpl {
     final long primCounts;              // packed prim & double counts
     final int vmslots;                  // total number of parameter slots
     final MethodType erasedType;        // the canonical erasure
+
     /*lazy*/ MethodType primsAsBoxes;   // replace prims by wrappers
     /*lazy*/ MethodType primArgsAsBoxes; // wrap args only; make raw return
     /*lazy*/ MethodType primsAsInts;    // replace prims by int/long
@@ -59,6 +60,7 @@ public class MethodTypeImpl {
     /*lazy*/ FromGeneric fromGeneric;   // convert cs. w/o prims to with
     /*lazy*/ SpreadGeneric[] spreadGeneric; // expand one argument to many
     /*lazy*/ FilterGeneric filterGeneric; // convert argument(s) on the fly
+    /*lazy*/ MethodHandle genericInvoker; // hook for invokeGeneric
 
     public MethodType erasedType() {
         return erasedType;
diff --git a/jdk/src/share/classes/sun/dyn/SpreadGeneric.java b/jdk/src/share/classes/sun/dyn/SpreadGeneric.java
index 2b12b067666b1915322aefd4739f92fdd65011ff..d95f3b963d4b8b19b35649cc08dffce1b2aeee5a 100644
--- a/jdk/src/share/classes/sun/dyn/SpreadGeneric.java
+++ b/jdk/src/share/classes/sun/dyn/SpreadGeneric.java
@@ -208,7 +208,7 @@ class SpreadGeneric {
      * The invoker is kept separate from the target because it can be
      * generated once per type erasure family, and reused across adapters.
      */
-    static abstract class Adapter extends JavaMethodHandle {
+    static abstract class Adapter extends BoundMethodHandle {
         /*
          * class X<> extends Adapter {
          *   (Object**N)=>R target;
@@ -221,21 +221,21 @@ class SpreadGeneric {
 
         @Override
         public String toString() {
-            return target.toString();
+            return MethodHandleImpl.addTypeString(target, this);
         }
 
         static final MethodHandle NO_ENTRY = ValueConversions.identity();
 
         protected boolean isPrototype() { return target == null; }
         protected Adapter(SpreadGeneric outer) {
-            super(NO_ENTRY);
+            super(Access.TOKEN, NO_ENTRY);
             this.outer = outer;
             this.target = null;
             assert(isPrototype());
         }
 
         protected Adapter(SpreadGeneric outer, MethodHandle target) {
-            super(outer.entryPoint);
+            super(Access.TOKEN, outer.entryPoint);
             this.outer = outer;
             this.target = target;
         }
@@ -277,12 +277,12 @@ class SpreadGeneric {
         protected xS2(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected xS2 makeInstance(SpreadGeneric outer, MethodHandle t) { return new xS2(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object av) throws Throwable { av = super.check(av,0);
-             return target.invokeExact(a0, a1)); }
+             return target.invokeExact(a0, a1)); }
         protected Object invoke_S1(Object a0, Object av) throws Throwable { av = super.check(av,1);
-             return target.invokeExact(a0,
+             return target.invokeExact(a0,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object av) throws Throwable { av = super.check(av,1);
-             return target.invokeExact(
+             return target.invokeExact(
                 super.select(av,0), super.select(av,1)); }
     }
     // */
@@ -300,10 +300,10 @@ class genclasses {
         "        protected @cat@(SpreadGeneric outer, MethodHandle t) { super(outer, t); }",
         "        protected @cat@ makeInstance(SpreadGeneric outer, MethodHandle t) { return new @cat@(outer, t); }",
         "        protected Object invoke_S0(@Tvav,@Object av) throws Throwable { av = super.check(av, 0);",
-        "            return target.invokeExact(@av@); }",
+        "            return target.invokeExact(@av@); }",
         "        //@each-S@",
         "        protected Object invoke_S@S@(@Tvav,@Object av) throws Throwable { av = super.check(av, @S@);",
-        "            return target.invokeExact(@av,@@sv@); }",
+        "            return target.invokeExact(@av,@@sv@); }",
         "        //@end-S@",
         "    }",
     } };
@@ -414,16 +414,16 @@ class genclasses {
         protected S0(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S0 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S0(outer, t); }
         protected Object invoke_S0(Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(); }
+            return target.invokeExact(); }
     }
     static class S1 extends Adapter {
         protected S1(SpreadGeneric outer) { super(outer); }  // to build prototype
         protected S1(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S1 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S1(outer, t); }
         protected Object invoke_S0(Object a0, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0); }
+            return target.invokeExact(a0); }
         protected Object invoke_S1(Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0)); }
     }
     static class S2 extends Adapter {
@@ -431,12 +431,12 @@ class genclasses {
         protected S2(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S2 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S2(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1); }
+            return target.invokeExact(a0, a1); }
         protected Object invoke_S1(Object a0, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0)); }
         protected Object invoke_S2(Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1)); }
     }
     static class S3 extends Adapter {
@@ -444,15 +444,15 @@ class genclasses {
         protected S3(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S3 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S3(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1, a2); }
+            return target.invokeExact(a0, a1, a2); }
         protected Object invoke_S1(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0, a1,
+            return target.invokeExact(a0, a1,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0), super.select(av,1)); }
         protected Object invoke_S3(Object av) throws Throwable { av = super.check(av, 3);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1), super.select(av,2)); }
     }
     static class S4 extends Adapter {
@@ -460,18 +460,18 @@ class genclasses {
         protected S4(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S4 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S4(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1, a2, a3); }
+            return target.invokeExact(a0, a1, a2, a3); }
         protected Object invoke_S1(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0, a1, a2,
+            return target.invokeExact(a0, a1, a2,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(a0, a1,
+            return target.invokeExact(a0, a1,
                 super.select(av,0), super.select(av,1)); }
         protected Object invoke_S3(Object a0, Object av) throws Throwable { av = super.check(av, 3);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0), super.select(av,1), super.select(av,2)); }
         protected Object invoke_S4(Object av) throws Throwable { av = super.check(av, 4);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
     }
     static class S5 extends Adapter {
@@ -479,21 +479,21 @@ class genclasses {
         protected S5(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S5 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S5(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1, a2, a3, a4); }
+            return target.invokeExact(a0, a1, a2, a3, a4); }
         protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0, a1, a2, a3,
+            return target.invokeExact(a0, a1, a2, a3,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(a0, a1, a2,
+            return target.invokeExact(a0, a1, a2,
                 super.select(av,0), super.select(av,1)); }
         protected Object invoke_S3(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 3);
-            return target.invokeExact(a0, a1,
+            return target.invokeExact(a0, a1,
                 super.select(av,0), super.select(av,1), super.select(av,2)); }
         protected Object invoke_S4(Object a0, Object av) throws Throwable { av = super.check(av, 4);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
         protected Object invoke_S5(Object av) throws Throwable { av = super.check(av, 5);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4)); }
     }
@@ -502,25 +502,25 @@ class genclasses {
         protected S6(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S6 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S6(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5); }
+            return target.invokeExact(a0, a1, a2, a3, a4, a5); }
         protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0, a1, a2, a3, a4,
+            return target.invokeExact(a0, a1, a2, a3, a4,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(a0, a1, a2, a3,
+            return target.invokeExact(a0, a1, a2, a3,
                 super.select(av,0), super.select(av,1)); }
         protected Object invoke_S3(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 3);
-            return target.invokeExact(a0, a1, a2,
+            return target.invokeExact(a0, a1, a2,
                 super.select(av,0), super.select(av,1), super.select(av,2)); }
         protected Object invoke_S4(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 4);
-            return target.invokeExact(a0, a1,
+            return target.invokeExact(a0, a1,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
         protected Object invoke_S5(Object a0, Object av) throws Throwable { av = super.check(av, 5);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4)); }
         protected Object invoke_S6(Object av) throws Throwable { av = super.check(av, 6);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5)); }
     }
@@ -529,29 +529,29 @@ class genclasses {
         protected S7(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S7 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S7(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6); }
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6); }
         protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(a0, a1, a2, a3, a4,
+            return target.invokeExact(a0, a1, a2, a3, a4,
                 super.select(av,0), super.select(av,1)); }
         protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 3);
-            return target.invokeExact(a0, a1, a2, a3,
+            return target.invokeExact(a0, a1, a2, a3,
                 super.select(av,0), super.select(av,1), super.select(av,2)); }
         protected Object invoke_S4(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 4);
-            return target.invokeExact(a0, a1, a2,
+            return target.invokeExact(a0, a1, a2,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
         protected Object invoke_S5(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 5);
-            return target.invokeExact(a0, a1,
+            return target.invokeExact(a0, a1,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4)); }
         protected Object invoke_S6(Object a0, Object av) throws Throwable { av = super.check(av, 6);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5)); }
         protected Object invoke_S7(Object av) throws Throwable { av = super.check(av, 7);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6)); }
     }
@@ -560,33 +560,33 @@ class genclasses {
         protected S8(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S8 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S8(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7); }
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7); }
         protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5,
                 super.select(av,0), super.select(av,1)); }
         protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 3);
-            return target.invokeExact(a0, a1, a2, a3, a4,
+            return target.invokeExact(a0, a1, a2, a3, a4,
                 super.select(av,0), super.select(av,1), super.select(av,2)); }
         protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 4);
-            return target.invokeExact(a0, a1, a2, a3,
+            return target.invokeExact(a0, a1, a2, a3,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
         protected Object invoke_S5(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 5);
-            return target.invokeExact(a0, a1, a2,
+            return target.invokeExact(a0, a1, a2,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4)); }
         protected Object invoke_S6(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 6);
-            return target.invokeExact(a0, a1,
+            return target.invokeExact(a0, a1,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5)); }
         protected Object invoke_S7(Object a0, Object av) throws Throwable { av = super.check(av, 7);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6)); }
         protected Object invoke_S8(Object av) throws Throwable { av = super.check(av, 8);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
     }
@@ -595,37 +595,37 @@ class genclasses {
         protected S9(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S9 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S9(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
         protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
                 super.select(av,0), super.select(av,1)); }
         protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 3);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5,
                 super.select(av,0), super.select(av,1), super.select(av,2)); }
         protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 4);
-            return target.invokeExact(a0, a1, a2, a3, a4,
+            return target.invokeExact(a0, a1, a2, a3, a4,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
         protected Object invoke_S5(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 5);
-            return target.invokeExact(a0, a1, a2, a3,
+            return target.invokeExact(a0, a1, a2, a3,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4)); }
         protected Object invoke_S6(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 6);
-            return target.invokeExact(a0, a1, a2,
+            return target.invokeExact(a0, a1, a2,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5)); }
         protected Object invoke_S7(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 7);
-            return target.invokeExact(a0, a1,
+            return target.invokeExact(a0, a1,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6)); }
         protected Object invoke_S8(Object a0, Object av) throws Throwable { av = super.check(av, 8);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
         protected Object invoke_S9(Object av) throws Throwable { av = super.check(av, 9);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
                 super.select(av,8)); }
@@ -635,42 +635,42 @@ class genclasses {
         protected S10(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
         protected S10 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S10(outer, t); }
         protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9, Object av) throws Throwable { av = super.check(av, 0);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
         protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object av) throws Throwable { av = super.check(av, 1);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8,
                 super.select(av,0)); }
         protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 2);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7,
                 super.select(av,0), super.select(av,1)); }
         protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 3);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
                 super.select(av,0), super.select(av,1), super.select(av,2)); }
         protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 4);
-            return target.invokeExact(a0, a1, a2, a3, a4, a5,
+            return target.invokeExact(a0, a1, a2, a3, a4, a5,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
         protected Object invoke_S5(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 5);
-            return target.invokeExact(a0, a1, a2, a3, a4,
+            return target.invokeExact(a0, a1, a2, a3, a4,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4)); }
         protected Object invoke_S6(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 6);
-            return target.invokeExact(a0, a1, a2, a3,
+            return target.invokeExact(a0, a1, a2, a3,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5)); }
         protected Object invoke_S7(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 7);
-            return target.invokeExact(a0, a1, a2,
+            return target.invokeExact(a0, a1, a2,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6)); }
         protected Object invoke_S8(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 8);
-            return target.invokeExact(a0, a1,
+            return target.invokeExact(a0, a1,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
         protected Object invoke_S9(Object a0, Object av) throws Throwable { av = super.check(av, 9);
-            return target.invokeExact(a0,
+            return target.invokeExact(a0,
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
                 super.select(av,8)); }
         protected Object invoke_S10(Object av) throws Throwable { av = super.check(av, 10);
-            return target.invokeExact(
+            return target.invokeExact(
                 super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
                 super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
                 super.select(av,8), super.select(av,9)); }
diff --git a/jdk/src/share/classes/sun/dyn/ToGeneric.java b/jdk/src/share/classes/sun/dyn/ToGeneric.java
index 65acc6f65b06702bd497d8d95826fb24ac1e119e..c6396454e8786a90b51b2a202c9c1f5e7eb78e23 100644
--- a/jdk/src/share/classes/sun/dyn/ToGeneric.java
+++ b/jdk/src/share/classes/sun/dyn/ToGeneric.java
@@ -323,7 +323,7 @@ class ToGeneric {
      * via another method handle {@code convert}, which is responsible for
      * converting the object result into the raw return value.
      */
-    static abstract class Adapter extends JavaMethodHandle {
+    static abstract class Adapter extends BoundMethodHandle {
         /*
          * class X<> extends Adapter {
          *   Object...=>Object target;
@@ -337,13 +337,13 @@ class ToGeneric {
 
         @Override
         public String toString() {
-            return target == null ? "prototype:"+convert : target.toString();
+            return target == null ? "prototype:"+convert : MethodHandleImpl.addTypeString(target, this);
         }
 
         protected boolean isPrototype() { return target == null; }
         /* Prototype constructor. */
         protected Adapter(MethodHandle entryPoint) {
-            super(entryPoint);
+            super(Access.TOKEN, entryPoint);
             this.invoker = null;
             this.convert = entryPoint;
             this.target = null;
@@ -355,7 +355,7 @@ class ToGeneric {
         }
 
         protected Adapter(MethodHandle entryPoint, MethodHandle invoker, MethodHandle convert, MethodHandle target) {
-            super(entryPoint);
+            super(Access.TOKEN, entryPoint);
             this.invoker = invoker;
             this.convert = convert;
             this.target = target;
@@ -367,33 +367,33 @@ class ToGeneric {
         // { return new ThisType(entryPoint, convert, target); }
 
         // Code to run when the arguments (<= 4) have all been boxed.
-        protected Object target()               throws Throwable { return invoker.invokeExact(target); }
-        protected Object target(Object a0)      throws Throwable { return invoker.invokeExact(target, a0); }
+        protected Object target()               throws Throwable { return invoker.invokeExact(target); }
+        protected Object target(Object a0)      throws Throwable { return invoker.invokeExact(target, a0); }
         protected Object target(Object a0, Object a1)
-                                                throws Throwable { return invoker.invokeExact(target, a0, a1); }
+                                                throws Throwable { return invoker.invokeExact(target, a0, a1); }
         protected Object target(Object a0, Object a1, Object a2)
-                                                throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
+                                                throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
         protected Object target(Object a0, Object a1, Object a2, Object a3)
-                                                throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
+                                                throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
         /*
-        protected Object target_0(Object... av) throws Throwable { return invoker.invokeExact(target, av); }
+        protected Object target_0(Object... av) throws Throwable { return invoker.invokeExact(target, av); }
         protected Object target_1(Object a0, Object... av)
-                                                throws Throwable { return invoker.invokeExact(target, a0, (Object)av); }
+                                                throws Throwable { return invoker.invokeExact(target, a0, (Object)av); }
         protected Object target_2(Object a0, Object a1, Object... av)
-                                                throws Throwable { return invoker.invokeExact(target, a0, a1, (Object)av); }
+                                                throws Throwable { return invoker.invokeExact(target, a0, a1, (Object)av); }
         protected Object target_3(Object a0, Object a1, Object a2, Object... av)
-                                                throws Throwable { return invoker.invokeExact(target, a0, a1, a2, (Object)av); }
+                                                throws Throwable { return invoker.invokeExact(target, a0, a1, a2, (Object)av); }
         protected Object target_4(Object a0, Object a1, Object a2, Object a3, Object... av)
-                                                throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, (Object)av); }
+                                                throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, (Object)av); }
         // */
         // (For more than 4 arguments, generate the code in the adapter itself.)
 
         // Code to run when the generic target has finished and produced a value.
-        protected Object return_L(Object res) throws Throwable { return convert.invokeExact(res); }
-        protected int    return_I(Object res) throws Throwable { return convert.invokeExact(res); }
-        protected long   return_J(Object res) throws Throwable { return convert.invokeExact(res); }
-        protected float  return_F(Object res) throws Throwable { return convert.invokeExact(res); }
-        protected double return_D(Object res) throws Throwable { return convert.invokeExact(res); }
+        protected Object return_L(Object res) throws Throwable { return (Object)convert.invokeExact(res); }
+        protected int    return_I(Object res) throws Throwable { return (int)   convert.invokeExact(res); }
+        protected long   return_J(Object res) throws Throwable { return (long)  convert.invokeExact(res); }
+        protected float  return_F(Object res) throws Throwable { return (float) convert.invokeExact(res); }
+        protected double return_D(Object res) throws Throwable { return (double)convert.invokeExact(res); }
 
         static private final String CLASS_PREFIX; // "sun.dyn.ToGeneric$"
         static {
@@ -420,7 +420,7 @@ class ToGeneric {
         protected A1(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
-        protected Object target(Object a0)   throws Throwable { return invoker.invokeExact(target, a0); }
+        protected Object target(Object a0)   throws Throwable { return invoker.invokeExact(target, a0); }
         protected Object targetA1(Object a0) throws Throwable { return target(a0); }
         protected Object targetA1(int    a0) throws Throwable { return target(a0); }
         protected Object targetA1(long   a0) throws Throwable { return target(a0); }
@@ -458,7 +458,7 @@ class genclasses {
         "        protected @cat@(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype",
         "        protected @cat@(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }",
         "        protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new @cat@(e, i, c, t); }",
-        "        protected Object target(@Ovav@)   throws Throwable { return invoker.invokeExact(target, @av@); }",
+        "        protected Object target(@Ovav@)   throws Throwable { return invoker.invokeExact(target, @av@); }",
         "        //@each-Tv@",
         "        protected Object target@cat@(@Tvav@) throws Throwable { return target(@av@); }",
         "        //@end-Tv@",
@@ -618,7 +618,7 @@ class genclasses {
         protected A0(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A0(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A0(e, i, c, t); }
-        protected Object target()   throws Throwable { return invoker.invokeExact(target); }
+        protected Object target()   throws Throwable { return invoker.invokeExact(target); }
         protected Object targetA0() throws Throwable { return target(); }
         protected Object invoke_L() throws Throwable { return return_L(targetA0()); }
         protected int    invoke_I() throws Throwable { return return_I(targetA0()); }
@@ -630,7 +630,7 @@ class genclasses {
         protected A1(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
-        protected Object target(Object a0)   throws Throwable { return invoker.invokeExact(target, a0); }
+        protected Object target(Object a0)   throws Throwable { return invoker.invokeExact(target, a0); }
         protected Object targetA1(Object a0) throws Throwable { return target(a0); }
         protected Object targetA1(int    a0) throws Throwable { return target(a0); }
         protected Object targetA1(long   a0) throws Throwable { return target(a0); }
@@ -654,7 +654,7 @@ class genclasses {
         protected A2(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A2(e, i, c, t); }
-        protected Object target(Object a0, Object a1)   throws Throwable { return invoker.invokeExact(target, a0, a1); }
+        protected Object target(Object a0, Object a1)   throws Throwable { return invoker.invokeExact(target, a0, a1); }
         protected Object targetA2(Object a0, Object a1) throws Throwable { return target(a0, a1); }
         protected Object targetA2(Object a0, int    a1) throws Throwable { return target(a0, a1); }
         protected Object targetA2(int    a0, int    a1) throws Throwable { return target(a0, a1); }
@@ -690,7 +690,7 @@ class genclasses {
         protected A3(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A3(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A3(e, i, c, t); }
-        protected Object target(Object a0, Object a1, Object a2)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
+        protected Object target(Object a0, Object a1, Object a2)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
         protected Object targetA3(Object a0, Object a1, Object a2) throws Throwable { return target(a0, a1, a2); }
         protected Object targetA3(Object a0, Object a1, int    a2) throws Throwable { return target(a0, a1, a2); }
         protected Object targetA3(Object a0, int    a1, int    a2) throws Throwable { return target(a0, a1, a2); }
@@ -739,7 +739,7 @@ class genclasses {
         protected A4(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A4(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A4(e, i, c, t); }
-        protected Object target(Object a0, Object a1, Object a2, Object a3)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
+        protected Object target(Object a0, Object a1, Object a2, Object a3)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
         protected Object targetA4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return target(a0, a1, a2, a3); }
         protected Object targetA4(Object a0, Object a1, Object a2, int    a3) throws Throwable { return target(a0, a1, a2, a3); }
         protected Object targetA4(Object a0, Object a1, int    a2, int    a3) throws Throwable { return target(a0, a1, a2, a3); }
@@ -781,7 +781,7 @@ class genclasses {
         protected A5(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A5(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A5(e, i, c, t); }
-        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4); }
+        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4); }
         protected Object targetA5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
         protected Object targetA5(Object a0, Object a1, Object a2, Object a3, int    a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
         protected Object targetA5(Object a0, Object a1, Object a2, int    a3, int    a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
@@ -832,7 +832,7 @@ class genclasses {
         protected A6(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A6(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A6(e, i, c, t); }
-        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5); }
+        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5); }
         protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
         protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
         protected Object targetA6(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
@@ -866,7 +866,7 @@ class genclasses {
         protected A7(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A7(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A7(e, i, c, t); }
-        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6); }
+        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6); }
         protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
         protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
         protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
@@ -904,7 +904,7 @@ class genclasses {
         protected A8(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A8(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A8(e, i, c, t); }
-        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7); }
+        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7); }
         protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
         protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
         protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
@@ -946,7 +946,7 @@ class genclasses {
         protected A9(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A9(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A9(e, i, c, t); }
-        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8); }
         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
@@ -992,7 +992,7 @@ class genclasses {
         protected A10(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
         protected A10(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
         protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A10(e, i, c, t); }
-        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+        protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
diff --git a/jdk/src/share/classes/sun/dyn/util/ValueConversions.java b/jdk/src/share/classes/sun/dyn/util/ValueConversions.java
index f5ee5cb81fdd4892bb1bbc3b4f38530c12617f0e..8cb5ece3967823f5703865370d98a75bda2a24e8 100644
--- a/jdk/src/share/classes/sun/dyn/util/ValueConversions.java
+++ b/jdk/src/share/classes/sun/dyn/util/ValueConversions.java
@@ -377,7 +377,7 @@ public class ValueConversions {
             REBOX_CONVERSIONS = newWrapperCaches(2);
 
     /**
-     * Becase we normalize primitive types to reduce the number of signatures,
+     * Because we normalize primitive types to reduce the number of signatures,
      * primitives are sometimes manipulated under an "erased" type,
      * either int (for types other than long/double) or long (for all types).
      * When the erased primitive value is then boxed into an Integer or Long,
@@ -475,10 +475,10 @@ public class ValueConversions {
     }
 
     private static final EnumMap[]
-            ZERO_CONSTANT_FUNCTIONS = newWrapperCaches(1);
+            CONSTANT_FUNCTIONS = newWrapperCaches(2);
 
     public static MethodHandle zeroConstantFunction(Wrapper wrap) {
-        EnumMap cache = ZERO_CONSTANT_FUNCTIONS[0];
+        EnumMap cache = CONSTANT_FUNCTIONS[0];
         MethodHandle mh = cache.get(wrap);
         if (mh != null) {
             return mh;
@@ -543,6 +543,24 @@ public class ValueConversions {
         return x;
     }
 
+    /**
+     * Identity function on ints.
+     * @param x an arbitrary int value
+     * @return the same value x
+     */
+    static int identity(int x) {
+        return x;
+    }
+
+    /**
+     * Identity function on longs.
+     * @param x an arbitrary long value
+     * @return the same value x
+     */
+    static long identity(long x) {
+        return x;
+    }
+
     /**
      * Identity function, with reference cast.
      * @param t an arbitrary reference type
@@ -553,7 +571,7 @@ public class ValueConversions {
         return t.cast(x);
     }
 
-    private static final MethodHandle IDENTITY, CAST_REFERENCE, ALWAYS_NULL, ALWAYS_ZERO, ZERO_OBJECT, IGNORE, EMPTY;
+    private static final MethodHandle IDENTITY, IDENTITY_I, IDENTITY_J, CAST_REFERENCE, ALWAYS_NULL, ALWAYS_ZERO, ZERO_OBJECT, IGNORE, EMPTY;
     static {
         try {
             MethodType idType = MethodType.genericMethodType(1);
@@ -562,6 +580,8 @@ public class ValueConversions {
             MethodType ignoreType = idType.changeReturnType(void.class);
             MethodType zeroObjectType = MethodType.genericMethodType(0);
             IDENTITY = IMPL_LOOKUP.findStatic(ValueConversions.class, "identity", idType);
+            IDENTITY_I = IMPL_LOOKUP.findStatic(ValueConversions.class, "identity", MethodType.methodType(int.class, int.class));
+            IDENTITY_J = IMPL_LOOKUP.findStatic(ValueConversions.class, "identity", MethodType.methodType(long.class, long.class));
             //CAST_REFERENCE = IMPL_LOOKUP.findVirtual(Class.class, "cast", idType);
             CAST_REFERENCE = IMPL_LOOKUP.findStatic(ValueConversions.class, "castReference", castType);
             ALWAYS_NULL = IMPL_LOOKUP.findStatic(ValueConversions.class, "alwaysNull", idType);
@@ -613,8 +633,53 @@ public class ValueConversions {
         return IDENTITY;
     }
 
+    public static MethodHandle identity(Class type) {
+        if (type == Object.class)
+            return IDENTITY;
+        else if (!type.isPrimitive())
+            return retype(MethodType.methodType(type, type), IDENTITY);
+        else
+            return identity(Wrapper.forPrimitiveType(type));
+    }
+
+    static MethodHandle identity(Wrapper wrap) {
+        EnumMap cache = CONSTANT_FUNCTIONS[1];
+        MethodHandle mh = cache.get(wrap);
+        if (mh != null) {
+            return mh;
+        }
+        // slow path
+        MethodType type = MethodType.methodType(wrap.primitiveType());
+        if (wrap != Wrapper.VOID)
+            type = type.appendParameterTypes(wrap.primitiveType());
+        try {
+            mh = IMPL_LOOKUP.findStatic(ValueConversions.class, "identity", type);
+        } catch (NoAccessException ex) {
+            mh = null;
+        }
+        if (mh == null && wrap == Wrapper.VOID) {
+            mh = EMPTY;  // #(){} : #()void
+        }
+        if (mh != null) {
+            cache.put(wrap, mh);
+            return mh;
+        }
+
+        // use a raw conversion
+        if (wrap.isSingleWord() && wrap != Wrapper.INT) {
+            mh = retype(type, identity(Wrapper.INT));
+        } else if (wrap.isDoubleWord() && wrap != Wrapper.LONG) {
+            mh = retype(type, identity(Wrapper.LONG));
+        }
+        if (mh != null) {
+            cache.put(wrap, mh);
+            return mh;
+        }
+        throw new IllegalArgumentException("cannot find identity for " + wrap);
+    }
+
     private static MethodHandle retype(MethodType type, MethodHandle mh) {
-        return AdapterMethodHandle.makeRetypeOnly(IMPL_TOKEN, type, mh);
+        return AdapterMethodHandle.makeRetypeRaw(IMPL_TOKEN, type, mh);
     }
 
     private static final Object[] NO_ARGS_ARRAY = {};
diff --git a/jdk/src/share/classes/sun/dyn/util/VerifyAccess.java b/jdk/src/share/classes/sun/dyn/util/VerifyAccess.java
index 13987dad9a998e62f410adf2230ad2d29e9abda2..0382bea42cd73f360be6ba5ba554b2ec21038d0b 100644
--- a/jdk/src/share/classes/sun/dyn/util/VerifyAccess.java
+++ b/jdk/src/share/classes/sun/dyn/util/VerifyAccess.java
@@ -25,7 +25,6 @@
 
 package sun.dyn.util;
 
-import java.dyn.LinkagePermission;
 import java.dyn.NoAccessException;
 import java.lang.reflect.Modifier;
 import sun.dyn.MemberName;
@@ -43,6 +42,7 @@ public class VerifyAccess {
 
     private static final int PACKAGE_ONLY = 0;
     private static final int ALL_ACCESS_MODES = (PUBLIC|PRIVATE|PROTECTED|PACKAGE_ONLY);
+    private static final boolean ALLOW_NESTMATE_ACCESS = false;
 
     /**
      * Evaluate the JVM linkage rules for access to the given method
@@ -102,6 +102,8 @@ public class VerifyAccess {
                 // a superclass of the lookup class.
             }
         }
+        if (defc == lookupClass)
+            return true;        // easy check; all self-access is OK
         switch (mods & ALL_ACCESS_MODES) {
         case PUBLIC:
             if (refc != defc)  return true;  // already checked above
@@ -112,7 +114,8 @@ public class VerifyAccess {
             return isSamePackage(defc, lookupClass);
         case PRIVATE:
             // Loosened rules for privates follows access rules for inner classes.
-            return isSamePackageMember(defc, lookupClass);
+            return (ALLOW_NESTMATE_ACCESS &&
+                    isSamePackageMember(defc, lookupClass));
         default:
             throw new IllegalArgumentException("bad modifiers: "+Modifier.toString(mods));
         }
@@ -206,24 +209,4 @@ public class VerifyAccess {
         }
         return false;
     }
-
-    /**
-     * Ensure the requesting class have privileges to perform invokedynamic
-     * linkage operations on subjectClass.  True if requestingClass is
-     * Access.class (meaning the request originates from the JVM) or if the
-     * classes are in the same package and have consistent class loaders.
-     * (The subject class loader must be identical with or be a child of
-     * the requesting class loader.)
-     * @param requestingClass
-     * @param subjectClass
-     */
-    public static void checkBootstrapPrivilege(Class requestingClass, Class subjectClass,
-                                               String permissionName) {
-        if (requestingClass == null)          return;
-        if (requestingClass == subjectClass)  return;
-        SecurityManager security = System.getSecurityManager();
-        if (security == null)  return;  // open season
-        if (isSamePackage(requestingClass, subjectClass))  return;
-        security.checkPermission(new LinkagePermission(permissionName, requestingClass));
-    }
 }
diff --git a/jdk/src/share/classes/sun/dyn/util/Wrapper.java b/jdk/src/share/classes/sun/dyn/util/Wrapper.java
index 5229c807310d40e116606235605eb56e1559449f..a3e34dd8147728b0927fa276c5fd74d04319dec2 100644
--- a/jdk/src/share/classes/sun/dyn/util/Wrapper.java
+++ b/jdk/src/share/classes/sun/dyn/util/Wrapper.java
@@ -26,17 +26,19 @@
 package sun.dyn.util;
 
 public enum Wrapper {
-    INT(Integer.class, int.class, 'I', (Integer)(int)0, Format.signed(32)),
-    LONG(Long.class, long.class, 'J', (Long)(long)0, Format.signed(64)),
+    BOOLEAN(Boolean.class, boolean.class, 'Z', (Boolean)false, Format.unsigned(1)),
+    // These must be in the order defined for widening primitive conversions in JLS 5.1.2
     BYTE(Byte.class, byte.class, 'B', (Byte)(byte)0, Format.signed(8)),
     SHORT(Short.class, short.class, 'S', (Short)(short)0, Format.signed(16)),
     CHAR(Character.class, char.class, 'C', (Character)(char)0, Format.unsigned(16)),
-    BOOLEAN(Boolean.class, boolean.class, 'Z', (Boolean)false, Format.unsigned(1)),
+    INT(Integer.class, int.class, 'I', (Integer)(int)0, Format.signed(32)),
+    LONG(Long.class, long.class, 'J', (Long)(long)0, Format.signed(64)),
     FLOAT(Float.class, float.class, 'F', (Float)(float)0, Format.floating(32)),
     DOUBLE(Double.class, double.class, 'D', (Double)(double)0, Format.floating(64)),
-    VOID(Void.class, void.class, 'V', null, Format.other(0)),
     //NULL(Null.class, null.class, 'N', null, Format.other(1)),
     OBJECT(Object.class, Object.class, 'L', null, Format.other(1)),
+    // VOID must be the last type, since it is "assignable" from any other type:
+    VOID(Void.class, void.class, 'V', null, Format.other(0)),
     ;
 
     private final Class wrapperType;
@@ -76,9 +78,11 @@ public enum Wrapper {
                    false);
             return kind | (size << SIZE_SHIFT) | (slots << SLOT_SHIFT);
         }
-        static int
+        static final int
                 INT      = SIGNED   | (32 << SIZE_SHIFT) | (1 << SLOT_SHIFT),
+                SHORT    = SIGNED   | (16 << SIZE_SHIFT) | (1 << SLOT_SHIFT),
                 BOOLEAN  = UNSIGNED | (1  << SIZE_SHIFT) | (1 << SLOT_SHIFT),
+                CHAR     = UNSIGNED | (16 << SIZE_SHIFT) | (1 << SLOT_SHIFT),
                 FLOAT    = FLOATING | (32 << SIZE_SHIFT) | (1 << SLOT_SHIFT),
                 VOID     = UNSIGNED | (0  << SIZE_SHIFT) | (0 << SLOT_SHIFT),
                 NUM_MASK = (-1) << SIZE_SHIFT;
@@ -111,6 +115,29 @@ public enum Wrapper {
     /** Is the wrapped type either float or double? */
     public boolean isFloating()    { return format >= Format.FLOAT; }
 
+    /** Does the JVM verifier allow a variable of this wrapper's
+     *  primitive type to be assigned from a value of the given wrapper's primitive type?
+     *  Cases:
+     *  
        
+     *  
      • unboxing followed by widening primitive conversion
+     *  
      • any type converted to {@code void}
+     *  
      • boxing conversion followed by widening reference conversion to {@code Object}
+     *  
      • conversion of {@code boolean} to any type
+     *  
      
+     */
+    public boolean isConvertibleFrom(Wrapper source) {
+        if (this == source)  return true;
+        if (this.compareTo(source) < 0) {
+            // At best, this is a narrowing conversion.
+            return false;
+        }
+        if ((this.format ^ source.format) == (Format.SHORT ^ Format.CHAR)) {
+            assert (this == SHORT && source == CHAR) || (this == CHAR && source == SHORT);
+            return false;
+        }
+        return true;
+    }
+
     /** Produce a zero value for the given wrapper type.
      *  This will be a numeric zero for a number or character,
      *  false for a boolean, and null for a reference or void.
@@ -122,10 +149,10 @@ public enum Wrapper {
     public Object zero() { return zero; }
 
     /** Produce a zero value for the given wrapper type T.
-     *  The optinoal argument must a type compatible with this wrapper.
+     *  The optional argument must a type compatible with this wrapper.
      *  Equivalent to {@code this.cast(this.zero(), type)}.
      */
-    public  T zero(Class type) { return cast(zero, type); }
+    public  T zero(Class type) { return convert(zero, type); }
 
 //    /** Produce a wrapper for the given wrapper or primitive type. */
 //    public static Wrapper valueOf(Class type) {
@@ -264,7 +291,11 @@ public enum Wrapper {
                    exampleType.isInterface()) {
             return forceType(wrapperType, exampleType);
         }
-        throw new ClassCastException(exampleType + " not <:" + wrapperType);
+        throw newClassCastException(exampleType, primitiveType);
+    }
+
+    private static ClassCastException newClassCastException(Class actual, Class expected) {
+        return new ClassCastException(actual + " is not compatible with " + expected);
     }
 
     /** If {@code type} is a primitive type, return the corresponding
@@ -325,17 +356,55 @@ public enum Wrapper {
 //    }
 
     /** Cast a wrapped value to the given type, which may be either a primitive or wrapper type.
+     *  The given target type must be this wrapper's primitive or wrapper type.
+     *  If this wrapper is OBJECT, the target type may also be an interface, perform no runtime check.
      *  Performs standard primitive conversions, including truncation and float conversions.
      *  The given type must be compatible with this wrapper.  That is, it must either
      *  be the wrapper type (or a subtype, in the case of {@code OBJECT}) or else
      *  it must be the wrapper's primitive type.
+     *  Primitive conversions are only performed if the given type is itself a primitive.
      *  @throws ClassCastException if the given type is not compatible with this wrapper
      */
     public  T cast(Object x, Class type) {
+        return convert(x, type, true);
+    }
+
+    /** Convert a wrapped value to the given type.
+     *  The given target type must be this wrapper's primitive or wrapper type.
+     *  This is equivalent to {@link #cast}, except that it refuses to perform
+     *  narrowing primitive conversions.
+     */
+    public  T convert(Object x, Class type) {
+        return convert(x, type, false);
+    }
+
+    private  T convert(Object x, Class type, boolean isCast) {
+        if (this == OBJECT) {
+            // If the target wrapper is OBJECT, just do a reference cast.
+            // If the target type is an interface, perform no runtime check.
+            // (This loophole is safe, and is allowed by the JVM verifier.)
+            // If the target type is a primitive, change it to a wrapper.
+            @SuppressWarnings("unchecked")
+            T result = (T) x;  // unchecked warning is expected here
+            return result;
+        }
         Class wtype = wrapperType(type);
-        if (wtype.isInstance(x))
-            return wtype.cast(x);
-        return wtype.cast(wrap(x));
+        if (wtype.isInstance(x)) {
+            @SuppressWarnings("unchecked")
+            T result = (T) x;  // unchecked warning is expected here
+            return result;
+        }
+        Class sourceType = x.getClass();  // throw NPE if x is null
+        if (!isCast) {
+            Wrapper source = findWrapperType(sourceType);
+            if (source == null || !this.isConvertibleFrom(source)) {
+                throw newClassCastException(wtype, sourceType);
+            }
+        }
+        @SuppressWarnings("unchecked")
+        T result = (T) wrap(x);  // unchecked warning is expected here
+        assert result.getClass() == wtype;
+        return result;
     }
 
     /** Cast a reference type to another reference type.
diff --git a/jdk/src/share/classes/sun/font/FontUtilities.java b/jdk/src/share/classes/sun/font/FontUtilities.java
index 4438cc6aeeea8a9e0862915ad362ebe1ec8ec6b5..e63baac1641020fc531495277c209621c92d6cf1 100644
--- a/jdk/src/share/classes/sun/font/FontUtilities.java
+++ b/jdk/src/share/classes/sun/font/FontUtilities.java
@@ -276,6 +276,18 @@ public final class FontUtilities {
             // 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/jdk/src/share/classes/sun/java2d/SurfaceData.java b/jdk/src/share/classes/sun/java2d/SurfaceData.java
index 5a5a32b1563e58037103f0559f0191cc46e491c9..08b3fcc914aad69dbeabb2a6df401f2a2f687041 100644
--- a/jdk/src/share/classes/sun/java2d/SurfaceData.java
+++ b/jdk/src/share/classes/sun/java2d/SurfaceData.java
@@ -46,11 +46,15 @@ import sun.java2d.loops.DrawPolygons;
 import sun.java2d.loops.DrawPath;
 import sun.java2d.loops.FillPath;
 import sun.java2d.loops.FillSpans;
+import sun.java2d.loops.FillParallelogram;
+import sun.java2d.loops.DrawParallelogram;
 import sun.java2d.loops.FontInfo;
 import sun.java2d.loops.DrawGlyphList;
 import sun.java2d.loops.DrawGlyphListAA;
 import sun.java2d.loops.DrawGlyphListLCD;
 import sun.java2d.pipe.LoopPipe;
+import sun.java2d.pipe.ShapeDrawPipe;
+import sun.java2d.pipe.ParallelogramPipe;
 import sun.java2d.pipe.CompositePipe;
 import sun.java2d.pipe.GeneralCompositePipe;
 import sun.java2d.pipe.SpanClipRenderer;
@@ -59,6 +63,7 @@ import sun.java2d.pipe.AAShapePipe;
 import sun.java2d.pipe.AlphaPaintPipe;
 import sun.java2d.pipe.AlphaColorPipe;
 import sun.java2d.pipe.PixelToShapeConverter;
+import sun.java2d.pipe.PixelToParallelogramConverter;
 import sun.java2d.pipe.TextPipe;
 import sun.java2d.pipe.TextRenderer;
 import sun.java2d.pipe.AATextRenderer;
@@ -364,6 +369,7 @@ public abstract class SurfaceData
 
     protected static final CompositePipe colorPipe;
     protected static final PixelToShapeConverter colorViaShape;
+    protected static final PixelToParallelogramConverter colorViaPgram;
     protected static final TextPipe colorText;
     protected static final CompositePipe clipColorPipe;
     protected static final TextPipe clipColorText;
@@ -396,6 +402,31 @@ public abstract class SurfaceData
 
     protected static final DrawImagePipe imagepipe;
 
+    // Utility subclass to add the LoopBasedPipe tagging interface
+    static class PixelToShapeLoopConverter
+        extends PixelToShapeConverter
+        implements LoopBasedPipe
+    {
+        public PixelToShapeLoopConverter(ShapeDrawPipe pipe) {
+            super(pipe);
+        }
+    }
+
+    // Utility subclass to add the LoopBasedPipe tagging interface
+    static class PixelToPgramLoopConverter
+        extends PixelToParallelogramConverter
+        implements LoopBasedPipe
+    {
+        public PixelToPgramLoopConverter(ShapeDrawPipe shapepipe,
+                                         ParallelogramPipe pgrampipe,
+                                         double minPenSize,
+                                         double normPosition,
+                                         boolean adjustfill)
+        {
+            super(shapepipe, pgrampipe, minPenSize, normPosition, adjustfill);
+        }
+    }
+
     static {
         colorPrimitives = new LoopPipe();
 
@@ -406,7 +437,10 @@ public abstract class SurfaceData
 
         colorPipe = new AlphaColorPipe();
         // colorShape = colorPrimitives;
-        colorViaShape = new PixelToShapeConverter(colorPrimitives);
+        colorViaShape = new PixelToShapeLoopConverter(colorPrimitives);
+        colorViaPgram = new PixelToPgramLoopConverter(colorPrimitives,
+                                                      colorPrimitives,
+                                                      1.0, 0.25, true);
         colorText = new TextRenderer(colorPipe);
         clipColorPipe = new SpanClipRenderer(colorPipe);
         clipColorText = new TextRenderer(clipColorPipe);
@@ -441,10 +475,12 @@ public abstract class SurfaceData
     }
 
     /* Not all surfaces and rendering mode combinations support LCD text. */
-    static final int LCDLOOP_UNKNOWN = 0;
-    static final int LCDLOOP_FOUND = 1;
-    static final int LCDLOOP_NOTFOUND = 2;
+    static final int LOOP_UNKNOWN = 0;
+    static final int LOOP_FOUND = 1;
+    static final int LOOP_NOTFOUND = 2;
     int haveLCDLoop;
+    int havePgramXORLoop;
+    int havePgramSolidLoop;
 
     public boolean canRenderLCDText(SunGraphics2D sg2d) {
         // For now the answer can only be true in the following cases:
@@ -453,18 +489,48 @@ public abstract class SurfaceData
             sg2d.clipState <= SunGraphics2D.CLIP_RECTANGULAR &&
             sg2d.surfaceData.getTransparency() == Transparency.OPAQUE)
         {
-            if (haveLCDLoop == LCDLOOP_UNKNOWN) {
+            if (haveLCDLoop == LOOP_UNKNOWN) {
                 DrawGlyphListLCD loop =
                     DrawGlyphListLCD.locate(SurfaceType.AnyColor,
                                             CompositeType.SrcNoEa,
                                             getSurfaceType());
-                haveLCDLoop = (loop!= null) ? LCDLOOP_FOUND : LCDLOOP_NOTFOUND;
+                haveLCDLoop = (loop != null) ? LOOP_FOUND : LOOP_NOTFOUND;
             }
-            return haveLCDLoop == LCDLOOP_FOUND;
+            return haveLCDLoop == LOOP_FOUND;
         }
         return false; /* for now - in the future we may want to search */
     }
 
+    public boolean canRenderParallelograms(SunGraphics2D sg2d) {
+        if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) {
+            if (sg2d.compositeState == sg2d.COMP_XOR) {
+                if (havePgramXORLoop == LOOP_UNKNOWN) {
+                    FillParallelogram loop =
+                        FillParallelogram.locate(SurfaceType.AnyColor,
+                                                 CompositeType.Xor,
+                                                 getSurfaceType());
+                    havePgramXORLoop =
+                        (loop != null) ? LOOP_FOUND : LOOP_NOTFOUND;
+                }
+                return havePgramXORLoop == LOOP_FOUND;
+            } else if (sg2d.compositeState <= sg2d.COMP_ISCOPY &&
+                       sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&
+                       sg2d.clipState != sg2d.CLIP_SHAPE)
+            {
+                if (havePgramSolidLoop == LOOP_UNKNOWN) {
+                    FillParallelogram loop =
+                        FillParallelogram.locate(SurfaceType.AnyColor,
+                                                 CompositeType.SrcNoEa,
+                                                 getSurfaceType());
+                    havePgramSolidLoop =
+                        (loop != null) ? LOOP_FOUND : LOOP_NOTFOUND;
+                }
+                return havePgramSolidLoop == LOOP_FOUND;
+            }
+        }
+        return false;
+    }
+
     public void validatePipe(SunGraphics2D sg2d) {
         sg2d.imagepipe = imagepipe;
         if (sg2d.compositeState == sg2d.COMP_XOR) {
@@ -480,9 +546,21 @@ public abstract class SurfaceData
                 // text drawn in XOR mode with a Paint object.
                 sg2d.textpipe = outlineTextRenderer;
             } else {
+                PixelToShapeConverter converter;
+                if (canRenderParallelograms(sg2d)) {
+                    converter = colorViaPgram;
+                    // Note that we use the transforming pipe here because it
+                    // will examine the shape and possibly perform an optimized
+                    // operation if it can be simplified.  The simplifications
+                    // will be valid for all STROKE and TRANSFORM types.
+                    sg2d.shapepipe = colorViaPgram;
+                } else {
+                    converter = colorViaShape;
+                    sg2d.shapepipe = colorPrimitives;
+                }
                 if (sg2d.clipState == sg2d.CLIP_SHAPE) {
-                    sg2d.drawpipe = colorViaShape;
-                    sg2d.fillpipe = colorViaShape;
+                    sg2d.drawpipe = converter;
+                    sg2d.fillpipe = converter;
                     // REMIND: We should not be changing text strategies
                     // between outline and glyph rendering based upon the
                     // presence of a complex clip as that could cause a
@@ -494,11 +572,11 @@ public abstract class SurfaceData
                     sg2d.textpipe = outlineTextRenderer;
                 } else {
                     if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
-                        sg2d.drawpipe = colorViaShape;
-                        sg2d.fillpipe = colorViaShape;
+                        sg2d.drawpipe = converter;
+                        sg2d.fillpipe = converter;
                     } else {
                         if (sg2d.strokeState != sg2d.STROKE_THIN) {
-                            sg2d.drawpipe = colorViaShape;
+                            sg2d.drawpipe = converter;
                         } else {
                             sg2d.drawpipe = colorPrimitives;
                         }
@@ -506,7 +584,6 @@ public abstract class SurfaceData
                     }
                     sg2d.textpipe = solidTextRenderer;
                 }
-                sg2d.shapepipe = colorPrimitives;
                 // assert(sg2d.surfaceData == this);
             }
         } else if (sg2d.compositeState == sg2d.COMP_CUSTOM) {
@@ -589,12 +666,24 @@ public abstract class SurfaceData
                 }
             }
         } else {
+            PixelToShapeConverter converter;
+            if (canRenderParallelograms(sg2d)) {
+                converter = colorViaPgram;
+                // Note that we use the transforming pipe here because it
+                // will examine the shape and possibly perform an optimized
+                // operation if it can be simplified.  The simplifications
+                // will be valid for all STROKE and TRANSFORM types.
+                sg2d.shapepipe = colorViaPgram;
+            } else {
+                converter = colorViaShape;
+                sg2d.shapepipe = colorPrimitives;
+            }
             if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
-                sg2d.drawpipe = colorViaShape;
-                sg2d.fillpipe = colorViaShape;
+                sg2d.drawpipe = converter;
+                sg2d.fillpipe = converter;
             } else {
                 if (sg2d.strokeState != sg2d.STROKE_THIN) {
-                    sg2d.drawpipe = colorViaShape;
+                    sg2d.drawpipe = converter;
                 } else {
                     sg2d.drawpipe = colorPrimitives;
                 }
@@ -602,7 +691,6 @@ public abstract class SurfaceData
             }
 
             sg2d.textpipe = getTextPipe(sg2d, false /* AA==OFF */);
-            sg2d.shapepipe = colorPrimitives;
             // assert(sg2d.surfaceData == this);
         }
 
@@ -761,6 +849,8 @@ public abstract class SurfaceData
         loops.drawPathLoop = DrawPath.locate(src, comp, dst);
         loops.fillPathLoop = FillPath.locate(src, comp, dst);
         loops.fillSpansLoop = FillSpans.locate(src, comp, dst);
+        loops.fillParallelogramLoop = FillParallelogram.locate(src, comp, dst);
+        loops.drawParallelogramLoop = DrawParallelogram.locate(src, comp, dst);
         loops.drawGlyphListLoop = DrawGlyphList.locate(src, comp, dst);
         loops.drawGlyphListAALoop = DrawGlyphListAA.locate(src, comp, dst);
         loops.drawGlyphListLCDLoop = DrawGlyphListLCD.locate(src, comp, dst);
diff --git a/jdk/src/share/classes/sun/java2d/loops/DrawParallelogram.java b/jdk/src/share/classes/sun/java2d/loops/DrawParallelogram.java
new file mode 100644
index 0000000000000000000000000000000000000000..788b2e4edd06241ec4661e5cee2b2a38cc24b301
--- /dev/null
+++ b/jdk/src/share/classes/sun/java2d/loops/DrawParallelogram.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2008, 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.
+ */
+
+/*
+ * @author Jim Graham
+ */
+
+package sun.java2d.loops;
+
+import sun.java2d.loops.GraphicsPrimitive;
+import sun.java2d.SunGraphics2D;
+import sun.java2d.SurfaceData;
+
+/**
+ * DrawParallelogram
+ * 1) fill the area between the 4 edges of an outer parallelogram
+ *    (as specified by an origin and 2 delta vectors)
+ *    but also outside the 4 edges of an inner parallelogram
+ *    (as specified by proportional amounts of the outer delta vectors)
+ */
+public class DrawParallelogram extends GraphicsPrimitive
+{
+    public final static String methodSignature =
+        "DrawParallelogram(...)".toString();
+
+    public final static int primTypeID = makePrimTypeID();
+
+    public static DrawParallelogram locate(SurfaceType srctype,
+                                           CompositeType comptype,
+                                           SurfaceType dsttype)
+    {
+        return (DrawParallelogram)
+            GraphicsPrimitiveMgr.locate(primTypeID,
+                                        srctype, comptype, dsttype);
+    }
+
+    protected DrawParallelogram(SurfaceType srctype,
+                                CompositeType comptype,
+                                SurfaceType dsttype)
+    {
+        super(methodSignature, primTypeID,
+              srctype, comptype, dsttype);
+    }
+
+    public DrawParallelogram(long pNativePrim,
+                             SurfaceType srctype,
+                             CompositeType comptype,
+                             SurfaceType dsttype)
+    {
+        super(pNativePrim, methodSignature, primTypeID,
+              srctype, comptype, dsttype);
+    }
+
+    /**
+     * All DrawParallelogram implementors must have this invoker method
+     */
+    public native void DrawParallelogram(SunGraphics2D sg, SurfaceData dest,
+                                         double x, double y,
+                                         double dx1, double dy1,
+                                         double dx2, double dy2,
+                                         double lw1, double lw2);
+
+    public GraphicsPrimitive makePrimitive(SurfaceType srctype,
+                                           CompositeType comptype,
+                                           SurfaceType dsttype)
+    {
+        // REMIND: iterate with a FillRect primitive?
+        throw new InternalError("DrawParallelogram not implemented for "+
+                                srctype+" with "+comptype);
+    }
+
+    public GraphicsPrimitive traceWrap() {
+        return new TraceDrawParallelogram(this);
+    }
+
+    private static class TraceDrawParallelogram extends DrawParallelogram {
+        DrawParallelogram target;
+
+        public TraceDrawParallelogram(DrawParallelogram target) {
+            super(target.getSourceType(),
+                  target.getCompositeType(),
+                  target.getDestType());
+            this.target = target;
+        }
+
+        public GraphicsPrimitive traceWrap() {
+            return this;
+        }
+
+        public void DrawParallelogram(SunGraphics2D sg2d, SurfaceData dest,
+                                      double x, double y,
+                                      double dx1, double dy1,
+                                      double dx2, double dy2,
+                                      double lw1, double lw2)
+        {
+            tracePrimitive(target);
+            target.DrawParallelogram(sg2d, dest,
+                                     x, y, dx1, dy1, dx2, dy2, lw1, lw2);
+        }
+    }
+}
diff --git a/jdk/src/share/classes/sun/java2d/loops/FillParallelogram.java b/jdk/src/share/classes/sun/java2d/loops/FillParallelogram.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bc1553d6a6bd9f08fbcc8831467f582f844d796
--- /dev/null
+++ b/jdk/src/share/classes/sun/java2d/loops/FillParallelogram.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2008, 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.
+ */
+
+/*
+ * @author Jim Graham
+ */
+
+package sun.java2d.loops;
+
+import sun.java2d.loops.GraphicsPrimitive;
+import sun.java2d.SunGraphics2D;
+import sun.java2d.SurfaceData;
+
+/**
+ * FillParallelogram
+ * 1) fill the area between the 4 edges of a parallelogram
+ *    (as specified by an origin and 2 delta vectors)
+ */
+public class FillParallelogram extends GraphicsPrimitive
+{
+    public final static String methodSignature =
+        "FillParallelogram(...)".toString();
+
+    public final static int primTypeID = makePrimTypeID();
+
+    public static FillParallelogram locate(SurfaceType srctype,
+                                           CompositeType comptype,
+                                           SurfaceType dsttype)
+    {
+        return (FillParallelogram)
+            GraphicsPrimitiveMgr.locate(primTypeID,
+                                        srctype, comptype, dsttype);
+    }
+
+    protected FillParallelogram(SurfaceType srctype,
+                                CompositeType comptype,
+                                SurfaceType dsttype)
+    {
+        super(methodSignature, primTypeID,
+              srctype, comptype, dsttype);
+    }
+
+    public FillParallelogram(long pNativePrim,
+                             SurfaceType srctype,
+                             CompositeType comptype,
+                             SurfaceType dsttype)
+    {
+        super(pNativePrim, methodSignature, primTypeID,
+              srctype, comptype, dsttype);
+    }
+
+    /**
+     * All FillParallelogram implementors must have this invoker method
+     */
+    public native void FillParallelogram(SunGraphics2D sg2d, SurfaceData dest,
+                                         double x0, double y0,
+                                         double dx1, double dy1,
+                                         double dx2, double dy2);
+
+    public GraphicsPrimitive makePrimitive(SurfaceType srctype,
+                                           CompositeType comptype,
+                                           SurfaceType dsttype)
+    {
+        // REMIND: iterate with a FillRect primitive?
+        throw new InternalError("FillParallelogram not implemented for "+
+                                srctype+" with "+comptype);
+    }
+
+    public GraphicsPrimitive traceWrap() {
+        return new TraceFillParallelogram(this);
+    }
+
+    private static class TraceFillParallelogram extends FillParallelogram {
+        FillParallelogram target;
+
+        public TraceFillParallelogram(FillParallelogram target) {
+            super(target.getSourceType(),
+                  target.getCompositeType(),
+                  target.getDestType());
+            this.target = target;
+        }
+
+        public GraphicsPrimitive traceWrap() {
+            return this;
+        }
+
+        public void FillParallelogram(SunGraphics2D sg2d, SurfaceData dest,
+                                      double x0, double y0,
+                                      double dx1, double dy1,
+                                      double dx2, double dy2)
+        {
+            tracePrimitive(target);
+            target.FillParallelogram(sg2d, dest, x0, y0, dx1, dy1, dx2, dy2);
+        }
+    }
+}
diff --git a/jdk/src/share/classes/sun/java2d/loops/RenderLoops.java b/jdk/src/share/classes/sun/java2d/loops/RenderLoops.java
index 350914b42db9cd98cacf716a9218f568b294dc88..192236f1fc2b3eeaeb6866190d66e77984cb4bae 100644
--- a/jdk/src/share/classes/sun/java2d/loops/RenderLoops.java
+++ b/jdk/src/share/classes/sun/java2d/loops/RenderLoops.java
@@ -47,6 +47,8 @@ public class RenderLoops {
     public DrawPath             drawPathLoop;
     public FillPath             fillPathLoop;
     public FillSpans            fillSpansLoop;
+    public FillParallelogram    fillParallelogramLoop;
+    public DrawParallelogram    drawParallelogramLoop;
     public DrawGlyphList        drawGlyphListLoop;
     public DrawGlyphListAA      drawGlyphListAALoop;
     public DrawGlyphListLCD     drawGlyphListLCDLoop;
diff --git a/jdk/src/share/classes/sun/java2d/pipe/LoopPipe.java b/jdk/src/share/classes/sun/java2d/pipe/LoopPipe.java
index b50b5529b1e1c0e5af6ca0e0db3f6b00b6342802..67db67062d461465d3405382a54c3c6ef4f149a9 100644
--- a/jdk/src/share/classes/sun/java2d/pipe/LoopPipe.java
+++ b/jdk/src/share/classes/sun/java2d/pipe/LoopPipe.java
@@ -41,11 +41,14 @@ import sun.java2d.SunGraphics2D;
 import sun.java2d.SurfaceData;
 import sun.java2d.loops.FontInfo;
 import sun.java2d.loops.DrawPolygons;
+import sun.java2d.loops.FillParallelogram;
+import sun.java2d.loops.DrawParallelogram;
 import sun.awt.SunHints;
 
 public class LoopPipe
     implements PixelDrawPipe,
                PixelFillPipe,
+               ParallelogramPipe,
                ShapeDrawPipe,
                LoopBasedPipe
 {
@@ -347,4 +350,25 @@ public class LoopPipe
             sg2d.loops.fillRectLoop.FillRect(sg2d, sd, x, y, w, h);
         }
     }
+
+    public void fillParallelogram(SunGraphics2D sg2d,
+                                  double x, double y,
+                                  double dx1, double dy1,
+                                  double dx2, double dy2)
+    {
+        FillParallelogram fp = sg2d.loops.fillParallelogramLoop;
+        fp.FillParallelogram(sg2d, sg2d.getSurfaceData(),
+                             x, y, dx1, dy1, dx2, dy2);
+    }
+
+    public void drawParallelogram(SunGraphics2D sg2d,
+                                  double x, double y,
+                                  double dx1, double dy1,
+                                  double dx2, double dy2,
+                                  double lw1, double lw2)
+    {
+        DrawParallelogram dp = sg2d.loops.drawParallelogramLoop;
+        dp.DrawParallelogram(sg2d, sg2d.getSurfaceData(),
+                             x, y, dx1, dy1, dx2, dy2, lw1, lw2);
+    }
 }
diff --git a/jdk/src/share/classes/sun/launcher/resources/launcher_pt_BR.properties b/jdk/src/share/classes/sun/launcher/resources/launcher_pt_BR.properties
new file mode 100644
index 0000000000000000000000000000000000000000..e89d147a5bba82b96edc51d297343ec426729607
--- /dev/null
+++ b/jdk/src/share/classes/sun/launcher/resources/launcher_pt_BR.properties
@@ -0,0 +1,116 @@
+#
+# Copyright (c) 2007, 2008, 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.
+#
+
+# Translators please note do not translate the options themselves
+java.launcher.opt.header  =   Usage: {0} [-options] class [args...]\n\
+\           (to execute a class)\n   or  {0} [-options] -jar jarfile [args...]\n\
+\           (to execute a jar file)\n\
+where options include:\n
+
+java.launcher.opt.datamodel  =\    -d{0}\t  use a {0}-bit data model if available\n
+java.launcher.opt.vmselect   =\    {0}\t  to select the "{1}" VM\n
+java.launcher.opt.hotspot    =\    {0}\t  is a synonym for the "{1}" VM  [deprecated]\n
+
+java.launcher.ergo.message1  =\                  The default VM is {0}
+java.launcher.ergo.message2  =\                  because you are running on a server-class machine.\n
+
+# Translators please note do not translate the options themselves
+java.launcher.opt.footer     =\    -cp \n\
+\    -classpath \n\
+\                  A {0} separated list of directories, JAR archives,\n\
+\                  and ZIP archives to search for class files.\n\
+\    -D=\n\
+\                  set a system property\n\
+\    -verbose[:class|gc|jni]\n\
+\                  enable verbose output\n\
+\    -version      print product version and exit\n\
+\    -version:\n\
+\                  require the specified version to run\n\
+\    -showversion  print product version and continue\n\
+\    -jre-restrict-search | -no-jre-restrict-search\n\
+\                  include/exclude user private JREs in the version search\n\
+\    -? -help      print this help message\n\
+\    -X            print help on non-standard options\n\
+\    -ea[:...|:]\n\
+\    -enableassertions[:...|:]\n\
+\                  enable assertions with specified granularity\n\
+\    -da[:...|:]\n\
+\    -disableassertions[:...|:]\n\
+\                  disable assertions with specified granularity\n\
+\    -esa | -enablesystemassertions\n\
+\                  enable system assertions\n\
+\    -dsa | -disablesystemassertions\n\
+\                  disable system assertions\n\
+\    -agentlib:[=]\n\
+\                  load native agent library , e.g. -agentlib:hprof\n\
+\                  see also, -agentlib:jdwp=help and -agentlib:hprof=help\n\
+\    -agentpath:[=]\n\
+\                  load native agent library by full pathname\n\
+\    -javaagent:[=]\n\
+\                  load Java programming language agent, see java.lang.instrument\n\
+\    -splash:\n\
+\                  show splash screen with specified image\n\
+See http://java.sun.com/javase/reference for more details.
+
+# Translators please note do not translate the options themselves
+java.launcher.X.usage=\
+\    -Xmixed           mixed mode execution (default)\n\
+\    -Xint             interpreted mode execution only\n\
+\    -Xbootclasspath:\n\
+\                      set search path for bootstrap classes and resources\n\
+\    -Xbootclasspath/a:\n\
+\                      append to end of bootstrap class path\n\
+\    -Xbootclasspath/p:\n\
+\                      prepend in front of bootstrap class path\n\
+\    -Xnoclassgc       disable class garbage collection\n\
+\    -Xincgc           enable incremental garbage collection\n\
+\    -Xloggc:    log GC status to a file with time stamps\n\
+\    -Xbatch           disable background compilation\n\
+\    -Xms        set initial Java heap size\n\
+\    -Xmx        set maximum Java heap size\n\
+\    -Xss        set java thread stack size\n\
+\    -Xprof            output cpu profiling data\n\
+\    -Xfuture          enable strictest checks, anticipating future default\n\
+\    -Xrs              reduce use of OS signals by Java/VM (see documentation)\n\
+\    -Xcheck:jni       perform additional checks for JNI functions\n\
+\    -Xshare:off       do not attempt to use shared class data\n\
+\    -Xshare:auto      use shared class data if possible (default)\n\
+\    -Xshare:on        require using shared class data, otherwise fail.\n\n\
+The -X options are non-standard and subject to change without notice.\n
+
+java.launcher.cls.error1=\
+    Error: Could not find main class {0}
+java.launcher.cls.error2=\
+    Error: Main method is not {0} in class {1}, please define the main method as:\n\
+\   public static void main(String[] args)
+java.launcher.cls.error3=\
+    Error: Main method must return a value of type void in class {0}, please \n\
+    define the main method as:\n\
+\   public static void main(String[] args)
+java.launcher.cls.error4=\
+    Error: Main method not found in class {0}, please define the main method as:\n\
+\   public static void main(String[] args)
+
+
diff --git a/jdk/src/share/classes/sun/management/resources/agent_pt_BR.properties b/jdk/src/share/classes/sun/management/resources/agent_pt_BR.properties
new file mode 100644
index 0000000000000000000000000000000000000000..1f050faf7e7795a55fc20042c60b65809e33ddc3
--- /dev/null
+++ b/jdk/src/share/classes/sun/management/resources/agent_pt_BR.properties
@@ -0,0 +1,92 @@
+#
+#
+# Copyright (c) 2004, 2005, 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.
+#
+
+# Localizations for Level names.  For the US locale
+# these are the same as the non-localized level name.
+
+agent.err.error			   = Erro
+agent.err.exception                = Exce\u00e7\u00e3o lan\u00e7ada pelo agente 
+agent.err.warning		   = Aviso
+
+agent.err.configfile.notfound      = Arquivo de configura\u00e7\u00e3o n\u00e3o encontrado
+agent.err.configfile.failed        = Falha ao ler o arquivo de configura\u00e7\u00e3o
+agent.err.configfile.closed.failed = Falha ao fechar o arquivo de configura\u00e7\u00e3o
+agent.err.configfile.access.denied = Acesso negado ao arquivo de configura\u00e7\u00e3o
+
+agent.err.exportaddress.failed	   = Falha na exporta\u00e7\u00e3o do endere\u00e7o do conector JMX para o buffer de instrumenta\u00e7\u00e3o
+
+agent.err.agentclass.notfound      = Classe do agente de gerenciamento n\u00e3o encontrada
+agent.err.agentclass.failed        = Classe do agente de gerenciamento falha 
+agent.err.premain.notfound         = premain(String) n\u00e3o existe na classe do agente
+agent.err.agentclass.access.denied = Acesso negado a premain(String)
+agent.err.invalid.agentclass       = Valor inv\u00e1lido da propriedade com.sun.management.agent.class
+
+agent.err.invalid.jmxremote.port   = N\u00famero inv\u00e1lido de com.sun.management.jmxremote.port
+
+agent.err.file.not.set               = Arquivo n\u00e3o especificado
+agent.err.file.not.readable          = Arquivo ileg\u00edvel
+agent.err.file.read.failed           = Falha ao ler o arquivo
+agent.err.file.not.found             = Arquivo n\u00e3o encontrado
+agent.err.file.access.not.restricted = O acesso de leitura do arquivo deve ser limitado
+
+agent.err.password.file.notset     = O arquivo de senha n\u00e3o est\u00e1 especificado, mas com.sun.management.jmxremote.authenticate=true
+agent.err.password.file.not.readable = Arquivo de senha ileg\u00edvel
+agent.err.password.file.read.failed = Falha ao ler o arquivo de senha
+agent.err.password.file.notfound   = Arquivo de senha n\u00e3o encontrado
+agent.err.password.file.access.notrestricted = O acesso de leitura do arquivo de senha deve ser limitado
+
+agent.err.access.file.notset       = O arquivo de acesso n\u00e3o est\u00e1 especificado, mas com.sun.management.jmxremote.authenticate=true
+agent.err.access.file.not.readable = Arquivo de acesso ileg\u00edvel
+agent.err.access.file.read.failed  = Falha ao ler o arquivo de acesso
+agent.err.access.file.notfound     = Arquivo de acesso n\u00e3o encontrado
+
+agent.err.connector.server.io.error = Erro de comunica\u00e7\u00e3o do servidor do conector JMX
+
+agent.err.invalid.option	   = Op\u00e7\u00e3o especificada inv\u00e1lida
+agent.err.invalid.snmp.port        = N\u00famero inv\u00e1lido de com.sun.management.snmp.port
+agent.err.invalid.snmp.trap.port   = N\u00famero inv\u00e1lido de com.sun.management.snmp.trap
+agent.err.unknown.snmp.interface   = Interface SNMP desconhecida
+agent.err.acl.file.notset          = N\u00e3o h\u00e1 nenhum arquivo ACL SNMP especificado, mas com.sun.management.snmp.acl=true
+agent.err.acl.file.notfound        = Arquivo ACL SNMP n\u00e3o encontrado
+agent.err.acl.file.not.readable    = Arquivo ACL SNMP ileg\u00edvel
+agent.err.acl.file.read.failed     = Falha ao ler o arquivo ACL SNMP
+agent.err.acl.file.access.notrestricted = O acesso de leitura do arquivo de senha deve ser limitado
+
+agent.err.snmp.adaptor.start.failed = Falha ao iniciar o adaptador SNMP com endere\u00e7o
+agent.err.snmp.mib.init.failed     = Falha ao inicializar o MIB SNMP com erro
+
+jmxremote.ConnectorBootstrap.initialize = Iniciando o servidor do conector JMX:
+jmxremote.ConnectorBootstrap.initialize.noAuthentication = Sem autentica\u00e7\u00e3o
+jmxremote.ConnectorBootstrap.initialize.ready = Conector JMX pronto em: {0}
+jmxremote.ConnectorBootstrap.initialize.password.readonly = O acesso de leitura do arquivo de senha deve ser limitado: {0}
+jmxremote.ConnectorBootstrap.initialize.file.readonly = O acesso de leitura do arquivo deve ser limitado: {0}
+
+jmxremote.AdaptorBootstrap.getTargetList.processing = Processando ACL
+jmxremote.AdaptorBootstrap.getTargetList.adding = Adicionando destino: {0}
+jmxremote.AdaptorBootstrap.getTargetList.starting = Iniciando o servidor do adaptador:
+jmxremote.AdaptorBootstrap.getTargetList.initialize1 = Adaptador pronto.
+jmxremote.AdaptorBootstrap.getTargetList.initialize2 = Adaptador SNMP pronto em: {0}:{1}
+jmxremote.AdaptorBootstrap.getTargetList.terminate = conclu\u00eddo {0}
diff --git a/jdk/src/share/classes/sun/misc/FpUtils.java b/jdk/src/share/classes/sun/misc/FpUtils.java
index 72ac47eee368e02c825fa9953f442410887dd6e0..21ea7c29a4431a7afb964fd03c57d2e345f6d5fa 100644
--- a/jdk/src/share/classes/sun/misc/FpUtils.java
+++ b/jdk/src/share/classes/sun/misc/FpUtils.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010 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
@@ -29,9 +29,9 @@ import sun.misc.FloatConsts;
 import sun.misc.DoubleConsts;
 
 /**
- * The class FpUtils contains static utility methods for
- * manipulating and inspecting float and
- * double floating-point numbers.  These methods include
+ * The class {@code FpUtils} contains static utility methods for
+ * manipulating and inspecting {@code float} and
+ * {@code double} floating-point numbers.  These methods include
  * functionality recommended or required by the IEEE 754
  * floating-point standard.
  *
@@ -136,7 +136,7 @@ public class FpUtils {
     // tests for exception cases.
 
     /**
-     * Returns unbiased exponent of a double.
+     * Returns unbiased exponent of a {@code double}.
      */
     public static int getExponent(double d){
         /*
@@ -149,7 +149,7 @@ public class FpUtils {
     }
 
     /**
-     * Returns unbiased exponent of a float.
+     * Returns unbiased exponent of a {@code float}.
      */
     public static int getExponent(float f){
         /*
@@ -185,15 +185,15 @@ public class FpUtils {
      * Returns the first floating-point argument with the sign of the
      * second floating-point argument.  Note that unlike the {@link
      * FpUtils#copySign(double, double) copySign} method, this method
-     * does not require NaN sign arguments to be treated
+     * does not require NaN {@code sign} arguments to be treated
      * as positive values; implementations are permitted to treat some
      * NaN arguments as positive and other NaN arguments as negative
      * to allow greater performance.
      *
      * @param magnitude  the parameter providing the magnitude of the result
      * @param sign   the parameter providing the sign of the result
-     * @return a value with the magnitude of magnitude
-     * and the sign of sign.
+     * @return a value with the magnitude of {@code magnitude}
+     * and the sign of {@code sign}.
      * @author Joseph D. Darcy
      */
     public static double rawCopySign(double magnitude, double sign) {
@@ -208,15 +208,15 @@ public class FpUtils {
      * Returns the first floating-point argument with the sign of the
      * second floating-point argument.  Note that unlike the {@link
      * FpUtils#copySign(float, float) copySign} method, this method
-     * does not require NaN sign arguments to be treated
+     * does not require NaN {@code sign} arguments to be treated
      * as positive values; implementations are permitted to treat some
      * NaN arguments as positive and other NaN arguments as negative
      * to allow greater performance.
      *
      * @param magnitude  the parameter providing the magnitude of the result
      * @param sign   the parameter providing the sign of the result
-     * @return a value with the magnitude of magnitude
-     * and the sign of sign.
+     * @return a value with the magnitude of {@code magnitude}
+     * and the sign of {@code sign}.
      * @author Joseph D. Darcy
      */
     public static float rawCopySign(float magnitude, float sign) {
@@ -230,129 +230,129 @@ public class FpUtils {
     /* ***************************************************************** */
 
     /**
-     * Returns true if the argument is a finite
-     * floating-point value; returns false otherwise (for
+     * Returns {@code true} if the argument is a finite
+     * floating-point value; returns {@code false} otherwise (for
      * NaN and infinity arguments).
      *
-     * @param d the double value to be tested
-     * @return true if the argument is a finite
-     * floating-point value, false otherwise.
+     * @param d the {@code double} value to be tested
+     * @return {@code true} if the argument is a finite
+     * floating-point value, {@code false} otherwise.
      */
     public static boolean isFinite(double d) {
         return Math.abs(d) <= DoubleConsts.MAX_VALUE;
     }
 
     /**
-     * Returns true if the argument is a finite
-     * floating-point value; returns false otherwise (for
+     * Returns {@code true} if the argument is a finite
+     * floating-point value; returns {@code false} otherwise (for
      * NaN and infinity arguments).
      *
-     * @param f the float value to be tested
-     * @return true if the argument is a finite
-     * floating-point value, false otherwise.
+     * @param f the {@code float} value to be tested
+     * @return {@code true} if the argument is a finite
+     * floating-point value, {@code false} otherwise.
      */
      public static boolean isFinite(float f) {
         return Math.abs(f) <= FloatConsts.MAX_VALUE;
     }
 
     /**
-     * Returns true if the specified number is infinitely
-     * large in magnitude, false otherwise.
+     * Returns {@code true} if the specified number is infinitely
+     * large in magnitude, {@code false} otherwise.
      *
      * 
      Note that this method is equivalent to the {@link
      * Double#isInfinite(double) Double.isInfinite} method; the
      * functionality is included in this class for convenience.
      *
      * @param   d   the value to be tested.
-     * @return  true if the value of the argument is positive
-     *          infinity or negative infinity; false otherwise.
+     * @return  {@code true} if the value of the argument is positive
+     *          infinity or negative infinity; {@code false} otherwise.
      */
     public static boolean isInfinite(double d) {
         return Double.isInfinite(d);
     }
 
     /**
-     * Returns true if the specified number is infinitely
-     * large in magnitude, false otherwise.
+     * Returns {@code true} if the specified number is infinitely
+     * large in magnitude, {@code false} otherwise.
      *
      * 
      Note that this method is equivalent to the {@link
      * Float#isInfinite(float) Float.isInfinite} method; the
      * functionality is included in this class for convenience.
      *
      * @param   f   the value to be tested.
-     * @return  true if the argument is positive infinity or
-     *          negative infinity; false otherwise.
+     * @return  {@code true} if the argument is positive infinity or
+     *          negative infinity; {@code false} otherwise.
      */
      public static boolean isInfinite(float f) {
          return Float.isInfinite(f);
     }
 
     /**
-     * Returns true if the specified number is a
-     * Not-a-Number (NaN) value, false otherwise.
+     * Returns {@code true} if the specified number is a
+     * Not-a-Number (NaN) value, {@code false} otherwise.
      *
      * 
      Note that this method is equivalent to the {@link
      * Double#isNaN(double) Double.isNaN} method; the functionality is
      * included in this class for convenience.
      *
      * @param   d   the value to be tested.
-     * @return  true if the value of the argument is NaN;
-     *          false otherwise.
+     * @return  {@code true} if the value of the argument is NaN;
+     *          {@code false} otherwise.
      */
     public static boolean isNaN(double d) {
         return Double.isNaN(d);
     }
 
     /**
-     * Returns true if the specified number is a
-     * Not-a-Number (NaN) value, false otherwise.
+     * Returns {@code true} if the specified number is a
+     * Not-a-Number (NaN) value, {@code false} otherwise.
      *
      * 
      Note that this method is equivalent to the {@link
      * Float#isNaN(float) Float.isNaN} method; the functionality is
      * included in this class for convenience.
      *
      * @param   f   the value to be tested.
-     * @return  true if the argument is NaN;
-     *          false otherwise.
+     * @return  {@code true} if the argument is NaN;
+     *          {@code false} otherwise.
      */
      public static boolean isNaN(float f) {
         return Float.isNaN(f);
     }
 
     /**
-     * Returns true if the unordered relation holds
+     * Returns {@code true} if the unordered relation holds
      * between the two arguments.  When two floating-point values are
      * unordered, one value is neither less than, equal to, nor
      * greater than the other.  For the unordered relation to be true,
-     * at least one argument must be a NaN.
+     * at least one argument must be a {@code NaN}.
      *
      * @param arg1      the first argument
      * @param arg2      the second argument
-     * @return true if at least one argument is a NaN,
-     * false otherwise.
+     * @return {@code true} if at least one argument is a NaN,
+     * {@code false} otherwise.
      */
     public static boolean isUnordered(double arg1, double arg2) {
         return isNaN(arg1) || isNaN(arg2);
     }
 
     /**
-     * Returns true if the unordered relation holds
+     * Returns {@code true} if the unordered relation holds
      * between the two arguments.  When two floating-point values are
      * unordered, one value is neither less than, equal to, nor
      * greater than the other.  For the unordered relation to be true,
-     * at least one argument must be a NaN.
+     * at least one argument must be a {@code NaN}.
      *
      * @param arg1      the first argument
      * @param arg2      the second argument
-     * @return true if at least one argument is a NaN,
-     * false otherwise.
+     * @return {@code true} if at least one argument is a NaN,
+     * {@code false} otherwise.
      */
      public static boolean isUnordered(float arg1, float arg2) {
         return isNaN(arg1) || isNaN(arg2);
     }
 
     /**
-     * Returns unbiased exponent of a double; for
+     * Returns unbiased exponent of a {@code double}; for
      * subnormal values, the number is treated as if it were
      * normalized.  That is for all finite, non-zero, positive numbers
      * x, scalb(x, -ilogb(x)) is
@@ -378,7 +378,6 @@ public class FpUtils {
                 return (1<<30);         // 2^30
             else // infinite value
                 return (1<<28);         // 2^28
-        // break;
 
         case DoubleConsts.MIN_EXPONENT-1:       // zero or subnormal
             if(d == 0.0) {
@@ -414,18 +413,16 @@ public class FpUtils {
                         exponent < DoubleConsts.MIN_EXPONENT);
                 return exponent;
             }
-        // break;
 
         default:
             assert( exponent >= DoubleConsts.MIN_EXPONENT &&
                     exponent <= DoubleConsts.MAX_EXPONENT);
             return exponent;
-        // break;
         }
     }
 
     /**
-     * Returns unbiased exponent of a float; for
+     * Returns unbiased exponent of a {@code float}; for
      * subnormal values, the number is treated as if it were
      * normalized.  That is for all finite, non-zero, positive numbers
      * x, scalb(x, -ilogb(x)) is
@@ -451,7 +448,6 @@ public class FpUtils {
                 return (1<<30);         // 2^30
             else // infinite value
                 return (1<<28);         // 2^28
-        // break;
 
         case FloatConsts.MIN_EXPONENT-1:        // zero or subnormal
             if(f == 0.0f) {
@@ -487,13 +483,11 @@ public class FpUtils {
                         exponent < FloatConsts.MIN_EXPONENT);
                 return exponent;
             }
-        // break;
 
         default:
             assert( exponent >= FloatConsts.MIN_EXPONENT &&
                     exponent <= FloatConsts.MAX_EXPONENT);
             return exponent;
-        // break;
         }
     }
 
@@ -534,22 +528,22 @@ public class FpUtils {
      */
 
     /**
-     * Return d ×
-     * 2scale_factor rounded as if performed
+     * Return {@code d} ×
+     * 2{@code scale_factor} rounded as if performed
      * by a single correctly rounded floating-point multiply to a
      * member of the double value set.  See §4.2.3
      * of the Java
      * Language Specification for a discussion of floating-point
      * value sets.  If the exponent of the result is between the
-     * double's minimum exponent and maximum exponent,
+     * {@code double}'s minimum exponent and maximum exponent,
      * the answer is calculated exactly.  If the exponent of the
-     * result would be larger than doubles's maximum
+     * result would be larger than {@code doubles}'s maximum
      * exponent, an infinity is returned.  Note that if the result is
-     * subnormal, precision may be lost; that is, when scalb(x,
-     * n) is subnormal, scalb(scalb(x, n), -n) may
+     * subnormal, precision may be lost; that is, when {@code scalb(x,
+     * n)} is subnormal, {@code scalb(scalb(x, n), -n)} may
      * not equal x.  When the result is non-NaN, the result has
-     * the same sign as d.
+     * the same sign as {@code d}.
      *
      *
      
      * Special cases:
@@ -562,8 +556,8 @@ public class FpUtils {
      * 
      *
      * @param d number to be scaled by a power of two.
-     * @param scale_factor power of 2 used to scale d
-     * @return d * 2scale_factor
+     * @param scale_factor power of 2 used to scale {@code d}
+     * @return {@code d * }2{@code scale_factor}
      * @author Joseph D. Darcy
      */
     public static double scalb(double d, int scale_factor) {
@@ -644,22 +638,22 @@ public class FpUtils {
     }
 
     /**
-     * Return f ×
-     * 2scale_factor rounded as if performed
+     * Return {@code f} ×
+     * 2{@code scale_factor} rounded as if performed
      * by a single correctly rounded floating-point multiply to a
      * member of the float value set.  See §4.2.3
      * of the Java
      * Language Specification for a discussion of floating-point
      * value set. If the exponent of the result is between the
-     * float's minimum exponent and maximum exponent, the
+     * {@code float}'s minimum exponent and maximum exponent, the
      * answer is calculated exactly.  If the exponent of the result
-     * would be larger than float's maximum exponent, an
+     * would be larger than {@code float}'s maximum exponent, an
      * infinity is returned.  Note that if the result is subnormal,
-     * precision may be lost; that is, when scalb(x, n)
-     * is subnormal, scalb(scalb(x, n), -n) may not equal
+     * precision may be lost; that is, when {@code scalb(x, n)}
+     * is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
      * x.  When the result is non-NaN, the result has the same
-     * sign as f.
+     * sign as {@code f}.
      *
      *
      
      * Special cases:
@@ -672,8 +666,8 @@ public class FpUtils {
      * 
      *
      * @param f number to be scaled by a power of two.
-     * @param scale_factor power of 2 used to scale f
-     * @return f * 2scale_factor
+     * @param scale_factor power of 2 used to scale {@code f}
+     * @return {@code f * }2{@code scale_factor}
      * @author Joseph D. Darcy
      */
      public static float scalb(float f, int scale_factor) {
@@ -709,34 +703,34 @@ public class FpUtils {
      * 
        
      * 
      •  If either argument is a NaN, then NaN is returned.
      *
-     * 
      •  If both arguments are signed zeros, direction
+     * 
      •  If both arguments are signed zeros, {@code direction}
      * is returned unchanged (as implied by the requirement of
      * returning the second argument if the arguments compare as
      * equal).
      *
-     * 
      •  If start is
-     * ±Double.MIN_VALUE and direction
+     * 
      •  If {@code start} is
+     * ±{@code Double.MIN_VALUE} and {@code direction}
      * has a value such that the result should have a smaller
-     * magnitude, then a zero with the same sign as start
+     * magnitude, then a zero with the same sign as {@code start}
      * is returned.
      *
-     * 
      •  If start is infinite and
-     * direction has a value such that the result should
-     * have a smaller magnitude, Double.MAX_VALUE with the
-     * same sign as start is returned.
+     * 
      •  If {@code start} is infinite and
+     * {@code direction} has a value such that the result should
+     * have a smaller magnitude, {@code Double.MAX_VALUE} with the
+     * same sign as {@code start} is returned.
      *
-     * 
      •  If start is equal to ±
-     * Double.MAX_VALUE and direction has a
+     * 
      •  If {@code start} is equal to ±
+     * {@code Double.MAX_VALUE} and {@code direction} has a
      * value such that the result should have a larger magnitude, an
-     * infinity with same sign as start is returned.
+     * infinity with same sign as {@code start} is returned.
      * 
      
      *
      * @param start     starting floating-point value
      * @param direction value indicating which of
-     * start's neighbors or start should
+     * {@code start}'s neighbors or {@code start} should
      * be returned
-     * @return The floating-point number adjacent to start in the
-     * direction of direction.
+     * @return The floating-point number adjacent to {@code start} in the
+     * direction of {@code direction}.
      * @author Joseph D. Darcy
      */
     public static double nextAfter(double start, double direction) {
@@ -809,34 +803,34 @@ public class FpUtils {
      * 
        
      * 
      •  If either argument is a NaN, then NaN is returned.
      *
-     * 
      •  If both arguments are signed zeros, a float
-     * zero with the same sign as direction is returned
+     * 
      •  If both arguments are signed zeros, a {@code float}
+     * zero with the same sign as {@code direction} is returned
      * (as implied by the requirement of returning the second argument
      * if the arguments compare as equal).
      *
-     * 
      •  If start is
-     * ±Float.MIN_VALUE and direction
+     * 
      •  If {@code start} is
+     * ±{@code Float.MIN_VALUE} and {@code direction}
      * has a value such that the result should have a smaller
-     * magnitude, then a zero with the same sign as start
+     * magnitude, then a zero with the same sign as {@code start}
      * is returned.
      *
-     * 
      •  If start is infinite and
-     * direction has a value such that the result should
-     * have a smaller magnitude, Float.MAX_VALUE with the
-     * same sign as start is returned.
+     * 
      •  If {@code start} is infinite and
+     * {@code direction} has a value such that the result should
+     * have a smaller magnitude, {@code Float.MAX_VALUE} with the
+     * same sign as {@code start} is returned.
      *
-     * 
      •  If start is equal to ±
-     * Float.MAX_VALUE and direction has a
+     * 
      •  If {@code start} is equal to ±
+     * {@code Float.MAX_VALUE} and {@code direction} has a
      * value such that the result should have a larger magnitude, an
-     * infinity with same sign as start is returned.
+     * infinity with same sign as {@code start} is returned.
      * 
      
      *
      * @param start     starting floating-point value
      * @param direction value indicating which of
-     * start's neighbors or start should
+     * {@code start}'s neighbors or {@code start} should
      * be returned
-     * @return The floating-point number adjacent to start in the
-     * direction of direction.
+     * @return The floating-point number adjacent to {@code start} in the
+     * direction of {@code direction}.
      * @author Joseph D. Darcy
      */
      public static float nextAfter(float start, double direction) {
@@ -900,12 +894,12 @@ public class FpUtils {
     }
 
     /**
-     * Returns the floating-point value adjacent to d in
+     * Returns the floating-point value adjacent to {@code d} in
      * the direction of positive infinity.  This method is
-     * semantically equivalent to nextAfter(d,
-     * Double.POSITIVE_INFINITY); however, a nextUp
+     * semantically equivalent to {@code nextAfter(d,
+     * Double.POSITIVE_INFINITY)}; however, a {@code nextUp}
      * implementation may run faster than its equivalent
-     * nextAfter call.
+     * {@code nextAfter} call.
      *
      * 
      Special Cases:
      * 
        
@@ -915,7 +909,7 @@ public class FpUtils {
      * positive infinity.
      *
      * 
      •  If the argument is zero, the result is
-     * Double.MIN_VALUE
+     * {@code Double.MIN_VALUE}
      *
      * 
      
      *
@@ -935,12 +929,12 @@ public class FpUtils {
     }
 
     /**
-     * Returns the floating-point value adjacent to f in
+     * Returns the floating-point value adjacent to {@code f} in
      * the direction of positive infinity.  This method is
-     * semantically equivalent to nextAfter(f,
-     * Double.POSITIVE_INFINITY); however, a nextUp
+     * semantically equivalent to {@code nextAfter(f,
+     * Double.POSITIVE_INFINITY)}; however, a {@code nextUp}
      * implementation may run faster than its equivalent
-     * nextAfter call.
+     * {@code nextAfter} call.
      *
      * 
      Special Cases:
      * 
        
@@ -950,7 +944,7 @@ public class FpUtils {
      * positive infinity.
      *
      * 
      •  If the argument is zero, the result is
-     * Float.MIN_VALUE
+     * {@code Float.MIN_VALUE}
      *
      * 
      
      *
@@ -970,12 +964,12 @@ public class FpUtils {
     }
 
     /**
-     * Returns the floating-point value adjacent to d in
+     * Returns the floating-point value adjacent to {@code d} in
      * the direction of negative infinity.  This method is
-     * semantically equivalent to nextAfter(d,
-     * Double.NEGATIVE_INFINITY); however, a
-     * nextDown implementation may run faster than its
-     * equivalent nextAfter call.
+     * semantically equivalent to {@code nextAfter(d,
+     * Double.NEGATIVE_INFINITY)}; however, a
+     * {@code nextDown} implementation may run faster than its
+     * equivalent {@code nextAfter} call.
      *
      * 
      Special Cases:
      * 
        
@@ -985,7 +979,7 @@ public class FpUtils {
      * negative infinity.
      *
      * 
      •  If the argument is zero, the result is
-     * -Double.MIN_VALUE
+     * {@code -Double.MIN_VALUE}
      *
      * 
      
      *
@@ -1007,12 +1001,12 @@ public class FpUtils {
     }
 
     /**
-     * Returns the floating-point value adjacent to f in
+     * Returns the floating-point value adjacent to {@code f} in
      * the direction of negative infinity.  This method is
-     * semantically equivalent to nextAfter(f,
-     * Float.NEGATIVE_INFINITY); however, a
-     * nextDown implementation may run faster than its
-     * equivalent nextAfter call.
+     * semantically equivalent to {@code nextAfter(f,
+     * Float.NEGATIVE_INFINITY)}; however, a
+     * {@code nextDown} implementation may run faster than its
+     * equivalent {@code nextAfter} call.
      *
      * 
      Special Cases:
      * 
        
@@ -1022,7 +1016,7 @@ public class FpUtils {
      * negative infinity.
      *
      * 
      •  If the argument is zero, the result is
-     * -Float.MIN_VALUE
+     * {@code -Float.MIN_VALUE}
      *
      * 
      
      *
@@ -1046,13 +1040,13 @@ public class FpUtils {
     /**
      * Returns the first floating-point argument with the sign of the
      * second floating-point argument.  For this method, a NaN
-     * sign argument is always treated as if it were
+     * {@code sign} argument is always treated as if it were
      * positive.
      *
      * @param magnitude  the parameter providing the magnitude of the result
      * @param sign   the parameter providing the sign of the result
-     * @return a value with the magnitude of magnitude
-     * and the sign of sign.
+     * @return a value with the magnitude of {@code magnitude}
+     * and the sign of {@code sign}.
      * @author Joseph D. Darcy
      * @since 1.5
      */
@@ -1063,13 +1057,13 @@ public class FpUtils {
     /**
      * Returns the first floating-point argument with the sign of the
      * second floating-point argument.  For this method, a NaN
-     * sign argument is always treated as if it were
+     * {@code sign} argument is always treated as if it were
      * positive.
      *
      * @param magnitude  the parameter providing the magnitude of the result
      * @param sign   the parameter providing the sign of the result
-     * @return a value with the magnitude of magnitude
-     * and the sign of sign.
+     * @return a value with the magnitude of {@code magnitude}
+     * and the sign of {@code sign}.
      * @author Joseph D. Darcy
      */
      public static float copySign(float magnitude, float sign) {
@@ -1078,8 +1072,8 @@ public class FpUtils {
 
     /**
      * Returns the size of an ulp of the argument.  An ulp of a
-     * double value is the positive distance between this
-     * floating-point value and the double value next
+     * {@code double} value is the positive distance between this
+     * floating-point value and the {@code double} value next
      * larger in magnitude.  Note that for non-NaN x,
      * ulp(-x) == ulp(x).
      *
@@ -1089,8 +1083,8 @@ public class FpUtils {
      * 
    •  If the argument is positive or negative infinity, then the
      * result is positive infinity.
      * 
    •  If the argument is positive or negative zero, then the result is
-     * Double.MIN_VALUE.
-     * 
    •  If the argument is ±Double.MAX_VALUE, then
+     * {@code Double.MIN_VALUE}.
+     * 
    •  If the argument is ±{@code Double.MAX_VALUE}, then
      * the result is equal to 2971.
      * 
      *
@@ -1105,11 +1099,9 @@ public class FpUtils {
         switch(exp) {
         case DoubleConsts.MAX_EXPONENT+1:       // NaN or infinity
             return Math.abs(d);
-            // break;
 
         case DoubleConsts.MIN_EXPONENT-1:       // zero or subnormal
             return Double.MIN_VALUE;
-            // break
 
         default:
             assert exp <= DoubleConsts.MAX_EXPONENT && exp >= DoubleConsts.MIN_EXPONENT;
@@ -1126,14 +1118,13 @@ public class FpUtils {
                 return Double.longBitsToDouble(1L <<
                 (exp - (DoubleConsts.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1)) ));
             }
-            // break
         }
     }
 
     /**
      * Returns the size of an ulp of the argument.  An ulp of a
-     * float value is the positive distance between this
-     * floating-point value and the float value next
+     * {@code float} value is the positive distance between this
+     * floating-point value and the {@code float} value next
      * larger in magnitude.  Note that for non-NaN x,
      * ulp(-x) == ulp(x).
      *
@@ -1143,8 +1134,8 @@ public class FpUtils {
      * 
    •  If the argument is positive or negative infinity, then the
      * result is positive infinity.
      * 
    •  If the argument is positive or negative zero, then the result is
-     * Float.MIN_VALUE.
-     * 
    •  If the argument is ±Float.MAX_VALUE, then
+     * {@code Float.MIN_VALUE}.
+     * 
    •  If the argument is ±{@code Float.MAX_VALUE}, then
      * the result is equal to 2104.
      * 
      *
@@ -1159,11 +1150,9 @@ public class FpUtils {
         switch(exp) {
         case FloatConsts.MAX_EXPONENT+1:        // NaN or infinity
             return Math.abs(f);
-            // break;
 
         case FloatConsts.MIN_EXPONENT-1:        // zero or subnormal
             return FloatConsts.MIN_VALUE;
-            // break
 
         default:
             assert exp <= FloatConsts.MAX_EXPONENT && exp >= FloatConsts.MIN_EXPONENT;
@@ -1180,7 +1169,6 @@ public class FpUtils {
                 return Float.intBitsToFloat(1 <<
                 (exp - (FloatConsts.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1)) ));
             }
-            // break
         }
      }
 
diff --git a/jdk/src/share/classes/sun/misc/VM.java b/jdk/src/share/classes/sun/misc/VM.java
index 9ea6990ae2440c1350f4dba6dc2af9156b66d134..452f1d2a3cbecf1f077ccceefe0f63d66d61317c 100644
--- a/jdk/src/share/classes/sun/misc/VM.java
+++ b/jdk/src/share/classes/sun/misc/VM.java
@@ -25,6 +25,7 @@
 
 package sun.misc;
 
+import static java.lang.Thread.State.*;
 import java.util.Properties;
 import java.util.HashMap;
 import java.util.Map;
@@ -332,69 +333,37 @@ public class VM {
         }
     }
 
-
+    /**
+     * Returns Thread.State for the given threadStatus
+     */
     public static Thread.State toThreadState(int threadStatus) {
-        // Initialize the threadStateMap
-        initThreadStateMap();
-
-        Thread.State s = threadStateMap.get(threadStatus);
-        if (s == null) {
-            // default to RUNNABLE if the threadStatus value is unknown
-            s = Thread.State.RUNNABLE;
+        if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
+            return RUNNABLE;
+        } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
+            return BLOCKED;
+        } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
+            return WAITING;
+        } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
+            return TIMED_WAITING;
+        } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
+            return TERMINATED;
+        } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
+            return NEW;
+        } else {
+            return RUNNABLE;
         }
-        return s;
     }
 
-    // a map of threadStatus values to the corresponding Thread.State
-    private static Map threadStateMap = null;
-    private static Map threadStateNames = null;
-
-    private synchronized static void initThreadStateMap() {
-        if (threadStateMap != null) {
-            return;
-        }
-
-        final Thread.State[] ts = Thread.State.values();
-
-        final int[][] vmThreadStateValues = new int[ts.length][];
-        final String[][] vmThreadStateNames = new String[ts.length][];
-        getThreadStateValues(vmThreadStateValues, vmThreadStateNames);
-
-        threadStateMap = new HashMap();
-        threadStateNames = new HashMap();
-        for (int i = 0; i < ts.length; i++) {
-            String state = ts[i].name();
-            int[] values = null;
-            String[] names = null;
-            for (int j = 0; j < ts.length; j++) {
-                if (vmThreadStateNames[j][0].startsWith(state)) {
-                    values = vmThreadStateValues[j];
-                    names = vmThreadStateNames[j];
-                }
-            }
-            if (values == null) {
-                throw new InternalError("No VM thread state mapped to " +
-                    state);
-            }
-            if (values.length != names.length) {
-                throw new InternalError("VM thread state values and names " +
-                    " mapped to " + state + ": length not matched" );
-            }
-            for (int k = 0; k < values.length; k++) {
-                threadStateMap.put(values[k], ts[i]);
-                threadStateNames.put(values[k], names[k]);
-            }
-        }
-    }
-    // Fill in vmThreadStateValues with int arrays, each of which contains
-    // the threadStatus values mapping to the Thread.State enum constant.
-    // Fill in vmThreadStateNames with String arrays, each of which contains
-    // the name of each threadStatus value of the format:
-    //    [.]
-    // e.g. WAITING.OBJECT_WAIT
-    //
-    private native static void getThreadStateValues(int[][] vmThreadStateValues,
-                                                    String[][] vmThreadStateNames);
+    /* The threadStatus field is set by the VM at state transition
+     * in the hotspot implementation. Its value is set according to
+     * the JVM TI specification GetThreadState function.
+     */
+    private final static int JVMTI_THREAD_STATE_ALIVE = 0x0001;
+    private final static int JVMTI_THREAD_STATE_TERMINATED = 0x0002;
+    private final static int JVMTI_THREAD_STATE_RUNNABLE = 0x0004;
+    private final static int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400;
+    private final static int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010;
+    private final static int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020;
 
     static {
         initialize();
diff --git a/jdk/src/share/native/sun/font/layout/HebrewShaping.cpp b/jdk/src/share/classes/sun/misc/resources/Messages_pt_BR.java
similarity index 52%
rename from jdk/src/share/native/sun/font/layout/HebrewShaping.cpp
rename to jdk/src/share/classes/sun/misc/resources/Messages_pt_BR.java
index e9c0a1fa80cc3f141701407ae5d5d30d5a011312..b90fc942acb018c20b9c7c5bf8b2b3a67c460a82 100644
--- a/jdk/src/share/native/sun/font/layout/HebrewShaping.cpp
+++ b/jdk/src/share/classes/sun/misc/resources/Messages_pt_BR.java
@@ -1,4 +1,5 @@
 /*
+ * Copyright (c) 2003, 2005, 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
@@ -20,39 +21,33 @@
  * 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
+package sun.misc.resources;
+
+/**
+ * 
       This class represents the ResourceBundle
+ * for sun.misc.
  *
+ * @author Michael Colburn
+ * @version 1.5, 11/17/05
  */
 
-#include "LETypes.h"
-#include "OpenTypeTables.h"
-#include "HebrewShaping.h"
-
-const LETag ligaFeatureTag  = 0x6C696761; // 'liga'
-const LETag emptyTag        = 0x00000000; // ''
+public class Messages_pt_BR extends java.util.ListResourceBundle {
 
-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;
+    /**
+     * Returns the contents of this ResourceBundle.
+     * 
      
+     * @return the contents of this ResourceBundle.
+     */
+    public Object[][] getContents() {
+        return contents;
     }
 
-    for (count = 0; count < charCount; count += 1, out += dir) {
-                tags[out] = hebrewTags;
-        }
-}
+    private static final Object[][] contents = {
+        { "optpkg.versionerror", "ERRO: formato de vers\u00e3o inv\u00e1lido usado no arquivo jar {0}. Verifique a documenta\u00e7\u00e3o para obter o formato de vers\u00e3o suportado." },
+        { "optpkg.attributeerror", "ERRO: o atributo de manifesto JAR {0} necess\u00e1rio n\u00e3o est\u00e1 definido no arquivo JAR {1}." },
+        { "optpkg.attributeserror", "ERRO: alguns atributos de manifesto JAR necess\u00e1rios n\u00e3o est\u00e3o definidos no arquivo JAR {0}." }
+    };
+
+}
\ No newline at end of file
diff --git a/jdk/src/share/classes/sun/net/httpserver/Request.java b/jdk/src/share/classes/sun/net/httpserver/Request.java
index a51664b32b0c2012a3536840eba053c19f44ab55..e27cab4dbb07a6c6814ee9b3684349f24968d5f8 100644
--- a/jdk/src/share/classes/sun/net/httpserver/Request.java
+++ b/jdk/src/share/classes/sun/net/httpserver/Request.java
@@ -129,9 +129,22 @@ class Request {
         hdrs = new Headers();
 
         char s[] = new char[10];
+        int len = 0;
+
         int firstc = is.read();
+
+        // check for empty headers
+        if (firstc == CR || firstc == LF) {
+            int c = is.read();
+            if (c == CR || c == LF) {
+                return hdrs;
+            }
+            s[0] = (char)firstc;
+            len = 1;
+            firstc = c;
+        }
+
         while (firstc != LF && firstc != CR && firstc >= 0) {
-            int len = 0;
             int keyend = -1;
             int c;
             boolean inKey = firstc > ' ';
@@ -191,6 +204,7 @@ class Request {
             else
                 v = String.copyValueOf(s, keyend, len - keyend);
             hdrs.add (k,v);
+            len = 0;
         }
         return hdrs;
     }
diff --git a/jdk/src/share/classes/sun/net/httpserver/SSLStreams.java b/jdk/src/share/classes/sun/net/httpserver/SSLStreams.java
index 8578177a61b3366d39439cfb6fb4c5ceab91702e..07a70dc6e377c8a5477d10aed07c7c2a60c39005 100644
--- a/jdk/src/share/classes/sun/net/httpserver/SSLStreams.java
+++ b/jdk/src/share/classes/sun/net/httpserver/SSLStreams.java
@@ -74,8 +74,8 @@ class SSLStreams {
     private void configureEngine(HttpsConfigurator cfg, InetSocketAddress addr){
         if (cfg != null) {
             Parameters params = new Parameters (cfg, addr);
-            cfg.configure (params);
 //BEGIN_TIGER_EXCLUDE
+            cfg.configure (params);
             SSLParameters sslParams = params.getSSLParameters();
             if (sslParams != null) {
                 engine.setSSLParameters (sslParams);
diff --git a/jdk/src/share/classes/sun/net/httpserver/ServerConfig.java b/jdk/src/share/classes/sun/net/httpserver/ServerConfig.java
index cae3cdd84d9c7c5aeef345edb32cad97f1148424..607da2393585c743ff5ac3a3853fffc0c032b65c 100644
--- a/jdk/src/share/classes/sun/net/httpserver/ServerConfig.java
+++ b/jdk/src/share/classes/sun/net/httpserver/ServerConfig.java
@@ -42,7 +42,7 @@ class ServerConfig {
     static final int DEFAULT_CLOCK_TICK = 10000 ; // 10 sec.
 
     /* These values must be a reasonable multiple of clockTick */
-    static final long DEFAULT_IDLE_INTERVAL = 300 ; // 5 min
+    static final long DEFAULT_IDLE_INTERVAL = 30 ; // 5 min
     static final int DEFAULT_MAX_IDLE_CONNECTIONS = 200 ;
 
     static final long DEFAULT_MAX_REQ_TIME = -1; // default: forever
diff --git a/jdk/src/share/classes/sun/nio/ch/FileChannelImpl.java b/jdk/src/share/classes/sun/nio/ch/FileChannelImpl.java
index e37fe799d84b3c8f5dc0d610becc0f1ea6503be0..32d0be649d3fb8616e27239c017bdc9b5488affa 100644
--- a/jdk/src/share/classes/sun/nio/ch/FileChannelImpl.java
+++ b/jdk/src/share/classes/sun/nio/ch/FileChannelImpl.java
@@ -39,13 +39,12 @@ import sun.security.action.GetPropertyAction;
 public class FileChannelImpl
     extends FileChannel
 {
-
-    // Used to make native read and write calls
-    private static final FileDispatcher nd;
-
     // Memory allocation size for mapping buffers
     private static final long allocationGranularity;
 
+    // Used to make native read and write calls
+    private final FileDispatcher nd;
+
     // File descriptor
     private final FileDescriptor fd;
 
@@ -63,22 +62,29 @@ public class FileChannelImpl
     private final Object positionLock = new Object();
 
     private FileChannelImpl(FileDescriptor fd, boolean readable,
-                            boolean writable, Object parent)
+                            boolean writable, boolean append, Object parent)
     {
         this.fd = fd;
         this.readable = readable;
         this.writable = writable;
         this.parent = parent;
+        this.nd = new FileDispatcherImpl(append);
     }
 
-    // Invoked by getChannel() methods
-    // of java.io.File{Input,Output}Stream and RandomAccessFile
-    //
+    // Used by FileInputStream.getChannel() and RandomAccessFile.getChannel()
     public static FileChannel open(FileDescriptor fd,
                                    boolean readable, boolean writable,
                                    Object parent)
     {
-        return new FileChannelImpl(fd, readable, writable, parent);
+        return new FileChannelImpl(fd, readable, writable, false, parent);
+    }
+
+    // Used by FileOutputStream.getChannel
+    public static FileChannel open(FileDescriptor fd,
+                                   boolean readable, boolean writable,
+                                   boolean append, Object parent)
+    {
+        return new FileChannelImpl(fd, readable, writable, append, parent);
     }
 
     private void ensureOpen() throws IOException {
@@ -704,6 +710,9 @@ public class FileChannelImpl
     private static class Unmapper
         implements Runnable
     {
+        // may be required to close file
+        private static final NativeDispatcher nd = new FileDispatcherImpl();
+
         // keep track of mapped buffer usage
         static volatile int count;
         static volatile long totalSize;
@@ -1119,7 +1128,6 @@ public class FileChannelImpl
     static {
         Util.load();
         allocationGranularity = initIDs();
-        nd = new FileDispatcherImpl();
     }
 
 }
diff --git a/jdk/src/share/classes/sun/nio/cs/UTF_32Coder.java b/jdk/src/share/classes/sun/nio/cs/UTF_32Coder.java
index 53645a75b6011aa6224f6b932a478788dced6b43..ebd64ec671543f3ad338b1635fc8918155802536 100644
--- a/jdk/src/share/classes/sun/nio/cs/UTF_32Coder.java
+++ b/jdk/src/share/classes/sun/nio/cs/UTF_32Coder.java
@@ -144,7 +144,7 @@ class UTF_32Coder {
 
         protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) {
             int mark = src.position();
-            if (!doneBOM) {
+            if (!doneBOM && src.hasRemaining()) {
                 if (dst.remaining() < 4)
                     return CoderResult.OVERFLOW;
                 put(BOM_BIG, dst);
diff --git a/jdk/src/share/classes/sun/nio/cs/UnicodeEncoder.java b/jdk/src/share/classes/sun/nio/cs/UnicodeEncoder.java
index cea0270c104b88ce81642a12ff764bc36f0bb5a6..65702dd9cd647ef8c61fdedd666e265cf6111b1a 100644
--- a/jdk/src/share/classes/sun/nio/cs/UnicodeEncoder.java
+++ b/jdk/src/share/classes/sun/nio/cs/UnicodeEncoder.java
@@ -70,13 +70,12 @@ public abstract class UnicodeEncoder extends CharsetEncoder {
     protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) {
         int mark = src.position();
 
-        if (needsMark) {
+        if (needsMark && src.hasRemaining()) {
             if (dst.remaining() < 2)
                 return CoderResult.OVERFLOW;
             put(BYTE_ORDER_MARK, dst);
             needsMark = false;
         }
-
         try {
             while (src.hasRemaining()) {
                 char c = src.get();
diff --git a/jdk/src/share/classes/sun/print/resources/serviceui_pt_BR.properties b/jdk/src/share/classes/sun/print/resources/serviceui_pt_BR.properties
new file mode 100644
index 0000000000000000000000000000000000000000..216c4b168e46217ef90db5a95a3697f3d3c3a398
--- /dev/null
+++ b/jdk/src/share/classes/sun/print/resources/serviceui_pt_BR.properties
@@ -0,0 +1,214 @@
+#
+#
+border.chromaticity=Apar\u00eancia da cor
+border.copies=C\u00f3pias
+border.jobattributes=Atributos do trabalho
+border.media=M\u00eddia
+border.orientation=Orienta\u00e7\u00e3o
+border.printrange=Intervalo de impress\u00e3o
+border.printservice=Servi\u00e7o de impress\u00e3o
+border.quality=Qualidade
+border.sides=Lados
+border.margins=Margens
+#
+button.cancel=Cancelar
+button.ok=OK
+button.print=Imprimir
+button.properties=Propriedades...
+button.properties.mnemonic=R
+#
+checkbox.collate=Agrupar
+checkbox.collate.mnemonic=C
+checkbox.jobsheets=P\u00e1gina com cabe\u00e7alho
+checkbox.jobsheets.mnemonic=B
+checkbox.printtofile=Imprimir em arquivo
+checkbox.printtofile.mnemonic=F
+#
+dialog.printtitle=Imprimir
+dialog.pstitle=Configurar p\u00e1gina
+dialog.overwrite=Este arquivo j\u00e1 existe.  Deseja substituir o arquivo existente?
+dialog.owtitle=Imprimir em arquivo
+dialog.printtofile=Imprimir em arquivo
+dialog.noprintermsg=Nenhum servi\u00e7o de impress\u00e3o encontrado.
+dialog.writeerror=N\u00e3o \u00e9 poss\u00edvel gravar no arquivo:
+#
+label.info=Info:
+label.jobname=Nome do trabalho:
+label.jobname.mnemonic=J
+label.numcopies=N\u00famero de c\u00f3pias:
+label.numcopies.mnemonic=O
+label.priority=Prioridade:
+label.priority.mnemonic=R
+label.psname=Nome:
+label.psname.mnemonic=N
+label.pstype=Tipo:
+label.rangeto=Para
+label.size=Tamanho:
+label.size.mnemonic=Z
+label.source=Fonte:
+label.source.mnemonic=C
+label.status=Status:
+label.username=Nome de usu\u00e1rio:
+label.username.mnemonic=U
+label.millimetres=(mm)
+label.inches=(pol)
+label.topmargin=superior
+label.topmargin.mnemonic=T
+label.bottommargin=inferior
+label.bottommargin.mnemonic=B
+label.leftmargin=esquerda
+label.leftmargin.mnemonic=F
+label.rightmargin=direita
+label.rightmargin.mnemonic=R
+#
+radiobutton.color=Cor
+radiobutton.color.mnemonic=C
+radiobutton.draftq=Rascunho
+radiobutton.draftq.mnemonic=F
+radiobutton.duplex=Duplex
+radiobutton.duplex.mnemonic=D
+radiobutton.highq=Alto
+radiobutton.highq.mnemonic=H
+radiobutton.landscape=Paisagem
+radiobutton.landscape.mnemonic=L
+radiobutton.monochrome=Monocrom\u00e1tico
+radiobutton.monochrome.mnemonic=M
+radiobutton.normalq=Normal
+radiobutton.normalq.mnemonic=N
+radiobutton.oneside=Um lado
+radiobutton.oneside.mnemonic=O
+radiobutton.portrait=Retrato
+radiobutton.portrait.mnemonic=P
+radiobutton.rangeall=Todas
+radiobutton.rangeall.mnemonic=L
+radiobutton.rangepages=P\u00e1ginas
+radiobutton.rangepages.mnemonic=E
+radiobutton.revlandscape=Paisagem invertida
+radiobutton.revlandscape.mnemonic=N
+radiobutton.revportrait=Retrato invertido
+radiobutton.revportrait.mnemonic=I
+radiobutton.tumble=Duplex horizontal
+radiobutton.tumble.mnemonic=T
+# The vkMnemonics correspond with the constants defined in KeyEvent, eg
+# 65 = KeyEvent.VK_A
+tab.appearance=Apar\u00eancia
+tab.appearance.vkMnemonic=65
+tab.general=Geral
+tab.general.vkMnemonic=71
+tab.pagesetup=Configurar p\u00e1gina
+tab.pagesetup.vkMnemonic=83
+#
+error.pagerange=Intervalo de p\u00e1ginas inv\u00e1lido; insira novamente os valores (por exemplo, 1-3,5,7-10)
+error.destination=Nome de arquivo inv\u00e1lido; tente novamente
+#
+# The following keys match the Strings returned by MediaSizeName.toString()
+# (in some cases the space character is replaced by '-' and the pound 
+# character is replaced with 'n')
+#
+iso-4a0=4A0 (ISO/DIN & JIS)
+iso-2a0=2A0 (ISO/DIN & JIS)
+iso-a0=A0 (ISO/DIN & JIS)
+iso-a1=A1 (ISO/DIN & JIS)
+iso-a2=A2 (ISO/DIN & JIS)
+iso-a3=A3 (ISO/DIN & JIS)
+iso-a4=A4 (ISO/DIN & JIS)
+iso-a5=A5 (ISO/DIN & JIS)
+iso-a6=A6 (ISO/DIN & JIS)
+iso-a7=A7 (ISO/DIN & JIS)
+iso-a8=A8 (ISO/DIN & JIS)
+iso-a9=A9 (ISO/DIN & JIS)
+iso-a10=A10 (ISO/DIN & JIS)
+iso-b0=B0 (ISO/DIN)
+iso-b1=B1 (ISO/DIN)
+iso-b2=B2 (ISO/DIN)
+iso-b3=B3 (ISO/DIN)
+iso-b4=B4 (ISO/DIN)
+iso-b5=B5 (ISO/DIN)
+iso-b6=B6 (ISO/DIN)
+iso-b7=B7 (ISO/DIN)
+iso-b8=B8 (ISO/DIN)
+iso-b9=B9 (ISO/DIN)
+iso-b10=B10 (ISO/DIN)
+jis-b0=B0 (JIS)
+jis-b1=B1 (JIS)
+jis-b2=B2 (JIS)
+jis-b3=B3 (JIS)
+jis-b4=B4 (JIS)
+jis-b5=B5 (JIS)
+jis-b6=B6 (JIS)
+jis-b7=B7 (JIS)
+jis-b8=B8 (JIS)
+jis-b9=B9 (JIS)
+jis-b10=B10 (JIS)
+iso-c0=C0 (ISO/DIN)
+iso-c1=C1 (ISO/DIN)
+iso-c2=C2 (ISO/DIN)
+iso-c3=C3 (ISO/DIN)
+iso-c4=C4 (ISO/DIN)
+iso-c5=C5 (ISO/DIN)
+iso-c6=C6 (ISO/DIN)
+iso-c7=C7 (ISO/DIN)
+iso-c8=C8 (ISO/DIN)
+iso-c9=C9 (ISO/DIN)
+iso-c10=C10 (ISO/DIN)
+na-letter=Carta
+na-legal=Of\u00edcio
+executive=Executivo
+ledger=Livro-raz\u00e3o
+tabloid=Tabl\u00f3ide
+invoice=Fatura
+folio=F\u00f3lio
+quarto=Quarto
+japanese-postcard=Cart\u00e3o-postal (JIS)
+oufuko-postcard=Cart\u00e3o-postal (JIS)
+a=Engenharia A
+b=Engenharia B
+c=Engenharia C
+d=Engenharia D
+e=Engenharia E
+iso-designated-long=Longo designado ISO
+italian-envelope=Envelope italiano
+italy-envelope=Envelope italiano
+invite-envelope=Envelope de convite
+monarch-envelope=Envelope monarca
+personal-envelope=Envelope personalizado
+na-number-9-envelope=Envelope n\u00ba 9
+na-number-10-envelope=Envelope n\u00ba 10
+na-number-11-envelope=Envelope n\u00ba 11
+na-number-12-envelope=Envelope n\u00ba 12
+na-number-14-envelope=Envelope n\u00ba 14
+na-6x9-envelope=Envelope 6x9
+na-7x9-envelope=Envelope 6x7
+na-9x11-envelope=Envelope 9x11
+na-9x12-envelope=Envelope 9x12
+na-10x13-envelope=Envelope 10x15
+na-10x14-envelope=Envelope 10x15
+na-10x15-envelope=Envelope 10x15
+na-5x7=Papel 5" x 7"
+na-8x10=Papel 8" x 10"
+#
+# The following keys match the Strings returned by MediaTray.toString()
+#
+auto-select=Selecionar automaticamente
+top=Superior
+middle=Meio
+bottom=Inferior
+envelope=Envelope
+manual=Manual
+large-capacity=Grande capacidade
+main=Principal
+side=Lado
+# Add the additional standard bins defined by win32
+Manual-Envelope=Envelope manual
+Automatic-Feeder=Alimentador autom\u00e1tico
+Tractor-Feeder=Alimentador por tracionador
+Small-Format=Formato pequeno
+Large-Format=Formato grande
+Cassette=Cassete
+Form-Source=Fonte do formul\u00e1rio
+#
+# The following keys match the Strings returned by 
+# PrinterIsAcceptingJobs.toString()
+#
+accepting-jobs=Aceitando trabalhos
+not-accepting-jobs=N\u00e3o aceitando trabalhos
diff --git a/jdk/src/share/classes/sun/rmi/registry/resources/rmiregistry_pt_BR.properties b/jdk/src/share/classes/sun/rmi/registry/resources/rmiregistry_pt_BR.properties
new file mode 100644
index 0000000000000000000000000000000000000000..4f1673a3dc7ed6d30d80eff8ad0df03e5b6a88a0
--- /dev/null
+++ b/jdk/src/share/classes/sun/rmi/registry/resources/rmiregistry_pt_BR.properties
@@ -0,0 +1,28 @@
+#
+#
+# Copyright (c) 1999, 2005, 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.
+#
+
+rmiregistry.usage=Uso: {0}  \n\nem que  inclui:\n  -J passa o argumento para o int\u00e9rprete de java
+rmiregistry.port.badnumber=o argumento da porta, {0}, n\u00e3o \u00e9 um n\u00famero.
diff --git a/jdk/src/share/classes/sun/rmi/rmic/resources/rmic.properties b/jdk/src/share/classes/sun/rmi/rmic/resources/rmic.properties
index d92ba227ab70fd956555cc832e9186dcafbc09b3..a01e5fbda0704d5dd438874c0a1d4285835fd1c7 100644
--- a/jdk/src/share/classes/sun/rmi/rmic/resources/rmic.properties
+++ b/jdk/src/share/classes/sun/rmi/rmic/resources/rmic.properties
@@ -100,8 +100,8 @@ rmic.usage=Usage: {0}  \
 \n  -bootclasspath   Override location of bootstrap class files\
 \n  -extdirs         Override location of installed extensions\
 \n  -d          Specify where to place generated class files\
-\n  -J       Pass argument to the java interpreter
-\n\
+\n  -J       Pass argument to the java interpreter\
+\n
 
 #
 # Generic Messages
diff --git a/jdk/src/share/classes/sun/rmi/rmic/resources/rmic_ja.properties b/jdk/src/share/classes/sun/rmi/rmic/resources/rmic_ja.properties
index a47d866f1b1b6ba9b194ebd110e5bd55c3ee8aa3..5261d0d36e8cfadcf22e67b698f3ff931f9addcb 100644
--- a/jdk/src/share/classes/sun/rmi/rmic/resources/rmic_ja.properties
+++ b/jdk/src/share/classes/sun/rmi/rmic/resources/rmic_ja.properties
@@ -100,8 +100,8 @@ rmic.usage=\u4f7f\u3044\u65b9: {0}  \
 \n  -bootclasspath   \u30d6\u30fc\u30c8\u30b9\u30c8\u30e9\u30c3\u30d7\u30af\u30e9\u30b9\u30d5\u30a1\u30a4\u30eb\u306e\u4f4d\u7f6e\u3092\u7f6e\u304d\u63db\u3048\u308b\
 \n  -extdirs         \u30a4\u30f3\u30b9\u30c8\u30fc\u30eb\u6e08\u307f\u62e1\u5f35\u6a5f\u80fd\u306e\u4f4d\u7f6e\u3092\u7f6e\u304d\u63db\u3048\u308b\
 \n  -d          \u751f\u6210\u3055\u308c\u305f\u30af\u30e9\u30b9\u30d5\u30a1\u30a4\u30eb\u3092\u683c\u7d0d\u3059\u308b\u4f4d\u7f6e\u3092\u6307\u5b9a\u3059\u308b\
-\n  -J    java \u30a4\u30f3\u30bf\u30d7\u30ea\u30bf\u306b\u5f15\u6570\u3092\u6e21\u3059
-\n\
+\n  -J    java \u30a4\u30f3\u30bf\u30d7\u30ea\u30bf\u306b\u5f15\u6570\u3092\u6e21\u3059\
+\n
 
 #
 # Generic Messages
diff --git a/jdk/src/share/classes/sun/rmi/rmic/resources/rmic_zh_CN.properties b/jdk/src/share/classes/sun/rmi/rmic/resources/rmic_zh_CN.properties
index 0792dbc47243a530117e0b40fee7e6490f1c7eec..7112eaeb8df3b8f13b5d34edefc734dfeb821fea 100644
--- a/jdk/src/share/classes/sun/rmi/rmic/resources/rmic_zh_CN.properties
+++ b/jdk/src/share/classes/sun/rmi/rmic/resources/rmic_zh_CN.properties
@@ -100,8 +100,8 @@ rmic.usage=\u7528\u6cd5\uff1a{0} <\u9009\u9879> <\u7c7b\u540d\u79f0>\
 \n  -bootclasspath <\u8def\u5f84>  \u8986\u76d6\u5f15\u5bfc\u7c7b\u6587\u4ef6\u7684\u4f4d\u7f6e\
 \n  -extdirs <\u8def\u5f84>        \u8986\u76d6\u5b89\u88c5\u7684\u6269\u5c55\u76ee\u5f55\u7684\u4f4d\u7f6e\
 \n  -d <\u76ee\u5f55>              \u6307\u5b9a\u5b58\u653e\u751f\u6210\u7684\u7c7b\u6587\u4ef6\u7684\u4f4d\u7f6e\
-\n  -J <\u8fd0\u884c\u65f6\u6807\u5fd7>        \u5411 java \u89e3\u91ca\u7a0b\u5e8f\u4f20\u9012\u53c2\u6570
-\n\
+\n  -J <\u8fd0\u884c\u65f6\u6807\u5fd7>        \u5411 java \u89e3\u91ca\u7a0b\u5e8f\u4f20\u9012\u53c2\u6570\
+\n
 
 #
 # Generic Messages
diff --git a/jdk/src/share/classes/sun/rmi/server/resources/rmid_pt_BR.properties b/jdk/src/share/classes/sun/rmi/server/resources/rmid_pt_BR.properties
new file mode 100644
index 0000000000000000000000000000000000000000..781b28588bcc6d1d91161563bf1acb3068a5007f
--- /dev/null
+++ b/jdk/src/share/classes/sun/rmi/server/resources/rmid_pt_BR.properties
@@ -0,0 +1,96 @@
+#
+#
+# Copyright (c) 1999, 2005, 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.
+#
+
+# "rmid", inetd", and "wait" should not be translated.
+rmid.syntax.exec.invalid=rmid foi iniciado de inetd com um status inv\u00e1lido (deve  estar em espera)
+
+# "rmid" and "inetd" should not be translated.
+rmid.syntax.port.badarg=a porta n\u00e3o pode ser especificada se rmid for iniciado de inetd
+
+# "port" here refers to a TCP port for the server to listen on.
+rmid.syntax.port.badnumber=a porta n\u00e3o \u00e9 um n\u00famero
+
+# "-port" should not be translated, because it's part of command syntax.
+rmid.syntax.port.missing=a op\u00e7\u00e3o -port requer argumento
+
+# "-log" should not be translated, because it's part of command syntax.
+rmid.syntax.log.missing=a op\u00e7\u00e3o -log requer argumento
+
+# "-log" should not be translated, because it's part of command syntax.
+rmid.syntax.log.required=op\u00e7\u00e3o -log necess\u00e1ria
+
+# {0} = the (string) illegal argument in question
+rmid.syntax.illegal.option=op\u00e7\u00e3o ilegal: {0}
+
+# {0} = the (string) reason text that came with a thrown exception
+# "Activation.main" should not be translated, because it's a codepoint
+rmid.unexpected.exception=Activation.main: ocorreu uma exce\u00e7\u00e3o: {0}
+
+# "java.home" should not be translated, because it's a property name
+# "ActivatorImpl" should not be translated, because it's a codepoint
+rmid.unfound.java.home.property=ActivatorImpl: n\u00e3o \u00e9 poss\u00edvel localizar java.home
+
+# "rmid" should not be translated
+rmid.inherited.channel.info=inicializa\u00e7\u00e3o de rmid com canal legado
+
+# "Activation.main" should not be translated, because it's a codepoint
+rmid.exec.policy.invalid=Activation.main: classe de pol\u00edtica de execu\u00e7\u00e3o inv\u00e1lida
+
+# "rmid" should not be translated
+rmid.exec.policy.exception=rmid: a tentativa de obter a pol\u00edtica de execu\u00e7\u00e3o gera:
+
+# "rmid" should not be translated
+rmid.exec.command=rmid: debugExec: executando "{0}"
+
+# "rmid" should not be translated
+rmid.group.inactive=rmid: grupo de ativa\u00e7\u00e3o inativo: {0}
+
+# "Activation.main", "sun.rmi.activation.execPolicy", "ExecPermission" and 
+# "ExecOptionPermission" should not be translated, since they refer to
+# class/permission names.
+rmid.exec.perms.inadequate=Activation.main: aviso: propriedade do sistema sun.rmi.activation.execPolicy\nn\u00e3o registrada e nenhuma ExecPermission/ExecOptionPermission\nconcedida; as tentativas de ativa\u00e7\u00e3o seguintes podem falhar devido a verifica\u00e7\u00f5es mal sucedidas da permiss\u00e3o\nExecPermission/ExecOptionPermission.  Para obter\ndocumenta\u00e7\u00e3o sobre como configurar a seguran\u00e7a rmid, conculte:\n\nhttp://java.sun.com/j2se/1.4/docs/tooldocs/solaris/rmid.html\nhttp://java.sun.com/j2se/1.4/docs/tooldocs/win32/rmid.html\n
+
+# "rmid", "-port", "-log", "-stop", "-C" and "-J" should not be translated,
+# because they are syntax
+rmid.usage=Uso: {0} \n\nem que  inclui:\n  -port         especifica a porta que rmid usar\u00e1\n  -log     especifica o diret\u00f3rio no qual o rmid grava o registro\n  -stop               para a chamada atual de rmid (para a porta especificada)\n  -C    passa o argumento para cada processo filho (grupo de ativa\u00e7\u00e3o)\n  -J    passa o argumento para o int\u00e9rprete de java\n
+# This means "The currently running activation daemon has been shut down,
+# and is about to exit".
+rmid.daemon.shutdown=encerramento do daemon de ativa\u00e7\u00e3o
+
+# "rmid" should not be translated
+rmid.restart.group.warning=\nrmid: (AVISO) reiniciar grupo gera:
+
+# "rmid" should not be translated
+rmid.restart.service.warning=\nrmid: (AVISO) reiniciar servi\u00e7o gera:
+
+# "rmid" should not be translated
+rmid.log.update.warning=\nrmid: (AVISO) registrar atualiza\u00e7\u00e3o gera:
+
+# "rmid" should not be translated
+rmid.log.snapshot.warning=\nrmid: (GRAVE) registrar instant\u00e2neo gera:
+
+# "rmid" should not be translated
+rmid.log.recover.warning=\nrmid: (AVISO) {0}: ignorando registro durante a recupera\u00e7\u00e3o:
diff --git a/jdk/src/share/classes/sun/security/provider/SeedGenerator.java b/jdk/src/share/classes/sun/security/provider/SeedGenerator.java
index ecf132044aad75724102206041a76e693694ad85..d66181a614925f4dc9a1cc200a185e073b685145 100644
--- a/jdk/src/share/classes/sun/security/provider/SeedGenerator.java
+++ b/jdk/src/share/classes/sun/security/provider/SeedGenerator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1996, 2009, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 2010, 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
@@ -138,13 +138,7 @@ abstract class SeedGenerator {
         instance.getSeedBytes(result);
     }
 
-    void getSeedBytes(byte[] result) {
-        for (int i = 0; i < result.length; i++) {
-          result[i] = getSeedByte();
-        }
-    }
-
-    abstract byte getSeedByte();
+    abstract void getSeedBytes(byte[] result);
 
     /**
      * Retrieve some system information, hashed.
@@ -369,6 +363,13 @@ abstract class SeedGenerator {
             }
         }
 
+        @Override
+        void getSeedBytes(byte[] result) {
+            for (int i = 0; i < result.length; i++) {
+                result[i] = getSeedByte();
+            }
+        }
+
         byte getSeedByte() {
             byte b = 0;
 
@@ -455,8 +456,7 @@ abstract class SeedGenerator {
     static class URLSeedGenerator extends SeedGenerator {
 
         private String deviceName;
-        private BufferedInputStream devRandom;
-
+        private InputStream devRandom;
 
         /**
          * The constructor is only called once to construct the one
@@ -465,7 +465,7 @@ abstract class SeedGenerator {
          */
 
         URLSeedGenerator(String egdurl) throws IOException {
-            if (egdurl == null) {
+        if (egdurl == null) {
                 throw new IOException("No random source specified");
             }
             deviceName = egdurl;
@@ -478,41 +478,78 @@ abstract class SeedGenerator {
 
         private void init() throws IOException {
             final URL device = new URL(deviceName);
-            devRandom = java.security.AccessController.doPrivileged
-                (new java.security.PrivilegedAction() {
-                        public BufferedInputStream run() {
-                            try {
-                                return new BufferedInputStream(device.openStream());
-                            } catch (IOException ioe) {
-                                return null;
+            try {
+                devRandom = java.security.AccessController.doPrivileged
+                    (new java.security.PrivilegedExceptionAction() {
+                        public InputStream run() throws IOException {
+                            /*
+                             * return a FileInputStream for file URLs and
+                             * avoid buffering. The openStream() call wraps
+                             * InputStream in a BufferedInputStream which
+                             * can buffer up to 8K bytes. This read is a
+                             * performance issue for entropy sources which
+                             * can be slow to replenish.
+                             */
+                            if (device.getProtocol().equalsIgnoreCase("file")) {
+                                File deviceFile = getDeviceFile(device);
+                                return new FileInputStream(deviceFile);
+                            } else {
+                                return device.openStream();
                             }
                         }
                     });
+            } catch (Exception e) {
+                throw new IOException("Failed to open " + deviceName, e.getCause());
+            }
+        }
 
-            if (devRandom == null) {
-                throw new IOException("failed to open " + device);
+        /*
+         * Use a URI to access this File. Previous code used a URL
+         * which is less strict on syntax. If we encounter a
+         * URISyntaxException we make best efforts for backwards
+         * compatibility. e.g. space character in deviceName string.
+         *
+         * Method called within PrivilegedExceptionAction block.
+         */
+        private File getDeviceFile(URL device) throws IOException {
+            try {
+                URI deviceURI = device.toURI();
+                if(deviceURI.isOpaque()) {
+                    // File constructor does not accept opaque URI
+                    URI localDir = new File(System.getProperty("user.dir")).toURI();
+                    String uriPath = localDir.toString() +
+                                         deviceURI.toString().substring(5);
+                    return new File(URI.create(uriPath));
+                } else {
+                    return new File(deviceURI);
+                }
+            } catch (URISyntaxException use) {
+                /*
+                 * Make best effort to access this File.
+                 * We can try using the URL path.
+                 */
+                return new File(device.getPath());
             }
         }
 
-        byte getSeedByte() {
-            byte b[] = new byte[1];
-            int stat;
+        @Override
+        void getSeedBytes(byte[] result) {
+            int len = result.length;
+            int read = 0;
             try {
-                stat = devRandom.read(b, 0, b.length);
+                while (read < len) {
+                    int count = devRandom.read(result, read, len - read);
+                    // /dev/random blocks - should never have EOF
+                    if (count < 0)
+                        throw new InternalError("URLSeedGenerator " + deviceName +
+                                        " reached end of file");
+                    read += count;
+                }
             } catch (IOException ioe) {
                 throw new InternalError("URLSeedGenerator " + deviceName +
                                         " generated exception: " +
                                         ioe.getMessage());
             }
-            if (stat == b.length) {
-                return b[0];
-            } else if (stat == -1) {
-                throw new InternalError("URLSeedGenerator " + deviceName +
-                                           " reached end of file");
-            } else {
-                throw new InternalError("URLSeedGenerator " + deviceName +
-                                           " failed read");
-            }
         }
 
     }
diff --git a/jdk/src/share/classes/sun/security/rsa/RSASignature.java b/jdk/src/share/classes/sun/security/rsa/RSASignature.java
index 74a42c0a3f5bfb6497dc151816285cf9e527f4fc..c510413a2151733b3a4cd1104be3360147b5ffad 100644
--- a/jdk/src/share/classes/sun/security/rsa/RSASignature.java
+++ b/jdk/src/share/classes/sun/security/rsa/RSASignature.java
@@ -185,6 +185,11 @@ public abstract class RSASignature extends SignatureSpi {
 
     // verify the data and return the result. See JCA doc
     protected boolean engineVerify(byte[] sigBytes) throws SignatureException {
+        if (sigBytes.length != RSACore.getByteLength(publicKey)) {
+            throw new SignatureException("Signature length not correct: got " +
+                    sigBytes.length + " but was expecting " +
+                    RSACore.getByteLength(publicKey));
+        }
         byte[] digest = getDigestValue();
         try {
             byte[] decrypted = RSACore.rsa(sigBytes, publicKey);
diff --git a/jdk/src/share/classes/sun/security/ssl/RSAClientKeyExchange.java b/jdk/src/share/classes/sun/security/ssl/RSAClientKeyExchange.java
index b9528df5146a86df15e14c4a3ec509d9f0c9848f..1c0d6921091962a28f1194aa53f0d8402c06d4d3 100644
--- a/jdk/src/share/classes/sun/security/ssl/RSAClientKeyExchange.java
+++ b/jdk/src/share/classes/sun/security/ssl/RSAClientKeyExchange.java
@@ -103,7 +103,8 @@ final class RSAClientKeyExchange extends HandshakeMessage {
             String s = ((protocolVersion.v >= ProtocolVersion.TLS12.v) ?
                 "SunTls12RsaPremasterSecret" : "SunTlsRsaPremasterSecret");
             KeyGenerator kg = JsseJce.getKeyGenerator(s);
-            kg.init(new TlsRsaPremasterSecretParameterSpec(major, minor));
+            kg.init(new TlsRsaPremasterSecretParameterSpec(major, minor),
+                    generator);
             preMaster = kg.generateKey();
 
             Cipher cipher = JsseJce.getCipher(JsseJce.CIPHER_RSA_PKCS1);
diff --git a/jdk/src/share/classes/sun/security/tools/JarSigner.java b/jdk/src/share/classes/sun/security/tools/JarSigner.java
index 89b9c7e75d739af18b5393a5b892cc239032acd2..03809d37812182380d614733938569d2c8a36b52 100644
--- a/jdk/src/share/classes/sun/security/tools/JarSigner.java
+++ b/jdk/src/share/classes/sun/security/tools/JarSigner.java
@@ -658,7 +658,9 @@ public class JarSigner {
                     boolean inScope = (inStoreOrScope & IN_SCOPE) != 0;
 
                     notSignedByAlias |= (inStoreOrScope & NOT_ALIAS) != 0;
-                    aliasNotInStore |= isSigned && (!inStore && !inScope);
+                    if (keystore != null) {
+                        aliasNotInStore |= isSigned && (!inStore && !inScope);
+                    }
 
                     // Only used when -verbose provided
                     StringBuffer sb = null;
@@ -723,7 +725,7 @@ public class JarSigner {
                         if (signatureRelated(name)) {
                             // Entries inside META-INF and other unsigned
                             // entries are grouped separately.
-                            label = "-" + label.substring(1);
+                            label = "-" + label;
                         }
 
                         // The label finally contains 2 parts separated by '|':
@@ -752,7 +754,7 @@ public class JarSigner {
                     List files = s.getValue();
                     String key = s.getKey();
                     if (key.charAt(0) == '-') { // the signature-related group
-                        key = ' ' + key.substring(1);
+                        key = key.substring(1);
                     }
                     int pipe = key.indexOf('|');
                     if (verbose.equals("all")) {
@@ -889,7 +891,7 @@ public class JarSigner {
      * Note: no newline character at the end
      */
     String printCert(String tab, Certificate c, boolean checkValidityPeriod,
-        long now) {
+        long now, boolean checkUsage) {
 
         StringBuilder certStr = new StringBuilder();
         String space = rb.getString("SPACE");
@@ -959,24 +961,26 @@ public class JarSigner {
             }
             certStr.append("]");
 
-            boolean[] bad = new boolean[3];
-            checkCertUsage(x509Cert, bad);
-            if (bad[0] || bad[1] || bad[2]) {
-                String x = "";
-                if (bad[0]) {
-                    x ="KeyUsage";
-                }
-                if (bad[1]) {
-                    if (x.length() > 0) x = x + ", ";
-                    x = x + "ExtendedKeyUsage";
-                }
-                if (bad[2]) {
-                    if (x.length() > 0) x = x + ", ";
-                    x = x + "NetscapeCertType";
-                }
-                certStr.append("\n").append(tab)
+            if (checkUsage) {
+                boolean[] bad = new boolean[3];
+                checkCertUsage(x509Cert, bad);
+                if (bad[0] || bad[1] || bad[2]) {
+                    String x = "";
+                    if (bad[0]) {
+                        x ="KeyUsage";
+                    }
+                    if (bad[1]) {
+                        if (x.length() > 0) x = x + ", ";
+                        x = x + "ExtendedKeyUsage";
+                    }
+                    if (bad[2]) {
+                        if (x.length() > 0) x = x + ", ";
+                        x = x + "NetscapeCertType";
+                    }
+                    certStr.append("\n").append(tab)
                         .append(MessageFormat.format(rb.getString(
                         ".{0}.extension.does.not.support.code.signing."), x));
+                }
             }
         }
         return certStr.toString();
@@ -1335,7 +1339,7 @@ public class JarSigner {
                             certUrl);
                     }
                     System.out.println(rb.getString("TSA.certificate.") +
-                        printCert("", tsaCert, false, 0));
+                        printCert("", tsaCert, false, 0, false));
                 }
                 if (signingMechanism != null) {
                     System.out.println(
@@ -1544,10 +1548,13 @@ public class JarSigner {
             s.append(printTimestamp(tab, timestamp));
             s.append('\n');
         }
-        // display the certificate(s)
+        // display the certificate(s). The first one is end-enity cert and
+        // its KeyUsage should be checked.
+        boolean first = true;
         for (Certificate c : certs) {
-            s.append(printCert(tab, c, true, now));
+            s.append(printCert(tab, c, true, now, first));
             s.append('\n');
+            first = false;
         }
         try {
             CertPath cp = certificateFactory.generateCertPath(certs);
@@ -1847,7 +1854,7 @@ public class JarSigner {
 
             // We don't meant to print anything, the next call
             // checks validity and keyUsage etc
-            printCert("", certChain[0], true, 0);
+            printCert("", certChain[0], true, 0, true);
 
             try {
                 CertPath cp = certificateFactory.generateCertPath(Arrays.asList(certChain));
diff --git a/jdk/src/share/classes/sun/security/tools/policytool/PolicyTool.java b/jdk/src/share/classes/sun/security/tools/policytool/PolicyTool.java
index e04316317a880e7daa6d9302b7659678d22dc613..f310504a2047b1dbc2ad6a80fe32bf9cd182197b 100644
--- a/jdk/src/share/classes/sun/security/tools/policytool/PolicyTool.java
+++ b/jdk/src/share/classes/sun/security/tools/policytool/PolicyTool.java
@@ -49,7 +49,7 @@ import javax.security.auth.x500.X500Principal;
 /**
  * PolicyTool may be used by users and administrators to configure the
  * overall java security policy (currently stored in the policy file).
- * Using PolicyTool administators may add and remove policies from
+ * Using PolicyTool administrators may add and remove policies from
  * the policy file. 
      
  *
  * @see java.security.Policy
@@ -1343,11 +1343,6 @@ class ToolDialog extends Dialog {
       PolicyTool.rb.getString
       ("Actions.");
 
-    /* gridbag index for display OverWriteFile (OW) components */
-    public static final int OW_LABEL                    = 0;
-    public static final int OW_OK_BUTTON                = 1;
-    public static final int OW_CANCEL_BUTTON            = 2;
-
     /* gridbag index for display PolicyEntry (PE) components */
     public static final int PE_CODEBASE_LABEL           = 0;
     public static final int PE_CODEBASE_TEXTFIELD       = 1;
@@ -1522,44 +1517,6 @@ class ToolDialog extends Dialog {
         return null;
     }
 
-    /**
-     * ask user if they want to overwrite an existing file
-     */
-    void displayOverWriteFileDialog(String filename, int nextEvent) {
-
-        // find where the PolicyTool gui is
-        Point location = tw.getLocationOnScreen();
-        setBounds(location.x + 75, location.y + 100, 400, 150);
-        setLayout(new GridBagLayout());
-
-        // ask the user if they want to over write the existing file
-        MessageFormat form = new MessageFormat(PolicyTool.rb.getString
-                ("OK.to.overwrite.existing.file.filename."));
-        Object[] source = {filename};
-        Label label = new Label(form.format(source));
-        tw.addNewComponent(this, label, OW_LABEL,
-                           0, 0, 2, 1, 0.0, 0.0, GridBagConstraints.BOTH,
-                           tw.TOP_PADDING);
-
-        // OK button
-        Button button = new Button(PolicyTool.rb.getString("OK"));
-        button.addActionListener(new OverWriteFileOKButtonListener
-                (tool, tw, this, filename, nextEvent));
-        tw.addNewComponent(this, button, OW_OK_BUTTON,
-                           0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
-                           tw.TOP_PADDING);
-
-        // Cancel button
-        // -- if the user hits cancel, do NOT go on to the next event
-        button = new Button(PolicyTool.rb.getString("Cancel"));
-        button.addActionListener(new CancelButtonListener(this));
-        tw.addNewComponent(this, button, OW_CANCEL_BUTTON,
-                           1, 1, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
-                           tw.TOP_PADDING);
-
-        setVisible(true);
-    }
-
     /**
      * pop up a dialog so the user can enter info to add a new PolicyEntry
      * - if edit is TRUE, then the user is editing an existing entry
@@ -2339,47 +2296,39 @@ class ToolDialog extends Dialog {
             return;
 
         // get the entered filename
-        String filename = new String(fd.getDirectory() + fd.getFile());
+        File saveAsFile = new File(fd.getDirectory(), fd.getFile());
+        String filename = saveAsFile.getPath();
         fd.dispose();
 
-        // see if the file already exists
-        File saveAsFile = new File(filename);
-        if (saveAsFile.exists()) {
-            // display a dialog box for the user to enter policy info
-            ToolDialog td = new ToolDialog
-                (PolicyTool.rb.getString("Overwrite.File"), tool, tw, true);
-            td.displayOverWriteFileDialog(filename, nextEvent);
-        } else {
-            try {
-                // save the policy entries to a file
-                tool.savePolicy(filename);
+        try {
+            // save the policy entries to a file
+            tool.savePolicy(filename);
 
-                // display status
-                MessageFormat form = new MessageFormat(PolicyTool.rb.getString
-                        ("Policy.successfully.written.to.filename"));
-                Object[] source = {filename};
-                tw.displayStatusDialog(null, form.format(source));
+            // display status
+            MessageFormat form = new MessageFormat(PolicyTool.rb.getString
+                    ("Policy.successfully.written.to.filename"));
+            Object[] source = {filename};
+            tw.displayStatusDialog(null, form.format(source));
 
-                // display the new policy filename
-                TextField newFilename = (TextField)tw.getComponent
-                                (tw.MW_FILENAME_TEXTFIELD);
-                newFilename.setText(filename);
-                tw.setVisible(true);
+            // display the new policy filename
+            TextField newFilename = (TextField)tw.getComponent
+                            (tw.MW_FILENAME_TEXTFIELD);
+            newFilename.setText(filename);
+            tw.setVisible(true);
 
-                // now continue with the originally requested command
-                // (QUIT, NEW, or OPEN)
-                userSaveContinue(tool, tw, this, nextEvent);
+            // now continue with the originally requested command
+            // (QUIT, NEW, or OPEN)
+            userSaveContinue(tool, tw, this, nextEvent);
 
-            } catch (FileNotFoundException fnfe) {
-                if (filename == null || filename.equals("")) {
-                    tw.displayErrorDialog(null, new FileNotFoundException
-                                (PolicyTool.rb.getString("null.filename")));
-                } else {
-                    tw.displayErrorDialog(null, fnfe);
-                }
-            } catch (Exception ee) {
-                tw.displayErrorDialog(null, ee);
+        } catch (FileNotFoundException fnfe) {
+            if (filename == null || filename.equals("")) {
+                tw.displayErrorDialog(null, new FileNotFoundException
+                            (PolicyTool.rb.getString("null.filename")));
+            } else {
+                tw.displayErrorDialog(null, fnfe);
             }
+        } catch (Exception ee) {
+            tw.displayErrorDialog(null, ee);
         }
     }
 
@@ -2494,7 +2443,7 @@ class ToolDialog extends Dialog {
                 return;
 
             // get the entered filename
-            String policyFile = new String(fd.getDirectory() + fd.getFile());
+            String policyFile = new File(fd.getDirectory(), fd.getFile()).getPath();
 
             try {
                 // open the policy file
@@ -2861,67 +2810,6 @@ class MainWindowListener implements ActionListener {
     }
 }
 
-/**
- * Event handler for OverWriteFileOKButton button
- */
-class OverWriteFileOKButtonListener implements ActionListener {
-
-    private PolicyTool tool;
-    private ToolWindow tw;
-    private ToolDialog td;
-    private String filename;
-    private int nextEvent;
-
-    OverWriteFileOKButtonListener(PolicyTool tool, ToolWindow tw,
-                                ToolDialog td, String filename, int nextEvent) {
-        this.tool = tool;
-        this.tw = tw;
-        this.td = td;
-        this.filename = filename;
-        this.nextEvent = nextEvent;
-    }
-
-    public void actionPerformed(ActionEvent e) {
-        try {
-            // save the policy entries to a file
-            tool.savePolicy(filename);
-
-            // display status
-            MessageFormat form = new MessageFormat
-                (PolicyTool.rb.getString
-                ("Policy.successfully.written.to.filename"));
-            Object[] source = {filename};
-            tw.displayStatusDialog(null, form.format(source));
-
-            // display the new policy filename
-            TextField newFilename = (TextField)tw.getComponent
-                                (tw.MW_FILENAME_TEXTFIELD);
-            newFilename.setText(filename);
-            tw.setVisible(true);
-
-            // now continue with the originally requested command
-            // (QUIT, NEW, or OPEN)
-            td.setVisible(false);
-            td.dispose();
-            td.userSaveContinue(tool, tw, td, nextEvent);
-
-        } catch (FileNotFoundException fnfe) {
-            if (filename == null || filename.equals("")) {
-                tw.displayErrorDialog(null, new FileNotFoundException
-                                (PolicyTool.rb.getString("null.filename")));
-            } else {
-                tw.displayErrorDialog(null, fnfe);
-            }
-            td.setVisible(false);
-            td.dispose();
-        } catch (Exception ee) {
-            tw.displayErrorDialog(null, ee);
-            td.setVisible(false);
-            td.dispose();
-        }
-    }
-}
-
 /**
  * Event handler for AddEntryDoneButton button
  *
diff --git a/jdk/src/share/classes/sun/security/util/AuthResources_pt_BR.java b/jdk/src/share/classes/sun/security/util/AuthResources_pt_BR.java
new file mode 100644
index 0000000000000000000000000000000000000000..91e6e1307323bfaa64a9879e3b2d57f798a04bb1
--- /dev/null
+++ b/jdk/src/share/classes/sun/security/util/AuthResources_pt_BR.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2000, 2006, 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 sun.security.util;
+
+/**
+ * 
       This class represents the ResourceBundle
+ * for the following packages:
+ *
+ * 
        
+ * 
      1.  com.sun.security.auth
+ * 
      2.  com.sun.security.auth.login
+ * 
      
+ *
+ * @version 1.6, 01/23/01
+ */
+public class AuthResources_pt_BR extends java.util.ListResourceBundle {
+
+    private static final Object[][] contents = {
+
+    // NT principals
+    {"invalid null input: value", "entrada nula inv\u00e1lida: {0}"},
+    {"NTDomainPrincipal: name", "NTDomainPrincipal: {0}"},
+    {"NTNumericCredential: name", "NTNumericCredential: {0}"},
+    {"Invalid NTSid value", "Valor de NTSid inv\u00e1lido"},
+    {"NTSid: name", "NTSid: {0}"},
+    {"NTSidDomainPrincipal: name", "NTSidDomainPrincipal: {0}"},
+    {"NTSidGroupPrincipal: name", "NTSidGroupPrincipal: {0}"},
+    {"NTSidPrimaryGroupPrincipal: name", "NTSidPrimaryGroupPrincipal: {0}"},
+    {"NTSidUserPrincipal: name", "NTSidUserPrincipal: {0}"},
+    {"NTUserPrincipal: name", "NTUserPrincipal: {0}"},
+
+    // UnixPrincipals
+    {"UnixNumericGroupPrincipal [Primary Group]: name",
+        "UnixNumericGroupPrincipal [grupo principal]: {0}"},
+    {"UnixNumericGroupPrincipal [Supplementary Group]: name",
+        "UnixNumericGroupPrincipal [grupo complement\u00e1rio]: {0}"},
+    {"UnixNumericUserPrincipal: name", "UnixNumericUserPrincipal: {0}"},
+    {"UnixPrincipal: name", "UnixPrincipal: {0}"},
+
+    // com.sun.security.auth.login.ConfigFile
+    {"Unable to properly expand config", "N\u00e3o \u00e9 poss\u00edvel expandir corretamente {0}"},
+    {"extra_config (No such file or directory)",
+        "{0} (tal arquivo ou diret\u00f3rio n\u00e3o existe)"},
+    {"Unable to locate a login configuration",
+        "N\u00e3o \u00e9 poss\u00edvel localizar uma configura\u00e7\u00e3o de logon"},
+    {"Configuration Error:\n\tInvalid control flag, flag",
+        "Erro de configura\u00e7\u00e3o:\n\tSinalizador de controle inv\u00e1lido, {0}"},
+    {"Configuration Error:\n\tCan not specify multiple entries for appName",
+        "Erro de configura\u00e7\u00e3o:\n\tN\u00e3o \u00e9 poss\u00edvel especificar v\u00e1rias entradas para {0}"},
+    {"Configuration Error:\n\texpected [expect], read [end of file]",
+        "Erro de configura\u00e7\u00e3o:\n\tesperado [{0}], lido [fim do arquivo]"},
+    {"Configuration Error:\n\tLine line: expected [expect], found [value]",
+        "Erro de configura\u00e7\u00e3o:\n\tlinha {0}: esperado [{1}], encontrado [{2}]"},
+    {"Configuration Error:\n\tLine line: expected [expect]",
+        "Erro de configura\u00e7\u00e3o:\n\tlinha {0}: esperado [{1}]"},
+    {"Configuration Error:\n\tLine line: system property [value] expanded to empty value",
+        "Erro de configura\u00e7\u00e3o:\n\tlinha {0}: propriedade do sistema [{1}] expandida para valor vazio"},
+
+    // com.sun.security.auth.module.JndiLoginModule
+    {"username: ","nome de usu\u00e1rio: "},
+    {"password: ","senha: "},
+
+    // com.sun.security.auth.module.KeyStoreLoginModule
+    {"Please enter keystore information",
+        "Insira as informa\u00e7\u00f5es do armazenamento de chaves"},
+    {"Keystore alias: ","Alias do armazenamento de chaves: "},
+    {"Keystore password: ","Senha do armazenamento de chaves: "},
+    {"Private key password (optional): ",
+        "Senha da chave privada (opcional): "},
+
+    // com.sun.security.auth.module.Krb5LoginModule
+    {"Kerberos username [[defUsername]]: ",
+        "Nome de usu\u00e1rio de Kerberos [{0}]: "},
+    {"Kerberos password for [username]: ",
+            "Senha de Kerberos de {0}: "},
+
+    /***    EVERYTHING BELOW IS DEPRECATED    ***/
+
+    // com.sun.security.auth.PolicyFile
+    {": error parsing ", ": erro ao analisar "},
+    {": ", ": "},
+    {": error adding Permission ", ": erro ao adicionar permiss\u00e3o "},
+    {" ", " "},
+    {": error adding Entry ", ": erro ao adicionar entrada "},
+    {"(", "("},
+    {")", ")"},
+    {"attempt to add a Permission to a readonly PermissionCollection",
+        "tentativa de adicionar uma permiss\u00e3o ao um PermissionCollection de somente leitura"},
+
+    // com.sun.security.auth.PolicyParser
+    {"expected keystore type", "tipo de armazenamento de chaves esperado"},
+    {"can not specify Principal with a ",
+        "n\u00e3o \u00e9 poss\u00edvel especificar um principal com uma "},
+    {"wildcard class without a wildcard name",
+        "de coringa sem um nome de coringa"},
+    {"expected codeBase or SignedBy", "CodeBase ou SignedBy esperado"},
+    {"only Principal-based grant entries permitted",
+        "somente \u00e9 permitido conceder entradas com base no principal"},
+    {"expected permission entry", "entrada de permiss\u00e3o esperada"},
+    {"number ", "n\u00famero "},
+    {"expected ", "esperado "},
+    {", read end of file", ", fim de arquivo lido"},
+    {"expected ';', read end of file", "esperado ';', fim de arquivo lido"},
+    {"line ", "linha "},
+    {": expected '", ": esperado '"},
+    {"', found '", "', encontrado '"},
+    {"'", "'"},
+
+    // SolarisPrincipals
+    {"SolarisNumericGroupPrincipal [Primary Group]: ",
+        "SolarisNumericGroupPrincipal [grupo principal]: "},
+    {"SolarisNumericGroupPrincipal [Supplementary Group]: ",
+        "SolarisNumericGroupPrincipal [grupo complement\u00e1rio]: "},
+    {"SolarisNumericUserPrincipal: ",
+        "SolarisNumericUserPrincipal: "},
+    {"SolarisPrincipal: ", "SolarisPrincipal: "},
+    {"provided null name", "nome nulo fornecido"}
+
+    };
+
+    /**
+     * Returns the contents of this ResourceBundle.
+     *
+     * 
      
+     *
+     * @return the contents of this ResourceBundle.
+     */
+    public Object[][] getContents() {
+    return contents;
+    }
+}
diff --git a/jdk/src/share/classes/sun/security/util/ManifestEntryVerifier.java b/jdk/src/share/classes/sun/security/util/ManifestEntryVerifier.java
index 3952ccee86dbc85b3d145b787e8948e6cad9c38d..3bcc18a7456cb94f9a5965c8e361b17c417d8c48 100644
--- a/jdk/src/share/classes/sun/security/util/ManifestEntryVerifier.java
+++ b/jdk/src/share/classes/sun/security/util/ManifestEntryVerifier.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2010, 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
@@ -44,6 +44,16 @@ public class ManifestEntryVerifier {
 
     private static final Debug debug = Debug.getInstance("jar");
 
+    /**
+     * Holder class to lazily load Sun provider. NOTE: if
+     * Providers.getSunProvider returned a cached provider, we could avoid the
+     * need for caching the provider with this holder class; we should try to
+     * revisit this in JDK 8.
+     */
+    private static class SunProviderHolder {
+        private static final Provider instance = Providers.getSunProvider();
+    }
+
     /** the created digest objects */
     HashMap createdDigests;
 
@@ -125,7 +135,7 @@ public class ManifestEntryVerifier {
                     try {
 
                         digest = MessageDigest.getInstance
-                                        (algorithm, Providers.getSunProvider());
+                                        (algorithm, SunProviderHolder.instance);
                         createdDigests.put(algorithm, digest);
                     } catch (NoSuchAlgorithmException nsae) {
                         // ignore
@@ -185,7 +195,10 @@ public class ManifestEntryVerifier {
                 Hashtable sigFileSigners)
         throws JarException
     {
-        if (skip) return null;
+        // MANIFEST.MF should not be skipped. It has signers.
+        if (skip && !entry.getName().equals(JarFile.MANIFEST_NAME)) {
+            return null;
+        }
 
         if (signers != null)
             return signers;
diff --git a/jdk/src/share/classes/sun/security/util/Resources_fr.java b/jdk/src/share/classes/sun/security/util/Resources_fr.java
index c9000d332568e3f7fa4353371663bb4c35ffc73f..a3acbdbf4432434a41343626dbe4fa72c05a5637 100644
--- a/jdk/src/share/classes/sun/security/util/Resources_fr.java
+++ b/jdk/src/share/classes/sun/security/util/Resources_fr.java
@@ -50,9 +50,9 @@ public class Resources_fr extends java.util.ListResourceBundle {
         {"keytool error: ", "erreur keytool : "},
         {"Illegal option:  ", "Option non valide :  "},
         {"Try keytool -help","Essayez keytool -help"},
-        {"Command option  needs an argument.", "L'option de commande {0} requiert un argument."},
+        {"Command option  needs an argument.", "L''option de commande {0} requiert un argument."},
         {"Warning:  Different store and key passwords not supported for PKCS12 KeyStores. Ignoring user-specified  value.",
-                "Avertissement\u00a0:  Les mots de passe store et key distincts ne sont pas pris en charge pour les keystores PKCS12. La valeur {0} sp\u00e9cifi\u00e9e par l'utilisateur est ignor\u00e9e."},
+                "Avertissement\u00a0:  Les mots de passe store et key distincts ne sont pas pris en charge pour les keystores PKCS12. La valeur {0} sp\u00e9cifi\u00e9e par l''utilisateur est ignor\u00e9e."},
         {"-keystore must be NONE if -storetype is {0}",
                 "-keystore doit \u00eatre d\u00e9fini sur NONE si -storetype est {0}"},
         {"Too may retries, program terminated",
@@ -75,7 +75,7 @@ public class Resources_fr extends java.util.ListResourceBundle {
                 "La validit\u00e9 doit \u00eatre sup\u00e9rieure \u00e0 z\u00e9ro"},
         {"provName not a provider", "{0} n''est pas un fournisseur"},
         {"Usage error: no command provided", "Erreur d'utilisation\u00a0: aucune commande fournie"},
-        {"Usage error,  is not a legal command", "Erreur d'utilisation, {0} n'est pas une commande valide"},
+        {"Usage error,  is not a legal command", "Erreur d''utilisation, {0} n''est pas une commande valide"},
         {"Source keystore file exists, but is empty: ", "Le fichier du keystore source existe, mais il est vide\u00a0: "},
         {"Please specify -srckeystore", "veuillez sp\u00e9cifier -srckeystore"},
         {"Must not specify both -v and -rfc with 'list' command",
@@ -100,16 +100,16 @@ public class Resources_fr extends java.util.ListResourceBundle {
         {"Unknown Entry Type", "Type d'entr\u00e9e inconnu"},
         {"Too many failures. Alias not changed", "Trop d'erreurs. Alias non modifi\u00e9"},
         {"Entry for alias  successfully imported.",
-                 "L'entr\u00e9e de l'alias {0} a \u00e9t\u00e9 import\u00e9e."},
-        {"Entry for alias  not imported.", "L'entr\u00e9e de l'alias {0} n'a pas \u00e9t\u00e9 import\u00e9e."},
+                 "L''entr\u00e9e de l''alias {0} a \u00e9t\u00e9 import\u00e9e."},
+        {"Entry for alias  not imported.", "L''entr\u00e9e de l''alias {0} n''a pas \u00e9t\u00e9 import\u00e9e."},
         {"Problem importing entry for alias : .\nEntry for alias  not imported.",
-                 "Probl\u00e8me lors de l'importation de l'entr\u00e9e de l'alias {0}\u00a0: {1}.\nL'entr\u00e9e de l'alias {0} n'a pas \u00e9t\u00e9 import\u00e9e."},
+                 "Probl\u00e8me lors de l''importation de l''entr\u00e9e de l''alias {0}\u00a0: {1}.\nL''entr\u00e9e de l''alias {0} n''a pas \u00e9t\u00e9 import\u00e9e."},
         {"Import command completed:   entries successfully imported,  entries failed or cancelled",
-                 "Commande d'importation ex\u00e9cut\u00e9e\u00a0:  {0} entr\u00e9es import\u00e9es, \u00e9chec ou annulation de {1} entr\u00e9es"},
+                 "Commande d''importation ex\u00e9cut\u00e9e\u00a0:  {0} entr\u00e9es import\u00e9es, \u00e9chec ou annulation de {1} entr\u00e9es"},
         {"Warning: Overwriting existing alias  in destination keystore",
-                 "Avertissement\u00a0: L'alias existant {0} est \u00e9cras\u00e9 dans le keystore de destination"},
+                 "Avertissement\u00a0: L''alias existant {0} est \u00e9cras\u00e9 dans le keystore de destination"},
         {"Existing entry alias  exists, overwrite? [no]:  ",
-                 "L'alias d'entr\u00e9e {0} existe d\u00e9j\u00e0, voulez-vous l'\u00e9craser\u00a0? [non]\u00a0:  "},
+                 "L''alias d''entr\u00e9e {0} existe d\u00e9j\u00e0, voulez-vous l''\u00e9craser\u00a0? [non]\u00a0:  "},
         {"Too many failures - try later", "Trop d'erreurs - r\u00e9essayez plus tard"},
         {"Certification request stored in file ",
                 "Demande de certification enregistr\u00e9e dans le fichier <{0}>"},
@@ -167,7 +167,7 @@ public class Resources_fr extends java.util.ListResourceBundle {
         {"alias, keyStore.getCreationDate(alias), ",
                 "{0}, {1,date}, "},
         {"alias, ", "{0}, "},
-        {"Entry type: ", "Type d'entr\u00e9e\u00a0: {0}"},
+        {"Entry type: ", "Type d''entr\u00e9e\u00a0: {0}"},
         {"Certificate chain length: ", "Longueur de cha\u00eene du certificat : "},
         {"Certificate[(i + 1)]:", "Certificat[{0,number,integer}]:"},
         {"Certificate fingerprint (MD5): ", "Empreinte du certificat (MD5) : "},
@@ -213,7 +213,7 @@ public class Resources_fr extends java.util.ListResourceBundle {
         {"\t(RETURN if same as for )",
                 "\t(appuyez sur Entr\u00e9e si le r\u00e9sultat est identique \u00e0 <{0}>)"},
         {"*PATTERN* printX509Cert",
-                "Propri\u00e9taire\u00a0: {0}\n\u00c9metteur\u00a0: {1}\nNum\u00e9ro de s\u00e9rie\u00a0: {2}\nValide du\u00a0: {3} au\u00a0: {4}\nEmpreintes du certificat\u00a0:\n\t MD5\u00a0:  {5}\n\t SHA1\u00a0: {6}\n\t Nom de l'algorithme de signature\u00a0: {7}\n\t Version\u00a0: {8}"},
+                "Propri\u00e9taire\u00a0: {0}\n\u00c9metteur\u00a0: {1}\nNum\u00e9ro de s\u00e9rie\u00a0: {2}\nValide du\u00a0: {3} au\u00a0: {4}\nEmpreintes du certificat\u00a0:\n\t MD5\u00a0:  {5}\n\t SHA1\u00a0: {6}\n\t Nom de l''algorithme de signature\u00a0: {7}\n\t Version\u00a0: {8}"},
         {"What is your first and last name?",
                 "Quels sont vos pr\u00e9nom et nom ?"},
         {"What is the name of your organizational unit?",
@@ -232,9 +232,9 @@ public class Resources_fr extends java.util.ListResourceBundle {
         {"y", "o"},
         {"  [defaultValue]:  ", "  [{0}] :  "},
         {"Alias  has no key",
-                "L'alias <{0}> n'est associ\u00e9 \u00e0 aucune cl\u00e9"},
+                "L''alias <{0}> n''est associ\u00e9 \u00e0 aucune cl\u00e9"},
         {"Alias  references an entry type that is not a private key entry.  The -keyclone command only supports cloning of private key entries",
-                 "L'entr\u00e9e \u00e0 laquelle l'alias <{0}> fait r\u00e9f\u00e9rence n'est pas une entr\u00e9e de type cl\u00e9 priv\u00e9e.  La commande -keyclone prend uniquement en charge le clonage des cl\u00e9s priv\u00e9es"},
+                 "L''entr\u00e9e \u00e0 laquelle l''alias <{0}> fait r\u00e9f\u00e9rence n''est pas une entr\u00e9e de type cl\u00e9 priv\u00e9e.  La commande -keyclone prend uniquement en charge le clonage des cl\u00e9s priv\u00e9es"},
 
         {"*****************  WARNING WARNING WARNING  *****************",
             "*****************  A V E R T I S S E M E N T  *****************"},
@@ -441,7 +441,7 @@ public class Resources_fr extends java.util.ListResourceBundle {
         {"KeyStore", "KeyStore"},
         {"Policy File:", "Fichier de r\u00e8gles :"},
         {"Could not open policy file: policyFile: e.toString()",
-                "Impossible d'ouvrir le fichier de strat\u00e9gie\u00a0: {0}: {1}"},
+                "Impossible d''ouvrir le fichier de strat\u00e9gie\u00a0: {0}: {1}"},
         {"Policy Tool", "Policy Tool"},
         {"Errors have occurred while opening the policy configuration.  View the Warning Log for more information.",
                 "Des erreurs se sont produites \u00e0 l'ouverture de la configuration de r\u00e8gles. Consultez le journal des avertissements pour obtenir des informations."},
@@ -499,7 +499,7 @@ public class Resources_fr extends java.util.ListResourceBundle {
         {"Save Changes", "Enregistrer les changements"},
         {"No Policy Entry selected", "Aucune r\u00e8gle s\u00e9lectionn\u00e9e"},
         {"Unable to open KeyStore: ex.toString()",
-                "Impossible d'ouvrir le keystore\u00a0: {0}"},
+                "Impossible d''ouvrir le keystore\u00a0: {0}"},
         {"No principal selected", "Aucun principal s\u00e9lectionn\u00e9"},
         {"No permission selected", "Aucune permission s\u00e9lectionn\u00e9e"},
         {"name", "nom"},
diff --git a/jdk/src/share/classes/sun/security/util/Resources_it.java b/jdk/src/share/classes/sun/security/util/Resources_it.java
index 4d296010e21da96c34aef5222269cf25564fdb67..840e97a167c86bdc01aecc7e0783b5e7ea297308 100644
--- a/jdk/src/share/classes/sun/security/util/Resources_it.java
+++ b/jdk/src/share/classes/sun/security/util/Resources_it.java
@@ -50,9 +50,9 @@ public class Resources_it extends java.util.ListResourceBundle {
         {"keytool error: ", "Errore keytool: "},
         {"Illegal option:  ", "Opzione non valida:  "},
         {"Try keytool -help","Provare keytool -help"},
-        {"Command option  needs an argument.", "\u00c8 necessario specificare un argomento per l'opzione di comando {0}."},
+        {"Command option  needs an argument.", "\u00c8 necessario specificare un argomento per l''opzione di comando {0}."},
         {"Warning:  Different store and key passwords not supported for PKCS12 KeyStores. Ignoring user-specified  value.",
-                "Avviso: non sono supportate password diverse di chiave e di archivio per i KeyStore PKCS12. Il valore {0} specificato dall'utente verr\u00e0 ignorato."},
+                "Avviso: non sono supportate password diverse di chiave e di archivio per i KeyStore PKCS12. Il valore {0} specificato dall''utente verr\u00e0 ignorato."},
         {"-keystore must be NONE if -storetype is {0}",
                 "Se -storetype \u00e8 impostato su {0}, -keystore deve essere impostato su NONE"},
         {"Too may retries, program terminated",
@@ -100,16 +100,16 @@ public class Resources_it extends java.util.ListResourceBundle {
         {"Unknown Entry Type", "Tipo di voce sconosciuto"},
         {"Too many failures. Alias not changed", "Si sono verificati troppi errori. L'alias non \u00e8 stato modificato."},
         {"Entry for alias  successfully imported.",
-                 "La voce dell'alias {0} \u00e8 stata importata."},
-        {"Entry for alias  not imported.", "La voce dell'alias {0} non \u00e8 stata importata."},
+                 "La voce dell''alias {0} \u00e8 stata importata."},
+        {"Entry for alias  not imported.", "La voce dell''alias {0} non \u00e8 stata importata."},
         {"Problem importing entry for alias : .\nEntry for alias  not imported.",
-                 "Si \u00e8 verificato un problema durante l'importazione della voce dell'alias {0}: {1}.\nLa voce dell'alias {0} non \u00e8 stata importata."},
+                 "Si \u00e8 verificato un problema durante l''importazione della voce dell''alias {0}: {1}.\nLa voce dell''alias {0} non \u00e8 stata importata."},
         {"Import command completed:   entries successfully imported,  entries failed or cancelled",
                  "Importazione completata:  {0} voci importate, {1} voci non importate o annullate"},
         {"Warning: Overwriting existing alias  in destination keystore",
-                 "Avviso: sovrascrittura in corso dell'alias {0} nel file keystore di destinazione"},
+                 "Avviso: sovrascrittura in corso dell''alias {0} nel file keystore di destinazione"},
         {"Existing entry alias  exists, overwrite? [no]:  ",
-                 "La voce dell'alias {0} esiste gi\u00e0. Sovrascrivere? [no]:  "},
+                 "La voce dell''alias {0} esiste gi\u00e0. Sovrascrivere? [no]:  "},
         {"Too many failures - try later", "Troppi errori - riprovare"},
         {"Certification request stored in file ",
                 "La richiesta di certificazione \u00e8 memorizzata nel file <{0}>"},
@@ -232,9 +232,9 @@ public class Resources_it extends java.util.ListResourceBundle {
         {"y", "s"},
         {"  [defaultValue]:  ", " [{0}]:  "},
         {"Alias  has no key",
-                "All'alias <{0}> non \u00e8 associata alcuna chiave"},
+                "All''alias <{0}> non \u00e8 associata alcuna chiave"},
         {"Alias  references an entry type that is not a private key entry.  The -keyclone command only supports cloning of private key entries",
-                 "L'alias <{0}> fa riferimento a un tipo di voce che non \u00e8 una voce di chiave privata. Il comando -keyclone supporta solo la duplicazione delle voci di chiave private."},
+                 "L''alias <{0}> fa riferimento a un tipo di voce che non \u00e8 una voce di chiave privata. Il comando -keyclone supporta solo la duplicazione delle voci di chiave private."},
 
         {"*****************  WARNING WARNING WARNING  *****************",
             "*****************  AVVISO  AVVISO  AVVISO  *****************"},
@@ -274,7 +274,7 @@ public class Resources_it extends java.util.ListResourceBundle {
         {"n", "n"},
         {"Wrong answer, try again", "Risposta errata, riprovare"},
         {"Secret key not generated, alias  already exists",
-                "La chiave segreta non \u00e8 stata generata; l'alias <{0}> esiste gi\u00e0"},
+                "La chiave segreta non \u00e8 stata generata; l''alias <{0}> esiste gi\u00e0"},
         {"Please provide -keysize for secret key generation",
                 "Specificare il valore -keysize per la generazione della chiave segreta"},
         {"keytool usage:\n", "utilizzo keytool:\n"},
@@ -401,7 +401,7 @@ public class Resources_it extends java.util.ListResourceBundle {
 
         // policytool
         {"Warning: A public key for alias 'signers[i]' does not exist.  Make sure a KeyStore is properly configured.",
-                "Avviso: non esiste una chiave pubblica per l'alias {0}. Verificare che il KeyStore sia configurato correttamente."},
+                "Avviso: non esiste una chiave pubblica per l''alias {0}. Verificare che il KeyStore sia configurato correttamente."},
         {"Warning: Class not found: class", "Avviso: Classe non trovata: {0}"},
         {"Warning: Invalid argument(s) for constructor: arg",
                 "Avviso: argomento o argomenti non validi per il costruttore {0}"},
diff --git a/jdk/src/share/classes/sun/security/util/Resources_pt_BR.java b/jdk/src/share/classes/sun/security/util/Resources_pt_BR.java
new file mode 100644
index 0000000000000000000000000000000000000000..847a4ae582ae12ad68bf5e6ec7779dfbe4248207
--- /dev/null
+++ b/jdk/src/share/classes/sun/security/util/Resources_pt_BR.java
@@ -0,0 +1,646 @@
+/*
+ * Copyright (c) 2001, 2006, 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 sun.security.util;
+
+/**
+ * 
       This class represents the ResourceBundle
+ * for javax.security.auth and sun.security.
+ *
+ * @version 1.33, 12/06/05
+ */
+public class Resources_pt_BR extends java.util.ListResourceBundle {
+
+    private static final Object[][] contents = {
+
+    // shared (from jarsigner)
+    {" ", " "},
+    {"  ", "  "},
+    {"      ", "      "},
+    {", ", ", "},
+    // shared (from keytool)
+    {"\n", "\n"},
+    {"*******************************************",
+        "*******************************************"},
+    {"*******************************************\n\n",
+        "*******************************************\n\n"},
+
+    // keytool
+    {"keytool error: ", "erro de keytool: "},
+    {"Illegal option:  ", "Op\u00e7\u00e3o ilegal:  "},
+        {"Try keytool -help","Tentar keytool -help"},
+        {"Command option  needs an argument.", "A op\u00e7\u00e3o de comando {0} precisa de um argumento."},
+        {"Warning:  Different store and key passwords not supported for PKCS12 KeyStores. Ignoring user-specified  value.",
+                "Aviso:  senhas de chave e de armazenamento diferentes n\u00e3o suportadas para KeyStores PKCS12. Ignorando valor {0} especificado pelo usu\u00e1rio."},
+    {"-keystore must be NONE if -storetype is {0}",
+        "-keystore deve ser NONE se -storetype for {0}"},
+        {"Too may retries, program terminated",
+                 "N\u00famero de tentativas excedido, programa finalizado"},
+    {"-storepasswd and -keypasswd commands not supported if -storetype is {0}",
+        "comandos -storepasswd e -keypasswd n\u00e3o suportados se -storetype for {0}"},
+    {"-keypasswd commands not supported if -storetype is PKCS12",
+        "comandos -keypasswd n\u00e3o suportados se -storetype for PKCS12"},
+    {"-keypass and -new can not be specified if -storetype is {0}",
+        "-keypass e -new n\u00e3o podem ser especificados se -storetype for {0}"},
+    {"if -protected is specified, then -storepass, -keypass, and -new must not be specified",
+        "se -protected estiver especificado, ent\u00e3o -storepass, -keypass e -new n\u00e3o devem ser especificados"},
+    {"if -srcprotected is specified, then -srcstorepass and -srckeypass must not be specified",
+        "se -srcprotected estiver especificado, ent\u00e3o -srcstorepass e -srckeypass n\u00e3o devem ser especificados"},
+    {"if keystore is not password protected, then -storepass, -keypass, and -new must not be specified",
+        "se o armazenamento de chaves n\u00e3o estiver protegido por senha, ent\u00e3o -storepass, -keypass e -new n\u00e3o devem ser especificados"},
+    {"if source keystore is not password protected, then -srcstorepass and -srckeypass must not be specified",
+        "se o armazenamento de chaves de origem n\u00e3o estiver protegido por senha, ent\u00e3o -srcstorepass e -srckeypass n\u00e3o devem ser especificados"},
+    {"Validity must be greater than zero",
+        "A validade deve ser maior do que zero"},
+    {"provName not a provider", "{0} n\u00e3o \u00e9 um fornecedor"},
+    {"Usage error: no command provided", "Erro de uso: nenhum comando fornecido"},
+    {"Usage error,  is not a legal command", "Erro de uso, {0} n\u00e3o \u00e9 um comando legal"},
+    {"Source keystore file exists, but is empty: ", "O arquivo de armazenamento de chaves de origem existe, mas est\u00e1 vazio: "},
+    {"Please specify -srckeystore", "Especifique -srckeystore"},
+    {"Must not specify both -v and -rfc with 'list' command",
+        "N\u00e3o devem ser especificados -v e -rfc com o comando 'list'"},
+    {"Key password must be at least 6 characters",
+        "A senha da chave deve ter como m\u00ednimo 6 caracteres"},
+    {"New password must be at least 6 characters",
+        "A nova senha deve ter como m\u00ednimo 6 caracteres"},
+    {"Keystore file exists, but is empty: ",
+        "O arquivo de armazenamento de chaves existe, mas est\u00e1 vazio: "},
+    {"Keystore file does not exist: ",
+        "O arquivo de armazenamento de chaves n\u00e3o existe. "},
+    {"Must specify destination alias", "Deve ser especificado um alias de destino"},
+    {"Must specify alias", "Deve ser especificado um alias"},
+    {"Keystore password must be at least 6 characters",
+        "A senha do armazenamento de chaves deve ter como m\u00ednimo 6 caracteres"},
+    {"Enter keystore password:  ", "Insira a senha do armazenamento de chaves:  "},
+    {"Enter source keystore password:  ", "Insira a senha do armazenamento de chaves de origem:  "},
+        {"Enter destination keystore password:  ", "Insira a senha do armazenamento de chaves de destino:  "},
+    {"Keystore password is too short - must be at least 6 characters",
+     "A senha do armazenamento de chaves \u00e9 muito curta - deve ter como m\u00ednimo 6 caracteres"},
+        {"Unknown Entry Type", "Tipo de entrada desconhecido"},
+        {"Too many failures. Alias not changed", "Excesso de falhas. Alias n\u00e3o alterado"},
+        {"Entry for alias  successfully imported.",
+                 "Entrada do alias {0} importada com \u00eaxito."},
+        {"Entry for alias  not imported.", "Entrada do alias {0} n\u00e3o importada."},
+        {"Problem importing entry for alias : .\nEntry for alias  not imported.",
+                 "Problema ao importar a entrada do {0}: {1}.\nEntrada do alias {0} n\u00e3o importada."},
+        {"Import command completed:   entries successfully imported,  entries failed or cancelled",
+                 "Comando de importa\u00e7\u00e3o conclu\u00eddo:  {0} entradas importadas com \u00eaxito, {1} entradas falhas ou canceladas"},
+        {"Warning: Overwriting existing alias  in destination keystore",
+                 "Aviso: substitui\u00e7\u00e3o de alias {0} existente no armazenamento de chaves de destino"},
+        {"Existing entry alias  exists, overwrite? [no]:  ",
+                 "Entrada j\u00e1 existente no alias {0}, substituir? [n\u00e3o]:  "},
+    {"Too many failures - try later", "Excesso de falhas - tentar mais tarde"},
+    {"Certification request stored in file ",
+        "Solicita\u00e7\u00e3o de certificado armazenada no arquivo <{0}>"},
+    {"Submit this to your CA", "Enviar \u00e0 CA"},
+        {"if alias not specified, destalias, srckeypass, and destkeypass must not be specified",
+            "se o alias n\u00e3o estiver especificado, destalias, srckeypass e destkeypass n\u00e3o devem ser especificados"},
+    {"Certificate stored in file ",
+        "Certificado armazenado no arquivo <{0}>"},
+    {"Certificate reply was installed in keystore",
+        "Resposta do certificado foi instalada no armazenamento de chaves"},
+    {"Certificate reply was not installed in keystore",
+        "Resposta do certificado n\u00e3o foi instalada no armazenamento de chaves"},
+    {"Certificate was added to keystore",
+        "O certificado foi adicionado ao armazenamento de chaves"},
+    {"Certificate was not added to keystore",
+        "O certificado n\u00e3o foi adicionado ao armazenamento de chaves"},
+    {"[Storing ksfname]", "[Armazenando {0}]"},
+    {"alias has no public key (certificate)",
+        "{0} n\u00e3o possui chave p\u00fablica (certificado)"},
+    {"Cannot derive signature algorithm",
+        "N\u00e3o \u00e9 poss\u00edvel obter algoritmo de assinatura"},
+    {"Alias  does not exist",
+        "O alias <{0}> n\u00e3o existe"},
+    {"Alias  has no certificate",
+        "O alias <{0}> n\u00e3o possui certificado"},
+    {"Key pair not generated, alias  already exists",
+        "Par de chaves n\u00e3o gerado, o alias <{0}> j\u00e1 existe"},
+    {"Cannot derive signature algorithm",
+        "N\u00e3o \u00e9 poss\u00edvel obter algoritmo de assinatura"},
+    {"Generating keysize bit keyAlgName key pair and self-signed certificate (sigAlgName) with a validity of validality days\n\tfor: x500Name",
+                "Gerando o par de chaves {1} de {0} bit e o certificado autoassinado ({2}) com uma validade de {3} dias\n\tpara: {4}"},
+    {"Enter key password for ", "Inserir a senha da chave de <{0}>"},
+    {"\t(RETURN if same as keystore password):  ",
+        "\t(RETURN se for igual \u00e0 senha do armazenamento de chaves):  "},
+    {"Key password is too short - must be at least 6 characters",
+        "A senha da chave \u00e9 muito curta - deve ter como m\u00ednimo 6 caracteres"},
+    {"Too many failures - key not added to keystore",
+        "Excesso de falhas - chave n\u00e3o adicionada ao armazenamento de chaves"},
+    {"Destination alias  already exists",
+        "O alias de destino <{0}> j\u00e1 existe"},
+    {"Password is too short - must be at least 6 characters",
+        "A senha \u00e9 muito curta - deve ter como m\u00ednimo 6 caracteres"},
+    {"Too many failures. Key entry not cloned",
+        "Excesso de falhas. Entrada da chave n\u00e3o clonada"},
+    {"key password for ", "senha da chave de <{0}>"},
+    {"Keystore entry for  already exists",
+        "A entrada do armazenamento de chaves de <{0}> j\u00e1 existe"},
+    {"Creating keystore entry for  ...",
+        "Criando entrada do armazenamento de chaves para <{0}> ..."},
+    {"No entries from identity database added",
+        "Nenhuma entrada adicionada do banco de dados de identidades"},
+    {"Alias name: alias", "Nome do alias: {0}"},
+    {"Creation date: keyStore.getCreationDate(alias)",
+        "Data de cria\u00e7\u00e3o: {0,data}"},
+    {"alias, keyStore.getCreationDate(alias), ",
+        "{0}, {1,data}, "},
+    {"alias, ", "{0}, "},
+    {"Entry type: ", "Tipo de entrada: {0}"},
+    {"Certificate chain length: ", "Comprimento da cadeia de certificados: "},
+    {"Certificate[(i + 1)]:", "Certificado[{0,n\u00famero,inteiro}]:"},
+    {"Certificate fingerprint (MD5): ", "Fingerprint (MD5) do certificado: "},
+    {"Entry type: trustedCertEntry\n", "Tipo de entrada: trustedCertEntry\n"},
+    {"trustedCertEntry,", "trustedCertEntry,"},
+    {"Keystore type: ", "Tipo de armazenamento de chaves: "},
+    {"Keystore provider: ", "Fornecedor de armazenamento de chaves: "},
+    {"Your keystore contains keyStore.size() entry",
+        "Seu armazenamento de chaves cont\u00e9m {0,n\u00famero,inteiro} entrada"},
+    {"Your keystore contains keyStore.size() entries",
+        "Seu armazenamento de chaves cont\u00e9m {0,n\u00famero,inteiro} entradas"},
+    {"Failed to parse input", "Falha ao analisar a entrada"},
+    {"Empty input", "Entrada vazia"},
+    {"Not X.509 certificate", "N\u00e3o \u00e9 um certificado X.509"},
+    {"Cannot derive signature algorithm",
+        "N\u00e3o \u00e9 poss\u00edvel obter algoritmo de assinatura"},
+    {"alias has no public key", "{0} n\u00e3o possui chave p\u00fablica"},
+    {"alias has no X.509 certificate", "{0} n\u00e3o possui certificado X.509"},
+    {"New certificate (self-signed):", "Novo certificado (autoassinado):"},
+    {"Reply has no certificates", "A resposta n\u00e3o possui certificado"},
+    {"Certificate not imported, alias  already exists",
+        "Certificado n\u00e3o importado, o alias <{0}> j\u00e1 existe"},
+    {"Input not an X.509 certificate", "A entrada n\u00e3o \u00e9 um certificado X.509"},
+    {"Certificate already exists in keystore under alias ",
+        "O certificado j\u00e1 existe no armazenamento de chaves no alias <{0}>"},
+    {"Do you still want to add it? [no]:  ",
+        "Ainda deseja adicion\u00e1-lo? [n\u00e3o]:  "},
+    {"Certificate already exists in system-wide CA keystore under alias ",
+        "O certificado j\u00e1 existe no armazenamento de chaves de CA em todo o sistema no alias <{0}>"},
+    {"Do you still want to add it to your own keystore? [no]:  ",
+        "Ainda deseja adicion\u00e1-lo ao seu pr\u00f3prio armazenamento de chaves? [n\u00e3o]:  "},
+    {"Trust this certificate? [no]:  ", "Confiar neste certificado? [n\u00e3o]:  "},
+    {"YES", "SIM"},
+    {"New prompt: ", "Nova {0}: "},
+    {"Passwords must differ", "As senhas devem ser diferentes"},
+    {"Re-enter new prompt: ", "Insira novamente a nova {0}: "},
+    {"Re-enter new password: ", "Insira novamente a nova senha: "},
+    {"They don't match. Try again", "Elas n\u00e3o correspondem. Tente novamente"},
+    {"Enter prompt alias name:  ", "Insira o nome do alias {0}:  "},
+        {"Enter new alias name\t(RETURN to cancel import for this entry):  ",
+                 "Insira o novo nome do alias\t(RETURN para cancelar a importa\u00e7\u00e3o desta entrada):  "},
+    {"Enter alias name:  ", "Insira o nome do alias:  "},
+    {"\t(RETURN if same as for )",
+        "\t(RETURN se for igual ao de <{0}>)"},
+    {"*PATTERN* printX509Cert",
+        "Propriet\u00e1rio: {0}\nEmissor: {1}\nN\u00famero de s\u00e9rie: {2}\nV\u00e1lido de: {3} a: {4}\nFingerprints do certificado:\n\t MD5:  {5}\n\t SHA1: {6}\n\t Nome do algoritmo de assinatura: {7}\n\t Vers\u00e3o: {8}"},
+    {"What is your first and last name?",
+        "Qual \u00e9 o seu nome e o seu sobrenome?"},
+    {"What is the name of your organizational unit?",
+        "Qual \u00e9 o nome da sua unidade organizacional?"},
+    {"What is the name of your organization?",
+        "Qual \u00e9 o nome da sua empresa?"},
+    {"What is the name of your City or Locality?",
+        "Qual \u00e9 o nome da sua cidade ou localidade?"},
+    {"What is the name of your State or Province?",
+        "Qual \u00e9 o nome do seu estado ou munic\u00edpio?"},
+    {"What is the two-letter country code for this unit?",
+        "Quais s\u00e3o as duas letras do c\u00f3digo do pa\u00eds desta unidade?"},
+    {"Is  correct?", "{0} \u00e9 correto?"},
+    {"no", "n\u00e3o"},
+    {"yes", "sim"},
+    {"y", "s"},
+    {"  [defaultValue]:  ", "  [{0}]:  "},
+    {"Alias  has no key",
+        "O alias <{0}> n\u00e3o possui chave"},
+        {"Alias  references an entry type that is not a private key entry.  The -keyclone command only supports cloning of private key entries",
+                 "O alias <{0}> faz refer\u00eancia a um tipo de entrada que n\u00e3o \u00e9 uma entrada de chave privada.  O comando -keyclone oferece suporte somente \u00e0 clonagem de entradas de chave privada"},
+
+    {"*****************  WARNING WARNING WARNING  *****************",
+        "*****************  AVISO AVISO AVISO  *****************"},
+
+        // Translators of the following 5 pairs, ATTENTION:
+        // the next 5 string pairs are meant to be combined into 2 paragraphs,
+        // 1+3+4 and 2+3+5. make sure your translation also does.
+        {"* The integrity of the information stored in your keystore  *",
+        "* A integridade das informa\u00e7\u00f5es armazenadas no seu armazenamento de chaves  *"},
+        {"* The integrity of the information stored in the srckeystore*",
+            "* A integridade das informa\u00e7\u00f5es armazenadas no srckeystore*"},
+    {"* has NOT been verified!  In order to verify its integrity, *",
+        "* N\u00c3O foi verificada!  Para verificar a integridade destas informa\u00e7\u00f5es, *"},
+    {"* you must provide your keystore password.                  *",
+        "* voc\u00ea deve fornecer a senha do seu armazenamento de chaves.                  *"},
+        {"* you must provide the srckeystore password.                *",
+            "* voc\u00ea deve fornecer a senha do srckeystore.                  *"},
+
+
+    {"Certificate reply does not contain public key for ",
+        "A resposta do certificado n\u00e3o cont\u00e9m a chave p\u00fablica de <{0}>"},
+    {"Incomplete certificate chain in reply",
+        "Cadeia de certificados incompleta na resposta"},
+    {"Certificate chain in reply does not verify: ",
+        "A cadeia de certificados da resposta n\u00e3o verifica: "},
+    {"Top-level certificate in reply:\n",
+        "Certificado de n\u00edvel superior na resposta:\n"},
+    {"... is not trusted. ", "... n\u00e3o \u00e9 confi\u00e1vel. "},
+    {"Install reply anyway? [no]:  ", "Instalar resposta assim mesmo? [n\u00e3o]:  "},
+    {"NO", "N\u00c3O"},
+    {"Public keys in reply and keystore don't match",
+        "As chaves p\u00fablicas da resposta e do armazenamento de chaves n\u00e3o correspondem"},
+    {"Certificate reply and certificate in keystore are identical",
+        "O certificado da resposta e o certificado do armazenamento de chaves s\u00e3o id\u00eanticos"},
+    {"Failed to establish chain from reply",
+        "Falha ao estabelecer a cadeia a partir da resposta"},
+    {"n", "n"},
+    {"Wrong answer, try again", "Resposta errada, tente novamente"},
+    {"Secret key not generated, alias  already exists",
+        "Chave secreta n\u00e3o gerada, o alias <{0}> j\u00e1 existe"},
+        {"Please provide -keysize for secret key generation",
+                "Forne\u00e7a o -keysize para a gera\u00e7\u00e3o da chave secreta"},
+    {"keytool usage:\n", "uso de keytool:\n"},
+
+        {"Extensions: ", "Extens\u00f5es: "},
+
+    {"-certreq     [-v] [-protected]",
+        "-certreq     [-v] [-protected]"},
+    {"\t     [-alias ] [-sigalg ]",
+        "\t     [-alias ] [-sigalg ]"},
+    {"\t     [-file ] [-keypass ]",
+        "\t     [-file ] [-keypass ]"},
+    {"\t     [-keystore ] [-storepass ]",
+        "\t     [-keystore ] [-storepass ]"},
+    {"\t     [-storetype ] [-providername ]",
+        "\t     [-storetype ] [-providername ]"},
+    {"\t     [-providerclass  [-providerarg ]] ...",
+        "\t     [-providerclass  [-providerarg ]] ..."},
+        {"\t     [-providerpath ]",
+                "\t     [-providerpath ]"},
+    {"-delete      [-v] [-protected] -alias ",
+        "-delete      [-v] [-protected] -alias "},
+    /** rest is same as -certreq starting from -keystore **/
+
+        //{"-export      [-v] [-rfc] [-protected]",
+        //       "-export      [-v] [-rfc] [-protected]"},
+    {"-exportcert  [-v] [-rfc] [-protected]",
+        "-exportcert  [-v] [-rfc] [-protected]"},
+    {"\t     [-alias ] [-file ]",
+        "\t     [-alias ] [-file ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+        //{"-genkey      [-v] [-protected]",
+        //        "-genkey      [-v] [-protected]"},
+    {"-genkeypair  [-v] [-protected]",
+        "-genkeypair  [-v] [-protected]"},
+    {"\t     [-alias ]", "\t     [-alias ]"},
+    {"\t     [-keyalg ] [-keysize ]",
+        "\t     [-keyalg ] [-keysize ]"},
+    {"\t     [-sigalg ] [-dname ]",
+        "\t     [-sigalg ] [-dname ]"},
+    {"\t     [-validity ] [-keypass ]",
+        "\t     [-validity ] [-keypass ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+    {"-genseckey   [-v] [-protected]",
+        "-genseckey   [-v] [-protected]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+    {"-help", "-help"},
+    //{"-identitydb  [-v] [-protected]",
+    //    "-identitydb  [-v] [-protected]"},
+    //{"\t     [-file ]", "\t     [-file ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+        //{"-import      [-v] [-noprompt] [-trustcacerts] [-protected]",
+        //       "-import      [-v] [-noprompt] [-trustcacerts] [-protected]"},
+    {"-importcert  [-v] [-noprompt] [-trustcacerts] [-protected]",
+        "-importcert  [-v] [-noprompt] [-trustcacerts] [-protected]"},
+    {"\t     [-alias ]", "\t     [-alias ]"},
+        {"\t     [-alias ] [-keypass ]",
+            "\t     [-alias ] [-keypass ]"},
+    {"\t     [-file ] [-keypass ]",
+        "\t     [-file ] [-keypass ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+    {"-importkeystore [-v] ",
+                "-importkeystore [-v] "},
+    {"\t     [-srckeystore ] [-destkeystore ]",
+                "\t     [-srckeystore ] [-destkeystore ]"},
+    {"\t     [-srcstoretype ] [-deststoretype ]",
+                "\t     [-srcstoretype ] [-deststoretype ]"},
+    {"\t     [-srcprotected] [-destprotected]",
+                "\t     [-srcprotected] [-destprotected]"},
+        {"\t     [-srcstorepass ] [-deststorepass ]",
+                "\t     [-srcstorepass ] [-deststorepass ]"},
+        {"\t     [-srcprovidername ]\n\t     [-destprovidername ]",  // line too long, split to 2
+                 "\t     [-srcprovidername ]\n\t     [-destprovidername ]"},
+    {"\t     [-srcalias  [-destalias ]",
+                "\t     [-srcalias  [-destalias ]"},
+    {"\t       [-srckeypass ] [-destkeypass ]]",
+                "\t       [-srckeypass ] [-destkeypass ]]"},
+        {"\t     [-noprompt]", "\t     [-noprompt]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+        {"-changealias [-v] [-protected] -alias  -destalias ",
+                "-changealias [-v] [-protected] -alias  -destalias "},
+        {"\t     [-keypass ]", "\t     [-keypass ]"},
+
+    //{"-keyclone    [-v] [-protected]",
+    //    "-keyclone    [-v] [-protected]"},
+    //{"\t     [-alias ] -dest ",
+    //    "\t     [-alias ] -dest "},
+    //{"\t     [-keypass ] [-new ]",
+    //    "\t     [-keypass ] [-new ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+    {"-keypasswd   [-v] [-alias ]",
+        "-keypasswd   [-v] [-alias ]"},
+    {"\t     [-keypass ] [-new ]",
+        "\t     [-keypass ] [-new ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+    {"-list        [-v | -rfc] [-protected]",
+        "-list        [-v | -rfc] [-protected]"},
+    {"\t     [-alias ]", "\t     [-alias ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+    {"-printcert   [-v] [-file ]",
+        "-printcert   [-v] [-file ]"},
+
+    //{"-selfcert    [-v] [-protected]",
+    //    "-selfcert    [-v] [-protected]"},
+    {"\t     [-alias ]", "\t     [-alias ]"},
+    //{"\t     [-dname ] [-validity ]",
+    //    "\t     [-dname ] [-validity ]"},
+    //{"\t     [-keypass ] [-sigalg ]",
+    //    "\t     [-keypass ] [-sigalg ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+    {"-storepasswd [-v] [-new ]",
+        "-storepasswd [-v] [-new ]"},
+    /** rest is same as -certreq starting from -keystore **/
+
+    // policytool
+    {"Warning: A public key for alias 'signers[i]' does not exist.  Make sure a KeyStore is properly configured.",
+        "Aviso: n\u00e3o existe uma chave p\u00fablica para o alias {0}.  Certifique-se de que um KeyStore esteja configurado adequadamente."},
+    {"Warning: Class not found: class", "Aviso: classe n\u00e3o encontrada: {0}"},
+    {"Warning: Invalid argument(s) for constructor: arg",
+        "Aviso: argumento(s) inv\u00e1lido(s) para o construtor: {0}"},
+    {"Illegal Principal Type: type", "Tipo principal ilegal: {0}"},
+    {"Illegal option: option", "Op\u00e7\u00e3o ilegal: {0}"},
+    {"Usage: policytool [options]", "Uso: policytool [op\u00e7\u00f5es]"},
+    {"  [-file ]    policy file location",
+        "  [-file ]    local do arquivo de pol\u00edtica"},
+    {"New", "Novo"},
+    {"Open", "Abrir"},
+    {"Save", "Salvar"},
+    {"Save As", "Salvar como"},
+    {"View Warning Log", "Visualizar registro de avisos"},
+    {"Exit", "Sair"},
+    {"Add Policy Entry", "Adicionar entrada de pol\u00edtica"},
+    {"Edit Policy Entry", "Editar entrada de pol\u00edtica"},
+    {"Remove Policy Entry", "Remover entrada de pol\u00edtica"},
+    {"Edit", "Editar"},
+        {"Retain", "Conservar"},
+
+        {"Warning: File name may include escaped backslash characters. " +
+                        "It is not necessary to escape backslash characters " +
+                        "(the tool escapes characters as necessary when writing " +
+                        "the policy contents to the persistent store).\n\n" +
+                        "Click on Retain to retain the entered name, or click on " +
+                        "Edit to edit the name.",
+            "Aviso: o nome do arquivo pode incluir caracteres de escape barra invertida. N\u00e3o \u00e9 necess\u00e1rio fazer o escape dos caracteres de barra invertida (a ferramenta faz o escape dos caracteres conforme necess\u00e1rio ao gravar o conte\u00fado da pol\u00edtica no armazenamento persistente).\n\nClique em Conservar para conservar o nome da entrada ou clique em Editar para edit\u00e1-lo."},
+
+        {"Add Public Key Alias", "Adicionar alias de chave p\u00fablica"},
+    {"Remove Public Key Alias", "Remover alias de chave p\u00fablica"},
+    {"File", "Arquivo"},
+    {"KeyStore", "KeyStore"},
+    {"Policy File:", "Arquivo de pol\u00edtica:"},
+    {"Could not open policy file: policyFile: e.toString()",
+        "N\u00e3o foi poss\u00edvel abrir o arquivo de pol\u00edtica: {0}: {1}"},
+    {"Policy Tool", "Ferramenta de pol\u00edtica"},
+    {"Errors have occurred while opening the policy configuration.  View the Warning Log for more information.",
+        "Ocorreram erros ao abrir a configura\u00e7\u00e3o da pol\u00edtica.  Consulte o registro de avisos para obter mais informa\u00e7\u00f5es."},
+    {"Error", "Erro"},
+    {"OK", "OK"},
+    {"Status", "Status"},
+    {"Warning", "Aviso"},
+    {"Permission:                                                       ",
+        "Permiss\u00e3o:                                                       "},
+    {"Principal Type:", "Tipo do principal:"},
+        {"Principal Name:", "Nome do principal:"},
+    {"Target Name:                                                    ",
+        "Nome de destino:                                                    "},
+    {"Actions:                                                             ",
+        "A\u00e7\u00f5es:                                                             "},
+    {"OK to overwrite existing file filename?",
+        "OK para substituir o arquivo existente {0}?"},
+    {"Cancel", "Cancelar"},
+    {"CodeBase:", "CodeBase:"},
+    {"SignedBy:", "SignedBy:"},
+    {"Add Principal", "Adicionar principal"},
+    {"Edit Principal", "Editar principal"},
+    {"Remove Principal", "Remover principal"},
+    {"Principals:", "Principais:"},
+    {"  Add Permission", "  Adicionar permiss\u00e3o"},
+    {"  Edit Permission", "  Editar permiss\u00e3o"},
+    {"Remove Permission", "Remover permiss\u00e3o"},
+    {"Done", "Conclu\u00eddo"},
+    {"KeyStore URL:", "URL do KeyStore:"},
+    {"KeyStore Type:", "Tipo de KeyStore:"},
+    {"KeyStore Provider:", "Fornecedor de KeyStore:"},
+    {"KeyStore Password URL:", "URL da senha do KeyStore:"},
+    {"Principals", "Principais"},
+    {"  Edit Principal:", "  Editar principal:"},
+    {"  Add New Principal:", "  Adicionar novo principal:"},
+    {"Permissions", "Permiss\u00f5es"},
+    {"  Edit Permission:", "  Editar permiss\u00e3o:"},
+    {"  Add New Permission:", "  Adicionar nova permiss\u00e3o:"},
+    {"Signed By:", "Assinado por:"},
+    {"Cannot Specify Principal with a Wildcard Class without a Wildcard Name",
+        "N\u00e3o \u00e9 poss\u00edvel especificar principal com uma classe de coringa sem um nome de coringa"},
+        {"Cannot Specify Principal without a Name",
+            "N\u00e3o \u00e9 poss\u00edvel especificar principal sem um nome"},
+    {"Permission and Target Name must have a value",
+        "O nome de destino e a permiss\u00e3o devem ter um valor"},
+    {"Remove this Policy Entry?", "Remover esta entrada de pol\u00edtica?"},
+    {"Overwrite File", "Substituir arquivo"},
+    {"Policy successfully written to filename",
+        "Pol\u00edtica gravada com \u00eaxito em {0}"},
+    {"null filename", "nome de arquivo nulo"},
+    {"Save changes?", "Salvar altera\u00e7\u00f5es?"},
+    {"Yes", "Sim"},
+    {"No", "N\u00e3o"},
+    {"Policy Entry", "Entrada de pol\u00edtica"},
+    {"Save Changes", "Salvar altera\u00e7\u00f5es"},
+    {"No Policy Entry selected", "Nenhuma entrada de pol\u00edtica selecionada"},
+    {"Unable to open KeyStore: ex.toString()",
+        "N\u00e3o \u00e9 poss\u00edvel abrir o KeyStore: {0}"},
+    {"No principal selected", "Nenhum principal selecionado"},
+    {"No permission selected", "Nenhuma permiss\u00e3o selecionada"},
+    {"name", "nome"},
+    {"configuration type", "tipo de configura\u00e7\u00e3o"},
+    {"environment variable name", "nome da vari\u00e1vel de ambiente"},
+    {"library name", "nome da biblioteca"},
+    {"package name", "nome do pacote"},
+    {"policy type", "tipo de pol\u00edtica"},
+    {"property name", "nome da propriedade"},
+    {"provider name", "nome do fornecedor"},
+        {"Principal List", "Lista de principais"},
+        {"Permission List", "Lista de permiss\u00f5es"},
+        {"Code Base", "Base de c\u00f3digo"},
+        {"KeyStore U R L:", "U R L do KeyStore:"},
+        {"KeyStore Password U R L:", "U R L da senha do KeyStore:"},
+
+
+    // javax.security.auth.PrivateCredentialPermission
+    {"invalid null input(s)", "entrada(s) nula(s) inv\u00e1lida(s)"},
+    {"actions can only be 'read'", "as a\u00e7\u00f5es podem ser somente 'lidas'"},
+    {"permission name [name] syntax invalid: ",
+        "sintaxe inv\u00e1lida do nome da permiss\u00e3o [{0}]: "},
+    {"Credential Class not followed by a Principal Class and Name",
+        "Classe da credencial n\u00e3o seguida por um nome e classe do principal"},
+    {"Principal Class not followed by a Principal Name",
+        "Classe do principal n\u00e3o seguida por um nome do principal"},
+    {"Principal Name must be surrounded by quotes",
+        "O nome do principal deve estar entre aspas"},
+    {"Principal Name missing end quote",
+        "Faltam as aspas finais no nome do principal "},
+    {"PrivateCredentialPermission Principal Class can not be a wildcard (*) value if Principal Name is not a wildcard (*) value",
+        "A classe do principal PrivateCredentialPermission n\u00e3o pode ser um valor coringa (*) se o nome do principal n\u00e3o for um valor coringa (*)"},
+    {"CredOwner:\n\tPrincipal Class = class\n\tPrincipal Name = name",
+        "CredOwner:\n\tClasse do principal = {0}\n\tNome do principal = {1}"},
+
+    // javax.security.auth.x500
+    {"provided null name", "nome nulo fornecido"},
+    {"provided null keyword map", "mapa de palavra-chave nulo fornecido"},
+    {"provided null OID map", "mapa OID nulo fornecido"},
+
+    // javax.security.auth.Subject
+    {"invalid null AccessControlContext provided",
+        "AccessControlContext nulo inv\u00e1lido fornecido"},
+    {"invalid null action provided", "a\u00e7\u00e3o nula inv\u00e1lida fornecida"},
+    {"invalid null Class provided", "classe nula inv\u00e1lida fornecida"},
+    {"Subject:\n", "Subject:\n"},
+    {"\tPrincipal: ", "\tPrincipal: "},
+    {"\tPublic Credential: ", "\tCredencial p\u00fablica: "},
+    {"\tPrivate Credentials inaccessible\n",
+        "\tCredenciais privadas inacess\u00edveis\n"},
+    {"\tPrivate Credential: ", "\tCredencial privada: "},
+    {"\tPrivate Credential inaccessible\n",
+        "\tCredencial privada inacess\u00edvel\n"},
+    {"Subject is read-only", "O Subject \u00e9 de somente leitura"},
+    {"attempting to add an object which is not an instance of java.security.Principal to a Subject's Principal Set",
+        "tentativa de adicionar um objeto que n\u00e3o \u00e9 uma inst\u00e2ncia de java.security.Principal a um conjunto de principais do Subject"},
+    {"attempting to add an object which is not an instance of class",
+        "tentativa de adicionar um objeto que n\u00e3o \u00e9 uma inst\u00e2ncia de {0}"},
+
+    // javax.security.auth.login.AppConfigurationEntry
+    {"LoginModuleControlFlag: ", "LoginModuleControlFlag: "},
+
+    // javax.security.auth.login.LoginContext
+    {"Invalid null input: name", "Entrada nula inv\u00e1lida: nome"},
+    {"No LoginModules configured for name",
+     "Nenhum LoginModule configurado para {0}"},
+    {"invalid null Subject provided", "Subject nulo inv\u00e1lido fornecido"},
+    {"invalid null CallbackHandler provided",
+        "CallbackHandler nulo inv\u00e1lido fornecido"},
+    {"null subject - logout called before login",
+        "Subject nulo - logoff chamado antes do logon"},
+    {"unable to instantiate LoginModule, module, because it does not provide a no-argument constructor",
+        "n\u00e3o \u00e9 poss\u00edvel instanciar LoginModule, {0}, porque n\u00e3o fornece um construtor sem argumento"},
+    {"unable to instantiate LoginModule",
+        "n\u00e3o \u00e9 poss\u00edvel instanciar LoginModule"},
+    {"unable to instantiate LoginModule: ",
+        "n\u00e3o \u00e9 poss\u00edvel instanciar LoginModule: "},
+    {"unable to find LoginModule class: ",
+        "n\u00e3o \u00e9 poss\u00edvel localizar a classe LoginModule: "},
+    {"unable to access LoginModule: ",
+        "n\u00e3o \u00e9 poss\u00edvel acessar LoginModule: "},
+    {"Login Failure: all modules ignored",
+        "Falha de logon: todos os m\u00f3dulos ignorados"},
+
+    // sun.security.provider.PolicyFile
+
+    {"java.security.policy: error parsing policy:\n\tmessage",
+        "java.security.policy: erro ao analisar {0}:\n\t{1}"},
+    {"java.security.policy: error adding Permission, perm:\n\tmessage",
+        "java.security.policy: erro ao adicionar permiss\u00e3o, {0}:\n\t{1}"},
+    {"java.security.policy: error adding Entry:\n\tmessage",
+        "java.security.policy: erro ao adicionar entrada:\n\t{0}"},
+    {"alias name not provided (pe.name)", "nome de alias n\u00e3o fornecido ({0})"},
+    {"unable to perform substitution on alias, suffix",
+        "n\u00e3o \u00e9 poss\u00edvel realizar a substitui\u00e7\u00e3o no alias, {0}"},
+    {"substitution value, prefix, unsupported",
+        "valor da substitui\u00e7\u00e3o, {0}, n\u00e3o suportado"},
+    {"(", "("},
+    {")", ")"},
+    {"type can't be null","o tipo n\u00e3o pode ser nulo"},
+
+    // sun.security.provider.PolicyParser
+    {"keystorePasswordURL can not be specified without also specifying keystore",
+        "keystorePasswordURL n\u00e3o pode ser especificado sem que o armazenamento de chaves tamb\u00e9m seja especificado"},
+    {"expected keystore type", "tipo de armazenamento de chaves esperado"},
+    {"expected keystore provider", "fornecedor de armazenamento de chaves esperado"},
+    {"multiple Codebase expressions",
+            "v\u00e1rias express\u00f5es CodeBase"},
+        {"multiple SignedBy expressions","v\u00e1rias express\u00f5es SignedBy"},
+    {"SignedBy has empty alias","SignedBy possui alias vazio"},
+    {"can not specify Principal with a wildcard class without a wildcard name",
+        "n\u00e3o \u00e9 poss\u00edvel especificar principal com uma classe de coringa sem um nome de coringa"},
+    {"expected codeBase or SignedBy or Principal",
+        "CodeBase ou SignedBy ou Principal esperado"},
+    {"expected permission entry", "entrada de permiss\u00e3o esperada"},
+    {"number ", "n\u00famero "},
+    {"expected [expect], read [end of file]",
+        "esperado [{0}], lido [fim do arquivo]"},
+    {"expected [;], read [end of file]",
+        "esperado [;], lido [fim do arquivo]"},
+    {"line number: msg", "linha {0}: {1}"},
+    {"line number: expected [expect], found [actual]",
+        "linha {0}: esperado [{1}], encontrado [{2}]"},
+    {"null principalClass or principalName",
+        "principalClass ou principalName nulo "},
+
+    // sun.security.pkcs11.SunPKCS11
+    {"PKCS11 Token [providerName] Password: ",
+        "Senha PKCS11 Token [{0}]: "},
+
+    /* --- DEPRECATED --- */
+    // javax.security.auth.Policy
+    {"unable to instantiate Subject-based policy",
+        "n\u00e3o \u00e9 poss\u00edvel instanciar a pol\u00edtica com base em Subject"}
+    };
+
+
+    /**
+     * Returns the contents of this ResourceBundle.
+     *
+     * 
      
+     *
+     * @return the contents of this ResourceBundle.
+     */
+    public Object[][] getContents() {
+    return contents;
+    }
+}
diff --git a/jdk/src/share/classes/sun/security/util/SignatureFileVerifier.java b/jdk/src/share/classes/sun/security/util/SignatureFileVerifier.java
index b0a334ee49804f2bb0473b21ab5b3b585aa4d27e..d3ce9013e1570a1bdf90a597e605f9fcf6526fdc 100644
--- a/jdk/src/share/classes/sun/security/util/SignatureFileVerifier.java
+++ b/jdk/src/share/classes/sun/security/util/SignatureFileVerifier.java
@@ -265,6 +265,9 @@ public class SignatureFileVerifier {
                 debug.println("processSignature unsigned name = "+name);
             }
         }
+
+        // MANIFEST.MF is always regarded as signed
+        updateSigners(newSigners, signers, JarFile.MANIFEST_NAME);
     }
 
     /**
diff --git a/jdk/src/share/classes/sun/tools/jar/resources/jar_pt_BR.properties b/jdk/src/share/classes/sun/tools/jar/resources/jar_pt_BR.properties
new file mode 100644
index 0000000000000000000000000000000000000000..e1c846f145bd4ca2e21b2989bdad9860fc157a16
--- /dev/null
+++ b/jdk/src/share/classes/sun/tools/jar/resources/jar_pt_BR.properties
@@ -0,0 +1,47 @@
+#
+# Copyright (c) 1999, 2006, 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.
+#
+
+error.cant.open=n\u00e3o \u00e9 poss\u00edvel abrir: {0} 
+error.illegal.option=Op\u00e7\u00e3o ilegal: {0}
+error.bad.option=Uma das op\u00e7\u00f5es -{ctxu} deve ser especificada.
+error.bad.cflag=sinalizador 'c' requer que os arquivos de manifesto ou entrada sejam especificados!
+error.bad.uflag=sinalizador 'u' requer os arquivos de manifesto, o sinalizador 'e' ou os arquivos de entrada sejam especificados!
+error.bad.eflag=sinalizador 'e' manifesto com o atributo 'Main-Class' n\u00e3o podem ser especificados \njuntos!
+error.nosuch.fileordir={0} : n\u00e3o h\u00e1 tal arquivo ou diret\u00f3rio
+error.write.file=Erro ao gravar o arquivo jar existente
+error.create.dir={0} : n\u00e3o foi poss\u00edvel gravar o diret\u00f3rio
+error.incorrect.length=largura incorreta durante processamento: {0}
+out.added.manifest=manifesto adicionado
+out.update.manifest=manifesto atualizado
+out.ignore.entry=ignorando entrada {0}
+out.adding=adicionando: {0}
+out.deflated=(vazio {0}%)
+out.stored=(armazenado 0%)
+out.create=\ \ criando: {0}
+out.extracted=extra\u00eddo: {0}
+out.inflated=\ \cheio: {0}
+out.size=(dento = {0}) (fora= {1})
+
+usage=Uso: arquivos jar {ctxui}[vfm0Me] [jar-file] [manifest-file] [entry-point] [-C dir] ...\nOp\u00e7\u00f5es:\n\ \   -c  cria novo arquivo de armazenamento\n\ \   -t  lista o sum\u00e1rio do arquivo de armazenamento\n\ \   -x  extrai arquivos nomeados (ou todos) do arquivo de armazenamento\n\ \   -u  atualizar o arquivo de armazenamento existente\n\ \   -v  gera sa\u00edda detalhada na sa\u00edda padr\u00e3o\n\ \   -f  especifica o nome do arquivo do arquivo de armazenamento\n\ \   -m  inclui as informa\u00e7\u00f5es do manifesto do arquivo de manifesto especificado\n\ \   -e  especifica o ponto de entrada do aplicativo para aplicativo independente \n\ \       empacotando em um arquivo jar execut\u00e1vel\n\ \   -0  armazena somente; n\u00e3o usa compacta\u00e7\u00e3o ZIP\n\ \   -M  n\u00e3o cria um arquivo de manifesto para as entradas\n\ \   -i  gera informa\u00e7\u00f5es de \u00edndice para os arquivos especificados\n\ \   -C  altera para o diret\u00f3rio e inclui o arquivo seguinte\nSe nenhum arquivo for um diret\u00f3rio, ent\u00e3o \u00e9 processado repetidamente.\nO nome do arquivo de manifesto, o nome do arquivo de armazenamento e o nome do ponto de entrada s\u00e3o\nespecificados na mesma ordem dos sinalizadores  'm', 'f' e 'e'.\n\nExemplo 1: para arquivar dois arquivos de classe em um arquivo de armazenamento denominado classes.jar: \n\ \      jar cvf classes.jar Foo.class Bar.class \nExemplo 2: use um arquivo de manifesto existente 'mymanifest' e arquive todos os\n\ \          arquivos no diret\u00f3rio foo/ na 'classes.jar': \n\ \      jar cvfm classes.jar mymanifest -C foo/ .\n
diff --git a/jdk/src/share/classes/sun/tools/jconsole/resources/JConsoleResources.java b/jdk/src/share/classes/sun/tools/jconsole/resources/JConsoleResources.java
index e642b2680322e169c0a913269dd0e962f304d676..7300a57c9feb81d9fed8edb2e7cc83e43b06caaa 100644
--- a/jdk/src/share/classes/sun/tools/jconsole/resources/JConsoleResources.java
+++ b/jdk/src/share/classes/sun/tools/jconsole/resources/JConsoleResources.java
@@ -434,8 +434,8 @@ public class JConsoleResources extends ListResourceBundle {
              "Usage: {0} [ -interval=n ] [ -notile ] [ -pluginpath  ] [ -version ] [ connection ... ]\n\n" +
              "  -interval   Set the update interval to n seconds (default is 4 seconds)\n" +
              "  -notile     Do not tile windows initially (for two or more connections)\n" +
-             "  -pluginpath Specify the path that jconsole uses to look up the plugins\n\n" +
-             "  -version    Print program version\n" +
+             "  -pluginpath Specify the path that jconsole uses to look up the plugins\n" +
+             "  -version    Print program version\n\n" +
              "  connection = pid || host:port || JMX URL (service:jmx:://...)\n" +
              "  pid         The process id of a target process\n" +
              "  host        A remote host name or IP address\n" +
diff --git a/jdk/src/share/classes/sun/tools/jconsole/resources/JConsoleResources_ja.java b/jdk/src/share/classes/sun/tools/jconsole/resources/JConsoleResources_ja.java
index 9fc4e95f7d863a686c299fd440b29dc169ab0f83..0ebcb2cc50ddccbc183e3192e23029e4dfae63f8 100644
--- a/jdk/src/share/classes/sun/tools/jconsole/resources/JConsoleResources_ja.java
+++ b/jdk/src/share/classes/sun/tools/jconsole/resources/JConsoleResources_ja.java
@@ -46,8 +46,6 @@ import static java.awt.event.KeyEvent.*;
  */
 public class JConsoleResources_ja extends JConsoleResources {
 
-    private static final String cr = System.getProperty("line.separator");
-
     /**
      * Returns the contents of this ResourceBundle.
      *
@@ -56,7 +54,7 @@ public class JConsoleResources_ja extends JConsoleResources {
      * @return the contents of this ResourceBundle.
      */
     protected Object[][] getContents0() {
-        return new Object[][] {
+        Object[][] temp = new Object[][] {
         // NOTE 1: The value strings in this file containing "{0}" are
         //         processed by the java.text.MessageFormat class.  Any
         //         single quotes appearing in these strings need to be
@@ -98,7 +96,7 @@ public class JConsoleResources_ja extends JConsoleResources {
         {"Attributes","\u5c5e\u6027"},
         {"Blank", "\u30d6\u30e9\u30f3\u30af"},
         {"BlockedCount WaitedCount",
-             "\u7dcf\u30d6\u30ed\u30c3\u30af\u6570 : {0}  \u7dcf\u5f85\u6a5f\u6570 : {1}" + cr},
+             "\u7dcf\u30d6\u30ed\u30c3\u30af\u6570 : {0}  \u7dcf\u5f85\u6a5f\u6570 : {1}\n"},
         {"Boot class path","\u30d6\u30fc\u30c8\u30af\u30e9\u30b9\u30d1\u30b9"},
         {"BorderedComponent.moreOrLessButton.toolTip", "\u8a73\u7d30\u60c5\u5831\u3092\u8868\u793a\u3059\u308b\u304b\u3069\u3046\u304b\u5207\u308a\u66ff\u3048\u308b"},
         {"CPU Usage","CPU \u4f7f\u7528\u72b6\u6cc1"},
@@ -268,21 +266,21 @@ public class JConsoleResources_ja extends JConsoleResources {
         {"Minimize All.mnemonic", 'M'},
         {"Minus Version", "\u3053\u308c\u306f {0} \u30d0\u30fc\u30b8\u30e7\u30f3 {1} \u3067\u3059"},
         {"Monitor locked",
-             "   - \u30ed\u30c3\u30af\u3055\u308c\u305f {0}" + cr},
+             "   - \u30ed\u30c3\u30af\u3055\u308c\u305f {0}\n"},
         {"Motif","Motif"},
         {"Name Build and Mode","{0} (\u30d3\u30eb\u30c9 {1}, {2})"},
         {"Name and Build","{0} (\u30d3\u30eb\u30c9 {1})"},
         {"Name","\u540d\u524d"},
         {"Name: ","\u540d\u524d: "},
         {"Name State",
-             "\u540d\u524d: {0}" + cr +
-             "\u72b6\u614b: {1}" + cr},
+             "\u540d\u524d: {0}\n" +
+             "\u72b6\u614b: {1}\n"},
         {"Name State LockName",
-             "\u540d\u524d: {0}" + cr +
-             "\u72b6\u614b: {1} ({2} \u4e0a)" + cr},
+             "\u540d\u524d: {0}\n" +
+             "\u72b6\u614b: {1} ({2} \u4e0a)\n"},
         {"Name State LockName LockOwner",
-             "\u540d\u524d: {0}" + cr +
-             "\u72b6\u614b: {1} ({2} \u4e0a) \u6240\u6709\u8005: {3}" + cr},
+             "\u540d\u524d: {0}\n" +
+             "\u72b6\u614b: {1} ({2} \u4e0a) \u6240\u6709\u8005: {3}\n"},
         {"New Connection...", "\u65b0\u898f\u63a5\u7d9a(N)..."},
         {"New Connection....mnemonic", 'N'},
         {"New value applied","\u65b0\u3057\u3044\u5024\u304c\u9069\u7528\u3055\u308c\u307e\u3057\u305f"},
@@ -348,7 +346,7 @@ public class JConsoleResources_ja extends JConsoleResources {
         {"Size Mb","{0} M \u30d0\u30a4\u30c8"},
         {"Source","\u30bd\u30fc\u30b9"},
         {"Stack trace",
-             cr + "\u30b9\u30bf\u30c3\u30af\u30c8\u30ec\u30fc\u30b9: " + cr},
+             "\n\u30b9\u30bf\u30c3\u30af\u30c8\u30ec\u30fc\u30b9: \n"},
         {"Success:","\u6210\u529f:"},
         // Note: SummaryTab.headerDateTimeFormat can be one the following:
         // 1. A combination of two styles for date and time, using the
@@ -426,22 +424,29 @@ public class JConsoleResources_ja extends JConsoleResources {
         {"plot", "\u30d7\u30ed\u30c3\u30c8"},
         {"visualize","\u8868\u793a"},
         {"zz usage text",
-             "\u4f7f\u3044\u65b9: {0} [ -interval=n ] [ -notile ] [ -pluginpath  ] [ -version ] [ connection ... ]" + cr +
-             cr +
-             "  -interval   \u66f4\u65b0\u9593\u9694\u3092 n \u79d2\u306b\u8a2d\u5b9a\u3059\u308b (\u30c7\u30d5\u30a9\u30eb\u30c8\u306f 4 \u79d2)" + cr +
-             "  -notile     \u521d\u671f\u72b6\u614b\u306e\u30a6\u30a3\u30f3\u30c9\u30a6\u3092\u30bf\u30a4\u30eb\u72b6\u306b\u4e26\u3079\u306a\u3044 (\u63a5\u7d9a\u304c\u8907\u6570\u3042\u308b\u5834\u5408)" + cr +
-             "  -pluginpath JConsole \u3067\u30d7\u30e9\u30b0\u30a4\u30f3\u3092\u63a2\u3059\u305f\u3081\u306b\u4f7f\u7528\u3059\u308b\u30d1\u30b9\u3092\u6307\u5b9a\u3059\u308b" + cr +
-             "  -version    \u30d7\u30ed\u30b0\u30e9\u30e0\u306e\u30d0\u30fc\u30b8\u30e7\u30f3\u3092\u51fa\u529b\u3059\u308b" + cr +
-             cr +
-             "  connection = pid || host:port || JMX URL (service:jmx:://...)" + cr +
-             "  pid         \u30bf\u30fc\u30b2\u30c3\u30c8\u30d7\u30ed\u30bb\u30b9\u306e\u30d7\u30ed\u30bb\u30b9 ID" + cr +
-             "  host        \u30ea\u30e2\u30fc\u30c8\u30db\u30b9\u30c8\u306e\u540d\u524d\u307e\u305f\u306f IP \u30a2\u30c9\u30ec\u30b9" + cr +
-             "  port        \u30ea\u30e2\u30fc\u30c8\u63a5\u7d9a\u7528\u306e\u30dd\u30fc\u30c8\u756a\u53f7" + cr +
-             cr +
-             "  -J          JConsole \u3092\u5b9f\u884c\u3059\u308b Java \u4eee\u60f3\u30de\u30b7\u30f3\u3078\u306e" + cr +
+             "\u4f7f\u3044\u65b9: {0} [ -interval=n ] [ -notile ] [ -pluginpath  ] [ -version ] [ connection ... ]\n\n" +
+             "  -interval   \u66f4\u65b0\u9593\u9694\u3092 n \u79d2\u306b\u8a2d\u5b9a\u3059\u308b (\u30c7\u30d5\u30a9\u30eb\u30c8\u306f 4 \u79d2)\n" +
+             "  -notile     \u521d\u671f\u72b6\u614b\u306e\u30a6\u30a3\u30f3\u30c9\u30a6\u3092\u30bf\u30a4\u30eb\u72b6\u306b\u4e26\u3079\u306a\u3044 (\u63a5\u7d9a\u304c\u8907\u6570\u3042\u308b\u5834\u5408)\n" +
+             "  -pluginpath JConsole \u3067\u30d7\u30e9\u30b0\u30a4\u30f3\u3092\u63a2\u3059\u305f\u3081\u306b\u4f7f\u7528\u3059\u308b\u30d1\u30b9\u3092\u6307\u5b9a\u3059\u308b\n" +
+             "  -version    \u30d7\u30ed\u30b0\u30e9\u30e0\u306e\u30d0\u30fc\u30b8\u30e7\u30f3\u3092\u51fa\u529b\u3059\u308b\n\n" +
+             "  connection = pid || host:port || JMX URL (service:jmx:://...)\n" +
+             "  pid         \u30bf\u30fc\u30b2\u30c3\u30c8\u30d7\u30ed\u30bb\u30b9\u306e\u30d7\u30ed\u30bb\u30b9 ID\n" +
+             "  host        \u30ea\u30e2\u30fc\u30c8\u30db\u30b9\u30c8\u306e\u540d\u524d\u307e\u305f\u306f IP \u30a2\u30c9\u30ec\u30b9\n" +
+             "  port        \u30ea\u30e2\u30fc\u30c8\u63a5\u7d9a\u7528\u306e\u30dd\u30fc\u30c8\u756a\u53f7\n\n" +
+             "  -J          JConsole \u3092\u5b9f\u884c\u3059\u308b Java \u4eee\u60f3\u30de\u30b7\u30f3\u3078\u306e\n" +
              "              \u5165\u529b\u5f15\u6570\u3092\u6307\u5b9a\u3059\u308b"},
         // END OF MATERIAL TO LOCALIZE
         };
+
+        String ls = System.getProperty("line.separator");
+        for(int i=0;iResourceBundle.
      *
@@ -56,7 +54,7 @@ public class JConsoleResources_zh_CN extends JConsoleResources {
      * @return the contents of this ResourceBundle.
      */
     protected Object[][] getContents0() {
-        return new Object[][] {
+        Object[][] temp = new Object[][] {
         // NOTE 1: The value strings in this file containing "{0}" are
         //         processed by the java.text.MessageFormat class.  Any
         //         single quotes appearing in these strings need to be
@@ -98,7 +96,7 @@ public class JConsoleResources_zh_CN extends JConsoleResources {
         {"Attributes","\u5c5e\u6027"},
         {"Blank", "\u7a7a\u767d"},
         {"BlockedCount WaitedCount",
-             "\u963b\u585e\u603b\u6570\uff1a{0}  \u7b49\u5f85\u603b\u6570\uff1a {1}" + cr},
+             "\u963b\u585e\u603b\u6570\uff1a{0}  \u7b49\u5f85\u603b\u6570\uff1a {1}\n"},
         {"Boot class path","\u5f15\u5bfc\u7c7b\u8def\u5f84"},
         {"BorderedComponent.moreOrLessButton.toolTip", "\u5207\u6362\u4ee5\u663e\u793a\u8f83\u591a\u4fe1\u606f\u6216\u8f83\u5c11\u4fe1\u606f"},
         {"CPU Usage","CPU \u4f7f\u7528\u60c5\u51b5"},
@@ -268,21 +266,21 @@ public class JConsoleResources_zh_CN extends JConsoleResources {
         {"Minimize All.mnemonic", 'M'},
         {"Minus Version", "\u8fd9\u662f {0} \u7248\u672c {1}"},
         {"Monitor locked",
-             "   - \u5df2\u9501\u5b9a {0}" + cr},
+             "   - \u5df2\u9501\u5b9a {0}\n"},
         {"Motif","\u4fee\u6539"},
         {"Name Build and Mode","{0}\uff08\u5185\u90e8\u7248\u672c {1}\u3001{2}\uff09"},
         {"Name and Build","{0}\uff08\u5185\u90e8\u7248\u672c {1}\uff09"},
         {"Name","\u540d\u79f0"},
         {"Name: ","\u540d\u79f0\uff1a "},
         {"Name State",
-             "\u540d\u79f0\uff1a {0}" + cr +
-             "\u72b6\u6001\uff1a {1}" + cr},
+             "\u540d\u79f0\uff1a {0}\n" +
+             "\u72b6\u6001\uff1a {1}\n"},
         {"Name State LockName",
-             "\u540d\u79f0\uff1a {0}" + cr +
-             "\u72b6\u6001\uff1a{1} \u5728 {2} \u4e0a" + cr},
+             "\u540d\u79f0\uff1a {0}\n" +
+             "\u72b6\u6001\uff1a{1} \u5728 {2} \u4e0a\n"},
         {"Name State LockName LockOwner",
-             "\u540d\u79f0\uff1a {0}" + cr +
-             "\u72b6\u6001\uff1a{1} \u5728 {2} \u4e0a\uff0c\u62e5\u6709\u8005\uff1a {3}" + cr},
+             "\u540d\u79f0\uff1a {0}\n" +
+             "\u72b6\u6001\uff1a{1} \u5728 {2} \u4e0a\uff0c\u62e5\u6709\u8005\uff1a {3}\n"},
         {"New Connection...", "\u65b0\u5efa\u8fde\u63a5..."},
         {"New Connection....mnemonic", 'N'},
         {"New value applied","\u5df2\u5e94\u7528\u65b0\u503c"},
@@ -348,7 +346,7 @@ public class JConsoleResources_zh_CN extends JConsoleResources {
         {"Size Mb","{0} Mb"},
         {"Source","\u6e90"},
         {"Stack trace",
-             cr + "\u5806\u6808\u8ffd\u8e2a\uff1a " + cr},
+             "\n\u5806\u6808\u8ffd\u8e2a\uff1a \n"},
         {"Success:","\u6210\u529f\uff1a"},
         // Note: SummaryTab.headerDateTimeFormat can be one the following:
         // 1. A combination of two styles for date and time, using the
@@ -426,22 +424,29 @@ public class JConsoleResources_zh_CN extends JConsoleResources {
         {"plot", "\u7ed8\u56fe"},
         {"visualize","\u663e\u793a"},
         {"zz usage text",
-             "\u7528\u6cd5: {0} [ -interval=n ] [ -notile ] [ -pluginpath  ] [ -version ] [ connection ...]" + cr +
-             cr +
-             "  -interval   \u5c06\u66f4\u65b0\u95f4\u9694\u65f6\u95f4\u8bbe\u7f6e\u4e3a n \u79d2\uff08\u9ed8\u8ba4\u503c\u4e3a 4 \u79d2\uff09" + cr +
-             "  -notile     \u6700\u521d\u4e0d\u5e73\u94fa\u663e\u793a\u7a97\u53e3\uff08\u5bf9\u4e8e\u4e24\u4e2a\u6216\u66f4\u591a\u8fde\u63a5\uff09" + cr +
-             "  -pluginpath \u6307\u5b9a jconsole \u7528\u4e8e\u67e5\u627e\u63d2\u4ef6\u7684\u8def\u5f84" + cr +
-             "  -version    \u8f93\u51fa\u7a0b\u5e8f\u7248\u672c" + cr +
-             cr +
-             "  connection = pid || host:port || JMX URL (service:jmx:://...)" + cr +
-             "  pid       \u76ee\u6807\u8fdb\u7a0b\u7684\u8fdb\u7a0b ID" + cr +
-             "  host      \u8fdc\u7a0b\u4e3b\u673a\u540d\u6216 IP \u5730\u5740" + cr +
-             "  port      \u7528\u4e8e\u8fdc\u7a0b\u8fde\u63a5\u7684\u7aef\u53e3\u53f7" + cr +
-             cr +
-             "  -J          \u5bf9\u6b63\u5728\u8fd0\u884c jconsole \u7684 Java \u865a\u62df\u673a\u6307\u5b9a" + cr +
+             "\u7528\u6cd5: {0} [ -interval=n ] [ -notile ] [ -pluginpath  ] [ -version ] [ connection ...]\n\n" +
+             "  -interval   \u5c06\u66f4\u65b0\u95f4\u9694\u65f6\u95f4\u8bbe\u7f6e\u4e3a n \u79d2\uff08\u9ed8\u8ba4\u503c\u4e3a 4 \u79d2\uff09\n" +
+             "  -notile     \u6700\u521d\u4e0d\u5e73\u94fa\u663e\u793a\u7a97\u53e3\uff08\u5bf9\u4e8e\u4e24\u4e2a\u6216\u66f4\u591a\u8fde\u63a5\uff09\n" +
+             "  -pluginpath \u6307\u5b9a jconsole \u7528\u4e8e\u67e5\u627e\u63d2\u4ef6\u7684\u8def\u5f84\n" +
+             "  -version    \u8f93\u51fa\u7a0b\u5e8f\u7248\u672c\n\n" +
+             "  connection = pid || host:port || JMX URL (service:jmx:://...)\n" +
+             "  pid       \u76ee\u6807\u8fdb\u7a0b\u7684\u8fdb\u7a0b ID\n" +
+             "  host      \u8fdc\u7a0b\u4e3b\u673a\u540d\u6216 IP \u5730\u5740\n" +
+             "  port      \u7528\u4e8e\u8fdc\u7a0b\u8fde\u63a5\u7684\u7aef\u53e3\u53f7\n\n" +
+             "  -J          \u5bf9\u6b63\u5728\u8fd0\u884c jconsole \u7684 Java \u865a\u62df\u673a\u6307\u5b9a\n" +
              "            \u8f93\u5165\u53c2\u6570"},
         // END OF MATERIAL TO LOCALIZE
         };
+
+        String ls = System.getProperty("line.separator");
+        for(int i=0;i/demo/nio/ZipFileSystem/zipfs.jar
- * into your class path as showed above.
+ * java Demo action ZipfileName [...]
  *
  * @author Xueming Shen
  */
@@ -153,14 +148,11 @@ public class Demo {
         Action action = Action.valueOf(args[0]);
         Map env = env = new HashMap<>();
         if (action == Action.create)
-            env.put("createNew", true);
+            env.put("create", "true");
         if (action == Action.tlist || action == Action.twalk)
             env.put("buildDirTree", true);
+        FileSystem fs = FileSystems.newFileSystem(Paths.get(args[1]), env, null);
 
-        FileSystem fs = FileSystems.newFileSystem(
-                            URI.create("zip" + Paths.get(args[1]).toUri().toString().substring(4)),
-                            env,
-                            null);
         try {
             FileSystem fs2;
             Path path, src, dst;
@@ -207,19 +199,13 @@ public class Demo {
                 src.copyTo(dst, COPY_ATTRIBUTES);
                 break;
             case zzmove:
-                fs2 = FileSystems.newFileSystem(
-                    URI.create("zip" + Paths.get(args[2]).toUri().toString().substring(4)),
-                    env,
-                    null);
+                fs2 = FileSystems.newFileSystem(Paths.get(args[2]), env, null);
                 //sf1.getPath(args[3]).moveTo(fs2.getPath(args[3]));
                 z2zmove(fs, fs2, args[3]);
                 fs2.close();
                 break;
             case zzcopy:
-                fs2 = FileSystems.newFileSystem(
-                    URI.create("zip" + Paths.get(args[2]).toUri().toString().substring(4)),
-                    env,
-                    null);
+                fs2 = FileSystems.newFileSystem(Paths.get(args[2]), env, null);
                 //sf1.getPath(args[3]).copyTo(fs2.getPath(args[3]));
                 z2zcopy(fs, fs2, args[3]);
                 fs2.close();
diff --git a/jdk/src/share/demo/nio/zipfs/README.txt b/jdk/src/share/demo/nio/zipfs/README.txt
index d5517bf7baeb481e4c601863944fee63c733421e..9a216e48d704aa4f8dbcab7812df5ebb8d4018cd 100644
--- a/jdk/src/share/demo/nio/zipfs/README.txt
+++ b/jdk/src/share/demo/nio/zipfs/README.txt
@@ -1,10 +1,6 @@
 ZipFileSystem is a file system provider that treats the contents of a zip or
 JAR file as a java.nio.file.FileSystem.
 
-To deploy the provider you must copy zipfs.jar into your extensions
-directory or else add /demo/nio/zipfs/zipfs.jar
-to your class path.
-
 The factory methods defined by the java.nio.file.FileSystems class can be
 used to create a FileSystem, eg:
 
@@ -15,9 +11,9 @@ used to create a FileSystem, eg:
 
 -or
 
-   // locate file system by URI
+   // locate file system by the legacy JAR URL syntax
    Map env = Collections.emptyMap();
-   URI uri = URI.create("zip:///mydir/foo.jar");
+   URI uri = URI.create("jar:file:/mydir/foo.jar");
    FileSystem fs = FileSystems.newFileSystem(uri, env);
 
 Once a FileSystem is created then classes in the java.nio.file package
@@ -26,4 +22,6 @@ can be used to access files in the zip/JAR file, eg:
    Path mf = fs.getPath("/META-INF/MANIFEST.MF");
    InputStream in = mf.newInputStream();
 
+See Demo.java for more interesting usages.
+
 
diff --git a/jdk/src/share/demo/nio/zipfs/META-INF/services/java.nio.file.spi.FileSystemProvider b/jdk/src/share/demo/nio/zipfs/src/META-INF/services/java.nio.file.spi.FileSystemProvider
similarity index 50%
rename from jdk/src/share/demo/nio/zipfs/META-INF/services/java.nio.file.spi.FileSystemProvider
rename to jdk/src/share/demo/nio/zipfs/src/META-INF/services/java.nio.file.spi.FileSystemProvider
index ace131aa0fd72ee57c88e85000f1f54840b5c138..58ee3a6b9727d7215c65474d48a1eb7239da1ebf 100644
--- a/jdk/src/share/demo/nio/zipfs/META-INF/services/java.nio.file.spi.FileSystemProvider
+++ b/jdk/src/share/demo/nio/zipfs/src/META-INF/services/java.nio.file.spi.FileSystemProvider
@@ -1,3 +1,2 @@
 com.sun.nio.zipfs.ZipFileSystemProvider
-com.sun.nio.zipfs.JarFileSystemProvider
 
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/JarFileSystemProvider.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/JarFileSystemProvider.java
similarity index 100%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/JarFileSystemProvider.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/JarFileSystemProvider.java
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipCoder.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipCoder.java
similarity index 100%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipCoder.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipCoder.java
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipConstants.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipConstants.java
similarity index 100%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipConstants.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipConstants.java
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipDirectoryStream.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipDirectoryStream.java
similarity index 100%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipDirectoryStream.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipDirectoryStream.java
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileAttributeView.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileAttributeView.java
similarity index 100%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileAttributeView.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileAttributeView.java
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileAttributes.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileAttributes.java
similarity index 100%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileAttributes.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileAttributes.java
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileStore.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileStore.java
similarity index 100%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileStore.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileStore.java
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileSystem.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystem.java
similarity index 99%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileSystem.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystem.java
index eddc5ac938229cfb040d3de799f6e9e6fdf934fa..21094011c01be0c31af45821ee912b9a0a425610 100644
--- a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileSystem.java
+++ b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystem.java
@@ -91,11 +91,11 @@ public class ZipFileSystem extends FileSystem {
         throws IOException
     {
         // configurable env setup
+        this.createNew    = "true".equals(env.get("create"));
+        this.nameEncoding = env.containsKey("encoding") ?
+                            (String)env.get("encoding") : "UTF-8";
         this.buildDirTree = TRUE.equals(env.get("buildDirTreea"));
         this.useTempFile  = TRUE.equals(env.get("useTempFile"));
-        this.createNew    = TRUE.equals(env.get("createNew"));
-        this.nameEncoding = env.containsKey("nameEncoding") ?
-                            (String)env.get("nameEncoding") : "UTF-8";
         this.defaultDir   = env.containsKey("default.dir") ?
                             (String)env.get("default.dir") : "/";
         if (this.defaultDir.charAt(0) != '/')
@@ -1176,7 +1176,9 @@ public class ZipFileSystem extends FileSystem {
         } else {
             os.write(buf, 0, LOCHDR);    // write out the loc header
             locoff += LOCHDR;
-            size += LOCNAM(buf) + LOCEXT(buf) + LOCSIZ(buf);
+            // use e.csize,  LOCSIZ(buf) is zero if FLAG_DATADESCR is on
+            // size += LOCNAM(buf) + LOCEXT(buf) + LOCSIZ(buf);
+            size += LOCNAM(buf) + LOCEXT(buf) + e.csize;
             written = LOCHDR + size;
         }
         int n;
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileSystemProvider.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java
similarity index 88%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileSystemProvider.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java
index 08c3a17648c2f0e3e2e72d8b678b940968be6923..cf39b07cae7540cb0cf95c366d3e6cf10409a0d8 100644
--- a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileSystemProvider.java
+++ b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java
@@ -63,7 +63,7 @@ public class ZipFileSystemProvider extends FileSystemProvider {
 
     @Override
     public String getScheme() {
-        return "zip";
+        return "jar";
     }
 
     protected Path uriToPath(URI uri) {
@@ -72,10 +72,14 @@ public class ZipFileSystemProvider extends FileSystemProvider {
             throw new IllegalArgumentException("URI scheme is not '" + getScheme() + "'");
         }
         try {
-            return Paths.get(new URI("file", uri.getHost(), uri.getPath(), null))
-                        .toAbsolutePath();
+            // only support legacy JAR URL syntax  jar:{uri}!/{entry} for now
+            String spec = uri.getSchemeSpecificPart();
+            int sep = spec.indexOf("!/");
+            if (sep != -1)
+                spec = spec.substring(0, sep);
+            return Paths.get(new URI(spec)).toAbsolutePath();
         } catch (URISyntaxException e) {
-            throw new AssertionError(e); //never thrown
+            throw new IllegalArgumentException(e.getMessage(), e);
         }
     }
 
@@ -119,14 +123,14 @@ public class ZipFileSystemProvider extends FileSystemProvider {
 
     @Override
     public Path getPath(URI uri) {
-        FileSystem fs = getFileSystem(uri);
-        String fragment = uri.getFragment();
-        if (fragment == null) {
+
+        String spec = uri.getSchemeSpecificPart();
+        int sep = spec.indexOf("!/");
+        if (sep == -1)
             throw new IllegalArgumentException("URI: "
                 + uri
-                + " does not contain path fragment ex. zip:///c:/foo.zip#/BAR");
-        }
-        return fs.getPath(fragment);
+                + " does not contain path info ex. jar:file:/c:/foo.zip!/BAR");
+        return getFileSystem(uri).getPath(spec.substring(sep + 1));
     }
 
     @Override
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipInfo.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipInfo.java
similarity index 98%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipInfo.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipInfo.java
index dd18cc9f4440044337b006ae815da5a29d9e709e..56954e1d9eab231dbdd1416837650b90ccfffcbc 100644
--- a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipInfo.java
+++ b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipInfo.java
@@ -33,9 +33,7 @@ package com.sun.nio.zipfs;
 
 import java.nio.file.Paths;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.Map;
-import com.sun.nio.zipfs.ZipFileSystem.Entry;
 import static com.sun.nio.zipfs.ZipConstants.*;
 import static com.sun.nio.zipfs.ZipUtils.*;
 
@@ -172,7 +170,7 @@ public class ZipInfo {
 
     static void printExtra(byte[] extra, int off, int len) {
         int end = off + len;
-        while (off + 4 < end) {
+        while (off + 4 <= end) {
             int tag = SH(extra, off);
             int sz = SH(extra, off + 2);
             print("        [tag=0x%04x, sz=%d, data= ", tag, sz);
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipPath.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java
similarity index 98%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipPath.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java
index 5fba2fafa9aef2c022b056e3418bd66153328b4c..a2c766f0da2f92666f533461c4332c984f2be13d 100644
--- a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipPath.java
+++ b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java
@@ -191,13 +191,12 @@ public class ZipPath extends Path {
 
     @Override
     public URI toUri() {
-        String zfPath = zfs.toString();
-        if (File.separatorChar == '\\')  // replace all separators by '/'
-            zfPath = "/" + zfPath.replace("\\", "/");
         try {
-            return new URI("zip", "",
-                           zfPath,
-                           zfs.getString(toAbsolutePath().path));
+            return new URI("jar",
+                           zfs.getZipFile().toUri() +
+                           "!" +
+                           zfs.getString(toAbsolutePath().path),
+                           null);
         } catch (Exception ex) {
             throw new AssertionError(ex);
         }
diff --git a/jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipUtils.java b/jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipUtils.java
similarity index 100%
rename from jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipUtils.java
rename to jdk/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipUtils.java
diff --git a/jdk/src/share/demo/zipfs b/jdk/src/share/demo/zipfs
new file mode 100644
index 0000000000000000000000000000000000000000..fd2ba7311b10082c5bbda04d1e49ef1db9600549
--- /dev/null
+++ b/jdk/src/share/demo/zipfs
@@ -0,0 +1,703 @@
+/*
+ * Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *   - Neither the name of Oracle nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+import java.nio.file.*;
+import java.nio.file.attribute.*;
+import java.net.*;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+import static java.nio.file.StandardOpenOption.*;
+import static java.nio.file.StandardCopyOption.*;
+
+/*
+ * ZipFileSystem usage demo
+ *
+ * java Demo action ZipfileName [...]
+ *
+ * @author Xueming Shen
+ */
+
+public class Demo {
+
+    static enum Action {
+        rename,          // 
+                         // rename entry src to dst inside zipfile
+
+        movein,          // 
+                         // move an external src file into zipfile
+                         // as entry dst
+
+        moveout,         // 
+                         // move a zipfile entry src out to dst
+
+        copy,            // 
+                         // copy entry src to dst inside zipfile
+
+        copyin,          // 
+                         // copy an external src file into zipfile
+                         // as entry dst
+
+        copyin_attrs,    // 
+                         // copy an external src file into zipfile
+                         // as entry dst, with attributes (timestamp)
+
+        copyout,         // 
+                         // copy zipfile entry src" out to file dst
+
+        copyout_attrs,   // 
+
+        zzmove,          // 
+                         // move entry path/dir from zfsrc to zfdst
+
+        zzcopy,          // 
+                         // copy path from zipfile zfsrc to zipfile
+                         // zfdst
+
+        attrs,           // 
+                         // printout the attributes of entry path
+
+        attrsspace,      // 
+                         // printout the storespace attrs of entry path
+
+        setmtime,        // 
+                         // set the lastModifiedTime of entry path
+
+        setatime,        // 
+        setctime,        // 
+
+        lsdir,           // 
+                         // list dir's direct child files/dirs
+
+        mkdir,           // 
+
+        mkdirs,          // 
+
+        rmdirs,          // 
+
+        list,            // 
+                         // recursively list all entries of dir
+                         // via DirectoryStream
+
+        tlist,           // 
+                         // list with buildDirTree=true
+
+        vlist,           // 
+                         // recursively verbose list all entries of
+                         // dir via DirectoryStream
+
+        walk,            // 
+                         // recursively walk all entries of dir
+                         // via Files.walkFileTree
+
+        twalk,           // 
+                         // walk with buildDirTree=true
+
+        extract,         // 
+
+        update,          // 
+
+        delete,          // 
+
+        add,             // 
+
+        create,          // 
+                         // create a new zipfile if it doesn't exit
+                         // and then add the file(s) into it.
+
+        attrs2,          // 
+                         // test different ways to print attrs
+
+        prof,
+    }
+
+    public static void main(String[] args) throws Throwable {
+
+        Action action = Action.valueOf(args[0]);
+        Map env = env = new HashMap<>();
+        if (action == Action.create)
+            env.put("create", "true");
+        if (action == Action.tlist || action == Action.twalk)
+            env.put("buildDirTree", true);
+        FileSystem fs = FileSystems.newFileSystem(Paths.get(args[1]), env, null);
+
+        try {
+            FileSystem fs2;
+            Path path, src, dst;
+            boolean isRename = false;
+            switch (action) {
+            case rename:
+                src = fs.getPath(args[2]);
+                dst = fs.getPath(args[3]);
+                src.moveTo(dst);
+                break;
+            case moveout:
+                src = fs.getPath(args[2]);
+                dst = Paths.get(args[3]);
+                src.moveTo(dst);
+                break;
+            case movein:
+                src = Paths.get(args[2]);
+                dst = fs.getPath(args[3]);
+                src.moveTo(dst);
+                break;
+            case copy:
+                src = fs.getPath(args[2]);
+                dst = fs.getPath(args[3]);
+                src.copyTo(dst);
+                break;
+            case copyout:
+                src = fs.getPath(args[2]);
+                dst = Paths.get(args[3]);
+                src.copyTo(dst);
+                break;
+            case copyin:
+                src = Paths.get(args[2]);
+                dst = fs.getPath(args[3]);
+                src.copyTo(dst);
+                break;
+            case copyin_attrs:
+                src = Paths.get(args[2]);
+                dst = fs.getPath(args[3]);
+                src.copyTo(dst, COPY_ATTRIBUTES);
+                break;
+            case copyout_attrs:
+                src = fs.getPath(args[2]);
+                dst = Paths.get(args[3]);
+                src.copyTo(dst, COPY_ATTRIBUTES);
+                break;
+            case zzmove:
+                fs2 = FileSystems.newFileSystem(Paths.get(args[2]), env, null);
+                //sf1.getPath(args[3]).moveTo(fs2.getPath(args[3]));
+                z2zmove(fs, fs2, args[3]);
+                fs2.close();
+                break;
+            case zzcopy:
+                fs2 = FileSystems.newFileSystem(Paths.get(args[2]), env, null);
+                //sf1.getPath(args[3]).copyTo(fs2.getPath(args[3]));
+                z2zcopy(fs, fs2, args[3]);
+                fs2.close();
+                break;
+            case attrs:
+                for (int i = 2; i < args.length; i++) {
+                    path = fs.getPath(args[i]);
+                    System.out.println(path);
+                    System.out.println(
+                        Attributes.readBasicFileAttributes(path).toString());
+                }
+                break;
+            case setmtime:
+                DateFormat df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
+                Date newDatetime = df.parse(args[2]);
+                for (int i = 3; i < args.length; i++) {
+                    path = fs.getPath(args[i]);
+                    path.setAttribute("lastModifiedTime",
+                                      FileTime.fromMillis(newDatetime.getTime()));
+                    System.out.println(
+                        Attributes.readBasicFileAttributes(path).toString());
+                }
+                break;
+            case setctime:
+                df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
+                newDatetime = df.parse(args[2]);
+                for (int i = 3; i < args.length; i++) {
+                    path = fs.getPath(args[i]);
+                    path.setAttribute("creationTime",
+                                      FileTime.fromMillis(newDatetime.getTime()));
+                    System.out.println(
+                        Attributes.readBasicFileAttributes(path).toString());
+                }
+                break;
+            case setatime:
+                df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
+                newDatetime = df.parse(args[2]);
+                for (int i = 3; i < args.length; i++) {
+                    path = fs.getPath(args[i]);
+                    path.setAttribute("lastAccessTime",
+                                      FileTime.fromMillis(newDatetime.getTime()));
+                    System.out.println(
+                        Attributes.readBasicFileAttributes(path).toString());
+                }
+                break;
+            case attrsspace:
+                path = fs.getPath("/");
+                FileStore fstore = path.getFileStore();
+                //System.out.println(fstore.getFileStoreAttributeView(FileStoreSpaceAttributeView.class)
+                //                         .readAttributes());
+                // or
+                System.out.printf("filestore[%s]%n", fstore.name());
+                System.out.printf("    totalSpace: %d%n",
+                                  (Long)fstore.getAttribute("space:totalSpace"));
+                System.out.printf("   usableSpace: %d%n",
+                                  (Long)fstore.getAttribute("space:usableSpace"));
+                System.out.printf("  unallocSpace: %d%n",
+                                  (Long)fstore.getAttribute("space:unallocatedSpace"));
+                break;
+            case list:
+            case tlist:
+                if (args.length < 3)
+                    list(fs.getPath("/"), false);
+                else
+                    list(fs.getPath(args[2]), false);
+                break;
+            case vlist:
+                if (args.length < 3)
+                    list(fs.getPath("/"), true);
+                else
+                    list(fs.getPath(args[2]), true);
+                break;
+            case twalk:
+            case walk:
+                walk(fs.getPath((args.length > 2)? args[2] : "/"));
+                break;
+            case extract:
+                if (args.length == 2) {
+                     extract(fs, "/");
+                } else {
+                    for (int i = 2; i < args.length; i++) {
+                        extract(fs, args[i]);
+                    }
+                }
+                break;
+            case delete:
+                for (int i = 2; i < args.length; i++)
+                    fs.getPath(args[i]).delete();
+                break;
+            case create:
+            case add:
+            case update:
+                for (int i = 2; i < args.length; i++) {
+                    update(fs, args[i]);
+                }
+                break;
+            case lsdir:
+                path = fs.getPath(args[2]);
+                final String fStr = (args.length > 3)?args[3]:"";
+                DirectoryStream ds = path.newDirectoryStream(
+                    new DirectoryStream.Filter() {
+                        public boolean accept(Path path) {
+                            return path.toString().contains(fStr);
+                        }
+                    });
+                for (Path p : ds)
+                    System.out.println(p);
+                break;
+            case mkdir:
+                fs.getPath(args[2]).createDirectory();
+                break;
+            case mkdirs:
+                mkdirs(fs.getPath(args[2]));
+                break;
+            case attrs2:
+                for (int i = 2; i < args.length; i++) {
+                    path = fs.getPath(args[i]);
+                    System.out.printf("%n%s%n", path);
+                    System.out.println("-------(1)---------");
+                    System.out.println(
+                        Attributes.readBasicFileAttributes(path).toString());
+                    System.out.println("-------(2)---------");
+                    Map map = path.readAttributes("zip:*");
+                    for (Map.Entry e : map.entrySet()) {
+                        System.out.printf("    %s : %s%n", e.getKey(), e.getValue());
+                    }
+                    System.out.println("-------(3)---------");
+                    map = path.readAttributes("size,lastModifiedTime,isDirectory");
+                    for (Map.Entry e : map.entrySet()) {
+                        System.out.printf("    %s : %s%n", e.getKey(), e.getValue());
+                    }
+                }
+                break;
+            case prof:
+                list(fs.getPath("/"), false);
+                while (true) {
+                    Thread.sleep(10000);
+                    //list(fs.getPath("/"), true);
+                    System.out.println("sleeping...");
+                }
+            }
+        } catch (Exception x) {
+            x.printStackTrace();
+        } finally {
+            if (fs != null)
+                fs.close();
+        }
+    }
+
+    private static byte[] getBytes(String name) {
+        return name.getBytes();
+    }
+
+    private static String getString(byte[] name) {
+        return new String(name);
+    }
+
+    private static void walk(Path path) throws IOException
+    {
+        Files.walkFileTree(
+            path,
+            new SimpleFileVisitor() {
+                private int indent = 0;
+                private void indent() {
+                    int n = 0;
+                    while (n++ < indent)
+                        System.out.printf(" ");
+                }
+
+                @Override
+                public FileVisitResult visitFile(Path file,
+                                                 BasicFileAttributes attrs)
+                {
+                    indent();
+                    System.out.printf("%s%n", file.getName().toString());
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult preVisitDirectory(Path dir,
+                                                         BasicFileAttributes attrs)
+                {
+                    indent();
+                    System.out.printf("[%s]%n", dir.toString());
+                    indent += 2;
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult postVisitDirectory(Path dir,
+                                                          IOException ioe)
+                {
+                    indent -= 2;
+                    return FileVisitResult.CONTINUE;
+                }
+        });
+    }
+
+    private static void update(FileSystem fs, String path) throws Throwable{
+        Path src = FileSystems.getDefault().getPath(path);
+        if (Boolean.TRUE.equals(src.getAttribute("isDirectory"))) {
+            DirectoryStream ds = src.newDirectoryStream();
+            for (Path child : ds)
+                update(fs, child.toString());
+            ds.close();
+        } else {
+            Path dst = fs.getPath(path);
+            Path parent = dst.getParent();
+            if (parent != null && parent.notExists())
+                mkdirs(parent);
+            src.copyTo(dst, REPLACE_EXISTING);
+        }
+    }
+
+    private static void extract(FileSystem fs, String path) throws Throwable{
+        Path src = fs.getPath(path);
+        if (Boolean.TRUE.equals(src.getAttribute("isDirectory"))) {
+            DirectoryStream ds = src.newDirectoryStream();
+            for (Path child : ds)
+                extract(fs, child.toString());
+            ds.close();
+        } else {
+            if (path.startsWith("/"))
+                path = path.substring(1);
+            Path dst = FileSystems.getDefault().getPath(path);
+            Path parent = dst.getParent();
+            if (parent.notExists())
+                mkdirs(parent);
+            src.copyTo(dst, REPLACE_EXISTING);
+        }
+    }
+
+    // use DirectoryStream
+    private static void z2zcopy(FileSystem src, FileSystem dst, String path)
+        throws IOException
+    {
+        Path srcPath = src.getPath(path);
+        Path dstPath = dst.getPath(path);
+
+        if (Boolean.TRUE.equals(srcPath.getAttribute("isDirectory"))) {
+            if (!dstPath.exists()) {
+                try {
+                    mkdirs(dstPath);
+                } catch (FileAlreadyExistsException x) {}
+            }
+            DirectoryStream ds = srcPath.newDirectoryStream();
+            for (Path child : ds) {
+                z2zcopy(src, dst,
+                        path + (path.endsWith("/")?"":"/") + child.getName());
+            }
+            ds.close();
+        } else {
+            //System.out.println("copying..." + path);
+            srcPath.copyTo(dstPath);
+        }
+    }
+
+    // use TreeWalk to move
+    private static void z2zmove(FileSystem src, FileSystem dst, String path)
+        throws IOException
+    {
+        final Path srcPath = src.getPath(path).toAbsolutePath();
+        final Path dstPath = dst.getPath(path).toAbsolutePath();
+
+        Files.walkFileTree(srcPath, new SimpleFileVisitor() {
+
+            @Override
+            public FileVisitResult visitFile(Path file,
+                                            BasicFileAttributes attrs)
+            {
+                Path dst = srcPath.relativize(file);
+                dst = dstPath.resolve(dst);
+                try {
+                    Path parent = dstPath.getParent();
+                    if (parent != null && parent.notExists())
+                        mkdirs(parent);
+                    file.moveTo(dst);
+                } catch (IOException x) {
+                    x.printStackTrace();
+                }
+                return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult preVisitDirectory(Path dir,
+                                                     BasicFileAttributes attrs)
+            {
+                Path dst = srcPath.relativize(dir);
+                dst = dstPath.resolve(dst);
+                try {
+
+                    if (dst.notExists())
+                        mkdirs(dst);
+                } catch (IOException x) {
+                    x.printStackTrace();
+                }
+                return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult postVisitDirectory(Path dir,
+                                                      IOException ioe)
+                throws IOException
+            {
+                try {
+                    dir.delete();
+                } catch (IOException x) {
+                    //x.printStackTrace();
+                }
+                return FileVisitResult.CONTINUE;
+            }
+        });
+
+    }
+
+    private static void mkdirs(Path path) throws IOException {
+        path = path.toAbsolutePath();
+        Path parent = path.getParent();
+        if (parent != null) {
+            if (parent.notExists())
+                mkdirs(parent);
+        }
+        path.createDirectory();
+    }
+
+    private static void rmdirs(Path path) throws IOException {
+        while (path != null && path.getNameCount() != 0) {
+            path.delete();
+            path = path.getParent();
+        }
+    }
+
+    private static void list(Path path, boolean verbose ) throws IOException {
+        if (!"/".equals(path.toString())) {
+           System.out.printf("  %s%n", path.toString());
+           if (verbose)
+                System.out.println(Attributes.readBasicFileAttributes(path).toString());
+        }
+        if (path.notExists())
+            return;
+        if (Attributes.readBasicFileAttributes(path).isDirectory()) {
+            DirectoryStream ds = path.newDirectoryStream();
+            for (Path child : ds)
+                list(child, verbose);
+            ds.close();
+        }
+    }
+
+    // check the content of two paths are equal
+    private static void checkEqual(Path src, Path dst) throws IOException
+    {
+        //System.out.printf("checking <%s> vs <%s>...%n",
+        //                  src.toString(), dst.toString());
+
+        //streams
+        InputStream isSrc = src.newInputStream();
+        InputStream isDst = dst.newInputStream();
+        byte[] bufSrc = new byte[8192];
+        byte[] bufDst = new byte[8192];
+
+        try {
+            int nSrc = 0;
+            while ((nSrc = isSrc.read(bufSrc)) != -1) {
+                int nDst = 0;
+                while (nDst < nSrc) {
+                    int n = isDst.read(bufDst, nDst, nSrc - nDst);
+                    if (n == -1) {
+                        System.out.printf("checking <%s> vs <%s>...%n",
+                                          src.toString(), dst.toString());
+                        throw new RuntimeException("CHECK FAILED!");
+                    }
+                    nDst += n;
+                }
+                while (--nSrc >= 0) {
+                    if (bufSrc[nSrc] != bufDst[nSrc]) {
+                        System.out.printf("checking <%s> vs <%s>...%n",
+                                          src.toString(), dst.toString());
+                        throw new RuntimeException("CHECK FAILED!");
+                    }
+                    nSrc--;
+                }
+            }
+        } finally {
+            isSrc.close();
+            isDst.close();
+        }
+
+        // channels
+        SeekableByteChannel chSrc = src.newByteChannel();
+        SeekableByteChannel chDst = dst.newByteChannel();
+        if (chSrc.size() != chDst.size()) {
+            System.out.printf("src[%s].size=%d, dst[%s].size=%d%n",
+                              chSrc.toString(), chSrc.size(),
+                              chDst.toString(), chDst.size());
+            throw new RuntimeException("CHECK FAILED!");
+        }
+        ByteBuffer bbSrc = ByteBuffer.allocate(8192);
+        ByteBuffer bbDst = ByteBuffer.allocate(8192);
+
+        try {
+            int nSrc = 0;
+            while ((nSrc = chSrc.read(bbSrc)) != -1) {
+                int nDst = chDst.read(bbDst);
+                if (nSrc != nDst) {
+                    System.out.printf("checking <%s> vs <%s>...%n",
+                                      src.toString(), dst.toString());
+                    throw new RuntimeException("CHECK FAILED!");
+                }
+                while (--nSrc >= 0) {
+                    if (bbSrc.get(nSrc) != bbDst.get(nSrc)) {
+                        System.out.printf("checking <%s> vs <%s>...%n",
+                                          src.toString(), dst.toString());
+                        throw new RuntimeException("CHECK FAILED!");
+                    }
+                    nSrc--;
+                }
+                bbSrc.flip();
+                bbDst.flip();
+            }
+        } catch (IOException x) {
+            x.printStackTrace();
+        } finally {
+            chSrc.close();
+            chDst.close();
+        }
+    }
+
+    private static void fchCopy(Path src, Path dst) throws IOException
+    {
+        Set read = new HashSet<>();
+        read.add(READ);
+        Set openwrite = new HashSet<>();
+        openwrite.add(CREATE_NEW);
+        openwrite.add(WRITE);
+
+        FileChannel srcFc = src.getFileSystem()
+                               .provider()
+                               .newFileChannel(src, read);
+        FileChannel dstFc = dst.getFileSystem()
+                               .provider()
+                               .newFileChannel(dst, openwrite);
+
+        try {
+            ByteBuffer bb = ByteBuffer.allocate(8192);
+            while (srcFc.read(bb) >= 0) {
+                bb.flip();
+                dstFc.write(bb);
+                bb.clear();
+            }
+        } finally {
+            srcFc.close();
+            dstFc.close();
+        }
+    }
+
+    private static void chCopy(Path src, Path dst) throws IOException
+    {
+        Set read = new HashSet<>();
+        read.add(READ);
+        Set openwrite = new HashSet<>();
+        openwrite.add(CREATE_NEW);
+        openwrite.add(WRITE);
+
+        SeekableByteChannel srcCh = src.newByteChannel(read);
+        SeekableByteChannel dstCh = dst.newByteChannel(openwrite);
+
+        try {
+            ByteBuffer bb = ByteBuffer.allocate(8192);
+            while (srcCh.read(bb) >= 0) {
+                bb.flip();
+                dstCh.write(bb);
+                bb.clear();
+            }
+        } finally {
+            srcCh.close();
+            dstCh.close();
+        }
+    }
+
+    private static void streamCopy(Path src, Path dst) throws IOException
+    {
+        InputStream isSrc = src.newInputStream();
+        OutputStream osDst = dst.newOutputStream();
+        byte[] buf = new byte[8192];
+        try {
+            int n = 0;
+            while ((n = isSrc.read(buf)) != -1) {
+                osDst.write(buf, 0, n);
+            }
+        } finally {
+            isSrc.close();
+            osDst.close();
+        }
+    }
+}
diff --git a/jdk/src/share/native/java/io/RandomAccessFile.c b/jdk/src/share/native/java/io/RandomAccessFile.c
index a8c3390b677a3acc62001ffbf09b77ce73e96aa0..437bab6b8318992c3aef42c12f20ecd1c14cfb2f 100644
--- a/jdk/src/share/native/java/io/RandomAccessFile.c
+++ b/jdk/src/share/native/java/io/RandomAccessFile.c
@@ -76,13 +76,13 @@ Java_java_io_RandomAccessFile_readBytes(JNIEnv *env,
 
 JNIEXPORT void JNICALL
 Java_java_io_RandomAccessFile_write(JNIEnv *env, jobject this, jint byte) {
-    writeSingle(env, this, byte, raf_fd);
+    writeSingle(env, this, byte, JNI_FALSE, raf_fd);
 }
 
 JNIEXPORT void JNICALL
 Java_java_io_RandomAccessFile_writeBytes(JNIEnv *env,
     jobject this, jbyteArray bytes, jint off, jint len) {
-    writeBytes(env, this, bytes, off, len, raf_fd);
+    writeBytes(env, this, bytes, off, len, JNI_FALSE, raf_fd);
 }
 
 JNIEXPORT jlong JNICALL
diff --git a/jdk/src/share/native/java/io/io_util.c b/jdk/src/share/native/java/io/io_util.c
index 986416e20d839c2126d738e031e7d61dd3292163..cef7d272ba24f8785f19c520bca331a5d1383429 100644
--- a/jdk/src/share/native/java/io/io_util.c
+++ b/jdk/src/share/native/java/io/io_util.c
@@ -127,7 +127,7 @@ readBytes(JNIEnv *env, jobject this, jbyteArray bytes,
 }
 
 void
-writeSingle(JNIEnv *env, jobject this, jint byte, jfieldID fid) {
+writeSingle(JNIEnv *env, jobject this, jint byte, jboolean append, jfieldID fid) {
     // Discard the 24 high-order bits of byte. See OutputStream#write(int)
     char c = (char) byte;
     jint n;
@@ -136,7 +136,11 @@ writeSingle(JNIEnv *env, jobject this, jint byte, jfieldID fid) {
         JNU_ThrowIOException(env, "Stream Closed");
         return;
     }
-    n = IO_Write(fd, &c, 1);
+    if (append == JNI_TRUE) {
+        n = IO_Append(fd, &c, 1);
+    } else {
+        n = IO_Write(fd, &c, 1);
+    }
     if (n == JVM_IO_ERR) {
         JNU_ThrowIOExceptionWithLastError(env, "Write error");
     } else if (n == JVM_IO_INTR) {
@@ -146,7 +150,7 @@ writeSingle(JNIEnv *env, jobject this, jint byte, jfieldID fid) {
 
 void
 writeBytes(JNIEnv *env, jobject this, jbyteArray bytes,
-           jint off, jint len, jfieldID fid)
+           jint off, jint len, jboolean append, jfieldID fid)
 {
     jint n;
     char stackBuf[BUF_SIZE];
@@ -185,7 +189,11 @@ writeBytes(JNIEnv *env, jobject this, jbyteArray bytes,
                 JNU_ThrowIOException(env, "Stream Closed");
                 break;
             }
-            n = IO_Write(fd, buf+off, len);
+            if (append == JNI_TRUE) {
+                n = IO_Append(fd, buf+off, len);
+            } else {
+                n = IO_Write(fd, buf+off, len);
+            }
             if (n == JVM_IO_ERR) {
                 JNU_ThrowIOExceptionWithLastError(env, "Write error");
                 break;
diff --git a/jdk/src/share/native/java/io/io_util.h b/jdk/src/share/native/java/io/io_util.h
index 436acdff16d21d73b2015d5692a44dbb3c3cd4c1..b98c5274a4818dd31f12e9a46b023f318699455e 100644
--- a/jdk/src/share/native/java/io/io_util.h
+++ b/jdk/src/share/native/java/io/io_util.h
@@ -41,9 +41,9 @@ extern jfieldID IO_handle_fdID;
 jint readSingle(JNIEnv *env, jobject this, jfieldID fid);
 jint readBytes(JNIEnv *env, jobject this, jbyteArray bytes, jint off,
                jint len, jfieldID fid);
-void writeSingle(JNIEnv *env, jobject this, jint byte, jfieldID fid);
+void writeSingle(JNIEnv *env, jobject this, jint byte, jboolean append, jfieldID fid);
 void writeBytes(JNIEnv *env, jobject this, jbyteArray bytes, jint off,
-                jint len, jfieldID fid);
+                jint len, jboolean append, jfieldID fid);
 void fileOpen(JNIEnv *env, jobject this, jstring path, jfieldID fid, int flags);
 void throwFileNotFoundException(JNIEnv *env, jstring path);
 
diff --git a/jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp
index 325ca9dab0521ceca06b85b4440bc15f42b2a03d..807a072410c403f363a5190889d2967b474edcc9 100644
--- a/jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp
+++ b/jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.cpp
@@ -59,16 +59,16 @@ le_bool CharSubstitutionFilter::accept(LEGlyphID glyph) const
 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 @@ void ArabicOpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], l
     }
 }
 
-UnicodeArabicOpenTypeLayoutEngine::UnicodeArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags)
-    : ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags)
+UnicodeArabicOpenTypeLayoutEngine::UnicodeArabicOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success)
+    : ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success)
 {
     fGSUBTable = (const GlyphSubstitutionTableHeader *) CanonShaping::glyphSubstitutionTable;
     fGDEFTable = (const GlyphDefinitionTableHeader *) CanonShaping::glyphDefinitionTable;
diff --git a/jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.h b/jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.h
index cb2baf19c1b49823fd240118425563fb45d727e8..956b3d50f8cbcd54bc57da9874b573bb165bc5ab 100644
--- a/jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.h
+++ b/jdk/src/share/native/sun/font/layout/ArabicLayoutEngine.h
@@ -66,6 +66,7 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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/jdk/src/share/native/sun/font/layout/ArabicShaping.cpp b/jdk/src/share/native/sun/font/layout/ArabicShaping.cpp
index c177cc8eac299076e34928d521ac3f6eaf70ecf7..7c91f4f97218cf31cbe5d8120a2426a7f9b35fe9 100644
--- a/jdk/src/share/native/sun/font/layout/ArabicShaping.cpp
+++ b/jdk/src/share/native/sun/font/layout/ArabicShaping.cpp
@@ -104,6 +104,7 @@ ArabicShaping::ShapeType ArabicShaping::getShapeType(LEUnicode c)
 #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 @@ void ArabicShaping::shape(const LEUnicode *chars, le_int32 offset, le_int32 char
         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/jdk/src/share/native/sun/font/layout/CanonData.cpp b/jdk/src/share/native/sun/font/layout/CanonData.cpp
index 7d1d1db2d6f505608669fb5c5fa753a45b652eff..41d4bc213ae1c77da55b890990291d0903f57040 100644
--- a/jdk/src/share/native/sun/font/layout/CanonData.cpp
+++ b/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 @@ const le_uint8 CanonShaping::glyphSubstitutionTable[] = {
     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 @@ const le_uint8 CanonShaping::glyphSubstitutionTable[] = {
     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 @@ const le_uint8 CanonShaping::glyphSubstitutionTable[] = {
     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 @@ const le_uint8 CanonShaping::glyphSubstitutionTable[] = {
     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,
-    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,
+    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, 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,
+    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, 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 @@ const le_uint8 CanonShaping::glyphDefinitionTable[] = {
     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 @@ const le_uint8 CanonShaping::glyphDefinitionTable[] = {
     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/jdk/src/share/native/sun/font/layout/CanonShaping.h b/jdk/src/share/native/sun/font/layout/CanonShaping.h
index e4f7c2cd0147a68e4ca9a75aeb5788489917f7d3..62ad919b965647a8aaa7b636125ba5891cc92924 100644
--- a/jdk/src/share/native/sun/font/layout/CanonShaping.h
+++ b/jdk/src/share/native/sun/font/layout/CanonShaping.h
@@ -38,7 +38,7 @@ U_NAMESPACE_BEGIN
 
 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/jdk/src/share/native/sun/font/layout/ClassDefinitionTables.cpp b/jdk/src/share/native/sun/font/layout/ClassDefinitionTables.cpp
index fcaf48de8060c8cac983e30419c91b8ff7b2e297..af600444007737d9fecc2bb37be1b126840fdfd9 100644
--- a/jdk/src/share/native/sun/font/layout/ClassDefinitionTables.cpp
+++ b/jdk/src/share/native/sun/font/layout/ClassDefinitionTables.cpp
@@ -93,7 +93,7 @@ le_int32 ClassDefFormat1Table::getGlyphClass(LEGlyphID glyphID) const
     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/jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp b/jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp
index d2825ed73e3b490c4a4ba8b5e66cd323385066fd..c799fc957e8dabd17844b356e6f5626e9a7288e4 100644
--- a/jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp
+++ b/jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.cpp
@@ -52,18 +52,23 @@ void ContextualSubstitutionBase::applySubstitutionLookups(
         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 @@ le_bool ContextualSubstitutionBase::matchGlyphCoverages(const Offset *coverageTa
     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 @@ le_uint32 ContextualSubstitutionSubtable::process(const LookupProcessor *lookupP
     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 ContextualSubstitutionSubtable::process(const LookupProcessor *lookupP
     }
 }
 
-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 @@ le_uint32 ContextualSubstitutionFormat1Subtable::process(const LookupProcessor *
                     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 @@ le_uint32 ContextualSubstitutionFormat1Subtable::process(const LookupProcessor *
     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 @@ le_uint32 ContextualSubstitutionFormat2Subtable::process(const LookupProcessor *
                     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 @@ le_uint32 ContextualSubstitutionFormat2Subtable::process(const LookupProcessor *
     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 @@ le_uint32 ContextualSubstitutionFormat3Subtable::process(const LookupProcessor *
         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 @@ le_uint32 ContextualSubstitutionFormat3Subtable::process(const LookupProcessor *
     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 @@ le_uint32 ChainingContextualSubstitutionSubtable::process(const LookupProcessor
     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 @@ le_uint32 ChainingContextualSubstitutionSubtable::process(const LookupProcessor
 // 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 @@ le_uint32 ChainingContextualSubstitutionFormat1Subtable::process(const LookupPro
                     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 @@ le_uint32 ChainingContextualSubstitutionFormat1Subtable::process(const LookupPro
     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 @@ le_uint32 ChainingContextualSubstitutionFormat2Subtable::process(const LookupPro
                     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 @@ le_uint32 ChainingContextualSubstitutionFormat2Subtable::process(const LookupPro
     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 @@ le_uint32 ChainingContextualSubstitutionFormat3Subtable::process(const LookupPro
         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/jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.h b/jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.h
index 743371d3ed0f01aaf9c0c2eaa88f939b9a2108c7..9df57fee2eb88cb5beb90eba88d2081bebd04e2d 100644
--- a/jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.h
+++ b/jdk/src/share/native/sun/font/layout/ContextualSubstSubtables.h
@@ -72,12 +72,13 @@ struct ContextualSubstitutionBase : GlyphSubstitutionSubtable
         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 @@ struct ContextualSubstitutionFormat1Subtable : ContextualSubstitutionSubtable
     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 @@ struct ContextualSubstitutionFormat2Subtable : ContextualSubstitutionSubtable
     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 @@ struct ContextualSubstitutionFormat3Subtable
     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 @@ struct ChainingContextualSubstitutionFormat1Subtable : ChainingContextualSubstit
     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 @@ struct ChainingContextualSubstitutionFormat2Subtable : ChainingContextualSubstit
     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 @@ struct ChainingContextualSubstitutionFormat3Subtable
   //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/jdk/src/share/native/sun/font/layout/CoverageTables.cpp b/jdk/src/share/native/sun/font/layout/CoverageTables.cpp
index e91d69f8d0e14b0218c4c00173847bca31e1578d..2d7c10baec58c9ff03ca9fef55b860c0ab6f9503 100644
--- a/jdk/src/share/native/sun/font/layout/CoverageTables.cpp
+++ b/jdk/src/share/native/sun/font/layout/CoverageTables.cpp
@@ -73,6 +73,10 @@ le_int32 CoverageFormat1Table::getGlyphCoverage(LEGlyphID glyphID) const
     le_uint16 probe = power;
     le_uint16 index = 0;
 
+        if (count == 0) {
+                return -1;
+        }
+
     if (SWAPW(glyphArray[extra]) <= ttGlyphID) {
         index = extra;
     }
diff --git a/jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp b/jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp
index fbd76b462544a829eeb9e606c1b03c36671f7904..e3a7d041efc8bf04b6e277295d2337d51e76f064 100644
--- a/jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp
+++ b/jdk/src/share/native/sun/font/layout/CursiveAttachmentSubtables.cpp
@@ -59,6 +59,8 @@ le_uint32 CursiveAttachmentSubtable::process(GlyphIterator *glyphIterator, const
 
         entryAnchorTable->getAnchor(glyphID, fontInstance, entryAnchor);
         glyphIterator->setCursiveEntryPoint(entryAnchor);
+    } else {
+        //glyphIterator->clearCursiveEntryPoint();
     }
 
     if (exitOffset != 0) {
@@ -66,6 +68,8 @@ le_uint32 CursiveAttachmentSubtable::process(GlyphIterator *glyphIterator, const
 
         exitAnchorTable->getAnchor(glyphID, fontInstance, exitAnchor);
         glyphIterator->setCursiveExitPoint(exitAnchor);
+    } else {
+        //glyphIterator->clearCursiveExitPoint();
     }
 
     return 1;
diff --git a/jdk/src/share/native/sun/font/layout/DeviceTables.cpp b/jdk/src/share/native/sun/font/layout/DeviceTables.cpp
index fdee8266f54d0f8b42c7122a37dd3854449bd048..c0a16cdd463aff98db91bab42cce3d787bd17f2d 100644
--- a/jdk/src/share/native/sun/font/layout/DeviceTables.cpp
+++ b/jdk/src/share/native/sun/font/layout/DeviceTables.cpp
@@ -41,13 +41,15 @@ const le_uint16 DeviceTable::fieldMasks[]    = {0x0003, 0x000F, 0x00FF};
 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/jdk/src/share/native/sun/font/layout/ExtensionSubtables.cpp b/jdk/src/share/native/sun/font/layout/ExtensionSubtables.cpp
index fa498a39fe57f81f0a145d186b533bdf3c8b6d46..7ecd26856351a728b52da15700198ddc9f8a76a4 100644
--- a/jdk/src/share/native/sun/font/layout/ExtensionSubtables.cpp
+++ b/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/jdk/src/share/native/sun/font/layout/ExtensionSubtables.h b/jdk/src/share/native/sun/font/layout/ExtensionSubtables.h
index bee48a3d5eda0a4ff7c83b24fa073d40f1ef38dd..47476fc984b70967f97b946ce2fcc690beabcc16 100644
--- a/jdk/src/share/native/sun/font/layout/ExtensionSubtables.h
+++ b/jdk/src/share/native/sun/font/layout/ExtensionSubtables.h
@@ -53,7 +53,7 @@ struct ExtensionSubtable //: GlyphSubstitutionSubtable
     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/jdk/src/share/native/sun/font/layout/Features.cpp b/jdk/src/share/native/sun/font/layout/Features.cpp
index 2f0627287cefa590c5d0fea9ac94f301b9bf4163..c83ac05d97d659016fe8c1d886d0703fb47896fb 100644
--- a/jdk/src/share/native/sun/font/layout/Features.cpp
+++ b/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/jdk/src/share/native/sun/font/layout/GXLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/GXLayoutEngine.cpp
index 29fcf31b1a8db2d038b0bfc62ae80a7a2899a0e5..9321d5a01e27cd055e383935f620857d0672e01e 100644
--- a/jdk/src/share/native/sun/font/layout/GXLayoutEngine.cpp
+++ b/jdk/src/share/native/sun/font/layout/GXLayoutEngine.cpp
@@ -41,8 +41,8 @@ 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)
+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/jdk/src/share/native/sun/font/layout/GXLayoutEngine.h b/jdk/src/share/native/sun/font/layout/GXLayoutEngine.h
index 93f99e0d6b5ad3a1d9b42563f42d498ea8cb06c0..b7aa296ca0d58d99970d73c7f661dc4d273c2c98 100644
--- a/jdk/src/share/native/sun/font/layout/GXLayoutEngine.h
+++ b/jdk/src/share/native/sun/font/layout/GXLayoutEngine.h
@@ -67,13 +67,14 @@ public:
      * @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/jdk/src/share/native/sun/font/layout/GlyphIterator.cpp b/jdk/src/share/native/sun/font/layout/GlyphIterator.cpp
index a3dfa0a73f93c150a50a834751442825d56402b2..2fea0e9df237738341dfc7c936c75a3155abc72f 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphIterator.cpp
+++ b/jdk/src/share/native/sun/font/layout/GlyphIterator.cpp
@@ -44,7 +44,7 @@ GlyphIterator::GlyphIterator(LEGlyphStorage &theGlyphStorage, GlyphPositionAdjus
                              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 @@ GlyphIterator::GlyphIterator(GlyphIterator &that)
     destIndex = that.destIndex;
     lookupFlags = that.lookupFlags;
     featureMask = that.featureMask;
+    glyphGroup  = that.glyphGroup;
     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
@@ -95,6 +96,7 @@ GlyphIterator::GlyphIterator(GlyphIterator &that, FeatureMask newFeatureMask)
     destIndex = that.destIndex;
     lookupFlags = that.lookupFlags;
     featureMask = newFeatureMask;
+    glyphGroup  = 0;
     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
@@ -112,6 +114,7 @@ GlyphIterator::GlyphIterator(GlyphIterator &that, le_uint16 newLookupFlags)
     destIndex = that.destIndex;
     lookupFlags = newLookupFlags;
     featureMask = that.featureMask;
+    glyphGroup  = that.glyphGroup;
     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
@@ -125,12 +128,13 @@ void GlyphIterator::reset(le_uint16 newLookupFlags, FeatureMask newFeatureMask)
 {
     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 @@ void GlyphIterator::setCurrGlyphPositionAdjustment(float xPlacementAdjust, float
     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::filterGlyph(le_uint32 index) const
     }
 }
 
-le_bool GlyphIterator::hasFeatureTag() const
+le_bool GlyphIterator::hasFeatureTag(le_bool matchGroup) const
 {
     if (featureMask == 0) {
         return TRUE;
@@ -400,14 +434,18 @@ le_bool GlyphIterator::hasFeatureTag() const
     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::nextInternal(le_uint32 delta)
 
 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::prevInternal(le_uint32 delta)
 
 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/jdk/src/share/native/sun/font/layout/GlyphIterator.h b/jdk/src/share/native/sun/font/layout/GlyphIterator.h
index a9750936500d3bb5e92a6e3109a8baa288334d6f..63d0aedda0047aff06ddec94dff473500475169b 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphIterator.h
+++ b/jdk/src/share/native/sun/font/layout/GlyphIterator.h
@@ -88,16 +88,18 @@ public:
     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 @@ private:
     le_int32    destIndex;
     le_uint16   lookupFlags;
     FeatureMask featureMask;
+    le_int32    glyphGroup;
 
     const GlyphClassDefinitionTable *glyphClassDefinitionTable;
     const MarkAttachClassDefinitionTable *markAttachClassDefinitionTable;
diff --git a/jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp b/jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp
index b2028a4f47cdf91d6970ea101dabaa09a1bdc882..f83407d754668841352e46b37eed4d84160d82a9 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp
+++ b/jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.cpp
@@ -71,6 +71,20 @@ const LEPoint *GlyphPositionAdjustments::getExitPoint(le_int32 index, LEPoint &e
     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 @@ void GlyphPositionAdjustments::applyCursiveAdjustments(LEGlyphStorage &glyphStor
                 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/jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.h b/jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.h
index 9fa2c4cccbc38949260b63960a708263e1310884..9ae4f53c9ba65b0bbb73f4bbf51a0383762ec8be 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.h
+++ b/jdk/src/share/native/sun/font/layout/GlyphPositionAdjustments.h
@@ -97,6 +97,8 @@ private:
         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 @@ public:
     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 @@ inline le_bool GlyphPositionAdjustments::EntryExitPoint::baselineIsLogicalEnd()
     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/jdk/src/share/native/sun/font/layout/GlyphPositioningTables.cpp b/jdk/src/share/native/sun/font/layout/GlyphPositioningTables.cpp
index 6382c593cdcad09f0bcacb0dc959a44246a046e9..dd3894e33d4c06e4bc6ad2c4d5bff3df715ca663 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphPositioningTables.cpp
+++ b/jdk/src/share/native/sun/font/layout/GlyphPositioningTables.cpp
@@ -43,12 +43,19 @@ U_NAMESPACE_BEGIN
 
 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/jdk/src/share/native/sun/font/layout/GlyphPositioningTables.h b/jdk/src/share/native/sun/font/layout/GlyphPositioningTables.h
index 2afde63b2d793f5244079cc87d1cac748a04f647..ef3c5e652f576df41237b15fb5dc51aa26f8d7e7 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphPositioningTables.h
+++ b/jdk/src/share/native/sun/font/layout/GlyphPositioningTables.h
@@ -53,7 +53,7 @@ struct GlyphPositioningTableHeader : public GlyphLookupTableHeader
 {
     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/jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp b/jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp
index 735ce7cd72305a48c40a630ab1d1edc1f857d5d4..22d251586a7d9cdedb36d95827a266f7d93c8f1f 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.cpp
+++ b/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 @@ typedef ChainingContextualSubstitutionSubtable ChainingContextualPositioningSubt
 
 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 @@ GlyphPositioningLookupProcessor::GlyphPositioningLookupProcessor()
 
 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 @@ le_uint32 GlyphPositioningLookupProcessor::applySubtable(const LookupSubtable *l
     {
         const ContextualPositioningSubtable *subtable = (const ContextualPositioningSubtable *) lookupSubtable;
 
-        delta = subtable->process(this, glyphIterator, fontInstance);
+        delta = subtable->process(this, glyphIterator, fontInstance, success);
         break;
     }
 
@@ -144,7 +160,7 @@ le_uint32 GlyphPositioningLookupProcessor::applySubtable(const LookupSubtable *l
     {
         const ChainingContextualPositioningSubtable *subtable = (const ChainingContextualPositioningSubtable *) lookupSubtable;
 
-        delta = subtable->process(this, glyphIterator, fontInstance);
+        delta = subtable->process(this, glyphIterator, fontInstance, success);
         break;
     }
 
@@ -152,7 +168,7 @@ le_uint32 GlyphPositioningLookupProcessor::applySubtable(const LookupSubtable *l
     {
         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/jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.h b/jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.h
index 11390f51db1568cd5a7ae2420702f930a080eb1e..6001f2c9863cf352e03f49367cb7d0853212bfaf 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphPosnLookupProc.h
+++ b/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 @@ 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,
+        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/jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp b/jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp
index aa3b88f826ad3ae9fd382bb113e1d14d71fc13b6..850b7829318b27fb35fb8240fcf1830ea87aaf9a 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.cpp
+++ b/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 @@ 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,
+        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 @@ GlyphSubstitutionLookupProcessor::GlyphSubstitutionLookupProcessor()
 }
 
 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 @@ le_uint32 GlyphSubstitutionLookupProcessor::applySubtable(const LookupSubtable *
     {
         const MultipleSubstitutionSubtable *subtable = (const MultipleSubstitutionSubtable *) lookupSubtable;
 
-        delta = subtable->process(glyphIterator, fFilter);
+        delta = subtable->process(glyphIterator, success, fFilter);
         break;
     }
 
@@ -113,7 +123,7 @@ le_uint32 GlyphSubstitutionLookupProcessor::applySubtable(const LookupSubtable *
     {
         const ContextualSubstitutionSubtable *subtable = (const ContextualSubstitutionSubtable *) lookupSubtable;
 
-        delta = subtable->process(this, glyphIterator, fontInstance);
+        delta = subtable->process(this, glyphIterator, fontInstance, success);
         break;
     }
 
@@ -121,7 +131,7 @@ le_uint32 GlyphSubstitutionLookupProcessor::applySubtable(const LookupSubtable *
     {
         const ChainingContextualSubstitutionSubtable *subtable = (const ChainingContextualSubstitutionSubtable *) lookupSubtable;
 
-        delta = subtable->process(this, glyphIterator, fontInstance);
+        delta = subtable->process(this, glyphIterator, fontInstance, success);
         break;
     }
 
@@ -129,7 +139,7 @@ le_uint32 GlyphSubstitutionLookupProcessor::applySubtable(const LookupSubtable *
     {
         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/jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.h b/jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.h
index 5ffa579aa96d2f5c1046c7937bbe672db4d32905..154cc2b9236ecfaa6025e6b8d16078b14973e33c 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphSubstLookupProc.h
+++ b/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 @@ 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,
+        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/jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp b/jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp
index e51e1518e5437c2768798db6baedf839c47321fc..bd056b602605253b6f63263c365fb4e3aa2f4c2a 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.cpp
+++ b/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/jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.h b/jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.h
index b533942906bec022535e42d596f3bd4ac2e40b3d..207747dd9a7841772479d983682f8ef670a85b7a 100644
--- a/jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.h
+++ b/jdk/src/share/native/sun/font/layout/GlyphSubstitutionTables.h
@@ -50,9 +50,16 @@ 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,
+                        LEErrorCode &success) const;
 };
 
 enum GlyphSubstitutionSubtableTypes
diff --git a/jdk/src/share/native/sun/font/layout/HanLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/HanLayoutEngine.cpp
index 0a50ef2428069687411757a3baf22316257abcb6..5e799ef8339a5a06fd426939690f308d85aeab9a 100644
--- a/jdk/src/share/native/sun/font/layout/HanLayoutEngine.cpp
+++ b/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 @@ static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap);
 #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/jdk/src/share/native/sun/font/layout/HanLayoutEngine.h b/jdk/src/share/native/sun/font/layout/HanLayoutEngine.h
index baf76199977e4a1552373a5d4a1b81acee1b1efb..6dd726069a5a7c5932b9a55fb422d44a2845b8a6 100644
--- a/jdk/src/share/native/sun/font/layout/HanLayoutEngine.h
+++ b/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 @@ public:
      * @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 @@ public:
      * @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/jdk/src/share/native/sun/font/layout/HangulLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/HangulLayoutEngine.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..806f2dc5813c75ba876b38e274fb9fab6f194a0d
--- /dev/null
+++ b/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/jdk/src/share/native/sun/font/layout/HangulLayoutEngine.h b/jdk/src/share/native/sun/font/layout/HangulLayoutEngine.h
new file mode 100644
index 0000000000000000000000000000000000000000..e2a485e5f817b544c04721d6204ec3ff028b5c42
--- /dev/null
+++ b/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 - TRUE 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/jdk/src/share/native/sun/font/layout/HebrewLigatureData.cpp b/jdk/src/share/native/sun/font/layout/HebrewLigatureData.cpp
deleted file mode 100644
index cc905ba8464965f2e014f58a1f0088405b408777..0000000000000000000000000000000000000000
--- a/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/jdk/src/share/native/sun/font/layout/HebrewShaping.h b/jdk/src/share/native/sun/font/layout/ICUFeatures.h
similarity index 64%
rename from jdk/src/share/native/sun/font/layout/HebrewShaping.h
rename to jdk/src/share/native/sun/font/layout/ICUFeatures.h
index b117a1434129b10c7abdc59ef022537ceadec48b..f32d8e2b86984d37f038494822b4a0b168bda8dd 100644
--- a/jdk/src/share/native/sun/font/layout/HebrewShaping.h
+++ b/jdk/src/share/native/sun/font/layout/ICUFeatures.h
@@ -25,28 +25,45 @@
 
 /*
  *
- * (C) Copyright IBM Corp. 1998, 1999, 2000 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved
  *
  */
 
-#ifndef __HEBREWSHAPING_H
-#define __HEBREWSHAPING_H
+#ifndef __ICUFEATURES_H
+#define __ICUFEATURES_H
+
+/**
+ * \file
+ * \internal
+ */
 
 #include "LETypes.h"
 #include "OpenTypeTables.h"
 
-class HebrewShaping
+U_NAMESPACE_BEGIN
+
+struct FeatureRecord
+{
+    ATag        featureTag;
+    Offset      featureTableOffset;
+};
+
+struct FeatureTable
+{
+    Offset      featureParamsOffset;
+    le_uint16   lookupCount;
+    le_uint16   lookupListIndexArray[ANY_NUMBER];
+};
+
+struct FeatureListTable
 {
-public:
-    static void shape(const LEUnicode *chars, le_int32 offset, le_int32 charCount, le_int32 charMax,
-                      le_bool rightToLeft, const LETag **tags);
+    le_uint16           featureCount;
+    FeatureRecord       featureRecordArray[ANY_NUMBER];
 
-    static const le_uint8 glyphSubstitutionTable[];
-    static const le_uint8 glyphDefinitionTable[];
+    const FeatureTable  *getFeatureTable(le_uint16 featureIndex, LETag *featureTag) const;
 
-private:
-    // forbid instantiation
-    HebrewShaping();
+    const FeatureTable *getFeatureTable(LETag featureTag) const;
 };
 
+U_NAMESPACE_END
 #endif
diff --git a/jdk/src/share/native/sun/font/layout/IndicClassTables.cpp b/jdk/src/share/native/sun/font/layout/IndicClassTables.cpp
index 4a9999bd5c3ff1b609da1ba72acfc867223d3123..73cd2cfd7189e690136b382522d48598f8da42ad 100644
--- a/jdk/src/share/native/sun/font/layout/IndicClassTables.cpp
+++ b/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 @@ U_NAMESPACE_BEGIN
 #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 @@ U_NAMESPACE_BEGIN
 // 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 @@ static const IndicClassTable::CharClass bengCharClasses[] =
     _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 @@ static const IndicClassTable::CharClass gujrCharClasses[] =
     _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 @@ static const IndicClassTable::CharClass oryaCharClasses[] =
     _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 @@ static const IndicClassTable::CharClass teluCharClasses[] =
     _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 @@ static const IndicClassTable::CharClass teluCharClasses[] =
 //  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 kndaCharClasses[] =
 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 @@ static const IndicClassTable::CharClass sinhCharClasses[] =
     _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 @@ static const SplitMatra sinhSplitTable[] = {{0x0DD9, 0x0DCA}, {0x0DD9, 0x0DCF},
 
 // 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 @@ static const IndicClassTable sinhClassTable = {0x0D80, 0x0DF4, 4, SINH_SCRIPT_FL
 //
 // 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 @@ static const IndicClassTable * const indicClassTables[] = {
     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 @@ le_int32 IndicReordering::getWorstCaseExpansion(le_int32 scriptCode)
     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/jdk/src/share/native/sun/font/layout/IndicLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/IndicLayoutEngine.cpp
index acc214641a2289439ac09946b402b723cb486286..4d2c4180226318f0639c83ccd683f8c2e954e5d4 100644
--- a/jdk/src/share/native/sun/font/layout/IndicLayoutEngine.cpp
+++ b/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 
 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)
-    : OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags), fMPreFixups(NULL)
+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;
+        fVersion2 =  FALSE;
 }
 
 IndicOpenTypeLayoutEngine::~IndicOpenTypeLayoutEngine()
@@ -89,8 +96,13 @@ le_int32 IndicOpenTypeLayoutEngine::glyphProcessing(const LEUnicode chars[], le_
         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 @@ le_int32 IndicOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[],
 
     // 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/jdk/src/share/native/sun/font/layout/IndicLayoutEngine.h b/jdk/src/share/native/sun/font/layout/IndicLayoutEngine.h
index ba1c5262cfed79e1de8b643bcfb9dd7d7585c40d..b443941bf99aed12be51373596a9669aa095dd8f 100644
--- a/jdk/src/share/native/sun/font/layout/IndicLayoutEngine.h
+++ b/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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ protected:
     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/jdk/src/share/native/sun/font/layout/IndicReordering.cpp b/jdk/src/share/native/sun/font/layout/IndicReordering.cpp
index 2bbceabda11e3cd5b8a99ed47ef61a663ac7cd48..9b28ada355d8d508139f5944ca3df695d7e51cc4 100644
--- a/jdk/src/share/native/sun/font/layout/IndicReordering.cpp
+++ b/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 @@ U_NAMESPACE_BEGIN
 #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 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
-
-class ReorderingOutput : public UMemory {
+#define caltFeatureTag LE_CALT_FEATURE_TAG
+#define kernFeatureTag LE_KERN_FEATURE_TAG
+
+#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
+
+// 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 @@ private:
     LEUnicode   fLengthMark;
     le_int32    fLengthMarkIndex;
 
-    LEUnicode   fVirama;
-    le_int32    fViramaIndex;
+    LEUnicode   fAlLakuna;
+    le_int32    fAlLakunaIndex;
 
     FeatureMask fMatraFeatures;
 
@@ -113,15 +154,20 @@ private:
     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 @@ private:
     }
 
 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 @@ public:
         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 @@ public:
         }
     }
 
+    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 @@ public:
         }
     }
 
-    // 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 @@ public:
         }
     }
 
+    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 FeatureMap featureMap[] =
 
 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 @@ const FeatureMap *IndicReordering::getFeatureMap(le_int32 &count)
     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::findSyllable(const IndicClassTable *classTable, const
 
 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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
             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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
 
             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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
             }
 
             output.writeLengthMark();
-            output.writeVirama();
+            output.writeAlLakuna();
 
             if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) {
                 output.writeVMabove();
@@ -538,7 +772,7 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
             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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
                 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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
             }
 
             // 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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
                 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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
             }
 
             // 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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
 
             // 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 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
             }
 
             output.writeLengthMark();
-            output.writeVirama();
+            output.writeAlLakuna();
 
             // write reph
             if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) {
@@ -740,13 +1004,250 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
     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/jdk/src/share/native/sun/font/layout/IndicReordering.h b/jdk/src/share/native/sun/font/layout/IndicReordering.h
index 1ab14f1bca17eb29924b2dedb6494e8fdf1a70cd..2a5b10e93691a73f16ff096247d1e3ec6a67cf1c 100644
--- a/jdk/src/share/native/sun/font/layout/IndicReordering.h
+++ b/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 @@ U_NAMESPACE_BEGIN
 #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 @@ U_NAMESPACE_BEGIN
 #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 @@ U_NAMESPACE_BEGIN
 #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 @@ typedef LEUnicode SplitMatra[3];
 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 @@ struct IndicClassTable
     const SplitMatra *splitMatraTable;
 
     inline le_int32 getWorstCaseExpansion() const;
+    inline le_bool getFilterZeroWidth() const;
 
     CharClass getCharClass(LEUnicode ch) const;
 
@@ -121,6 +134,7 @@ struct IndicClassTable
     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 @@ struct IndicClassTable
     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 @@ struct IndicClassTable
     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 @@ class IndicReordering /* not : public UObject because all methods are static */
 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, LEErrorCode& success);
 
-    static void adjustMPres(MPreFixups *mpreFixups, LEGlyphStorage &glyphStorage);
+    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 @@ inline le_int32 IndicClassTable::getWorstCaseExpansion() const
     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 @@ inline le_bool IndicClassTable::isVirama(CharClass charClass)
     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 @@ inline le_bool IndicClassTable::hasPostBaseForm(CharClass charClass)
     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 @@ inline le_bool IndicClassTable::isVirama(LEUnicode ch) const
     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 @@ inline le_bool IndicClassTable::hasBelowBaseForm(LEUnicode ch) const
     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/jdk/src/share/native/sun/font/layout/KernTable.cpp b/jdk/src/share/native/sun/font/layout/KernTable.cpp
index 1120ac19c86ddf4e5b544349bc319c09dab7e3ac..8d368211309a65b9966144bde281a32bfc47b4ee 100644
--- a/jdk/src/share/native/sun/font/layout/KernTable.cpp
+++ b/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 
 
@@ -91,8 +92,8 @@ struct KernTableHeader {
  * 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 @@ KernTable::KernTable(const LEFontInstance* font, const void* tableData)
       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/jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp
index c007e9887ba34bf14b78ca19f2090a05f37c8448..d1f0674ebf43b503a43c4167843d06c352ae0be1 100644
--- a/jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.cpp
+++ b/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 @@ 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)
+                    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/jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.h b/jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.h
index 713884bcd9bb02066183fd682881236e52040eb0..602d8563a3377fc2a3214c682b53b7fc2055ca8f 100644
--- a/jdk/src/share/native/sun/font/layout/KhmerLayoutEngine.h
+++ b/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 @@ public:
      *
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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/jdk/src/share/native/sun/font/layout/KhmerReordering.cpp b/jdk/src/share/native/sun/font/layout/KhmerReordering.cpp
index cd869ab2880dca28c98dcfa4c9dc22b42b8bf99d..ea8fcf51ec2e65c2af25d656635e3ffe420affbf 100644
--- a/jdk/src/share/native/sun/font/layout/KhmerReordering.cpp
+++ b/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 @@ const KhmerClassTable *KhmerClassTable::getKhmerClassTable()
 
 
 
-class ReorderingOutput : public UMemory {
+class KhmerReorderingOutput : public UMemory {
 private:
+    le_int32 fSyllableCount;
     le_int32 fOutIndex;
     LEUnicode *fOutChars;
 
@@ -158,17 +159,22 @@ private:
 
 
 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 @@ public:
         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 @@ static const le_int8 khmerStateTable[][KhmerClassTable::CC_COUNT] =
     {-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 @@ le_int32 KhmerReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
 {
     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 @@ le_int32 KhmerReordering::reorder(const LEUnicode *chars, le_int32 charCount, le
     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/jdk/src/share/native/sun/font/layout/LEFontInstance.cpp b/jdk/src/share/native/sun/font/layout/LEFontInstance.cpp
index b41b45fb6ac15d6ffb77e164063e1ce1ce9549d9..4b7bcd10fa0585b2a90ea0e88b1ddc98922325ae 100644
--- a/jdk/src/share/native/sun/font/layout/LEFontInstance.cpp
+++ b/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 @@ U_NAMESPACE_BEGIN
 
 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 @@ const LEFontInstance *LEFontInstance::getSubFont(const LEUnicode chars[], le_int
 }
 
 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 @@ void LEFontInstance::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset,
             }
         }
 
-        glyphStorage[out] = mapCharToGlyph(code, mapper);
+        glyphStorage[out] = mapCharToGlyph(code, mapper, filterZeroWidth);
 
         if (code >= 0x10000) {
             i += 1;
@@ -93,15 +103,72 @@ void LEFontInstance::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset,
 }
 
 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/jdk/src/share/native/sun/font/layout/LEFontInstance.h b/jdk/src/share/native/sun/font/layout/LEFontInstance.h
index 5206ce9eacd623fd514bc0595e7aec34a3e29668..1f1d415b8205a372bff0d32780d97115f53c1967 100644
--- a/jdk/src/share/native/sun/font/layout/LEFontInstance.h
+++ b/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 @@ public:
      * Destructor.
      * @stable ICU 3.2
      */
-    virtual inline ~LECharMapper() {};
+    virtual ~LECharMapper();
 
     /**
      * This method does the adjustments.
@@ -75,7 +75,7 @@ public:
  * 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 @@ class LEGlyphStorage;
  * 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 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
      * @param count - the number of characters
      * @param reverse - if TRUE, store the glyph indices in reverse order.
      * @param mapper - the character mapper.
+     * @param filterZeroWidth - TRUE 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 mapCharToGlyph(mappedCh).
+     *
+     * @param ch - the character
+     * @param mapper - the character mapper
+     * @param filterZeroWidth - TRUE 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 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
 
 };
 
-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 @@ inline le_int32 LEFontInstance::floatToFixed(float theFloat)
     return (le_int32) (theFloat * 65536.0);
 }
 
-inline le_int32 LEFontInstance::getLineHeight() const
-{
-    return getAscent() + getDescent() + getLeading();
-}
-
 U_NAMESPACE_END
 #endif
 
diff --git a/jdk/src/share/native/sun/font/layout/LEGlyphStorage.cpp b/jdk/src/share/native/sun/font/layout/LEGlyphStorage.cpp
index cb3e1c81a09cd3819f5a191b3a47116ae0b361c4..be5f0831b8e8b40ae167bf0146af1e6802f72e4d 100644
--- a/jdk/src/share/native/sun/font/layout/LEGlyphStorage.cpp
+++ b/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 @@ U_NAMESPACE_BEGIN
 
 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 @@ void LEGlyphStorage::allocateGlyphArray(le_int32 initialGlyphCount, le_bool righ
     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 @@ le_int32 LEGlyphStorage::allocatePositions(LEErrorCode &success)
         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 @@ le_int32 LEGlyphStorage::allocateAuxData(LEErrorCode &success)
         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 @@ void LEGlyphStorage::adoptGlyphCount(le_int32 newGlyphCount)
     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 LEGlyphStorage::applyInsertions()
 
     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/jdk/src/share/native/sun/font/layout/LEGlyphStorage.h b/jdk/src/share/native/sun/font/layout/LEGlyphStorage.h
index 0851c4158b54b997e8b20d8ad5cd62e2ef856668..71869ebb0756945c0c93ac06c7a3ccb2f6f4146a 100644
--- a/jdk/src/share/native/sun/font/layout/LEGlyphStorage.h
+++ b/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 @@ U_NAMESPACE_BEGIN
  *
  * @see LEInsertionList.h
  *
- * @draft ICU 3.6
+ * @stable ICU 3.6
  */
 class U_LAYOUT_API LEGlyphStorage : public UObject, protected LEInsertionCallback
 {
@@ -130,7 +130,7 @@ protected:
      *
      * @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 @@ public:
      * allocateGlyphArray, allocatePositions and allocateAuxData
      * 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 @@ public:
      *
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
      * @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 @@ public:
      *
      * @return the glyph ID
      *
-     * @draft ICU 3.0
+     * @stable ICU 3.0
      */
     LEGlyphID getGlyphID(le_int32 glyphIndex, LEErrorCode &success) const;
 
@@ -308,7 +308,7 @@ public:
      *
      * @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 @@ public:
      *
      * @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 @@ public:
      *
      * @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,15 +346,51 @@ public:
      *
      * @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 LEInsertionList.h
+     *
+     * @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 LEInsertionList
+     * 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 applyInsertions 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 LEInsetionList.h
+     * @see LEInsertionList.h
      *
-     * @draft ICU 3.0
+     * @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
      * insertGlyphs to be applied to the glyph array. The
@@ -365,7 +401,7 @@ public:
      *
      * @see LEInsertionList.h
      *
-     * @draft ICU 3.0
+     * @stable ICU 3.0
      */
     le_int32 applyInsertions();
 
@@ -376,7 +412,7 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @param from the LEGlyphStorage 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 @@ public:
      * @param from the LEGlyphStorage 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 @@ public:
      * @param from the LEGlyphStorage 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 @@ public:
      * @param from the LEGlyphStorage 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 @@ public:
      * @param from the LEGlyphStorage 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 @@ public:
      *
      * @param newGlyphCount the new glyph count.
      *
-     * @draft ICU 3.0
+     * @stable ICU 3.0
      */
     void adoptGlyphCount(le_int32 newGlyphCount);
 
@@ -500,21 +536,21 @@ public:
      * 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/jdk/src/share/native/sun/font/layout/LEInsertionList.cpp b/jdk/src/share/native/sun/font/layout/LEInsertionList.cpp
index c92690a774a58a54ec32ab3a4299e87db9ab5974..c88436c0489150bcc9591ec4be7a48b5a5b4caef 100644
--- a/jdk/src/share/native/sun/font/layout/LEInsertionList.cpp
+++ b/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 @@ le_int32 LEInsertionList::getGrowAmount()
     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/jdk/src/share/native/sun/font/layout/LEInsertionList.h b/jdk/src/share/native/sun/font/layout/LEInsertionList.h
index d74847a401aea9dc4f40152d20641b7cd369a761..6a48227973e4859d3a7b022cc604309db4651282 100644
--- a/jdk/src/share/native/sun/font/layout/LEInsertionList.h
+++ b/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 @@ struct InsertionRecord;
  *
  * @internal
  */
-class LEInsertionCallback
+class U_LAYOUT_API LEInsertionCallback
 {
 public:
     /**
@@ -62,6 +62,11 @@ public:
      * @internal
      */
     virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[]) = 0;
+
+    /**
+     * The destructor
+     */
+     virtual ~LEInsertionCallback();
 };
 
 /**
@@ -103,13 +108,14 @@ public:
      * @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
      *         not 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/jdk/src/share/native/sun/font/layout/LELanguages.h b/jdk/src/share/native/sun/font/layout/LELanguages.h
index a50f6c1cab5b8d20f111f4dc7fc8b60d31de4e1e..94ce50fc74a5cc71c965a8f57b7db420f49a94d3 100644
--- a/jdk/src/share/native/sun/font/layout/LELanguages.h
+++ b/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 @@ U_NAMESPACE_BEGIN
  * 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 @@ enum LanguageCodes {
     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/jdk/src/share/native/sun/font/layout/LEScripts.h b/jdk/src/share/native/sun/font/layout/LEScripts.h
index 1615da95655b09c2401e808dc81ef5dd9c0b6cf0..ed25b6044132fc233b5ba1651c7906cc533e32e4 100644
--- a/jdk/src/share/native/sun/font/layout/LEScripts.h
+++ b/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 UScript 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 @@ enum ScriptCodes {
     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 @@ enum ScriptCodes {
     shawScriptCode = 51,
     taleScriptCode = 52,
     ugarScriptCode = 53,
+/**
+ * @stable ICU 3.0
+ */
+
     hrktScriptCode = 54,
+/**
+ * @stable ICU 3.4
+ */
+
+    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 = 55
+    scriptCodeCount = 147
 };
 
 U_NAMESPACE_END
diff --git a/jdk/src/share/native/sun/font/layout/LEStandalone.h b/jdk/src/share/native/sun/font/layout/LEStandalone.h
index ecf0410e918b46fa96a309d837a4f4b04d1f1560..b0ccec6481a9652111cd3dd49c7c4f8b5120d73d 100644
--- a/jdk/src/share/native/sun/font/layout/LEStandalone.h
+++ b/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/jdk/src/share/native/sun/font/layout/LESwaps.h b/jdk/src/share/native/sun/font/layout/LESwaps.h
index 9bfeacd4e1b53236491337180de6e6fcb9298285..ef59f4a7df30c2d56f13297060b71822b3a0941e 100644
--- a/jdk/src/share/native/sun/font/layout/LESwaps.h
+++ b/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/jdk/src/share/native/sun/font/layout/LETypes.h b/jdk/src/share/native/sun/font/layout/LETypes.h
index f0fffad55f28ea3d63dcc84945a0129bfec7db41..be0441b538f500f9e7158360e07cc2bf3634929e 100644
--- a/jdk/src/share/native/sun/font/layout/LETypes.h
+++ b/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
  *
  */
 
@@ -472,6 +472,7 @@ enum LEFeatureTags {
     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' */
@@ -535,6 +536,7 @@ enum LEFeatureTags {
     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/jdk/src/share/native/sun/font/layout/LayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/LayoutEngine.cpp
index 046b2b28dbd22ef7323622152875723c5b94a1df..6b0aa1baa58111fd37d20529f5603bac568c08fc 100644
--- a/jdk/src/share/native/sun/font/layout/LayoutEngine.cpp
+++ b/jdk/src/share/native/sun/font/layout/LayoutEngine.cpp
@@ -38,10 +38,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"
@@ -59,6 +60,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,
@@ -96,9 +100,8 @@ LEUnicode32 DefaultCharMapper::mapChar(LEUnicode32 ch) const
     }
 
     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;
         }
@@ -134,6 +137,37 @@ CharSubstitutionFilter::~CharSubstitutionFilter()
     // nothing to do
 }
 
+class CanonMarkFilter : public UMemory, public LEGlyphFilter
+{
+private:
+    const GlyphClassDefinitionTable *classDefTable;
+
+    CanonMarkFilter(const CanonMarkFilter &other); // forbid copying of this class
+    CanonMarkFilter &operator=(const CanonMarkFilter &other); // forbid copying of this class
+
+public:
+    CanonMarkFilter(const GlyphDefinitionTableHeader *gdefTable);
+    virtual ~CanonMarkFilter();
+
+    virtual le_bool accept(LEGlyphID glyph) const;
+};
+
+CanonMarkFilter::CanonMarkFilter(const GlyphDefinitionTableHeader *gdefTable)
+{
+    classDefTable = gdefTable->getMarkAttachClassDefinitionTable();
+}
+
+CanonMarkFilter::~CanonMarkFilter()
+{
+    // nothing to do?
+}
+
+le_bool CanonMarkFilter::accept(LEGlyphID glyph) const
+{
+    le_int32 glyphClass = classDefTable->getGlyphClass(glyph);
+
+    return glyphClass != 0;
+}
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine)
 
@@ -150,11 +184,22 @@ static const FeatureMap canonFeatureMap[] =
 
 static const le_int32 canonFeatureMapCount = LE_ARRAY_SIZE(canonFeatureMap);
 
-LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags)
+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)
+    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
@@ -183,37 +228,6 @@ void LayoutEngine::getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const
     fGlyphStorage->getGlyphs(glyphs, success);
 }
 
-class CanonMarkFilter : public LEGlyphFilter
-{
-private:
-    const GlyphClassDefinitionTable *classDefTable;
-
-    CanonMarkFilter(const CanonMarkFilter &other); // forbid copying of this class
-    CanonMarkFilter &operator=(const CanonMarkFilter &other); // forbid copying of this class
-
-public:
-    CanonMarkFilter(const GlyphDefinitionTableHeader *gdefTable);
-    virtual ~CanonMarkFilter();
-
-    virtual le_bool accept(LEGlyphID glyph) const;
-};
-
-CanonMarkFilter::CanonMarkFilter(const GlyphDefinitionTableHeader *gdefTable)
-{
-    classDefTable = gdefTable->getMarkAttachClassDefinitionTable();
-}
-
-CanonMarkFilter::~CanonMarkFilter()
-{
-    // nothing to do?
-}
-
-le_bool CanonMarkFilter::accept(LEGlyphID glyph) const
-{
-    le_int32 glyphClass = classDefTable->getGlyphClass(glyph);
-
-    return glyphClass != 0;
-}
 
 void LayoutEngine::getGlyphPositions(float positions[], LEErrorCode &success) const
 {
@@ -244,8 +258,21 @@ le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 off
 
     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
@@ -254,18 +281,19 @@ le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 off
                         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;
         }
 
@@ -275,21 +303,41 @@ le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 off
         }
 
         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);
 
-        out = (rightToLeft? count - 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;
@@ -474,7 +522,7 @@ void LayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le
 
     DefaultCharMapper charMapper(TRUE, mirror);
 
-    fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, glyphStorage);
+    fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, fFilterZeroWidth, glyphStorage);
 }
 
 // Input: characters, font?
@@ -494,6 +542,10 @@ le_int32 LayoutEngine::layoutChars(const LEUnicode chars[], le_int32 offset, le_
 
     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);
@@ -525,8 +577,15 @@ LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstan
     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:
@@ -538,11 +597,15 @@ LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstan
         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:
@@ -554,36 +617,35 @@ LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstan
             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) {
-            result = new GXLayoutEngine(fontInstance, scriptCode, languageCode, morphTable);
+            result = new GXLayoutEngine(fontInstance, scriptCode, languageCode, morphTable, success);
         } else {
             switch (scriptCode) {
             case bengScriptCode:
@@ -597,29 +659,38 @@ LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstan
             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/jdk/src/share/native/sun/font/layout/LayoutEngine.h b/jdk/src/share/native/sun/font/layout/LayoutEngine.h
index 7e87b1a22cb2b9145c62b3adfddf46b215a367b1..4334ce355d496231550122d1a7d4bacec8d39f41 100644
--- a/jdk/src/share/native/sun/font/layout/LayoutEngine.h
+++ b/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
  *
  */
 
@@ -132,6 +132,14 @@ protected:
      */
     le_int32 fTypoFlags;
 
+    /**
+     * TRUE if mapCharsToGlyphs 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 @@ protected:
      * @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 @@ public:
 
     /**
      * 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 @@ public:
      *
      * @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 @@ public:
 
     /**
      * 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/jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp b/jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp
index 12df5eb7131ae7a942fb90f5783a8994806e9ac2..0c173f3c7d5113b010fb7b0845c9996cd3b6084c 100644
--- a/jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp
+++ b/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 @@ le_uint32 LigatureSubstitutionSubtable::process(GlyphIterator *glyphIterator, co
             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 @@ le_uint32 LigatureSubstitutionSubtable::process(GlyphIterator *glyphIterator, co
                 }
             }
 
-            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/jdk/src/share/native/sun/font/layout/LookupProcessor.cpp b/jdk/src/share/native/sun/font/layout/LookupProcessor.cpp
index 038316fc39590127a16a8a35fe1f15d453f284b0..eb5002ef8a23733e5921d0e6ec37dd383e43d726 100644
--- a/jdk/src/share/native/sun/font/layout/LookupProcessor.cpp
+++ b/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 @@ le_uint32 LookupProcessor::applyLookupTable(const LookupTable *lookupTable, Glyp
     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_uint32 LookupProcessor::applyLookupTable(const LookupTable *lookupTable, Glyp
 
 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) {
@@ -92,10 +100,9 @@ le_int32 LookupProcessor::process(LEGlyphStorage &glyphStorage, GlyphPositionAdj
             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;
                 }
             }
 
@@ -107,12 +114,16 @@ le_int32 LookupProcessor::process(LEGlyphStorage &glyphStorage, GlyphPositionAdj
 }
 
 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;
 }
@@ -134,7 +145,8 @@ le_int32 LookupProcessor::selectLookups(const FeatureTable *featureTable, Featur
 
 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),
       lookupOrderArray(NULL), lookupOrderCount(0)
 {
@@ -144,6 +156,10 @@ LookupProcessor::LookupProcessor(const char *baseAddress,
     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);
@@ -170,6 +186,10 @@ LookupProcessor::LookupProcessor(const char *baseAddress,
     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;
@@ -200,6 +220,10 @@ LookupProcessor::LookupProcessor(const char *baseAddress,
     }
 
     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];
@@ -289,6 +313,8 @@ LookupProcessor::LookupProcessor(const char *baseAddress,
 
 LookupProcessor::LookupProcessor()
 {
+        lookupOrderArray = NULL;
+        lookupSelectArray = NULL;
 }
 
 LookupProcessor::~LookupProcessor()
diff --git a/jdk/src/share/native/sun/font/layout/LookupProcessor.h b/jdk/src/share/native/sun/font/layout/LookupProcessor.h
index 2ed5d9aa331ad5b207f6f336a3104f2b0662fdfc..73a44f05cdbd57a0b600dac59b51a1ac14b208f5 100644
--- a/jdk/src/share/native/sun/font/layout/LookupProcessor.h
+++ b/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 @@ struct LookupTable;
 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/jdk/src/share/native/sun/font/layout/MPreFixups.cpp b/jdk/src/share/native/sun/font/layout/MPreFixups.cpp
index 5412ca1c7d6ff2db476e20b875f063cae1e6a3a8..673ea32ca16e2f153b9d00ffc814c990ae9d7f1e 100644
--- a/jdk/src/share/native/sun/font/layout/MPreFixups.cpp
+++ b/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::add(le_int32 baseIndex, le_int32 mpreIndex)
     }
 }
 
-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 @@ void MPreFixups::apply(LEGlyphStorage &glyphStorage)
         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/jdk/src/share/native/sun/font/layout/MPreFixups.h b/jdk/src/share/native/sun/font/layout/MPreFixups.h
index 2cb7600b880c69eb42e6c53b24105b0da4ea44b1..7ae70bd47e72ccd82aad6d145993f77f823a7b0c 100644
--- a/jdk/src/share/native/sun/font/layout/MPreFixups.h
+++ b/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 @@ public:
 
     void add(le_int32 baseIndex, le_int32 mpreIndex);
 
-    void apply(LEGlyphStorage &glyphStorage);
+    void apply(LEGlyphStorage &glyphStorage, LEErrorCode& success);
 
 private:
     FixupData *fFixupData;
diff --git a/jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp b/jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp
index 708f3df9f95b7f5187c67f02bd5dfa7bc2aa6d75..45b78cf81fec609a99995a3f60dd2c1b24a4dc65 100644
--- a/jdk/src/share/native/sun/font/layout/MarkToBasePosnSubtables.cpp
+++ b/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 @@ le_int32 MarkToBasePositioningSubtable::process(GlyphIterator *glyphIterator, co
     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/jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp b/jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp
index 038911c722a2cbbbcdb906f8aae5ba851bd18e3d..e105e1eb688e3faf860d999153fb9fba278a9918 100644
--- a/jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp
+++ b/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 @@ le_uint32 MultipleSubstitutionSubtable::process(GlyphIterator *glyphIterator, co
                 }
             }
 
-            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/jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.h b/jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.h
index 64029ffe416a2091533d729b34be20a0d5d3d869..5fe715ab7d5523bd34ca2441e97c4a0005c2d0c4 100644
--- a/jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.h
+++ b/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 @@ struct MultipleSubstitutionSubtable : GlyphSubstitutionSubtable
     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/jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp
index 9e1ef358a648c0bed1c811a1cbe7f2441fcc7b54..45eaadf4b7acac2c6b14f662ad9074bc5000a242 100644
--- a/jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.cpp
+++ b/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 @@ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OpenTypeLayoutEngine)
 #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 @@ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OpenTypeLayoutEngine)
 #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 @@ static const FeatureMap featureMap[] =
         {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)
 {
@@ -101,7 +111,7 @@ OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, l
     const GlyphPositioningTableHeader *gposTable = (const GlyphPositioningTableHeader *) getFontTable(gposTableTag);
 
     // 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;
@@ -109,11 +119,17 @@ OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, l
     default: break;
     }
 
+    if (typoFlags & 0x80000000L) {
+        fSubstitutionFilter = new CharSubstitutionFilter(fontInstance);
+    }
+
     setScriptAndLanguageTags();
 
     fGDEFTable = (const GlyphDefinitionTableHeader *) getFontTable(gdefTableTag);
 
-    if (gposTable != NULL && gposTable->coversScriptAndLanguage(fScriptTag, fLangSysTag)) {
+// 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;
     }
 }
@@ -128,8 +144,8 @@ void OpenTypeLayoutEngine::reset()
 }
 
 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)
 {
     setScriptAndLanguageTags();
@@ -137,6 +153,10 @@ OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, l
 
 OpenTypeLayoutEngine::~OpenTypeLayoutEngine()
 {
+    if (fTypoFlags & 0x80000000L) {
+        delete fSubstitutionFilter;
+    }
+
     reset();
 }
 
@@ -145,10 +165,25 @@ LETag OpenTypeLayoutEngine::getScriptTag(le_int32 scriptCode)
     if (scriptCode < 0 || scriptCode >= scriptCodeCount) {
         return 0xFFFFFFFF;
     }
-
     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)
 {
     if (languageCode < 0 || languageCode >= languageCodeCount) {
@@ -161,6 +196,7 @@ LETag OpenTypeLayoutEngine::getLangSysTag(le_int32 languageCode)
 void OpenTypeLayoutEngine::setScriptAndLanguageTags()
 {
     fScriptTag  = getScriptTag(fScriptCode);
+    fScriptTagV2 = getV2ScriptTag(fScriptCode);
     fLangSysTag = getLangSysTag(fLanguageCode);
 }
 
@@ -176,20 +212,39 @@ le_int32 OpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_i
         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;
     }
 
-    glyphStorage.allocateGlyphArray(outCharCount, rightToLeft, success);
+        CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, outChars, glyphStorage);
+    }
+
+    if (LE_FAILURE(success)) {
+        return 0;
+    }
+
+    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
@@ -213,13 +268,45 @@ le_int32 OpenTypeLayoutEngine::glyphProcessing(const LEUnicode chars[], le_int32
     }
 
     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)) {
@@ -251,6 +338,10 @@ le_int32 OpenTypeLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 o
 
     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...
@@ -260,6 +351,10 @@ le_int32 OpenTypeLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 o
         //adjustGlyphs(chars, offset, count, rightToLeft, fakeGlyphs, fakeGlyphCount);
     }
 
+    if (LE_FAILURE(success)) {
+        return 0;
+    }
+
     outGlyphCount = glyphPostProcessing(fakeGlyphStorage, glyphStorage, success);
 
     return outGlyphCount;
@@ -279,8 +374,11 @@ void OpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int3
     }
 
     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;
 
@@ -303,9 +401,21 @@ void OpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int3
         }
 #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) {
@@ -338,6 +448,21 @@ void OpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int3
         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/jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h b/jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h
index d5c7d5fca10596f0f6d7dadd1fdc05813f656647..cf257fb813104fa896be3c549552ce64892e2cd8 100644
--- a/jdk/src/share/native/sun/font/layout/OpenTypeLayoutEngine.h
+++ b/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 @@ U_NAMESPACE_BEGIN
  *
  * @internal
  */
-class OpenTypeLayoutEngine : public LayoutEngine
+class U_LAYOUT_API OpenTypeLayoutEngine : public LayoutEngine
 {
 public:
     /**
@@ -80,6 +80,7 @@ public:
      * @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 @@ public:
      * @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 @@ public:
      * @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 @@ public:
     /**
      * 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 @@ public:
      * @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 @@ public:
      */
     static UClassID getStaticClassID();
 
+    /**
+     * The array of language tags, indexed by language code.
+     *
+     * @internal
+     */
+    static const LETag languageTags[];
+
 private:
 
     /**
@@ -160,11 +184,6 @@ private:
      */
     static const LETag scriptTags[];
 
-    /**
-     * The array of language tags, indexed by language code.
-     */
-    static const LETag languageTags[];
-
 protected:
     /**
      * A set of "default" features. The default characterProcessing method
@@ -237,6 +256,13 @@ protected:
      */
     LETag fScriptTag;
 
+    /**
+     * The four byte script tag for V2 fonts.
+     *
+     * @internal
+     */
+    LETag fScriptTagV2;
+
     /**
      * The four byte language tag
      *
@@ -304,6 +330,8 @@ protected:
     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/jdk/src/share/native/sun/font/layout/OpenTypeTables.h b/jdk/src/share/native/sun/font/layout/OpenTypeTables.h
index 126e400119c59ab40e5a73ca05953e84fda95fb2..c4a4a68b75a7fd216f5e4abca77799e8edfbcfd9 100644
--- a/jdk/src/share/native/sun/font/layout/OpenTypeTables.h
+++ b/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 @@ U_NAMESPACE_BEGIN
 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/jdk/src/share/native/sun/font/layout/OpenTypeUtilities.cpp b/jdk/src/share/native/sun/font/layout/OpenTypeUtilities.cpp
index 6ede057a53e20e3e48cf0e0f403cd8245bba1048..3b25aa280c93f691920daac6ee0a0f7e59f17168 100644
--- a/jdk/src/share/native/sun/font/layout/OpenTypeUtilities.cpp
+++ b/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 OpenTypeUtilities::getGlyphRangeIndex(TTGlyphID glyphID, const GlyphRan
     le_int32 probe = power;
     le_int32 range = 0;
 
+        if (recordCount == 0) {
+                return -1;
+        }
+
     if (SWAPW(records[extra].firstGlyph) <= glyphID) {
         range = extra;
     }
diff --git a/jdk/src/share/native/sun/font/layout/PairPositioningSubtables.cpp b/jdk/src/share/native/sun/font/layout/PairPositioningSubtables.cpp
index 0bd6624912d1af26eb12269c0c05a7557308920c..d5d4f1bf15b4a243c7e9083511725f18581e3f70 100644
--- a/jdk/src/share/native/sun/font/layout/PairPositioningSubtables.cpp
+++ b/jdk/src/share/native/sun/font/layout/PairPositioningSubtables.cpp
@@ -101,7 +101,10 @@ le_uint32 PairPositioningFormat1Subtable::process(GlyphIterator *glyphIterator,
             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 @@ le_uint32 PairPositioningFormat2Subtable::process(GlyphIterator *glyphIterator,
             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 @@ le_uint32 PairPositioningFormat2Subtable::process(GlyphIterator *glyphIterator,
 
 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 @@ const PairValueRecord *PairPositioningFormat1Subtable::findPairValueRecord(TTGly
     if (SWAPW(record->secondGlyph) == glyphID) {
         return record;
     }
+#endif
 
     return NULL;
 }
diff --git a/jdk/src/share/native/sun/font/layout/ScriptAndLanguage.cpp b/jdk/src/share/native/sun/font/layout/ScriptAndLanguage.cpp
index 77fd0f60141b5cf94eacfc2058af3f62008dc82d..bb8b65ba371fd31b888eafe75f7998880639b45b 100644
--- a/jdk/src/share/native/sun/font/layout/ScriptAndLanguage.cpp
+++ b/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 @@ const LangSysTable *ScriptTable::findLanguage(LETag languageTag, le_bool exactMa
         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 LangSysTable *ScriptListTable::findLanguage(LETag scriptTag, LETag languag
     const ScriptTable *scriptTable = findScript(scriptTag);
 
     if (scriptTable == 0) {
-        return 0;
+        return NULL;
     }
 
     return scriptTable->findLanguage(languageTag, exactMatch);
diff --git a/jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp b/jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp
index 91de6df4bfcecd4c5382aaa572d856da89383eff..c7d46c631bc59966ac95821bac4460ac8c893aa4 100644
--- a/jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.cpp
+++ b/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 @@ U_NAMESPACE_BEGIN
 
 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 @@ const LETag OpenTypeLayoutEngine::scriptTags[] = {
     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 @@ const LETag OpenTypeLayoutEngine::scriptTags[] = {
     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 @@ const LETag OpenTypeLayoutEngine::scriptTags[] = {
     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 @@ const LETag OpenTypeLayoutEngine::languageTags[] = {
     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/jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.h b/jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.h
index 849940954689b29dc2a636e7b41814b948249c5d..885b50c0da23afdc35f73108ab5e7ba5be303bd3 100644
--- a/jdk/src/share/native/sun/font/layout/ScriptAndLanguageTags.h
+++ b/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 shawScriptTag = 0x73686177; /* 'shaw' (SHAVIAN) */
 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 urdLanguageTag = 0x55524420; /* 'URD' (Urdu) */
 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/jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp b/jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp
index d2016ba13a74dceae6f83abd0aa418f8d5e84827..d9064a11c12f2890fa4209345b569c483b1ccc6f 100644
--- a/jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp
+++ b/jdk/src/share/native/sun/font/layout/SegmentArrayProcessor.cpp
@@ -74,7 +74,7 @@ void SegmentArrayProcessor::process(LEGlyphStorage &glyphStorage)
 
             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/jdk/src/share/native/sun/font/layout/ShapingTypeData.cpp b/jdk/src/share/native/sun/font/layout/ShapingTypeData.cpp
index c4c293977d4604e83f52757a97826c2c96461ef9..06529907ba93a795d2302ad6e01bfe296d4b3ec1 100644
--- a/jdk/src/share/native/sun/font/layout/ShapingTypeData.cpp
+++ b/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/jdk/src/share/native/sun/font/layout/SubstitutionLookups.cpp b/jdk/src/share/native/sun/font/layout/SubstitutionLookups.cpp
index 286cf2f063c3d035007200ed88f32f5a05d3e509..7103a3fbb3b238349304e6bb4c662c7c030e8c08 100644
--- a/jdk/src/share/native/sun/font/layout/SubstitutionLookups.cpp
+++ b/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 @@ void SubstitutionLookup::applySubstitutionLookups(
         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/jdk/src/share/native/sun/font/layout/SubstitutionLookups.h b/jdk/src/share/native/sun/font/layout/SubstitutionLookups.h
index ef06fd07ccc94d4327efaafbba7dbd5e408bcffd..03693b1ef11a24ac754d0cee24852a80b4700cb9 100644
--- a/jdk/src/share/native/sun/font/layout/SubstitutionLookups.h
+++ b/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 @@ struct SubstitutionLookup
         le_uint16 substCount,
         GlyphIterator *glyphIterator,
         const LEFontInstance *fontInstance,
-        le_int32 position);
+        le_int32 position,
+                LEErrorCode& success);
 };
 
 U_NAMESPACE_END
diff --git a/jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp
index d4fc121da277a61afc57392cf503366e03458e21..65177a6e94c737195b1a9fa87c6908accabf8b25 100644
--- a/jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.cpp
+++ b/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 @@ le_int32 ThaiLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offse
     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/jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.h b/jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.h
index 28e1a72f17a9bd41e6bbd8dc029b75eac040ef3d..6851a5c837603ef73919dedde5d340f4f24cbd2b 100644
--- a/jdk/src/share/native/sun/font/layout/ThaiLayoutEngine.h
+++ b/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 @@ public:
      * @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 @@ protected:
     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 - TRUE 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/jdk/src/share/native/sun/font/layout/TibetanLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/TibetanLayoutEngine.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9f706548aae2d8436254d74384cf0627e553d9d2
--- /dev/null
+++ b/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 - 
+ *
+ * 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/jdk/src/share/native/sun/font/layout/TibetanLayoutEngine.h b/jdk/src/share/native/sun/font/layout/TibetanLayoutEngine.h
new file mode 100644
index 0000000000000000000000000000000000000000..c40dcc3343f81bed4ac04d58795c16ed36e5439b
--- /dev/null
+++ b/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 - 
+ *
+ * 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 - TRUE 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/jdk/src/share/native/sun/font/layout/TibetanReordering.cpp b/jdk/src/share/native/sun/font/layout/TibetanReordering.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..853843f3895196a37d733c36fb105c62dcc9be8d
--- /dev/null
+++ b/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 - 
+ *
+ * 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 
+#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/jdk/src/share/native/sun/font/layout/TibetanReordering.h b/jdk/src/share/native/sun/font/layout/TibetanReordering.h
new file mode 100644
index 0000000000000000000000000000000000000000..26a7ce4bb9a9b8bc78de9fa38adda665c24c15e9
--- /dev/null
+++ b/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 - 
+ *
+ * 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/jdk/src/share/native/sun/java2d/loops/Any3Byte.c b/jdk/src/share/native/sun/java2d/loops/Any3Byte.c
index 0f51bdc602b6cdd79c54fde69cdfc7c5d5251c2f..b44c9e7d6fcedc72598f486cd07d864bb0b10fda 100644
--- a/jdk/src/share/native/sun/java2d/loops/Any3Byte.c
+++ b/jdk/src/share/native/sun/java2d/loops/Any3Byte.c
@@ -38,6 +38,7 @@ RegisterFunc RegisterAny3Byte;
 
 DECLARE_SOLID_FILLRECT(Any3Byte);
 DECLARE_SOLID_FILLSPANS(Any3Byte);
+DECLARE_SOLID_PARALLELOGRAM(Any3Byte);
 DECLARE_SOLID_DRAWLINE(Any3Byte);
 DECLARE_XOR_FILLRECT(Any3Byte);
 DECLARE_XOR_FILLSPANS(Any3Byte);
@@ -48,6 +49,7 @@ DECLARE_XOR_DRAWGLYPHLIST(Any3Byte);
 NativePrimitive Any3BytePrimitives[] = {
     REGISTER_SOLID_FILLRECT(Any3Byte),
     REGISTER_SOLID_FILLSPANS(Any3Byte),
+    REGISTER_SOLID_PARALLELOGRAM(Any3Byte),
     REGISTER_SOLID_LINE_PRIMITIVES(Any3Byte),
     REGISTER_XOR_FILLRECT(Any3Byte),
     REGISTER_XOR_FILLSPANS(Any3Byte),
@@ -72,6 +74,8 @@ DEFINE_SOLID_FILLRECT(Any3Byte)
 
 DEFINE_SOLID_FILLSPANS(Any3Byte)
 
+DEFINE_SOLID_PARALLELOGRAM(Any3Byte)
+
 DEFINE_SOLID_DRAWLINE(Any3Byte)
 
 DEFINE_XOR_FILLRECT(Any3Byte)
diff --git a/jdk/src/share/native/sun/java2d/loops/Any4Byte.c b/jdk/src/share/native/sun/java2d/loops/Any4Byte.c
index 126ff922b2e47d4e14249d64020f015ff658a35e..05f165fb87bd31e1b1af58d475697951e258c0e9 100644
--- a/jdk/src/share/native/sun/java2d/loops/Any4Byte.c
+++ b/jdk/src/share/native/sun/java2d/loops/Any4Byte.c
@@ -41,6 +41,7 @@ RegisterFunc RegisterAny4Byte;
 
 DECLARE_SOLID_FILLRECT(Any4Byte);
 DECLARE_SOLID_FILLSPANS(Any4Byte);
+DECLARE_SOLID_PARALLELOGRAM(Any4Byte);
 DECLARE_SOLID_DRAWLINE(Any4Byte);
 DECLARE_XOR_FILLRECT(Any4Byte);
 DECLARE_XOR_FILLSPANS(Any4Byte);
@@ -51,6 +52,7 @@ DECLARE_XOR_DRAWGLYPHLIST(Any4Byte);
 NativePrimitive Any4BytePrimitives[] = {
     REGISTER_SOLID_FILLRECT(Any4Byte),
     REGISTER_SOLID_FILLSPANS(Any4Byte),
+    REGISTER_SOLID_PARALLELOGRAM(Any4Byte),
     REGISTER_SOLID_LINE_PRIMITIVES(Any4Byte),
     REGISTER_XOR_FILLRECT(Any4Byte),
     REGISTER_XOR_FILLSPANS(Any4Byte),
@@ -75,6 +77,8 @@ DEFINE_SOLID_FILLRECT(Any4Byte)
 
 DEFINE_SOLID_FILLSPANS(Any4Byte)
 
+DEFINE_SOLID_PARALLELOGRAM(Any4Byte)
+
 DEFINE_SOLID_DRAWLINE(Any4Byte)
 
 DEFINE_XOR_FILLRECT(Any4Byte)
diff --git a/jdk/src/share/native/sun/java2d/loops/AnyByte.c b/jdk/src/share/native/sun/java2d/loops/AnyByte.c
index 2d19c0d18c042a8194a2139e34cc18ca53bedd70..fa9fcd982a65275b0aacb715a80d9db1b1e33ee4 100644
--- a/jdk/src/share/native/sun/java2d/loops/AnyByte.c
+++ b/jdk/src/share/native/sun/java2d/loops/AnyByte.c
@@ -38,6 +38,7 @@ RegisterFunc RegisterAnyByte;
 
 DECLARE_SOLID_FILLRECT(AnyByte);
 DECLARE_SOLID_FILLSPANS(AnyByte);
+DECLARE_SOLID_PARALLELOGRAM(AnyByte);
 DECLARE_SOLID_DRAWLINE(AnyByte);
 DECLARE_XOR_FILLRECT(AnyByte);
 DECLARE_XOR_FILLSPANS(AnyByte);
@@ -48,6 +49,7 @@ DECLARE_XOR_DRAWGLYPHLIST(AnyByte);
 NativePrimitive AnyBytePrimitives[] = {
     REGISTER_SOLID_FILLRECT(AnyByte),
     REGISTER_SOLID_FILLSPANS(AnyByte),
+    REGISTER_SOLID_PARALLELOGRAM(AnyByte),
     REGISTER_SOLID_LINE_PRIMITIVES(AnyByte),
     REGISTER_XOR_FILLRECT(AnyByte),
     REGISTER_XOR_FILLSPANS(AnyByte),
@@ -72,6 +74,8 @@ DEFINE_SOLID_FILLRECT(AnyByte)
 
 DEFINE_SOLID_FILLSPANS(AnyByte)
 
+DEFINE_SOLID_PARALLELOGRAM(AnyByte)
+
 DEFINE_SOLID_DRAWLINE(AnyByte)
 
 DEFINE_XOR_FILLRECT(AnyByte)
diff --git a/jdk/src/share/native/sun/java2d/loops/AnyInt.c b/jdk/src/share/native/sun/java2d/loops/AnyInt.c
index 4e580c6048cec1a06b02c4e9ea77f31f7e53e4a4..a4244ebd9360602d68ff904a80e7cc4c1d7cdba6 100644
--- a/jdk/src/share/native/sun/java2d/loops/AnyInt.c
+++ b/jdk/src/share/native/sun/java2d/loops/AnyInt.c
@@ -38,6 +38,7 @@ RegisterFunc RegisterAnyInt;
 
 DECLARE_SOLID_FILLRECT(AnyInt);
 DECLARE_SOLID_FILLSPANS(AnyInt);
+DECLARE_SOLID_PARALLELOGRAM(AnyInt);
 DECLARE_SOLID_DRAWLINE(AnyInt);
 DECLARE_XOR_FILLRECT(AnyInt);
 DECLARE_XOR_FILLSPANS(AnyInt);
@@ -48,6 +49,7 @@ DECLARE_XOR_DRAWGLYPHLIST(AnyInt);
 NativePrimitive AnyIntPrimitives[] = {
     REGISTER_SOLID_FILLRECT(AnyInt),
     REGISTER_SOLID_FILLSPANS(AnyInt),
+    REGISTER_SOLID_PARALLELOGRAM(AnyInt),
     REGISTER_SOLID_LINE_PRIMITIVES(AnyInt),
     REGISTER_XOR_FILLRECT(AnyInt),
     REGISTER_XOR_FILLSPANS(AnyInt),
@@ -72,6 +74,8 @@ DEFINE_SOLID_FILLRECT(AnyInt)
 
 DEFINE_SOLID_FILLSPANS(AnyInt)
 
+DEFINE_SOLID_PARALLELOGRAM(AnyInt)
+
 DEFINE_SOLID_DRAWLINE(AnyInt)
 
 DEFINE_XOR_FILLRECT(AnyInt)
diff --git a/jdk/src/share/native/sun/java2d/loops/AnyShort.c b/jdk/src/share/native/sun/java2d/loops/AnyShort.c
index dd04e3096b17fca554c3e2398282113911ee63e1..556490d3522dbc92745e3b0d2737361f3f3baeff 100644
--- a/jdk/src/share/native/sun/java2d/loops/AnyShort.c
+++ b/jdk/src/share/native/sun/java2d/loops/AnyShort.c
@@ -38,6 +38,7 @@ RegisterFunc RegisterAnyShort;
 
 DECLARE_SOLID_FILLRECT(AnyShort);
 DECLARE_SOLID_FILLSPANS(AnyShort);
+DECLARE_SOLID_PARALLELOGRAM(AnyShort);
 DECLARE_SOLID_DRAWLINE(AnyShort);
 DECLARE_XOR_FILLRECT(AnyShort);
 DECLARE_XOR_FILLSPANS(AnyShort);
@@ -48,6 +49,7 @@ DECLARE_XOR_DRAWGLYPHLIST(AnyShort);
 NativePrimitive AnyShortPrimitives[] = {
     REGISTER_SOLID_FILLRECT(AnyShort),
     REGISTER_SOLID_FILLSPANS(AnyShort),
+    REGISTER_SOLID_PARALLELOGRAM(AnyShort),
     REGISTER_SOLID_LINE_PRIMITIVES(AnyShort),
     REGISTER_XOR_FILLRECT(AnyShort),
     REGISTER_XOR_FILLSPANS(AnyShort),
@@ -72,6 +74,8 @@ DEFINE_SOLID_FILLRECT(AnyShort)
 
 DEFINE_SOLID_FILLSPANS(AnyShort)
 
+DEFINE_SOLID_PARALLELOGRAM(AnyShort)
+
 DEFINE_SOLID_DRAWLINE(AnyShort)
 
 DEFINE_XOR_FILLRECT(AnyShort)
diff --git a/jdk/src/share/native/sun/java2d/loops/DrawParallelogram.c b/jdk/src/share/native/sun/java2d/loops/DrawParallelogram.c
new file mode 100644
index 0000000000000000000000000000000000000000..5906e6ab605f1c156131c7ff71ec1110df7e7430
--- /dev/null
+++ b/jdk/src/share/native/sun/java2d/loops/DrawParallelogram.c
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2008, 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.
+ */
+
+#include "math.h"
+#include "GraphicsPrimitiveMgr.h"
+#include "LineUtils.h"
+#include "LoopMacros.h"
+#include "Trace.h"
+
+#include "sun_java2d_loops_FillParallelogram.h"
+#include "sun_java2d_loops_DrawParallelogram.h"
+
+DECLARE_SOLID_DRAWLINE(AnyInt);
+
+#define HANDLE_PGRAM_EDGE(X1, Y1, X2, Y2, \
+                          pRasInfo, pixel, pPrim, pFunc, pCompInfo) \
+    do { \
+         jint ix1 = (jint) floor(X1); \
+         jint ix2 = (jint) floor(X2); \
+         jint iy1 = (jint) floor(Y1); \
+         jint iy2 = (jint) floor(Y2); \
+         LineUtils_ProcessLine(pRasInfo, pixel, \
+                               pFunc, pPrim, pCompInfo, \
+                               ix1, iy1, ix2, iy2, JNI_TRUE); \
+    } while (0)
+
+#define PGRAM_MIN_MAX(bmin, bmax, v0, dv1, dv2) \
+    do { \
+        double vmin, vmax; \
+        if (dv1 < 0) { \
+            vmin = v0+dv1; \
+            vmax = v0; \
+        } else { \
+            vmin = v0; \
+            vmax = v0+dv1; \
+        } \
+        if (dv2 < 0) { \
+            vmin -= dv2; \
+        } else { \
+            vmax += dv2; \
+        } \
+        bmin = (jint) floor(vmin + 0.5); \
+        bmax = (jint) floor(vmax + 0.5); \
+    } while(0)
+
+#define PGRAM_INIT_X(starty, x, y, slope) \
+    (DblToLong((x) + (slope) * ((starty)+0.5 - (y))) + LongOneHalf - 1)
+
+typedef struct {
+    jdouble x0;
+    jdouble y0;
+    jdouble y1;
+    jdouble slope;
+    jlong dx;
+    jint ystart;
+    jint yend;
+} EdgeInfo;
+
+#define STORE_EDGE(pEDGE, X0, Y0, Y1, SLOPE, DELTAX) \
+    do { \
+        (pEDGE)->x0 = (X0); \
+        (pEDGE)->y0 = (Y0); \
+        (pEDGE)->y1 = (Y1); \
+        (pEDGE)->slope = (SLOPE); \
+        (pEDGE)->dx = (DELTAX); \
+        (pEDGE)->ystart = (jint) floor((Y0) + 0.5); \
+        (pEDGE)->yend   = (jint) floor((Y1) + 0.5); \
+    } while (0)
+
+#define STORE_PGRAM(pLTEDGE, pRTEDGE, \
+                    X0, Y0, dX1, dY1, dX2, dY2, \
+                    SLOPE1, SLOPE2, DELTAX1, DELTAX2) \
+    do { \
+        STORE_EDGE((pLTEDGE)+0, \
+                   (X0), (Y0), (Y0) + (dY1), \
+                   (SLOPE1), (DELTAX1)); \
+        STORE_EDGE((pRTEDGE)+0, \
+                   (X0), (Y0), (Y0) + (dY2), \
+                   (SLOPE2), (DELTAX2)); \
+        STORE_EDGE((pLTEDGE)+1, \
+                   (X0) + (dX1), (Y0) + (dY1), (Y0) + (dY1) + (dY2), \
+                   (SLOPE2), (DELTAX2)); \
+        STORE_EDGE((pRTEDGE)+1, \
+                   (X0) + (dX2), (Y0) + (dY2), (Y0) + (dY1) + (dY2), \
+                   (SLOPE1), (DELTAX1)); \
+    } while (0)
+
+/*
+ * Class:     sun_java2d_loops_DrawParallelogram
+ * Method:    DrawParallelogram
+ * Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;DDDDDDDD)V
+ */
+JNIEXPORT void JNICALL
+Java_sun_java2d_loops_DrawParallelogram_DrawParallelogram
+    (JNIEnv *env, jobject self,
+     jobject sg2d, jobject sData,
+     jdouble x0, jdouble y0,
+     jdouble dx1, jdouble dy1,
+     jdouble dx2, jdouble dy2,
+     jdouble lw1, jdouble lw2)
+{
+    SurfaceDataOps *sdOps;
+    SurfaceDataRasInfo rasInfo;
+    NativePrimitive *pPrim;
+    CompositeInfo compInfo;
+    jint pixel;
+    EdgeInfo edges[8];
+    EdgeInfo *active[4];
+    jint ix1, iy1, ix2, iy2;
+    jdouble ldx1, ldy1, ldx2, ldy2;
+    jdouble ox0, oy0;
+
+    /*
+     * Sort parallelogram by y values, ensure that each delta vector
+     * has a non-negative y delta.
+     */
+    if (dy1 < 0) {
+        x0 += dx1;  y0 += dy1;
+        dx1 = -dx1; dy1 = -dy1;
+    }
+    if (dy2 < 0) {
+        x0 += dx2;  y0 += dy2;
+        dx2 = -dx2; dy2 = -dy2;
+    }
+    /* Sort delta vectors so dxy1 is left of dxy2. */
+    if (dx1 * dy2 > dx2 * dy1) {
+        double v = dx1; dx1 = dx2; dx2 = v;
+               v = dy1; dy1 = dy2; dy2 = v;
+               v = lw1; lw1 = lw2; lw2 = v;
+    }
+
+    // dx,dy for line width in the "1" and "2" directions.
+    ldx1 = dx1 * lw1;
+    ldy1 = dy1 * lw1;
+    ldx2 = dx2 * lw2;
+    ldy2 = dy2 * lw2;
+
+    // calculate origin of the outer parallelogram
+    ox0 = x0 - (ldx1 + ldx2) / 2.0;
+    oy0 = y0 - (ldy1 + ldy2) / 2.0;
+
+    PGRAM_MIN_MAX(ix1, ix2, ox0, dx1+ldx1, dx2+ldx2);
+    iy1 = (jint) floor(oy0 + 0.5);
+    iy2 = (jint) floor(oy0 + dy1 + ldy1 + dy2 + ldy2 + 0.5);
+
+    pPrim = GetNativePrim(env, self);
+    if (pPrim == NULL) {
+        return;
+    }
+    pixel = GrPrim_Sg2dGetPixel(env, sg2d);
+    if (pPrim->pCompType->getCompInfo != NULL) {
+        GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);
+    }
+
+    sdOps = SurfaceData_GetOps(env, sData);
+    if (sdOps == NULL) {
+        return;
+    }
+
+    GrPrim_Sg2dGetClip(env, sg2d, &rasInfo.bounds);
+    SurfaceData_IntersectBoundsXYXY(&rasInfo.bounds, ix1, iy1, ix2, iy2);
+    if (rasInfo.bounds.y2 <= rasInfo.bounds.y1 ||
+        rasInfo.bounds.x2 <= rasInfo.bounds.x1)
+    {
+        return;
+    }
+
+    if (sdOps->Lock(env, sdOps, &rasInfo, pPrim->dstflags) != SD_SUCCESS) {
+        return;
+    }
+
+    ix1 = rasInfo.bounds.x1;
+    iy1 = rasInfo.bounds.y1;
+    ix2 = rasInfo.bounds.x2;
+    iy2 = rasInfo.bounds.y2;
+    if (ix2 > ix1 && iy2 > iy1) {
+        sdOps->GetRasInfo(env, sdOps, &rasInfo);
+        if (rasInfo.rasBase) {
+            jdouble lslope, rslope;
+            jlong ldx, rdx;
+            jint loy, hiy, numedges;
+            FillParallelogramFunc *pFill =
+                pPrim->funcs.drawparallelogram->fillpgram;
+
+            lslope = (dy1 == 0) ? 0 : dx1 / dy1;
+            rslope = (dy2 == 0) ? 0 : dx2 / dy2;
+            ldx = DblToLong(lslope);
+            rdx = DblToLong(rslope);
+
+            // Only need to generate 4 quads if the interior still
+            // has a hole in it (i.e. if the line width ratios were
+            // both less than 1.0)
+            if (lw1 < 1.0f && lw2 < 1.0f) {
+                // If the line widths are both less than a pixel wide
+                // then we can use a drawline function instead for even
+                // more performance.
+                lw1 = sqrt(ldx1*ldx1 + ldy1*ldy1);
+                lw2 = sqrt(ldx2*ldx2 + ldy2*ldy2);
+                if (lw1 <= 1.0001 && lw2 <= 1.0001) {
+                    jdouble x3, y3;
+                    DrawLineFunc *pLine =
+                        pPrim->funcs.drawparallelogram->drawline;
+
+                    x3 = (dx1 += x0);
+                    y3 = (dy1 += y0);
+                    x3 += dx2;
+                    y3 += dy2;
+                    dx2 += x0;
+                    dy2 += y0;
+
+                    HANDLE_PGRAM_EDGE( x0,  y0, dx1, dy1,
+                                      &rasInfo, pixel, pPrim, pLine, &compInfo);
+                    HANDLE_PGRAM_EDGE(dx1, dy1,  x3,  y3,
+                                      &rasInfo, pixel, pPrim, pLine, &compInfo);
+                    HANDLE_PGRAM_EDGE( x3,  y3, dx2, dy2,
+                                      &rasInfo, pixel, pPrim, pLine, &compInfo);
+                    HANDLE_PGRAM_EDGE(dx2, dy2,  x0,  y0,
+                                      &rasInfo, pixel, pPrim, pLine, &compInfo);
+                    SurfaceData_InvokeRelease(env, sdOps, &rasInfo);
+                    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
+                    return;
+                }
+
+                // To simplify the edge management below we presort the
+                // inner and outer edges so that they are globally sorted
+                // from left to right.  If you scan across the array of
+                // edges for a given Y range then the edges you encounter
+                // will be sorted in X as well.
+                // If AB are left top and bottom edges of outer parallelogram,
+                // and CD are the right pair of edges, and abcd are the
+                // corresponding inner parallelogram edges then we want them
+                // sorted as ABabcdCD to ensure this horizontal ordering.
+                // Conceptually it is like 2 pairs of nested parentheses.
+                STORE_PGRAM(edges + 2, edges + 4,
+                            ox0 + ldx1 + ldx2, oy0 + ldy1 + ldy2,
+                            dx1 - ldx1, dy1 - ldy1,
+                            dx2 - ldx2, dy2 - ldy2,
+                            lslope, rslope, ldx, rdx);
+                numedges = 8;
+            } else {
+                // The line width ratios were large enough to consume
+                // the entire hole in the middle of the parallelogram
+                // so we can just issue one large quad for the outer
+                // parallelogram.
+                numedges = 4;
+            }
+
+            // The outer parallelogram always goes in the first two
+            // and last two entries in the array so we either have
+            // ABabcdCD ordering for 8 edges or ABCD ordering for 4
+            // edges.  See comment above where we store the inner
+            // parallelogram for a more complete description.
+            STORE_PGRAM(edges + 0, edges + numedges-2,
+                        ox0, oy0,
+                        dx1 + ldx1, dy1 + ldy1,
+                        dx2 + ldx2, dy2 + ldy2,
+                        lslope, rslope, ldx, rdx);
+
+            loy = edges[0].ystart;
+            if (loy < iy1) loy = iy1;
+            while (loy < iy2) {
+                jint numactive = 0;
+                jint cur;
+
+                hiy = iy2;
+                // Maintaining a sorted edge list is probably overkill for
+                // 4 or 8 edges.  The indices chosen above for storing the
+                // inner and outer left and right edges already guarantee
+                // left to right ordering so we just need to scan for edges
+                // that overlap the current Y range (and also determine the
+                // maximum Y value for which the range is valid).
+                for (cur = 0; cur < numedges; cur++) {
+                    EdgeInfo *pEdge = &edges[cur];
+                    jint yend = pEdge->yend;
+                    if (loy < yend) {
+                        // This edge is still in play, have we reached it yet?
+                        jint ystart = pEdge->ystart;
+                        if (loy < ystart) {
+                            // This edge is not active (yet)
+                            // Stop before we get to the top of it
+                            if (hiy > ystart) hiy = ystart;
+                        } else {
+                            // This edge is active, store it
+                            active[numactive++] = pEdge;
+                            // And stop when we get to the bottom of it
+                            if (hiy > yend) hiy = yend;
+                        }
+                    }
+                }
+#ifdef DEBUG
+                if ((numactive & 1) != 0) {
+                    J2dTraceLn1(J2D_TRACE_ERROR,
+                                "DrawParallelogram: "
+                                "ODD NUMBER OF PGRAM EDGES (%d)!!",
+                                numactive);
+                }
+#endif
+                for (cur = 0; cur < numactive; cur += 2) {
+                    EdgeInfo *pLeft  = active[cur+0];
+                    EdgeInfo *pRight = active[cur+1];
+                    jlong lx = PGRAM_INIT_X(loy,
+                                            pLeft->x0, pLeft->y0,
+                                            pLeft->slope);
+                    jlong rx = PGRAM_INIT_X(loy,
+                                            pRight->x0, pRight->y0,
+                                            pRight->slope);
+                    (*pFill)(&rasInfo,
+                             ix1, loy, ix2, hiy,
+                             lx, pLeft->dx,
+                             rx, pRight->dx,
+                             pixel, pPrim, &compInfo);
+                }
+                loy = hiy;
+            }
+        }
+        SurfaceData_InvokeRelease(env, sdOps, &rasInfo);
+    }
+    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
+}
diff --git a/jdk/src/share/native/sun/java2d/loops/FillParallelogram.c b/jdk/src/share/native/sun/java2d/loops/FillParallelogram.c
new file mode 100644
index 0000000000000000000000000000000000000000..bc55176e19b82fabf1ff81ee4f596f639681a201
--- /dev/null
+++ b/jdk/src/share/native/sun/java2d/loops/FillParallelogram.c
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2008, 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.
+ */
+
+#include "math.h"
+#include "GraphicsPrimitiveMgr.h"
+
+#include "sun_java2d_loops_FillParallelogram.h"
+
+#define PGRAM_MIN_MAX(bmin, bmax, v0, dv1, dv2) \
+    do { \
+        double vmin, vmax; \
+        if (dv1 < 0) { \
+            vmin = v0+dv1; \
+            vmax = v0; \
+        } else { \
+            vmin = v0; \
+            vmax = v0+dv1; \
+        } \
+        if (dv2 < 0) { \
+            vmin -= dv2; \
+        } else { \
+            vmax += dv2; \
+        } \
+        bmin = (jint) floor(vmin + 0.5); \
+        bmax = (jint) floor(vmax + 0.5); \
+    } while(0)
+
+#define PGRAM_INIT_X(starty, x, y, slope) \
+    (DblToLong((x) + (slope) * ((starty)+0.5 - (y))) + LongOneHalf - 1)
+
+/*
+ * Class:     sun_java2d_loops_FillParallelogram
+ * Method:    FillParallelogram
+ * Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;DDDDDD)V
+ */
+JNIEXPORT void JNICALL
+Java_sun_java2d_loops_FillParallelogram_FillParallelogram
+    (JNIEnv *env, jobject self,
+     jobject sg2d, jobject sData,
+     jdouble x0, jdouble y0,
+     jdouble dx1, jdouble dy1,
+     jdouble dx2, jdouble dy2)
+{
+    SurfaceDataOps *sdOps;
+    SurfaceDataRasInfo rasInfo;
+    NativePrimitive *pPrim;
+    CompositeInfo compInfo;
+    jint pixel;
+    jint ix1, iy1, ix2, iy2;
+
+    if ((dy1 == 0 && dx1 == 0) || (dy2 == 0 && dx2 == 0)) {
+        return;
+    }
+
+    /*
+     * Sort parallelogram by y values, ensure that each delta vector
+     * has a non-negative y delta, and eliminate degenerate parallelograms.
+     */
+    if (dy1 < 0) {
+        x0 += dx1;  y0 += dy1;
+        dx1 = -dx1; dy1 = -dy1;
+    }
+    if (dy2 < 0) {
+        x0 += dx2;  y0 += dy2;
+        dx2 = -dx2; dy2 = -dy2;
+    }
+    /* Sort delta vectors so dxy1 is left of dxy2. */
+    if (dx1 * dy2 > dx2 * dy1) {
+        double v = dx1; dx1 = dx2; dx2 = v;
+               v = dy1; dy1 = dy2; dy2 = v;
+    }
+    PGRAM_MIN_MAX(ix1, ix2, x0, dx1, dx2);
+    iy1 = (jint) floor(y0 + 0.5);
+    iy2 = (jint) floor(y0 + dy1 + dy2 + 0.5);
+
+    pPrim = GetNativePrim(env, self);
+    if (pPrim == NULL) {
+        return;
+    }
+    pixel = GrPrim_Sg2dGetPixel(env, sg2d);
+    if (pPrim->pCompType->getCompInfo != NULL) {
+        GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);
+    }
+
+    sdOps = SurfaceData_GetOps(env, sData);
+    if (sdOps == NULL) {
+        return;
+    }
+
+    GrPrim_Sg2dGetClip(env, sg2d, &rasInfo.bounds);
+    SurfaceData_IntersectBoundsXYXY(&rasInfo.bounds, ix1, iy1, ix2, iy2);
+    if (rasInfo.bounds.y2 <= rasInfo.bounds.y1 ||
+        rasInfo.bounds.x2 <= rasInfo.bounds.x1)
+    {
+        return;
+    }
+
+    if (sdOps->Lock(env, sdOps, &rasInfo, pPrim->dstflags) != SD_SUCCESS) {
+        return;
+    }
+
+    ix1 = rasInfo.bounds.x1;
+    iy1 = rasInfo.bounds.y1;
+    ix2 = rasInfo.bounds.x2;
+    iy2 = rasInfo.bounds.y2;
+    if (ix2 > ix1 && iy2 > iy1) {
+        sdOps->GetRasInfo(env, sdOps, &rasInfo);
+        if (rasInfo.rasBase) {
+            jdouble lslope = (dy1 == 0) ? 0 : dx1 / dy1;
+            jdouble rslope = (dy2 == 0) ? 0 : dx2 / dy2;
+            jlong ldx = DblToLong(lslope);
+            jlong rdx = DblToLong(rslope);
+            jint cy1, cy2, loy, hiy;
+            dx1 += x0;
+            dy1 += y0;
+            dx2 += x0;
+            dy2 += y0;
+            cy1 = (jint) floor(dy1 + 0.5);
+            cy2 = (jint) floor(dy2 + 0.5);
+
+            /* Top triangular portion. */
+            loy = iy1;
+            hiy = (cy1 < cy2) ? cy1 : cy2;
+            if (hiy > iy2) hiy = iy2;
+            if (loy < hiy) {
+                jlong lx = PGRAM_INIT_X(loy, x0, y0, lslope);
+                jlong rx = PGRAM_INIT_X(loy, x0, y0, rslope);
+                (*pPrim->funcs.fillparallelogram)(&rasInfo,
+                                                  ix1, loy, ix2, hiy,
+                                                  lx, ldx, rx, rdx,
+                                                  pixel, pPrim, &compInfo);
+            }
+
+            /* Middle parallelogram portion, which way does it slant? */
+            if (cy1 < cy2) {
+                /* Middle parallelogram portion, slanted to right. */
+                /* left leg turned a corner at y0+dy1 */
+                /* right leg continuing on its initial trajectory from y0 */
+                loy = cy1;
+                hiy = cy2;
+                if (loy < iy1) loy = iy1;
+                if (hiy > iy2) hiy = iy2;
+                if (loy < hiy) {
+                    jlong lx = PGRAM_INIT_X(loy, dx1, dy1, rslope);
+                    jlong rx = PGRAM_INIT_X(loy,  x0,  y0, rslope);
+                    (*pPrim->funcs.fillparallelogram)(&rasInfo,
+                                                      ix1, loy, ix2, hiy,
+                                                      lx, rdx, rx, rdx,
+                                                      pixel, pPrim, &compInfo);
+                }
+            } else if (cy2 < cy1) {
+                /* Middle parallelogram portion, slanted to left. */
+                /* left leg continuing on its initial trajectory from y0 */
+                /* right leg turned a corner at y0+dy2 */
+                loy = cy2;
+                hiy = cy1;
+                if (loy < iy1) loy = iy1;
+                if (hiy > iy2) hiy = iy2;
+                if (loy < hiy) {
+                    jlong lx = PGRAM_INIT_X(loy,  x0,  y0, lslope);
+                    jlong rx = PGRAM_INIT_X(loy, dx2, dy2, lslope);
+                    (*pPrim->funcs.fillparallelogram)(&rasInfo,
+                                                      ix1, loy, ix2, hiy,
+                                                      lx, ldx, rx, ldx,
+                                                      pixel, pPrim, &compInfo);
+                }
+            }
+
+            /* Bottom triangular portion. */
+            loy = (cy1 > cy2) ? cy1 : cy2;
+            if (loy < iy1) loy = iy1;
+            hiy = iy2;
+            if (loy < hiy) {
+                /* left leg turned its corner at y0+dy1, now moving right */
+                /* right leg turned its corner at y0+dy2, now moving left */
+                jlong lx = PGRAM_INIT_X(loy, dx1, dy1, rslope);
+                jlong rx = PGRAM_INIT_X(loy, dx2, dy2, lslope);
+                (*pPrim->funcs.fillparallelogram)(&rasInfo,
+                                                  ix1, loy, ix2, hiy,
+                                                  lx, rdx, rx, ldx,
+                                                  pixel, pPrim, &compInfo);
+            }
+        }
+        SurfaceData_InvokeRelease(env, sdOps, &rasInfo);
+    }
+    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
+}
diff --git a/jdk/src/share/native/sun/java2d/loops/GraphicsPrimitiveMgr.c b/jdk/src/share/native/sun/java2d/loops/GraphicsPrimitiveMgr.c
index 5ccc7e4b0e8ad3bfd0dab9e940d61b0b295c67df..62edfedb0bfcb166a55351170545415ab545cf99 100644
--- a/jdk/src/share/native/sun/java2d/loops/GraphicsPrimitiveMgr.c
+++ b/jdk/src/share/native/sun/java2d/loops/GraphicsPrimitiveMgr.c
@@ -574,6 +574,8 @@ struct _PrimitiveTypes PrimitiveTypes = {
     { "sun/java2d/loops/ScaledBlit", SD_LOCK_READ, SD_LOCK_WRITE, NULL, NULL},
     { "sun/java2d/loops/FillRect", 0, SD_LOCK_WRITE, NULL, NULL},
     { "sun/java2d/loops/FillSpans", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
+    { "sun/java2d/loops/FillParallelogram", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
+    { "sun/java2d/loops/DrawParallelogram", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
     { "sun/java2d/loops/DrawLine", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
     { "sun/java2d/loops/DrawRect", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
     { "sun/java2d/loops/DrawPolygons", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
diff --git a/jdk/src/share/native/sun/java2d/loops/GraphicsPrimitiveMgr.h b/jdk/src/share/native/sun/java2d/loops/GraphicsPrimitiveMgr.h
index 4385785ca42eff3ed11adcff876aeada3cdc95b1..695ab5faa5abaac444d607881599bc929a524d48 100644
--- a/jdk/src/share/native/sun/java2d/loops/GraphicsPrimitiveMgr.h
+++ b/jdk/src/share/native/sun/java2d/loops/GraphicsPrimitiveMgr.h
@@ -333,6 +333,26 @@ typedef void (TransformInterpFunc)(jint *pRGBbase, jint numpix,
                                    jint xfract, jint dxfract,
                                    jint yfract, jint dyfract);
 
+/*
+ * The signature of the inner loop function for a "FillParallelogram"
+ * Note that this same inner loop is used for native DrawParallelogram
+ * primitives.
+ * Note that these functions are paired with equivalent DrawLine
+ * inner loop functions to facilitate nicer looking and faster thin
+ * transformed drawrect calls.
+ */
+typedef void (FillParallelogramFunc)(SurfaceDataRasInfo *pRasInfo,
+                                     jint lox, jint loy, jint hix, jint hiy,
+                                     jlong leftx, jlong dleftx,
+                                     jlong rightx, jlong drightx,
+                                     jint pixel, struct _NativePrimitive *pPrim,
+                                     CompositeInfo *pCompInfo);
+
+typedef struct {
+    FillParallelogramFunc       *fillpgram;
+    DrawLineFunc                *drawline;
+} DrawParallelogramFuncs;
+
 /*
  * This structure contains all information for defining a single
  * native GraphicsPrimitive, including:
@@ -363,6 +383,8 @@ typedef struct _NativePrimitive {
         ScaleBlitFunc           *scaledblit;
         FillRectFunc            *fillrect;
         FillSpansFunc           *fillspans;
+        FillParallelogramFunc   *fillparallelogram;
+        DrawParallelogramFuncs  *drawparallelogram;
         DrawLineFunc            *drawline;
         MaskFillFunc            *maskfill;
         MaskBlitFunc            *maskblit;
@@ -393,6 +415,8 @@ extern struct _PrimitiveTypes {
     PrimitiveType       ScaledBlit;
     PrimitiveType       FillRect;
     PrimitiveType       FillSpans;
+    PrimitiveType       FillParallelogram;
+    PrimitiveType       DrawParallelogram;
     PrimitiveType       DrawLine;
     PrimitiveType       DrawRect;
     PrimitiveType       DrawPolygons;
@@ -536,6 +560,7 @@ extern jint sunHints_INTVAL_STROKE_PURE;
 #define LongOneHalf     (((jlong) 1) << 31)
 #define IntToLong(i)    (((jlong) (i)) << 32)
 #define DblToLong(d)    ((jlong) ((d) * IntToLong(1)))
+#define LongToDbl(l)    (((jdouble) l) / IntToLong(1))
 #define WholeOfLong(l)  ((jint) ((l) >> 32))
 #define FractOfLong(l)  ((jint) (l))
 #define URShift(i, n)   (((juint) (i)) >> (n))
@@ -595,6 +620,10 @@ extern jint sunHints_INTVAL_STROKE_PURE;
 #define REGISTER_FILLSPANS(SRC, COMP, DST, FUNC) \
     REGISTER_PRIMITIVE(FillSpans, SRC, COMP, DST, FUNC)
 
+#define REGISTER_FILLPGRAM(SRC, COMP, DST, FUNC) \
+    REGISTER_PRIMITIVE(FillParallelogram, SRC, COMP, DST, FUNC), \
+    REGISTER_PRIMITIVE(DrawParallelogram, SRC, COMP, DST, FUNC)
+
 #define REGISTER_LINE_PRIMITIVES(SRC, COMP, DST, FUNC) \
     REGISTER_PRIMITIVE(DrawLine, SRC, COMP, DST, FUNC), \
     REGISTER_PRIMITIVE(DrawRect, SRC, COMP, DST, FUNC), \
diff --git a/jdk/src/share/native/sun/java2d/loops/LoopMacros.h b/jdk/src/share/native/sun/java2d/loops/LoopMacros.h
index 8b54e563fa47d7ca0f71d35f8df026db0bfae3f7..457cb4ba20b56406ca1778ac28b07ef3dffad4a2 100644
--- a/jdk/src/share/native/sun/java2d/loops/LoopMacros.h
+++ b/jdk/src/share/native/sun/java2d/loops/LoopMacros.h
@@ -607,6 +607,12 @@
 
 #define NAME_TRANSFORMHELPER_FUNCS(TYPE) TYPE ## TransformHelperFuncs
 
+#define NAME_SOLID_FILLPGRAM(TYPE)       TYPE ## SetParallelogram
+#define NAME_SOLID_PGRAM_FUNCS(TYPE)     TYPE ## SetParallelogramFuncs
+
+#define NAME_XOR_FILLPGRAM(TYPE)         TYPE ## XorParallelogram
+#define NAME_XOR_PGRAM_FUNCS(TYPE)       TYPE ## XorParallelogramFuncs
+
 /*
  * These macros conveniently name and declare the indicated native
  * primitive loop function for forward referencing.
@@ -689,6 +695,16 @@
     TransformHelperFunc NAME_TRANSFORMHELPER_BC(TYPE); \
     TransformHelperFuncs NAME_TRANSFORMHELPER_FUNCS(TYPE)
 
+#define DECLARE_SOLID_PARALLELOGRAM(TYPE) \
+    FillParallelogramFunc NAME_SOLID_FILLPGRAM(TYPE); \
+    DECLARE_SOLID_DRAWLINE(TYPE); \
+    DrawParallelogramFuncs NAME_SOLID_PGRAM_FUNCS(TYPE)
+
+#define DECLARE_XOR_PARALLELOGRAM(TYPE) \
+    FillParallelogramFunc NAME_XOR_FILLPGRAM(TYPE); \
+    DECLARE_XOR_DRAWLINE(TYPE); \
+    DrawParallelogramFuncs NAME_XOR_PGRAM_FUNCS(TYPE)
+
 /*
  * These macros construct the necessary NativePrimitive structure
  * for the indicated native primitive loop function which will be
@@ -800,6 +816,18 @@
     REGISTER_PRIMITIVE(TransformHelper, TYPE, SrcNoEa, IntArgbPre, \
                        (AnyFunc *) &NAME_TRANSFORMHELPER_FUNCS(TYPE))
 
+#define REGISTER_SOLID_PARALLELOGRAM(TYPE) \
+    REGISTER_PRIMITIVE(FillParallelogram, AnyColor, SrcNoEa, TYPE, \
+                       NAME_SOLID_FILLPGRAM(TYPE)), \
+    REGISTER_PRIMITIVE(DrawParallelogram, AnyColor, SrcNoEa, TYPE, \
+                       (AnyFunc *) &NAME_SOLID_PGRAM_FUNCS(TYPE))
+
+#define REGISTER_XOR_PARALLELOGRAM(TYPE) \
+    REGISTER_PRIMITIVE(FillParallelogram, AnyColor, Xor, TYPE, \
+                       NAME_XOR_FILLPGRAM(TYPE)), \
+    REGISTER_PRIMITIVE(DrawParallelogram, AnyColor, Xor, TYPE, \
+                       (AnyFunc *) &NAME_XOR_PGRAM_FUNCS(TYPE))
+
 /*
  * This macro defines an entire function to implement a Blit inner loop
  * for copying pixels of a common type from one buffer to another.
@@ -1264,6 +1292,51 @@ void NAME_SOLID_FILLSPANS(DST)(SurfaceDataRasInfo *pRasInfo, \
     } \
 }
 
+/*
+ * This macro defines an entire function to implement a FillParallelogram
+ * inner loop for tracing 2 diagonal edges (left and right) and setting
+ * those regions of pixels between them to a specific pixel value.
+ * No blending of the fill color is done with the pixels.
+ */
+#define DEFINE_SOLID_FILLPGRAM(DST) \
+void NAME_SOLID_FILLPGRAM(DST)(SurfaceDataRasInfo *pRasInfo, \
+                               jint lox, jint loy, jint hix, jint hiy, \
+                               jlong leftx, jlong dleftx, \
+                               jlong rightx, jlong drightx, \
+                               jint pixel, struct _NativePrimitive *pPrim, \
+                               CompositeInfo *pCompInfo) \
+{ \
+    Declare ## DST ## PixelData(pix) \
+    jint scan = pRasInfo->scanStride; \
+    DST ## DataType *pPix = PtrCoord(pRasInfo->rasBase, 0, 0, loy, scan); \
+ \
+    Extract ## DST ## PixelData(pixel, pix); \
+    while (loy < hiy) { \
+        jint lx = WholeOfLong(leftx); \
+        jint rx = WholeOfLong(rightx); \
+        if (lx < lox) lx = lox; \
+        if (rx > hix) rx = hix; \
+        while (lx < rx) { \
+            Store ## DST ## PixelData(pPix, lx, pixel, pix); \
+            lx++; \
+        } \
+        pPix = PtrAddBytes(pPix, scan); \
+        leftx += dleftx; \
+        rightx += drightx; \
+        loy++; \
+    } \
+}
+
+#define DEFINE_SOLID_DRAWPARALLELOGRAM_FUNCS(DST) \
+    DrawParallelogramFuncs NAME_SOLID_PGRAM_FUNCS(DST) = { \
+        NAME_SOLID_FILLPGRAM(DST), \
+        NAME_SOLID_DRAWLINE(DST), \
+    };
+
+#define DEFINE_SOLID_PARALLELOGRAM(DST) \
+    DEFINE_SOLID_FILLPGRAM(DST) \
+    DEFINE_SOLID_DRAWPARALLELOGRAM_FUNCS(DST)
+
 /*
  * This macro declares the bumpmajor and bumpminor variables used for the
  * DrawLine functions.
diff --git a/jdk/src/share/native/sun/security/ec/ECC_JNI.cpp b/jdk/src/share/native/sun/security/ec/ECC_JNI.cpp
index 1ddc5853368724f9fb0f2fd48d2e765ae252f803..a810cd8db28ddfa93e8dbc1e915d926f5da4af12 100644
--- a/jdk/src/share/native/sun/security/ec/ECC_JNI.cpp
+++ b/jdk/src/share/native/sun/security/ec/ECC_JNI.cpp
@@ -89,7 +89,7 @@ JNICALL Java_sun_security_ec_ECKeyPairGenerator_generateECKeyPair
     // Fill a new ECParams using the supplied OID
     if (EC_DecodeParams(¶ms_item, &ecparams, 0) != SECSuccess) {
         /* bad curve OID */
-        ThrowException(env, INVALID_ALGORITHM_PARAMETER_EXCEPTION);
+        ThrowException(env, (char *) INVALID_ALGORITHM_PARAMETER_EXCEPTION);
         goto cleanup;
     }
 
@@ -101,7 +101,7 @@ JNICALL Java_sun_security_ec_ECKeyPairGenerator_generateECKeyPair
     // Generate the new keypair (using the supplied seed)
     if (EC_NewKey(ecparams, &privKey, (unsigned char *) pSeedBuffer,
         jSeedLength, 0) != SECSuccess) {
-        ThrowException(env, KEY_EXCEPTION);
+        ThrowException(env, (char *) KEY_EXCEPTION);
         goto cleanup;
     }
 
diff --git a/jdk/src/solaris/classes/java/lang/ProcessImpl.java b/jdk/src/solaris/classes/java/lang/ProcessImpl.java
index 5c291b138c31419097ea64e9f8a6b58d9090da6a..ed0c6397677007a2e6529dbe7f907115cfe3ddc3 100644
--- a/jdk/src/solaris/classes/java/lang/ProcessImpl.java
+++ b/jdk/src/solaris/classes/java/lang/ProcessImpl.java
@@ -111,7 +111,8 @@ final class ProcessImpl {
                 else if (redirects[1] == Redirect.INHERIT)
                     std_fds[1] = 1;
                 else {
-                    f1 = redirects[1].toFileOutputStream();
+                    f1 = new FileOutputStream(redirects[1].file(),
+                                              redirects[1].append());
                     std_fds[1] = fdAccess.get(f1.getFD());
                 }
 
@@ -120,7 +121,8 @@ final class ProcessImpl {
                 else if (redirects[2] == Redirect.INHERIT)
                     std_fds[2] = 2;
                 else {
-                    f2 = redirects[2].toFileOutputStream();
+                    f2 = new FileOutputStream(redirects[2].file(),
+                                              redirects[2].append());
                     std_fds[2] = fdAccess.get(f2.getFD());
                 }
             }
diff --git a/jdk/src/solaris/classes/sun/awt/X11/MotifDnDDragSourceProtocol.java b/jdk/src/solaris/classes/sun/awt/X11/MotifDnDDragSourceProtocol.java
index 3cfffa71979596f9507c368fe82f5cc125b26b5d..85cd5448fd533fca470453fb159cd5e207c0c348 100644
--- a/jdk/src/solaris/classes/sun/awt/X11/MotifDnDDragSourceProtocol.java
+++ b/jdk/src/solaris/classes/sun/awt/X11/MotifDnDDragSourceProtocol.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, 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
@@ -134,7 +134,8 @@ class MotifDnDDragSourceProtocol extends XDragSourceProtocol
         if (swapNeeded) {
             t = MotifDnDConstants.Swapper.swap(t);
         }
-        long time = t;
+        long time = t & 0xffffffffL;
+             // with correction of (32-bit unsigned to 64-bit signed) implicit conversion.
 
         /* Discard events from the previous receiver. */
         if (targetEnterServerTime == XConstants.CurrentTime ||
diff --git a/jdk/src/solaris/classes/sun/awt/X11/MotifDnDDropTargetProtocol.java b/jdk/src/solaris/classes/sun/awt/X11/MotifDnDDropTargetProtocol.java
index a6ec86c505f165a5304cfef511ff1e5cdcf258d1..030c02f557b8e400239a99353afa4d02b33e2237 100644
--- a/jdk/src/solaris/classes/sun/awt/X11/MotifDnDDropTargetProtocol.java
+++ b/jdk/src/solaris/classes/sun/awt/X11/MotifDnDDropTargetProtocol.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, 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
@@ -928,7 +928,9 @@ class MotifDnDDropTargetProtocol extends XDropTargetProtocol {
             throw new IOException("Cannot get data: drag source property atom unavailable");
         }
 
-        long time_stamp = MotifDnDConstants.Swapper.getInt(data + 4, eventByteOrder);
+        long time_stamp = MotifDnDConstants.Swapper.getInt(data + 4, eventByteOrder) & 0xffffffffL;
+                          // with correction of (32-bit unsigned to 64-bit signed) implicit conversion.
+
         XAtom selectionAtom = XAtom.get(selatom);
 
         XSelection selection = XSelection.getSelection(selectionAtom);
@@ -962,7 +964,9 @@ class MotifDnDDropTargetProtocol extends XDropTargetProtocol {
             return false;
         }
 
-        long time_stamp = MotifDnDConstants.Swapper.getInt(data + 4, eventByteOrder);
+        long time_stamp = MotifDnDConstants.Swapper.getInt(data + 4, eventByteOrder) & 0xffffffffL;
+                          // with correction of (32-bit unsigned to 64-bit signed) implicit conversion.
+
         long sel_atom = MotifDnDConstants.Swapper.getInt(data + 12, eventByteOrder);
 
         long status_atom = 0;
diff --git a/jdk/src/solaris/classes/sun/nio/ch/FileDispatcherImpl.java b/jdk/src/solaris/classes/sun/nio/ch/FileDispatcherImpl.java
index 6f17340372e3692b443802073415c94ed2a757dd..f56d317cc91106563daa298ade43f6e6ddf8fa10 100644
--- a/jdk/src/solaris/classes/sun/nio/ch/FileDispatcherImpl.java
+++ b/jdk/src/solaris/classes/sun/nio/ch/FileDispatcherImpl.java
@@ -35,6 +35,13 @@ class FileDispatcherImpl extends FileDispatcher
         init();
     }
 
+    FileDispatcherImpl(boolean append) {
+        /* append is ignored */
+    }
+
+    FileDispatcherImpl() {
+    }
+
     int read(FileDescriptor fd, long address, int len) throws IOException {
         return read0(fd, address, len);
     }
diff --git a/jdk/src/solaris/classes/sun/nio/ch/SctpNet.java b/jdk/src/solaris/classes/sun/nio/ch/SctpNet.java
index c19aa7d1ec5041146ba34f09ff8462f8c4700f3f..f426ae7f6a5808e1f08d12f7bae07a06ce56db67 100644
--- a/jdk/src/solaris/classes/sun/nio/ch/SctpNet.java
+++ b/jdk/src/solaris/classes/sun/nio/ch/SctpNet.java
@@ -43,7 +43,7 @@ public class SctpNet {
 
     /* -- Miscellaneous SCTP utilities -- */
 
-    static boolean bindxIPv4MappedAddresses() {
+    private static boolean IPv4MappedAddresses() {
         if ("SunOS".equals(osName)) {
             /* Solaris supports IPv4Mapped Addresses with bindx */
             return true;
@@ -87,7 +87,7 @@ public class SctpNet {
     static void bindx(int fd, InetAddress[] addrs, int port, boolean add)
             throws IOException {
         bindx(fd, addrs, port, addrs.length, add,
-                bindxIPv4MappedAddresses());
+                IPv4MappedAddresses());
     }
 
     static Set getLocalAddresses(int fd)
@@ -145,11 +145,16 @@ public class SctpNet {
             InetSocketAddress netAddr = (InetSocketAddress)addr;
 
             if (name.equals(SCTP_PRIMARY_ADDR)) {
-                setPrimAddrOption0(fd, assocId,
-                        netAddr.getAddress(), netAddr.getPort());
+                setPrimAddrOption0(fd,
+                                   assocId,
+                                   netAddr.getAddress(),
+                                   netAddr.getPort());
             } else {
-                setPeerPrimAddrOption0(fd, assocId,
-                        netAddr.getAddress(), netAddr.getPort());
+                setPeerPrimAddrOption0(fd,
+                                       assocId,
+                                       netAddr.getAddress(),
+                                       netAddr.getPort(),
+                                       IPv4MappedAddresses());
             }
         } else if (name.equals(SCTP_DISABLE_FRAGMENTS) ||
             name.equals(SCTP_EXPLICIT_COMPLETE) ||
@@ -290,7 +295,7 @@ public class SctpNet {
             int port) throws IOException;
 
     static native void setPeerPrimAddrOption0(int fd, int assocId,
-            InetAddress ia, int port) throws IOException;
+            InetAddress ia, int port, boolean preferIPv6) throws IOException;
 
     static native SocketAddress getPrimAddrOption0(int fd, int assocId)
             throws IOException;
diff --git a/jdk/src/solaris/native/java/io/FileOutputStream_md.c b/jdk/src/solaris/native/java/io/FileOutputStream_md.c
index 1d71052ec5651005840f82ce5b1b2db9fb8323ac..ffc2011797ddb9e02f5eeffecac77e1f7ce344a0 100644
--- a/jdk/src/solaris/native/java/io/FileOutputStream_md.c
+++ b/jdk/src/solaris/native/java/io/FileOutputStream_md.c
@@ -60,14 +60,14 @@ Java_java_io_FileOutputStream_open(JNIEnv *env, jobject this,
 }
 
 JNIEXPORT void JNICALL
-Java_java_io_FileOutputStream_write(JNIEnv *env, jobject this, jint byte) {
-    writeSingle(env, this, byte, fos_fd);
+Java_java_io_FileOutputStream_write(JNIEnv *env, jobject this, jint byte, jboolean append) {
+    writeSingle(env, this, byte, append, fos_fd);
 }
 
 JNIEXPORT void JNICALL
 Java_java_io_FileOutputStream_writeBytes(JNIEnv *env,
-    jobject this, jbyteArray bytes, jint off, jint len) {
-    writeBytes(env, this, bytes, off, len, fos_fd);
+    jobject this, jbyteArray bytes, jint off, jint len, jboolean append) {
+    writeBytes(env, this, bytes, off, len, append, fos_fd);
 }
 
 JNIEXPORT void JNICALL
diff --git a/jdk/src/solaris/native/java/io/io_util_md.h b/jdk/src/solaris/native/java/io/io_util_md.h
index 378fbcb1ebc24f4a3dbfcd4ceea7a2fb93ec1561..b5fe90e6a7387b89505703d44962010bdfca85d8 100644
--- a/jdk/src/solaris/native/java/io/io_util_md.h
+++ b/jdk/src/solaris/native/java/io/io_util_md.h
@@ -53,8 +53,9 @@
 #define THIS_FD(obj) (*env)->GetIntField(env, obj, IO_fd_fdID)
 
 /*
- * Route the routines through HPI
+ * Route the routines through VM
  */
+#define IO_Append JVM_Write
 #define IO_Write JVM_Write
 #define IO_Sync JVM_Sync
 #define IO_Read JVM_Read
diff --git a/jdk/src/solaris/native/sun/java2d/loops/java2d_Mlib.c b/jdk/src/solaris/native/sun/java2d/loops/java2d_Mlib.c
index d35839cf6a9dd53a7cf0a74e2448ac923bed5c25..758e6433dfdb9e3df091a8dda221c9469c186786 100644
--- a/jdk/src/solaris/native/sun/java2d/loops/java2d_Mlib.c
+++ b/jdk/src/solaris/native/sun/java2d/loops/java2d_Mlib.c
@@ -282,6 +282,50 @@ DEFINE_XOR_SPANS(XorSpans, AnyShort, 1)
 
 /***************************************************************/
 
+#define DEFINE_SET_PGRAM(FUNC, ANYTYPE, NCHAN)                      \
+void ADD_SUFF(ANYTYPE##FUNC)(SurfaceDataRasInfo *pRasInfo,          \
+                             jint lox, jint loy,                    \
+                             jint hix, jint hiy,                    \
+                             jlong leftx, jlong dleftx,             \
+                             jlong rightx, jlong drightx,           \
+                             jint pixel, NativePrimitive * pPrim,   \
+                             CompositeInfo * pCompInfo)             \
+{                                                                   \
+    mlib_image dst[1];                                              \
+    mlib_s32 dstScan = pRasInfo->scanStride;                        \
+    mlib_u8  *dstBase = (mlib_u8*)(pRasInfo->rasBase), *pdst;       \
+    mlib_s32 c_arr[4];                                              \
+                                                                    \
+    STORE_CONST_##NCHAN(c_arr, pixel);                              \
+    pdst = dstBase + loy*dstScan;                                   \
+                                                                    \
+    while (loy < hiy) {                                             \
+        jint lx = WholeOfLong(leftx);                               \
+        jint rx = WholeOfLong(rightx);                              \
+        if (lx < lox) lx = lox;                                     \
+        if (rx > hix) rx = hix;                                     \
+                                                                    \
+        MLIB_IMAGE_SET(dst, MLIB_##ANYTYPE, NCHAN_##ANYTYPE,        \
+                       rx-lx, 1, dstScan,                           \
+                       pdst + lx*ANYTYPE##PixelStride);             \
+                                                                    \
+        mlib_ImageClear(dst, c_arr);                                \
+                                                                    \
+        pdst = PtrAddBytes(pdst, dstScan);                          \
+        leftx += dleftx;                                            \
+        rightx += drightx;                                          \
+        loy++;                                                      \
+    }                                                               \
+}
+
+DEFINE_SET_PGRAM(SetParallelogram, Any3Byte, 3)
+DEFINE_SET_PGRAM(SetParallelogram, Any4Byte, 4)
+DEFINE_SET_PGRAM(SetParallelogram, AnyByte,  1)
+DEFINE_SET_PGRAM(SetParallelogram, AnyInt,   1)
+DEFINE_SET_PGRAM(SetParallelogram, AnyShort, 1)
+
+/***************************************************************/
+
 #define SCALE_COPY(index, chan)         \
     pDst[chan] = pSrc[index]
 
diff --git a/jdk/src/solaris/native/sun/java2d/loops/vis_FuncArray.c b/jdk/src/solaris/native/sun/java2d/loops/vis_FuncArray.c
index ab520919efb3a0aa073e7ba3d6489e762fe06b3f..513e376deff0648eed067aef31927ef21acfa6be 100644
--- a/jdk/src/solaris/native/sun/java2d/loops/vis_FuncArray.c
+++ b/jdk/src/solaris/native/sun/java2d/loops/vis_FuncArray.c
@@ -51,6 +51,7 @@ DEF_FUNC(AnyByteIsomorphicXorCopy)
 DEF_FUNC(AnyByteSetLine)
 DEF_FUNC(AnyByteSetRect)
 DEF_FUNC(AnyByteSetSpans)
+DEF_FUNC(AnyByteSetParallelogram)
 DEF_FUNC(AnyByteXorLine)
 DEF_FUNC(AnyByteXorRect)
 DEF_FUNC(AnyByteXorSpans)
@@ -62,6 +63,7 @@ DEF_FUNC(AnyShortIsomorphicXorCopy)
 DEF_FUNC(AnyShortSetLine)
 DEF_FUNC(AnyShortSetRect)
 DEF_FUNC(AnyShortSetSpans)
+DEF_FUNC(AnyShortSetParallelogram)
 DEF_FUNC(AnyShortXorLine)
 DEF_FUNC(AnyShortXorRect)
 DEF_FUNC(AnyShortXorSpans)
@@ -73,6 +75,7 @@ DEF_FUNC(Any3ByteIsomorphicXorCopy)
 DEF_FUNC(Any3ByteSetLine)
 DEF_FUNC(Any3ByteSetRect)
 DEF_FUNC(Any3ByteSetSpans)
+DEF_FUNC(Any3ByteSetParallelogram)
 DEF_FUNC(Any3ByteXorLine)
 DEF_FUNC(Any3ByteXorRect)
 DEF_FUNC(Any3ByteXorSpans)
@@ -84,6 +87,7 @@ DEF_FUNC(Any4ByteIsomorphicXorCopy)
 DEF_FUNC(Any4ByteSetLine)
 DEF_FUNC(Any4ByteSetRect)
 DEF_FUNC(Any4ByteSetSpans)
+DEF_FUNC(Any4ByteSetParallelogram)
 DEF_FUNC(Any4ByteXorLine)
 DEF_FUNC(Any4ByteXorRect)
 DEF_FUNC(Any4ByteXorSpans)
@@ -95,6 +99,7 @@ DEF_FUNC(AnyIntIsomorphicXorCopy)
 DEF_FUNC(AnyIntSetLine)
 DEF_FUNC(AnyIntSetRect)
 DEF_FUNC(AnyIntSetSpans)
+DEF_FUNC(AnyIntSetParallelogram)
 DEF_FUNC(AnyIntXorLine)
 DEF_FUNC(AnyIntXorRect)
 DEF_FUNC(AnyIntXorSpans)
@@ -513,6 +518,7 @@ static AnyFunc_pair vis_func_pair_array[] = {
     ADD_FUNC(AnyByteSetLine),
     ADD_FUNC(AnyByteSetRect),
     ADD_FUNC(AnyByteSetSpans),
+    ADD_FUNC(AnyByteSetParallelogram),
     ADD_FUNC(AnyByteXorLine),
     ADD_FUNC(AnyByteXorRect),
     ADD_FUNC(AnyByteXorSpans),
@@ -524,6 +530,7 @@ static AnyFunc_pair vis_func_pair_array[] = {
     ADD_FUNC(AnyShortSetLine),
     ADD_FUNC(AnyShortSetRect),
     ADD_FUNC(AnyShortSetSpans),
+    ADD_FUNC(AnyShortSetParallelogram),
     ADD_FUNC(AnyShortXorLine),
     ADD_FUNC(AnyShortXorRect),
     ADD_FUNC(AnyShortXorSpans),
@@ -533,6 +540,7 @@ static AnyFunc_pair vis_func_pair_array[] = {
     ADD_FUNC(Any3ByteSetLine),
     ADD_FUNC(Any3ByteSetRect),
     ADD_FUNC(Any3ByteSetSpans),
+    ADD_FUNC(Any3ByteSetParallelogram),
     ADD_FUNC(Any3ByteXorLine),
     ADD_FUNC(Any3ByteXorRect),
     ADD_FUNC(Any3ByteXorSpans),
@@ -544,6 +552,7 @@ static AnyFunc_pair vis_func_pair_array[] = {
     ADD_FUNC(Any4ByteSetLine),
     ADD_FUNC(Any4ByteSetRect),
     ADD_FUNC(Any4ByteSetSpans),
+    ADD_FUNC(Any4ByteSetParallelogram),
     ADD_FUNC(Any4ByteXorLine),
     ADD_FUNC(Any4ByteXorRect),
     ADD_FUNC(Any4ByteXorSpans),
@@ -555,6 +564,7 @@ static AnyFunc_pair vis_func_pair_array[] = {
     ADD_FUNC(AnyIntSetLine),
     ADD_FUNC(AnyIntSetRect),
     ADD_FUNC(AnyIntSetSpans),
+    ADD_FUNC(AnyIntSetParallelogram),
     ADD_FUNC(AnyIntXorLine),
     ADD_FUNC(AnyIntXorRect),
     ADD_FUNC(AnyIntXorSpans),
diff --git a/jdk/src/solaris/native/sun/nio/ch/SctpNet.c b/jdk/src/solaris/native/sun/nio/ch/SctpNet.c
index f462ae3445ddf9629708e7eb1843dd35a3596603..ceb012aebb81df0622ccd89b17669be4400a5606 100644
--- a/jdk/src/solaris/native/sun/nio/ch/SctpNet.c
+++ b/jdk/src/solaris/native/sun/nio/ch/SctpNet.c
@@ -617,18 +617,18 @@ JNIEXPORT void JNICALL Java_sun_nio_ch_SctpNet_setPrimAddrOption0
  * Signature: (IILjava/net/InetAddress;I)V
  */
 JNIEXPORT void JNICALL Java_sun_nio_ch_SctpNet_setPeerPrimAddrOption0
-  (JNIEnv *env, jclass klass, jint fd, jint assocId, jobject iaObj, jint port) {
+  (JNIEnv *env, jclass klass, jint fd, jint assocId,
+   jobject iaObj, jint port, jboolean preferIPv6) {
     struct sctp_setpeerprim prim;
-    struct sockaddr_storage ss;
-    int ss_len = sizeof(ss);
+    struct sockaddr* sap = (struct sockaddr*)&prim.sspp_addr;
+    int sap_len;
 
-    if (NET_InetAddressToSockaddr(env, iaObj, port, (struct sockaddr *)&ss,
-                                  &ss_len, JNI_TRUE) != 0) {
+    if (NET_InetAddressToSockaddr(env, iaObj, port, sap,
+                                  &sap_len, preferIPv6) != 0) {
         return;
     }
 
     prim.sspp_assoc_id = assocId;
-    prim.sspp_addr = ss;
 
     if (setsockopt(fd, IPPROTO_SCTP, SCTP_SET_PEER_PRIMARY_ADDR, &prim,
             sizeof(prim)) < 0) {
diff --git a/jdk/src/windows/classes/java/lang/ProcessImpl.java b/jdk/src/windows/classes/java/lang/ProcessImpl.java
index c0a0daa09a8428bd9a2086cb0287a6eba454ee3c..b3357dd0c9d58dc5f2d0af2aba3fe8ae9e7c5178 100644
--- a/jdk/src/windows/classes/java/lang/ProcessImpl.java
+++ b/jdk/src/windows/classes/java/lang/ProcessImpl.java
@@ -35,6 +35,8 @@ import java.io.FileDescriptor;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.lang.ProcessBuilder.Redirect;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
 
 /* This class is for the exclusive use of ProcessBuilder.start() to
  * create new processes.
@@ -47,6 +49,35 @@ final class ProcessImpl extends Process {
     private static final sun.misc.JavaIOFileDescriptorAccess fdAccess
         = sun.misc.SharedSecrets.getJavaIOFileDescriptorAccess();
 
+    /**
+     * Open a file for writing. If {@code append} is {@code true} then the file
+     * is opened for atomic append directly and a FileOutputStream constructed
+     * with the resulting handle. This is because a FileOutputStream created
+     * to append to a file does not open the file in a manner that guarantees
+     * that writes by the child process will be atomic.
+     */
+    private static FileOutputStream newFileOutputStream(File f, boolean append)
+        throws IOException
+    {
+        if (append) {
+            SecurityManager sm = System.getSecurityManager();
+            if (sm != null)
+                sm.checkWrite(f.getPath());
+            long handle = openForAtomicAppend(f.getPath());
+            final FileDescriptor fd = new FileDescriptor();
+            fdAccess.setHandle(fd, handle);
+            return AccessController.doPrivileged(
+                new PrivilegedAction() {
+                    public FileOutputStream run() {
+                        return new FileOutputStream(fd);
+                    }
+                }
+            );
+        } else {
+            return new FileOutputStream(f);
+        }
+    }
+
     // System-dependent portion of ProcessBuilder.start()
     static Process start(String cmdarray[],
                          java.util.Map environment,
@@ -82,7 +113,8 @@ final class ProcessImpl extends Process {
                 else if (redirects[1] == Redirect.INHERIT)
                     stdHandles[1] = fdAccess.getHandle(FileDescriptor.out);
                 else {
-                    f1 = redirects[1].toFileOutputStream();
+                    f1 = newFileOutputStream(redirects[1].file(),
+                                             redirects[1].append());
                     stdHandles[1] = fdAccess.getHandle(f1.getFD());
                 }
 
@@ -91,7 +123,8 @@ final class ProcessImpl extends Process {
                 else if (redirects[2] == Redirect.INHERIT)
                     stdHandles[2] = fdAccess.getHandle(FileDescriptor.err);
                 else {
-                    f2 = redirects[2].toFileOutputStream();
+                    f2 = newFileOutputStream(redirects[2].file(),
+                                             redirects[2].append());
                     stdHandles[2] = fdAccess.getHandle(f2.getFD());
                 }
             }
@@ -251,5 +284,15 @@ final class ProcessImpl extends Process {
                                       boolean redirectErrorStream)
         throws IOException;
 
+    /**
+     * Opens a file for atomic append. The file is created if it doesn't
+     * already exist.
+     *
+     * @param file the file to open or create
+     * @return the native HANDLE
+     */
+    private static native long openForAtomicAppend(String path)
+        throws IOException;
+
     private static native boolean closeHandle(long handle);
 }
diff --git a/jdk/src/windows/classes/sun/awt/Win32GraphicsDevice.java b/jdk/src/windows/classes/sun/awt/Win32GraphicsDevice.java
index 5663a9ff7f3d89ca1dd06541aaf4c9b47e935465..14b93bd0e2b48c6123f3aba21d050754faa0050e 100644
--- a/jdk/src/windows/classes/sun/awt/Win32GraphicsDevice.java
+++ b/jdk/src/windows/classes/sun/awt/Win32GraphicsDevice.java
@@ -30,6 +30,7 @@ import java.awt.GraphicsDevice;
 import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsEnvironment;
 import java.awt.DisplayMode;
+import java.awt.EventQueue;
 import java.awt.Frame;
 import java.awt.Rectangle;
 import java.awt.Window;
@@ -610,11 +611,18 @@ public class Win32GraphicsDevice extends GraphicsDevice implements
      *
      * @param w full-screen window
      */
-    protected void addFSWindowListener(Window w) {
+    protected void addFSWindowListener(final Window w) {
         // Note: even though we create a listener for Window instances of
         // fs windows they will not receive window events.
         fsWindowListener = new Win32FSWindowAdapter(this);
-        w.addWindowListener(fsWindowListener);
+
+        // Fix for 6709453. Using invokeLater to avoid listening
+        // for the events already posted to the queue.
+        EventQueue.invokeLater(new Runnable() {
+            public void run() {
+                w.addWindowListener(fsWindowListener);
+            }
+        });
     }
 
     /**
diff --git a/jdk/src/windows/classes/sun/awt/windows/WFileDialogPeer.java b/jdk/src/windows/classes/sun/awt/windows/WFileDialogPeer.java
index 6c0cbc470f505f0d268118c12fe5118ba2d7deac..3f1adb2cc1cd8f40a385509635d4df5fd1f6fb36 100644
--- a/jdk/src/windows/classes/sun/awt/windows/WFileDialogPeer.java
+++ b/jdk/src/windows/classes/sun/awt/windows/WFileDialogPeer.java
@@ -35,6 +35,7 @@ import java.util.ResourceBundle;
 import java.util.MissingResourceException;
 import java.util.Vector;
 import sun.awt.AppContext;
+import sun.awt.CausedFocusEvent;
 import sun.awt.AWTAccessor;
 
 public class WFileDialogPeer extends WWindowPeer implements FileDialogPeer {
@@ -252,6 +253,14 @@ public class WFileDialogPeer extends WWindowPeer implements FileDialogPeer {
                                 boolean focusedWindowChangeAllowed) {
         return false;
     }
+
+    public boolean requestFocus
+         (Component lightweightChild, boolean temporary,
+          boolean focusedWindowChangeAllowed, long time, CausedFocusEvent.Cause cause)
+    {
+        return false;
+    }
+
     void start() {}
     public void beginValidate() {}
     public void endValidate() {}
diff --git a/jdk/src/windows/classes/sun/awt/windows/WPrintDialogPeer.java b/jdk/src/windows/classes/sun/awt/windows/WPrintDialogPeer.java
index 7d433679136f04912ca0115a81fa321aa9ed30c0..9fa8e2f9180fb12709e45f8f35cdef8657e7d04c 100644
--- a/jdk/src/windows/classes/sun/awt/windows/WPrintDialogPeer.java
+++ b/jdk/src/windows/classes/sun/awt/windows/WPrintDialogPeer.java
@@ -31,6 +31,7 @@ import java.awt.peer.ComponentPeer;
 import java.awt.dnd.DropTarget;
 import java.util.Vector;
 import sun.awt.AppContext;
+import sun.awt.CausedFocusEvent;
 import sun.awt.AWTAccessor;
 
 public class WPrintDialogPeer extends WWindowPeer implements DialogPeer {
@@ -131,6 +132,15 @@ public class WPrintDialogPeer extends WWindowPeer implements DialogPeer {
     public boolean requestFocus(boolean temporary, boolean focusedWindowChangeAllowed) {
         return false;
     }
+
+    public boolean requestFocus
+         (Component lightweightChild, boolean temporary,
+          boolean focusedWindowChangeAllowed, long time, CausedFocusEvent.Cause cause)
+    {
+
+        return false;
+    }
+
     public void updateFocusableWindowState() {}
     void start() {}
     public void beginValidate() {}
diff --git a/jdk/src/windows/classes/sun/awt/windows/awtLocalization_pt_BR.properties b/jdk/src/windows/classes/sun/awt/windows/awtLocalization_pt_BR.properties
new file mode 100644
index 0000000000000000000000000000000000000000..86e0905dce9196de54af21bb8cad75bcb5a5ae04
--- /dev/null
+++ b/jdk/src/windows/classes/sun/awt/windows/awtLocalization_pt_BR.properties
@@ -0,0 +1,10 @@
+
+#
+# AWT Localization Properties
+#
+
+# Default font size for Menus and MenuItems
+menuFont=SansSerif-plain-11
+
+# Value for "All files" for FileDialog
+allFiles=Todos os arquivos
diff --git a/jdk/src/windows/classes/sun/nio/ch/FileDispatcherImpl.java b/jdk/src/windows/classes/sun/nio/ch/FileDispatcherImpl.java
index 2cdc8f8fe9fcffc66ff034f13fcff1e41e9b5b0d..43f0745be4084fb6b04a4351b86e59ed02551fe1 100644
--- a/jdk/src/windows/classes/sun/nio/ch/FileDispatcherImpl.java
+++ b/jdk/src/windows/classes/sun/nio/ch/FileDispatcherImpl.java
@@ -35,6 +35,20 @@ class FileDispatcherImpl extends FileDispatcher
         Util.load();
     }
 
+    /**
+     * Indicates if the dispatcher should first advance the file position
+     * to the end of file when writing.
+     */
+    private final boolean append;
+
+    FileDispatcherImpl(boolean append) {
+        this.append = append;
+    }
+
+    FileDispatcherImpl() {
+        this(false);
+    }
+
     int read(FileDescriptor fd, long address, int len)
         throws IOException
     {
@@ -54,7 +68,7 @@ class FileDispatcherImpl extends FileDispatcher
     }
 
     int write(FileDescriptor fd, long address, int len) throws IOException {
-        return write0(fd, address, len);
+        return write0(fd, address, len, append);
     }
 
     int pwrite(FileDescriptor fd, long address, int len,
@@ -66,7 +80,7 @@ class FileDispatcherImpl extends FileDispatcher
     }
 
     long writev(FileDescriptor fd, long address, int len) throws IOException {
-        return writev0(fd, address, len);
+        return writev0(fd, address, len, append);
     }
 
     int force(FileDescriptor fd, boolean metaData) throws IOException {
@@ -116,13 +130,13 @@ class FileDispatcherImpl extends FileDispatcher
     static native long readv0(FileDescriptor fd, long address, int len)
         throws IOException;
 
-    static native int write0(FileDescriptor fd, long address, int len)
+    static native int write0(FileDescriptor fd, long address, int len, boolean append)
         throws IOException;
 
     static native int pwrite0(FileDescriptor fd, long address, int len,
                              long position) throws IOException;
 
-    static native long writev0(FileDescriptor fd, long address, int len)
+    static native long writev0(FileDescriptor fd, long address, int len, boolean append)
         throws IOException;
 
     static native int force0(FileDescriptor fd, boolean metaData)
diff --git a/jdk/src/windows/classes/sun/nio/fs/WindowsChannelFactory.java b/jdk/src/windows/classes/sun/nio/fs/WindowsChannelFactory.java
index 3795a6f40d2e9552e10f6624e2886a7b0f1d7ba8..736ea7b1ea0562336af9af8fd90e2420f026ec3d 100644
--- a/jdk/src/windows/classes/sun/nio/fs/WindowsChannelFactory.java
+++ b/jdk/src/windows/classes/sun/nio/fs/WindowsChannelFactory.java
@@ -157,7 +157,7 @@ class WindowsChannelFactory {
             throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
 
         FileDescriptor fdObj = open(pathForWindows, pathToCheck, flags, pSecurityDescriptor);
-        return FileChannelImpl.open(fdObj, flags.read, flags.write, null);
+        return FileChannelImpl.open(fdObj, flags.read, flags.write, flags.append, null);
     }
 
     /**
@@ -230,7 +230,7 @@ class WindowsChannelFactory {
         if (flags.read)
             dwDesiredAccess |= GENERIC_READ;
         if (flags.write)
-            dwDesiredAccess |= (flags.append) ? FILE_APPEND_DATA : GENERIC_WRITE;
+            dwDesiredAccess |= GENERIC_WRITE;
 
         int dwShareMode = 0;
         if (flags.shareRead)
diff --git a/jdk/src/windows/classes/sun/security/provider/NativeSeedGenerator.java b/jdk/src/windows/classes/sun/security/provider/NativeSeedGenerator.java
index 194b970a1e1147a00bad5625b47748777b51f8e1..dc14b5f6b9fcfc9399469ed442f5552a5883b8c8 100644
--- a/jdk/src/windows/classes/sun/security/provider/NativeSeedGenerator.java
+++ b/jdk/src/windows/classes/sun/security/provider/NativeSeedGenerator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2010, 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
@@ -53,6 +53,7 @@ class NativeSeedGenerator extends SeedGenerator {
      */
     private static native boolean nativeGenerateSeed(byte[] result);
 
+    @Override
     void getSeedBytes(byte[] result) {
         // fill array as a side effect
         if (nativeGenerateSeed(result) == false) {
@@ -62,9 +63,4 @@ class NativeSeedGenerator extends SeedGenerator {
         }
     }
 
-    byte getSeedByte() {
-        byte[] b = new byte[1];
-        getSeedBytes(b);
-        return b[0];
-    }
 }
diff --git a/jdk/src/windows/native/java/io/FileOutputStream_md.c b/jdk/src/windows/native/java/io/FileOutputStream_md.c
index 221ba504f5f22f3c7377e57c94b6bf48ee676833..23c754d466739bfa796cc3bf9003191707cb2a60 100644
--- a/jdk/src/windows/native/java/io/FileOutputStream_md.c
+++ b/jdk/src/windows/native/java/io/FileOutputStream_md.c
@@ -61,14 +61,15 @@ Java_java_io_FileOutputStream_open(JNIEnv *env, jobject this,
 }
 
 JNIEXPORT void JNICALL
-Java_java_io_FileOutputStream_write(JNIEnv *env, jobject this, jint byte) {
-    writeSingle(env, this, byte, fos_fd);
+Java_java_io_FileOutputStream_write(JNIEnv *env, jobject this, jint byte, jboolean append) {
+    writeSingle(env, this, byte, append, fos_fd);
 }
 
 JNIEXPORT void JNICALL
 Java_java_io_FileOutputStream_writeBytes(JNIEnv *env,
-    jobject this, jbyteArray bytes, jint off, jint len) {
-    writeBytes(env, this, bytes, off, len, fos_fd);
+    jobject this, jbyteArray bytes, jint off, jint len, jboolean append)
+{
+    writeBytes(env, this, bytes, off, len, append, fos_fd);
 }
 
 JNIEXPORT void JNICALL
diff --git a/jdk/src/windows/native/java/io/io_util_md.c b/jdk/src/windows/native/java/io/io_util_md.c
index 722913f775a3a2491bdc8382ac1165cc831d05ee..2679e7b951700986fc28fd75ceba546f71872f2a 100644
--- a/jdk/src/windows/native/java/io/io_util_md.c
+++ b/jdk/src/windows/native/java/io/io_util_md.c
@@ -225,14 +225,7 @@ pathToNTPath(JNIEnv *env, jstring path, jboolean throwFNFE) {
 jlong
 winFileHandleOpen(JNIEnv *env, jstring path, int flags)
 {
-    /* To implement O_APPEND, we use the strategy from
-       http://msdn2.microsoft.com/en-us/library/aa363858.aspx
-       "You can get atomic append by opening a file with
-       FILE_APPEND_DATA access and _without_ FILE_WRITE_DATA access.
-       If you do this then all writes will ignore the current file
-       pointer and be done at the end-of file." */
     const DWORD access =
-        (flags & O_APPEND) ? (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA) :
         (flags & O_WRONLY) ?  GENERIC_WRITE :
         (flags & O_RDWR)   ? (GENERIC_READ | GENERIC_WRITE) :
         GENERIC_READ;
@@ -307,7 +300,6 @@ handleStdinAvailable(jlong, long *);
 
 int
 handleAvailable(jlong fd, jlong *pbytes) {
-    jlong current, end;
     HANDLE h = (HANDLE)fd;
     DWORD type = 0;
 
@@ -327,18 +319,17 @@ handleAvailable(jlong fd, jlong *pbytes) {
     }
     /* Handle is for regular file */
     if (type == FILE_TYPE_DISK) {
-        long highPos = 0;
-        DWORD sizeLow = 0;
-        DWORD sizeHigh = 0;
-        DWORD lowPos = SetFilePointer(h, 0, &highPos, FILE_CURRENT);
-        if (lowPos == ((DWORD)-1)) {
+        jlong current, end;
+
+        LARGE_INTEGER filesize;
+        current = handleLseek(fd, 0, SEEK_CUR);
+        if (current < 0) {
             return FALSE;
         }
-        current = (((jlong)highPos) << 32) | lowPos;
-        end = GetFileSize(h, &sizeHigh);
-        if (sizeLow == ((DWORD)-1)) {
+        if (GetFileSizeEx(h, &filesize) == 0) {
             return FALSE;
         }
+        end = long_to_jlong(filesize.QuadPart);
         *pbytes = end - current;
         return TRUE;
     }
@@ -511,24 +502,42 @@ handleRead(jlong fd, void *buf, jint len)
     return read;
 }
 
-JNIEXPORT
-size_t
-handleWrite(jlong fd, const void *buf, jint len)
+static size_t writeInternal(jlong fd, const void *buf, jint len, jboolean append)
 {
     BOOL result = 0;
     DWORD written = 0;
     HANDLE h = (HANDLE)fd;
     if (h != INVALID_HANDLE_VALUE) {
-        result = WriteFile(h,           /* File handle to write */
-                      buf,              /* pointers to the buffers */
-                      len,              /* number of bytes to write */
-                      &written,         /* receives number of bytes written */
-                      NULL);            /* no overlapped struct */
+        OVERLAPPED ov;
+        LPOVERLAPPED lpOv;
+        if (append == JNI_TRUE) {
+            ov.Offset = (DWORD)0xFFFFFFFF;
+            ov.OffsetHigh = (DWORD)0xFFFFFFFF;
+            ov.hEvent = NULL;
+            lpOv = &ov;
+        } else {
+            lpOv = NULL;
+        }
+        result = WriteFile(h,                /* File handle to write */
+                           buf,              /* pointers to the buffers */
+                           len,              /* number of bytes to write */
+                           &written,         /* receives number of bytes written */
+                           lpOv);            /* overlapped struct */
     }
     if ((h == INVALID_HANDLE_VALUE) || (result == 0)) {
         return -1;
     }
-    return written;
+    return (size_t)written;
+}
+
+JNIEXPORT
+size_t handleWrite(jlong fd, const void *buf, jint len) {
+    return writeInternal(fd, buf, len, JNI_FALSE);
+}
+
+JNIEXPORT
+size_t handleAppend(jlong fd, const void *buf, jint len) {
+    return writeInternal(fd, buf, len, JNI_TRUE);
 }
 
 jint
@@ -558,6 +567,7 @@ handleClose(JNIEnv *env, jobject this, jfieldID fid)
 jlong
 handleLseek(jlong fd, jlong offset, jint whence)
 {
+    LARGE_INTEGER pos, distance;
     DWORD lowPos = 0;
     long highPos = 0;
     DWORD op = FILE_CURRENT;
@@ -573,13 +583,9 @@ handleLseek(jlong fd, jlong offset, jint whence)
         op = FILE_BEGIN;
     }
 
-    lowPos = (DWORD)offset;
-    highPos = (long)(offset >> 32);
-    lowPos = SetFilePointer(h, lowPos, &highPos, op);
-    if (lowPos == ((DWORD)-1)) {
-        if (GetLastError() != ERROR_SUCCESS) {
-            return -1;
-        }
+    distance.QuadPart = offset;
+    if (SetFilePointerEx(h, distance, &pos, op) == 0) {
+        return -1;
     }
-    return (((jlong)highPos) << 32) | lowPos;
+    return long_to_jlong(pos.QuadPart);
 }
diff --git a/jdk/src/windows/native/java/io/io_util_md.h b/jdk/src/windows/native/java/io/io_util_md.h
index 6b6b89b6397a998eb28b335dcc553df5c79ffae0..97a68c2febae0cdba5f5335b9a56ab4e42ad66c4 100644
--- a/jdk/src/windows/native/java/io/io_util_md.h
+++ b/jdk/src/windows/native/java/io/io_util_md.h
@@ -41,6 +41,7 @@ JNIEXPORT int handleSync(jlong fd);
 int handleSetLength(jlong fd, jlong length);
 JNIEXPORT size_t handleRead(jlong fd, void *buf, jint len);
 JNIEXPORT size_t handleWrite(jlong fd, const void *buf, jint len);
+JNIEXPORT size_t handleAppend(jlong fd, const void *buf, jint len);
 jint handleClose(JNIEnv *env, jobject this, jfieldID fid);
 jlong handleLseek(jlong fd, jlong offset, jint whence);
 
@@ -74,8 +75,9 @@ jlong winFileHandleOpen(JNIEnv *env, jstring path, int flags);
 #define THIS_FD(obj) (*env)->GetLongField(env, obj, IO_handle_fdID)
 
 /*
- * Route the routines away from HPI layer
+ * Route the routines away from VM
  */
+#define IO_Append handleAppend
 #define IO_Write handleWrite
 #define IO_Sync handleSync
 #define IO_Read handleRead
diff --git a/jdk/src/windows/native/java/lang/ProcessImpl_md.c b/jdk/src/windows/native/java/lang/ProcessImpl_md.c
index e5fe23e71ec842515a3851557cbc77a11bbdadcb..afc5e7d2529acda414732ac0c78f4fac37e7aa20 100644
--- a/jdk/src/windows/native/java/lang/ProcessImpl_md.c
+++ b/jdk/src/windows/native/java/lang/ProcessImpl_md.c
@@ -315,3 +315,51 @@ Java_java_lang_ProcessImpl_closeHandle(JNIEnv *env, jclass ignored, jlong handle
 {
     return CloseHandle((HANDLE) handle);
 }
+
+/**
+ * Returns a copy of the Unicode characters of a string. Fow now this
+ * function doesn't handle long path names and other issues.
+ */
+static WCHAR* getPath(JNIEnv *env, jstring ps) {
+    WCHAR *pathbuf = NULL;
+    const jchar *chars = (*(env))->GetStringChars(env, ps, NULL);
+    if (chars != NULL) {
+        size_t pathlen = wcslen(chars);
+        pathbuf = (WCHAR*)malloc((pathlen + 6) * sizeof(WCHAR));
+        if (pathbuf == NULL) {
+            JNU_ThrowOutOfMemoryError(env, NULL);
+        } else {
+            wcscpy(pathbuf, chars);
+        }
+        (*env)->ReleaseStringChars(env, ps, chars);
+    }
+    return pathbuf;
+}
+
+JNIEXPORT jlong JNICALL
+Java_java_lang_ProcessImpl_openForAtomicAppend(JNIEnv *env, jclass ignored, jstring path)
+{
+    const DWORD access = (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA);
+    const DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
+    const DWORD disposition = OPEN_ALWAYS;
+    const DWORD flagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
+    HANDLE h;
+    WCHAR *pathbuf = getPath(env, path);
+    if (pathbuf == NULL) {
+        /* Exception already pending */
+        return -1;
+    }
+    h = CreateFileW(
+        pathbuf,            /* Wide char path name */
+        access,             /* Read and/or write permission */
+        sharing,            /* File sharing flags */
+        NULL,               /* Security attributes */
+        disposition,        /* creation disposition */
+        flagsAndAttributes, /* flags and attributes */
+        NULL);
+    free(pathbuf);
+    if (h == INVALID_HANDLE_VALUE) {
+        JNU_ThrowIOExceptionWithLastError(env, "CreateFileW");
+    }
+    return ptr_to_jlong(h);
+}
diff --git a/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp b/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp
index 38cec3f499f2f23435b4db75ab1a4dcb407942f2..41b3dfe772e40c2108cbb4128ddffeb517ee2a78 100644
--- a/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp
+++ b/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp
@@ -349,7 +349,8 @@ D3DPipelineManager::CheckOSVersion()
 {
     // require Windows XP or newer client-class OS
     if (IS_WINVER_ATLEAST(5, 1) &&
-        !D3DPPLM_OsVersionMatches(OS_WINSERV_2008|OS_WINSERV_2003))
+        !D3DPPLM_OsVersionMatches(OS_WINSERV_2008R2|OS_WINSERV_2008|
+                                  OS_WINSERV_2003))
     {
         J2dTraceLn(J2D_TRACE_INFO,
                    "D3DPPLM::CheckOSVersion: Windows XP or newer client-classs"\
@@ -442,14 +443,22 @@ BOOL D3DPPLM_OsVersionMatches(USHORT osInfo) {
         if (bVersOk && osvi.dwPlatformId == VER_PLATFORM_WIN32_NT &&
             osvi.dwMajorVersion > 4)
         {
-            if (osvi.dwMajorVersion >= 6 && osvi.dwMinorVersion >= 0) {
+            if (osvi.dwMajorVersion >= 6 && osvi.dwMinorVersion == 0) {
                 if (osvi.wProductType == VER_NT_WORKSTATION) {
-                    J2dRlsTrace(J2D_TRACE_INFO, "OS_VISTA or newer\n");
+                    J2dRlsTrace(J2D_TRACE_INFO, "OS_VISTA\n");
                     currentOS = OS_VISTA;
                 } else {
-                    J2dRlsTrace(J2D_TRACE_INFO, "OS_WINSERV_2008 or newer\n");
+                    J2dRlsTrace(J2D_TRACE_INFO, "OS_WINSERV_2008\n");
                     currentOS = OS_WINSERV_2008;
                 }
+            } else if (osvi.dwMajorVersion >= 6 && osvi.dwMinorVersion >= 1) {
+                if (osvi.wProductType == VER_NT_WORKSTATION) {
+                    J2dRlsTrace(J2D_TRACE_INFO, "OS_WINDOWS7 or newer\n");
+                    currentOS = OS_WINDOWS7;
+                } else {
+                    J2dRlsTrace(J2D_TRACE_INFO, "OS_WINSERV_2008R2 or newer\n");
+                    currentOS = OS_WINSERV_2008R2;
+                }
             } else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2) {
                 if (osvi.wProductType == VER_NT_WORKSTATION) {
                     J2dRlsTrace(J2D_TRACE_INFO, "OS_WINXP_64\n");
diff --git a/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.h b/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.h
index c67af102b1bd1403d6c077907d75958446776e5c..b903680869a05044189a34a25e0f1a92e4460eb0 100644
--- a/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.h
+++ b/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.h
@@ -145,7 +145,10 @@ private:
 #define OS_WINXP        (1 << 2)
 #define OS_WINXP_64     (1 << 3)
 #define OS_WINSERV_2003 (1 << 4)
-#define OS_ALL (OS_VISTA|OS_WINSERV_2008|OS_WINXP|OS_WINXP_64|OS_WINSERV_2003)
+#define OS_WINDOWS7     (1 << 5)
+#define OS_WINSERV_2008R2 (1 << 6)
+#define OS_ALL (OS_VISTA|OS_WINSERV_2008|OS_WINXP|OS_WINXP_64|OS_WINSERV_2003|\
+                OS_WINDOWS7|OS_WINSERV_2008R2)
 #define OS_UNKNOWN      (~OS_ALL)
 BOOL D3DPPLM_OsVersionMatches(USHORT osInfo);
 
diff --git a/jdk/src/windows/native/sun/java2d/windows/GDIWindowSurfaceData.cpp b/jdk/src/windows/native/sun/java2d/windows/GDIWindowSurfaceData.cpp
index 21b944d2084c167b110d609094cd6c94764f3431..5ddf0d76f267b68b84789abfe645b12f759a58bb 100644
--- a/jdk/src/windows/native/sun/java2d/windows/GDIWindowSurfaceData.cpp
+++ b/jdk/src/windows/native/sun/java2d/windows/GDIWindowSurfaceData.cpp
@@ -54,6 +54,7 @@ static HPEN     nullpen;
 static jclass xorCompClass;
 
 static jboolean beingShutdown = JNI_FALSE;
+static volatile LONG timeStamp = 0;
 extern CriticalSection windowMoveLock;
 
 extern "C"
@@ -90,12 +91,24 @@ void SetupThreadGraphicsInfo(JNIEnv *env, GDIWinSDOps *wsdo) {
     HDC oldhDC = info->hDC;
     // the hDC is NULL for offscreen surfaces - we don't store it
     // in TLS as it must be created new every time.
-    if (((oldhDC == NULL) && wsdo->window != NULL) || (info->wsdo != wsdo)) {
+
+    if( ((oldhDC == NULL) && wsdo->window != NULL) ||
+         (info->wsdo != wsdo) ||
+         (info->wsdoTimeStamp != wsdo->timeStamp) )
+    {
 
         // Init graphics state, either because this is our first time
         // using it in this thread or because this thread is now
         // dealing with a different window than it was last time.
 
+        //check extra condition:
+        //(info->wsdoTimeStamp != wsdo->timeStamp).
+        //Checking memory addresses (info->wsdo != wsdo) will not detect
+        //that wsdo points to a newly allocated structure in case
+        //that structure just got allocated at a "recycled" memory location
+        //which previously was pointed by info->wsdo
+        //see bug# 6859086
+
         // Release cached DC. We use deferred DC releasing mechanism because
         // the DC is associated with cached wsdo and component peer,
         // which may've been disposed by this time, and we have
@@ -157,7 +170,9 @@ void SetupThreadGraphicsInfo(JNIEnv *env, GDIWinSDOps *wsdo) {
         info->xorcolor = 0;
         info->patrop = PATCOPY;
 
+        //store the address and time stamp of newly allocated GDIWinSDOps structure
         info->wsdo = wsdo;
+        info->wsdoTimeStamp = wsdo->timeStamp;
     }
 }
 
@@ -367,6 +382,7 @@ Java_sun_java2d_windows_GDIWindowSurfaceData_initOps(JNIEnv *env, jobject wsd,
         JNU_ThrowOutOfMemoryError(env, "Initialization of SurfaceData failed.");
         return;
     }
+    wsdo->timeStamp = InterlockedIncrement(&timeStamp); //creation time stamp
     wsdo->sdOps.Lock = GDIWinSD_Lock;
     wsdo->sdOps.GetRasInfo = GDIWinSD_GetRasInfo;
     wsdo->sdOps.Unlock = GDIWinSD_Unlock;
diff --git a/jdk/src/windows/native/sun/java2d/windows/GDIWindowSurfaceData.h b/jdk/src/windows/native/sun/java2d/windows/GDIWindowSurfaceData.h
index a70b9bf21e99a0c96fb9001fef699f208e4864d7..8c0bcc3cd864e1e129c00dd2a1590846cfc8ff8a 100644
--- a/jdk/src/windows/native/sun/java2d/windows/GDIWindowSurfaceData.h
+++ b/jdk/src/windows/native/sun/java2d/windows/GDIWindowSurfaceData.h
@@ -148,6 +148,11 @@ typedef void InvalidateSDFunc(JNIEnv *env,
  */
 struct _GDIWinSDOps {
     SurfaceDataOps      sdOps;
+    LONG                timeStamp; // creation time stamp.
+                                   // Doesn't store a real time -
+                                   // just counts creation events of this structure
+                                   // made by GDIWindowSurfaceData_initOps()
+                                   // see bug# 6859086
     jboolean            invalid;
     GetDCFunc           *GetDC;
     ReleaseDCFunc       *ReleaseDC;
@@ -192,6 +197,13 @@ extern "C" {
 typedef struct {
     HDC         hDC;
     GDIWinSDOps *wsdo;
+    LONG        wsdoTimeStamp; // wsdo creation time stamp.
+                               // Other threads may deallocate wsdo
+                               // and then allocate a new GDIWinSDOps
+                               // structure at the same memory location.
+                               // Time stamp is the only way to detect if
+                               // wsdo got changed.
+                               // see bug# 6859086
     RECT        bounds;
     jobject     clip;
     jobject     comp;
diff --git a/jdk/src/windows/native/sun/jkernel/kernel.rc b/jdk/src/windows/native/sun/jkernel/kernel.rc
index 39a8f087304cab5c7ba5ccb86b97da61b5d3457a..6d69ebfdc2d17150f59f0a8ba78eebab98e32f70 100644
--- a/jdk/src/windows/native/sun/jkernel/kernel.rc
+++ b/jdk/src/windows/native/sun/jkernel/kernel.rc
@@ -149,6 +149,18 @@ LANGUAGE LANG_SWEDISH, SUBLANG_NEUTRAL
 #endif	  // Swedish resources
 /////////////////////////////////////////////////////////////////////////////
 
+/////////////////////////////////////////////////////////////////////////////
+// Brazilian Portuguese resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_PTB)
+#ifdef _WIN32
+LANGUAGE LANG_PORTUGUESE, SUBLANG_PORTUGUESE_BRAZILIAN
+#pragma code_page(1252)
+#endif //_WIN32
+#include "kernel_pt_BR.rc"
+#endif    // Brazilian Portuguese resources
+/////////////////////////////////////////////////////////////////////////////
+
 /////////////////////////////////////////////////////////////////////////////
 // English (U.S.) resources
 
diff --git a/jdk/src/windows/native/sun/jkernel/kernel_pt_BR.rc b/jdk/src/windows/native/sun/jkernel/kernel_pt_BR.rc
new file mode 100644
index 0000000000000000000000000000000000000000..e3e4a030a863a45897aeb09fd2a2fdb4f5e4698b
--- /dev/null
+++ b/jdk/src/windows/native/sun/jkernel/kernel_pt_BR.rc
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2008, 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
+ * 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.
+ */
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DOWNLOAD_DIALOG DIALOGEX 0,0,340,120
+STYLE DS_MODALFRAME | DS_3DLOOK | DS_CENTER | WS_POPUP | 
+    WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Componentes adicionais necessários"
+EXSTYLE WS_EX_APPWINDOW
+FONT 8, "MS Sans Serif"
+BEGIN
+    LTEXT           "", IDC_DOWNLOAD_MASTHEAD,0,0,340,39
+    LTEXT           "", IDC_MASTHEAD_TEXT,60,8,225,12
+    CONTROL         "", IDC_STATIC,"Static", SS_BLACKFRAME | SS_SUNKEN,0,39,340,1
+    LTEXT           "", IDC_DOWNLOAD_TEXT,12,60,316,20
+    LTEXT           "", IDC_TIME_REMAINING,12,90,316,10
+    CONTROL         "Progress1",1006,"msctls_progress32",PBS_SMOOTH,12,100,265,14
+    PUSHBUTTON	    "Cancelar",  2,285,100,46,14
+END
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO DISCARDABLE 
+BEGIN
+    105, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 236
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 63
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_DOWNLOAD_CANCEL_MESSAGE   "O cancelamento da instalação dos componentes adicionais necessários ao aplicativo pode fazer com que o aplicativo se feche.\n\nTem certeza que deseja cancelar a instalação dos componentes adicionais?"
+    IDS_DOWNLOAD_CANCEL_CAPTION   "Cancelar - Componentes adicionais"
+    IDS_DOWNLOAD_CANCEL_INSTRUCTION   ""
+    IDS_HTTP_INSTRUCTION_REQUEST_TIMEOUT      "Tempo limite de conexão excedido"
+    IDS_HTTP_INSTRUCTION_SERVER_NOT_REACHABLE "Não é possível se conectar à Internet"
+    IDS_HTTP_INSTRUCTION_UNKNOWN_ERROR        "Erro de servidor (Erro %s)"
+    IDS_HTTP_INSTRUCTION_SERVICE_UNAVAIL      "Serviço não disponível (Erro %s)"
+    IDS_HTTP_INSTRUCTION_FORBIDDEN            "Acesso negado ou proibido (Erro %s)"
+    IDS_HTTP_STATUS_OTHER                     "Ocorreu um erro durante esta solicitação. Deseja tentar a solicitação novamente?"
+
+// HTTP status code
+    IDS_HTTP_STATUS_REQUEST_TIMEOUT "O servidor usado para baixar os componentes necessários não está respondendo e o tempo limite da conexão foi excedido. Deseja tentar se conectar novamente?"
+    IDS_HTTP_STATUS_FORBIDDEN		"Você não tem permissão para acessar o servidor para baixar os componentes necessários ao aplicativo. Tentar acessar o servidor novamente?"
+    IDS_HTTP_STATUS_SERVER_ERROR	"Ocorreu um erro no servidor e não foi possível concluir a solicitação. Deseja tentar a solicitação novamente?"
+    IDS_HTTP_STATUS_SERVICE_UNAVAIL	"O serviço solicitado não está disponível temporariamente. Deseja tentar a solicitação novamente?"
+
+
+    IDS_DOWNLOAD_STATUS_RETRY		"O servidor está ocupado atualmente, tente novamente em %ld segundos ..."
+  
+    IDS_ERROR_CAPTION               "Instalador Java"
+    IDS_HOURSMINUTESECOND	    "Tempo restante estimado: %d horas %d minutos %.0f segundos"
+    IDS_HOURMINUTESECOND	    "Tempo restante estimado: %d hora %d minutos %.0f segundos"
+    IDS_MINUTESECOND 		    "Tempo restante estimado: %d minutos %.0f segundos"
+    IDS_SECOND                      "Tempo restante estimado: %.0f segundos"
+    IDS_DISK_FULL_ERROR_CAPTION     "Disco cheio %s"
+    IDS_DISK_FULL_ERROR             "Não há espaço em disco suficiente para baixar os componentes solicitados. Libere espaço em disco e, a seguir, tente novamente."
+    IDS_DISK_WRITE_ERROR_CAPTION    "Não é possível gravar no disco %s"
+    IDS_DISK_WRITE_ERROR            "Ocorreu um erro durante a gravação no disco. Verifique se o disco não está protegido contra gravação."
+    IDS_HTTP_STATUS_SERVER_NOT_REACHABLE "O Java não pode se conectar à Internet. Verifique se as configurações de conexão à Internet estão corretas (isso pode ser encontrado no painel de controle do Windows em Opções de Internet > Conexão) e se o firewall permite que java.exe acesse a Internet."
+
+    IDS_DOWNLOAD_RETRY             "Erro de download"
+    IDS_DOWNLOAD_RETRY_TEXT        "Ocorreu um erro durante o download de alguns componentes solicitados. Deseja tentar o download destes componentes novamente?"
+
+    IDS_DOWNLOAD                   "Instalando componentes adicionais"
+    IDS_DOWNLOAD_UNPACKING         "Descompactando pacotes"
+    IDS_DOWNLOAD_TEXT              "O aplicativo Java se iniciará quando os componentes adicionais que ele precisa tiverem sido baixados e instalados."
+    
+    IDS_FILE_UPDATE_ERROR          "Ocorreu um erro durante a atualização de %s%s."
+    IDS_FILE_DELETE_ERROR          "Ocorreu um erro durante a remoção de %s%s."
+    IDS_JAVA_HOME_ERROR            "Não é possível determinar o diretório base Java."
+    IDS_KERNEL_HOME_ERROR          "Não é possível determinar o caminho para o jkernel.dll."
+    IDS_JBROKER_ERROR              "Não é possível iniciar jbroker.exe"
+    IDS_FATAL_ERROR                "O Java não pôde baixar os componentes necessários. O programa se fechará agora."
+    IDS_ERROR_DOWNLOADING_BUNDLE_PROPERTIES "O Java não pôde estabelecer comunicação com o servidor de downloads. O programa se fechará agora."
+    IDS_ERROR_MALFORMED_BUNDLE_PROPERTIES "O Java encontrou um erro ao estabelecer comunicação com o servidor de downloads. O programa se fechará agora."
+    IDS_ERROR_MALFORMED_URL "O Java não pôde baixar da URL '%s'. O programa se fechará agora."
+END
diff --git a/jdk/src/windows/native/sun/nio/ch/FileDispatcherImpl.c b/jdk/src/windows/native/sun/nio/ch/FileDispatcherImpl.c
index f4d0b17d63b94a599c4c07f2b6fe36fac26e1ae5..2a146c284facabd6c441aa8cd379554188918db9 100644
--- a/jdk/src/windows/native/sun/nio/ch/FileDispatcherImpl.c
+++ b/jdk/src/windows/native/sun/nio/ch/FileDispatcherImpl.c
@@ -184,18 +184,28 @@ Java_sun_nio_ch_FileDispatcherImpl_pread0(JNIEnv *env, jclass clazz, jobject fdo
 
 JNIEXPORT jint JNICALL
 Java_sun_nio_ch_FileDispatcherImpl_write0(JNIEnv *env, jclass clazz, jobject fdo,
-                                       jlong address, jint len)
+                                          jlong address, jint len, jboolean append)
 {
     BOOL result = 0;
     DWORD written = 0;
     HANDLE h = (HANDLE)(handleval(env, fdo));
 
     if (h != INVALID_HANDLE_VALUE) {
+        OVERLAPPED ov;
+        LPOVERLAPPED lpOv;
+        if (append == JNI_TRUE) {
+            ov.Offset = (DWORD)0xFFFFFFFF;
+            ov.OffsetHigh = (DWORD)0xFFFFFFFF;
+            ov.hEvent = NULL;
+            lpOv = &ov;
+        } else {
+            lpOv = NULL;
+        }
         result = WriteFile(h,           /* File handle to write */
                       (LPCVOID)address, /* pointers to the buffers */
                       len,              /* number of bytes to write */
                       &written,         /* receives number of bytes written */
-                      NULL);            /* no overlapped struct */
+                      lpOv);            /* overlapped struct */
     }
 
     if ((h == INVALID_HANDLE_VALUE) || (result == 0)) {
@@ -207,7 +217,7 @@ Java_sun_nio_ch_FileDispatcherImpl_write0(JNIEnv *env, jclass clazz, jobject fdo
 
 JNIEXPORT jlong JNICALL
 Java_sun_nio_ch_FileDispatcherImpl_writev0(JNIEnv *env, jclass clazz, jobject fdo,
-                                       jlong address, jint len)
+                                           jlong address, jint len, jboolean append)
 {
     BOOL result = 0;
     DWORD written = 0;
@@ -219,7 +229,16 @@ Java_sun_nio_ch_FileDispatcherImpl_writev0(JNIEnv *env, jclass clazz, jobject fd
         int i = 0;
         DWORD num = 0;
         struct iovec *iovecp = (struct iovec *)jlong_to_ptr(address);
-
+        OVERLAPPED ov;
+        LPOVERLAPPED lpOv;
+        if (append == JNI_TRUE) {
+            ov.Offset = (DWORD)0xFFFFFFFF;
+            ov.OffsetHigh = (DWORD)0xFFFFFFFF;
+            ov.hEvent = NULL;
+            lpOv = &ov;
+        } else {
+            lpOv = NULL;
+        }
         for(i=0; i 0) {
                 totalWritten += written;
             }
@@ -444,9 +463,10 @@ Java_sun_nio_ch_FileDispatcherImpl_closeByHandle(JNIEnv *env, jclass clazz,
 }
 
 JNIEXPORT jlong JNICALL
-Java_sun_nio_ch_FileDispatcherImpl_duplicateHandle(JNIEnv *env, jclass this, jlong hFile)
+Java_sun_nio_ch_FileDispatcherImpl_duplicateHandle(JNIEnv *env, jclass this, jlong handle)
 {
     HANDLE hProcess = GetCurrentProcess();
+    HANDLE hFile = jlong_to_ptr(handle);
     HANDLE hResult;
     BOOL res = DuplicateHandle(hProcess, hFile, hProcess, &hResult, 0, FALSE,
                                DUPLICATE_SAME_ACCESS);
diff --git a/jdk/test/com/sun/jndi/ldap/InvalidLdapFilters.java b/jdk/test/com/sun/jndi/ldap/InvalidLdapFilters.java
index 5cadd3ad5b29c46b163fc00572640eab9d5fb4de..e0e0e906a653593a583f9ded3bbe1e3cc6429eb6 100644
--- a/jdk/test/com/sun/jndi/ldap/InvalidLdapFilters.java
+++ b/jdk/test/com/sun/jndi/ldap/InvalidLdapFilters.java
@@ -48,6 +48,8 @@
  * @run main/othervm InvalidLdapFilters valid (sn;lang-en:dn:2.4.6.8.10:=Barney)
  * @run main/othervm InvalidLdapFilters valid
          (&(objectClass=Person)(|(sn=Jensen)(cn=Bab*)))
+ * @run main/othervm InvalidLdapFilters valid
+         (orcluserapplnprovstatus;EMAIL_email=PROVISIONING_FAILURE)
  * @run main/othervm InvalidLdapFilters invalid "(&(cn=Robert Dean)))"
  * @run main/othervm InvalidLdapFilters invalid (&|(cn=Bob))
  * @run main/othervm InvalidLdapFilters invalid (&&(cn=Bob))
diff --git a/jdk/test/com/sun/net/httpserver/Test10.java b/jdk/test/com/sun/net/httpserver/Test10.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a1c9efa775596024e873b44bfafbf471b266acf
--- /dev/null
+++ b/jdk/test/com/sun/net/httpserver/Test10.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2010 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 7005016
+ * @summary  pit jdk7 b121  sqe test jhttp/HttpServer150013 failing
+ * @run main/othervm -Dsun.net.httpserver.clockTick=1000 -Dsun.net.httpserver.idleInterval=3 Test10
+ */
+
+import com.sun.net.httpserver.*;
+
+import java.io.*;
+import java.net.*;
+import java.util.concurrent.*;
+
+/*
+ * Test handling of empty Http headers
+ */
+
+public class Test10 extends Test {
+    public static void main (String[] args) throws Exception {
+        System.out.print ("Test10: ");
+        Handler handler = new Handler();
+        InetSocketAddress addr = new InetSocketAddress (0);
+        HttpServer server = HttpServer.create (addr, 0);
+        int port = server.getAddress().getPort();
+        HttpContext c2 = server.createContext ("/test", handler);
+
+        ExecutorService exec = Executors.newCachedThreadPool();
+        server.setExecutor (exec);
+        try {
+            server.start ();
+            doClient(port);
+            System.out.println ("OK");
+        } finally {
+            delay();
+            if (server != null)
+                server.stop(2);
+            if (exec != null)
+                exec.shutdown();
+        }
+    }
+
+    static class Handler implements HttpHandler {
+        volatile int invocation = 0;
+        public void handle (HttpExchange t)
+            throws IOException
+        {
+            InputStream is = t.getRequestBody();
+            while (is.read() != -1);
+            Headers map = t.getRequestHeaders();
+            t.sendResponseHeaders (200, -1);
+            t.close();
+        }
+    }
+
+    public static void doClient (int port) throws Exception {
+        String s = "GET /test/1.html HTTP/1.1\r\n\r\n";
+
+        Socket socket = new Socket ("localhost", port);
+        OutputStream os = socket.getOutputStream();
+        os.write (s.getBytes());
+        socket.setSoTimeout (10 * 1000);
+        InputStream is = socket.getInputStream();
+        int c;
+        byte[] b = new byte [1024];
+        while ((c=is.read(b)) != -1) ;
+        is.close();
+        socket.close();
+    }
+}
diff --git a/jdk/test/com/sun/nio/sctp/SctpChannel/SocketOptionTests.java b/jdk/test/com/sun/nio/sctp/SctpChannel/SocketOptionTests.java
index eb7318ef8eb3820044683e709459e80f0d71eb68..3eee285956579e91f73c33f5511fe26ea64fe9fb 100644
--- a/jdk/test/com/sun/nio/sctp/SctpChannel/SocketOptionTests.java
+++ b/jdk/test/com/sun/nio/sctp/SctpChannel/SocketOptionTests.java
@@ -188,6 +188,7 @@ public class SocketOptionTests {
             }
             check(found, "SCTP_PRIMARY_ADDR returned bogus address!");
 
+            System.out.println("SCTP_PRIMARY_ADDR try set to: " + addrToSet);
             sc.setOption(SCTP_PRIMARY_ADDR, addrToSet);
             System.out.println("SCTP_PRIMARY_ADDR set to: " + addrToSet);
             primaryAddr = sc.getOption(SCTP_PRIMARY_ADDR);
diff --git a/jdk/test/demo/zipfs/Basic.java b/jdk/test/demo/zipfs/Basic.java
index 91f8af274eeedec25d058756d47c6fd260999b65..8341b939273aed546195ad786c6d7225b739225a 100644
--- a/jdk/test/demo/zipfs/Basic.java
+++ b/jdk/test/demo/zipfs/Basic.java
@@ -40,24 +40,24 @@ public class Basic {
         boolean found = false;
 
         for (FileSystemProvider provider: FileSystemProvider.installedProviders()) {
-            if (provider.getScheme().equalsIgnoreCase("zip")) {
+            if (provider.getScheme().equalsIgnoreCase("jar")) {
                 found = true;
                 break;
             }
         }
         if (!found)
-            throw new RuntimeException("'zip' provider not installed");
+            throw new RuntimeException("'jar' provider not installed");
 
         // Test: FileSystems#newFileSystem(FileRef)
         Map env = new HashMap();
         FileSystems.newFileSystem(zipfile, env, null).close();
 
         // Test: FileSystems#newFileSystem(URI)
-        URI uri = URI.create("zip" + zipfile.toUri().toString().substring(4));
+        URI uri = new URI("jar", zipfile.toUri().toString(), null);
         FileSystem fs = FileSystems.newFileSystem(uri, env, null);
 
         // Test: exercise toUri method
-        String expected = uri.toString() + "#/foo";
+        String expected = uri.toString() + "!/foo";
         String actual = fs.getPath("/foo").toUri().toString();
         if (!actual.equals(expected)) {
             throw new RuntimeException("toUri returned '" + actual +
diff --git a/jdk/test/demo/zipfs/ZipFSTester.java b/jdk/test/demo/zipfs/ZipFSTester.java
index 76a8d7aeed3f5e6e62f759c02fa26391cc9049b3..8c5a104bac233a30910d122d1f12c1013273608f 100644
--- a/jdk/test/demo/zipfs/ZipFSTester.java
+++ b/jdk/test/demo/zipfs/ZipFSTester.java
@@ -58,7 +58,7 @@ public class ZipFSTester {
         // clone a fs and test on it
         Path tmpfsPath = getTempPath();
         Map env = new HashMap();
-        env.put("createNew", true);
+        env.put("create", "true");
         FileSystem fs0 = newZipFileSystem(tmpfsPath, env);
         z2zcopy(fs, fs0, "/", 0);
         fs0.close();                // sync to file
@@ -147,7 +147,7 @@ public class ZipFSTester {
 
         // create a new filesystem, copy everything from fs
         Map env = new HashMap();
-        env.put("createNew", true);
+        env.put("create", "true");
         FileSystem fs0 = newZipFileSystem(fs1Path, env);
 
         final FileSystem fs2 = newZipFileSystem(fs2Path, env);
@@ -282,11 +282,7 @@ public class ZipFSTester {
     private static FileSystem newZipFileSystem(Path path, Map env)
         throws IOException
     {
-        return FileSystems.newFileSystem(
-                   URI.create("zip" +
-                               path.toUri().toString().substring(4)),
-                   env,
-                   null);
+        return FileSystems.newFileSystem(path, env, null);
     }
 
     private static Path getTempPath() throws IOException
diff --git a/jdk/test/java/awt/font/TextLayout/TestOldHangul.java b/jdk/test/java/awt/font/TextLayout/TestOldHangul.java
new file mode 100644
index 0000000000000000000000000000000000000000..b52ba38557d6158ab37a3269b1abf92f96665eff
--- /dev/null
+++ b/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/jdk/test/java/awt/font/TextLayout/TestTibetan.java b/jdk/test/java/awt/font/TextLayout/TestTibetan.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc55472a3cdcbeb8921f2e39321274f221d89a8b
--- /dev/null
+++ b/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/jdk/test/java/dyn/ClassValueTest.java b/jdk/test/java/dyn/ClassValueTest.java
index cf7bcff82d6d0da509890c0981092f4fd75c4250..f917e9581da62aed9c40a462771d438674002fcc 100644
--- a/jdk/test/java/dyn/ClassValueTest.java
+++ b/jdk/test/java/dyn/ClassValueTest.java
@@ -53,12 +53,13 @@ public class ClassValueTest {
         return "CV1:" + type.getName();
     }
     static int countForCV1;
-    static final ClassValue CV1 = new ClassValue() {
+    static final ClassValue CV1 = new CV1();
+    private static class CV1 extends ClassValue {
         protected String computeValue(Class type) {
             countForCV1++;
             return nameForCV1(type);
         }
-    };
+    }
 
     static final Class[] CLASSES = {
         String.class,
diff --git a/jdk/test/java/dyn/InvokeDynamicPrintArgs.java b/jdk/test/java/dyn/InvokeDynamicPrintArgs.java
new file mode 100644
index 0000000000000000000000000000000000000000..1bf1b73b197dcf31bcff7ac2c16922eaa3e69e45
--- /dev/null
+++ b/jdk/test/java/dyn/InvokeDynamicPrintArgs.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2010, 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
+ * @summary smoke test for invokedynamic instructions
+ * @library indify
+ * @compile InvokeDynamicPrintArgs.java
+ * @run main/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic
+ *      indify.Indify
+ *      --verify-specifier-count=3 --transitionalJSR292=false
+ *      --expand-properties --classpath ${test.classes}
+ *      --java InvokeDynamicPrintArgs --check-output
+ */
+
+import java.util.*;
+import java.io.*;
+
+import java.dyn.*;
+import static java.dyn.MethodHandles.*;
+import static java.dyn.MethodType.*;
+
+public class InvokeDynamicPrintArgs {
+    public static void main(String... av) throws Throwable {
+        if (av.length > 0)  openBuf();  // --check-output mode
+        System.out.println("Printing some argument lists, starting with a empty one:");
+        INDY_nothing().invokeExact();                 // BSM specifier #0 = {bsm}
+        INDY_bar().invokeExact("bar arg", 1);         // BSM specifier #1 = {bsm2, Void.class, "void type"}
+        INDY_bar2().invokeExact("bar2 arg", 222);     // BSM specifier #1 = (same)
+        INDY_baz().invokeExact("baz arg", 2, 3.14);   // BSM specifier #2 = {bsm2, 1234.5}
+        INDY_foo().invokeExact("foo arg");            // BSM specifier #0 = (same)
+        // Hence, BSM specifier count should be 3.  See "--verify-specifier-count=3" above.
+        System.out.println("Done printing argument lists.");
+        closeBuf();
+    }
+
+    private static PrintStream oldOut;
+    private static ByteArrayOutputStream buf;
+    private static void openBuf() {
+        oldOut = System.out;
+        buf = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(buf));
+    }
+    private static void closeBuf() {
+        if (buf == null)  return;
+        System.out.flush();
+        System.setOut(oldOut);
+        String[] haveLines = new String(buf.toByteArray()).split("[\n\r]+");
+        for (String line : haveLines)  System.out.println(line);
+        Iterator iter = Arrays.asList(haveLines).iterator();
+        for (String want : EXPECT_OUTPUT) {
+            String have = iter.hasNext() ? iter.next() : "[EOF]";
+            if (want.equals(have))  continue;
+            System.err.println("want line: "+want);
+            System.err.println("have line: "+have);
+            throw new AssertionError("unexpected output: "+have);
+        }
+        if (iter.hasNext())
+            throw new AssertionError("unexpected output: "+iter.next());
+    }
+    private static final String[] EXPECT_OUTPUT = {
+        "Printing some argument lists, starting with a empty one:",
+        "[InvokeDynamicPrintArgs, nothing, ()void][]",
+        "[InvokeDynamicPrintArgs, bar, (java.lang.String,int)void, class java.lang.Void, void type!, 1, 234.5, 67.5, 89][bar arg, 1]",
+        "[InvokeDynamicPrintArgs, bar2, (java.lang.String,int)void, class java.lang.Void, void type!, 1, 234.5, 67.5, 89][bar2 arg, 222]",
+        "[InvokeDynamicPrintArgs, baz, (java.lang.String,int,double)void, 1234.5][baz arg, 2, 3.14]",
+        "[InvokeDynamicPrintArgs, foo, (java.lang.String)void][foo arg]",
+        "Done printing argument lists."
+    };
+
+    private static void printArgs(Object bsmInfo, Object... args) {
+        System.out.println(bsmInfo+Arrays.deepToString(args));
+    }
+    private static MethodHandle MH_printArgs() throws ReflectiveOperationException {
+        shouldNotCallThis();
+        return lookup().findStatic(lookup().lookupClass(),
+                                   "printArgs", methodType(void.class, Object.class, Object[].class));
+    }
+
+    private static CallSite bsm(Lookup caller, String name, MethodType type) throws ReflectiveOperationException {
+        // ignore caller and name, but match the type:
+        Object bsmInfo = Arrays.asList(caller, name, type);
+        return new ConstantCallSite(MH_printArgs().bindTo(bsmInfo).asCollector(Object[].class, type.parameterCount()).asType(type));
+    }
+    private static MethodType MT_bsm() {
+        shouldNotCallThis();
+        return methodType(CallSite.class, Lookup.class, String.class, MethodType.class);
+    }
+    private static MethodHandle MH_bsm() throws ReflectiveOperationException {
+        shouldNotCallThis();
+        return lookup().findStatic(lookup().lookupClass(), "bsm", MT_bsm());
+    }
+
+    private static CallSite bsm2(Lookup caller, String name, MethodType type, Object arg) throws ReflectiveOperationException {
+        // ignore caller and name, but match the type:
+        List bsmInfo = new ArrayList<>(Arrays.asList(caller, name, type));
+        if (arg instanceof Object[])
+            bsmInfo.addAll(Arrays.asList((Object[])arg));
+        else
+            bsmInfo.add(arg);
+        return new ConstantCallSite(MH_printArgs().bindTo(bsmInfo).asCollector(Object[].class, type.parameterCount()).asType(type));
+    }
+    private static MethodType MT_bsm2() {
+        shouldNotCallThis();
+        return methodType(CallSite.class, Lookup.class, String.class, MethodType.class, Object.class);
+    }
+    private static MethodHandle MH_bsm2() throws ReflectiveOperationException {
+        shouldNotCallThis();
+        return lookup().findStatic(lookup().lookupClass(), "bsm2", MT_bsm2());
+    }
+
+    private static MethodHandle INDY_nothing() throws Throwable {
+        shouldNotCallThis();
+        return ((CallSite) MH_bsm().invokeGeneric(lookup(),
+                                                  "nothing", methodType(void.class)
+                                                  )).dynamicInvoker();
+    }
+    private static MethodHandle INDY_foo() throws Throwable {
+        shouldNotCallThis();
+        return ((CallSite) MH_bsm().invokeGeneric(lookup(),
+                                                  "foo", methodType(void.class, String.class)
+                                                  )).dynamicInvoker();
+    }
+    private static MethodHandle INDY_bar() throws Throwable {
+        shouldNotCallThis();
+        return ((CallSite) MH_bsm2().invokeGeneric(lookup(),
+                                                  "bar", methodType(void.class, String.class, int.class)
+                                                  , new Object[] { Void.class, "void type!",
+                                                                   1, 234.5F, 67.5, (long)89 }
+                                                  )).dynamicInvoker();
+    }
+    private static MethodHandle INDY_bar2() throws Throwable {
+        shouldNotCallThis();
+        return ((CallSite) MH_bsm2().invokeGeneric(lookup(),
+                                                  "bar2", methodType(void.class, String.class, int.class)
+                                                  , new Object[] { Void.class, "void type!",
+                                                                   1, 234.5F, 67.5, (long)89 }
+                                                  )).dynamicInvoker();
+    }
+    private static MethodHandle INDY_baz() throws Throwable {
+        shouldNotCallThis();
+        return ((CallSite) MH_bsm2().invokeGeneric(lookup(),
+                                                  "baz", methodType(void.class, String.class, int.class, double.class)
+                                                  , 1234.5
+                                                  )).dynamicInvoker();
+    }
+
+    private static void shouldNotCallThis() {
+        // if this gets called, the transformation has not taken place
+        if (System.getProperty("InvokeDynamicPrintArgs.allow-untransformed") != null)  return;
+        throw new AssertionError("this code should be statically transformed away by Indify");
+    }
+}
diff --git a/jdk/test/java/dyn/InvokeGenericTest.java b/jdk/test/java/dyn/InvokeGenericTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..12670668c7e11dce205e994c308a74b142c57683
--- /dev/null
+++ b/jdk/test/java/dyn/InvokeGenericTest.java
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) 2009, 2010, 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.
+ */
+
+/* @test
+ * @summary unit tests for java.dyn.MethodHandle.invokeGeneric
+ * @compile -XDallowTransitionalJSR292=no -target 7 InvokeGenericTest.java
+ * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles test.java.dyn.InvokeGenericTest
+ */
+
+package test.java.dyn;
+
+import java.dyn.*;
+import static java.dyn.MethodHandles.*;
+import static java.dyn.MethodType.*;
+import java.lang.reflect.*;
+import java.util.*;
+import org.junit.*;
+import static org.junit.Assert.*;
+import static org.junit.Assume.*;
+
+
+/**
+ *
+ * @author jrose
+ */
+public class InvokeGenericTest {
+    // How much output?
+    static int verbosity = 0;
+    static {
+        String vstr = System.getProperty("test.java.dyn.InvokeGenericTest.verbosity");
+        if (vstr != null)  verbosity = Integer.parseInt(vstr);
+    }
+
+    @Test
+    public void testFirst() throws Throwable {
+        verbosity += 9; try {
+            // left blank for debugging
+        } finally { printCounts(); verbosity -= 9; }
+    }
+
+    public InvokeGenericTest() {
+    }
+
+    @Before
+    public void checkImplementedPlatform() {
+        boolean platformOK = false;
+        Properties properties = System.getProperties();
+        String vers = properties.getProperty("java.vm.version");
+        String name = properties.getProperty("java.vm.name");
+        String arch = properties.getProperty("os.arch");
+        if ((arch.equals("amd64") || arch.equals("i386") || arch.equals("x86") ||
+             arch.equals("sparc") || arch.equals("sparcv9")) &&
+            (name.contains("Client") || name.contains("Server"))
+            ) {
+            platformOK = true;
+        } else {
+            System.err.println("Skipping tests for unsupported platform: "+Arrays.asList(vers, name, arch));
+        }
+        assumeTrue(platformOK);
+    }
+
+    String testName;
+    static int allPosTests, allNegTests;
+    int posTests, negTests;
+    @After
+    public void printCounts() {
+        if (verbosity >= 2 && (posTests | negTests) != 0) {
+            System.out.println();
+            if (posTests != 0)  System.out.println("=== "+testName+": "+posTests+" positive test cases run");
+            if (negTests != 0)  System.out.println("=== "+testName+": "+negTests+" negative test cases run");
+            allPosTests += posTests;
+            allNegTests += negTests;
+            posTests = negTests = 0;
+        }
+    }
+    void countTest(boolean positive) {
+        if (positive) ++posTests;
+        else          ++negTests;
+    }
+    void countTest() { countTest(true); }
+    void startTest(String name) {
+        if (testName != null)  printCounts();
+        if (verbosity >= 1)
+            System.out.println(name);
+        posTests = negTests = 0;
+        testName = name;
+    }
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        calledLog.clear();
+        calledLog.add(null);
+        nextArgVal = INITIAL_ARG_VAL;
+    }
+
+    @AfterClass
+    public static void tearDownClass() throws Exception {
+        int posTests = allPosTests, negTests = allNegTests;
+        if (verbosity >= 2 && (posTests | negTests) != 0) {
+            System.out.println();
+            if (posTests != 0)  System.out.println("=== "+posTests+" total positive test cases");
+            if (negTests != 0)  System.out.println("=== "+negTests+" total negative test cases");
+        }
+    }
+
+    static List calledLog = new ArrayList();
+    static Object logEntry(String name, Object... args) {
+        return Arrays.asList(name, Arrays.asList(args));
+    }
+    static Object called(String name, Object... args) {
+        Object entry = logEntry(name, args);
+        calledLog.add(entry);
+        return entry;
+    }
+    static void assertCalled(String name, Object... args) {
+        Object expected = logEntry(name, args);
+        Object actual   = calledLog.get(calledLog.size() - 1);
+        if (expected.equals(actual) && verbosity < 9)  return;
+        System.out.println("assertCalled "+name+":");
+        System.out.println("expected:   "+expected);
+        System.out.println("actual:     "+actual);
+        System.out.println("ex. types:  "+getClasses(expected));
+        System.out.println("act. types: "+getClasses(actual));
+        assertEquals("previous method call", expected, actual);
+    }
+    static void printCalled(MethodHandle target, String name, Object... args) {
+        if (verbosity >= 3)
+            System.out.println("calling MH="+target+" to "+name+Arrays.toString(args));
+    }
+
+    static Object castToWrapper(Object value, Class dst) {
+        Object wrap = null;
+        if (value instanceof Number)
+            wrap = castToWrapperOrNull(((Number)value).longValue(), dst);
+        if (value instanceof Character)
+            wrap = castToWrapperOrNull((char)(Character)value, dst);
+        if (wrap != null)  return wrap;
+        return dst.cast(value);
+    }
+
+    static Object castToWrapperOrNull(long value, Class dst) {
+        if (dst == int.class || dst == Integer.class)
+            return (int)(value);
+        if (dst == long.class || dst == Long.class)
+            return (long)(value);
+        if (dst == char.class || dst == Character.class)
+            return (char)(value);
+        if (dst == short.class || dst == Short.class)
+            return (short)(value);
+        if (dst == float.class || dst == Float.class)
+            return (float)(value);
+        if (dst == double.class || dst == Double.class)
+            return (double)(value);
+        if (dst == byte.class || dst == Byte.class)
+            return (byte)(value);
+        if (dst == boolean.class || dst == boolean.class)
+            return ((value % 29) & 1) == 0;
+        return null;
+    }
+
+    static final int ONE_MILLION = (1000*1000),  // first int value
+                     TEN_BILLION = (10*1000*1000*1000),  // scale factor to reach upper 32 bits
+                     INITIAL_ARG_VAL = ONE_MILLION << 1;  // <<1 makes space for sign bit;
+    static long nextArgVal;
+    static long nextArg(boolean moreBits) {
+        long val = nextArgVal++;
+        long sign = -(val & 1); // alternate signs
+        val >>= 1;
+        if (moreBits)
+            // Guarantee some bits in the high word.
+            // In any case keep the decimal representation simple-looking,
+            // with lots of zeroes, so as not to make the printed decimal
+            // strings unnecessarily noisy.
+            val += (val % ONE_MILLION) * TEN_BILLION;
+        return val ^ sign;
+    }
+    static int nextArg() {
+        // Produce a 32-bit result something like ONE_MILLION+(smallint).
+        // Example: 1_000_042.
+        return (int) nextArg(false);
+    }
+    static long nextArg(Class kind) {
+        if (kind == long.class   || kind == Long.class ||
+            kind == double.class || kind == Double.class)
+            // produce a 64-bit result something like
+            // ((TEN_BILLION+1) * (ONE_MILLION+(smallint)))
+            // Example: 10_000_420_001_000_042.
+            return nextArg(true);
+        return (long) nextArg();
+    }
+
+    static Object randomArg(Class param) {
+        Object wrap = castToWrapperOrNull(nextArg(param), param);
+        if (wrap != null) {
+            return wrap;
+        }
+//        import sun.dyn.util.Wrapper;
+//        Wrapper wrap = Wrapper.forBasicType(dst);
+//        if (wrap == Wrapper.OBJECT && Wrapper.isWrapperType(dst))
+//            wrap = Wrapper.forWrapperType(dst);
+//        if (wrap != Wrapper.OBJECT)
+//            return wrap.wrap(nextArg++);
+        if (param.isInterface()) {
+            for (Class c : param.getClasses()) {
+                if (param.isAssignableFrom(c) && !c.isInterface())
+                    { param = c; break; }
+            }
+        }
+        if (param.isInterface() || param.isAssignableFrom(String.class))
+            return "#"+nextArg();
+        else
+            try {
+                return param.newInstance();
+            } catch (InstantiationException ex) {
+            } catch (IllegalAccessException ex) {
+            }
+        return null;  // random class not Object, String, Integer, etc.
+    }
+    static Object[] randomArgs(Class... params) {
+        Object[] args = new Object[params.length];
+        for (int i = 0; i < args.length; i++)
+            args[i] = randomArg(params[i]);
+        return args;
+    }
+    static Object[] randomArgs(int nargs, Class param) {
+        Object[] args = new Object[nargs];
+        for (int i = 0; i < args.length; i++)
+            args[i] = randomArg(param);
+        return args;
+    }
+
+    static final Object ANON_OBJ = new Object();
+    static Object zeroArg(Class param) {
+        Object x = castToWrapperOrNull(0L, param);
+        if (x != null)  return x;
+        if (param.isInterface() || param.isAssignableFrom(String.class))  return "\"\"";
+        if (param == Object.class)  return ANON_OBJ;
+        if (param.getComponentType() != null)  return Array.newInstance(param.getComponentType(), 0);
+        return null;
+    }
+    static Object[] zeroArgs(Class... params) {
+        Object[] args = new Object[params.length];
+        for (int i = 0; i < args.length; i++)
+            args[i] = zeroArg(params[i]);
+        return args;
+    }
+    static Object[] zeroArgs(List> params) {
+        return zeroArgs(params.toArray(new Class[0]));
+    }
+
+    static  T[] array(Class atype, E... a) {
+        return Arrays.copyOf(a, a.length, atype);
+    }
+    static  T[] cat(T[] a, T... b) {
+        int alen = a.length, blen = b.length;
+        if (blen == 0)  return a;
+        T[] c = Arrays.copyOf(a, alen + blen);
+        System.arraycopy(b, 0, c, alen, blen);
+        return c;
+    }
+    static Integer[] boxAll(int... vx) {
+        Integer[] res = new Integer[vx.length];
+        for (int i = 0; i < res.length; i++) {
+            res[i] = vx[i];
+        }
+        return res;
+    }
+    static Object getClasses(Object x) {
+        if (x == null)  return x;
+        if (x instanceof String)  return x;  // keep the name
+        if (x instanceof List) {
+            // recursively report classes of the list elements
+            Object[] xa = ((List)x).toArray();
+            for (int i = 0; i < xa.length; i++)
+                xa[i] = getClasses(xa[i]);
+            return Arrays.asList(xa);
+        }
+        return x.getClass().getSimpleName();
+    }
+
+    static MethodHandle changeArgTypes(MethodHandle target, Class argType) {
+        return changeArgTypes(target, 0, 999, argType);
+    }
+    static MethodHandle changeArgTypes(MethodHandle target,
+            int beg, int end, Class argType) {
+        MethodType targetType = target.type();
+        end = Math.min(end, targetType.parameterCount());
+        ArrayList> argTypes = new ArrayList>(targetType.parameterList());
+        Collections.fill(argTypes.subList(beg, end), argType);
+        MethodType ttype2 = MethodType.methodType(targetType.returnType(), argTypes);
+        return MethodHandles.convertArguments(target, ttype2);
+    }
+
+    // This lookup is good for all members in and under InvokeGenericTest.
+    static final Lookup LOOKUP = MethodHandles.lookup();
+
+    Map>, MethodHandle> CALLABLES = new HashMap>, MethodHandle>();
+    MethodHandle callable(List> params) {
+        MethodHandle mh = CALLABLES.get(params);
+        if (mh == null) {
+            mh = collectArguments(collector_MH, methodType(Object.class, params));
+            CALLABLES.put(params, mh);
+        }
+        return mh;
+    }
+    MethodHandle callable(Class... params) {
+        return callable(Arrays.asList(params));
+    }
+    private static Object collector(Object... args) {
+        return Arrays.asList(args);
+    }
+    private static final MethodHandle collector_MH;
+    static {
+        try {
+            collector_MH
+                = LOOKUP.findStatic(LOOKUP.lookupClass(),
+                                    "collector",
+                                    methodType(Object.class, Object[].class));
+        } catch (NoAccessException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    @Test
+    public void testSimple() throws Throwable {
+        startTest("testSimple");
+        countTest();
+        String[] args = { "one", "two" };
+        MethodHandle mh = callable(Object.class, String.class);
+        Object res; List resl;
+        res = resl = (List) mh.invokeGeneric((String)args[0], (Object)args[1]);
+        //System.out.println(res);
+        assertEquals(Arrays.asList(args), res);
+    }
+
+    @Test
+    public void testWrongArgumentCount() throws Throwable {
+        startTest("testWrongArgumentCount");
+        for (int i = 0; i <= 10; i++) {
+            testWrongArgumentCount(Collections.>nCopies(i, Integer.class));
+            if (i <= 4) {
+                testWrongArgumentCount(Collections.>nCopies(i, int.class));
+                testWrongArgumentCount(Collections.>nCopies(i, long.class));
+            }
+        }
+    }
+    public void testWrongArgumentCount(List> params) throws Throwable {
+        int max = params.size();
+        for (int i = 0; i < max; i++) {
+            List> params2 = params.subList(0, i);
+            for (int k = 0; k <= 2; k++) {
+                if (k == 1)  params  = methodType(Object.class,  params).generic().parameterList();
+                if (k == 2)  params2 = methodType(Object.class, params2).generic().parameterList();
+                testWrongArgumentCount(params, params2);
+                testWrongArgumentCount(params2, params);
+            }
+        }
+    }
+    public void testWrongArgumentCount(List> expect, List> observe) throws Throwable {
+        countTest(false);
+        if (expect.equals(observe))
+            assert(false);
+        MethodHandle target = callable(expect);
+        Object[] args = zeroArgs(observe);
+        Object junk;
+        try {
+            switch (args.length) {
+            case 0:
+                junk = target.invokeGeneric(); break;
+            case 1:
+                junk = target.invokeGeneric(args[0]); break;
+            case 2:
+                junk = target.invokeGeneric(args[0], args[1]); break;
+            case 3:
+                junk = target.invokeGeneric(args[0], args[1], args[2]); break;
+            case 4:
+                junk = target.invokeGeneric(args[0], args[1], args[2], args[3]); break;
+            default:
+                junk = target.invokeWithArguments(args); break;
+            }
+        } catch (WrongMethodTypeException ex) {
+            return;
+        } catch (Exception ex) {
+            throw new RuntimeException("wrong exception calling "+target+target.type()+" on "+Arrays.asList(args)+" : "+ex);
+        }
+        throw new RuntimeException("bad success calling "+target+target.type()+" on "+Arrays.asList(args));
+    }
+
+    /** Make a list of all combinations of the given types, with the given arities.
+     *  A void return type is possible iff the first type is void.class.
+     */
+    static List allMethodTypes(int minargc, int maxargc, Class... types) {
+        ArrayList result = new ArrayList();
+        if (types.length > 0) {
+            ArrayList argcTypes = new ArrayList();
+            // build arity-zero types first
+            for (Class rtype : types) {
+                argcTypes.add(MethodType.methodType(rtype));
+            }
+            if (types[0] == void.class)
+                // void is not an argument type
+                types = Arrays.copyOfRange(types, 1, types.length);
+            for (int argc = 0; argc <= maxargc; argc++) {
+                if (argc >= minargc)
+                    result.addAll(argcTypes);
+                if (argc >= maxargc)
+                    break;
+                ArrayList prevTypes = argcTypes;
+                argcTypes = new ArrayList();
+                for (MethodType prevType : prevTypes) {
+                    for (Class ptype : types) {
+                        argcTypes.add(prevType.insertParameterTypes(argc, ptype));
+                    }
+                }
+            }
+        }
+        return Collections.unmodifiableList(result);
+    }
+    static List allMethodTypes(int argc, Class... types) {
+        return allMethodTypes(argc, argc, types);
+    }
+
+    interface RandomInterface { }
+
+    MethodHandle toString_MH;
+
+    @Test
+    public void testReferenceConversions() throws Throwable {
+        startTest("testReferenceConversions");
+        toString_MH = LOOKUP.
+            findVirtual(Object.class, "toString", MethodType.methodType(String.class));
+        String[] args = { "one", "two" };
+        for (MethodType type : allMethodTypes(2, Object.class, String.class, RandomInterface.class)) {
+            testReferenceConversions(type, args);
+        }
+    }
+    public void testReferenceConversions(MethodType type, Object... args) throws Throwable {
+        countTest();
+        if (verbosity > 3)  System.out.println("target type: "+type);
+        MethodHandle mh = callable(type.parameterList());
+        MethodHandle tsdrop = MethodHandles.dropArguments(toString_MH, 1, type.parameterList());
+        mh = MethodHandles.foldArguments(tsdrop, mh);
+        mh = mh.asType(type);
+        Object res = mh.invokeGeneric((String)args[0], (Object)args[1]);
+        //System.out.println(res);
+        assertEquals(Arrays.asList(args).toString(), res);
+    }
+
+
+    @Test @Ignore("known failure pending 6939861")
+    public void testBoxConversions() throws Throwable {
+        startTest("testBoxConversions");
+        countTest();
+        Integer[] args = { 1, 2 };
+        MethodHandle mh = callable(Object.class, int.class);
+        Object res; List resl;
+        res = resl = (List) mh.invokeGeneric((int)args[0], (Object)args[1]);
+        //System.out.println(res);
+        assertEquals(Arrays.asList(args), res);
+    }
+
+}
diff --git a/jdk/test/java/dyn/JavaDocExamples.java b/jdk/test/java/dyn/JavaDocExamplesTest.java
similarity index 54%
rename from jdk/test/java/dyn/JavaDocExamples.java
rename to jdk/test/java/dyn/JavaDocExamplesTest.java
index db5a5ef2a21018ba30eea62afdbfa54e1b84e5d7..9cb41f9fcec8336759aa8e93769498919174dc26 100644
--- a/jdk/test/java/dyn/JavaDocExamples.java
+++ b/jdk/test/java/dyn/JavaDocExamplesTest.java
@@ -25,18 +25,18 @@
 
 /* @test
  * @summary example code used in javadoc for java.dyn API
- * @compile -XDallowTransitionalJSR292=no JavaDocExamples.java
- * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles test.java.dyn.JavaDocExamples
+ * @compile -XDallowTransitionalJSR292=no JavaDocExamplesTest.java
+ * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles test.java.dyn.JavaDocExamplesTest
  */
 
 /*
 ---- To run outside jtreg:
 $ $JAVA7X_HOME/bin/javac -cp $JUNIT4_JAR -d /tmp/Classes \
-   $DAVINCI/sources/jdk/test/java/dyn/JavaDocExamples.java
+   $DAVINCI/sources/jdk/test/java/dyn/JavaDocExamplesTest.java
 $ $JAVA7X_HOME/bin/java   -cp $JUNIT4_JAR:/tmp/Classes \
    -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles \
-   -Dtest.java.dyn.JavaDocExamples.verbosity=1 \
-     test.java.dyn.JavaDocExamples
+   -Dtest.java.dyn.JavaDocExamplesTest.verbosity=1 \
+     test.java.dyn.JavaDocExamplesTest
 ----
 */
 
@@ -57,15 +57,15 @@ import static org.junit.Assume.*;
 /**
  * @author jrose
  */
-public class JavaDocExamples {
+public class JavaDocExamplesTest {
     /** Wrapper for running the JUnit tests in this module.
      *  Put JUnit on the classpath!
      */
     public static void main(String... ignore) {
-        org.junit.runner.JUnitCore.runClasses(JavaDocExamples.class);
+        org.junit.runner.JUnitCore.runClasses(JavaDocExamplesTest.class);
     }
     // How much output?
-    static int verbosity = Integer.getInteger("test.java.dyn.JavaDocExamples.verbosity", 0);
+    static int verbosity = Integer.getInteger("test.java.dyn.JavaDocExamplesTest.verbosity", 0);
 
 {}
 static final private Lookup LOOKUP = lookup();
@@ -95,11 +95,11 @@ MethodHandle CONCAT_3 = LOOKUP.findVirtual(String.class,
 MethodHandle HASHCODE_3 = LOOKUP.findVirtual(Object.class,
   "hashCode", methodType(int.class));
 //assertEquals("xy", (String) CONCAT_1.invokeExact("x", "y"));
-assertEquals("xy", (String) CONCAT_2.invokeExact("x", "y"));
-assertEquals("xy", (String) CONCAT_3.invokeExact("x", "y"));
-//assertEquals("xy".hashCode(), (int) HASHCODE_1.invokeExact((Object)"xy"));
-assertEquals("xy".hashCode(), (int) HASHCODE_2.invokeExact((Object)"xy"));
-assertEquals("xy".hashCode(), (int) HASHCODE_3.invokeExact((Object)"xy"));
+assertEquals("xy", (String) CONCAT_2.invokeExact("x", "y"));
+assertEquals("xy", (String) CONCAT_3.invokeExact("x", "y"));
+//assertEquals("xy".hashCode(), (int) HASHCODE_1.invokeExact((Object)"xy"));
+assertEquals("xy".hashCode(), (int) HASHCODE_2.invokeExact((Object)"xy"));
+assertEquals("xy".hashCode(), (int) HASHCODE_3.invokeExact((Object)"xy"));
 {}
     }
     @Test public void testDropArguments() throws Throwable {
@@ -107,16 +107,32 @@ assertEquals("xy".hashCode(), (int) HASHCODE_3.invokeExact((Object)"xy"));
 {} /// JAVADOC
 MethodHandle cat = lookup().findVirtual(String.class,
   "concat", methodType(String.class, String.class));
-cat = cat.asType(methodType(Object.class, String.class, String.class)); /*(String)*/
-assertEquals("xy", /*(String)*/ cat.invokeExact("x", "y"));
+assertEquals("xy", (String) cat.invokeExact("x", "y"));
 MethodHandle d0 = dropArguments(cat, 0, String.class);
-assertEquals("yz", /*(String)*/ d0.invokeExact("x", "y", "z"));
+assertEquals("yz", (String) d0.invokeExact("x", "y", "z"));
 MethodHandle d1 = dropArguments(cat, 1, String.class);
-assertEquals("xz", /*(String)*/ d1.invokeExact("x", "y", "z"));
+assertEquals("xz", (String) d1.invokeExact("x", "y", "z"));
 MethodHandle d2 = dropArguments(cat, 2, String.class);
-assertEquals("xy", /*(String)*/ d2.invokeExact("x", "y", "z"));
+assertEquals("xy", (String) d2.invokeExact("x", "y", "z"));
 MethodHandle d12 = dropArguments(cat, 1, int.class, boolean.class);
-assertEquals("xz", /*(String)*/ d12.invokeExact("x", 12, true, "z"));
+assertEquals("xz", (String) d12.invokeExact("x", 12, true, "z"));
+            }}
+    }
+
+    @Test public void testFilterArguments() throws Throwable {
+        {{
+{} /// JAVADOC
+MethodHandle cat = lookup().findVirtual(String.class,
+  "concat", methodType(String.class, String.class));
+MethodHandle upcase = lookup().findVirtual(String.class,
+  "toUpperCase", methodType(String.class));
+assertEquals("xy", (String) cat.invokeExact("x", "y"));
+MethodHandle f0 = filterArguments(cat, 0, upcase);
+assertEquals("Xy", (String) f0.invokeExact("x", "y")); // Xy
+MethodHandle f1 = filterArguments(cat, 1, upcase);
+assertEquals("xY", (String) f1.invokeExact("x", "y")); // xY
+MethodHandle f2 = filterArguments(cat, 0, upcase, upcase);
+assertEquals("XY", (String) f2.invokeExact("x", "y")); // XY
             }}
     }
 
@@ -125,4 +141,38 @@ assertEquals("xz", /*(String)*/ d12.invokeExact("x", 12, true, "z"));
             System.out.println("result: "+act);
         Assert.assertEquals(exp, act);
     }
+
+static MethodHandle asList;
+    @Test public void testWithTypeHandler() throws Throwable {
+        {{
+{} /// JAVADOC
+MethodHandle makeEmptyList = MethodHandles.constant(List.class, Arrays.asList());
+MethodHandle asList = lookup()
+  .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class));
+
+JavaDocExamplesTest.asList = asList;
+/*
+static MethodHandle collectingTypeHandler(MethodHandle base, MethodType newType) {
+  return asList.asCollector(Object[].class, newType.parameterCount()).asType(newType);
+}
+*/
+
+MethodHandle collectingTypeHandler = lookup()
+  .findStatic(lookup().lookupClass(), "collectingTypeHandler",
+     methodType(MethodHandle.class, MethodHandle.class, MethodType.class));
+MethodHandle makeAnyList = makeEmptyList.withTypeHandler(collectingTypeHandler);
+
+assertEquals("[]", makeAnyList.invokeGeneric().toString());
+assertEquals("[1]", makeAnyList.invokeGeneric(1).toString());
+assertEquals("[two, too]", makeAnyList.invokeGeneric("two", "too").toString());
+            }}
+    }
+
+static MethodHandle collectingTypeHandler(MethodHandle base, MethodType newType) {
+    //System.out.println("Converting "+asList+" to "+newType);
+    MethodHandle conv = asList.asCollector(Object[].class, newType.parameterCount()).asType(newType);
+    //System.out.println(" =>"+conv);
+    return conv;
+}
+
 }
diff --git a/jdk/test/java/dyn/MethodHandlesTest.java b/jdk/test/java/dyn/MethodHandlesTest.java
index 62b0c903269f88649800bcedb99447ed705d2ec5..e92bc6dbae477c823e249697dd7b5c5418119875 100644
--- a/jdk/test/java/dyn/MethodHandlesTest.java
+++ b/jdk/test/java/dyn/MethodHandlesTest.java
@@ -25,8 +25,8 @@
 
 /* @test
  * @summary unit tests for java.dyn.MethodHandles
- * @compile -XDinvokedynamic MethodHandlesTest.java
- * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic test.java.dyn.MethodHandlesTest
+ * @compile -source 7 -target 7 -XDallowTransitionalJSR292=no MethodHandlesTest.java
+ * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles test.java.dyn.MethodHandlesTest
  */
 
 package test.java.dyn;
@@ -62,7 +62,6 @@ public class MethodHandlesTest {
     // lookups, without exercising the actual method handle.
     static boolean DO_MORE_CALLS = true;
 
-
     @Test
     public void testFirst() throws Throwable {
         verbosity += 9; try {
@@ -458,7 +457,7 @@ public class MethodHandlesTest {
         Exception noAccess = null;
         try {
             if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
-            target = lookup.findStatic(defc, name, type);
+            target = lookup.in(defc).findStatic(defc, name, type);
         } catch (NoAccessException ex) {
             noAccess = ex;
         }
@@ -469,16 +468,22 @@ public class MethodHandlesTest {
         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
         if (!positive)  return; // negative test failed as expected
         assertEquals(type, target.type());
-        assertTrue(target.toString().contains(name));  // rough check
+        assertNameStringContains(target, name);
         if (!DO_MORE_CALLS && lookup != PRIVATE)  return;
         Object[] args = randomArgs(params);
         printCalled(target, name, args);
-        target.invokeVarargs(args);
+        target.invokeWithArguments(args);
         assertCalled(name, args);
         if (verbosity >= 1)
             System.out.print(':');
     }
 
+    // rough check of name string
+    static void assertNameStringContains(Object x, String s) {
+        if (x.toString().contains(s))  return;
+        assertEquals(s, x);
+    }
+
     @Test
     public void testFindVirtual() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
@@ -522,7 +527,7 @@ public class MethodHandlesTest {
         Exception noAccess = null;
         try {
             if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
-            target = lookup.findVirtual(defc, methodName, type);
+            target = lookup.in(defc).findVirtual(defc, methodName, type);
         } catch (NoAccessException ex) {
             noAccess = ex;
         }
@@ -535,12 +540,12 @@ public class MethodHandlesTest {
         Class[] paramsWithSelf = cat(array(Class[].class, (Class)defc), params);
         MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
         assertEquals(typeWithSelf, target.type());
-        assertTrue(target.toString().contains(methodName));  // rough check
+        assertNameStringContains(target, methodName);
         if (!DO_MORE_CALLS && lookup != PRIVATE)  return;
         Object[] argsWithSelf = randomArgs(paramsWithSelf);
         if (rcvc != defc)  argsWithSelf[0] = randomArg(rcvc);
         printCalled(target, name, argsWithSelf);
-        target.invokeVarargs(argsWithSelf);
+        target.invokeWithArguments(argsWithSelf);
         assertCalled(name, argsWithSelf);
         if (verbosity >= 1)
             System.out.print(':');
@@ -576,7 +581,8 @@ public class MethodHandlesTest {
         Exception noAccess = null;
         try {
             if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
-            target = lookup.findSpecial(defc, name, type, specialCaller);
+            if (verbosity >= 5)  System.out.println("  lookup => "+lookup.in(specialCaller));
+            target = lookup.in(specialCaller).findSpecial(defc, name, type, specialCaller);
         } catch (NoAccessException ex) {
             noAccess = ex;
         }
@@ -591,11 +597,11 @@ public class MethodHandlesTest {
         assertEquals(type,          target.type().dropParameterTypes(0,1));
         Class[] paramsWithSelf = cat(array(Class[].class, (Class)specialCaller), params);
         MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
-        assertTrue(target.toString().contains(name));  // rough check
+        assertNameStringContains(target, name);
         if (!DO_MORE_CALLS && lookup != PRIVATE && lookup != EXAMPLE)  return;
         Object[] args = randomArgs(paramsWithSelf);
         printCalled(target, name, args);
-        target.invokeVarargs(args);
+        target.invokeWithArguments(args);
         assertCalled(name, args);
     }
 
@@ -632,7 +638,7 @@ public class MethodHandlesTest {
         Exception noAccess = null;
         try {
             if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
-            target = lookup.bind(receiver, methodName, type);
+            target = lookup.in(defc).bind(receiver, methodName, type);
         } catch (NoAccessException ex) {
             noAccess = ex;
         }
@@ -645,7 +651,7 @@ public class MethodHandlesTest {
         assertEquals(type, target.type());
         Object[] args = randomArgs(params);
         printCalled(target, name, args);
-        target.invokeVarargs(args);
+        target.invokeWithArguments(args);
         Object[] argsWithReceiver = cat(array(Object[].class, receiver), args);
         assertCalled(name, argsWithReceiver);
         if (verbosity >= 1)
@@ -705,9 +711,9 @@ public class MethodHandlesTest {
         try {
             if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
             if (isSpecial)
-                target = lookup.unreflectSpecial(rmethod, specialCaller);
+                target = lookup.in(specialCaller).unreflectSpecial(rmethod, specialCaller);
             else
-                target = lookup.unreflect(rmethod);
+                target = lookup.in(defc).unreflect(rmethod);
         } catch (NoAccessException ex) {
             noAccess = ex;
         }
@@ -737,7 +743,7 @@ public class MethodHandlesTest {
         }
         Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
         printCalled(target, name, argsMaybeWithSelf);
-        target.invokeVarargs(argsMaybeWithSelf);
+        target.invokeWithArguments(argsMaybeWithSelf);
         assertCalled(name, argsMaybeWithSelf);
         if (verbosity >= 1)
             System.out.print(':');
@@ -875,7 +881,7 @@ public class MethodHandlesTest {
         if (isStatic)  expType = expType.dropParameterTypes(0, 1);
         MethodHandle mh = lookup.unreflectGetter(f);
         assertSame(mh.type(), expType);
-        assertEquals(mh.toString(), fname);
+        assertNameStringContains(mh, fname);
         HasFields fields = new HasFields();
         Object sawValue;
         Class rtype = type;
@@ -885,12 +891,12 @@ public class MethodHandlesTest {
         for (int i = 0; i <= 1; i++) {
             if (isStatic) {
                 if (type == int.class)
-                    sawValue = mh.invokeExact();  // do these exactly
+                    sawValue = (int) mh.invokeExact();  // do these exactly
                 else
                     sawValue = mh.invokeExact();
             } else {
                 if (type == int.class)
-                    sawValue = mh.invokeExact((Object) fields);
+                    sawValue = (int) mh.invokeExact((Object) fields);
                 else
                     sawValue = mh.invokeExact((Object) fields);
             }
@@ -947,7 +953,7 @@ public class MethodHandlesTest {
             mh = lookup.findStaticSetter(fclass, fname, ftype);
         else  throw new InternalError();
         assertSame(mh.type(), expType);
-        assertEquals(mh.toString(), fname);
+        assertNameStringContains(mh, fname);
         HasFields fields = new HasFields();
         Object sawValue;
         Class vtype = type;
@@ -959,14 +965,14 @@ public class MethodHandlesTest {
             Object putValue = randomArg(type);
             if (isStatic) {
                 if (type == int.class)
-                    mh.invokeExact((int)(Integer)putValue);  // do these exactly
+                    mh.invokeExact((int)putValue);  // do these exactly
                 else
-                    mh.invokeExact(putValue);
+                    mh.invokeExact(putValue);
             } else {
                 if (type == int.class)
-                    mh.invokeExact((Object) fields, (int)(Integer)putValue);
+                    mh.invokeExact((Object) fields, (int)putValue);
                 else
-                    mh.invokeExact((Object) fields, putValue);
+                    mh.invokeExact((Object) fields, putValue);
             }
             assertEquals(f.get(fields), putValue);
         }
@@ -1032,11 +1038,11 @@ public class MethodHandlesTest {
             model.set(i, random);
             if (testSetter) {
                 if (elemType == int.class)
-                    mh.invokeExact((int[]) array, i, (int)(Integer)random);
+                    mh.invokeExact((int[]) array, i, (int)random);
                 else if (elemType == boolean.class)
-                    mh.invokeExact((boolean[]) array, i, (boolean)(Boolean)random);
+                    mh.invokeExact((boolean[]) array, i, (boolean)random);
                 else
-                    mh.invokeExact(array, i, random);
+                    mh.invokeExact(array, i, random);
                 assertEquals(model, array2list(array));
             } else {
                 Array.set(array, i, random);
@@ -1052,9 +1058,9 @@ public class MethodHandlesTest {
             if (!testSetter) {
                 expValue = sawValue;
                 if (elemType == int.class)
-                    sawValue = mh.invokeExact((int[]) array, i);
+                    sawValue = (int) mh.invokeExact((int[]) array, i);
                 else if (elemType == boolean.class)
-                    sawValue = mh.invokeExact((boolean[]) array, i);
+                    sawValue = (boolean) mh.invokeExact((boolean[]) array, i);
                 else
                     sawValue = mh.invokeExact(array, i);
                 assertEquals(sawValue, expValue);
@@ -1102,6 +1108,18 @@ public class MethodHandlesTest {
         }
     }
 
+    static MethodHandle typeHandler2(MethodHandle target, MethodType newType) {
+        MethodType oldType = target.type();
+        int oldArity = oldType.parameterCount();
+        int newArity = newType.parameterCount();
+        if (newArity < oldArity)
+            return MethodHandles.insertArguments(target, oldArity, "OPTIONAL");
+        else if (newArity > oldArity)
+            return MethodHandles.dropArguments(target, oldArity-1, newType.parameterType(oldArity-1));
+        else
+            return target;  // attempt no further conversions
+    }
+
     @Test
     public void testConvertArguments() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
@@ -1115,10 +1133,29 @@ public class MethodHandlesTest {
     }
 
     void testConvert(MethodHandle id, Class rtype, String name, Class... params) throws Throwable {
-        testConvert(true, id, rtype, name, params);
+        testConvert(true, false, id, rtype, name, params);
+        testConvert(true, true,  id, rtype, name, params);
     }
 
-    void testConvert(boolean positive, MethodHandle id, Class rtype, String name, Class... params) throws Throwable {
+    @Test
+    public void testTypeHandler() throws Throwable {
+        MethodHandle id = Callee.ofType(1);
+        MethodHandle th2 = PRIVATE.findStatic(MethodHandlesTest.class, "typeHandler2",
+                               MethodType.methodType(MethodHandle.class, MethodHandle.class, MethodType.class));
+        MethodHandle id2 = id.withTypeHandler(th2);
+        testConvert(true,  false, id2, null, "id", Object.class);
+        testConvert(true,  true,  id2, null, "id", Object.class);
+        if (true)  return;  //FIXME
+        testConvert(true,  false, id2, null, "id", String.class);  // FIXME: throws WMT
+        testConvert(false, true,  id2, null, "id", String.class);  // FIXME: should not succeed
+        testConvert(false, false, id2, null, "id", Object.class, String.class); //FIXME: array[1] line 1164
+        testConvert(true,  true,  id2, null, "id", Object.class, String.class);
+        testConvert(false, false, id2, null, "id");
+        testConvert(true,  true,  id2, null, "id");
+    }
+
+    void testConvert(boolean positive, boolean useAsType,
+                     MethodHandle id, Class rtype, String name, Class... params) throws Throwable {
         countTest(positive);
         MethodType idType = id.type();
         if (rtype == null)  rtype = idType.returnType();
@@ -1135,7 +1172,7 @@ public class MethodHandlesTest {
             if (src != dst)
                 convArgs[i] = castToWrapper(convArgs[i], dst);
         }
-        Object convResult = id.invokeVarargs(convArgs);
+        Object convResult = id.invokeWithArguments(convArgs);
         {
             Class dst = newType.returnType();
             Class src = idType.returnType();
@@ -1145,7 +1182,10 @@ public class MethodHandlesTest {
         MethodHandle target = null;
         RuntimeException error = null;
         try {
-            target = MethodHandles.convertArguments(id, newType);
+            if (useAsType)
+                target = MethodHandles.convertArguments(id, newType);
+            else
+                target = id.asType(newType);
         } catch (RuntimeException ex) {
             error = ex;
         }
@@ -1157,7 +1197,7 @@ public class MethodHandlesTest {
         if (!positive)  return; // negative test failed as expected
         assertEquals(newType, target.type());
         printCalled(target, id.toString(), args);
-        Object result = target.invokeVarargs(args);
+        Object result = target.invokeWithArguments(args);
         assertCalled(name, convArgs);
         assertEquals(convResult, result);
         if (verbosity >= 1)
@@ -1279,7 +1319,7 @@ public class MethodHandlesTest {
         MethodType outType = MethodType.methodType(Object.class, permTypes);
         MethodHandle target = MethodHandles.convertArguments(ValueConversions.varargsList(outargs), outType);
         MethodHandle newTarget = MethodHandles.permuteArguments(target, inType, reorder);
-        Object result = newTarget.invokeVarargs(args);
+        Object result = newTarget.invokeWithArguments(args);
         Object expected = Arrays.asList(permArgs);
         assertEquals(expected, result);
     }
@@ -1311,19 +1351,19 @@ public class MethodHandlesTest {
         Object[] args = randomArgs(target2.type().parameterArray());
         // make sure the target does what we think it does:
         if (pos == 0 && nargs < 5) {
-            Object[] check = (Object[]) target.invokeVarargs(args);
+            Object[] check = (Object[]) target.invokeWithArguments(args);
             assertArrayEquals(args, check);
             switch (nargs) {
                 case 0:
-                    check = target.invokeExact();
+                    check = (Object[]) target.invokeExact();
                     assertArrayEquals(args, check);
                     break;
                 case 1:
-                    check = target.invokeExact(args[0]);
+                    check = (Object[]) target.invokeExact(args[0]);
                     assertArrayEquals(args, check);
                     break;
                 case 2:
-                    check = target.invokeExact(args[0], args[1]);
+                    check = (Object[]) target.invokeExact(args[0], args[1]);
                     assertArrayEquals(args, check);
                     break;
             }
@@ -1337,12 +1377,15 @@ public class MethodHandlesTest {
         MethodHandle result = MethodHandles.spreadArguments(target2, newType);
         Object[] returnValue;
         if (pos == 0) {
-            Object rawRetVal = result.invokeExact(args);
-            returnValue = (Object[]) rawRetVal;
+            // In the following line, the first cast implies
+            // normal Object return value for the MH call (Object[])->Object,
+            // while the second cast dynamically converts to an Object array.
+            // Such a double cast is typical of MH.invokeExact.
+            returnValue = (Object[]) (Object) result.invokeExact(args);
         } else {
             Object[] args1 = Arrays.copyOfRange(args, 0, pos+1);
             args1[pos] = Arrays.copyOfRange(args, pos, args.length);
-            returnValue = (Object[]) result.invokeVarargs(args1);
+            returnValue = (Object[]) result.invokeWithArguments(args1);
         }
         assertArrayEquals(args, returnValue);
     }
@@ -1379,7 +1422,7 @@ public class MethodHandlesTest {
         if (verbosity >= 3)
             System.out.println("collect from "+Arrays.asList(args)+" ["+pos+".."+nargs+"]");
         MethodHandle result = MethodHandles.collectArguments(target, newType);
-        Object[] returnValue = (Object[]) result.invokeVarargs(args);
+        Object[] returnValue = (Object[]) result.invokeWithArguments(args);
 //        assertTrue(returnValue.length == pos+1 && returnValue[pos] instanceof Object[]);
 //        returnValue[pos] = Arrays.asList((Object[]) returnValue[pos]);
 //        collectedArgs[pos] = Arrays.asList((Object[]) collectedArgs[pos]);
@@ -1412,7 +1455,7 @@ public class MethodHandlesTest {
         MethodHandle target2 = MethodHandles.insertArguments(target, pos,
                 (Object[]) argsToInsert.toArray());
         argsToInsert.clear();  // remove from argsToInsert
-        Object res2 = target2.invokeVarargs(argsToPass);
+        Object res2 = target2.invokeWithArguments(argsToPass);
         Object res2List = Arrays.asList((Object[])res2);
         if (verbosity >= 3)
             System.out.println("result: "+res2List);
@@ -1440,14 +1483,12 @@ public class MethodHandlesTest {
         Object[] argsToPass = randomArgs(nargs, Object.class);
         if (verbosity >= 3)
             System.out.println("filter "+target+" at "+pos+" with "+filter);
-        MethodHandle[] filters = new MethodHandle[pos*2+1];
-        filters[pos] = filter;
-        MethodHandle target2 = MethodHandles.filterArguments(target, filters);
+        MethodHandle target2 = MethodHandles.filterArguments(target, pos, filter);
         // Simulate expected effect of filter on arglist:
         Object[] filteredArgs = argsToPass.clone();
         filteredArgs[pos] = filter.invokeExact(filteredArgs[pos]);
         List expected = Arrays.asList(filteredArgs);
-        Object result = target2.invokeVarargs(argsToPass);
+        Object result = target2.invokeWithArguments(argsToPass);
         if (verbosity >= 3)
             System.out.println("result: "+result);
         if (!expected.equals(result))
@@ -1472,7 +1513,7 @@ public class MethodHandlesTest {
         if (pos != 0)  return;  // can fold only at pos=0 for now
         countTest();
         MethodHandle target = ValueConversions.varargsList(1 + nargs);
-        MethodHandle combine = ValueConversions.varargsList(fold);
+        MethodHandle combine = ValueConversions.varargsList(fold).asType(MethodType.genericMethodType(fold));
         List argsToPass = Arrays.asList(randomArgs(nargs, Object.class));
         if (verbosity >= 3)
             System.out.println("fold "+target+" with "+combine);
@@ -1482,9 +1523,9 @@ public class MethodHandlesTest {
         List argsToFold = expected.subList(pos, pos + fold);
         if (verbosity >= 3)
             System.out.println("fold: "+argsToFold+" into "+target2);
-        Object foldedArgs = combine.invokeVarargs(argsToFold);
+        Object foldedArgs = combine.invokeWithArguments(argsToFold);
         argsToFold.add(0, foldedArgs);
-        Object result = target2.invokeVarargs(argsToPass);
+        Object result = target2.invokeWithArguments(argsToPass);
         if (verbosity >= 3)
             System.out.println("result: "+result);
         if (!expected.equals(result))
@@ -1516,7 +1557,7 @@ public class MethodHandlesTest {
         for (int i = drop; i > 0; i--) {
             argsToDrop.add(pos, "blort#"+i);
         }
-        Object res2 = target2.invokeVarargs(argsToDrop);
+        Object res2 = target2.invokeWithArguments(argsToDrop);
         Object res2List = Arrays.asList((Object[])res2);
         //if (!resList.equals(res2List))
         //    System.out.println("*** fail at n/p/d = "+nargs+"/"+pos+"/"+drop+": "+argsToDrop+" => "+res2List);
@@ -1572,7 +1613,7 @@ public class MethodHandlesTest {
         countTest();
         calledLog.clear();
         inv = MethodHandles.exactInvoker(type);
-        result = inv.invokeVarargs(targetPlusArgs);
+        result = inv.invokeWithArguments(targetPlusArgs);
         if (testRetCode)  assertEquals(code, result);
         assertCalled("invokee", args);
         // generic invoker
@@ -1598,7 +1639,7 @@ public class MethodHandlesTest {
             assertCalled("invokee", args);
         }
         calledLog.clear();
-        result = inv.invokeVarargs(targetPlusArgs);
+        result = inv.invokeWithArguments(targetPlusArgs);
         if (testRetCode)  assertEquals(code, result);
         assertCalled("invokee", args);
         // varargs invoker #0
@@ -1640,17 +1681,29 @@ public class MethodHandlesTest {
             List tailList = targetPlusVarArgs.subList(1+k, 1+nargs);
             Object[] tail = tailList.toArray();
             tailList.clear(); tailList.add(tail);
-            result = inv.invokeVarargs(targetPlusVarArgs);
+            result = inv.invokeWithArguments(targetPlusVarArgs);
             if (testRetCode)  assertEquals(code, result);
             assertCalled("invokee", args);
         }
+
         // dynamic invoker
         countTest();
-        CallSite site = new CallSite(MethodHandlesTest.class, "foo", type);
-        inv = MethodHandles.dynamicInvoker(site);
+        CallSite site = new MutableCallSite(type);
+        inv = site.dynamicInvoker();
+
+        // see if we get the result of the original target:
+        try {
+            result = inv.invokeWithArguments(args);
+            assertTrue("should not reach here", false);
+        } catch (IllegalStateException ex) {
+            String msg = ex.getMessage();
+            assertTrue(msg, msg.contains("site"));
+        }
+
+        // set new target after invoker is created, to make sure we track target
         site.setTarget(target);
         calledLog.clear();
-        result = inv.invokeVarargs(args);
+        result = inv.invokeWithArguments(args);
         if (testRetCode)  assertEquals(code, result);
         assertCalled("invokee", args);
     }
@@ -1734,7 +1787,7 @@ public class MethodHandlesTest {
             String willCall = (equals ? "targetIfEquals" : "fallbackIfNotEquals");
             if (verbosity >= 3)
                 System.out.println(logEntry(willCall, argList));
-            Object result = mh.invokeVarargs(argList);
+            Object result = mh.invokeWithArguments(argList);
             assertCalled(willCall, argList);
         }
     }
@@ -1767,16 +1820,17 @@ public class MethodHandlesTest {
         MethodHandle throwOrReturn
                 = PRIVATE.findStatic(MethodHandlesTest.class, "throwOrReturn",
                     MethodType.methodType(Object.class, Object.class, Throwable.class));
-        MethodHandle thrower = throwOrReturn;
+        MethodHandle thrower = throwOrReturn.asType(MethodType.genericMethodType(2));
         while (thrower.type().parameterCount() < nargs)
             thrower = MethodHandles.dropArguments(thrower, thrower.type().parameterCount(), Object.class);
+        MethodHandle catcher = ValueConversions.varargsList(1+nargs).asType(MethodType.genericMethodType(1+nargs));
         MethodHandle target = MethodHandles.catchException(thrower,
-                thrown.getClass(), ValueConversions.varargsList(1+nargs));
+                thrown.getClass(), catcher);
         assertEquals(thrower.type(), target.type());
         //System.out.println("catching with "+target+" : "+throwOrReturn);
         Object[] args = randomArgs(nargs, Object.class);
         args[1] = (throwIt ? thrown : null);
-        Object returned = target.invokeVarargs(args);
+        Object returned = target.invokeWithArguments(args);
         //System.out.println("return from "+target+" : "+returned);
         if (!throwIt) {
             assertSame(args[0], returned);
@@ -1828,13 +1882,10 @@ public class MethodHandlesTest {
         testCastFailure("unbox/return", 11000);
     }
 
-    static class Surprise implements MethodHandleProvider {
+    static class Surprise {
         public MethodHandle asMethodHandle() {
             return VALUE.bindTo(this);
         }
-        public MethodHandle asMethodHandle(MethodType type) {
-            return asMethodHandle().asType(type);
-        }
         Object value(Object x) {
             trace("value", x);
             if (boo != null)  return boo;
@@ -1896,8 +1947,8 @@ public class MethodHandlesTest {
             }
             if (callee != null) {
                 callee = MethodHandles.convertArguments(callee, MethodType.genericMethodType(1));
-                surprise = MethodHandles.filterArguments(callee, surprise);
-                identity = MethodHandles.filterArguments(callee, identity);
+                surprise = MethodHandles.filterArguments(callee, 0, surprise);
+                identity = MethodHandles.filterArguments(callee, 0, identity);
             }
         }
         assertNotSame(mode, surprise, surprise0);
@@ -1949,7 +2000,7 @@ public class MethodHandlesTest {
         assertEquals(mt, mh.type());
         assertEquals(Example.class, mh.type().returnType());
         args = randomArgs(mh.type().parameterArray());
-        mh.invokeVarargs(args);
+        mh.invokeWithArguments(args);
         assertCalled(name, args);
 
         // Try a virtual method.
@@ -1959,7 +2010,7 @@ public class MethodHandlesTest {
         assertEquals(mt, mh.type().dropParameterTypes(0,1));
         assertTrue(mh.type().parameterList().contains(Example.class));
         args = randomArgs(mh.type().parameterArray());
-        mh.invokeVarargs(args);
+        mh.invokeWithArguments(args);
         assertCalled(name, args);
     }
 
diff --git a/jdk/test/java/dyn/indify/Indify.java b/jdk/test/java/dyn/indify/Indify.java
new file mode 100644
index 0000000000000000000000000000000000000000..0896f0e0a434fc8de4583e776f6dde5172076898
--- /dev/null
+++ b/jdk/test/java/dyn/indify/Indify.java
@@ -0,0 +1,1861 @@
+/*
+ * Copyright (c) 2010, 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 indify;
+
+import java.util.*;
+import java.io.*;
+import java.lang.reflect.Modifier;
+import java.util.regex.*;
+
+/**
+ * Transform one or more class files to incorporate JSR 292 features,
+ * such as {@code invokedynamic}.
+ * 
      
+ * This is a standalone program in a single source file.
+ * In this form, it may be useful for test harnesses, small experiments, and javadoc examples.
+ * Copies of this file may show up in multiple locations for standalone usage.
+ * The primary maintained location of this file is as follows:
+ * 
+ * http://kenai.com/projects/ninja/sources/indify-repo/content/src/indify/Indify.java
+ * 
      
+ * Static private methods named MH_x and MT_x (where x is arbitrary)
+ * must be stereotyped generators of MethodHandle and MethodType
+ * constants.  All calls to them are transformed to {@code CONSTANT_MethodHandle}
+ * and {@code CONSTANT_MethodType} "ldc" instructions.
+ * The stereotyped code must create method types by calls to {@code methodType} or
+ * {@code fromMethodDescriptorString}.  The "lookup" argument must be created
+ * by calls to {@code java.dyn.MethodHandles#lookup MethodHandles.lookup}.
+ * The class and string arguments must be constant.
+ * The following methods of {@code java.dyn.MethodHandle.Lookup Lookup} are
+ * allowed for method handle creation: {@code findStatic}, {@code findVirtual},
+ * {@code findConstructor}, {@code findSpecial},
+ * {@code findGetter}, {@code findSetter},
+ * {@code findStaticGetter}, or {@code findStaticSetter}.
+ * The call to one of these methods must be followed immediately
+ * by an {@code areturn} instruction.
+ * The net result of the call to the MH_x or MT_x method must be
+ * the creation of a constant method handle.  Thus, replacing calls
+ * to MH_x or MT_x methods by {@code ldc} instructions should leave
+ * the meaning of the program unchanged.
+ * 
      
+ * Static private methods named INDY_x must be stereotyped generators
+ * of {@code invokedynamic} call sites.
+ * All calls to them must be immediately followed by
+ * {@code invokeExact} calls.
+ * All such pairs of calls are transformed to {@code invokedynamic}
+ * instructions.  Each INDY_x method must begin with a call to a
+ * MH_x method, which is taken to be its bootstrap method.
+ * The method must be immediately invoked (via {@code invokeGeneric}
+ * on constant lookup, name, and type arguments.  An object array of
+ * constants may also be appended to the {@code invokeGeneric call}.
+ * This call must be cast to {@code CallSite}, and the result must be
+ * immediately followed by a call to {@code dynamicInvoker}, with the
+ * resulting method handle returned.
+ * 
      
+ * The net result of all of these actions is equivalent to the JVM's
+ * execution of an {@code invokedynamic} instruction in the unlinked state.
+ * Running this code once should produce the same results as running
+ * the corresponding {@code invokedynamic} instruction.
+ * In order to model the caching behavior, the code of an INDY_x
+ * method is allowed to begin with getstatic, aaload, and if_acmpne
+ * instructions which load a static method handle value and return it
+ * if the value is non-null.
+ * 
      
+ * Example usage:
+ * 
      +$ JAVA_HOME=(some recent OpenJDK 7 build)
+$ ant
+$ $JAVA_HOME/bin/java -cp build/classes indify.Indify --overwrite --dest build/testout build/classes/indify/Example.class
+$ $JAVA_HOME/bin/java -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic -cp build/classes indify.Example
+MT = (java.lang.Object)java.lang.Object
+MH = adder(int,int)java.lang.Integer
+adder(1,2) = 3
+calling indy:  42
+$ $JAVA_HOME/bin/java -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic -cp build/testout indify.Example
+(same output as above)
+ * 
      
+ * 
      
+ * Until the format of {@code CONSTANT_InvokeDynamic} entries is finalized,
+ * the {@code --transitionalJSR292} switch is recommended (and turned on by default).
+ * 
      
+ * A version of this transformation built on top of http://asm.ow2.org/ would be welcome.
+ * @author John Rose
+ */
+public class Indify {
+    public static void main(String... av) throws IOException {
+        new Indify().run(av);
+    }
+
+    public File dest;
+    public String[] classpath = {"."};
+    public boolean keepgoing = false;
+    public boolean expandProperties = false;
+    public boolean overwrite = false;
+    public boolean quiet = false;
+    public boolean verbose = false;
+    public boolean transitionalJSR292 = true;  // default to false later
+    public boolean all = false;
+    public int verifySpecifierCount = -1;
+
+    public void run(String... av) throws IOException {
+        List avl = new ArrayList<>(Arrays.asList(av));
+        parseOptions(avl);
+        if (avl.isEmpty())
+            throw new IllegalArgumentException("Usage: indify [--dest dir] [option...] file...");
+        if ("--java".equals(avl.get(0))) {
+            avl.remove(0);
+            try {
+                runApplication(avl.toArray(new String[0]));
+            } catch (Exception ex) {
+                if (ex instanceof RuntimeException)  throw (RuntimeException) ex;
+                throw new RuntimeException(ex);
+            }
+            return;
+        }
+        Exception err = null;
+        for (String a : avl) {
+            try {
+                indify(a);
+            } catch (Exception ex) {
+                if (err == null)  err = ex;
+                System.err.println("failure on "+a);
+                if (!keepgoing)  break;
+            }
+        }
+        if (err != null) {
+            if (err instanceof IOException)  throw (IOException) err;
+            throw (RuntimeException) err;
+        }
+    }
+
+    /** Execute the given application under a class loader which indifies all application classes. */
+    public void runApplication(String... av) throws Exception {
+        List avl = new ArrayList<>(Arrays.asList(av));
+        String mainClassName = avl.remove(0);
+        av = avl.toArray(new String[0]);
+        Class mainClass = Class.forName(mainClassName, true, makeClassLoader());
+        java.lang.reflect.Method main = mainClass.getMethod("main", String[].class);
+        main.invoke(null, (Object) av);
+    }
+
+    public void parseOptions(List av) throws IOException {
+        for (; !av.isEmpty(); av.remove(0)) {
+            String a = av.get(0);
+            if (a.startsWith("-")) {
+                String a2 = null;
+                int eq = a.indexOf('=');
+                if (eq > 0) {
+                    a2 = maybeExpandProperties(a.substring(eq+1));
+                    a = a.substring(0, eq+1);
+                }
+                switch (a) {
+                case "--java":
+                    return;  // keep this argument
+                case "-d": case "--dest": case "-d=": case "--dest=":
+                    dest = new File(a2 != null ? a2 : maybeExpandProperties(av.remove(1)));
+                    break;
+                case "-cp": case "--classpath":
+                    classpath = maybeExpandProperties(av.remove(1)).split("["+File.pathSeparatorChar+"]");
+                    break;
+                case "-k": case "--keepgoing": case "--keepgoing=":
+                    keepgoing = booleanOption(a2);  // print errors but keep going
+                    break;
+                case "--expand-properties": case "--expand-properties=":
+                    expandProperties = booleanOption(a2);  // expand property references in subsequent arguments
+                    break;
+                case "--verify-specifier-count": case "--verify-specifier-count=":
+                    verifySpecifierCount = Integer.valueOf(a2);
+                    break;
+                case "--overwrite": case "--overwrite=":
+                    overwrite = booleanOption(a2);  // overwrite output files
+                    break;
+                case "--all": case "--all=":
+                    all = booleanOption(a2);  // copy all classes, even if no patterns
+                    break;
+                case "-q": case "--quiet": case "--quiet=":
+                    quiet = booleanOption(a2);  // less output
+                    break;
+                case "-v": case "--verbose": case "--verbose=":
+                    verbose = booleanOption(a2);  // more output
+                    break;
+                case "--transitionalJSR292": case "--transitionalJSR292=":
+                    transitionalJSR292 = booleanOption(a2);  // use older invokedynamic format
+                    break;
+                default:
+                    throw new IllegalArgumentException("unrecognized flag: "+a);
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
+        if (dest == null && !overwrite)
+            throw new RuntimeException("no output specified; need --dest d or --overwrite");
+        if (expandProperties) {
+            for (int i = 0; i < av.size(); i++)
+                av.set(i, maybeExpandProperties(av.get(i)));
+        }
+    }
+
+    private boolean booleanOption(String s) {
+        if (s == null)  return true;
+        switch (s) {
+        case "true":  case "yes": case "1": return true;
+        case "false": case "no":  case "0": return false;
+        }
+        throw new IllegalArgumentException("unrecognized boolean flag="+s);
+    }
+
+    private String maybeExpandProperties(String s) {
+        if (!expandProperties)  return s;
+        Set propsDone = new HashSet<>();
+        while (s.contains("${")) {
+            int lbrk = s.indexOf("${");
+            int rbrk = s.indexOf('}', lbrk);
+            if (rbrk < 0)  break;
+            String prop = s.substring(lbrk+2, rbrk);
+            if (!propsDone.add(prop))  break;
+            String value = System.getProperty(prop);
+            if (verbose)  System.err.println("expanding ${"+prop+"} => "+value);
+            if (value == null)  break;
+            s = s.substring(0, lbrk) + value + s.substring(rbrk+1);
+        }
+        return s;
+    }
+
+    public void indify(String a) throws IOException {
+        File f = new File(a);
+        String fn = f.getName();
+        if (fn.endsWith(".class") && f.isFile())
+            indifyFile(f, dest);
+        else if (fn.endsWith(".jar") && f.isFile())
+            indifyJar(f, dest);
+        else if (f.isDirectory())
+            indifyTree(f, dest);
+        else if (!keepgoing)
+            throw new RuntimeException("unrecognized file: "+a);
+    }
+
+    private void ensureDirectory(File dir) {
+        if (dir.mkdirs() && !quiet)
+            System.err.println("created "+dir);
+    }
+
+    public void indifyFile(File f, File dest) throws IOException {
+        if (verbose)  System.err.println("reading "+f);
+        ClassFile cf = new ClassFile(f);
+        Logic logic = new Logic(cf);
+        boolean changed = logic.transform();
+        logic.reportPatternMethods(quiet, keepgoing);
+        if (changed || all) {
+            File outfile;
+            if (dest != null) {
+                ensureDirectory(dest);
+                outfile = classPathFile(dest, cf.nameString());
+            } else {
+                outfile = f;  // overwrite input file, no matter where it is
+            }
+            cf.writeTo(outfile);
+            if (!quiet)  System.err.println("wrote "+outfile);
+        }
+    }
+
+    File classPathFile(File pathDir, String className) {
+        String qualname = className+".class";
+        qualname = qualname.replace('/', File.separatorChar);
+        return new File(pathDir, qualname);
+    }
+
+    public void indifyJar(File f, Object dest) throws IOException {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    public void indifyTree(File f, File dest) throws IOException {
+        if (verbose)  System.err.println("reading directory: "+f);
+        for (File f2 : f.listFiles(new FilenameFilter() {
+                public boolean accept(File dir, String name) {
+                    if (name.endsWith(".class"))  return true;
+                    if (name.contains("."))  return false;
+                    // return true if it might be a package name:
+                    return Character.isJavaIdentifierStart(name.charAt(0));
+                }})) {
+            if (f2.getName().endsWith(".class"))
+                indifyFile(f2, dest);
+            else if (f2.isDirectory())
+                indifyTree(f2, dest);
+        }
+    }
+
+    public ClassLoader makeClassLoader() {
+        return new Loader();
+    }
+    private class Loader extends ClassLoader {
+        Loader() {
+            this(Indify.class.getClassLoader());
+        }
+        Loader(ClassLoader parent) {
+            super(parent);
+        }
+        public Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
+            File f = findClassInPath(name);
+            if (f != null) {
+                try {
+                    Class c = transformAndLoadClass(f);
+                    if (c != null) {
+                        if (resolve)  resolveClass(c);
+                        return c;
+                    }
+                } catch (Exception ex) {
+                    if (ex instanceof IllegalArgumentException)
+                        // pass error from reportPatternMethods
+                        throw (IllegalArgumentException) ex;
+                }
+            }
+            return super.loadClass(name, resolve);
+        }
+        private File findClassInPath(String name) {
+            for (String s : classpath) {
+                File f = classPathFile(new File(s), name);
+                if (f.exists() && f.canRead()) {
+                    return f;
+                }
+            }
+            return null;
+        }
+        protected Class findClass(String name) throws ClassNotFoundException {
+            try {
+                return transformAndLoadClass(findClassInPath(name));
+            } catch (IOException ex) {
+                throw new ClassNotFoundException("IO error", ex);
+            }
+        }
+        private Class transformAndLoadClass(File f) throws ClassNotFoundException, IOException {
+            if (verbose)  System.out.println("Loading class from "+f);
+            ClassFile cf = new ClassFile(f);
+            Logic logic = new Logic(cf);
+            boolean changed = logic.transform();
+            if (verbose && !changed)  System.out.println("(no change)");
+            logic.reportPatternMethods(!verbose, keepgoing);
+            byte[] bytes = cf.toByteArray();
+            return defineClass(null, bytes, 0, bytes.length);
+        }
+    }
+
+    private class Logic {
+        // Indify logic, per se.
+        ClassFile cf;
+        final char[] poolMarks;
+        final Map constants = new HashMap<>();
+        final Map indySignatures = new HashMap<>();
+        Logic(ClassFile cf) {
+            this.cf = cf;
+            poolMarks = new char[cf.pool.size()];
+        }
+        boolean transform() {
+            if (!initializeMarks())  return false;
+            if (!findPatternMethods())  return false;
+            Pool pool = cf.pool;
+            //for (Constant c : cp)  System.out.println("  # "+c);
+            for (Method m : cf.methods) {
+                if (constants.containsKey(m))  continue;  // don't bother
+                // Transform references.
+                int blab = 0;
+                for (Instruction i = m.instructions(); i != null; i = i.next()) {
+                    if (i.bc != opc_invokestatic)  continue;
+                    int methi = i.u2At(1);
+                    if (poolMarks[methi] == 0)  continue;
+                    Short[] ref = pool.getMemberRef((short)methi);
+                    Method conm = findMember(cf.methods, ref[1], ref[2]);
+                    if (conm == null)  continue;
+                    Constant con = constants.get(conm);
+                    if (con == null)  continue;
+                    if (blab++ == 0 && !quiet)
+                        System.err.println("patching "+cf.nameString()+"."+m);
+                    //if (blab == 1) { for (Instruction j = m.instructions(); j != null; j = j.next()) System.out.println("  |"+j); }
+                    if (con.tag == CONSTANT_InvokeDynamic ||
+                        con.tag == CONSTANT_InvokeDynamic_17) {
+                        // need to patch the following instruction too,
+                        // but there are usually intervening argument pushes too
+                        Instruction i2 = findPop(i);
+                        Short[] ref2 = null;
+                        short ref2i = 0;
+                        if (i2 != null && i2.bc == opc_invokevirtual &&
+                                poolMarks[(char)(ref2i = (short) i2.u2At(1))] == 'D')
+                            ref2 = pool.getMemberRef(ref2i);
+                        if (ref2 == null || !"invokeExact".equals(pool.getString(ref2[1]))) {
+                            System.err.println(m+": failed to create invokedynamic at "+i.pc);
+                            continue;
+                        }
+                        String invType = pool.getString(ref2[2]);
+                        String bsmType = indySignatures.get(conm);
+                        if (!invType.equals(bsmType)) {
+                            System.err.println(m+": warning: "+conm+" call type and local invoke type differ: "
+                                    +bsmType+", "+invType);
+                        }
+                        assert(i.len == 3 || i2.len == 3);
+                        if (!quiet)  System.err.println(i+" "+conm+";...; "+i2+" => invokedynamic "+con);
+                        int start = i.pc + 3, end = i2.pc;
+                        System.arraycopy(i.codeBase, start, i.codeBase, i.pc, end-start);
+                        i.forceNext(0);  // force revisit of new instruction
+                        i2.u1AtPut(-3, opc_invokedynamic);
+                        i2.u2AtPut(-2, con.index);
+                        i2.u2AtPut(0, (short)0);
+                        i2.u1AtPut(2, opc_nop);
+                        //System.out.println(new Instruction(i.codeBase, i2.pc-3));
+                    } else {
+                        if (!quiet)  System.err.println(i+" "+conm+" => ldc "+con);
+                        assert(i.len == 3);
+                        i.u1AtPut(0, opc_ldc_w);
+                        i.u2AtPut(1, con.index);
+                    }
+                }
+                //if (blab >= 1) { for (Instruction j = m.instructions(); j != null; j = j.next()) System.out.println("    |"+j); }
+            }
+            cf.methods.removeAll(constants.keySet());
+            return true;
+        }
+
+        // Scan forward from the instruction to find where the stack p
+        // below the current sp at the instruction.
+        Instruction findPop(Instruction i) {
+            //System.out.println("findPop from "+i);
+            Pool pool = cf.pool;
+            JVMState jvm = new JVMState();
+        decode:
+            for (i = i.clone().next(); i != null; i = i.next()) {
+                String pops = INSTRUCTION_POPS[i.bc];
+                //System.out.println("  "+i+" "+jvm.stack+" : "+pops.replace("$", " => "));
+                if (pops == null)  break;
+                if (jvm.stackMotion(i.bc))  continue decode;
+                if (pops.indexOf('Q') >= 0) {
+                    Short[] ref = pool.getMemberRef((short) i.u2At(1));
+                    String type = simplifyType(pool.getString(CONSTANT_Utf8, ref[2]));
+                    switch (i.bc) {
+                    case opc_getstatic:
+                    case opc_getfield:
+                    case opc_putstatic:
+                    case opc_putfield:
+                        pops = pops.replace("Q", type);
+                        break;
+                    default:
+                        if (!type.startsWith("("))
+                            throw new InternalError(i.toString());
+                        pops = pops.replace("Q$Q", type.substring(1).replace(")","$"));
+                        break;
+                    }
+                    //System.out.println("special type: "+type+" => "+pops);
+                }
+                int npops = pops.indexOf('$');
+                if (npops < 0)  throw new InternalError();
+                if (npops > jvm.sp())  return i;
+                List args = jvm.args(npops);
+                int k = 0;
+                for (Object x : args) {
+                    char have = (Character) x;
+                    char want = pops.charAt(k++);
+                    if (have == 'X' || want == 'X')  continue;
+                    if (have != want)  break decode;
+                }
+                if (pops.charAt(k++) != '$')  break decode;
+                args.clear();
+                while (k < pops.length())
+                    args.add(pops.charAt(k++));
+            }
+            System.err.println("*** bailout on jvm: "+jvm.stack+" "+i);
+            return null;
+        }
+
+        boolean findPatternMethods() {
+            boolean found = false;
+            for (char mark : "THI".toCharArray()) {
+                for (Method m : cf.methods) {
+                    if (!Modifier.isPrivate(m.access))  continue;
+                    if (!Modifier.isStatic(m.access))  continue;
+                    if (nameAndTypeMark(m.name, m.type) == mark) {
+                        Constant con = scanPattern(m, mark);
+                        if (con == null)  continue;
+                        constants.put(m, con);
+                        found = true;
+                    }
+                }
+            }
+            return found;
+        }
+
+        void reportPatternMethods(boolean quietly, boolean allowMatchFailure) {
+            if (!quietly && !constants.keySet().isEmpty())
+                System.err.println("pattern methods removed: "+constants.keySet());
+            for (Method m : cf.methods) {
+                if (nameMark(cf.pool.getString(m.name)) != 0 &&
+                    constants.get(m) == null) {
+                    String failure = "method has special name but fails to match pattern: "+m;
+                    if (!allowMatchFailure)
+                        throw new IllegalArgumentException(failure);
+                    else if (!quietly)
+                        System.err.println("warning: "+failure);
+                }
+            }
+            if (verifySpecifierCount >= 0) {
+                List specs = bootstrapMethodSpecifiers(false);
+                int specsLen = (specs == null ? 0 : specs.size());
+                if (specsLen != verifySpecifierCount) {
+                    throw new IllegalArgumentException("BootstrapMethods length is "+specsLen+" but should be "+verifySpecifierCount);
+                }
+            }
+        }
+
+        // mark constant pool entries according to participation in patterns
+        boolean initializeMarks() {
+            boolean changed = false;
+            for (;;) {
+                boolean changed1 = false;
+                int cpindex = -1;
+                for (Constant e : cf.pool) {
+                    ++cpindex;
+                    if (e == null)  continue;
+                    char mark = poolMarks[cpindex];
+                    if (mark != 0)  continue;
+                    switch (e.tag) {
+                    case CONSTANT_Utf8:
+                        mark = nameMark(e.itemString()); break;
+                    case CONSTANT_NameAndType:
+                        mark = nameAndTypeMark(e.itemIndexes()); break;
+                    case CONSTANT_Class: {
+                        int n1 = e.itemIndex();
+                        char nmark = poolMarks[(char)n1];
+                        if ("DJ".indexOf(nmark) >= 0)
+                            mark = nmark;
+                        break;
+                    }
+                    case CONSTANT_Field:
+                    case CONSTANT_Method: {
+                        Short[] n12 = e.itemIndexes();
+                        short cl = n12[0];
+                        short nt = n12[1];
+                        char cmark = poolMarks[(char)cl];
+                        if (cmark != 0) {
+                            mark = cmark;  // it is a java.dyn.* or java.lang.* method
+                            break;
+                        }
+                        String cls = cf.pool.getString(CONSTANT_Class, cl);
+                        if (cls.equals(cf.nameString())) {
+                            switch (poolMarks[(char)nt]) {
+                            // it is a private MH/MT/INDY method
+                            case 'T': case 'H': case 'I':
+                                mark = poolMarks[(char)nt];
+                                break;
+                            }
+                        }
+                        break;
+                    }
+                    default:  break;
+                    }
+                    if (mark != 0) {
+                        poolMarks[cpindex] = mark;
+                        changed1 = true;
+                    }
+                }
+                if (!changed1)
+                    break;
+                changed = true;
+            }
+            return changed;
+        }
+        char nameMark(String s) {
+            if (s.startsWith("MT_"))                return 'T';
+            else if (s.startsWith("MH_"))           return 'H';
+            else if (s.startsWith("INDY_"))         return 'I';
+            else if (s.startsWith("java/dyn/"))     return 'D';
+            else if (s.startsWith("java/lang/"))    return 'J';
+            return 0;
+        }
+        char nameAndTypeMark(Short[] n12) {
+            return nameAndTypeMark(n12[0], n12[1]);
+        }
+        char nameAndTypeMark(short n1, short n2) {
+            char mark = poolMarks[(char)n1];
+            if (mark == 0)  return 0;
+            String descr = cf.pool.getString(CONSTANT_Utf8, n2);
+            String requiredType;
+            switch (poolMarks[(char)n1]) {
+            case 'H': requiredType = "()Ljava/dyn/MethodHandle;";  break;
+            case 'T': requiredType = "()Ljava/dyn/MethodType;";    break;
+            case 'I': requiredType = "()Ljava/dyn/MethodHandle;";  break;
+            default:  return 0;
+            }
+            if (descr.equals(requiredType))  return mark;
+            return 0;
+        }
+
+        private class JVMState {
+            final List stack = new ArrayList<>();
+            int sp() { return stack.size(); }
+            void push(Object x) { stack.add(x); }
+            void push2(Object x) { stack.add(EMPTY_SLOT); stack.add(x); }
+            void pushAt(int pos, Object x) { stack.add(stack.size()+pos, x); }
+            Object pop() { return stack.remove(sp()-1); }
+            Object top() { return stack.get(sp()-1); }
+            List args(boolean hasRecv, String type) {
+                return args(argsize(type) + (hasRecv ? 1 : 0));
+            }
+            List args(int argsize) {
+                return stack.subList(sp()-argsize, sp());
+            }
+            boolean stackMotion(int bc) {
+                switch (bc) {
+                case opc_pop:    pop();             break;
+                case opc_pop2:   pop(); pop();      break;
+                case opc_swap:   pushAt(-1, pop()); break;
+                case opc_dup:    push(top());       break;
+                case opc_dup_x1: pushAt(-2, top()); break;
+                case opc_dup_x2: pushAt(-3, top()); break;
+                // ? also: dup2{,_x1,_x2}
+                default:  return false;
+                }
+                return true;
+            }
+        }
+        private final String EMPTY_SLOT = "_";
+        private void removeEmptyJVMSlots(List args) {
+            for (;;) {
+                int i = args.indexOf(EMPTY_SLOT);
+                if (i >= 0 && i+1 < args.size()
+                    && (isConstant(args.get(i+1), CONSTANT_Long) ||
+                        isConstant(args.get(i+1), CONSTANT_Double)))
+                    args.remove(i);
+                else  break;
+            }
+        }
+
+        private Constant scanPattern(Method m, char patternMark) {
+            if (verbose)  System.err.println("scan "+m+" for pattern="+patternMark);
+            int wantTag;
+            switch (patternMark) {
+            case 'T': wantTag = CONSTANT_MethodType; break;
+            case 'H': wantTag = CONSTANT_MethodHandle; break;
+            case 'I': wantTag = CONSTANT_InvokeDynamic; break;
+            default: throw new InternalError();
+            }
+            Instruction i = m.instructions();
+            JVMState jvm = new JVMState();
+            Pool pool = cf.pool;
+            int branchCount = 0;
+            Object arg;
+            List args;
+            List bsmArgs = null;  // args to invokeGeneric
+        decode:
+            for (; i != null; i = i.next()) {
+                //System.out.println(jvm.stack+" "+i);
+                int bc = i.bc;
+                switch (bc) {
+                case opc_ldc:           jvm.push(pool.get(i.u1At(1)));   break;
+                case opc_ldc_w:         jvm.push(pool.get(i.u2At(1)));   break;
+                case opc_ldc2_w:        jvm.push2(pool.get(i.u2At(1)));  break;
+                case opc_aconst_null:   jvm.push(null);                  break;
+                case opc_bipush:        jvm.push((int)(byte) i.u1At(1)); break;
+                case opc_sipush:        jvm.push((int)(short)i.u2At(1)); break;
+
+                // these support creation of a restarg array
+                case opc_anewarray:
+                    arg = jvm.pop();
+                    if (!(arg instanceof Integer))  break decode;
+                    arg = Arrays.asList(new Object[(Integer)arg]);
+                    jvm.push(arg);
+                    break;
+                case opc_dup:
+                    jvm.push(jvm.top()); break;
+                case opc_aastore:
+                    args = jvm.args(3);  // array, index, value
+                    if (args.get(0) instanceof List &&
+                        args.get(1) instanceof Integer) {
+                        ((List)args.get(0)).set( (Integer)args.get(1), args.get(2) );
+                    }
+                    args.clear();
+                    break;
+
+                case opc_getstatic:
+                {
+                    // int.class compiles to getstatic Integer.TYPE
+                    int fieldi = i.u2At(1);
+                    char mark = poolMarks[fieldi];
+                    //System.err.println("getstatic "+fieldi+Arrays.asList(pool.getStrings(pool.getMemberRef((short)fieldi)))+mark);
+                    if (mark == 'J') {
+                        Short[] ref = pool.getMemberRef((short) fieldi);
+                        String name = pool.getString(CONSTANT_Utf8, ref[1]);
+                        if ("TYPE".equals(name)) {
+                            String wrapperName = pool.getString(CONSTANT_Class, ref[0]).replace('/', '.');
+                            // a primitive type descriptor
+                            Class primClass;
+                            try {
+                                primClass = (Class) Class.forName(wrapperName).getField(name).get(null);
+                            } catch (Exception ex) {
+                                throw new InternalError("cannot load "+wrapperName+"."+name);
+                            }
+                            jvm.push(primClass);
+                            break;
+                        }
+                    }
+                    // unknown field; keep going...
+                    jvm.push(UNKNOWN_CON);
+                    break;
+                }
+                case opc_putstatic:
+                {
+                    if (patternMark != 'I')  break decode;
+                    jvm.pop();
+                    // unknown field; keep going...
+                    break;
+                }
+
+                case opc_invokestatic:
+                case opc_invokevirtual:
+                {
+                    boolean hasRecv = (bc == opc_invokevirtual);
+                    int methi = i.u2At(1);
+                    char mark = poolMarks[methi];
+                    Short[] ref = pool.getMemberRef((short)methi);
+                    String type = pool.getString(CONSTANT_Utf8, ref[2]);
+                    //System.out.println("invoke "+pool.getString(CONSTANT_Utf8, ref[1])+" "+Arrays.asList(ref)+" : "+type);
+                    args = jvm.args(hasRecv, type);
+                    String intrinsic = null;
+                    Constant con;
+                    if (mark == 'D' || mark == 'J') {
+                        intrinsic = pool.getString(CONSTANT_Utf8, ref[1]);
+                        if (mark == 'J') {
+                            String cls = pool.getString(CONSTANT_Class, ref[0]);
+                            cls = cls.substring(1+cls.lastIndexOf('/'));
+                            intrinsic = cls+"."+intrinsic;
+                        }
+                        //System.out.println("recognized intrinsic "+intrinsic);
+                        byte refKind = -1;
+                        switch (intrinsic) {
+                        case "findGetter":          refKind = REF_getField;         break;
+                        case "findStaticGetter":    refKind = REF_getStatic;        break;
+                        case "findSetter":          refKind = REF_putField;         break;
+                        case "findStaticSetter":    refKind = REF_putStatic;        break;
+                        case "findVirtual":         refKind = REF_invokeVirtual;    break;
+                        case "findStatic":          refKind = REF_invokeStatic;     break;
+                        case "findSpecial":         refKind = REF_invokeSpecial;    break;
+                        case "findConstructor":     refKind = REF_newInvokeSpecial; break;
+                        }
+                        if (refKind >= 0 && (con = parseMemberLookup(refKind, args)) != null) {
+                            args.clear(); args.add(con);
+                            continue;
+                        }
+                    }
+                    Method ownMethod = null;
+                    if (mark == 'T' || mark == 'H' || mark == 'I') {
+                        ownMethod = findMember(cf.methods, ref[1], ref[2]);
+                    }
+                    switch (intrinsic == null ? "" : intrinsic) {
+                    case "fromMethodDescriptorString":
+                        con = makeMethodTypeCon(args.get(0));
+                        args.clear(); args.add(con);
+                        continue;
+                    case "methodType": {
+                        flattenVarargs(args);  // there are several overloadings, some with varargs
+                        StringBuilder buf = new StringBuilder();
+                        String rtype = null;
+                        for (Object typeArg : args) {
+                            if (typeArg instanceof Class) {
+                                Class argClass = (Class) typeArg;
+                                if (argClass.isPrimitive()) {
+                                    char tchar;
+                                    switch (argClass.getName()) {
+                                    case "void":    tchar = 'V'; break;
+                                    case "boolean": tchar = 'Z'; break;
+                                    case "byte":    tchar = 'B'; break;
+                                    case "char":    tchar = 'C'; break;
+                                    case "short":   tchar = 'S'; break;
+                                    case "int":     tchar = 'I'; break;
+                                    case "long":    tchar = 'J'; break;
+                                    case "float":   tchar = 'F'; break;
+                                    case "double":  tchar = 'D'; break;
+                                    default:  throw new InternalError(argClass.toString());
+                                    }
+                                    buf.append(tchar);
+                                } else {
+                                    // should not happen, but...
+                                    buf.append('L').append(argClass.getName().replace('.','/')).append(';');
+                                }
+                            } else if (typeArg instanceof Constant) {
+                                Constant argCon = (Constant) typeArg;
+                                if (argCon.tag == CONSTANT_Class) {
+                                    String cn = pool.get(argCon.itemIndex()).itemString();
+                                    if (cn.endsWith(";"))
+                                        buf.append(cn);
+                                    else
+                                        buf.append('L').append(cn).append(';');
+                                } else {
+                                    break decode;
+                                }
+                            } else {
+                                break decode;
+                            }
+                            if (rtype == null) {
+                                // first arg is treated differently
+                                rtype = buf.toString();
+                                buf.setLength(0);
+                                buf.append('(');
+                            }
+                        }
+                        buf.append(')').append(rtype);
+                        con = con = makeMethodTypeCon(buf.toString());
+                        args.clear(); args.add(con);
+                        continue;
+                    }
+                    case "lookup":
+                    case "dynamicInvoker":
+                        args.clear(); args.add(intrinsic);
+                        continue;
+                    case "lookupClass":
+                        if (args.equals(Arrays.asList("lookup"))) {
+                            // fold lookup().lookupClass() to the enclosing class
+                            args.clear(); args.add(pool.get(cf.thisc));
+                            continue;
+                        }
+                        break;
+                    case "invokeGeneric":
+                    case "invokeWithArguments":
+                        if (patternMark != 'I')  break decode;
+                        if ("invokeWithArguments".equals(intrinsic))
+                            flattenVarargs(args);
+                        bsmArgs = new ArrayList(args);
+                        args.clear(); args.add("invokeGeneric");
+                        continue;
+                    case "Integer.valueOf":
+                    case "Float.valueOf":
+                    case "Long.valueOf":
+                    case "Double.valueOf":
+                        removeEmptyJVMSlots(args);
+                        if (args.size() == 1) {
+                            arg = args.remove(0);
+                            assert(3456 == (CONSTANT_Integer*1000 + CONSTANT_Float*100 + CONSTANT_Long*10 + CONSTANT_Double));
+                            if (isConstant(arg, CONSTANT_Integer + "IFLD".indexOf(intrinsic.charAt(0)))
+                                || arg instanceof Number) {
+                                args.add(arg); continue;
+                            }
+                        }
+                        break decode;
+                    }
+                    if (!hasRecv && ownMethod != null && patternMark != 0) {
+                        con = constants.get(ownMethod);
+                        if (con == null)  break decode;
+                        args.clear(); args.add(con);
+                        continue;
+                    } else if (type.endsWith(")V")) {
+                        // allow calls like println("reached the pattern method")
+                        args.clear();
+                        continue;
+                    }
+                    break decode;  // bail out for most calls
+                }
+                case opc_areturn:
+                {
+                    ++branchCount;
+                    if (bsmArgs != null) {
+                        // parse bsmArgs as (MH, lookup, String, MT, [extra])
+                        Constant indyCon = makeInvokeDynamicCon(bsmArgs);
+                        if (indyCon != null) {
+                            Constant typeCon = (Constant) bsmArgs.get(3);
+                            indySignatures.put(m, pool.getString(typeCon.itemIndex()));
+                            return indyCon;
+                        }
+                        System.err.println(m+": inscrutable bsm arguments: "+bsmArgs);
+                        break decode;  // bail out
+                    }
+                    arg = jvm.pop();
+                    if (branchCount == 2 && UNKNOWN_CON.equals(arg))
+                        break;  // merge to next path
+                    if (isConstant(arg, wantTag))
+                        return (Constant) arg;
+                    break decode;  // bail out
+                }
+                default:
+                    if (jvm.stackMotion(i.bc))  break;
+                    if (bc >= opc_nconst_MIN && bc <= opc_nconst_MAX)
+                        { jvm.push(INSTRUCTION_CONSTANTS[bc - opc_nconst_MIN]); break; }
+                    if (patternMark == 'I') {
+                        // these support caching paths in INDY_x methods
+                        if (bc == opc_aload || bc >= opc_aload_0 && bc <= opc_aload_MAX)
+                            { jvm.push(UNKNOWN_CON); break; }
+                        if (bc == opc_astore || bc >= opc_astore_0 && bc <= opc_astore_MAX)
+                            { jvm.pop(); break; }
+                        switch (bc) {
+                        case opc_getfield:
+                        case opc_aaload:
+                            jvm.push(UNKNOWN_CON); break;
+                        case opc_ifnull:
+                        case opc_ifnonnull:
+                            // ignore branch target
+                            if (++branchCount != 1)  break decode;
+                            jvm.pop();
+                            break;
+                        case opc_checkcast:
+                            arg = jvm.top();
+                            if ("invokeWithArguments".equals(arg) ||
+                                "invokeGeneric".equals(arg))
+                                break;  // assume it is a helpful cast
+                            break decode;
+                        default:
+                            break decode;  // bail out
+                        }
+                        continue decode; // go to next instruction
+                    }
+                    break decode;  // bail out
+                } //end switch
+            }
+            System.err.println(m+": bailout on "+i+" jvm stack: "+jvm.stack);
+            return null;
+        }
+        private final String UNKNOWN_CON = "";
+
+        private void flattenVarargs(List args) {
+            int size = args.size();
+            if (size > 0 && args.get(size-1) instanceof List)
+                args.addAll((List) args.remove(size-1));
+        }
+
+        private boolean isConstant(Object x, int tag) {
+            return x instanceof Constant && ((Constant)x).tag == tag;
+        }
+        private Constant makeMethodTypeCon(Object x) {
+            short utfIndex;
+            if (x instanceof String)
+                utfIndex = (short) cf.pool.addConstant(CONSTANT_Utf8, x).index;
+            else if (isConstant(x, CONSTANT_String))
+                utfIndex = ((Constant)x).itemIndex();
+            else  return null;
+            return cf.pool.addConstant(CONSTANT_MethodType, utfIndex);
+        }
+        private Constant parseMemberLookup(byte refKind, List args) {
+            // E.g.: lookup().findStatic(Foo.class, "name", MethodType)
+            if (args.size() != 4)  return null;
+            int argi = 0;
+            if (!"lookup".equals(args.get(argi++)))  return null;
+            short refindex, cindex, ntindex, nindex, tindex;
+            Object con;
+            if (!isConstant(con = args.get(argi++), CONSTANT_Class))  return null;
+            cindex = (short)((Constant)con).index;
+            if (!isConstant(con = args.get(argi++), CONSTANT_String))  return null;
+            nindex = ((Constant)con).itemIndex();
+            if (isConstant(con = args.get(argi++), CONSTANT_MethodType) ||
+                isConstant(con, CONSTANT_Class)) {
+                tindex = ((Constant)con).itemIndex();
+            } else return null;
+            ntindex = (short) cf.pool.addConstant(CONSTANT_NameAndType,
+                    new Short[]{ nindex, tindex }).index;
+            byte reftag = CONSTANT_Method;
+            if (refKind <= REF_putStatic)
+                reftag = CONSTANT_Field;
+            else if (refKind == REF_invokeInterface)
+                reftag = CONSTANT_InterfaceMethod;
+            Constant ref = cf.pool.addConstant(reftag, new Short[]{ cindex, ntindex });
+            return cf.pool.addConstant(CONSTANT_MethodHandle, new Object[]{ refKind, (short)ref.index });
+        }
+        private Constant makeInvokeDynamicCon(List args) {
+            // E.g.: MH_bsm.invokeGeneric(lookup(), "name", MethodType, "extraArg")
+            removeEmptyJVMSlots(args);
+            if (args.size() != 4 && args.size() != 5)  return null;
+            int argi = 0;
+            short nindex, tindex, ntindex, bsmindex;
+            Object con;
+            if (!isConstant(con = args.get(argi++), CONSTANT_MethodHandle))  return null;
+            bsmindex = (short) ((Constant)con).index;
+            if (!"lookup".equals(args.get(argi++)))  return null;
+            if (!isConstant(con = args.get(argi++), CONSTANT_String))  return null;
+            nindex = ((Constant)con).itemIndex();
+            if (!isConstant(con = args.get(argi++), CONSTANT_MethodType))  return null;
+            tindex = ((Constant)con).itemIndex();
+            ntindex = (short) cf.pool.addConstant(CONSTANT_NameAndType,
+                                                  new Short[]{ nindex, tindex }).index;
+            if (transitionalJSR292) {
+                if (argi != args.size()) {
+                    System.err.println("BSM specifier has extra arguments but transitionalJSR292=1");
+                    return null;
+                }
+                return cf.pool.addConstant(CONSTANT_InvokeDynamic_17,
+                        new Short[]{ bsmindex, ntindex });
+            }
+            List extraArgs = Collections.emptyList();
+            if (argi < args.size()) {
+                Object arg = args.get(argi);
+                if (arg instanceof List)
+                    extraArgs = (List) arg;
+                else
+                    extraArgs = Arrays.asList(arg);
+                removeEmptyJVMSlots(args);
+            }
+            List extraArgIndexes = new CountedList<>(Short.class);
+            for (Object x : extraArgs) {
+                if (x instanceof Number) {
+                    Object num = null; byte numTag = 0;
+                    if (x instanceof Integer) { num = x; numTag = CONSTANT_Integer; }
+                    if (x instanceof Float)   { num = Float.floatToRawIntBits((Float)x); numTag = CONSTANT_Float; }
+                    if (x instanceof Long)    { num = x; numTag = CONSTANT_Long; }
+                    if (x instanceof Double)  { num = Double.doubleToRawLongBits((Double)x); numTag = CONSTANT_Double; }
+                    if (num != null)  x = cf.pool.addConstant(numTag, x);
+                }
+                if (!(x instanceof Constant))  return null;
+                extraArgIndexes.add((short) ((Constant)x).index);
+            }
+            List specs = bootstrapMethodSpecifiers(true);
+            int specindex = -1;
+            Object[] spec = new Object[]{ bsmindex, extraArgIndexes };
+            for (Object[] spec1 : specs) {
+                if (Arrays.equals(spec1, spec)) {
+                    specindex = specs.indexOf(spec1);
+                    if (verbose)  System.err.println("reusing BSM specifier: "+spec1[0]+spec1[1]);
+                    break;
+                }
+            }
+            if (specindex == -1) {
+                specindex = (short) specs.size();
+                specs.add(spec);
+                if (verbose)  System.err.println("adding BSM specifier: "+spec[0]+spec[1]);
+            }
+            return cf.pool.addConstant(CONSTANT_InvokeDynamic,
+                        new Short[]{ (short)specindex, ntindex });
+        }
+
+        List bootstrapMethodSpecifiers(boolean createIfNotFound) {
+            Attr bsms = cf.findAttr("BootstrapMethods");
+            if (bsms == null) {
+                if (!createIfNotFound)  return null;
+                bsms = new Attr(cf, "BootstrapMethods", new byte[]{0,0});
+                assert(bsms == cf.findAttr("BootstrapMethods"));
+            }
+            if (bsms.item instanceof byte[]) {
+                // unflatten
+                List specs = new CountedList<>(Object[].class);
+                DataInputStream in = new DataInputStream(new ByteArrayInputStream((byte[]) bsms.item));
+                try {
+                    int len = (char) in.readShort();
+                    for (int i = 0; i < len; i++) {
+                        short bsm = in.readShort();
+                        int argc = (char) in.readShort();
+                        List argv = new CountedList<>(Short.class);
+                        for (int j = 0; j < argc; j++)
+                            argv.add(in.readShort());
+                        specs.add(new Object[]{ bsm, argv });
+                    }
+                } catch (IOException ex) { throw new InternalError(); }
+                bsms.item = specs;
+            }
+            return (List) bsms.item;
+        }
+    }
+
+    private DataInputStream openInput(File f) throws IOException {
+        return new DataInputStream(new BufferedInputStream(new FileInputStream(f)));
+    }
+
+    private DataOutputStream openOutput(File f) throws IOException {
+        if (!overwrite && f.exists())
+            throw new IOException("file already exists: "+f);
+        ensureDirectory(f.getParentFile());
+        return new DataOutputStream(new BufferedOutputStream(new FileOutputStream(f)));
+    }
+
+    static byte[] readRawBytes(DataInputStream in, int size) throws IOException {
+        byte[] bytes = new byte[size];
+        int nr = in.read(bytes);
+        if (nr != size)
+            throw new InternalError("wrong size: "+nr);
+        return bytes;
+    }
+
+    private interface Chunk {
+        void readFrom(DataInputStream in) throws IOException;
+        void writeTo(DataOutputStream out) throws IOException;
+    }
+
+    private static class CountedList extends ArrayList implements Chunk {
+        final Class itemClass;
+        final int rowlen;
+        CountedList(Class itemClass, int rowlen) {
+            this.itemClass = itemClass;
+            this.rowlen = rowlen;
+        }
+        CountedList(Class itemClass) { this(itemClass, -1); }
+        public void readFrom(DataInputStream in) throws IOException {
+            int count = in.readUnsignedShort();
+            while (size() < count) {
+                if (rowlen < 0) {
+                    add(readInput(in, itemClass));
+                } else {
+                    Class elemClass = itemClass.getComponentType();
+                    Object[] row = (Object[]) java.lang.reflect.Array.newInstance(elemClass, rowlen);
+                    for (int i = 0; i < rowlen; i++)
+                        row[i] = readInput(in, elemClass);
+                    add(itemClass.cast(row));
+                }
+            }
+        }
+        public void writeTo(DataOutputStream out) throws IOException {
+            out.writeShort((short)size());
+            for (T item : this) {
+                writeOutput(out, item);
+            }
+        }
+    }
+
+    private static  T readInput(DataInputStream in, Class dataClass) throws IOException {
+        Object data;
+        if (dataClass == Integer.class) {
+            data = in.readInt();
+        } else if (dataClass == Short.class) {
+            data = in.readShort();
+        } else if (dataClass == Byte.class) {
+            data = in.readByte();
+        } else if (dataClass == String.class) {
+            data = in.readUTF();
+        } else if (Chunk.class.isAssignableFrom(dataClass)) {
+            T obj;
+            try { obj = dataClass.newInstance(); }
+                catch (Exception ex) { throw new RuntimeException(ex); }
+            ((Chunk)obj).readFrom(in);
+            data = obj;
+        } else {
+            throw new InternalError("bad input datum: "+dataClass);
+        }
+        return dataClass.cast(data);
+    }
+    private static  T readInput(byte[] bytes, Class dataClass) {
+        try {
+            return readInput(new DataInputStream(new ByteArrayInputStream(bytes)), dataClass);
+        } catch (IOException ex) {
+            throw new InternalError();
+        }
+    }
+    private static void readInputs(DataInputStream in, Object... data) throws IOException {
+        for (Object x : data)  ((Chunk)x).readFrom(in);
+    }
+
+    private static void writeOutput(DataOutputStream out, Object data) throws IOException {
+        if (data == null) {
+            return;
+        } if (data instanceof Integer) {
+            out.writeInt((Integer)data);
+        } else if (data instanceof Long) {
+            out.writeLong((Long)data);
+        } else if (data instanceof Short) {
+            out.writeShort((Short)data);
+        } else if (data instanceof Byte) {
+            out.writeByte((Byte)data);
+        } else if (data instanceof String) {
+            out.writeUTF((String)data);
+        } else if (data instanceof byte[]) {
+            out.write((byte[])data);
+        } else if (data instanceof Object[]) {
+            for (Object x : (Object[]) data)
+                writeOutput(out, x);
+        } else if (data instanceof Chunk) {
+            Chunk x = (Chunk) data;
+            x.writeTo(out);
+        } else if (data instanceof List) {
+            for (Object x : (List) data)
+                writeOutput(out, x);
+        } else {
+            throw new InternalError("bad output datum: "+data+" : "+data.getClass().getName());
+        }
+    }
+    private static void writeOutputs(DataOutputStream out, Object... data) throws IOException {
+        for (Object x : data)  writeOutput(out, x);
+    }
+
+    public static abstract class Outer {
+        public abstract List inners();
+        protected void linkInners() {
+            for (Inner i : inners()) {
+                i.linkOuter(this);
+                if (i instanceof Outer)
+                    ((Outer)i).linkInners();
+            }
+        }
+        public  T outer(Class c) {
+            for (Outer walk = this;; walk = ((Inner)walk).outer()) {
+                if (c.isInstance(walk))
+                    return c.cast(walk);
+                //if (!(walk instanceof Inner))  return null;
+            }
+        }
+
+        public abstract List attrs();
+        public Attr findAttr(String name) {
+            return findAttr(outer(ClassFile.class).pool.stringIndex(name, false));
+        }
+        public Attr findAttr(int name) {
+            if (name == 0)  return null;
+            for (Attr a : attrs()) {
+                if (a.name == name)  return a;
+            }
+            return null;
+        }
+    }
+    public interface Inner { Outer outer(); void linkOuter(Outer o); }
+    public static abstract class InnerOuter extends Outer implements Inner {
+        public Outer outer;
+        public Outer outer() { return outer; }
+        public void linkOuter(Outer o) { assert(outer == null); outer = o; }
+    }
+    public static class Constant implements Chunk {
+        public final byte tag;
+        public final T item;
+        public final int index;
+        public Constant(int index, byte tag, T item) {
+            this.index = index;
+            this.tag = tag;
+            this.item = item;
+        }
+        public Constant checkTag(byte tag) {
+            if (this.tag != tag)  throw new InternalError(this.toString());
+            return this;
+        }
+        public String itemString() { return (String)item; }
+        public Short itemIndex() { return (Short)item; }
+        public Short[] itemIndexes() { return (Short[])item; }
+        public void readFrom(DataInputStream in) throws IOException {
+            throw new InternalError("do not call");
+        }
+        public void writeTo(DataOutputStream out) throws IOException {
+            writeOutputs(out, tag, item);
+        }
+        public boolean equals(Object x) { return (x instanceof Constant && equals((Constant)x)); }
+        public boolean equals(Constant that) {
+            return (this.tag == that.tag && this.itemAsComparable().equals(that.itemAsComparable()));
+        }
+        public int hashCode() { return (tag * 31) + this.itemAsComparable().hashCode(); }
+        public Object itemAsComparable() {
+            switch (tag) {
+            case CONSTANT_Double:   return Double.longBitsToDouble((Long)item);
+            case CONSTANT_Float:    return Float.intBitsToFloat((Integer)item);
+            }
+            return (item instanceof Object[] ? Arrays.asList((Object[])item) : item);
+        }
+        public String toString() {
+            String itstr = String.valueOf(itemAsComparable());
+            return (index + ":" + tagName(tag) + (itstr.startsWith("[")?"":"=") + itstr);
+        }
+        private static String[] TAG_NAMES;
+        public static String tagName(byte tag) {  // used for error messages
+            if (TAG_NAMES == null)
+                TAG_NAMES = ("None Utf8 Unicode Integer Float Long Double Class String"
+                             +" Fieldref Methodref InterfaceMethodref NameAndType #13 #14"
+                             +" MethodHandle MethodType InvokeDynamic#17 InvokeDynamic").split(" ");
+            if ((tag & 0xFF) >= TAG_NAMES.length)  return "#"+(tag & 0xFF);
+            return TAG_NAMES[tag & 0xFF];
+        }
+    }
+
+    public static class Pool extends CountedList implements Chunk {
+        private Map strings = new TreeMap<>();
+
+        public Pool() {
+            super(Constant.class);
+        }
+        public void readFrom(DataInputStream in) throws IOException {
+            int count = in.readUnsignedShort();
+            add(null);  // always ignore first item
+            while (size() < count) {
+                readConstant(in);
+            }
+        }
+        public  Constant addConstant(byte tag, T item) {
+            Constant con = new Constant<>(size(), tag, item);
+            int idx = indexOf(con);
+            if (idx >= 0)  return get(idx);
+            add(con);
+            if (tag == CONSTANT_Utf8)  strings.put((String)item, (short) con.index);
+            return con;
+        }
+        private void readConstant(DataInputStream in) throws IOException {
+            byte tag = in.readByte();
+            int index = size();
+            Object arg;
+            switch (tag) {
+            case CONSTANT_Utf8:
+                arg = in.readUTF();
+                strings.put((String) arg, (short) size());
+                break;
+            case CONSTANT_Integer:
+            case CONSTANT_Float:
+                arg = in.readInt(); break;
+            case CONSTANT_Long:
+            case CONSTANT_Double:
+                add(new Constant(index, tag, in.readLong()));
+                add(null);
+                return;
+            case CONSTANT_Class:
+            case CONSTANT_String:
+                arg = in.readShort(); break;
+            case CONSTANT_Field:
+            case CONSTANT_Method:
+            case CONSTANT_InterfaceMethod:
+            case CONSTANT_NameAndType:
+            case CONSTANT_InvokeDynamic_17:
+            case CONSTANT_InvokeDynamic:
+                // read an ordered pair
+                arg = new Short[] { in.readShort(), in.readShort() };
+                break;
+            case CONSTANT_MethodHandle:
+                // read an ordered pair; first part is a u1 (not u2)
+                arg = new Object[] { in.readByte(), in.readShort() };
+                break;
+            case CONSTANT_MethodType:
+                arg = in.readShort(); break;
+            default:
+                throw new InternalError("bad CP tag "+tag);
+            }
+            add(new Constant(index, tag, arg));
+        }
+
+        // Access:
+        public Constant get(int index) {
+            // extra 1-bits get into the shorts
+            return super.get((char) index);
+        }
+        String getString(byte tag, short index) {
+            get(index).checkTag(tag);
+            return getString(index);
+        }
+        String getString(short index) {
+            Object v = get(index).item;
+            if (v instanceof Short)
+                v = get((Short)v).checkTag(CONSTANT_Utf8).item;
+            return (String) v;
+        }
+        String[] getStrings(Short[] indexes) {
+            String[] res = new String[indexes.length];
+            for (int i = 0; i < indexes.length; i++)
+                res[i] = getString(indexes[i]);
+            return res;
+        }
+        int stringIndex(String name, boolean createIfNotFound) {
+            Short x = strings.get(name);
+            if (x != null)  return (char)(int) x;
+            if (!createIfNotFound)  return 0;
+            return addConstant(CONSTANT_Utf8, name).index;
+        }
+        Short[] getMemberRef(short index) {
+            Short[] cls_nnt = get(index).itemIndexes();
+            Short[] name_type = get(cls_nnt[1]).itemIndexes();
+            return new Short[]{ cls_nnt[0], name_type[0], name_type[1] };
+        }
+    }
+
+    public class ClassFile extends Outer implements Chunk {
+        ClassFile(File f) throws IOException {
+            DataInputStream in = openInput(f);
+            try {
+                readFrom(in);
+            } finally {
+                if (in != null)  in.close();
+            }
+        }
+
+        public int                magic, version;  // 
+        public final Pool         pool       = new Pool();
+        public short              access, thisc, superc;
+        public final List  interfaces = new CountedList<>(Short.class);
+        public final List  fields     = new CountedList<>(Field.class);
+        public final List methods    = new CountedList<>(Method.class);
+        public final List   attrs      = new CountedList<>(Attr.class);
+
+        public final void readFrom(DataInputStream in) throws IOException {
+            magic = in.readInt(); version = in.readInt();
+            if (magic != 0xCAFEBABE)  throw new IOException("bad magic number");
+            pool.readFrom(in);
+            Code_index = pool.stringIndex("Code", false);
+            access = in.readShort(); thisc = in.readShort(); superc = in.readShort();
+            readInputs(in, interfaces, fields, methods, attrs);
+            if (in.read() >= 0)  throw new IOException("junk after end of file");
+            linkInners();
+        }
+
+        void writeTo(File f) throws IOException {
+            DataOutputStream out = openOutput(f);
+            try {
+                writeTo(out);
+            } finally {
+                out.close();
+            }
+        }
+
+        public void writeTo(DataOutputStream out) throws IOException {
+            writeOutputs(out, magic, version, pool,
+                         access, thisc, superc, interfaces,
+                         fields, methods, attrs);
+        }
+
+        public byte[] toByteArray() {
+            try {
+                ByteArrayOutputStream buf = new ByteArrayOutputStream();
+                writeTo(new DataOutputStream(buf));
+                return buf.toByteArray();
+            } catch (IOException ex) {
+                throw new InternalError();
+            }
+        }
+
+        public List inners() {
+            List inns = new ArrayList<>();
+            inns.addAll(fields); inns.addAll(methods); inns.addAll(attrs);
+            return inns;
+        }
+        public List attrs() { return attrs; }
+
+        // derived stuff:
+        public String nameString() { return pool.getString(CONSTANT_Class, thisc); }
+        int Code_index;
+    }
+
+    private static  T findMember(List mems, int name, int type) {
+        if (name == 0 || type == 0)  return null;
+        for (T m : mems) {
+            if (m.name == name && m.type == type)  return m;
+        }
+        return null;
+    }
+
+    public static class Member extends InnerOuter implements Chunk {
+        public short access, name, type;
+        public final List attrs = new CountedList<>(Attr.class);
+        public void readFrom(DataInputStream in) throws IOException {
+            access = in.readShort(); name = in.readShort(); type = in.readShort();
+            readInputs(in, attrs);
+        }
+        public void writeTo(DataOutputStream out) throws IOException {
+            writeOutputs(out, access, name, type, attrs);
+        }
+        public List inners() { return attrs; }
+        public List attrs() { return attrs; }
+        public ClassFile outer() { return (ClassFile) outer; }
+        public String nameString() { return outer().pool.getString(CONSTANT_Utf8, name); }
+        public String typeString() { return outer().pool.getString(CONSTANT_Utf8, type); }
+        public String toString() {
+            if (outer == null)  return super.toString();
+            return nameString() + (this instanceof Method ? "" : ":")
+                    + simplifyType(typeString());
+        }
+    }
+    public static class Field extends Member {
+    }
+    public static class Method extends Member {
+        public Code code() {
+            Attr a = findAttr("Code");
+            if (a == null)  return null;
+            return (Code) a.item;
+        }
+        public Instruction instructions() {
+            Code code = code();
+            if (code == null)  return null;
+            return code.instructions();
+        }
+    }
+
+    public static class Attr extends InnerOuter implements Chunk {
+        public short name;
+        public int size = -1;  // no pre-declared size
+        public Object item;
+
+        public Attr() {}
+        public Attr(Outer outer, String name, Object item) {
+            ClassFile cf = outer.outer(ClassFile.class);
+            linkOuter(outer);
+            this.name = (short) cf.pool.stringIndex(name, true);
+            this.item = item;
+            outer.attrs().add(this);
+        }
+        public void readFrom(DataInputStream in) throws IOException {
+            name = in.readShort();
+            size = in.readInt();
+            item = readRawBytes(in, size);
+        }
+        public void writeTo(DataOutputStream out) throws IOException {
+            out.writeShort(name);
+            // write the 4-byte size header and then the contents:
+            byte[] bytes;
+            int trueSize;
+            if (item instanceof byte[]) {
+                bytes = (byte[]) item;
+                out.writeInt(trueSize = bytes.length);
+                out.write(bytes);
+            } else {
+                trueSize = flatten(out);
+            }
+            if (trueSize != size && size >= 0)
+                System.err.println("warning: attribute size changed "+size+" to "+trueSize);
+        }
+        public void linkOuter(Outer o) {
+            super.linkOuter(o);
+            if (item instanceof byte[] &&
+                outer instanceof Method &&
+                ((Method)outer).outer().Code_index == name) {
+                    item = readInput((byte[])item, Code.class);
+            }
+        }
+        public List inners() {
+            if (item instanceof Inner)
+                return Collections.nCopies(1, (Inner)item);
+            return Collections.emptyList();
+        }
+        public List attrs() { return null; }  // Code overrides this
+        public byte[] flatten() {
+            ByteArrayOutputStream buf = new ByteArrayOutputStream(size);
+            flatten(buf);
+            return buf.toByteArray();
+        }
+        public int flatten(DataOutputStream out) throws IOException {
+            ByteArrayOutputStream buf = new ByteArrayOutputStream(Math.max(20, size));
+            int trueSize = flatten(buf);
+            out.writeInt(trueSize);
+            buf.writeTo(out);
+            return trueSize;
+        }
+        private int flatten(ByteArrayOutputStream buf) {
+            try {
+                writeOutput(new DataOutputStream(buf), item);
+                return buf.size();
+            } catch (IOException ex) {
+                throw new InternalError();
+            }
+        }
+        public String nameString() {
+            ClassFile cf = outer(ClassFile.class);
+            if (cf == null)  return "#"+name;
+            return cf.pool.getString(name);
+        }
+        public String toString() {
+            return nameString()+(size < 0 ? "=" : "["+size+"]=")+item;
+        }
+    }
+
+    public static class Code extends InnerOuter implements Chunk {
+        public short stacks, locals;
+        public byte[] bytes;
+        public final List etable = new CountedList<>(Short[].class, 4);
+        public final List attrs = new CountedList<>(Attr.class);
+        // etable[N] = (N)*{ startpc, endpc, handlerpc, catchtype }
+        public void readFrom(DataInputStream in) throws IOException {
+            stacks = in.readShort(); locals = in.readShort();
+            bytes = readRawBytes(in, in.readInt());
+            readInputs(in, etable, attrs);
+        }
+        public void writeTo(DataOutputStream out) throws IOException {
+            writeOutputs(out, stacks, locals, bytes.length, bytes, etable, attrs);
+        }
+        public List inners() { return attrs; }
+        public List attrs() { return attrs; }
+        public Instruction instructions() {
+            return new Instruction(bytes, 0);
+        }
+    }
+
+    // lots of constants
+    private static final byte
+        CONSTANT_Utf8              = 1,
+        CONSTANT_Integer           = 3,
+        CONSTANT_Float             = 4,
+        CONSTANT_Long              = 5,
+        CONSTANT_Double            = 6,
+        CONSTANT_Class             = 7,
+        CONSTANT_String            = 8,
+        CONSTANT_Field             = 9,
+        CONSTANT_Method            = 10,
+        CONSTANT_InterfaceMethod   = 11,
+        CONSTANT_NameAndType       = 12,
+        CONSTANT_MethodHandle      = 15,  // JSR 292
+        CONSTANT_MethodType        = 16,  // JSR 292
+        CONSTANT_InvokeDynamic_17  = 17,  // JSR 292, only occurs in old class files
+        CONSTANT_InvokeDynamic     = 18;  // JSR 292
+    private static final byte
+        REF_getField               = 1,
+        REF_getStatic              = 2,
+        REF_putField               = 3,
+        REF_putStatic              = 4,
+        REF_invokeVirtual          = 5,
+        REF_invokeStatic           = 6,
+        REF_invokeSpecial          = 7,
+        REF_newInvokeSpecial       = 8,
+        REF_invokeInterface        = 9;
+
+    private static final int
+        opc_nop                    = 0,
+        opc_aconst_null            = 1,
+        opc_nconst_MIN             = 2,  // iconst_m1
+        opc_nconst_MAX             = 15, // dconst_1
+        opc_bipush                 = 16,
+        opc_sipush                 = 17,
+        opc_ldc                    = 18,
+        opc_ldc_w                  = 19,
+        opc_ldc2_w                 = 20,
+        opc_aload                  = 25,
+        opc_aload_0                = 42,
+        opc_aload_MAX              = 45,
+        opc_aaload                 = 50,
+        opc_astore                 = 58,
+        opc_astore_0               = 75,
+        opc_astore_MAX             = 78,
+        opc_aastore                = 83,
+        opc_pop                    = 87,
+        opc_pop2                   = 88,
+        opc_dup                    = 89,
+        opc_dup_x1                 = 90,
+        opc_dup_x2                 = 91,
+        opc_dup2                   = 92,
+        opc_dup2_x1                = 93,
+        opc_dup2_x2                = 94,
+        opc_swap                   = 95,
+        opc_tableswitch            = 170,
+        opc_lookupswitch           = 171,
+        opc_areturn                = 176,
+        opc_getstatic              = 178,
+        opc_putstatic              = 179,
+        opc_getfield               = 180,
+        opc_putfield               = 181,
+        opc_invokevirtual          = 182,
+        opc_invokespecial          = 183,
+        opc_invokestatic           = 184,
+        opc_invokeinterface        = 185,
+        opc_invokedynamic          = 186,
+        opc_anewarray              = 189,
+        opc_checkcast              = 192,
+        opc_ifnull                 = 198,
+        opc_ifnonnull              = 199,
+        opc_wide                   = 196;
+
+    private static final Object[] INSTRUCTION_CONSTANTS = {
+        -1, 0, 1, 2, 3, 4, 5, 0L, 1L, 0.0F, 1.0F, 2.0F, 0.0D, 1.0D
+    };
+
+    private static final String INSTRUCTION_FORMATS =
+        "nop$ aconst_null$L iconst_m1$I iconst_0$I iconst_1$I "+
+        "iconst_2$I iconst_3$I iconst_4$I iconst_5$I lconst_0$J_ "+
+        "lconst_1$J_ fconst_0$F fconst_1$F fconst_2$F dconst_0$D_ "+
+        "dconst_1$D_ bipush=bx$I sipush=bxx$I ldc=bk$X ldc_w=bkk$X "+
+        "ldc2_w=bkk$X_ iload=bl/wbll$I lload=bl/wbll$J_ fload=bl/wbll$F "+
+        "dload=bl/wbll$D_ aload=bl/wbll$L iload_0$I iload_1$I "+
+        "iload_2$I iload_3$I lload_0$J_ lload_1$J_ lload_2$J_ "+
+        "lload_3$J_ fload_0$F fload_1$F fload_2$F fload_3$F dload_0$D_ "+
+        "dload_1$D_ dload_2$D_ dload_3$D_ aload_0$L aload_1$L "+
+        "aload_2$L aload_3$L iaload$LI$I laload$LI$J_ faload$LI$F "+
+        "daload$LI$D_ aaload$LI$L baload$LI$I caload$LI$I saload$LI$I "+
+        "istore=bl/wbll$I$ lstore=bl/wbll$J_$ fstore=bl/wbll$F$ "+
+        "dstore=bl/wbll$D_$ astore=bl/wbll$L$ istore_0$I$ istore_1$I$ "+
+        "istore_2$I$ istore_3$I$ lstore_0$J_$ lstore_1$J_$ "+
+        "lstore_2$J_$ lstore_3$J_$ fstore_0$F$ fstore_1$F$ fstore_2$F$ "+
+        "fstore_3$F$ dstore_0$D_$ dstore_1$D_$ dstore_2$D_$ "+
+        "dstore_3$D_$ astore_0$L$ astore_1$L$ astore_2$L$ astore_3$L$ "+
+        "iastore$LII$ lastore$LIJ_$ fastore$LIF$ dastore$LID_$ "+
+        "aastore$LIL$ bastore$LII$ castore$LII$ sastore$LII$ pop$X$ "+
+        "pop2$XX$ dup$X$XX dup_x1$XX$XXX dup_x2$XXX$XXXX dup2$XX$XXXX "+
+        "dup2_x1$XXX$XXXXX dup2_x2$XXXX$XXXXXX swap$XX$XX "+
+        "iadd$II$I ladd$J_J_$J_ fadd$FF$F dadd$D_D_$D_ isub$II$I "+
+        "lsub$J_J_$J_ fsub$FF$F dsub$D_D_$D_ imul$II$I lmul$J_J_$J_ "+
+        "fmul$FF$F dmul$D_D_$D_ idiv$II$I ldiv$J_J_$J_ fdiv$FF$F "+
+        "ddiv$D_D_$D_ irem$II$I lrem$J_J_$J_ frem$FF$F drem$D_D_$D_ "+
+        "ineg$I$I lneg$J_$J_ fneg$F$F dneg$D_$D_ ishl$II$I lshl$J_I$J_ "+
+        "ishr$II$I lshr$J_I$J_ iushr$II$I lushr$J_I$J_ iand$II$I "+
+        "land$J_J_$J_ ior$II$I lor$J_J_$J_ ixor$II$I lxor$J_J_$J_ "+
+        "iinc=blx/wbllxx$ i2l$I$J_ i2f$I$F i2d$I$D_ l2i$J_$I l2f$J_$F "+
+        "l2d$J_$D_ f2i$F$I f2l$F$J_ f2d$F$D_ d2i$D_$I d2l$D_$J_ "+
+        "d2f$D_$F i2b$I$I i2c$I$I i2s$I$I lcmp fcmpl fcmpg dcmpl dcmpg "+
+        "ifeq=boo ifne=boo iflt=boo ifge=boo ifgt=boo ifle=boo "+
+        "if_icmpeq=boo if_icmpne=boo if_icmplt=boo if_icmpge=boo "+
+        "if_icmpgt=boo if_icmple=boo if_acmpeq=boo if_acmpne=boo "+
+        "goto=boo jsr=boo ret=bl/wbll tableswitch=* lookupswitch=* "+
+        "ireturn lreturn freturn dreturn areturn return "+
+        "getstatic=bkf$Q putstatic=bkf$Q$ getfield=bkf$L$Q "+
+        "putfield=bkf$LQ$ invokevirtual=bkm$LQ$Q "+
+        "invokespecial=bkm$LQ$Q invokestatic=bkm$Q$Q "+
+        "invokeinterface=bkixx$LQ$Q invokedynamic=bkd__$Q$Q new=bkc$L "+
+        "newarray=bx$I$L anewarray=bkc$I$L arraylength$L$I athrow "+
+        "checkcast=bkc$L$L instanceof=bkc$L$I monitorenter$L "+
+        "monitorexit$L wide=* multianewarray=bkcx ifnull=boo "+
+        "ifnonnull=boo goto_w=boooo jsr_w=boooo ";
+    private static final String[] INSTRUCTION_NAMES;
+    private static final String[] INSTRUCTION_POPS;
+    private static final int[] INSTRUCTION_INFO;
+    static {
+        String[] insns = INSTRUCTION_FORMATS.split(" ");
+        assert(insns[opc_lookupswitch].startsWith("lookupswitch"));
+        assert(insns[opc_tableswitch].startsWith("tableswitch"));
+        assert(insns[opc_wide].startsWith("wide"));
+        assert(insns[opc_invokedynamic].startsWith("invokedynamic"));
+        int[] info = new int[256];
+        String[] names = new String[256];
+        String[] pops = new String[256];
+        for (int i = 0; i < insns.length; i++) {
+            String insn = insns[i];
+            int dl = insn.indexOf('$');
+            if (dl > 0) {
+                String p = insn.substring(dl+1);
+                if (p.indexOf('$') < 0)  p = "$" + p;
+                pops[i] = p;
+                insn = insn.substring(0, dl);
+            }
+            int eq = insn.indexOf('=');
+            if (eq < 0) {
+                info[i] = 1;
+                names[i] = insn;
+                continue;
+            }
+            names[i] = insn.substring(0, eq);
+            String fmt = insn.substring(eq+1);
+            if (fmt.equals("*")) {
+                info[i] = 0;
+                continue;
+            }
+            int sl = fmt.indexOf('/');
+            if (sl < 0) {
+                info[i] = (char) fmt.length();
+            } else {
+                String wfmt = fmt.substring(sl+1);
+                fmt = fmt.substring(0, sl);
+                info[i] = (char)( fmt.length() + (wfmt.length() * 16) );
+            }
+        }
+        INSTRUCTION_INFO = info;
+        INSTRUCTION_NAMES = names;
+        INSTRUCTION_POPS = pops;
+    }
+
+    public static class Instruction implements Cloneable {
+        byte[] codeBase;
+        int pc;
+        int bc;
+        int info;
+        int wide;
+        int len;
+        Instruction(byte[] codeBase, int pc) {
+            this.codeBase = codeBase;
+            init(pc);
+        }
+        public Instruction clone() {
+            try {
+                return (Instruction) super.clone();
+            } catch (CloneNotSupportedException ex) {
+                throw new InternalError();
+            }
+        }
+        private Instruction init(int pc) {
+            this.pc = pc;
+            this.bc = codeBase[pc] & 0xFF;
+            this.info = INSTRUCTION_INFO[bc];
+            this.wide = 0;
+            this.len = (info & 0x0F);
+            if (len == 0)
+                computeLength();
+            return this;
+        }
+        Instruction next() {
+            if (len == 0 && bc != 0)  throw new InternalError();
+            int npc = pc + len;
+            if (npc == codeBase.length)
+                return null;
+            return init(npc);
+        }
+        void forceNext(int newLen) {
+            bc = opc_nop;
+            len = newLen;
+        }
+
+        public String toString() {
+            StringBuilder buf = new StringBuilder();
+            buf.append(pc).append(":").append(INSTRUCTION_NAMES[bc]);
+            switch (len) {
+            case 3: buf.append(" ").append(u2At(1)); break;
+            case 5: buf.append(" ").append(u2At(1)).append(" ").append(u2At(3)); break;
+            default:  for (int i = 1; i < len; i++)  buf.append(" ").append(u1At(1));
+            }
+            return buf.toString();
+        }
+
+        // these are the hard parts
+        private void computeLength() {
+            int cases;
+            switch (bc) {
+            case opc_wide:
+                bc = codeBase[pc + 1];
+                info = INSTRUCTION_INFO[bc];
+                len = ((info >> 4) & 0x0F);
+                if (len == 0)  throw new RuntimeException("misplaced wide bytecode: "+bc);
+                return;
+
+            case opc_tableswitch:
+                cases = (u4At(alignedIntOffset(2)) - u4At(alignedIntOffset(1)) + 1);
+                len = alignedIntOffset(3 + cases*1);
+                return;
+
+            case opc_lookupswitch:
+                cases = u4At(alignedIntOffset(1));
+                len = alignedIntOffset(2 + cases*2);
+                return;
+
+            default:
+                throw new RuntimeException("unknown bytecode: "+bc);
+            }
+        }
+        // switch code
+        // clget the Nth int (where 0 is the first after the opcode itself)
+        public int alignedIntOffset(int n) {
+            int pos = pc + 1;
+            pos += ((-pos) & 0x03);  // align it
+            pos += (n * 4);
+            return pos - pc;
+        }
+        public int u1At(int pos) {
+            return (codeBase[pc+pos] & 0xFF);
+        }
+        public int u2At(int pos) {
+            return (u1At(pos+0)<<8) + u1At(pos+1);
+        }
+        public int u4At(int pos) {
+            return (u2At(pos+0)<<16) + u2At(pos+2);
+        }
+        public void u1AtPut(int pos, int x) {
+            codeBase[pc+pos] = (byte)x;
+        }
+        public void u2AtPut(int pos, int x) {
+            codeBase[pc+pos+0] = (byte)(x >> 8);
+            codeBase[pc+pos+1] = (byte)(x >> 0);
+        }
+    }
+
+    static String simplifyType(String type) {
+        String simpleType = OBJ_SIGNATURE.matcher(type).replaceAll("L");
+        assert(simpleType.matches("^\\([A-Z]*\\)[A-Z]$"));
+        // change (DD)D to (D_D_)D_
+        simpleType = WIDE_SIGNATURE.matcher(simpleType).replaceAll("\\0_");
+        return simpleType;
+    }
+    static int argsize(String type) {
+        return simplifyType(type).length()-3;
+    }
+    private static final Pattern OBJ_SIGNATURE = Pattern.compile("\\[*L[^;]*;|\\[+[A-Z]");
+    private static final Pattern WIDE_SIGNATURE = Pattern.compile("[JD]");
+}
diff --git a/jdk/test/java/io/FileInputStream/LargeFileAvailable.java b/jdk/test/java/io/FileInputStream/LargeFileAvailable.java
new file mode 100644
index 0000000000000000000000000000000000000000..35c9ce47483bc234609a67ae3ba22ea5208b2542
--- /dev/null
+++ b/jdk/test/java/io/FileInputStream/LargeFileAvailable.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2010, 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 6402006
+ * @summary Test if available returns correct value when reading
+ *          a large file.
+ */
+
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.channels.*;
+import static java.nio.file.StandardOpenOption.*;
+
+public class LargeFileAvailable {
+    private static final long FILESIZE = 7405576182L;
+    public static void main(String args[]) throws Exception {
+        File file = createLargeFile(FILESIZE);
+        try (FileInputStream fis = new FileInputStream(file)) {
+            if (file.length() != FILESIZE) {
+                throw new RuntimeException("unexpected file size = " + file.length());
+            }
+
+            long bigSkip = 3110608882L;
+            long remaining = FILESIZE;
+            remaining -= skipBytes(fis, bigSkip, remaining);
+            remaining -= skipBytes(fis, 10L, remaining);
+            remaining -= skipBytes(fis, bigSkip, remaining);
+            if (fis.available() != (int) remaining) {
+                 throw new RuntimeException("available() returns " +
+                     fis.available() +
+                     " but expected " + remaining);
+            }
+        } finally {
+            file.delete();
+        }
+    }
+
+    // Skip toSkip number of bytes and expect that the available() method
+    // returns avail number of bytes.
+    private static long skipBytes(InputStream is, long toSkip, long avail)
+            throws IOException {
+        long skip = is.skip(toSkip);
+        if (skip != toSkip) {
+            throw new RuntimeException("skip() returns " + skip +
+                " but expected " + toSkip);
+        }
+        long remaining = avail - skip;
+        int expected = remaining >= Integer.MAX_VALUE
+                           ? Integer.MAX_VALUE
+                           : (int) remaining;
+
+        System.out.println("Skipped " + skip + " bytes " +
+            " available() returns " + expected +
+            " remaining=" + remaining);
+        if (is.available() != expected) {
+            throw new RuntimeException("available() returns " +
+                is.available() + " but expected " + expected);
+        }
+        return skip;
+    }
+
+    private static File createLargeFile(long filesize) throws Exception {
+        // Create a large file as a sparse file if possible
+        File largefile = File.createTempFile("largefile", null);
+        // re-create as a sparse file
+        largefile.toPath().delete();
+        try (FileChannel fc =
+                FileChannel.open(largefile.toPath(),
+                                 CREATE_NEW, WRITE, SPARSE)) {
+            ByteBuffer bb = ByteBuffer.allocate(1).put((byte)1);
+            bb.rewind();
+            int rc = fc.write(bb, filesize-1);
+            if (rc != 1) {
+                throw new RuntimeException("Failed to write 1 byte to the large file");
+            }
+        }
+        return largefile;
+    }
+}
diff --git a/jdk/test/java/io/Serializable/cloneArray/CloneArray.java b/jdk/test/java/io/Serializable/cloneArray/CloneArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..650ac3ccb9f8e7f7e473618fcda6d4e3460df239
--- /dev/null
+++ b/jdk/test/java/io/Serializable/cloneArray/CloneArray.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2010, 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 6990094
+ * @summary Verify ObjectInputStream.cloneArray works on many kinds of arrays
+ * @author Stuart Marks, Joseph D. Darcy
+ */
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+
+public class CloneArray {
+    static Object replacement;
+
+    static class Resolver implements Serializable {
+        private Object readResolve() throws ObjectStreamException {
+            return replacement;
+        }
+    }
+
+    private static void test(Object rep)
+        throws IOException, ClassNotFoundException {
+
+        try(ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+            try(ObjectOutputStream oos = new ObjectOutputStream(baos)) {
+                oos.writeObject(new Resolver());
+                oos.writeObject(new Resolver());
+            }
+
+            Object o1;
+            Object o2;
+            try(ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+                ObjectInputStream ois = new ObjectInputStream(bais)) {
+                replacement = rep;
+                o1 = ois.readUnshared();
+                o2 = ois.readUnshared();
+            }
+
+            if (o1 == o2)
+                throw new AssertionError("o1 and o2 must not be identical");
+        }
+    }
+
+    public static void main(String[] args)
+        throws IOException, ClassNotFoundException {
+        Object[] replacements = {
+            new byte[]    {1},
+            new char[]    {'2'},
+            new short[]   {3},
+            new int[]     {4},
+            new long[]    {5},
+            new float[]   {6.0f},
+            new double[]  {7.0},
+            new boolean[] {true},
+            new Object[] {"A string."}
+        };
+
+        for(Object replacement : replacements) {
+            test(replacement);
+        }
+    }
+}
diff --git a/jdk/test/java/nio/channels/FileChannel/AtomicAppend.java b/jdk/test/java/nio/channels/FileChannel/AtomicAppend.java
new file mode 100644
index 0000000000000000000000000000000000000000..1420318d5d7efbf971814ecef816c9f6b5748e85
--- /dev/null
+++ b/jdk/test/java/nio/channels/FileChannel/AtomicAppend.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2010, 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
+ * @summary Check that appends are atomic
+ */
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.util.Random;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import static java.nio.file.StandardOpenOption.*;
+
+public class AtomicAppend {
+    static final Random rand = new Random();
+
+    // Open file for appending, returning FileChannel
+    static FileChannel newFileChannel(File file) throws IOException {
+        if (rand.nextBoolean()) {
+            return new FileOutputStream(file, true).getChannel();
+        } else {
+            return FileChannel.open(file.toPath(), APPEND);
+        }
+    }
+
+    // Open file for append, returning OutputStream
+    static OutputStream newOutputStream(File file) throws IOException {
+        if (rand.nextBoolean()) {
+            return new FileOutputStream(file, true);
+        } else {
+            return file.toPath().newOutputStream(APPEND);
+        }
+    }
+
+    // write a byte to the given channel
+    static void write(FileChannel fc, int b) throws IOException {
+        ByteBuffer buf = ByteBuffer.allocate(1);
+        buf.put((byte)b);
+        buf.flip();
+        if (rand.nextBoolean()) {
+            ByteBuffer[] bufs = new ByteBuffer[1];
+            bufs[0] = buf;
+            fc.write(bufs);
+        } else {
+            fc.write(buf);
+        }
+    }
+
+    public static void main(String[] args) throws Throwable {
+        final int nThreads = 16;
+        final int writes = 1000;
+        final File file = File.createTempFile("foo", null);
+        try {
+            ExecutorService pool = Executors.newFixedThreadPool(nThreads);
+            for (int i = 0; i < nThreads; i++)
+                pool.execute(new Runnable() { public void run() {
+                    try {
+                        // randomly choose FileChannel or OutputStream
+                        if (rand.nextBoolean()) {
+                            try (FileChannel fc = newFileChannel(file)) {
+                                for (int j=0; j newSize) {
-                if (c.position() != newSize)
-                    throw new RuntimeException("Position greater than size");
-            } else {
-                if (c.position() != position)
-                    throw new RuntimeException("Truncate changed position");
+                if (position > newSize) {
+                    if (fc.position() != newSize)
+                        throw new RuntimeException("Position greater than size");
+                } else {
+                    if (fc.position() != position)
+                        throw new RuntimeException("Truncate changed position");
+                };
             }
+        }
+    }
+
+    /**
+     * Test behavior of truncate method when file is opened for append
+     */
+    static void appendTest(File blah) throws Exception {
+        for (int i=0; i<10; i++) {
+            long testSize = generator.nextInt(1000) + 10;
+            initTestFile(blah, testSize);
+            FileChannel fc = (i < 5) ?
+                new FileOutputStream(blah, true).getChannel() :
+                FileChannel.open(blah.toPath(), APPEND);
+            try (fc) {
+                // truncate file
+                long newSize = generator.nextInt((int)testSize);
+                fc.truncate(newSize);
+                if (fc.size() != newSize)
+                    throw new RuntimeException("Truncate failed");
 
-            c.close();
-            fis.close();
+                // write one byte
+                ByteBuffer buf = ByteBuffer.allocate(1);
+                buf.put((byte)'x');
+                buf.flip();
+                fc.write(buf);
+                if (fc.size() != (newSize+1))
+                    throw new RuntimeException("Unexpected size");
+            }
         }
-        blah.delete();
     }
 
     /**
diff --git a/jdk/test/java/security/CodeSigner/Serialize.java b/jdk/test/java/security/CodeSigner/Serialize.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a1f9fca97e661513ce4ef50aa52caa06c9cfeb3
--- /dev/null
+++ b/jdk/test/java/security/CodeSigner/Serialize.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2010, 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 6799854
+ * @summary CodeSigner.hashCode() does not work with serialization
+ */
+
+import java.io.*;
+import java.security.CodeSigner;
+import java.security.Timestamp;
+import java.security.cert.*;
+import java.util.Collections;
+import java.util.Date;
+
+public class Serialize {
+
+    public static void main(String[] args) throws Exception {
+
+        // Create a certpath consisting of one certificate
+        File f = new File(System.getProperty("test.src", "."), "cert_file");
+        FileInputStream fis = new FileInputStream(f);
+        CertificateFactory cf = CertificateFactory.getInstance("X.509");
+        Certificate c = cf.generateCertificate(fis);
+        fis.close();
+        CertPath cp = cf.generateCertPath(Collections.singletonList(c));
+
+        // Create a code signer
+        CodeSigner cs = new CodeSigner(cp, new Timestamp(new Date(), cp));
+
+        // Serialize the code signer
+        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
+        ObjectOutputStream out = new ObjectOutputStream(byteOut);
+        out.writeObject(cs);
+        out.close();
+
+        // Deserialize the code signer
+        byte[] data = byteOut.toByteArray();
+        CodeSigner cs2 = (CodeSigner) new ObjectInputStream(
+            new ByteArrayInputStream(data)).readObject();
+
+        // Test for equality
+        if (!cs.equals(cs2) || cs.hashCode() != cs2.hashCode()) {
+            throw new Exception("CodeSigner serialization test FAILED");
+        }
+    }
+}
diff --git a/jdk/test/java/security/CodeSigner/cert_file b/jdk/test/java/security/CodeSigner/cert_file
new file mode 100644
index 0000000000000000000000000000000000000000..42af97b376221127bc892d2479e53655ac768b8b
Binary files /dev/null and b/jdk/test/java/security/CodeSigner/cert_file differ
diff --git a/jdk/test/java/text/Format/DateFormat/Bug4396385.java b/jdk/test/java/text/Format/DateFormat/Bug4396385.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0263257db59d9790fa21d3056bb10dc82711971
--- /dev/null
+++ b/jdk/test/java/text/Format/DateFormat/Bug4396385.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2010, 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 4396385
+ * @summary Make sure to detect invalid values for 1-based hour formats.
+ */
+
+import java.text.*;
+import java.util.*;
+
+public class Bug4396385 {
+    private static int errorCount = 0;
+    private static String[][] data = {
+        { "hh:mma", "-1:30AM" },
+        { "hh:mma", "00:30AM" },
+        { "hh:mma", "13:30AM" },
+        { "kk:mm",  "-1:12" },
+        { "kk:mm",  "00:12" },
+        { "kk:mm",  "25:12" },
+    };
+
+    public static void main(String[] args) {
+        TimeZone tz = TimeZone.getDefault();
+        // Use "GMT" to avoid any surprises related to offset
+        // transitions.
+        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
+
+        try {
+            for (String[] item : data) {
+                test(item[0], item[1]);
+            }
+        } finally {
+            // Restore the default time zone
+            TimeZone.setDefault(tz);
+        }
+
+        if (errorCount > 0) {
+            throw new RuntimeException("Failed with " + errorCount + " error(s).");
+        }
+    }
+
+    private static void test(String pattern, String src) {
+        SimpleDateFormat sdf = new SimpleDateFormat(pattern, Locale.US);
+        sdf.setLenient(false);
+        ParsePosition pos = new ParsePosition(0);
+        System.out.printf("parse: \"%s\" with \"%s\"", src, pattern);
+        Date date = sdf.parse(src, pos);
+        System.out.printf(": date = %s, errorIndex = %d", date, pos.getErrorIndex());
+        if (date != null || pos.getErrorIndex() == -1) {
+            System.out.println(": failed");
+            errorCount++;
+        } else {
+            System.out.println(": passed");
+        }
+    }
+}
diff --git a/jdk/test/java/util/Locale/LocaleEnhanceTest.java b/jdk/test/java/util/Locale/LocaleEnhanceTest.java
index 44e6eaadff8a3d3b94c2639f359087c0cd960759..f7ed5ab3dfb5f183e25587d44d581d2b39299614 100644
--- a/jdk/test/java/util/Locale/LocaleEnhanceTest.java
+++ b/jdk/test/java/util/Locale/LocaleEnhanceTest.java
@@ -1201,6 +1201,49 @@ public class LocaleEnhanceTest extends LocaleTestFmwk {
         }
     }
 
+    public void testBug7002320() {
+        // forLanguageTag() and Builder.setLanguageTag(String)
+        // should add a location extension for following two cases.
+        //
+        // 1. language/country are "ja"/"JP" and the resolved variant (x-lvariant-*)
+        //    is exactly "JP" and no BCP 47 extensions are available, then add
+        //    a Unicode locale extension "ca-japanese".
+        // 2. language/country are "th"/"TH" and the resolved variant is exactly
+        //    "TH" and no BCP 47 extensions are available, then add a Unicode locale
+        //    extension "nu-thai".
+        //
+        String[][] testdata = {
+            {"ja-JP-x-lvariant-JP", "ja-JP-u-ca-japanese-x-lvariant-JP"},   // special case 1
+            {"ja-JP-x-lvariant-JP-XXX"},
+            {"ja-JP-u-ca-japanese-x-lvariant-JP"},
+            {"ja-JP-u-ca-gregory-x-lvariant-JP"},
+            {"ja-JP-u-cu-jpy-x-lvariant-JP"},
+            {"ja-x-lvariant-JP"},
+            {"th-TH-x-lvariant-TH", "th-TH-u-nu-thai-x-lvariant-TH"},   // special case 2
+            {"th-TH-u-nu-thai-x-lvariant-TH"},
+            {"en-US-x-lvariant-JP"},
+        };
+
+        Builder bldr = new Builder();
+
+        for (String[] data : testdata) {
+            String in = data[0];
+            String expected = (data.length == 1) ? data[0] : data[1];
+
+            // forLanguageTag
+            Locale loc = Locale.forLanguageTag(in);
+            String out = loc.toLanguageTag();
+            assertEquals("Language tag roundtrip by forLanguageTag with input: " + in, expected, out);
+
+            // setLanguageTag
+            bldr.clear();
+            bldr.setLanguageTag(in);
+            loc = bldr.build();
+            out = loc.toLanguageTag();
+            assertEquals("Language tag roundtrip by Builder.setLanguageTag with input: " + in, expected, out);
+        }
+    }
+
     ///
     /// utility asserts
     ///
diff --git a/jdk/test/java/util/concurrent/BlockingQueue/Interrupt.java b/jdk/test/java/util/concurrent/BlockingQueue/Interrupt.java
index 418515ded51fa1479fb893bf00f6564fe04ec90f..aafa92c42ed6c1df1b871717a31456feb256cf60 100644
--- a/jdk/test/java/util/concurrent/BlockingQueue/Interrupt.java
+++ b/jdk/test/java/util/concurrent/BlockingQueue/Interrupt.java
@@ -136,5 +136,5 @@ public class Interrupt {
         try {realMain(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
-    private static abstract class Fun {abstract void f() throws Throwable;}
+    private abstract static class Fun {abstract void f() throws Throwable;}
 }
diff --git a/jdk/test/java/util/concurrent/BlockingQueue/LoopHelpers.java b/jdk/test/java/util/concurrent/BlockingQueue/LoopHelpers.java
index f6bac816a7babe3f6b058ac3aa74ce76bb1979e2..5bf6d0dbbee5900c0abe3cfa9a55aa6d8313e645 100644
--- a/jdk/test/java/util/concurrent/BlockingQueue/LoopHelpers.java
+++ b/jdk/test/java/util/concurrent/BlockingQueue/LoopHelpers.java
@@ -79,9 +79,9 @@ class LoopHelpers {
      * Basically same as java.util.Random.
      */
     public static class SimpleRandom {
-        private final static long multiplier = 0x5DEECE66DL;
-        private final static long addend = 0xBL;
-        private final static long mask = (1L << 48) - 1;
+        private static final long multiplier = 0x5DEECE66DL;
+        private static final long addend = 0xBL;
+        private static final long mask = (1L << 48) - 1;
         static final AtomicLong seq = new AtomicLong(1);
         private long seed = System.nanoTime() + seq.getAndIncrement();
 
diff --git a/jdk/test/java/util/concurrent/ConcurrentHashMap/LoopHelpers.java b/jdk/test/java/util/concurrent/ConcurrentHashMap/LoopHelpers.java
index f6bac816a7babe3f6b058ac3aa74ce76bb1979e2..5bf6d0dbbee5900c0abe3cfa9a55aa6d8313e645 100644
--- a/jdk/test/java/util/concurrent/ConcurrentHashMap/LoopHelpers.java
+++ b/jdk/test/java/util/concurrent/ConcurrentHashMap/LoopHelpers.java
@@ -79,9 +79,9 @@ class LoopHelpers {
      * Basically same as java.util.Random.
      */
     public static class SimpleRandom {
-        private final static long multiplier = 0x5DEECE66DL;
-        private final static long addend = 0xBL;
-        private final static long mask = (1L << 48) - 1;
+        private static final long multiplier = 0x5DEECE66DL;
+        private static final long addend = 0xBL;
+        private static final long mask = (1L << 48) - 1;
         static final AtomicLong seq = new AtomicLong(1);
         private long seed = System.nanoTime() + seq.getAndIncrement();
 
diff --git a/jdk/test/java/util/concurrent/ConcurrentHashMap/MapCheck.java b/jdk/test/java/util/concurrent/ConcurrentHashMap/MapCheck.java
index e9ca263c91088e424d95d4ef06ae0ba246103c82..c6075c131b94a45119d763def02734e235fa6ad2 100644
--- a/jdk/test/java/util/concurrent/ConcurrentHashMap/MapCheck.java
+++ b/jdk/test/java/util/concurrent/ConcurrentHashMap/MapCheck.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4486658
- * @compile MapCheck.java
+ * @compile -source 1.5 MapCheck.java
  * @run main/timeout=240 MapCheck
  * @summary Times and checks basic map operations
  */
@@ -64,7 +64,7 @@ public class MapCheck {
         if (args.length > 0) {
             try {
                 mapClass = Class.forName(args[0]);
-            } catch(ClassNotFoundException e) {
+            } catch (ClassNotFoundException e) {
                 throw new RuntimeException("Class " + args[0] + " not found.");
             }
         }
@@ -102,7 +102,7 @@ public class MapCheck {
         try {
             Map m = (Map)cl.newInstance();
             return m;
-        } catch(Exception e) {
+        } catch (Exception e) {
             throw new RuntimeException("Can't instantiate " + cl + ": " + e);
         }
     }
@@ -139,7 +139,7 @@ public class MapCheck {
             }
         }
         timer.finish();
-        reallyAssert (sum == expect * iters);
+        reallyAssert(sum == expect * iters);
     }
 
     static void t2(String nm, int n, Map s, Object[] key, int expect) {
@@ -149,7 +149,7 @@ public class MapCheck {
             if (s.remove(key[i]) != null) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == expect);
+        reallyAssert(sum == expect);
     }
 
     static void t3(String nm, int n, Map s, Object[] key, int expect) {
@@ -159,7 +159,7 @@ public class MapCheck {
             if (s.put(key[i], absent[i & absentMask]) == null) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == expect);
+        reallyAssert(sum == expect);
     }
 
     static void t4(String nm, int n, Map s, Object[] key, int expect) {
@@ -169,7 +169,7 @@ public class MapCheck {
             if (s.containsKey(key[i])) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == expect);
+        reallyAssert(sum == expect);
     }
 
     static void t5(String nm, int n, Map s, Object[] key, int expect) {
@@ -179,7 +179,7 @@ public class MapCheck {
             if (s.remove(key[i]) != null) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == expect);
+        reallyAssert(sum == expect);
     }
 
     static void t6(String nm, int n, Map s, Object[] k1, Object[] k2) {
@@ -190,7 +190,7 @@ public class MapCheck {
             if (s.get(k2[i & absentMask]) != null) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == n);
+        reallyAssert(sum == n);
     }
 
     static void t7(String nm, int n, Map s, Object[] k1, Object[] k2) {
@@ -201,7 +201,7 @@ public class MapCheck {
             if (s.containsKey(k2[i & absentMask])) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == n);
+        reallyAssert(sum == n);
     }
 
     static void t8(String nm, int n, Map s, Object[] key, int expect) {
@@ -211,7 +211,7 @@ public class MapCheck {
             if (s.get(key[i]) != null) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == expect);
+        reallyAssert(sum == expect);
     }
 
 
@@ -223,7 +223,7 @@ public class MapCheck {
         for (int i = 0; i < absentSize; i += step)
             if (s.containsValue(absent[i])) ++sum;
         timer.finish();
-        reallyAssert (sum != 0);
+        reallyAssert(sum != 0);
     }
 
 
@@ -235,7 +235,7 @@ public class MapCheck {
             if (ks.contains(key[i])) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
     }
 
 
@@ -243,37 +243,37 @@ public class MapCheck {
         int sum = 0;
         timer.start("Iter Key               ", size);
         for (Iterator it = s.keySet().iterator(); it.hasNext(); ) {
-            if(it.next() != MISSING)
+            if (it.next() != MISSING)
                 ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
     }
 
     static void ittest2(Map s, int size) {
         int sum = 0;
         timer.start("Iter Value             ", size);
         for (Iterator it = s.values().iterator(); it.hasNext(); ) {
-            if(it.next() != MISSING)
+            if (it.next() != MISSING)
                 ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
     }
     static void ittest3(Map s, int size) {
         int sum = 0;
         timer.start("Iter Entry             ", size);
         for (Iterator it = s.entrySet().iterator(); it.hasNext(); ) {
-            if(it.next() != MISSING)
+            if (it.next() != MISSING)
                 ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
     }
 
     static void ittest4(Map s, int size, int pos) {
         IdentityHashMap seen = new IdentityHashMap(size);
-        reallyAssert (s.size() == size);
+        reallyAssert(s.size() == size);
         int sum = 0;
         timer.start("Iter XEntry            ", size);
         Iterator it = s.entrySet().iterator();
@@ -287,9 +287,9 @@ public class MapCheck {
             if (x != MISSING)
                 ++sum;
         }
-        reallyAssert (s.containsKey(k));
+        reallyAssert(s.containsKey(k));
         it.remove();
-        reallyAssert (!s.containsKey(k));
+        reallyAssert(!s.containsKey(k));
         while (it.hasNext()) {
             Map.Entry x = (Map.Entry)(it.next());
             Object k2 = x.getKey();
@@ -298,12 +298,12 @@ public class MapCheck {
                 ++sum;
         }
 
-        reallyAssert (s.size() == size-1);
+        reallyAssert(s.size() == size-1);
         s.put(k, v);
-        reallyAssert (seen.size() == size);
+        reallyAssert(seen.size() == size);
         timer.finish();
-        reallyAssert (sum == size);
-        reallyAssert (s.size() == size);
+        reallyAssert(sum == size);
+        reallyAssert(s.size() == size);
     }
 
 
@@ -324,7 +324,7 @@ public class MapCheck {
                 ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
     }
 
     static void entest2(Hashtable ht, int size) {
@@ -335,7 +335,7 @@ public class MapCheck {
                 ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
     }
 
 
@@ -349,7 +349,7 @@ public class MapCheck {
                 ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
     }
 
     static void entest4(Hashtable ht, int size) {
@@ -361,7 +361,7 @@ public class MapCheck {
                 ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
     }
 
     static void entest(Map s, int size) {
@@ -409,13 +409,13 @@ public class MapCheck {
 
         timer.start("Iter Equals            ", size * 2);
         boolean eqt = s2.equals(s) && s.equals(s2);
-        reallyAssert (eqt);
+        reallyAssert(eqt);
         timer.finish();
 
         timer.start("Iter HashCode          ", size * 2);
         int shc = s.hashCode();
         int s2hc = s2.hashCode();
-        reallyAssert (shc == s2hc);
+        reallyAssert(shc == s2hc);
         timer.finish();
 
         timer.start("Put (present)          ", size);
@@ -430,7 +430,7 @@ public class MapCheck {
             if (es2.contains(entry)) ++sum;
         }
         timer.finish();
-        reallyAssert (sum == size);
+        reallyAssert(sum == size);
 
         t6("Get                    ", size, s2, key, absent);
 
@@ -438,13 +438,13 @@ public class MapCheck {
         s2.put(key[size-1], absent[0]);
         timer.start("Iter Equals            ", size * 2);
         eqt = s2.equals(s) && s.equals(s2);
-        reallyAssert (!eqt);
+        reallyAssert(!eqt);
         timer.finish();
 
         timer.start("Iter HashCode          ", size * 2);
         int s1h = s.hashCode();
         int s2h = s2.hashCode();
-        reallyAssert (s1h != s2h);
+        reallyAssert(s1h != s2h);
         timer.finish();
 
         s2.put(key[size-1], hold);
@@ -455,12 +455,12 @@ public class MapCheck {
             es.remove(s2i.next());
         timer.finish();
 
-        reallyAssert (s.isEmpty());
+        reallyAssert(s.isEmpty());
 
         timer.start("Clear                  ", size);
         s2.clear();
         timer.finish();
-        reallyAssert (s2.isEmpty() && s.isEmpty());
+        reallyAssert(s2.isEmpty() && s.isEmpty());
     }
 
     static void stest(Map s, int size) throws Exception {
@@ -489,7 +489,7 @@ public class MapCheck {
         System.out.print(time + "ms");
 
         if (s instanceof IdentityHashMap) return;
-        reallyAssert (s.equals(m));
+        reallyAssert(s.equals(m));
     }
 
 
diff --git a/jdk/test/java/util/concurrent/ConcurrentHashMap/MapLoops.java b/jdk/test/java/util/concurrent/ConcurrentHashMap/MapLoops.java
index 5f3d375515e7ecf2321fc1809d7f88f51f0fd8e9..53ed2919a9d82b1ef0580b8730b7cf5565bf10cb 100644
--- a/jdk/test/java/util/concurrent/ConcurrentHashMap/MapLoops.java
+++ b/jdk/test/java/util/concurrent/ConcurrentHashMap/MapLoops.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4486658
- * @compile MapLoops.java
+ * @compile -source 1.5 MapLoops.java
  * @run main/timeout=1600 MapLoops
  * @summary Exercise multithreaded maps, by default ConcurrentHashMap.
  * Multithreaded hash table test.  Each thread does a random walk
@@ -225,7 +225,7 @@ public class MapLoops {
                 barrier.await();
             }
             catch (Throwable throwable) {
-                synchronized(System.err) {
+                synchronized (System.err) {
                     System.err.println("--------------------------------");
                     throwable.printStackTrace();
                 }
diff --git a/jdk/test/java/util/concurrent/ConcurrentQueues/LoopHelpers.java b/jdk/test/java/util/concurrent/ConcurrentQueues/LoopHelpers.java
index f6bac816a7babe3f6b058ac3aa74ce76bb1979e2..5bf6d0dbbee5900c0abe3cfa9a55aa6d8313e645 100644
--- a/jdk/test/java/util/concurrent/ConcurrentQueues/LoopHelpers.java
+++ b/jdk/test/java/util/concurrent/ConcurrentQueues/LoopHelpers.java
@@ -79,9 +79,9 @@ class LoopHelpers {
      * Basically same as java.util.Random.
      */
     public static class SimpleRandom {
-        private final static long multiplier = 0x5DEECE66DL;
-        private final static long addend = 0xBL;
-        private final static long mask = (1L << 48) - 1;
+        private static final long multiplier = 0x5DEECE66DL;
+        private static final long addend = 0xBL;
+        private static final long mask = (1L << 48) - 1;
         static final AtomicLong seq = new AtomicLong(1);
         private long seed = System.nanoTime() + seq.getAndIncrement();
 
diff --git a/jdk/test/java/util/concurrent/CopyOnWriteArrayList/EqualsRace.java b/jdk/test/java/util/concurrent/CopyOnWriteArrayList/EqualsRace.java
index ad063ea237aab85723e093d0fc53955ef1dae4a8..7bc8fab638b6995943ff4390928f82a455706dec 100644
--- a/jdk/test/java/util/concurrent/CopyOnWriteArrayList/EqualsRace.java
+++ b/jdk/test/java/util/concurrent/CopyOnWriteArrayList/EqualsRace.java
@@ -66,7 +66,7 @@ public class EqualsRace {
         try {realMain(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
-    private static abstract class CheckedThread extends Thread {
+    private abstract static class CheckedThread extends Thread {
         public abstract void realRun() throws Throwable;
         public void run() {
             try { realRun(); } catch (Throwable t) { unexpected(t); }}}
diff --git a/jdk/test/java/util/concurrent/CopyOnWriteArraySet/RacingCows.java b/jdk/test/java/util/concurrent/CopyOnWriteArraySet/RacingCows.java
index afde87549ed374e79abdae14621349b9760152a1..6d13dac3cca70e94efe46ae0912cdab9cceb0668 100644
--- a/jdk/test/java/util/concurrent/CopyOnWriteArraySet/RacingCows.java
+++ b/jdk/test/java/util/concurrent/CopyOnWriteArraySet/RacingCows.java
@@ -125,7 +125,7 @@ public class RacingCows {
         try {realMain(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
-    private static abstract class CheckedThread extends Thread {
+    private abstract static class CheckedThread extends Thread {
         public abstract void realRun() throws Throwable;
         public void run() {
             try { realRun(); } catch (Throwable t) { unexpected(t); }}}
diff --git a/jdk/test/java/util/concurrent/CyclicBarrier/Basic.java b/jdk/test/java/util/concurrent/CyclicBarrier/Basic.java
index b20a81ea2ffe314defba39e8b0ed7234bb8df86b..f0459d613d531c32bb1853f5779dbe36598efbbd 100644
--- a/jdk/test/java/util/concurrent/CyclicBarrier/Basic.java
+++ b/jdk/test/java/util/concurrent/CyclicBarrier/Basic.java
@@ -83,7 +83,7 @@ public class Basic {
     //----------------------------------------------------------------
     // Convenience methods for creating threads that call CyclicBarrier.await
     //----------------------------------------------------------------
-    private static abstract class Awaiter extends Thread {
+    private abstract static class Awaiter extends Thread {
         static AtomicInteger count = new AtomicInteger(1);
 
         {
@@ -417,14 +417,14 @@ public class Basic {
         try {realMain(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
-    static abstract class Fun { abstract void f() throws Throwable; }
+    abstract static class Fun { abstract void f() throws Throwable; }
     private static void THROWS(Class k, Fun... fs) {
         for (Fun f : fs)
             try { f.f(); fail("Expected " + k.getName() + " not thrown"); }
             catch (Throwable t) {
                 if (k.isAssignableFrom(t.getClass())) pass();
                 else unexpected(t);}}
-    private static abstract class CheckedThread extends Thread {
+    private abstract static class CheckedThread extends Thread {
         abstract void realRun() throws Throwable;
         public void run() {
             try {realRun();} catch (Throwable t) {unexpected(t);}}}
diff --git a/jdk/test/java/util/concurrent/Exchanger/ExchangeLoops.java b/jdk/test/java/util/concurrent/Exchanger/ExchangeLoops.java
index b207b8c2d92f494c15ce51fd0c24a21ae3d08707..2055c056ca33215aae45ea7648b7372107484f46 100644
--- a/jdk/test/java/util/concurrent/Exchanger/ExchangeLoops.java
+++ b/jdk/test/java/util/concurrent/Exchanger/ExchangeLoops.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4486658
- * @compile ExchangeLoops.java
+ * @compile -source 1.5 ExchangeLoops.java
  * @run main/timeout=720 ExchangeLoops
  * @summary checks to make sure a pipeline of exchangers passes data.
  */
@@ -78,9 +78,9 @@ public class ExchangeLoops {
         final Exchanger right;
         final CyclicBarrier barrier;
         volatile int result;
-        Stage (Exchanger left,
-               Exchanger right,
-               CyclicBarrier b, int iters) {
+        Stage(Exchanger left,
+              Exchanger right,
+              CyclicBarrier b, int iters) {
             this.left = left;
             this.right = right;
             barrier = b;
diff --git a/jdk/test/java/util/concurrent/Exchanger/LoopHelpers.java b/jdk/test/java/util/concurrent/Exchanger/LoopHelpers.java
index d3dd5b4a5ef182500f5f8c375c941c01e96bb1a9..6b65b8b2d4aa5b0eec43287030d252a71b89e0cd 100644
--- a/jdk/test/java/util/concurrent/Exchanger/LoopHelpers.java
+++ b/jdk/test/java/util/concurrent/Exchanger/LoopHelpers.java
@@ -78,9 +78,9 @@ class LoopHelpers {
      * Basically same as java.util.Random.
      */
     public static class SimpleRandom {
-        private final static long multiplier = 0x5DEECE66DL;
-        private final static long addend = 0xBL;
-        private final static long mask = (1L << 48) - 1;
+        private static final long multiplier = 0x5DEECE66DL;
+        private static final long addend = 0xBL;
+        private static final long mask = (1L << 48) - 1;
         static final AtomicLong seq = new AtomicLong(1);
         private long seed = System.nanoTime() + seq.getAndIncrement();
 
diff --git a/jdk/test/java/util/concurrent/ExecutorCompletionService/ExecutorCompletionServiceLoops.java b/jdk/test/java/util/concurrent/ExecutorCompletionService/ExecutorCompletionServiceLoops.java
index 2c67ba5697d34270eadb9345d5587b005331f098..71c45e75f7fa3e7a28d804dc5ec8543587e50e4e 100644
--- a/jdk/test/java/util/concurrent/ExecutorCompletionService/ExecutorCompletionServiceLoops.java
+++ b/jdk/test/java/util/concurrent/ExecutorCompletionService/ExecutorCompletionServiceLoops.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4965960
- * @compile ExecutorCompletionServiceLoops.java
+ * @compile -source 1.5 ExecutorCompletionServiceLoops.java
  * @run main/timeout=3600 ExecutorCompletionServiceLoops
  * @summary  Exercise ExecutorCompletionServiceLoops
  */
diff --git a/jdk/test/java/util/concurrent/ExecutorCompletionService/LoopHelpers.java b/jdk/test/java/util/concurrent/ExecutorCompletionService/LoopHelpers.java
index d3dd5b4a5ef182500f5f8c375c941c01e96bb1a9..6b65b8b2d4aa5b0eec43287030d252a71b89e0cd 100644
--- a/jdk/test/java/util/concurrent/ExecutorCompletionService/LoopHelpers.java
+++ b/jdk/test/java/util/concurrent/ExecutorCompletionService/LoopHelpers.java
@@ -78,9 +78,9 @@ class LoopHelpers {
      * Basically same as java.util.Random.
      */
     public static class SimpleRandom {
-        private final static long multiplier = 0x5DEECE66DL;
-        private final static long addend = 0xBL;
-        private final static long mask = (1L << 48) - 1;
+        private static final long multiplier = 0x5DEECE66DL;
+        private static final long addend = 0xBL;
+        private static final long mask = (1L << 48) - 1;
         static final AtomicLong seq = new AtomicLong(1);
         private long seed = System.nanoTime() + seq.getAndIncrement();
 
diff --git a/jdk/test/java/util/concurrent/Executors/Throws.java b/jdk/test/java/util/concurrent/Executors/Throws.java
index c310ad5c9ec801884e592d54c39b2b23bc66bc72..d98537931ee39f2139deb39cd2ea91681d29df08 100644
--- a/jdk/test/java/util/concurrent/Executors/Throws.java
+++ b/jdk/test/java/util/concurrent/Executors/Throws.java
@@ -122,7 +122,7 @@ public class Throws {
         try {realMain(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
-    private static abstract class Fun {abstract void f() throws Throwable;}
+    private abstract static class Fun {abstract void f() throws Throwable;}
     static void THROWS(Class k, Fun... fs) {
         for (Fun f : fs)
             try { f.f(); fail("Expected " + k.getName() + " not thrown"); }
diff --git a/jdk/test/java/util/concurrent/FutureTask/BlockingTaskExecutor.java b/jdk/test/java/util/concurrent/FutureTask/BlockingTaskExecutor.java
index bd6c2e839da52eac2987c2d9d85d2f0c1e6042c8..4c6f12ba29d44486b50791b5fcb0b4a71ff79d76 100644
--- a/jdk/test/java/util/concurrent/FutureTask/BlockingTaskExecutor.java
+++ b/jdk/test/java/util/concurrent/FutureTask/BlockingTaskExecutor.java
@@ -87,7 +87,7 @@ public class BlockingTaskExecutor {
      * A helper class with a method to wait for a notification.
      *
      * The notification is received via the
-     * sendNotification method.
+     * {@code sendNotification} method.
      */
     static class NotificationReceiver {
         /** Has the notifiee been notified? */
diff --git a/jdk/test/java/util/concurrent/FutureTask/CancelledFutureLoops.java b/jdk/test/java/util/concurrent/FutureTask/CancelledFutureLoops.java
index c12f5cde94463d5ffc6e097b7c318e4658a6a3d1..6a0ca8c93df8c466dd66cce3fd4255ffa43e46fe 100644
--- a/jdk/test/java/util/concurrent/FutureTask/CancelledFutureLoops.java
+++ b/jdk/test/java/util/concurrent/FutureTask/CancelledFutureLoops.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4486658
- * @compile CancelledFutureLoops.java
+ * @compile -source 1.5 CancelledFutureLoops.java
  * @run main/timeout=2000 CancelledFutureLoops
  * @summary Checks for responsiveness of futures to cancellation.
  * Runs under the assumption that ITERS computations require more than
@@ -64,10 +64,10 @@ public final class CancelledFutureLoops {
             try {
                 new FutureLoop(i).test();
             }
-            catch(BrokenBarrierException bb) {
+            catch (BrokenBarrierException bb) {
                 // OK; ignore
             }
-            catch(ExecutionException ee) {
+            catch (ExecutionException ee) {
                 // OK; ignore
             }
             Thread.sleep(TIMEOUT);
diff --git a/jdk/test/java/util/concurrent/FutureTask/Customized.java b/jdk/test/java/util/concurrent/FutureTask/Customized.java
index 1f1f8fb49391aa81922d203a7379c17ddc753951..5d107c58ad1ec473c83cb6b2b790b289c650ab2e 100644
--- a/jdk/test/java/util/concurrent/FutureTask/Customized.java
+++ b/jdk/test/java/util/concurrent/FutureTask/Customized.java
@@ -203,7 +203,7 @@ public class Customized {
         try {realMain(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
-    private static abstract class Fun {abstract void f() throws Throwable;}
+    private abstract static class Fun {abstract void f() throws Throwable;}
     static void THROWS(Class k, Fun... fs) {
         for (Fun f : fs)
             try { f.f(); fail("Expected " + k.getName() + " not thrown"); }
diff --git a/jdk/test/java/util/concurrent/FutureTask/LoopHelpers.java b/jdk/test/java/util/concurrent/FutureTask/LoopHelpers.java
index d3dd5b4a5ef182500f5f8c375c941c01e96bb1a9..6b65b8b2d4aa5b0eec43287030d252a71b89e0cd 100644
--- a/jdk/test/java/util/concurrent/FutureTask/LoopHelpers.java
+++ b/jdk/test/java/util/concurrent/FutureTask/LoopHelpers.java
@@ -78,9 +78,9 @@ class LoopHelpers {
      * Basically same as java.util.Random.
      */
     public static class SimpleRandom {
-        private final static long multiplier = 0x5DEECE66DL;
-        private final static long addend = 0xBL;
-        private final static long mask = (1L << 48) - 1;
+        private static final long multiplier = 0x5DEECE66DL;
+        private static final long addend = 0xBL;
+        private static final long mask = (1L << 48) - 1;
         static final AtomicLong seq = new AtomicLong(1);
         private long seed = System.nanoTime() + seq.getAndIncrement();
 
diff --git a/jdk/test/java/util/concurrent/ScheduledThreadPoolExecutor/DelayOverflow.java b/jdk/test/java/util/concurrent/ScheduledThreadPoolExecutor/DelayOverflow.java
index 2e0854b0fc7c21618fc87b8e1a115c71ae05abfc..bc34d00965fc0a7a5bd89b4add0617f15c60be35 100644
--- a/jdk/test/java/util/concurrent/ScheduledThreadPoolExecutor/DelayOverflow.java
+++ b/jdk/test/java/util/concurrent/ScheduledThreadPoolExecutor/DelayOverflow.java
@@ -161,11 +161,8 @@ public class DelayOverflow {
         if (x == null ? y == null : x.equals(y)) pass();
         else fail(x + " not equal to " + y);}
     public static void main(String[] args) throws Throwable {
-        Class k = new Object(){}.getClass().getEnclosingClass();
-        try {k.getMethod("instanceMain",String[].class)
-                .invoke( k.newInstance(), (Object) args);}
-        catch (Throwable e) {throw e.getCause();}}
-    public void instanceMain(String[] args) throws Throwable {
+        new DelayOverflow().instanceMain(args);}
+    void instanceMain(String[] args) throws Throwable {
         try {test(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
diff --git a/jdk/test/java/util/concurrent/ThreadPoolExecutor/ConfigChanges.java b/jdk/test/java/util/concurrent/ThreadPoolExecutor/ConfigChanges.java
index 40d11e04b311b42619226b3f1157be6839b59540..4c69a594bcbad6670146287bc62a125ff41324b2 100644
--- a/jdk/test/java/util/concurrent/ThreadPoolExecutor/ConfigChanges.java
+++ b/jdk/test/java/util/concurrent/ThreadPoolExecutor/ConfigChanges.java
@@ -36,9 +36,9 @@ import java.util.concurrent.atomic.*;
 import static java.util.concurrent.TimeUnit.*;
 
 public class ConfigChanges {
-    final static ThreadGroup tg = new ThreadGroup("pool");
+    static final ThreadGroup tg = new ThreadGroup("pool");
 
-    final static Random rnd = new Random();
+    static final Random rnd = new Random();
 
     static void report(ThreadPoolExecutor tpe) {
         try {
@@ -241,7 +241,7 @@ public class ConfigChanges {
         try {realMain(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
-    private static abstract class Fun {abstract void f() throws Throwable;}
+    private abstract static class Fun {abstract void f() throws Throwable;}
     static void THROWS(Class k, Fun... fs) {
         for (Fun f : fs)
             try { f.f(); fail("Expected " + k.getName() + " not thrown"); }
diff --git a/jdk/test/java/util/concurrent/ThreadPoolExecutor/Custom.java b/jdk/test/java/util/concurrent/ThreadPoolExecutor/Custom.java
index 108ca7bd4fc6ce100bf4e712dddf267e86e514c7..d60bdcefdea872d9c4e829464c54e4f29a72f25a 100644
--- a/jdk/test/java/util/concurrent/ThreadPoolExecutor/Custom.java
+++ b/jdk/test/java/util/concurrent/ThreadPoolExecutor/Custom.java
@@ -43,7 +43,7 @@ public class Custom {
 
 
     private static class CustomTask extends FutureTask {
-        public final static AtomicInteger births = new AtomicInteger(0);
+        public static final AtomicInteger births = new AtomicInteger(0);
         CustomTask(Callable c) { super(c); births.getAndIncrement(); }
         CustomTask(Runnable r, V v) { super(r, v); births.getAndIncrement(); }
     }
@@ -63,7 +63,7 @@ public class Custom {
     }
 
     private static class CustomSTPE extends ScheduledThreadPoolExecutor {
-        public final static AtomicInteger decorations = new AtomicInteger(0);
+        public static final AtomicInteger decorations = new AtomicInteger(0);
         CustomSTPE() {
             super(threadCount);
         }
@@ -89,7 +89,7 @@ public class Custom {
         return count;
     }
 
-    private final static int threadCount = 10;
+    private static final int threadCount = 10;
 
     public static void main(String[] args) throws Throwable {
         CustomTPE tpe = new CustomTPE();
diff --git a/jdk/test/java/util/concurrent/ThreadPoolExecutor/ScheduledTickleService.java b/jdk/test/java/util/concurrent/ThreadPoolExecutor/ScheduledTickleService.java
index 94c71e72605af2a110f4f7423d470d56a98e4cfd..a0c3b53d5e14fcb0f88cecf4b85e08d9b691fa4c 100644
--- a/jdk/test/java/util/concurrent/ThreadPoolExecutor/ScheduledTickleService.java
+++ b/jdk/test/java/util/concurrent/ThreadPoolExecutor/ScheduledTickleService.java
@@ -37,10 +37,10 @@ public class ScheduledTickleService {
 
     // We get intermittent ClassCastException if greater than 1
     // because of calls to compareTo
-    private final static int concurrency = 2;
+    private static final int concurrency = 2;
 
     // Record when tasks are done
-    public final static CountDownLatch done = new CountDownLatch(concurrency);
+    public static final CountDownLatch done = new CountDownLatch(concurrency);
 
     public static void realMain(String... args) throws InterruptedException {
         // our tickle service
diff --git a/jdk/test/java/util/concurrent/ThreadPoolExecutor/ShutdownNowExecuteRace.java b/jdk/test/java/util/concurrent/ThreadPoolExecutor/ShutdownNowExecuteRace.java
index b2a8313893cf8ec08ee9e4ef1b332369f25814f7..04b08ef6f379749774cede4c88164a4811d7039c 100644
--- a/jdk/test/java/util/concurrent/ThreadPoolExecutor/ShutdownNowExecuteRace.java
+++ b/jdk/test/java/util/concurrent/ThreadPoolExecutor/ShutdownNowExecuteRace.java
@@ -40,7 +40,7 @@ public class ShutdownNowExecuteRace {
     static volatile boolean quit = false;
     static volatile ThreadPoolExecutor pool = null;
 
-    final static Runnable sleeper = new Runnable() { public void run() {
+    static final Runnable sleeper = new Runnable() { public void run() {
         final long ONE_HOUR = 1000L * 60L * 60L;
         try { Thread.sleep(ONE_HOUR); }
         catch (InterruptedException ie) {}
@@ -81,14 +81,14 @@ public class ShutdownNowExecuteRace {
         try {realMain(args);} catch (Throwable t) {unexpected(t);}
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
         if (failed > 0) throw new AssertionError("Some tests failed");}
-    private static abstract class Fun {abstract void f() throws Throwable;}
+    private abstract static class Fun {abstract void f() throws Throwable;}
     static void THROWS(Class k, Fun... fs) {
         for (Fun f : fs)
             try { f.f(); fail("Expected " + k.getName() + " not thrown"); }
             catch (Throwable t) {
                 if (k.isAssignableFrom(t.getClass())) pass();
                 else unexpected(t);}}
-    private static abstract class CheckedThread extends Thread {
+    private abstract static class CheckedThread extends Thread {
         abstract void realRun() throws Throwable;
         public void run() {
             try {realRun();} catch (Throwable t) {unexpected(t);}}}
diff --git a/jdk/test/java/util/concurrent/ThreadPoolExecutor/ThrowingTasks.java b/jdk/test/java/util/concurrent/ThreadPoolExecutor/ThrowingTasks.java
index 6ff46c95c6bf0f3bf9c0248bb405e82bc160f033..534bf59f52ef9613584f4070a4c42d76bdc3d065 100644
--- a/jdk/test/java/util/concurrent/ThreadPoolExecutor/ThrowingTasks.java
+++ b/jdk/test/java/util/concurrent/ThreadPoolExecutor/ThrowingTasks.java
@@ -35,7 +35,7 @@ import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
 public class ThrowingTasks {
-    final static Random rnd = new Random();
+    static final Random rnd = new Random();
 
     @SuppressWarnings("serial")
     static class UncaughtExceptions
@@ -65,16 +65,16 @@ public class ThrowingTasks {
         }
     }
 
-    final static UncaughtExceptions uncaughtExceptions
+    static final UncaughtExceptions uncaughtExceptions
         = new UncaughtExceptions();
-    final static UncaughtExceptionsTable uncaughtExceptionsTable
+    static final UncaughtExceptionsTable uncaughtExceptionsTable
         = new UncaughtExceptionsTable();
-    final static AtomicLong totalUncaughtExceptions
+    static final AtomicLong totalUncaughtExceptions
         = new AtomicLong(0);
-    final static CountDownLatch uncaughtExceptionsLatch
+    static final CountDownLatch uncaughtExceptionsLatch
         = new CountDownLatch(24);
 
-    final static Thread.UncaughtExceptionHandler handler
+    static final Thread.UncaughtExceptionHandler handler
         = new Thread.UncaughtExceptionHandler() {
                 public void uncaughtException(Thread t, Throwable e) {
                     check(! Thread.currentThread().isInterrupted());
@@ -84,19 +84,19 @@ public class ThrowingTasks {
                     uncaughtExceptionsLatch.countDown();
                 }};
 
-    final static ThreadGroup tg = new ThreadGroup("Flaky");
+    static final ThreadGroup tg = new ThreadGroup("Flaky");
 
-    final static ThreadFactory tf = new ThreadFactory() {
+    static final ThreadFactory tf = new ThreadFactory() {
             public Thread newThread(Runnable r) {
                 Thread t = new Thread(tg, r);
                 t.setUncaughtExceptionHandler(handler);
                 return t;
             }};
 
-    final static RuntimeException rte = new RuntimeException();
-    final static Error error = new Error();
-    final static Throwable weird = new Throwable();
-    final static Exception checkedException = new Exception();
+    static final RuntimeException rte = new RuntimeException();
+    static final Error error = new Error();
+    static final Throwable weird = new Throwable();
+    static final Exception checkedException = new Exception();
 
     static class Thrower implements Runnable {
         Throwable t;
@@ -105,13 +105,13 @@ public class ThrowingTasks {
         public void run() { if (t != null) Thread.currentThread().stop(t); }
     }
 
-    final static Thrower noThrower      = new Thrower(null);
-    final static Thrower rteThrower     = new Thrower(rte);
-    final static Thrower errorThrower   = new Thrower(error);
-    final static Thrower weirdThrower   = new Thrower(weird);
-    final static Thrower checkedThrower = new Thrower(checkedException);
+    static final Thrower noThrower      = new Thrower(null);
+    static final Thrower rteThrower     = new Thrower(rte);
+    static final Thrower errorThrower   = new Thrower(error);
+    static final Thrower weirdThrower   = new Thrower(weird);
+    static final Thrower checkedThrower = new Thrower(checkedException);
 
-    final static List throwers = Arrays.asList(
+    static final List throwers = Arrays.asList(
         noThrower, rteThrower, errorThrower, weirdThrower, checkedThrower);
 
     static class Flaky implements Runnable {
diff --git a/jdk/test/java/util/concurrent/atomic/VMSupportsCS8.java b/jdk/test/java/util/concurrent/atomic/VMSupportsCS8.java
index 09c648c3fca35ef96abdb92a0a839504aabf423b..72ad18a9a3060599ae69b3564354aade09bee3c6 100644
--- a/jdk/test/java/util/concurrent/atomic/VMSupportsCS8.java
+++ b/jdk/test/java/util/concurrent/atomic/VMSupportsCS8.java
@@ -24,6 +24,8 @@
 /*
  * @test
  * @bug 4992443 4994819
+ * @compile -source 1.5 VMSupportsCS8.java
+ * @run main VMSupportsCS8
  * @summary Checks that the value of VMSupportsCS8 matches system properties.
  */
 
diff --git a/jdk/test/java/util/concurrent/locks/Lock/FlakyMutex.java b/jdk/test/java/util/concurrent/locks/Lock/FlakyMutex.java
index 5d4fc70460d6e59ac212c8a7ca600ebb6c1c905f..acee4b9826098ac05fb46bf615cd0d2e17690455 100644
--- a/jdk/test/java/util/concurrent/locks/Lock/FlakyMutex.java
+++ b/jdk/test/java/util/concurrent/locks/Lock/FlakyMutex.java
@@ -75,10 +75,10 @@ public class FlakyMutex implements Lock {
                             catch (Throwable t) { checkThrowable(t); }
                         }
 
-                        try { check (! m.tryLock()); }
+                        try { check(! m.tryLock()); }
                         catch (Throwable t) { checkThrowable(t); }
 
-                        try { check (! m.tryLock(1, TimeUnit.MICROSECONDS)); }
+                        try { check(! m.tryLock(1, TimeUnit.MICROSECONDS)); }
                         catch (Throwable t) { checkThrowable(t); }
 
                         m.unlock();
diff --git a/jdk/test/java/util/concurrent/locks/Lock/TimedAcquireLeak.java b/jdk/test/java/util/concurrent/locks/Lock/TimedAcquireLeak.java
index 5fd884ad33c7652070e2ee132cd0ce9804d9275f..4f00f19abfd96b19c8a8cc02fec6c66b06c11f9c 100644
--- a/jdk/test/java/util/concurrent/locks/Lock/TimedAcquireLeak.java
+++ b/jdk/test/java/util/concurrent/locks/Lock/TimedAcquireLeak.java
@@ -64,7 +64,7 @@ public class TimedAcquireLeak {
         return outputOf(new InputStreamReader(is, "UTF-8"));
     }
 
-    final static ExecutorService drainers = Executors.newFixedThreadPool(12);
+    static final ExecutorService drainers = Executors.newFixedThreadPool(12);
     static Future futureOutputOf(final InputStream is) {
         return drainers.submit(
             new Callable() { public String call() throws IOException {
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantLock/CancelledLockLoops.java b/jdk/test/java/util/concurrent/locks/ReentrantLock/CancelledLockLoops.java
index fc769df409294cf59bc27c1f39db6208989b821f..3f7667c247a15c69964fb97f8b17638296383292 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantLock/CancelledLockLoops.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantLock/CancelledLockLoops.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4486658
- * @compile CancelledLockLoops.java
+ * @compile -source 1.5 CancelledLockLoops.java
  * @run main/timeout=2800 CancelledLockLoops
  * @summary tests lockInterruptibly.
  * Checks for responsiveness of locks to interrupts. Runs under that
@@ -64,7 +64,7 @@ public final class CancelledLockLoops {
             try {
                 new ReentrantLockLoop(i).test();
             }
-            catch(BrokenBarrierException bb) {
+            catch (BrokenBarrierException bb) {
                 // OK, ignore
             }
             Thread.sleep(TIMEOUT);
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantLock/LockOncePerThreadLoops.java b/jdk/test/java/util/concurrent/locks/ReentrantLock/LockOncePerThreadLoops.java
index 88b2f2d00b14f31078110773bbb4a796c4accb98..8682e24dbab8b8af2c4cb1236f17af3e8b10763a 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantLock/LockOncePerThreadLoops.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantLock/LockOncePerThreadLoops.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4486658
- * @compile LockOncePerThreadLoops.java
+ * @compile -source 1.5 LockOncePerThreadLoops.java
  * @run main/timeout=15000 LockOncePerThreadLoops
  * @summary Checks for missed signals by locking and unlocking each of an array of locks once per thread
  */
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantLock/LoopHelpers.java b/jdk/test/java/util/concurrent/locks/ReentrantLock/LoopHelpers.java
index d3dd5b4a5ef182500f5f8c375c941c01e96bb1a9..6b65b8b2d4aa5b0eec43287030d252a71b89e0cd 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantLock/LoopHelpers.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantLock/LoopHelpers.java
@@ -78,9 +78,9 @@ class LoopHelpers {
      * Basically same as java.util.Random.
      */
     public static class SimpleRandom {
-        private final static long multiplier = 0x5DEECE66DL;
-        private final static long addend = 0xBL;
-        private final static long mask = (1L << 48) - 1;
+        private static final long multiplier = 0x5DEECE66DL;
+        private static final long addend = 0xBL;
+        private static final long mask = (1L << 48) - 1;
         static final AtomicLong seq = new AtomicLong(1);
         private long seed = System.nanoTime() + seq.getAndIncrement();
 
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantLock/SimpleReentrantLockLoops.java b/jdk/test/java/util/concurrent/locks/ReentrantLock/SimpleReentrantLockLoops.java
index ac85bba4c3f646393973713c5036fb0ee6b49cbd..db7d5af61dc1ab205ac4c8cff69c0af15a23022a 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantLock/SimpleReentrantLockLoops.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantLock/SimpleReentrantLockLoops.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4486658
- * @compile SimpleReentrantLockLoops.java
+ * @compile -source 1.5 SimpleReentrantLockLoops.java
  * @run main/timeout=4500 SimpleReentrantLockLoops
  * @summary multiple threads using a single lock
  */
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantLock/TimeoutLockLoops.java b/jdk/test/java/util/concurrent/locks/ReentrantLock/TimeoutLockLoops.java
index 0a90bebc352fb264738efff6983ba40b0938593f..3c20867531a976a8cacde8747b1ca34b9ec1ae96 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantLock/TimeoutLockLoops.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantLock/TimeoutLockLoops.java
@@ -34,6 +34,8 @@
 /*
  * @test
  * @bug 4486658 5031862
+ * @compile -source 1.5 TimeoutLockLoops.java
+ * @run main TimeoutLockLoops
  * @summary Checks for responsiveness of locks to timeouts.
  * Runs under the assumption that ITERS computations require more than
  * TIMEOUT msecs to complete, which seems to be a safe assumption for
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/Bug6571733.java b/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/Bug6571733.java
index c63e7a30c77371ea97820c28f1516d6cad815c40..0a65d352a90846bdcfb4e6088af636dafe48f599 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/Bug6571733.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/Bug6571733.java
@@ -45,7 +45,7 @@ public class Bug6571733 {
 
         Thread thread = new Thread() { public void run() {
             try {
-                check (! lock.writeLock().tryLock(0, TimeUnit.DAYS));
+                check(! lock.writeLock().tryLock(0, TimeUnit.DAYS));
 
                 lock.readLock().lock();
                 lock.readLock().unlock();
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/LoopHelpers.java b/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/LoopHelpers.java
index d3dd5b4a5ef182500f5f8c375c941c01e96bb1a9..6b65b8b2d4aa5b0eec43287030d252a71b89e0cd 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/LoopHelpers.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/LoopHelpers.java
@@ -78,9 +78,9 @@ class LoopHelpers {
      * Basically same as java.util.Random.
      */
     public static class SimpleRandom {
-        private final static long multiplier = 0x5DEECE66DL;
-        private final static long addend = 0xBL;
-        private final static long mask = (1L << 48) - 1;
+        private static final long multiplier = 0x5DEECE66DL;
+        private static final long addend = 0xBL;
+        private static final long mask = (1L << 48) - 1;
         static final AtomicLong seq = new AtomicLong(1);
         private long seed = System.nanoTime() + seq.getAndIncrement();
 
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/MapLoops.java b/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/MapLoops.java
index ce6651fbb2df6035e35e3d19662292f61512fe71..a8e47e5a25edf9dfeca3ca70c169c6223931c289 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/MapLoops.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/MapLoops.java
@@ -34,7 +34,7 @@
 /*
  * @test
  * @bug 4486658
- * @compile MapLoops.java
+ * @compile -source 1.5 MapLoops.java
  * @run main/timeout=4700 MapLoops
  * @summary Exercise multithreaded maps, by default ConcurrentHashMap.
  * Multithreaded hash table test.  Each thread does a random walk
@@ -65,7 +65,7 @@ public class MapLoops {
         if (args.length > 0) {
             try {
                 mapClass = Class.forName(args[0]);
-            } catch(ClassNotFoundException e) {
+            } catch (ClassNotFoundException e) {
                 throw new RuntimeException("Class " + args[0] + " not found.");
             }
         }
diff --git a/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/RWMap.java b/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/RWMap.java
index 8c5121e536a2921856a5fb878b28a7ab0062b2d8..53f63d6e33c01dca54eec675ddc62a5ff86e6749 100644
--- a/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/RWMap.java
+++ b/jdk/test/java/util/concurrent/locks/ReentrantReadWriteLock/RWMap.java
@@ -57,21 +57,33 @@ public class RWMap implements Map {
     }
 
     public int size() {
-        rwl.readLock().lock(); try {return m.size();} finally { rwl.readLock().unlock(); }
+        rwl.readLock().lock();
+        try { return m.size(); }
+        finally { rwl.readLock().unlock(); }
     }
-    public boolean isEmpty(){
-        rwl.readLock().lock(); try {return m.isEmpty();} finally { rwl.readLock().unlock(); }
+
+    public boolean isEmpty() {
+        rwl.readLock().lock();
+        try { return m.isEmpty(); }
+        finally { rwl.readLock().unlock(); }
     }
 
     public Object get(Object key) {
-        rwl.readLock().lock(); try {return m.get(key);} finally { rwl.readLock().unlock(); }
+        rwl.readLock().lock();
+        try { return m.get(key); }
+        finally { rwl.readLock().unlock(); }
     }
 
     public boolean containsKey(Object key) {
-        rwl.readLock().lock(); try {return m.containsKey(key);} finally { rwl.readLock().unlock(); }
+        rwl.readLock().lock();
+        try { return m.containsKey(key); }
+        finally { rwl.readLock().unlock(); }
     }
-    public boolean containsValue(Object value){
-        rwl.readLock().lock(); try {return m.containsValue(value);} finally { rwl.readLock().unlock(); }
+
+    public boolean containsValue(Object value) {
+        rwl.readLock().lock();
+        try { return m.containsValue(value); }
+        finally { rwl.readLock().unlock(); }
     }
 
 
@@ -88,28 +100,45 @@ public class RWMap implements Map {
     }
 
     public boolean equals(Object o) {
-        rwl.readLock().lock(); try {return m.equals(o);} finally { rwl.readLock().unlock(); }
+        rwl.readLock().lock();
+        try { return m.equals(o); }
+        finally { rwl.readLock().unlock(); }
     }
+
     public int hashCode() {
-        rwl.readLock().lock(); try {return m.hashCode();} finally { rwl.readLock().unlock(); }
+        rwl.readLock().lock();
+        try { return m.hashCode(); }
+        finally { rwl.readLock().unlock(); }
     }
+
     public String toString() {
-        rwl.readLock().lock(); try {return m.toString();} finally { rwl.readLock().unlock(); }
+        rwl.readLock().lock();
+        try { return m.toString(); }
+        finally { rwl.readLock().unlock(); }
     }
 
-
-
     public Object put(Object key, Object value) {
-        rwl.writeLock().lock(); try {return m.put(key, value);} finally { rwl.writeLock().unlock(); }
+        rwl.writeLock().lock();
+        try { return m.put(key, value); }
+        finally { rwl.writeLock().unlock(); }
     }
+
     public Object remove(Object key) {
-        rwl.writeLock().lock(); try {return m.remove(key);} finally { rwl.writeLock().unlock(); }
+        rwl.writeLock().lock();
+        try { return m.remove(key); }
+        finally { rwl.writeLock().unlock(); }
     }
+
     public void putAll(Map map) {
-        rwl.writeLock().lock(); try {m.putAll(map);} finally { rwl.writeLock().unlock(); }
+        rwl.writeLock().lock();
+        try { m.putAll(map); }
+        finally { rwl.writeLock().unlock(); }
     }
+
     public void clear() {
-        rwl.writeLock().lock(); try {m.clear();} finally { rwl.writeLock().unlock(); }
+        rwl.writeLock().lock();
+        try { m.clear(); }
+        finally { rwl.writeLock().unlock(); }
     }
 
 }
diff --git a/jdk/test/java/util/zip/ZipFile/FinalizeInflater.java b/jdk/test/java/util/zip/ZipFile/FinalizeInflater.java
new file mode 100644
index 0000000000000000000000000000000000000000..e80fd7490762b6813ae9b16f17d02d17df822ac1
--- /dev/null
+++ b/jdk/test/java/util/zip/ZipFile/FinalizeInflater.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2010, 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 7003462
+   @summary Make sure cached Inflater does not get finalized.
+ */
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class FinalizeInflater {
+
+    public static void main(String[] args) throws Throwable {
+        try (ZipFile zf = new ZipFile(new File(System.getProperty("test.src", "."), "input.zip")))
+        {
+            ZipEntry ze = zf.getEntry("ReadZip.java");
+            read(zf.getInputStream(ze));
+            System.gc();
+            System.runFinalization();
+            System.gc();
+            // read again
+            read(zf.getInputStream(ze));
+        }
+    }
+
+    private static void read(InputStream is)
+        throws IOException
+    {
+        Wrapper wrapper = new Wrapper(is);
+        byte[] buffer = new byte[32];
+        try {
+            while(is.read(buffer)>0){}
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+    }
+
+    static class Wrapper{
+        InputStream is;
+        public Wrapper(InputStream is) {
+            this.is = is;
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            super.finalize();
+            is.close();
+        }
+    }
+}
diff --git a/jdk/test/javax/swing/DataTransfer/6456844/bug6456844.java b/jdk/test/javax/swing/DataTransfer/6456844/bug6456844.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b290375f45e4c354e3b89eb4b1362a4e44fa9b4
--- /dev/null
+++ b/jdk/test/javax/swing/DataTransfer/6456844/bug6456844.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2010, 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 6456844
+   @summary Tests that JTextComponent doesn't create drop locations with null bias.
+   @author Shannon Hickey
+*/
+
+import sun.swing.SwingAccessor;
+
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import javax.swing.text.JTextComponent;
+import java.awt.*;
+
+public class bug6456844 {
+
+    public static void main(String[] args) {
+        JEditorPane ep = new JEditorPane();
+        ep.setContentType("text/html");
+        ep.setText("abc");
+        ep.setBorder(new EmptyBorder(20, 20, 20, 20));
+        ep.setBounds(0, 0, 100, 100);
+
+        JTextComponent.DropLocation location =
+                (JTextComponent.DropLocation) SwingAccessor.getJTextComponentAccessor().dropLocationForPoint(ep,
+                        new Point(0, 0));
+
+        if (location.getBias() == null) {
+            throw new RuntimeException("null bias");
+        }
+    }
+}
diff --git a/jdk/test/javax/swing/JDialog/6639507/bug6639507.java b/jdk/test/javax/swing/JDialog/6639507/bug6639507.java
new file mode 100644
index 0000000000000000000000000000000000000000..13d1915a3b7b293ea9a9d358c5d3ff9e69c8cacf
--- /dev/null
+++ b/jdk/test/javax/swing/JDialog/6639507/bug6639507.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2010, 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 6639507
+   @summary Title of javax.swing.JDialog is null while spec says it's empty
+   @author Pavel Porvatov
+*/
+import javax.swing.*;
+import java.awt.*;
+
+public class bug6639507 {
+    public static void main(String[] args) {
+        SwingUtilities.invokeLater(new Runnable() {
+            public void run() {
+                assertEmptyTitle(new Dialog((Frame) null), "new Dialog((Frame) null)");
+                assertEmptyTitle(new Dialog((Frame) null, true), "new Dialog((Frame) null, true)");
+                assertEmptyTitle(new Dialog((Dialog) null), "new Dialog((Dialog) null)");
+                assertEmptyTitle(new Dialog((Window) null), "new Dialog((Window) null)");
+                assertEmptyTitle(new Dialog(new Dialog((Window) null), Dialog.ModalityType.APPLICATION_MODAL),
+                        "new Dialog((Window) null), Dialog.ModalityType.APPLICATION_MODAL");
+
+                assertEmptyTitle(new JDialog((Frame) null), "new JDialog((Frame) null)");
+                assertEmptyTitle(new JDialog((Frame) null, true), "new JDialog((Frame) null, true)");
+                assertEmptyTitle(new JDialog((Dialog) null), "new JDialog((Dialog) null)");
+                assertEmptyTitle(new JDialog((Dialog) null, true), "new JDialog((Dialog) null, true)");
+                assertEmptyTitle(new JDialog((Window) null), "new JDialog((Window) null)");
+                assertEmptyTitle(new JDialog((Window) null, Dialog.ModalityType.APPLICATION_MODAL),
+                        "new JDialog((Window) null, Dialog.ModalityType.APPLICATION_MODAL)");
+            }
+        });
+    }
+
+    private static void assertEmptyTitle(Dialog dialog, String ctr) {
+        String title = dialog.getTitle();
+
+        if (title == null || title.length() > 0) {
+            throw new RuntimeException("Title is not empty for constructor " + ctr);
+        }
+    }
+}
diff --git a/jdk/test/sun/nio/cs/EncodingNothing.java b/jdk/test/sun/nio/cs/EncodingNothing.java
new file mode 100644
index 0000000000000000000000000000000000000000..e75e0800e96985ed3906c24e718155b535c45a07
--- /dev/null
+++ b/jdk/test/sun/nio/cs/EncodingNothing.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2010, 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 6415373
+ * @summary Encoding nothing should output nothing
+ */
+
+import java.io.*;
+import java.nio.charset.*;
+
+public class EncodingNothing {
+
+    public static void main(String[] args) throws Throwable {
+        int failed = 0;
+        for (Charset cs : Charset.availableCharsets().values()) {
+            if (! cs.canEncode())
+                continue;
+            System.out.printf("%s: ", cs.name());
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            OutputStreamWriter osw = new OutputStreamWriter(baos, cs);
+            osw.close();
+            if (baos.size() != 0) {
+                System.out.printf(" Failed:  output bytes=%d", baos.size());
+                failed++;
+            }
+            System.out.println();
+        }
+        if (failed != 0)
+            throw new AssertionError("Some tests failed");
+    }
+}
diff --git a/jdk/test/sun/security/krb5/tools/ktarg.sh b/jdk/test/sun/security/krb5/tools/ktarg.sh
index ed78b5807ce34cfa26f57e2f476f4d847831aa04..4f84e2469aa7e6b59b098dac7c8374bbceff96f1 100644
--- a/jdk/test/sun/security/krb5/tools/ktarg.sh
+++ b/jdk/test/sun/security/krb5/tools/ktarg.sh
@@ -56,7 +56,7 @@ KEYTAB=ktarg.tmp
 rm $KEYTAB 2> /dev/null
 KTAB="${TESTJAVA}${FS}bin${FS}ktab -k $KEYTAB"
 
-$KTAB -a me mine || exit 1
+$KTAB -a me@LOCAL mine || exit 1
 
 $KTAB -hello
 if [ $? = 0 ]; then exit 2; fi
diff --git a/jdk/test/sun/security/provider/SeedGenerator/SeedGeneratorChoice.java b/jdk/test/sun/security/provider/SeedGenerator/SeedGeneratorChoice.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba49c6564b774c78bc92826ee3b67cecd0d307d0
--- /dev/null
+++ b/jdk/test/sun/security/provider/SeedGenerator/SeedGeneratorChoice.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ * 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 6998583
+ * @summary NativeSeedGenerator is making 8192 byte read requests from
+ *             entropy pool on each init.
+ * @run main SeedGeneratorChoice
+ * @run main/othervm -Djava.security.egd=file:/dev/random SeedGeneratorChoice
+ * @run main/othervm -Djava.security.egd=file:filename  SeedGeneratorChoice
+ */
+
+/*
+ * Side testcase introduced to ensure changes for 6998583 will always
+ * succeed in falling back to ThreadedSeedGenerator if issues are found
+ * with the native OS generator request. We should never see an exception
+ * causing exit.
+ * We should always fall back to the ThreadedSeedGenerator if exceptions
+ * are encountered with user defined source of entropy.
+ */
+
+import java.security.SecureRandom;
+
+public class SeedGeneratorChoice {
+
+    public static void main(String... arguments) throws Exception {
+        byte[] bytes;
+        SecureRandom prng = SecureRandom.getInstance("SHA1PRNG");
+        bytes = prng.generateSeed(1);
+    }
+}
diff --git a/jdk/test/sun/security/rsa/InvalidBitString.java b/jdk/test/sun/security/rsa/InvalidBitString.java
new file mode 100644
index 0000000000000000000000000000000000000000..be9e42ca5444f95027113a9655bedc0224c557d0
--- /dev/null
+++ b/jdk/test/sun/security/rsa/InvalidBitString.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2010, 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
+ * @summary Validation of signatures succeed when it should fail
+ * @bug 6896700
+ */
+
+import java.io.InputStream;
+import java.io.ByteArrayInputStream;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateFactory;
+import java.security.PublicKey;
+import java.security.SignatureException;
+
+public class InvalidBitString {
+
+    // Test cert for CN=CA
+    static String signerCertStr =
+        "-----BEGIN CERTIFICATE-----\n" +
+        "MIIBtDCCAR2gAwIBAgIEemxRHjANBgkqhkiG9w0BAQUFADANMQswCQYDVQQDEwJDQTAeFw0xMDA2\n" +
+        "MDMwODA2MjlaFw0xMDA5MDEwODA2MjlaMA0xCzAJBgNVBAMTAkNBMIGfMA0GCSqGSIb3DQEBAQUA\n" +
+        "A4GNADCBiQKBgQCp2G7pGwMOw4oM7zFFeRKrByuPLNAXClGsh+itdRiOeUgEby6OB9IAgXm93086\n" +
+        "Z9dWCfRYbzJbDRSnUE7FS1iQsIRIeOEuFMIMogcBK+sOf364ONwMXsI4gtYVmxn4BaaajVWt6C/g\n" +
+        "FBGZQxp81aORDyUIrlCkMIxhZBSsNPIJYwIDAQABoyEwHzAdBgNVHQ4EFgQUKrvzNhJmdKoqq2li\n" +
+        "utCzKkwA1N0wDQYJKoZIhvcNAQEFBQADgYEAEIaegsW7fWWjXk4YOMlcl893vx6tnU8ThuQSjwGI\n" +
+        "rIs93sBYuY7lQIpQw8+XM89WT1XuBB6R2SsnxeW+gHtsU/EE6iJJAEMeCILwEGUL02blwHBQWmpa\n" +
+        "i3YeGXw+IFe/4OAysPT7ZRbUb7mPt37Ht6hIjain71ShR5anXIuawVE=\n" +
+        "-----END CERTIFICATE-----\n";
+    // Test cert for CN=A, happens to have a zero at the beginning of signature
+    static String normalCertStr =
+        "-----BEGIN CERTIFICATE-----\n" +
+        "MIIB1DCCAT2gAwIBAgIEae+u1TANBgkqhkiG9w0BAQUFADANMQswCQYDVQQDEwJDQTAeFw0xMDA2\n" +
+        "MDMwODA2NTNaFw0xMDA5MDEwODA2NTNaMAwxCjAIBgNVBAMTAUEwgZ8wDQYJKoZIhvcNAQEBBQAD\n" +
+        "gY0AMIGJAoGBAKZ7C6bC8AJmXIRNwuPJcgIPW1ygN3rE5PIKPAkeK/dYnPmUJNuiSxOFPJCrLMuL\n" +
+        "sweQh82Dq/viu+KBb27xVzJ4pK02fbcWdJDo7cIms0Wm+HckK5myA6xmqnpmPOjb/vWCLE6pN2Xg\n" +
+        "pJyrdeWV77eBvqE9OiCsMTP8WgHI9zLvAgMBAAGjQjBAMB0GA1UdDgQWBBTtIKqCHnL9QeFn+YrX\n" +
+        "+k00NUk9mjAfBgNVHSMEGDAWgBQqu/M2EmZ0qiqraWK60LMqTADU3TANBgkqhkiG9w0BAQUFAAOB\n" +
+        "gQAAOcQsEruDAY/z3eXJ7OtWSZlLC0yTVNVdUVNLQ58xNqPrmKNBXNpj/72N8xrTB++ApW+DLgLy\n" +
+        "cwGU5PVRtsYeiV6prUkpqUf62SQgwI4guAQy1ileeP1CNQJI3cHQExMAHvQT8fJtlD0WZD3nfesq\n" +
+        "mmQDOpoJLkmO/73Z7IibVA==\n" +
+        "-----END CERTIFICATE-----\n";
+    // normalCertStr with an extra zero at the beginning of signature
+    static String longerCertStr =
+        "-----BEGIN CERTIFICATE-----\n" +
+        "MIIB1TCCAT2gAwIBAgIEae+u1TANBgkqhkiG9w0BAQUFADANMQswCQYDVQQDEwJDQTAeFw0xMDA2\n" +
+        "MDMwODA2NTNaFw0xMDA5MDEwODA2NTNaMAwxCjAIBgNVBAMTAUEwgZ8wDQYJKoZIhvcNAQEBBQAD\n" +
+        "gY0AMIGJAoGBAKZ7C6bC8AJmXIRNwuPJcgIPW1ygN3rE5PIKPAkeK/dYnPmUJNuiSxOFPJCrLMuL\n" +
+        "sweQh82Dq/viu+KBb27xVzJ4pK02fbcWdJDo7cIms0Wm+HckK5myA6xmqnpmPOjb/vWCLE6pN2Xg\n" +
+        "pJyrdeWV77eBvqE9OiCsMTP8WgHI9zLvAgMBAAGjQjBAMB0GA1UdDgQWBBTtIKqCHnL9QeFn+YrX\n" +
+        "+k00NUk9mjAfBgNVHSMEGDAWgBQqu/M2EmZ0qiqraWK60LMqTADU3TANBgkqhkiG9w0BAQUFAAOB\n" +
+        "ggAAADnELBK7gwGP893lyezrVkmZSwtMk1TVXVFTS0OfMTaj65ijQVzaY/+9jfMa0wfvgKVvgy4C\n" +
+        "8nMBlOT1UbbGHoleqa1JKalH+tkkIMCOILgEMtYpXnj9QjUCSN3B0BMTAB70E/HybZQ9FmQ9533r\n" +
+        "KppkAzqaCS5Jjv+92eyIm1Q=\n" +
+        "-----END CERTIFICATE-----\n";
+    // normalCertStr without the initial zero at the beginning of signature
+    static String shorterCertStr =
+        "-----BEGIN CERTIFICATE-----\n" +
+        "MIIB0zCCAT2gAwIBAgIEae+u1TANBgkqhkiG9w0BAQUFADANMQswCQYDVQQDEwJDQTAeFw0xMDA2\n" +
+        "MDMwODA2NTNaFw0xMDA5MDEwODA2NTNaMAwxCjAIBgNVBAMTAUEwgZ8wDQYJKoZIhvcNAQEBBQAD\n" +
+        "gY0AMIGJAoGBAKZ7C6bC8AJmXIRNwuPJcgIPW1ygN3rE5PIKPAkeK/dYnPmUJNuiSxOFPJCrLMuL\n" +
+        "sweQh82Dq/viu+KBb27xVzJ4pK02fbcWdJDo7cIms0Wm+HckK5myA6xmqnpmPOjb/vWCLE6pN2Xg\n" +
+        "pJyrdeWV77eBvqE9OiCsMTP8WgHI9zLvAgMBAAGjQjBAMB0GA1UdDgQWBBTtIKqCHnL9QeFn+YrX\n" +
+        "+k00NUk9mjAfBgNVHSMEGDAWgBQqu/M2EmZ0qiqraWK60LMqTADU3TANBgkqhkiG9w0BAQUFAAOB\n" +
+        "gAA5xCwSu4MBj/Pd5cns61ZJmUsLTJNU1V1RU0tDnzE2o+uYo0Fc2mP/vY3zGtMH74Clb4MuAvJz\n" +
+        "AZTk9VG2xh6JXqmtSSmpR/rZJCDAjiC4BDLWKV54/UI1AkjdwdATEwAe9BPx8m2UPRZkPed96yqa\n" +
+        "ZAM6mgkuSY7/vdnsiJtU\n" +
+        "-----END CERTIFICATE-----\n";
+
+    public static void main(String args[]) throws Exception {
+
+        Certificate signer = generate(signerCertStr);
+
+        // the valid certificate
+        Certificate normal = generate(normalCertStr);
+        // the invalid certificate with extra signature bits
+        Certificate longer = generate(longerCertStr);
+        // the invalid certificate without enough signature bits
+        Certificate shorter = generate(shorterCertStr);
+
+        if (!test(normal, signer, " normal", true) ||
+                !test(longer, signer, " longer", false) ||
+                !test(shorter, signer, "shorter", false)) {
+            throw new Exception("Test failed.");
+        }
+    }
+
+    private static Certificate generate(String certStr) throws Exception {
+        InputStream is = null;
+        try {
+            CertificateFactory cf = CertificateFactory.getInstance("X.509");
+            is = new ByteArrayInputStream(certStr.getBytes());
+            return cf.generateCertificate(is);
+        } finally {
+            if (is != null) {
+                is.close();
+            }
+        }
+    }
+
+    private static boolean test(Certificate target, Certificate signer,
+            String title, boolean expected) throws Exception {
+        System.out.print("Checking " + title + ": expected: " +
+                (expected ? "    verified" : "NOT verified"));
+        boolean actual;
+        try {
+            PublicKey pubKey = signer.getPublicKey();
+            target.verify(pubKey);
+            actual = true;
+        } catch (SignatureException se) {
+            actual = false;
+        }
+        System.out.println(", actual: " +
+                (actual ? "    verified" : "NOT verified"));
+        return actual == expected;
+    }
+
+}
diff --git a/jdk/test/sun/security/rsa/TestKeyPairGenerator.java b/jdk/test/sun/security/rsa/TestKeyPairGenerator.java
index 444d5ece29115713d24094c12932a1ba6f113f6e..88ab075bced80c9b14ee52964e7592618c144152 100644
--- a/jdk/test/sun/security/rsa/TestKeyPairGenerator.java
+++ b/jdk/test/sun/security/rsa/TestKeyPairGenerator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, 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
@@ -85,8 +85,12 @@ public class TestKeyPairGenerator {
         sig.initVerify(kp2.getPublic());
         sig.update(data);
         // verify needs to return false and not throw an Exception
-        if (sig.verify(signature)) {
-            throw new Exception("verification unexpectedly succeeded");
+        try {
+            if (sig.verify(signature)) {
+                throw new Exception("verification unexpectedly succeeded");
+            }
+        } catch (SignatureException se) {
+            // Yet another kind of failure, OK.
         }
     }
 
diff --git a/jdk/test/sun/security/tools/jarsigner/JarSigningNonAscii.java b/jdk/test/sun/security/tools/jarsigner/JarSigningNonAscii.java
index ed17e6e7bb6454481b884d7e1fc466e0b654d9dd..c0cae086252a65a361e1cb44af050b2c4865572f 100644
--- a/jdk/test/sun/security/tools/jarsigner/JarSigningNonAscii.java
+++ b/jdk/test/sun/security/tools/jarsigner/JarSigningNonAscii.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, 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
@@ -113,7 +113,7 @@ public class JarSigningNonAscii {
             }
         }
 
-        if (isSignedCount != 3) {
+        if (isSignedCount != 4) {
             throw new SecurityException("error signing JAR file");
         }
 
diff --git a/jdk/test/sun/security/tools/jarsigner/checkusage.sh b/jdk/test/sun/security/tools/jarsigner/checkusage.sh
new file mode 100644
index 0000000000000000000000000000000000000000..957df161d9b35eadfca4a8dfe17e625ba340c7ae
--- /dev/null
+++ b/jdk/test/sun/security/tools/jarsigner/checkusage.sh
@@ -0,0 +1,109 @@
+#
+# Copyright (c) 2010, 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 7004168
+# @summary jarsigner -verify checks for KeyUsage codesigning ext on all certs
+#  instead of just signing cert
+#
+# @run shell checkusage.sh
+#
+
+if [ "${TESTJAVA}" = "" ] ; then
+  JAVAC_CMD=`which javac`
+  TESTJAVA=`dirname $JAVAC_CMD`/..
+fi
+
+# set platform-dependent variables
+OS=`uname -s`
+case "$OS" in
+  Windows_* )
+    FS="\\"
+    ;;
+  * )
+    FS="/"
+    ;;
+esac
+
+KT="$TESTJAVA${FS}bin${FS}keytool -storepass changeit -keypass changeit"
+JAR=$TESTJAVA${FS}bin${FS}jar
+JARSIGNER="$TESTJAVA${FS}bin${FS}jarsigner"
+
+rm js.jks trust.jks unrelated.jks 2> /dev/null
+
+echo x > x
+$JAR cvf a.jar x
+
+################### 3 Keystores #######################
+
+# Keystore js.jks: including CA and Publisher
+# CA contains a non-empty KeyUsage
+$KT -keystore js.jks -genkeypair -alias ca -dname CN=CA -ext KU=kCS -ext bc -validity 365
+$KT -keystore js.jks -genkeypair -alias pub -dname CN=Publisher
+
+# Publisher contains the correct KeyUsage
+$KT -keystore js.jks -certreq -alias pub | \
+        $KT -keystore js.jks -gencert -alias ca -ext KU=dig -validity 365 | \
+        $KT -keystore js.jks -importcert -alias pub
+
+# Keystore trust.jks: including CA only
+$KT -keystore js.jks -exportcert -alias ca | \
+        $KT -keystore trust.jks -importcert -alias ca -noprompt
+
+# Keystore unrelated.jks: unrelated
+$KT -keystore unrelated.jks -genkeypair -alias nothing -dname CN=Nothing -validity 365
+
+
+################### 4 Tests #######################
+
+# Test 1: Sign should be OK
+
+$JARSIGNER -keystore js.jks -storepass changeit a.jar pub
+RESULT=$?
+echo $RESULT
+#[ $RESULT = 0 ] || exit 1
+
+# Test 2: Verify should be OK
+
+$JARSIGNER -keystore trust.jks -strict -verify a.jar
+RESULT=$?
+echo $RESULT
+#[ $RESULT = 0 ] || exit 2
+
+# Test 3: When no keystore is specified, the error is only
+# "chain not validated"
+
+$JARSIGNER -strict -verify a.jar
+RESULT=$?
+echo $RESULT
+#[ $RESULT = 4 ] || exit 3
+
+# Test 4: When unrelated keystore is specified, the error is
+# "chain not validated" and "not alias in keystore"
+
+$JARSIGNER -keystore unrelated.jks -strict -verify a.jar
+RESULT=$?
+echo $RESULT
+#[ $RESULT = 36 ] || exit 4
+
+exit 0
diff --git a/jdk/test/sun/security/tools/jarsigner/concise_jarsigner.sh b/jdk/test/sun/security/tools/jarsigner/concise_jarsigner.sh
index 0b145a902b62bf86550d659c590422d59f54cff7..5edce57057b66a1163a7c23d9fe603b896e40e75 100644
--- a/jdk/test/sun/security/tools/jarsigner/concise_jarsigner.sh
+++ b/jdk/test/sun/security/tools/jarsigner/concise_jarsigner.sh
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2009, 2010, 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
@@ -79,9 +79,9 @@ $JAR uvf a.jar A5.class A6.class
 $JARSIGNER -verify a.jar
 [ $? = 0 ] || exit $LINENO
 
-# 4(chainNotValidated)+16(hasUnsignedEntry)+32(aliasNotInStore)
+# 4(chainNotValidated)+16(hasUnsignedEntry)
 $JARSIGNER -verify a.jar -strict
-[ $? = 52 ] || exit $LINENO
+[ $? = 20 ] || exit $LINENO
 
 # 16(hasUnsignedEntry)
 $JARSIGNER -verify a.jar -strict -keystore js.jks
@@ -103,27 +103,31 @@ LINES=`$JARSIGNER -verify a.jar -verbose | grep $YEAR | wc -l`
 LINES=`$JARSIGNER -verify a.jar -verbose:grouped | grep $YEAR | wc -l`
 [ $LINES = 12 ] || exit $LINENO
 
-# 3 groups: unrelated, signed, unsigned
+# 4 groups: MANIFST, unrelated, signed, unsigned
 LINES=`$JARSIGNER -verify a.jar -verbose:summary | grep $YEAR | wc -l`
+[ $LINES = 4 ] || exit $LINENO
+
+# still 4 groups, but MANIFEST group has no other file
+LINES=`$JARSIGNER -verify a.jar -verbose:summary | grep "more)" | wc -l`
 [ $LINES = 3 ] || exit $LINENO
 
-# 4 groups: unrelated, signed by a1/a2, signed by a2, unsigned
+# 5 groups: MANIFEST, unrelated, signed by a1/a2, signed by a2, unsigned
 LINES=`$JARSIGNER -verify a.jar -verbose:summary -certs | grep $YEAR | wc -l`
-[ $LINES = 4 ] || exit $LINENO
+[ $LINES = 5 ] || exit $LINENO
 
-# 2*2 for A1/A2, 2 for A3/A4
+# 2 for MANIFEST, 2*2 for A1/A2, 2 for A3/A4
 LINES=`$JARSIGNER -verify a.jar -verbose -certs | grep "\[certificate" | wc -l`
-[ $LINES = 6 ] || exit $LINENO
+[ $LINES = 8 ] || exit $LINENO
 
-# a1,a2 for A1/A2, a2 for A3/A4
+# a1,a2 for MANIFEST, a1,a2 for A1/A2, a2 for A3/A4
 LINES=`$JARSIGNER -verify a.jar -verbose:grouped -certs | grep "\[certificate" | wc -l`
-[ $LINES = 3 ] || exit $LINENO
+[ $LINES = 5 ] || exit $LINENO
 
-# a1,a2 for A1/A2, a2 for A3/A4
+# a1,a2 for MANIFEST, a1,a2 for A1/A2, a2 for A3/A4
 LINES=`$JARSIGNER -verify a.jar -verbose:summary -certs | grep "\[certificate" | wc -l`
-[ $LINES = 3 ] || exit $LINENO
+[ $LINES = 5 ] || exit $LINENO
 
-# 4 groups
+# still 5 groups, but MANIFEST group has no other file
 LINES=`$JARSIGNER -verify a.jar -verbose:summary -certs | grep "more)" | wc -l`
 [ $LINES = 4 ] || exit $LINENO
 
diff --git a/jdk/test/sun/security/tools/jarsigner/onlymanifest.sh b/jdk/test/sun/security/tools/jarsigner/onlymanifest.sh
new file mode 100644
index 0000000000000000000000000000000000000000..5ea95784b1b5007280fa58396efddbd70a8f5856
--- /dev/null
+++ b/jdk/test/sun/security/tools/jarsigner/onlymanifest.sh
@@ -0,0 +1,68 @@
+#
+# Copyright (c) 2010, 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 7004035
+# @summary signed jar with only META-INF/* inside is not verifiable
+#
+
+if [ "${TESTJAVA}" = "" ] ; then
+  JAVAC_CMD=`which javac`
+  TESTJAVA=`dirname $JAVAC_CMD`/..
+fi
+
+# set platform-dependent variables
+OS=`uname -s`
+case "$OS" in
+  Windows_* )
+    FS="\\"
+    ;;
+  * )
+    FS="/"
+    ;;
+esac
+
+KS=onlymanifest.jks
+JFILE=onlymanifest.jar
+
+KT="$TESTJAVA${FS}bin${FS}keytool -storepass changeit -keypass changeit \
+        -keystore $KS"
+JAR=$TESTJAVA${FS}bin${FS}jar
+JARSIGNER=$TESTJAVA${FS}bin${FS}jarsigner
+
+rm $KS $JFILE 2> /dev/null
+
+# Create an empty jar file with only MANIFEST.MF
+
+echo "Key: Value" > manifest
+$JAR cvfm $JFILE manifest
+
+$KT -alias a -dname CN=a -genkey -validity 300 || exit 1
+$JARSIGNER -keystore $KS -storepass changeit $JFILE a -debug -strict || exit 2
+$JARSIGNER -keystore $KS -storepass changeit -verify $JFILE a -debug -strict \
+        > onlymanifest.out || exit 3
+
+grep unsigned onlymanifest.out && exit 4
+
+exit 0
+
diff --git a/jdk/test/sun/util/calendar/Bug6653944.java b/jdk/test/sun/util/calendar/Bug6653944.java
new file mode 100644
index 0000000000000000000000000000000000000000..59c8b734c977bc17bdc03f936443d383006bfc97
--- /dev/null
+++ b/jdk/test/sun/util/calendar/Bug6653944.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2010, 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 6653944
+ *@summary Deserialization tests for YEAR calculcations
+ */
+
+import java.io.*;
+import java.util.*;
+
+public class Bug6653944 {
+    private static int errorCount = 0;
+
+    public static void main(String[] args) throws Exception {
+        Calendar buddhist = Calendar.getInstance(new Locale("th", "TH"));
+        int expectedYear = buddhist.get(Calendar.YEAR);
+
+        Calendar deserialized = (Calendar) deserialize(serialize(buddhist));
+        compare(deserialized, buddhist);
+
+        int deserializedYear = deserialized.get(Calendar.YEAR);
+        compare(deserializedYear, expectedYear);
+
+        // test add(YEAR, n).
+        buddhist.add(Calendar.YEAR, 12);
+        expectedYear = buddhist.get(Calendar.YEAR);
+        deserialized.add(Calendar.YEAR, 12);
+        deserializedYear = deserialized.get(Calendar.YEAR);
+        compare(deserialized, buddhist);
+        compare(deserializedYear, expectedYear);
+
+        if (errorCount > 0) {
+            throw new RuntimeException("Bug6653944: failed");
+        }
+    }
+
+    private static void compare(int got, int expected) {
+        if (got != expected) {
+            System.err.println("got " + got + ", expected " + expected);
+            errorCount++;
+        }
+    }
+
+    private static void compare(Calendar got, Calendar expected) {
+        if (!got.equals(expected)) {
+            System.err.println("got " + got + ", expected " + expected);
+            errorCount++;
+        }
+    }
+
+    private static byte[] serialize(Serializable obj) throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        ObjectOutputStream oos = new ObjectOutputStream(baos);
+        oos.writeObject(obj);
+        oos.close();
+        return baos.toByteArray();
+    }
+
+    private static Object deserialize(byte[] data) throws Exception {
+        ByteArrayInputStream bais = new ByteArrayInputStream(data);
+        ObjectInputStream ois = new ObjectInputStream(bais);
+        return ois.readObject();
+    }
+}
diff --git a/make/scripts/vsvars.sh b/make/scripts/vsvars.sh
new file mode 100644
index 0000000000000000000000000000000000000000..369a04a9ec30da46d8635dae1128338318617965
--- /dev/null
+++ b/make/scripts/vsvars.sh
@@ -0,0 +1,546 @@
+#!/bin/sh
+
+#
+# Copyright (c) 2009, 2010, 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.
+#
+
+# This file should be used to set the Visual Studio environment
+#   variables normally set by the vcvars32.bat or vcvars64.bat file or
+#   SetEnv.cmd for older SDKs.
+
+# Use cygpath?
+isCygwin="`uname -s | grep CYGWIN`"
+if [ "${isCygwin}" != "" ] ; then
+  cygpath="/usr/bin/cygpath"
+  cygpath_short="${cygpath} -m -s"
+  cygpath_windows="${cygpath} -w -s"
+  cygpath_path="${cygpath} -p"
+  pathsep=':'
+else
+  cygpath="dosname"
+  cygpath_short="${cygpath} -s"
+  cygpath_windows="${cygpath} -s"
+  cygpath_path="echo"
+  pathsep=';'
+fi
+
+########################################################################
+# Error functions
+msg() # message
+{
+  echo "$1" 1>&2
+}
+error() # message
+{
+  msg "ERROR: $1"
+  exit 1
+}
+warning() # message
+{
+  msg "WARNING: $1"
+}
+envpath() # path
+{
+  if [ "${cygpath_short}" != "" -a -d "$1" ] ; then
+    ${cygpath_short} "$1"
+  else
+    echo "$1"
+  fi
+}
+########################################################################
+
+
+# Defaults settings
+debug="false"
+verbose="false"
+shellStyle="sh"
+parentCsh="` ps -p ${PPID} 2> /dev/null | grep csh `"
+if [ "${parentCsh}" != "" ] ; then
+  shellStyle="csh"
+fi
+
+set -e
+
+# Check environment first
+if [ "${PROGRAMFILES}" != "" ] ; then
+  progfiles=`envpath "${PROGRAMFILES}"`
+elif [ "${ProgramFiles}" != "" ] ; then
+  progfiles=`envpath "${ProgramFiles}"`
+elif [ "${SYSTEMDRIVE}" != "" ] ; then
+  progfiles=`envpath "${SYSTEMDRIVE}/Program Files"`
+elif [ "${SystemDrive}" != "" ] ; then
+  progfiles=`envpath "${SystemDrive}/Program Files"`
+else
+  error "No PROGRAMFILES or SYSTEMDRIVE defined in environment"
+fi
+
+# Arch data model
+if [ "${PROCESSOR_IDENTIFIER}" != "" ] ; then
+  arch=`echo "${PROCESSOR_IDENTIFIER}" | cut -d' ' -f1`
+elif [ "${MACHTYPE}" != "" ] ; then
+  if [ "`echo ${MACHTYPE} | grep 64`" != "" ] ; then
+    # Assume this is X64, not IA64
+    arch="x64"
+  else
+    arch="x86"
+  fi
+else
+ arch="`uname -m`"
+fi
+if [ "${arch}" = "X86" -o \
+     "${arch}" = "386" -o "${arch}" = "i386" -o \
+     "${arch}" = "486" -o "${arch}" = "i486" -o \
+     "${arch}" = "586" -o "${arch}" = "i586" -o \
+     "${arch}" = "686" -o "${arch}" = "i686" -o \
+     "${arch}" = "86" ] ; then
+  arch="x86"
+fi
+if [ "${arch}" = "X64"     -o \
+     "${arch}" = "8664"    -o "${arch}" = "i8664"   -o \
+     "${arch}" = "amd64"   -o "${arch}" = "AMD64"   -o \
+     "${arch}" = "EM64T"   -o "${arch}" = "emt64t"  -o \
+     "${arch}" = "intel64" -o "${arch}" = "Intel64" -o \
+     "${arch}" = "64" ] ; then
+  arch="x64"
+  binarch64="/amd64"
+fi
+if [ "${arch}" = "IA64" ] ; then
+  arch="ia64"
+  binarch64="/ia64"
+fi
+if [ "${arch}" != "x86" -a "${arch}" != "x64" -a "${arch}" != "ia64" ] ; then
+ error "No PROCESSOR_IDENTIFIER or MACHTYPE environment variables and uname -m is not helping"
+fi
+if [ "${arch}" = "x86" ] ; then
+  arch_data_model=32
+  progfiles32="${progfiles}"
+  progfiles64="${progfiles}"
+else
+  arch_data_model=64
+  progfiles32="${progfiles}"
+  if [ "${PROGRAMW6432}" != "" ] ; then
+    progfiles64=`envpath "${PROGRAMW6432}"`
+  else
+    progfiles64=`envpath "C:/Program Files"`
+  fi
+fi
+
+# VS2010 (VC10)
+if [ "${VS100COMNTOOLS}" = "" ] ; then
+  VS100COMNTOOLS="${progfiles32}/Microsoft Visual Studio 10.0/Common7/Tools/"
+  export VS100COMNTOOLS
+fi
+vc10Bin32Dir=`envpath "${VS100COMNTOOLS}"`/../../VC/Bin
+vc10Bin64Dir="${vc10Bin32Dir}${binarch64}"
+vc10vars32Bat="vcvars32.bat"
+vc10vars64Bat="vcvars64.bat"
+
+# VS2008 (VC9)
+if [ "${VS90COMNTOOLS}" = "" ] ; then
+  VS90COMNTOOLS="${progfiles32}/Microsoft Visual Studio 9.0/Common7/Tools/"
+  export VS90COMNTOOLS
+fi
+vc9Bin32Dir=`envpath "${VS90COMNTOOLS}"`/../../VC/Bin
+vc9Bin64Dir="${vc9Bin32Dir}"
+vc9vars32Bat="vcvars32.bat"
+vc9vars64Bat="vcvars64.bat"
+
+# VS2005 (VC8)
+if [ "${VS80COMNTOOLS}" = "" ] ; then
+  VS80COMNTOOLS="${progfiles32}/Microsoft Visual Studio 8.0/Common7/Tools/"
+  export VS80COMNTOOLS
+fi
+vc8Bin32Dir=`envpath "${VS80COMNTOOLS}"`/../../VC/Bin
+vc8Bin64Dir="${progfiles64}/Microsoft Platform SDK"
+vc8vars32Bat="vcvars32.bat"
+vc8vars64Bat="SetEnv.cmd /X64"
+
+# VS2003 (VC7)
+if [ "${VS71COMNTOOLS}" = "" ] ; then
+  VS71COMNTOOLS="${progfiles32}/Microsoft Visual Studio .NET 2003/Common7/Tools/"
+  export VS71COMNTOOLS
+fi
+vc7Bin32Dir=`envpath "${VS71COMNTOOLS}"`/../../VC7/Bin
+vc7Bin64Dir="${progfiles64}/Microsoft Platform SDK"
+vc7vars32Bat="vcvars32.bat"
+vc7vars64Bat="SetEnv.cmd /X64"
+
+# Force user to select
+vcSelection=""
+
+# Parse options
+usage="Usage: $0 [-help] [-debug] [-v] [-c] [-s] [-p] [-v10] [-v9] [-v8] [-v7] [-32] [-64]"
+while [ $# -gt 0 ] ; do
+  if [ "$1" = "-help" ] ; then
+    msg "${usage}"
+    msg "  -help    Print out this help message"
+    msg "  -debug   Print out extra env variables to help debug this script"
+    msg "  -v       Verbose output warns about missing directories"
+    msg "  -c       Print out csh style output"
+    msg "  -s       Print out sh style output"
+    msg "  -p       Print out properties style output"
+    msg "  -v10     Use Visual Studio 10 VS2010"
+    msg "  -v9      Use Visual Studio 9 VS2008"
+    msg "  -v8      Use Visual Studio 8 VS2005"
+    msg "  -v7      Use Visual Studio 7 VS2003"
+    msg "  -32      Force 32bit"
+    msg "  -64      Force 64bit"
+    exit 0
+  elif [ "$1" = "-debug" ] ; then
+    debug="true"
+    shift
+  elif [ "$1" = "-v" ] ; then
+    verbose="true"
+    shift
+  elif [ "$1" = "-c" ] ; then
+    shellStyle="csh"
+    shift
+  elif [ "$1" = "-s" ] ; then
+    shellStyle="sh"
+    shift
+  elif [ "$1" = "-p" ] ; then
+    shellStyle="props"
+    shift
+  elif [ "$1" = "-v10" ] ; then
+    vcBin32Dir="${vc10Bin32Dir}"
+    vcBin64Dir="${vc10Bin64Dir}"
+    vcvars32Bat="${vc10vars32Bat}"
+    vcvars64Bat="${vc10vars64Bat}"
+    vcSelection="10"
+    shift
+  elif [ "$1" = "-v9" ] ; then
+    vcBin32Dir="${vc9Bin32Dir}"
+    vcBin64Dir="${vc9Bin64Dir}"
+    vcvars32Bat="${vc9vars32Bat}"
+    vcvars64Bat="${vc9vars64Bat}"
+    vcSelection="9"
+    shift
+  elif [ "$1" = "-v8" ] ; then
+    vcBin32Dir="${vc8Bin32Dir}"
+    vcBin64Dir="${vc8Bin64Dir}"
+    vcvars32Bat="${vc8vars32Bat}"
+    vcvars64Bat="${vc8vars64Bat}"
+    vcSelection="8"
+    shift
+  elif [ "$1" = "-v7" ] ; then
+    vcBin32Dir="${vc7Bin32Dir}"
+    vcBin64Dir="${vc7Bin64Dir}"
+    vcvars32Bat="${vc7vars32Bat}"
+    vcvars64Bat="${vc7vars64Bat}"
+    vcSelection="7"
+    shift
+  elif [ "$1" = "-32" ] ; then
+    arch_data_model=32
+    shift
+  elif [ "$1" = "-64" ] ; then
+    arch_data_model=64
+    shift
+  else
+    msg "${usage}"
+    error "Unknown option: $1"
+  fi
+done
+
+# Need to pick
+if [ "${vcSelection}" = "" ] ; then
+  msg "${usage}"
+  error "You must pick the version"
+fi
+
+# Which vcvars bat file to run
+if [ "${arch_data_model}" = "32" ] ; then
+  vcBinDir="${vcBin32Dir}"
+  vcvarsBat="${vcvars32Bat}"
+fi
+if [ "${arch_data_model}" = "64" ] ; then
+  vcBinDir="${vcBin64Dir}"
+  vcvarsBat="${vcvars64Bat}"
+fi
+
+# Do not allow any error returns
+set -e
+
+# Different systems have different awk's
+if [ -f /usr/bin/nawk ] ; then
+  awk="nawk"
+elif [ -f /usr/bin/gawk ] ; then
+  awk="gawk"
+else
+  awk="awk"
+fi
+
+if [ "${verbose}" = "true" ] ; then
+  echo "# Welcome to verbose mode"
+  set -x
+fi
+
+if [ "${debug}" = "true" ] ; then
+  echo "# Welcome to debug mode"
+  set -x
+fi
+
+# Temp file area
+tmp="/tmp/vsvars.$$"
+rm -f -r ${tmp}
+mkdir -p ${tmp}
+
+# Check paths
+checkPaths() # var path sep
+{
+  set -e
+  sep="$3"
+  checklist="${tmp}/checklist"
+  printf "%s\n" "$2" | \
+    sed -e 's@\\@/@g' | \
+    sed -e 's@//@/@g' | \
+    ${awk} -F"${sep}" '{for(i=1;i<=NF;i++){printf "%s\n",$i;}}'  \
+      > ${checklist}
+  cat ${checklist} | while read orig; do
+    if [ "${orig}" != "" ] ; then
+      if [ ! -d "${orig}" ] ; then
+        warning "Directory in $1 does not exist: ${orig}"
+      fi
+    fi
+  done
+}
+
+# Remove all duplicate entries
+removeDeadDups() # string sep
+{
+  set -e
+  sep="$2"
+  pathlist="${tmp}/pathlist"
+  printf "%s\n" "$1" | \
+    sed -e 's@\\@/@g' | \
+    sed -e 's@//@/@g' | \
+    ${awk} -F"${sep}" '{for(i=1;i<=NF;i++){printf "%s\n",$i;}}'  \
+      > ${pathlist}
+  upaths="${tmp}/upaths"
+  cat ${pathlist} | while read orig; do
+    p="${orig}"
+    if [ "${cygpath_short}" != "" ] ; then
+      if [ "${p}" != "" ] ; then
+        if [ -d "${p}" ] ; then
+          short=`${cygpath_short} "${p}"`
+          if [ "${short}" != "" -a -d "${short}" ] ; then
+            p=`${cygpath} "${short}"`
+          fi
+          echo "${p}" >> ${upaths}
+        fi
+      fi
+    fi
+  done
+  newpaths=""
+  for i in  `cat ${upaths}` ; do
+    # For some reason, \r characters can get into this
+    i=`echo "${i}" | tr -d '\r' | sed -e 's@/$@@'`
+    if [ "${newpaths}" = "" ] ; then
+      newpaths="${i}"
+    else
+      newpaths="${newpaths}${sep}${i}"
+    fi
+  done
+  printf "%s\n" "${newpaths}" | \
+    ${awk} -F"${sep}" \
+       '{a[$1];printf "%s",$1;for(i=2;i<=NF;i++){if(!($i in a)){a[$i];printf "%s%s",FS,$i;}};printf "\n";}'
+}
+
+# Create bat file to process Visual Studio vcvars*.bat files
+createBat() # batfile bindir command
+{
+  bat="$1"
+  bindir="$2"
+  command="$3"
+  stdout="${bat}.stdout"
+  rm -f ${bat} ${stdout}
+  echo "Output from: ${command}" > ${stdout}
+  bdir=`envpath "${bindir}"`
+  cat > ${bat} << EOF  
+REM Pick the right vcvars bat file
+REM Empty these out so we only get the additions we want
+set INCLUDE=
+set LIB=
+set LIBPATH=
+set MSVCDIR=
+set MSSdk=
+set Mstools=
+set DevEnvDir=
+set VCINSTALLDIR=
+set VSINSTALLDIR=
+set WindowsSdkDir=
+REM Run the vcvars bat file, send all output to stderr
+call `${cygpath_windows} ${bdir}`\\${command} > `${cygpath_windows} "${stdout}"`
+REM Echo out env var settings
+echo VS_VS71COMNTOOLS="%VS71COMNTOOLS%"
+echo export VS_VS71COMNTOOLS
+echo VS_VS80COMNTOOLS="%VS80COMNTOOLS%"
+echo export VS_VS80COMNTOOLS
+echo VS_VS90COMNTOOLS="%VS90COMNTOOLS%"
+echo export VS_VS90COMNTOOLS
+echo VS_VS100COMNTOOLS="%VS100COMNTOOLS%"
+echo export VS_VS100COMNTOOLS
+echo VS_VCINSTALLDIR="%VCINSTALLDIR%"
+echo export VS_VCINSTALLDIR
+echo VS_VSINSTALLDIR="%VSINSTALLDIR%"
+echo export VS_VSINSTALLDIR
+echo VS_DEVENVDIR="%DevEnvDir%"
+echo export VS_DEVENVDIR
+echo VS_MSVCDIR="%MSVCDIR%"
+echo export VS_MSVCDIR
+echo VS_MSSDK="%MSSdk%"
+echo export VS_MSSDK
+echo VS_MSTOOLS="%Mstools%"
+echo export VS_MSTOOLS
+echo VS_WINDOWSSDKDIR="%WindowsSdkDir%"
+echo export VS_WINDOWSSDKDIR
+echo VS_INCLUDE="%INCLUDE%"
+echo export VS_INCLUDE
+echo VS_LIB="%LIB%"
+echo export VS_LIB
+echo VS_LIBPATH="%LIBPATH%"
+echo export VS_LIBPATH
+echo VS_WPATH="%PATH%"
+echo export VS_WPATH
+EOF
+  chmod a+x ${bat}
+}
+
+# Create env file
+createEnv() # batfile envfile
+{
+  rm -f ${1}.stdout
+  cmd.exe /Q /C `${cygpath_short} $1` | \
+    sed -e 's@\\@/@g' | \
+    sed -e 's@//@/@g' > $2
+  if [ -f "${1}.stdout" ] ; then
+    cat ${1}.stdout 1>&2
+  fi
+  chmod a+x $2
+}
+
+printEnv() # name pname vsname val
+{
+  name="$1"
+  pname="$2"
+  vsname="$3"
+  val="$4"
+  if [ "${val}" != "" ] ; then
+    if [ "${shellStyle}" = "csh" ] ; then
+      if [ "${debug}" = "true" ] ; then
+        echo "setenv ${vsname} \"${val}\";"
+      fi
+      echo "setenv ${name} \"${val}\";"
+    elif [ "${shellStyle}" = "sh" ] ; then
+      if [ "${debug}" = "true" ] ; then
+        echo "${vsname}=\"${val}\";"
+        echo "export ${vsname};"
+      fi
+      echo "${name}=\"${val}\";"
+      echo "export ${name};"
+    elif [ "${shellStyle}" = "props" ] ; then
+      echo "vs.${pname}=${val}"
+    fi
+  fi
+}
+
+#############################################################################
+
+# Get Visual Studio settings
+if [ "${cygpath}" != "" ] ; then
+
+  # Create bat file to run
+  batfile="${tmp}/vs-to-env.bat"
+  if [ ! -d "${vcBinDir}" ] ; then
+    error "Does not exist: ${vcBinDir}"
+  elif [ "${vcvarsBat}" = "" ] ; then
+    error "No vcvars script: ${vcvarsBat}"
+  else
+    createBat "${batfile}" "${vcBinDir}" "${vcvarsBat}"
+  fi
+
+  # Run bat file to create environment variable settings
+  envfile="${tmp}/env.sh"
+  createEnv "${batfile}" "${envfile}"
+
+  # Read in the VS_* settings
+  . ${envfile}
+
+  # Derive unix style path, save old, and define new (remove dups)
+  VS_UPATH=`${cygpath_path} "${VS_WPATH}"`
+  export VS_UPATH
+  VS_OPATH=`printf "%s" "${PATH}" | sed -e 's@\\\\@/@g'`
+  export VS_OPATH
+  VS_PATH=`removeDeadDups "${VS_UPATH}${pathsep}${VS_OPATH}" "${pathsep}"`
+  export VS_PATH
+
+fi
+
+# Adjustments due to differences in vcvars*bat files
+if [ "${VS_MSVCDIR}" = "" ] ; then
+  VS_MSVCDIR="${VS_VCINSTALLDIR}"
+fi
+if [ "${VS_DEVENVDIR}" = "" ] ; then
+  VS_DEVENVDIR="${VS_VSINSTALLDIR}"
+fi
+
+# Print env settings
+#        env           vs.prop       vs env           value
+#        -------       -------       ----------       -----
+printEnv INCLUDE       include       VS_INCLUDE       "${VS_INCLUDE}"
+printEnv LIB           lib           VS_LIB           "${VS_LIB}"
+printEnv LIBPATH       libpath       VS_LIBPATH       "${VS_LIBPATH}"
+if [ "${debug}" = "true" ] ; then
+  printEnv UPATH         upath         VS_UPATH         "${VS_UPATH}"
+  printEnv WPATH         wpath         VS_WPATH         "${VS_WPATH}"
+  printEnv OPATH         opath         VS_OPATH         "${VS_OPATH}"
+fi
+printEnv PATH          path          VS_PATH          "${VS_PATH}"
+printEnv VCINSTALLDIR  vcinstalldir  VS_VCINSTALLDIR  "${VS_VCINSTALLDIR}"
+printEnv VSINSTALLDIR  vsinstalldir  VS_VSINSTALLDIR  "${VS_VSINSTALLDIR}"
+printEnv MSVCDIR       msvcdir       VS_MSVCDIR       "${VS_MSVCDIR}"
+printEnv MSSDK         mssdk         VS_MSSDK         "${VS_MSSDK}"
+printEnv MSTOOLS       mstools       VS_MSTOOLS       "${VS_MSTOOLS}"
+printEnv DEVENVDIR     devenvdir     VS_DEVENVDIR     "${VS_DEVENVDIR}"
+printEnv WINDOWSSDKDIR windowssdkdir VS_WINDOWSSDKDIR "${VS_WINDOWSSDKDIR}"
+if [ "${vcSelection}" = "10" ] ; then
+  printEnv VS100COMNTOOLS vs100comntools VS_VS100COMNTOOLS "${VS_VS100COMNTOOLS}"
+elif [ "${vcSelection}" = "9" ] ; then
+  printEnv VS90COMNTOOLS vs90comntools VS_VS90COMNTOOLS "${VS_VS90COMNTOOLS}"
+elif [ "${vcSelection}" = "7" ] ; then
+  printEnv VS71COMNTOOLS vs71comntools VS_VS71COMNTOOLS "${VS_VS71COMNTOOLS}"
+elif [ "${vcSelection}" = "8" ] ; then
+  printEnv VS80COMNTOOLS vs80comntools VS_VS80COMNTOOLS "${VS_VS80COMNTOOLS}"
+fi
+
+# Check final settings
+if [ "${verbose}" = "true" ] ; then
+  checkPaths "Windows PATH" "${VS_WPATH}" ";"
+  checkPaths LIB "${VS_LIB}" ";"
+  checkPaths INCLUDE "${VS_INCLUDE}" ";"
+  checkPaths PATH "${VS_PATH}" "${pathsep}"
+fi
+
+# Remove all temp files
+rm -f -r ${tmp}
+
+exit 0
+
diff --git a/make/templates/bsd-header b/make/templates/bsd-header
index 1291114fc4915796c00f98859bf423e877a15144..cce4fa786bf6ee42085d35135718544463e798e5 100644
--- a/make/templates/bsd-header
+++ b/make/templates/bsd-header
@@ -1,4 +1,4 @@
-Copyright %YEARS% Sun Microsystems, Inc.  All Rights Reserved.
+Copyright (c) %YEARS% Oracle and/or its affiliates. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
@@ -26,3 +26,4 @@ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/make/templates/gpl-cp-header b/make/templates/gpl-cp-header
index ed422f45fdc3fd72d193a4d0c87b517e61464131..8c03edf89e03ad2f46e43b4534381be9d9c623fa 100644
--- a/make/templates/gpl-cp-header
+++ b/make/templates/gpl-cp-header
@@ -1,4 +1,4 @@
-Copyright %YEARS% Sun Microsystems, Inc.  All Rights Reserved.
+Copyright (c) %YEARS% 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
@@ -20,3 +20,4 @@ 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.
+
diff --git a/make/templates/gpl-header b/make/templates/gpl-header
index e717b45b516a678eb2dfe85b52730942dba98536..dffde479c682c4e12ea0f94314bfa0d73e426a23 100644
--- a/make/templates/gpl-header
+++ b/make/templates/gpl-header
@@ -1,4 +1,4 @@
-Copyright %YEARS% Sun Microsystems, Inc.  All Rights Reserved.
+Copyright (c) %YEARS% 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
@@ -18,3 +18,4 @@ 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.
+