--- old/src/java.base/share/classes/sun/text/normalizer/NormalizerImpl.java	2020-01-10 15:57:31.000000000 -0800
+++ /dev/null	2020-01-10 15:57:31.000000000 -0800
@@ -1,2188 +0,0 @@
-/*
- * Copyright (c) 2009, 2019, 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.
- */
-
-/*
- *******************************************************************************
- *   Copyright (C) 2009-2014, International Business Machines
- *   Corporation and others.  All Rights Reserved.
- *******************************************************************************
- */
-package sun.text.normalizer;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.text.Normalizer;
-
-// Original filename in ICU4J: Normalizer2Impl.java
-public final class NormalizerImpl {
-    public static final class Hangul {
-        /* Korean Hangul and Jamo constants */
-        public static final int JAMO_L_BASE=0x1100;     /* "lead" jamo */
-        public static final int JAMO_V_BASE=0x1161;     /* "vowel" jamo */
-        public static final int JAMO_T_BASE=0x11a7;     /* "trail" jamo */
-
-        public static final int HANGUL_BASE=0xac00;
-        public static final int HANGUL_END=0xd7a3;
-
-        public static final int JAMO_L_COUNT=19;
-        public static final int JAMO_V_COUNT=21;
-        public static final int JAMO_T_COUNT=28;
-
-        public static final int HANGUL_COUNT=JAMO_L_COUNT*JAMO_V_COUNT*JAMO_T_COUNT;
-        public static final int HANGUL_LIMIT=HANGUL_BASE+HANGUL_COUNT;
-
-        public static boolean isHangul(int c) {
-            return HANGUL_BASE<=c && c<HANGUL_LIMIT;
-        }
-        public static boolean isHangulLV(int c) {
-            c-=HANGUL_BASE;
-            return 0<=c && c<HANGUL_COUNT && c%JAMO_T_COUNT==0;
-        }
-
-        /**
-         * Decomposes c, which must be a Hangul syllable, into buffer
-         * and returns the length of the decomposition (2 or 3).
-         */
-        public static int decompose(int c, Appendable buffer) {
-            try {
-                c-=HANGUL_BASE;
-                int c2=c%JAMO_T_COUNT;
-                c/=JAMO_T_COUNT;
-                buffer.append((char)(JAMO_L_BASE+c/JAMO_V_COUNT));
-                buffer.append((char)(JAMO_V_BASE+c%JAMO_V_COUNT));
-                if(c2==0) {
-                    return 2;
-                } else {
-                    buffer.append((char)(JAMO_T_BASE+c2));
-                    return 3;
-                }
-            } catch(IOException e) {
-                throw new InternalError(e);
-            }
-        }
-    }
-
-    /**
-     * Writable buffer that takes care of canonical ordering.
-     * Its Appendable methods behave like the C++ implementation's
-     * appendZeroCC() methods.
-     * <p>
-     * If dest is a StringBuilder, then the buffer writes directly to it.
-     * Otherwise, the buffer maintains a StringBuilder for intermediate text segments
-     * until no further changes are necessary and whole segments are appended.
-     * append() methods that take combining-class values always write to the StringBuilder.
-     * Other append() methods flush and append to the Appendable.
-     */
-    public static final class ReorderingBuffer implements Appendable {
-        public ReorderingBuffer(NormalizerImpl ni, Appendable dest, int destCapacity) {
-            impl=ni;
-            app=dest;
-            if (app instanceof StringBuilder) {
-                appIsStringBuilder=true;
-                str=(StringBuilder)dest;
-                // In Java, the constructor subsumes public void init(int destCapacity)
-                str.ensureCapacity(destCapacity);
-                reorderStart=0;
-                if(str.length()==0) {
-                    lastCC=0;
-                } else {
-                    setIterator();
-                    lastCC=previousCC();
-                    // Set reorderStart after the last code point with cc<=1 if there is one.
-                    if(lastCC>1) {
-                        while(previousCC()>1) {}
-                    }
-                    reorderStart=codePointLimit;
-                }
-            } else {
-                appIsStringBuilder=false;
-                str=new StringBuilder();
-                reorderStart=0;
-                lastCC=0;
-            }
-        }
-
-        public boolean isEmpty() { return str.length()==0; }
-        public int length() { return str.length(); }
-        public int getLastCC() { return lastCC; }
-
-        public StringBuilder getStringBuilder() { return str; }
-
-        public boolean equals(CharSequence s, int start, int limit) {
-            return UTF16Plus.equal(str, 0, str.length(), s, start, limit);
-        }
-
-        public void append(int c, int cc) {
-            if(lastCC<=cc || cc==0) {
-                str.appendCodePoint(c);
-                lastCC=cc;
-                if(cc<=1) {
-                    reorderStart=str.length();
-                }
-            } else {
-                insert(c, cc);
-            }
-        }
-        public void append(CharSequence s, int start, int limit, boolean isNFD,
-                           int leadCC, int trailCC) {
-            if(start==limit) {
-                return;
-            }
-            if(lastCC<=leadCC || leadCC==0) {
-                if(trailCC<=1) {
-                    reorderStart=str.length()+(limit-start);
-                } else if(leadCC<=1) {
-                    reorderStart=str.length()+1;  // Ok if not a code point boundary.
-                }
-                str.append(s, start, limit);
-                lastCC=trailCC;
-            } else {
-                int c=Character.codePointAt(s, start);
-                start+=Character.charCount(c);
-                insert(c, leadCC);  // insert first code point
-                while(start<limit) {
-                    c=Character.codePointAt(s, start);
-                    start+=Character.charCount(c);
-                    if(start<limit) {
-                        if (isNFD) {
-                            leadCC = getCCFromYesOrMaybe(impl.getNorm16(c));
-                        } else {
-                            leadCC = impl.getCC(impl.getNorm16(c));
-                        }
-                    } else {
-                        leadCC=trailCC;
-                    }
-                    append(c, leadCC);
-                }
-            }
-        }
-        // The following append() methods work like C++ appendZeroCC().
-        // They assume that the cc or trailCC of their input is 0.
-        // Most of them implement Appendable interface methods.
-        @Override
-        public ReorderingBuffer append(char c) {
-            str.append(c);
-            lastCC=0;
-            reorderStart=str.length();
-            return this;
-        }
-        public void appendZeroCC(int c) {
-            str.appendCodePoint(c);
-            lastCC=0;
-            reorderStart=str.length();
-        }
-        @Override
-        public ReorderingBuffer append(CharSequence s) {
-            if(s.length()!=0) {
-                str.append(s);
-                lastCC=0;
-                reorderStart=str.length();
-            }
-            return this;
-        }
-        @Override
-        public ReorderingBuffer append(CharSequence s, int start, int limit) {
-            if(start!=limit) {
-                str.append(s, start, limit);
-                lastCC=0;
-                reorderStart=str.length();
-            }
-            return this;
-        }
-        /**
-         * Flushes from the intermediate StringBuilder to the Appendable,
-         * if they are different objects.
-         * Used after recomposition.
-         * Must be called at the end when writing to a non-StringBuilder Appendable.
-         */
-        public void flush() {
-            if(appIsStringBuilder) {
-                reorderStart=str.length();
-            } else {
-                try {
-                    app.append(str);
-                    str.setLength(0);
-                    reorderStart=0;
-                } catch(IOException e) {
-                    throw new InternalError(e);  // Avoid declaring "throws IOException".
-                }
-            }
-            lastCC=0;
-        }
-        /**
-         * Flushes from the intermediate StringBuilder to the Appendable,
-         * if they are different objects.
-         * Then appends the new text to the Appendable or StringBuilder.
-         * Normally used after quick check loops find a non-empty sequence.
-         */
-        public ReorderingBuffer flushAndAppendZeroCC(CharSequence s, int start, int limit) {
-            if(appIsStringBuilder) {
-                str.append(s, start, limit);
-                reorderStart=str.length();
-            } else {
-                try {
-                    app.append(str).append(s, start, limit);
-                    str.setLength(0);
-                    reorderStart=0;
-                } catch(IOException e) {
-                    throw new InternalError(e);  // Avoid declaring "throws IOException".
-                }
-            }
-            lastCC=0;
-            return this;
-        }
-        public void remove() {
-            str.setLength(0);
-            lastCC=0;
-            reorderStart=0;
-        }
-        public void removeSuffix(int suffixLength) {
-            int oldLength=str.length();
-            str.delete(oldLength-suffixLength, oldLength);
-            lastCC=0;
-            reorderStart=str.length();
-        }
-
-        // Inserts c somewhere before the last character.
-        // Requires 0<cc<lastCC which implies reorderStart<limit.
-        private void insert(int c, int cc) {
-            for(setIterator(), skipPrevious(); previousCC()>cc;) {}
-            // insert c at codePointLimit, after the character with prevCC<=cc
-            if(c<=0xffff) {
-                str.insert(codePointLimit, (char)c);
-                if(cc<=1) {
-                    reorderStart=codePointLimit+1;
-                }
-            } else {
-                str.insert(codePointLimit, Character.toChars(c));
-                if(cc<=1) {
-                    reorderStart=codePointLimit+2;
-                }
-            }
-        }
-
-        private final NormalizerImpl impl;
-        private final Appendable app;
-        private final StringBuilder str;
-        private final boolean appIsStringBuilder;
-        private int reorderStart;
-        private int lastCC;
-
-        // private backward iterator
-        private void setIterator() { codePointStart=str.length(); }
-        private void skipPrevious() {  // Requires 0<codePointStart.
-            codePointLimit=codePointStart;
-            codePointStart=str.offsetByCodePoints(codePointStart, -1);
-        }
-        private int previousCC() {  // Returns 0 if there is no previous character.
-            codePointLimit=codePointStart;
-            if(reorderStart>=codePointStart) {
-                return 0;
-            }
-            int c=str.codePointBefore(codePointStart);
-            codePointStart-=Character.charCount(c);
-            return impl.getCCFromYesOrMaybeCP(c);
-        }
-        private int codePointStart, codePointLimit;
-    }
-
-    // TODO: Propose as public API on the UTF16 class.
-    // TODO: Propose widening UTF16 methods that take char to take int.
-    // TODO: Propose widening UTF16 methods that take String to take CharSequence.
-    public static final class UTF16Plus {
-        /**
-         * Is this code point a lead surrogate (U+d800..U+dbff)?
-         * @param c code unit or code point
-         * @return true or false
-         */
-        public static boolean isLeadSurrogate(int c) { return (c & 0xfffffc00) == 0xd800; }
-        /**
-         * Assuming c is a surrogate code point (UTF16.isSurrogate(c)),
-         * is it a lead surrogate?
-         * @param c code unit or code point
-         * @return true or false
-         */
-        public static boolean isSurrogateLead(int c) { return (c&0x400)==0; }
-
-        /**
-         * Compares two CharSequence subsequences for binary equality.
-         * @param s1 first sequence
-         * @param start1 start offset in first sequence
-         * @param limit1 limit offset in first sequence
-         * @param s2 second sequence
-         * @param start2 start offset in second sequence
-         * @param limit2 limit offset in second sequence
-         * @return true if s1.subSequence(start1, limit1) contains the same text
-         *              as s2.subSequence(start2, limit2)
-         */
-        public static boolean equal(CharSequence s1, int start1, int limit1,
-                                    CharSequence s2, int start2, int limit2) {
-            if((limit1-start1)!=(limit2-start2)) {
-                return false;
-            }
-            if(s1==s2 && start1==start2) {
-                return true;
-            }
-            while(start1<limit1) {
-                if(s1.charAt(start1++)!=s2.charAt(start2++)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-    }
-
-    public NormalizerImpl() {}
-
-    private static final class IsAcceptable implements ICUBinary.Authenticate {
-        public boolean isDataVersionAcceptable(byte version[]) {
-            return version[0]==4;
-        }
-    }
-    private static final IsAcceptable IS_ACCEPTABLE = new IsAcceptable();
-    private static final int DATA_FORMAT = 0x4e726d32;  // "Nrm2"
-
-    public NormalizerImpl load(ByteBuffer bytes) {
-        try {
-            dataVersion=ICUBinary.readHeaderAndDataVersion(bytes, DATA_FORMAT, IS_ACCEPTABLE);
-            int indexesLength=bytes.getInt()/4;  // inIndexes[IX_NORM_TRIE_OFFSET]/4
-            if(indexesLength<=IX_MIN_LCCC_CP) {
-                throw new InternalError("Normalizer2 data: not enough indexes");
-            }
-            int[] inIndexes=new int[indexesLength];
-            inIndexes[0]=indexesLength*4;
-            for(int i=1; i<indexesLength; ++i) {
-                inIndexes[i]=bytes.getInt();
-            }
-
-            minDecompNoCP=inIndexes[IX_MIN_DECOMP_NO_CP];
-            minCompNoMaybeCP=inIndexes[IX_MIN_COMP_NO_MAYBE_CP];
-            minLcccCP=inIndexes[IX_MIN_LCCC_CP];
-
-            minYesNo=inIndexes[IX_MIN_YES_NO];
-            minYesNoMappingsOnly=inIndexes[IX_MIN_YES_NO_MAPPINGS_ONLY];
-            minNoNo=inIndexes[IX_MIN_NO_NO];
-            minNoNoCompBoundaryBefore=inIndexes[IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE];
-            minNoNoCompNoMaybeCC=inIndexes[IX_MIN_NO_NO_COMP_NO_MAYBE_CC];
-            minNoNoEmpty=inIndexes[IX_MIN_NO_NO_EMPTY];
-            limitNoNo=inIndexes[IX_LIMIT_NO_NO];
-            minMaybeYes=inIndexes[IX_MIN_MAYBE_YES];
-            assert((minMaybeYes&7)==0);  // 8-aligned for noNoDelta bit fields
-            centerNoNoDelta=(minMaybeYes>>DELTA_SHIFT)-MAX_DELTA-1;
-
-            // Read the normTrie.
-            int offset=inIndexes[IX_NORM_TRIE_OFFSET];
-            int nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];
-            int triePosition = bytes.position();
-            normTrie = CodePointTrie.Fast16.fromBinary(bytes);
-            int trieLength = bytes.position() - triePosition;
-            if(trieLength>(nextOffset-offset)) {
-                throw new InternalError("Normalizer2 data: not enough bytes for normTrie");
-            }
-            ICUBinary.skipBytes(bytes, (nextOffset-offset)-trieLength);  // skip padding after trie bytes
-
-            // Read the composition and mapping data.
-            offset=nextOffset;
-            nextOffset=inIndexes[IX_SMALL_FCD_OFFSET];
-            int numChars=(nextOffset-offset)/2;
-            if(numChars!=0) {
-                maybeYesCompositions=ICUBinary.getString(bytes, numChars, 0);
-                extraData=maybeYesCompositions.substring((MIN_NORMAL_MAYBE_YES-minMaybeYes)>>OFFSET_SHIFT);
-            }
-
-            // smallFCD: new in formatVersion 2
-            offset=nextOffset;
-            smallFCD=new byte[0x100];
-            bytes.get(smallFCD);
-
-            return this;
-        } catch(IOException e) {
-            throw new InternalError(e);
-        }
-    }
-    public NormalizerImpl load(String name) {
-        return load(ICUBinary.getRequiredData(name));
-    }
-
-    // The trie stores values for lead surrogate code *units*.
-    // Surrogate code *points* are inert.
-    public int getNorm16(int c) {
-        return UTF16Plus.isLeadSurrogate(c) ? INERT : normTrie.get(c);
-    }
-    public int getRawNorm16(int c) { return normTrie.get(c); }
-    public boolean isAlgorithmicNoNo(int norm16) { return limitNoNo<=norm16 && norm16<minMaybeYes; }
-    public boolean isCompNo(int norm16) { return minNoNo<=norm16 && norm16<minMaybeYes; }
-    public boolean isDecompYes(int norm16) { return norm16<minYesNo || minMaybeYes<=norm16; }
-
-    public int getCC(int norm16) {
-        if(norm16>=MIN_NORMAL_MAYBE_YES) {
-            return getCCFromNormalYesOrMaybe(norm16);
-        }
-        if(norm16<minNoNo || limitNoNo<=norm16) {
-            return 0;
-        }
-        return getCCFromNoNo(norm16);
-    }
-    public static int getCCFromNormalYesOrMaybe(int norm16) {
-        return (norm16 >> OFFSET_SHIFT) & 0xff;
-    }
-    public static int getCCFromYesOrMaybe(int norm16) {
-        return norm16>=MIN_NORMAL_MAYBE_YES ? getCCFromNormalYesOrMaybe(norm16) : 0;
-    }
-    public int getCCFromYesOrMaybeCP(int c) {
-        if (c < minCompNoMaybeCP) { return 0; }
-        return getCCFromYesOrMaybe(getNorm16(c));
-    }
-
-    /**
-     * Returns the FCD data for code point c.
-     * @param c A Unicode code point.
-     * @return The lccc(c) in bits 15..8 and tccc(c) in bits 7..0.
-     */
-    public int getFCD16(int c) {
-        if(c<minDecompNoCP) {
-            return 0;
-        } else if(c<=0xffff) {
-            if(!singleLeadMightHaveNonZeroFCD16(c)) { return 0; }
-        }
-        return getFCD16FromNormData(c);
-    }
-    /** Returns true if the single-or-lead code unit c might have non-zero FCD data. */
-    public boolean singleLeadMightHaveNonZeroFCD16(int lead) {
-        // 0<=lead<=0xffff
-        byte bits=smallFCD[lead>>8];
-        if(bits==0) { return false; }
-        return ((bits>>((lead>>5)&7))&1)!=0;
-    }
-
-    /** Gets the FCD value from the regular normalization data. */
-    public int getFCD16FromNormData(int c) {
-        int norm16=getNorm16(c);
-        if (norm16 >= limitNoNo) {
-            if(norm16>=MIN_NORMAL_MAYBE_YES) {
-                // combining mark
-                norm16=getCCFromNormalYesOrMaybe(norm16);
-                return norm16|(norm16<<8);
-            } else if(norm16>=minMaybeYes) {
-                return 0;
-            } else {  // isDecompNoAlgorithmic(norm16)
-                int deltaTrailCC = norm16 & DELTA_TCCC_MASK;
-                if (deltaTrailCC <= DELTA_TCCC_1) {
-                    return deltaTrailCC >> OFFSET_SHIFT;
-                }
-                // Maps to an isCompYesAndZeroCC.
-                c=mapAlgorithmic(c, norm16);
-                norm16=getRawNorm16(c);
-            }
-        }
-        if(norm16<=minYesNo || isHangulLVT(norm16)) {
-            // no decomposition or Hangul syllable, all zeros
-            return 0;
-        }
-        // c decomposes, get everything from the variable-length extra data
-        int mapping=norm16>>OFFSET_SHIFT;
-        int firstUnit=extraData.charAt(mapping);
-        int fcd16=firstUnit>>8;  // tccc
-        if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
-            fcd16|=extraData.charAt(mapping-1)&0xff00;  // lccc
-        }
-        return fcd16;
-    }
-
-    /**
-     * Gets the decomposition for one code point.
-     * @param c code point
-     * @return c's decomposition, if it has one; returns null if it does not have a decomposition
-     */
-    public String getDecomposition(int c) {
-        int norm16;
-        if(c<minDecompNoCP || isMaybeOrNonZeroCC(norm16=getNorm16(c))) {
-            // c does not decompose
-            return null;
-        }
-        int decomp = -1;
-        if(isDecompNoAlgorithmic(norm16)) {
-            // Maps to an isCompYesAndZeroCC.
-            decomp=c=mapAlgorithmic(c, norm16);
-            // The mapping might decompose further.
-            norm16 = getRawNorm16(c);
-        }
-        if (norm16 < minYesNo) {
-            if(decomp<0) {
-                return null;
-            } else {
-                return UTF16.valueOf(decomp);
-            }
-        } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
-            // Hangul syllable: decompose algorithmically
-            StringBuilder buffer=new StringBuilder();
-            Hangul.decompose(c, buffer);
-            return buffer.toString();
-        }
-        // c decomposes, get everything from the variable-length extra data
-        int mapping=norm16>>OFFSET_SHIFT;
-        int length=extraData.charAt(mapping++)&MAPPING_LENGTH_MASK;
-        return extraData.substring(mapping, mapping+length);
-    }
-
-    // Fixed norm16 values.
-    public static final int MIN_YES_YES_WITH_CC=0xfe02;
-    public static final int JAMO_VT=0xfe00;
-    public static final int MIN_NORMAL_MAYBE_YES=0xfc00;
-    public static final int JAMO_L=2;  // offset=1 hasCompBoundaryAfter=FALSE
-    public static final int INERT=1;  // offset=0 hasCompBoundaryAfter=TRUE
-
-    // norm16 bit 0 is comp-boundary-after.
-    public static final int HAS_COMP_BOUNDARY_AFTER=1;
-    public static final int OFFSET_SHIFT=1;
-
-    // For algorithmic one-way mappings, norm16 bits 2..1 indicate the
-    // tccc (0, 1, >1) for quick FCC boundary-after tests.
-    public static final int DELTA_TCCC_0=0;
-    public static final int DELTA_TCCC_1=2;
-    public static final int DELTA_TCCC_GT_1=4;
-    public static final int DELTA_TCCC_MASK=6;
-    public static final int DELTA_SHIFT=3;
-
-    public static final int MAX_DELTA=0x40;
-
-    // Byte offsets from the start of the data, after the generic header.
-    public static final int IX_NORM_TRIE_OFFSET=0;
-    public static final int IX_EXTRA_DATA_OFFSET=1;
-    public static final int IX_SMALL_FCD_OFFSET=2;
-    public static final int IX_RESERVED3_OFFSET=3;
-    public static final int IX_TOTAL_SIZE=7;
-    public static final int MIN_CCC_LCCC_CP=0x300;
-    // Code point thresholds for quick check codes.
-    public static final int IX_MIN_DECOMP_NO_CP=8;
-    public static final int IX_MIN_COMP_NO_MAYBE_CP=9;
-
-    // Norm16 value thresholds for quick check combinations and types of extra data.
-
-    /** Mappings & compositions in [minYesNo..minYesNoMappingsOnly[. */
-    public static final int IX_MIN_YES_NO=10;
-    /** Mappings are comp-normalized. */
-    public static final int IX_MIN_NO_NO=11;
-    public static final int IX_LIMIT_NO_NO=12;
-    public static final int IX_MIN_MAYBE_YES=13;
-
-    /** Mappings only in [minYesNoMappingsOnly..minNoNo[. */
-    public static final int IX_MIN_YES_NO_MAPPINGS_ONLY=14;
-    /** Mappings are not comp-normalized but have a comp boundary before. */
-    public static final int IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE=15;
-    /** Mappings do not have a comp boundary before. */
-    public static final int IX_MIN_NO_NO_COMP_NO_MAYBE_CC=16;
-    /** Mappings to the empty string. */
-    public static final int IX_MIN_NO_NO_EMPTY=17;
-
-    public static final int IX_MIN_LCCC_CP=18;
-    public static final int IX_COUNT=20;
-
-    public static final int MAPPING_HAS_CCC_LCCC_WORD=0x80;
-    public static final int MAPPING_HAS_RAW_MAPPING=0x40;
-    // unused bit 0x20;
-    public static final int MAPPING_LENGTH_MASK=0x1f;
-
-    public static final int COMP_1_LAST_TUPLE=0x8000;
-    public static final int COMP_1_TRIPLE=1;
-    public static final int COMP_1_TRAIL_LIMIT=0x3400;
-    public static final int COMP_1_TRAIL_MASK=0x7ffe;
-    public static final int COMP_1_TRAIL_SHIFT=9;  // 10-1 for the "triple" bit
-    public static final int COMP_2_TRAIL_SHIFT=6;
-    public static final int COMP_2_TRAIL_MASK=0xffc0;
-
-    // higher-level functionality ------------------------------------------ ***
-
-    /**
-     * Decomposes s[src, limit[ and writes the result to dest.
-     * limit can be NULL if src is NUL-terminated.
-     * destLengthEstimate is the initial dest buffer capacity and can be -1.
-     */
-    public void decompose(CharSequence s, int src, int limit, StringBuilder dest,
-                   int destLengthEstimate) {
-        if(destLengthEstimate<0) {
-            destLengthEstimate=limit-src;
-        }
-        dest.setLength(0);
-        ReorderingBuffer buffer=new ReorderingBuffer(this, dest, destLengthEstimate);
-        decompose(s, src, limit, buffer);
-    }
-
-    // Dual functionality:
-    // buffer!=NULL: normalize
-    // buffer==NULL: isNormalized/quickCheck/spanQuickCheckYes
-    public int decompose(CharSequence s, int src, int limit,
-                         ReorderingBuffer buffer) {
-        int minNoCP=minDecompNoCP;
-
-        int prevSrc;
-        int c=0;
-        int norm16=0;
-
-        // only for quick check
-        int prevBoundary=src;
-        int prevCC=0;
-
-        for(;;) {
-            // count code units below the minimum or with irrelevant data for the quick check
-            for(prevSrc=src; src!=limit;) {
-                if( (c=s.charAt(src))<minNoCP ||
-                    isMostDecompYesAndZeroCC(norm16=normTrie.bmpGet(c))
-                ) {
-                    ++src;
-                } else if(!UTF16Plus.isLeadSurrogate(c)) {
-                    break;
-                } else {
-                    char c2;
-                    if ((src + 1) != limit && Character.isLowSurrogate(c2 = s.charAt(src + 1))) {
-                        c = Character.toCodePoint((char)c, c2);
-                        norm16 = normTrie.suppGet(c);
-                        if (isMostDecompYesAndZeroCC(norm16)) {
-                            src += 2;
-                        } else {
-                            break;
-                        }
-                    } else {
-                        ++src;  // unpaired lead surrogate: inert
-                    }
-                }
-            }
-            // copy these code units all at once
-            if(src!=prevSrc) {
-                if(buffer!=null) {
-                    buffer.flushAndAppendZeroCC(s, prevSrc, src);
-                } else {
-                    prevCC=0;
-                    prevBoundary=src;
-                }
-            }
-            if(src==limit) {
-                break;
-            }
-
-            // Check one above-minimum, relevant code point.
-            src+=Character.charCount(c);
-            if(buffer!=null) {
-                decompose(c, norm16, buffer);
-            } else {
-                if(isDecompYes(norm16)) {
-                    int cc=getCCFromYesOrMaybe(norm16);
-                    if(prevCC<=cc || cc==0) {
-                        prevCC=cc;
-                        if(cc<=1) {
-                            prevBoundary=src;
-                        }
-                        continue;
-                    }
-                }
-                return prevBoundary;  // "no" or cc out of order
-            }
-        }
-        return src;
-    }
-    public void decomposeAndAppend(CharSequence s, boolean doDecompose, ReorderingBuffer buffer) {
-        int limit=s.length();
-        if(limit==0) {
-            return;
-        }
-        if(doDecompose) {
-            decompose(s, 0, limit, buffer);
-            return;
-        }
-        // Just merge the strings at the boundary.
-        int c=Character.codePointAt(s, 0);
-        int src=0;
-        int firstCC, prevCC, cc;
-        firstCC=prevCC=cc=getCC(getNorm16(c));
-        while(cc!=0) {
-            prevCC=cc;
-            src+=Character.charCount(c);
-            if(src>=limit) {
-                break;
-            }
-            c=Character.codePointAt(s, src);
-            cc=getCC(getNorm16(c));
-        };
-        buffer.append(s, 0, src, false, firstCC, prevCC);
-        buffer.append(s, src, limit);
-    }
-
-    // Very similar to composeQuickCheck(): Make the same changes in both places if relevant.
-    // doCompose: normalize
-    // !doCompose: isNormalized (buffer must be empty and initialized)
-    public boolean compose(CharSequence s, int src, int limit,
-                           boolean onlyContiguous,
-                           boolean doCompose,
-                           ReorderingBuffer buffer) {
-        int prevBoundary=src;
-        int minNoMaybeCP=minCompNoMaybeCP;
-
-        for (;;) {
-            // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
-            // or with (compYes && ccc==0) properties.
-            int prevSrc;
-            int c = 0;
-            int norm16 = 0;
-            for (;;) {
-                if (src == limit) {
-                    if (prevBoundary != limit && doCompose) {
-                        buffer.append(s, prevBoundary, limit);
-                    }
-                    return true;
-                }
-                if( (c=s.charAt(src))<minNoMaybeCP ||
-                    isCompYesAndZeroCC(norm16=normTrie.bmpGet(c))
-                ) {
-                    ++src;
-                } else {
-                    prevSrc = src++;
-                    if (!UTF16Plus.isLeadSurrogate(c)) {
-                        break;
-                    } else {
-                        char c2;
-                        if (src != limit && Character.isLowSurrogate(c2 = s.charAt(src))) {
-                            ++src;
-                            c = Character.toCodePoint((char)c, c2);
-                            norm16 = normTrie.suppGet(c);
-                            if (!isCompYesAndZeroCC(norm16)) {
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
-            // The current character is either a "noNo" (has a mapping)
-            // or a "maybeYes" (combines backward)
-            // or a "yesYes" with ccc!=0.
-            // It is not a Hangul syllable or Jamo L because those have "yes" properties.
-
-            // Medium-fast path: Handle cases that do not require full decomposition and recomposition.
-            if (!isMaybeOrNonZeroCC(norm16)) {  // minNoNo <= norm16 < minMaybeYes
-                if (!doCompose) {
-                    return false;
-                }
-                // Fast path for mapping a character that is immediately surrounded by boundaries.
-                // In this case, we need not decompose around the current character.
-                if (isDecompNoAlgorithmic(norm16)) {
-                    // Maps to a single isCompYesAndZeroCC character
-                    // which also implies hasCompBoundaryBefore.
-                    if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
-                            hasCompBoundaryBefore(s, src, limit)) {
-                        if (prevBoundary != prevSrc) {
-                            buffer.append(s, prevBoundary, prevSrc);
-                        }
-                        buffer.append(mapAlgorithmic(c, norm16), 0);
-                        prevBoundary = src;
-                        continue;
-                    }
-                } else if (norm16 < minNoNoCompBoundaryBefore) {
-                    // The mapping is comp-normalized which also implies hasCompBoundaryBefore.
-                    if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
-                            hasCompBoundaryBefore(s, src, limit)) {
-                        if (prevBoundary != prevSrc) {
-                            buffer.append(s, prevBoundary, prevSrc);
-                        }
-                        int mapping = norm16 >> OFFSET_SHIFT;
-                        int length = extraData.charAt(mapping++) & MAPPING_LENGTH_MASK;
-                        buffer.append(extraData, mapping, mapping + length);
-                        prevBoundary = src;
-                        continue;
-                    }
-                } else if (norm16 >= minNoNoEmpty) {
-                    // The current character maps to nothing.
-                    // Simply omit it from the output if there is a boundary before _or_ after it.
-                    // The character itself implies no boundaries.
-                    if (hasCompBoundaryBefore(s, src, limit) ||
-                            hasCompBoundaryAfter(s, prevBoundary, prevSrc, onlyContiguous)) {
-                        if (prevBoundary != prevSrc) {
-                            buffer.append(s, prevBoundary, prevSrc);
-                        }
-                        prevBoundary = src;
-                        continue;
-                    }
-                }
-                // Other "noNo" type, or need to examine more text around this character:
-                // Fall through to the slow path.
-            } else if (isJamoVT(norm16) && prevBoundary != prevSrc) {
-                char prev=s.charAt(prevSrc-1);
-                if(c<Hangul.JAMO_T_BASE) {
-                    // The current character is a Jamo Vowel,
-                    // compose with previous Jamo L and following Jamo T.
-                    char l = (char)(prev-Hangul.JAMO_L_BASE);
-                    if(l<Hangul.JAMO_L_COUNT) {
-                        if (!doCompose) {
-                            return false;
-                        }
-                        int t;
-                        if (src != limit &&
-                                0 < (t = (s.charAt(src) - Hangul.JAMO_T_BASE)) &&
-                                t < Hangul.JAMO_T_COUNT) {
-                            // The next character is a Jamo T.
-                            ++src;
-                        } else if (hasCompBoundaryBefore(s, src, limit)) {
-                            // No Jamo T follows, not even via decomposition.
-                            t = 0;
-                        } else {
-                            t = -1;
-                        }
-                        if (t >= 0) {
-                            int syllable = Hangul.HANGUL_BASE +
-                                (l*Hangul.JAMO_V_COUNT + (c-Hangul.JAMO_V_BASE)) *
-                                Hangul.JAMO_T_COUNT + t;
-                            --prevSrc;  // Replace the Jamo L as well.
-                            if (prevBoundary != prevSrc) {
-                                buffer.append(s, prevBoundary, prevSrc);
-                            }
-                            buffer.append((char)syllable);
-                            prevBoundary = src;
-                            continue;
-                        }
-                        // If we see L+V+x where x!=T then we drop to the slow path,
-                        // decompose and recompose.
-                        // This is to deal with NFKC finding normal L and V but a
-                        // compatibility variant of a T.
-                        // We need to either fully compose that combination here
-                        // (which would complicate the code and may not work with strange custom data)
-                        // or use the slow path.
-                    }
-                } else if (Hangul.isHangulLV(prev)) {
-                    // The current character is a Jamo Trailing consonant,
-                    // compose with previous Hangul LV that does not contain a Jamo T.
-                    if (!doCompose) {
-                        return false;
-                    }
-                    int syllable = prev + c - Hangul.JAMO_T_BASE;
-                    --prevSrc;  // Replace the Hangul LV as well.
-                    if (prevBoundary != prevSrc) {
-                        buffer.append(s, prevBoundary, prevSrc);
-                    }
-                    buffer.append((char)syllable);
-                    prevBoundary = src;
-                    continue;
-                }
-                // No matching context, or may need to decompose surrounding text first:
-                // Fall through to the slow path.
-            } else if (norm16 > JAMO_VT) {  // norm16 >= MIN_YES_YES_WITH_CC
-                // One or more combining marks that do not combine-back:
-                // Check for canonical order, copy unchanged if ok and
-                // if followed by a character with a boundary-before.
-                int cc = getCCFromNormalYesOrMaybe(norm16);  // cc!=0
-                if (onlyContiguous /* FCC */ && getPreviousTrailCC(s, prevBoundary, prevSrc) > cc) {
-                    // Fails FCD test, need to decompose and contiguously recompose.
-                    if (!doCompose) {
-                        return false;
-                    }
-                } else {
-                    // If !onlyContiguous (not FCC), then we ignore the tccc of
-                    // the previous character which passed the quick check "yes && ccc==0" test.
-                    int n16;
-                    for (;;) {
-                        if (src == limit) {
-                            if (doCompose) {
-                                buffer.append(s, prevBoundary, limit);
-                            }
-                            return true;
-                        }
-                        int prevCC = cc;
-                        c = Character.codePointAt(s, src);
-                        n16 = normTrie.get(c);
-                        if (n16 >= MIN_YES_YES_WITH_CC) {
-                            cc = getCCFromNormalYesOrMaybe(n16);
-                            if (prevCC > cc) {
-                                if (!doCompose) {
-                                    return false;
-                                }
-                                break;
-                            }
-                        } else {
-                            break;
-                        }
-                        src += Character.charCount(c);
-                    }
-                    // p is after the last in-order combining mark.
-                    // If there is a boundary here, then we continue with no change.
-                    if (norm16HasCompBoundaryBefore(n16)) {
-                        if (isCompYesAndZeroCC(n16)) {
-                            src += Character.charCount(c);
-                        }
-                        continue;
-                    }
-                    // Use the slow path. There is no boundary in [prevSrc, src[.
-                }
-            }
-
-            // Slow path: Find the nearest boundaries around the current character,
-            // decompose and recompose.
-            if (prevBoundary != prevSrc && !norm16HasCompBoundaryBefore(norm16)) {
-                c = Character.codePointBefore(s, prevSrc);
-                norm16 = normTrie.get(c);
-                if (!norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
-                    prevSrc -= Character.charCount(c);
-                }
-            }
-            if (doCompose && prevBoundary != prevSrc) {
-                buffer.append(s, prevBoundary, prevSrc);
-            }
-            int recomposeStartIndex=buffer.length();
-            // We know there is not a boundary here.
-            decomposeShort(s, prevSrc, src, false /* !stopAtCompBoundary */, onlyContiguous,
-                           buffer);
-            // Decompose until the next boundary.
-            src = decomposeShort(s, src, limit, true /* stopAtCompBoundary */, onlyContiguous,
-                                 buffer);
-            recompose(buffer, recomposeStartIndex, onlyContiguous);
-            if(!doCompose) {
-                if(!buffer.equals(s, prevSrc, src)) {
-                    return false;
-                }
-                buffer.remove();
-            }
-            prevBoundary=src;
-        }
-    }
-
-    /**
-     * Very similar to compose(): Make the same changes in both places if relevant.
-     * doSpan: spanQuickCheckYes (ignore bit 0 of the return value)
-     * !doSpan: quickCheck
-     * @return bits 31..1: spanQuickCheckYes (==s.length() if "yes") and
-     *         bit 0: set if "maybe"; otherwise, if the span length&lt;s.length()
-     *         then the quick check result is "no"
-     */
-    public int composeQuickCheck(CharSequence s, int src, int limit,
-                                 boolean onlyContiguous, boolean doSpan) {
-        int qcResult=0;
-        int prevBoundary=src;
-        int minNoMaybeCP=minCompNoMaybeCP;
-
-        for(;;) {
-            // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
-            // or with (compYes && ccc==0) properties.
-            int prevSrc;
-            int c = 0;
-            int norm16 = 0;
-            for (;;) {
-                if(src==limit) {
-                    return (src<<1)|qcResult;  // "yes" or "maybe"
-                }
-                if( (c=s.charAt(src))<minNoMaybeCP ||
-                    isCompYesAndZeroCC(norm16=normTrie.bmpGet(c))
-                ) {
-                    ++src;
-                } else {
-                    prevSrc = src++;
-                    if (!UTF16Plus.isLeadSurrogate(c)) {
-                        break;
-                    } else {
-                        char c2;
-                        if (src != limit && Character.isLowSurrogate(c2 = s.charAt(src))) {
-                            ++src;
-                            c = Character.toCodePoint((char)c, c2);
-                            norm16 = normTrie.suppGet(c);
-                            if (!isCompYesAndZeroCC(norm16)) {
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
-            // The current character is either a "noNo" (has a mapping)
-            // or a "maybeYes" (combines backward)
-            // or a "yesYes" with ccc!=0.
-            // It is not a Hangul syllable or Jamo L because those have "yes" properties.
-
-            int prevNorm16 = INERT;
-            if (prevBoundary != prevSrc) {
-                prevBoundary = prevSrc;
-                if (!norm16HasCompBoundaryBefore(norm16)) {
-                    c = Character.codePointBefore(s, prevSrc);
-                    int n16 = getNorm16(c);
-                    if (!norm16HasCompBoundaryAfter(n16, onlyContiguous)) {
-                        prevBoundary -= Character.charCount(c);
-                        prevNorm16 = n16;
-                    }
-                }
-            }
-
-            if(isMaybeOrNonZeroCC(norm16)) {
-                int cc=getCCFromYesOrMaybe(norm16);
-                if (onlyContiguous /* FCC */ && cc != 0 &&
-                        getTrailCCFromCompYesAndZeroCC(prevNorm16) > cc) {
-                    // The [prevBoundary..prevSrc[ character
-                    // passed the quick check "yes && ccc==0" test
-                    // but is out of canonical order with the current combining mark.
-                } else {
-                    // If !onlyContiguous (not FCC), then we ignore the tccc of
-                    // the previous character which passed the quick check "yes && ccc==0" test.
-                    for (;;) {
-                        if (norm16 < MIN_YES_YES_WITH_CC) {
-                            if (!doSpan) {
-                                qcResult = 1;
-                            } else {
-                                return prevBoundary << 1;  // spanYes does not care to know it's "maybe"
-                            }
-                        }
-                        if (src == limit) {
-                            return (src<<1) | qcResult;  // "yes" or "maybe"
-                        }
-                        int prevCC = cc;
-                        c = Character.codePointAt(s, src);
-                        norm16 = getNorm16(c);
-                        if (isMaybeOrNonZeroCC(norm16)) {
-                            cc = getCCFromYesOrMaybe(norm16);
-                            if (!(prevCC <= cc || cc == 0)) {
-                                break;
-                            }
-                        } else {
-                            break;
-                        }
-                        src += Character.charCount(c);
-                    }
-                    // src is after the last in-order combining mark.
-                    if (isCompYesAndZeroCC(norm16)) {
-                        prevBoundary = src;
-                        src += Character.charCount(c);
-                        continue;
-                    }
-                }
-            }
-            return prevBoundary<<1;  // "no"
-        }
-    }
-    public void composeAndAppend(CharSequence s,
-                                 boolean doCompose,
-                                 boolean onlyContiguous,
-                                 ReorderingBuffer buffer) {
-        int src=0, limit=s.length();
-        if(!buffer.isEmpty()) {
-            int firstStarterInSrc=findNextCompBoundary(s, 0, limit, onlyContiguous);
-            if(0!=firstStarterInSrc) {
-                int lastStarterInDest=findPreviousCompBoundary(buffer.getStringBuilder(),
-                                                               buffer.length(), onlyContiguous);
-                StringBuilder middle=new StringBuilder((buffer.length()-lastStarterInDest)+
-                                                       firstStarterInSrc+16);
-                middle.append(buffer.getStringBuilder(), lastStarterInDest, buffer.length());
-                buffer.removeSuffix(buffer.length()-lastStarterInDest);
-                middle.append(s, 0, firstStarterInSrc);
-                compose(middle, 0, middle.length(), onlyContiguous, true, buffer);
-                src=firstStarterInSrc;
-            }
-        }
-        if(doCompose) {
-            compose(s, src, limit, onlyContiguous, true, buffer);
-        } else {
-            buffer.append(s, src, limit);
-        }
-    }
-    // Dual functionality:
-    // buffer!=NULL: normalize
-    // buffer==NULL: isNormalized/quickCheck/spanQuickCheckYes
-    public int makeFCD(CharSequence s, int src, int limit, ReorderingBuffer buffer) {
-        // Note: In this function we use buffer->appendZeroCC() because we track
-        // the lead and trail combining classes here, rather than leaving it to
-        // the ReorderingBuffer.
-        // The exception is the call to decomposeShort() which uses the buffer
-        // in the normal way.
-
-        // Tracks the last FCD-safe boundary, before lccc=0 or after properly-ordered tccc<=1.
-        // Similar to the prevBoundary in the compose() implementation.
-        int prevBoundary=src;
-        int prevSrc;
-        int c=0;
-        int prevFCD16=0;
-        int fcd16=0;
-
-        for(;;) {
-            // count code units with lccc==0
-            for(prevSrc=src; src!=limit;) {
-                if((c=s.charAt(src))<minLcccCP) {
-                    prevFCD16=~c;
-                    ++src;
-                } else if(!singleLeadMightHaveNonZeroFCD16(c)) {
-                    prevFCD16=0;
-                    ++src;
-                } else {
-                    if (UTF16Plus.isLeadSurrogate(c)) {
-                        char c2;
-                        if ((src + 1) != limit && Character.isLowSurrogate(c2 = s.charAt(src + 1))) {
-                            c = Character.toCodePoint((char)c, c2);
-                        }
-                    }
-                    if((fcd16=getFCD16FromNormData(c))<=0xff) {
-                        prevFCD16=fcd16;
-                        src+=Character.charCount(c);
-                    } else {
-                        break;
-                    }
-                }
-            }
-            // copy these code units all at once
-            if(src!=prevSrc) {
-                if(src==limit) {
-                    if(buffer!=null) {
-                        buffer.flushAndAppendZeroCC(s, prevSrc, src);
-                    }
-                    break;
-                }
-                prevBoundary=src;
-                // We know that the previous character's lccc==0.
-                if(prevFCD16<0) {
-                    // Fetching the fcd16 value was deferred for this below-minLcccCP code point.
-                    int prev=~prevFCD16;
-                    if(prev<minDecompNoCP) {
-                        prevFCD16=0;
-                    } else {
-                        prevFCD16=getFCD16FromNormData(prev);
-                        if(prevFCD16>1) {
-                            --prevBoundary;
-                        }
-                    }
-                } else {
-                    int p=src-1;
-                    if( Character.isLowSurrogate(s.charAt(p)) && prevSrc<p &&
-                        Character.isHighSurrogate(s.charAt(p-1))
-                    ) {
-                        --p;
-                        // Need to fetch the previous character's FCD value because
-                        // prevFCD16 was just for the trail surrogate code point.
-                        prevFCD16=getFCD16FromNormData(Character.toCodePoint(s.charAt(p), s.charAt(p+1)));
-                        // Still known to have lccc==0 because its lead surrogate unit had lccc==0.
-                    }
-                    if(prevFCD16>1) {
-                        prevBoundary=p;
-                    }
-                }
-                if(buffer!=null) {
-                    // The last lccc==0 character is excluded from the
-                    // flush-and-append call in case it needs to be modified.
-                    buffer.flushAndAppendZeroCC(s, prevSrc, prevBoundary);
-                    buffer.append(s, prevBoundary, src);
-                }
-                // The start of the current character (c).
-                prevSrc=src;
-            } else if(src==limit) {
-                break;
-            }
-
-            src+=Character.charCount(c);
-            // The current character (c) at [prevSrc..src[ has a non-zero lead combining class.
-            // Check for proper order, and decompose locally if necessary.
-            if((prevFCD16&0xff)<=(fcd16>>8)) {
-                // proper order: prev tccc <= current lccc
-                if((fcd16&0xff)<=1) {
-                    prevBoundary=src;
-                }
-                if(buffer!=null) {
-                    buffer.appendZeroCC(c);
-                }
-                prevFCD16=fcd16;
-                continue;
-            } else if(buffer==null) {
-                return prevBoundary;  // quick check "no"
-            } else {
-                /*
-                 * Back out the part of the source that we copied or appended
-                 * already but is now going to be decomposed.
-                 * prevSrc is set to after what was copied/appended.
-                 */
-                buffer.removeSuffix(prevSrc-prevBoundary);
-                /*
-                 * Find the part of the source that needs to be decomposed,
-                 * up to the next safe boundary.
-                 */
-                src=findNextFCDBoundary(s, src, limit);
-                /*
-                 * The source text does not fulfill the conditions for FCD.
-                 * Decompose and reorder a limited piece of the text.
-                 */
-                decomposeShort(s, prevBoundary, src, false, false, buffer);
-                prevBoundary=src;
-                prevFCD16=0;
-            }
-        }
-        return src;
-    }
-
-    public boolean hasDecompBoundaryBefore(int c) {
-        return c < minLcccCP || (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) ||
-            norm16HasDecompBoundaryBefore(getNorm16(c));
-    }
-    public boolean norm16HasDecompBoundaryBefore(int norm16) {
-        if (norm16 < minNoNoCompNoMaybeCC) {
-            return true;
-        }
-        if (norm16 >= limitNoNo) {
-            return norm16 <= MIN_NORMAL_MAYBE_YES || norm16 == JAMO_VT;
-        }
-        // c decomposes, get everything from the variable-length extra data
-        int mapping=norm16>>OFFSET_SHIFT;
-        int firstUnit=extraData.charAt(mapping);
-        // true if leadCC==0 (hasFCDBoundaryBefore())
-        return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (extraData.charAt(mapping-1)&0xff00)==0;
-    }
-    public boolean hasDecompBoundaryAfter(int c) {
-        if (c < minDecompNoCP) {
-            return true;
-        }
-        if (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) {
-            return true;
-        }
-        return norm16HasDecompBoundaryAfter(getNorm16(c));
-    }
-    public boolean norm16HasDecompBoundaryAfter(int norm16) {
-        if(norm16 <= minYesNo || isHangulLVT(norm16)) {
-            return true;
-        }
-        if (norm16 >= limitNoNo) {
-            if (isMaybeOrNonZeroCC(norm16)) {
-                return norm16 <= MIN_NORMAL_MAYBE_YES || norm16 == JAMO_VT;
-            }
-            // Maps to an isCompYesAndZeroCC.
-            return (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1;
-        }
-        // c decomposes, get everything from the variable-length extra data
-        int mapping=norm16>>OFFSET_SHIFT;
-        int firstUnit=extraData.charAt(mapping);
-        // decomp after-boundary: same as hasFCDBoundaryAfter(),
-        // fcd16<=1 || trailCC==0
-        if(firstUnit>0x1ff) {
-            return false;  // trailCC>1
-        }
-        if(firstUnit<=0xff) {
-            return true;  // trailCC==0
-        }
-        // if(trailCC==1) test leadCC==0, same as checking for before-boundary
-        // true if leadCC==0 (hasFCDBoundaryBefore())
-        return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (extraData.charAt(mapping-1)&0xff00)==0;
-    }
-    public boolean isDecompInert(int c) { return isDecompYesAndZeroCC(getNorm16(c)); }
-
-    public boolean hasCompBoundaryBefore(int c) {
-        return c<minCompNoMaybeCP || norm16HasCompBoundaryBefore(getNorm16(c));
-    }
-    public boolean hasCompBoundaryAfter(int c, boolean onlyContiguous) {
-        return norm16HasCompBoundaryAfter(getNorm16(c), onlyContiguous);
-    }
-
-    private boolean isMaybe(int norm16) { return minMaybeYes<=norm16 && norm16<=JAMO_VT; }
-    private boolean isMaybeOrNonZeroCC(int norm16) { return norm16>=minMaybeYes; }
-    private static boolean isInert(int norm16) { return norm16==INERT; }
-    private static boolean isJamoVT(int norm16) { return norm16==JAMO_VT; }
-    private int hangulLVT() { return minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER; }
-    private boolean isHangulLV(int norm16) { return norm16==minYesNo; }
-    private boolean isHangulLVT(int norm16) {
-        return norm16==hangulLVT();
-    }
-    private boolean isCompYesAndZeroCC(int norm16) { return norm16<minNoNo; }
-    // UBool isCompYes(uint16_t norm16) const {
-    //     return norm16>=MIN_YES_YES_WITH_CC || norm16<minNoNo;
-    // }
-    // UBool isCompYesOrMaybe(uint16_t norm16) const {
-    //     return norm16<minNoNo || minMaybeYes<=norm16;
-    // }
-    // private boolean hasZeroCCFromDecompYes(int norm16) {
-    //     return norm16<=MIN_NORMAL_MAYBE_YES || norm16==JAMO_VT;
-    // }
-    private boolean isDecompYesAndZeroCC(int norm16) {
-        return norm16<minYesNo ||
-               norm16==JAMO_VT ||
-               (minMaybeYes<=norm16 && norm16<=MIN_NORMAL_MAYBE_YES);
-    }
-    /**
-     * A little faster and simpler than isDecompYesAndZeroCC() but does not include
-     * the MaybeYes which combine-forward and have ccc=0.
-     * (Standard Unicode 10 normalization does not have such characters.)
-     */
-    private boolean isMostDecompYesAndZeroCC(int norm16) {
-        return norm16<minYesNo || norm16==MIN_NORMAL_MAYBE_YES || norm16==JAMO_VT;
-    }
-    private boolean isDecompNoAlgorithmic(int norm16) { return norm16>=limitNoNo; }
-
-    // For use with isCompYes().
-    // Perhaps the compiler can combine the two tests for MIN_YES_YES_WITH_CC.
-    // static uint8_t getCCFromYes(uint16_t norm16) {
-    //     return norm16>=MIN_YES_YES_WITH_CC ? getCCFromNormalYesOrMaybe(norm16) : 0;
-    // }
-    private int getCCFromNoNo(int norm16) {
-        int mapping=norm16>>OFFSET_SHIFT;
-        if((extraData.charAt(mapping)&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
-            return extraData.charAt(mapping-1)&0xff;
-        } else {
-            return 0;
-        }
-    }
-    int getTrailCCFromCompYesAndZeroCC(int norm16) {
-        if(norm16<=minYesNo) {
-            return 0;  // yesYes and Hangul LV have ccc=tccc=0
-        } else {
-            // For Hangul LVT we harmlessly fetch a firstUnit with tccc=0 here.
-            return extraData.charAt(norm16>>OFFSET_SHIFT)>>8;  // tccc from yesNo
-        }
-    }
-
-    // Requires algorithmic-NoNo.
-    private int mapAlgorithmic(int c, int norm16) {
-        return c+(norm16>>DELTA_SHIFT)-centerNoNoDelta;
-    }
-
-    // Requires minYesNo<norm16<limitNoNo.
-    // private int getMapping(int norm16) { return extraData+(norm16>>OFFSET_SHIFT); }
-
-    /**
-     * @return index into maybeYesCompositions, or -1
-     */
-    private int getCompositionsListForDecompYes(int norm16) {
-        if(norm16<JAMO_L || MIN_NORMAL_MAYBE_YES<=norm16) {
-            return -1;
-        } else {
-            if((norm16-=minMaybeYes)<0) {
-                // norm16<minMaybeYes: index into extraData which is a substring at
-                //     maybeYesCompositions[MIN_NORMAL_MAYBE_YES-minMaybeYes]
-                // same as (MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16
-                norm16+=MIN_NORMAL_MAYBE_YES;  // for yesYes; if Jamo L: harmless empty list
-            }
-            return norm16>>OFFSET_SHIFT;
-        }
-    }
-    /**
-     * @return index into maybeYesCompositions
-     */
-    private int getCompositionsListForComposite(int norm16) {
-        // A composite has both mapping & compositions list.
-        int list=((MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16)>>OFFSET_SHIFT;
-        int firstUnit=maybeYesCompositions.charAt(list);
-        return list+  // mapping in maybeYesCompositions
-            1+  // +1 to skip the first unit with the mapping length
-            (firstUnit&MAPPING_LENGTH_MASK);  // + mapping length
-    }
-
-    // Decompose a short piece of text which is likely to contain characters that
-    // fail the quick check loop and/or where the quick check loop's overhead
-    // is unlikely to be amortized.
-    // Called by the compose() and makeFCD() implementations.
-    // Public in Java for collation implementation code.
-    private int decomposeShort(
-            CharSequence s, int src, int limit,
-            boolean stopAtCompBoundary, boolean onlyContiguous,
-            ReorderingBuffer buffer) {
-        while(src<limit) {
-            int c=Character.codePointAt(s, src);
-            if (stopAtCompBoundary && c < minCompNoMaybeCP) {
-                return src;
-            }
-            int norm16 = getNorm16(c);
-            if (stopAtCompBoundary && norm16HasCompBoundaryBefore(norm16)) {
-                return src;
-            }
-            src+=Character.charCount(c);
-            decompose(c, norm16, buffer);
-            if (stopAtCompBoundary && norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
-                return src;
-            }
-        }
-        return src;
-    }
-    private void decompose(int c, int norm16, ReorderingBuffer buffer) {
-        // get the decomposition and the lead and trail cc's
-        if (norm16 >= limitNoNo) {
-            if (isMaybeOrNonZeroCC(norm16)) {
-                buffer.append(c, getCCFromYesOrMaybe(norm16));
-                return;
-            }
-            // Maps to an isCompYesAndZeroCC.
-            c=mapAlgorithmic(c, norm16);
-            norm16=getRawNorm16(c);
-        }
-        if (norm16 < minYesNo) {
-            // c does not decompose
-            buffer.append(c, 0);
-        } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
-            // Hangul syllable: decompose algorithmically
-            Hangul.decompose(c, buffer);
-        } else {
-            // c decomposes, get everything from the variable-length extra data
-            int mapping=norm16>>OFFSET_SHIFT;
-            int firstUnit=extraData.charAt(mapping);
-            int length=firstUnit&MAPPING_LENGTH_MASK;
-            int leadCC, trailCC;
-            trailCC=firstUnit>>8;
-            if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
-                leadCC=extraData.charAt(mapping-1)>>8;
-            } else {
-                leadCC=0;
-            }
-            ++mapping;  // skip over the firstUnit
-            buffer.append(extraData, mapping, mapping+length, true, leadCC, trailCC);
-        }
-    }
-
-    /**
-     * Finds the recomposition result for
-     * a forward-combining "lead" character,
-     * specified with a pointer to its compositions list,
-     * and a backward-combining "trail" character.
-     *
-     * <p>If the lead and trail characters combine, then this function returns
-     * the following "compositeAndFwd" value:
-     * <pre>
-     * Bits 21..1  composite character
-     * Bit      0  set if the composite is a forward-combining starter
-     * </pre>
-     * otherwise it returns -1.
-     *
-     * <p>The compositions list has (trail, compositeAndFwd) pair entries,
-     * encoded as either pairs or triples of 16-bit units.
-     * The last entry has the high bit of its first unit set.
-     *
-     * <p>The list is sorted by ascending trail characters (there are no duplicates).
-     * A linear search is used.
-     *
-     * <p>See normalizer2impl.h for a more detailed description
-     * of the compositions list format.
-     */
-    private static int combine(String compositions, int list, int trail) {
-        int key1, firstUnit;
-        if(trail<COMP_1_TRAIL_LIMIT) {
-            // trail character is 0..33FF
-            // result entry may have 2 or 3 units
-            key1=(trail<<1);
-            while(key1>(firstUnit=compositions.charAt(list))) {
-                list+=2+(firstUnit&COMP_1_TRIPLE);
-            }
-            if(key1==(firstUnit&COMP_1_TRAIL_MASK)) {
-                if((firstUnit&COMP_1_TRIPLE)!=0) {
-                    return (compositions.charAt(list+1)<<16)|compositions.charAt(list+2);
-                } else {
-                    return compositions.charAt(list+1);
-                }
-            }
-        } else {
-            // trail character is 3400..10FFFF
-            // result entry has 3 units
-            key1=COMP_1_TRAIL_LIMIT+(((trail>>COMP_1_TRAIL_SHIFT))&~COMP_1_TRIPLE);
-            int key2=(trail<<COMP_2_TRAIL_SHIFT)&0xffff;
-            int secondUnit;
-            for(;;) {
-                if(key1>(firstUnit=compositions.charAt(list))) {
-                    list+=2+(firstUnit&COMP_1_TRIPLE);
-                } else if(key1==(firstUnit&COMP_1_TRAIL_MASK)) {
-                    if(key2>(secondUnit=compositions.charAt(list+1))) {
-                        if((firstUnit&COMP_1_LAST_TUPLE)!=0) {
-                            break;
-                        } else {
-                            list+=3;
-                        }
-                    } else if(key2==(secondUnit&COMP_2_TRAIL_MASK)) {
-                        return ((secondUnit&~COMP_2_TRAIL_MASK)<<16)|compositions.charAt(list+2);
-                    } else {
-                        break;
-                    }
-                } else {
-                    break;
-                }
-            }
-        }
-        return -1;
-    }
-
-    /*
-     * Recomposes the buffer text starting at recomposeStartIndex
-     * (which is in NFD - decomposed and canonically ordered),
-     * and truncates the buffer contents.
-     *
-     * Note that recomposition never lengthens the text:
-     * Any character consists of either one or two code units;
-     * a composition may contain at most one more code unit than the original starter,
-     * while the combining mark that is removed has at least one code unit.
-     */
-    private void recompose(ReorderingBuffer buffer, int recomposeStartIndex,
-                           boolean onlyContiguous) {
-        StringBuilder sb=buffer.getStringBuilder();
-        int p=recomposeStartIndex;
-        if(p==sb.length()) {
-            return;
-        }
-
-        int starter, pRemove;
-        int compositionsList;
-        int c, compositeAndFwd;
-        int norm16;
-        int cc, prevCC;
-        boolean starterIsSupplementary;
-
-        // Some of the following variables are not used until we have a forward-combining starter
-        // and are only initialized now to avoid compiler warnings.
-        compositionsList=-1;  // used as indicator for whether we have a forward-combining starter
-        starter=-1;
-        starterIsSupplementary=false;
-        prevCC=0;
-
-        for(;;) {
-            c=sb.codePointAt(p);
-            p+=Character.charCount(c);
-            norm16=getNorm16(c);
-            cc=getCCFromYesOrMaybe(norm16);
-            if( // this character combines backward and
-                isMaybe(norm16) &&
-                // we have seen a starter that combines forward and
-                compositionsList>=0 &&
-                // the backward-combining character is not blocked
-                (prevCC<cc || prevCC==0)
-            ) {
-                if(isJamoVT(norm16)) {
-                    // c is a Jamo V/T, see if we can compose it with the previous character.
-                    if(c<Hangul.JAMO_T_BASE) {
-                        // c is a Jamo Vowel, compose with previous Jamo L and following Jamo T.
-                        char prev=(char)(sb.charAt(starter)-Hangul.JAMO_L_BASE);
-                        if(prev<Hangul.JAMO_L_COUNT) {
-                            pRemove=p-1;
-                            char syllable=(char)
-                                (Hangul.HANGUL_BASE+
-                                 (prev*Hangul.JAMO_V_COUNT+(c-Hangul.JAMO_V_BASE))*
-                                 Hangul.JAMO_T_COUNT);
-                            char t;
-                            if(p!=sb.length() && (t=(char)(sb.charAt(p)-Hangul.JAMO_T_BASE))<Hangul.JAMO_T_COUNT) {
-                                ++p;
-                                syllable+=t;  // The next character was a Jamo T.
-                            }
-                            sb.setCharAt(starter, syllable);
-                            // remove the Jamo V/T
-                            sb.delete(pRemove, p);
-                            p=pRemove;
-                        }
-                    }
-                    /*
-                     * No "else" for Jamo T:
-                     * Since the input is in NFD, there are no Hangul LV syllables that
-                     * a Jamo T could combine with.
-                     * All Jamo Ts are combined above when handling Jamo Vs.
-                     */
-                    if(p==sb.length()) {
-                        break;
-                    }
-                    compositionsList=-1;
-                    continue;
-                } else if((compositeAndFwd=combine(maybeYesCompositions, compositionsList, c))>=0) {
-                    // The starter and the combining mark (c) do combine.
-                    int composite=compositeAndFwd>>1;
-
-                    // Remove the combining mark.
-                    pRemove=p-Character.charCount(c);  // pRemove & p: start & limit of the combining mark
-                    sb.delete(pRemove, p);
-                    p=pRemove;
-                    // Replace the starter with the composite.
-                    if(starterIsSupplementary) {
-                        if(composite>0xffff) {
-                            // both are supplementary
-                            sb.setCharAt(starter, UTF16.getLeadSurrogate(composite));
-                            sb.setCharAt(starter+1, UTF16.getTrailSurrogate(composite));
-                        } else {
-                            sb.setCharAt(starter, (char)c);
-                            sb.deleteCharAt(starter+1);
-                            // The composite is shorter than the starter,
-                            // move the intermediate characters forward one.
-                            starterIsSupplementary=false;
-                            --p;
-                        }
-                    } else if(composite>0xffff) {
-                        // The composite is longer than the starter,
-                        // move the intermediate characters back one.
-                        starterIsSupplementary=true;
-                        sb.setCharAt(starter, UTF16.getLeadSurrogate(composite));
-                        sb.insert(starter+1, UTF16.getTrailSurrogate(composite));
-                        ++p;
-                    } else {
-                        // both are on the BMP
-                        sb.setCharAt(starter, (char)composite);
-                    }
-
-                    // Keep prevCC because we removed the combining mark.
-
-                    if(p==sb.length()) {
-                        break;
-                    }
-                    // Is the composite a starter that combines forward?
-                    if((compositeAndFwd&1)!=0) {
-                        compositionsList=
-                            getCompositionsListForComposite(getRawNorm16(composite));
-                    } else {
-                        compositionsList=-1;
-                    }
-
-                    // We combined; continue with looking for compositions.
-                    continue;
-                }
-            }
-
-            // no combination this time
-            prevCC=cc;
-            if(p==sb.length()) {
-                break;
-            }
-
-            // If c did not combine, then check if it is a starter.
-            if(cc==0) {
-                // Found a new starter.
-                if((compositionsList=getCompositionsListForDecompYes(norm16))>=0) {
-                    // It may combine with something, prepare for it.
-                    if(c<=0xffff) {
-                        starterIsSupplementary=false;
-                        starter=p-1;
-                    } else {
-                        starterIsSupplementary=true;
-                        starter=p-2;
-                    }
-                }
-            } else if(onlyContiguous) {
-                // FCC: no discontiguous compositions; any intervening character blocks.
-                compositionsList=-1;
-            }
-        }
-        buffer.flush();
-    }
-
-    /**
-     * Does c have a composition boundary before it?
-     * True if its decomposition begins with a character that has
-     * ccc=0 && NFC_QC=Yes (isCompYesAndZeroCC()).
-     * As a shortcut, this is true if c itself has ccc=0 && NFC_QC=Yes
-     * (isCompYesAndZeroCC()) so we need not decompose.
-     */
-    private boolean hasCompBoundaryBefore(int c, int norm16) {
-        return c<minCompNoMaybeCP || norm16HasCompBoundaryBefore(norm16);
-    }
-    private boolean norm16HasCompBoundaryBefore(int norm16) {
-        return norm16 < minNoNoCompNoMaybeCC || isAlgorithmicNoNo(norm16);
-    }
-    private boolean hasCompBoundaryBefore(CharSequence s, int src, int limit) {
-        return src == limit || hasCompBoundaryBefore(Character.codePointAt(s, src));
-    }
-    private boolean norm16HasCompBoundaryAfter(int norm16, boolean onlyContiguous) {
-        return (norm16 & HAS_COMP_BOUNDARY_AFTER) != 0 &&
-            (!onlyContiguous || isTrailCC01ForCompBoundaryAfter(norm16));
-    }
-    private boolean hasCompBoundaryAfter(CharSequence s, int start, int p, boolean onlyContiguous) {
-        return start == p || hasCompBoundaryAfter(Character.codePointBefore(s, p), onlyContiguous);
-    }
-    /** For FCC: Given norm16 HAS_COMP_BOUNDARY_AFTER, does it have tccc<=1? */
-    private boolean isTrailCC01ForCompBoundaryAfter(int norm16) {
-        return isInert(norm16) || (isDecompNoAlgorithmic(norm16) ?
-            (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1 : extraData.charAt(norm16 >> OFFSET_SHIFT) <= 0x1ff);
-    }
-
-    private int findPreviousCompBoundary(CharSequence s, int p, boolean onlyContiguous) {
-        while(p>0) {
-            int c=Character.codePointBefore(s, p);
-            int norm16 = getNorm16(c);
-            if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
-                break;
-            }
-            p-=Character.charCount(c);
-            if(hasCompBoundaryBefore(c, norm16)) {
-                break;
-            }
-        }
-        return p;
-    }
-    private int findNextCompBoundary(CharSequence s, int p, int limit, boolean onlyContiguous) {
-        while(p<limit) {
-            int c=Character.codePointAt(s, p);
-            int norm16=normTrie.get(c);
-            if(hasCompBoundaryBefore(c, norm16)) {
-                break;
-            }
-            p+=Character.charCount(c);
-            if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
-                break;
-            }
-        }
-        return p;
-    }
-
-
-    private int findNextFCDBoundary(CharSequence s, int p, int limit) {
-        while(p<limit) {
-            int c=Character.codePointAt(s, p);
-            int norm16;
-            if (c < minLcccCP || norm16HasDecompBoundaryBefore(norm16 = getNorm16(c))) {
-                break;
-            }
-            p+=Character.charCount(c);
-            if (norm16HasDecompBoundaryAfter(norm16)) {
-                break;
-            }
-        }
-        return p;
-    }
-
-    /**
-     * Get the canonical decomposition
-     * sherman  for ComposedCharIter
-     */
-    public static int getDecompose(int chars[], String decomps[]) {
-        Normalizer2 impl = Normalizer2.getNFDInstance();
-
-        int length=0;
-        int norm16 = 0;
-        int ch = -1;
-        int i = 0;
-
-        while (++ch < 0x2fa1e) {   //no cannoical above 0x3ffff
-            //TBD !!!! the hack code heres save us about 50ms for startup
-            //need a better solution/lookup
-            if (ch == 0x30ff)
-                ch = 0xf900;
-            else if (ch == 0x115bc)
-                ch = 0x1d15e;
-            else if (ch == 0x1d1c1)
-                ch = 0x2f800;
-
-            String s = impl.getDecomposition(ch);
-
-            if(s != null && i < chars.length) {
-                chars[i] = ch;
-                decomps[i++] = s;
-            }
-        }
-        return i;
-    }
-
-    //------------------------------------------------------
-    // special method for Collation (RBTableBuilder.build())
-    //------------------------------------------------------
-    private static boolean needSingleQuotation(char c) {
-        return (c >= 0x0009 && c <= 0x000D) ||
-               (c >= 0x0020 && c <= 0x002F) ||
-               (c >= 0x003A && c <= 0x0040) ||
-               (c >= 0x005B && c <= 0x0060) ||
-               (c >= 0x007B && c <= 0x007E);
-    }
-
-    public static String canonicalDecomposeWithSingleQuotation(String string) {
-       Normalizer2 impl = Normalizer2.getNFDInstance();
-       char[] src = string.toCharArray();
-       int    srcIndex = 0;
-       int    srcLimit = src.length;
-       char[] dest = new char[src.length * 3];  //MAX_BUF_SIZE_DECOMPOSE = 3
-       int    destIndex = 0;
-       int    destLimit = dest.length;
-
-        int prevSrc;
-        String norm;
-        int reorderStartIndex, length;
-        char c1, c2;
-        int cp;
-        int minNoMaybe = 0x00c0;
-        int cc, prevCC, trailCC;
-        char[] p;
-        int pStart;
-
-        // initialize
-        reorderStartIndex = 0;
-        prevCC = 0;
-        norm = null;
-        cp = 0;
-        pStart = 0;
-
-        cc = trailCC = -1; // initialize to bogus value
-        c1 = 0;
-        for (;;) {
-            prevSrc=srcIndex;
-            //quick check (1)less than minNoMaybe (2)no decomp (3)hangual
-            while (srcIndex != srcLimit &&
-                   ((c1 = src[srcIndex]) < minNoMaybe ||
-                    (norm = impl.getDecomposition(cp = string.codePointAt(srcIndex))) == null ||
-                    (c1 >= '\uac00' && c1 <= '\ud7a3'))) { // Hangul Syllables
-                prevCC = 0;
-                srcIndex += (cp < 0x10000) ? 1 : 2;
-            }
-
-            // copy these code units all at once
-            if (srcIndex != prevSrc) {
-                length = srcIndex - prevSrc;
-                if ((destIndex + length) <= destLimit) {
-                    System.arraycopy(src,prevSrc,dest,destIndex,length);
-                }
-
-                destIndex += length;
-                reorderStartIndex = destIndex;
-            }
-
-            // end of source reached?
-            if (srcIndex == srcLimit) {
-                break;
-            }
-
-            // cp already contains *src and norm32 is set for it, increment src
-            srcIndex += (cp < 0x10000) ? 1 : 2;
-
-            if (cp < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
-                c2 = 0;
-                length = 1;
-
-                if (Character.isHighSurrogate(c1)
-                    || Character.isLowSurrogate(c1)) {
-                    norm = null;
-                }
-            } else {
-                length = 2;
-                c2 = src[srcIndex-1];
-            }
-
-          // get the decomposition and the lead and trail cc's
-          if (norm == null) {
-              // cp does not decompose
-              cc = trailCC = UCharacter.getCombiningClass(cp);
-              p = null;
-              pStart = -1;
-          } else {
-
-                pStart = 0;
-                p = norm.toCharArray();
-                length = p.length;
-                int cpNum = norm.codePointCount(0, length);
-                cc= UCharacter.getCombiningClass(norm.codePointAt(0));
-                trailCC= UCharacter.getCombiningClass(norm.codePointAt(cpNum-1));
-                if (length == 1) {
-                    // fastpath a single code unit from decomposition
-                    c1 = p[pStart];
-                    c2 = 0;
-                    p = null;
-                    pStart = -1;
-                }
-            }
-
-            if((destIndex + length * 3) >= destLimit) {  // 2 SingleQuotations
-                // buffer overflow
-                char[] tmpBuf = new char[destLimit * 2];
-                System.arraycopy(dest, 0, tmpBuf, 0, destIndex);
-                dest = tmpBuf;
-                destLimit = dest.length;
-            }
-
-            // append the decomposition to the destination buffer, assume length>0
-            {
-                int reorderSplit = destIndex;
-                if (p == null) {
-                    // fastpath: single code point
-                    if (needSingleQuotation(c1)) {
-                        //if we need single quotation, no need to consider "prevCC"
-                        //and it must NOT be a supplementary pair
-                        dest[destIndex++] = '\'';
-                        dest[destIndex++] = c1;
-                        dest[destIndex++] = '\'';
-                        trailCC = 0;
-                    } else if(cc != 0 && cc < prevCC) {
-                        // (c1, c2) is out of order with respect to the preceding
-                        //  text
-                        destIndex += length;
-                        trailCC = insertOrdered(dest, reorderStartIndex,
-                                                reorderSplit, destIndex, c1, c2, cc);
-                    } else {
-                        // just append (c1, c2)
-                        dest[destIndex++] = c1;
-                        if(c2 != 0) {
-                            dest[destIndex++] = c2;
-                        }
-                    }
-                } else {
-                    // general: multiple code points (ordered by themselves)
-                    // from decomposition
-                    if (needSingleQuotation(p[pStart])) {
-                        dest[destIndex++] = '\'';
-                        dest[destIndex++] = p[pStart++];
-                        dest[destIndex++] = '\'';
-                        length--;
-                        do {
-                            dest[destIndex++] = p[pStart++];
-                        } while(--length > 0);
-                    } else if (cc != 0 && cc < prevCC) {
-                        destIndex += length;
-                        trailCC = mergeOrdered(dest, reorderStartIndex,
-                                               reorderSplit, p, pStart,
-                                               pStart+length);
-                    } else {
-                        // just append the decomposition
-                        do {
-                            dest[destIndex++] = p[pStart++];
-                        } while (--length > 0);
-                    }
-                }
-            }
-            prevCC = trailCC;
-            if(prevCC == 0) {
-                reorderStartIndex = destIndex;
-            }
-        }
-
-        return new String(dest, 0, destIndex);
-    }
-
-    /**
-     * simpler, single-character version of mergeOrdered() -
-     * bubble-insert one single code point into the preceding string
-     * which is already canonically ordered
-     * (c, c2) may or may not yet have been inserted at src[current]..src[p]
-     *
-     * it must be p=current+lengthof(c, c2) i.e. p=current+(c2==0 ? 1 : 2)
-     *
-     * before: src[start]..src[current] is already ordered, and
-     *         src[current]..src[p]     may or may not hold (c, c2) but
-     *                          must be exactly the same length as (c, c2)
-     * after: src[start]..src[p] is ordered
-     *
-     * @return the trailing combining class
-     */
-    private static int/*unsigned byte*/ insertOrdered(char[] source,
-                                                      int start,
-                                                      int current, int p,
-                                                      char c1, char c2,
-                                                      int/*unsigned byte*/ cc) {
-        int back, preBack;
-        int r;
-        int prevCC, trailCC=cc;
-
-        if (start<current && cc!=0) {
-            // search for the insertion point where cc>=prevCC
-            preBack=back=current;
-
-            PrevArgs prevArgs = new PrevArgs();
-            prevArgs.current  = current;
-            prevArgs.start    = start;
-            prevArgs.src      = source;
-            prevArgs.c1       = c1;
-            prevArgs.c2       = c2;
-
-            // get the prevCC
-            prevCC=getPrevCC(prevArgs);
-            preBack = prevArgs.current;
-
-            if(cc<prevCC) {
-                // this will be the last code point, so keep its cc
-                trailCC=prevCC;
-                back=preBack;
-                while(start<preBack) {
-                    prevCC=getPrevCC(prevArgs);
-                    preBack=prevArgs.current;
-                    if(cc>=prevCC) {
-                        break;
-                    }
-                    back=preBack;
-                }
-
-                // this is where we are right now with all these indicies:
-                // [start]..[pPreBack] 0..? code points that we can ignore
-                // [pPreBack]..[pBack] 0..1 code points with prevCC<=cc
-                // [pBack]..[current] 0..n code points with >cc, move up to insert (c, c2)
-                // [current]..[p]         1 code point (c, c2) with cc
-
-                // move the code units in between up
-                r=p;
-                do {
-                    source[--r]=source[--current];
-                } while (back!=current);
-            }
-        }
-
-        // insert (c1, c2)
-        source[current] = c1;
-        if (c2!=0) {
-            source[(current+1)] = c2;
-        }
-
-        // we know the cc of the last code point
-        return trailCC;
-    }
-    /**
-     * merge two UTF-16 string parts together
-     * to canonically order (order by combining classes) their concatenation
-     *
-     * the two strings may already be adjacent, so that the merging is done
-     * in-place if the two strings are not adjacent, then the buffer holding the
-     * first one must be large enough
-     * the second string may or may not be ordered in itself
-     *
-     * before: [start]..[current] is already ordered, and
-     *         [next]..[limit]    may be ordered in itself, but
-     *                          is not in relation to [start..current[
-     * after: [start..current+(limit-next)[ is ordered
-     *
-     * the algorithm is a simple bubble-sort that takes the characters from
-     * src[next++] and inserts them in correct combining class order into the
-     * preceding part of the string
-     *
-     * since this function is called much less often than the single-code point
-     * insertOrdered(), it just uses that for easier maintenance
-     *
-     * @return the trailing combining class
-     */
-    private static int /*unsigned byte*/ mergeOrdered(char[] source,
-                                                      int start,
-                                                      int current,
-                                                      char[] data,
-                                                        int next,
-                                                        int limit) {
-            int r;
-            int /*unsigned byte*/ cc, trailCC=0;
-            boolean adjacent;
-
-            adjacent= current==next;
-            NextCCArgs ncArgs = new NextCCArgs();
-            ncArgs.source = data;
-            ncArgs.next   = next;
-            ncArgs.limit  = limit;
-
-            if(start!=current) {
-
-                while(ncArgs.next<ncArgs.limit) {
-                    cc=getNextCC(ncArgs);
-                    if(cc==0) {
-                        // does not bubble back
-                        trailCC=0;
-                        if(adjacent) {
-                            current=ncArgs.next;
-                        } else {
-                            data[current++]=ncArgs.c1;
-                            if(ncArgs.c2!=0) {
-                                data[current++]=ncArgs.c2;
-                            }
-                        }
-                        break;
-                    } else {
-                        r=current+(ncArgs.c2==0 ? 1 : 2);
-                        trailCC=insertOrdered(source,start, current, r,
-                                              ncArgs.c1, ncArgs.c2, cc);
-                        current=r;
-                    }
-                }
-            }
-
-            if(ncArgs.next==ncArgs.limit) {
-                // we know the cc of the last code point
-                return trailCC;
-            } else {
-                if(!adjacent) {
-                    // copy the second string part
-                    do {
-                        source[current++]=data[ncArgs.next++];
-                    } while(ncArgs.next!=ncArgs.limit);
-                    ncArgs.limit=current;
-                }
-                PrevArgs prevArgs = new PrevArgs();
-                prevArgs.src   = data;
-                prevArgs.start = start;
-                prevArgs.current =  ncArgs.limit;
-                return getPrevCC(prevArgs);
-            }
-
-    }
-    private static final class PrevArgs{
-        char[] src;
-        int start;
-        int current;
-        char c1;
-        char c2;
-    }
-
-    private static final class NextCCArgs{
-        char[] source;
-        int next;
-        int limit;
-        char c1;
-        char c2;
-    }
-    private static int /*unsigned byte*/ getNextCC(NextCCArgs args) {
-        args.c1=args.source[args.next++];
-        args.c2=0;
-
-        if (UTF16.isTrailSurrogate(args.c1)) {
-            /* unpaired second surrogate */
-            return 0;
-        } else if (!UTF16.isLeadSurrogate(args.c1)) {
-            return UCharacter.getCombiningClass(args.c1);
-        } else if (args.next!=args.limit &&
-                        UTF16.isTrailSurrogate(args.c2=args.source[args.next])){
-            ++args.next;
-            return UCharacter.getCombiningClass(Character.toCodePoint(args.c1, args.c2));
-        } else {
-            /* unpaired first surrogate */
-            args.c2=0;
-            return 0;
-        }
-    }
-    private static int /*unsigned*/ getPrevCC(PrevArgs args) {
-        args.c1=args.src[--args.current];
-        args.c2=0;
-
-        if (args.c1 < MIN_CCC_LCCC_CP) {
-            return 0;
-        } else if (UTF16.isLeadSurrogate(args.c1)) {
-            /* unpaired first surrogate */
-            return 0;
-        } else if (!UTF16.isTrailSurrogate(args.c1)) {
-            return UCharacter.getCombiningClass(args.c1);
-        } else if (args.current!=args.start &&
-                    UTF16.isLeadSurrogate(args.c2=args.src[args.current-1])) {
-            --args.current;
-            return UCharacter.getCombiningClass(Character.toCodePoint(args.c2, args.c1));
-        } else {
-            /* unpaired second surrogate */
-            args.c2=0;
-            return 0;
-        }
-    }
-
-    private int getPreviousTrailCC(CharSequence s, int start, int p) {
-        if (start == p) {
-            return 0;
-        }
-        return getFCD16(Character.codePointBefore(s, p));
-    }
-
-    private VersionInfo dataVersion;
-
-    // BMP code point thresholds for quick check loops looking at single UTF-16 code units.
-    private int minDecompNoCP;
-    private int minCompNoMaybeCP;
-    private int minLcccCP;
-
-    // Norm16 value thresholds for quick check combinations and types of extra data.
-    private int minYesNo;
-    private int minYesNoMappingsOnly;
-    private int minNoNo;
-    private int minNoNoCompBoundaryBefore;
-    private int minNoNoCompNoMaybeCC;
-    private int minNoNoEmpty;
-    private int limitNoNo;
-    private int centerNoNoDelta;
-    private int minMaybeYes;
-
-    private CodePointTrie.Fast16 normTrie;
-    private String maybeYesCompositions;
-    private String extraData;  // mappings and/or compositions for yesYes, yesNo & noNo characters
-    private byte[] smallFCD;  // [0x100] one bit per 32 BMP code points, set if any FCD!=0
-}
--- /dev/null	2020-01-10 15:57:31.000000000 -0800
+++ new/src/java.base/share/classes/jdk/internal/icu/impl/NormalizerImpl.java	2020-01-10 15:57:30.000000000 -0800
@@ -0,0 +1,2193 @@
+/*
+ * Copyright (c) 2009, 2020, 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.
+ */
+
+/*
+ *******************************************************************************
+ *   Copyright (C) 2009-2014, International Business Machines
+ *   Corporation and others.  All Rights Reserved.
+ *******************************************************************************
+ */
+package jdk.internal.icu.impl;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import jdk.internal.icu.lang.UCharacter;
+import jdk.internal.icu.text.Normalizer2;
+import jdk.internal.icu.text.UTF16;
+import jdk.internal.icu.util.CodePointTrie;
+import jdk.internal.icu.util.VersionInfo;
+
+// Original filename in ICU4J: Normalizer2Impl.java
+public final class NormalizerImpl {
+    public static final class Hangul {
+        /* Korean Hangul and Jamo constants */
+        public static final int JAMO_L_BASE=0x1100;     /* "lead" jamo */
+        public static final int JAMO_V_BASE=0x1161;     /* "vowel" jamo */
+        public static final int JAMO_T_BASE=0x11a7;     /* "trail" jamo */
+
+        public static final int HANGUL_BASE=0xac00;
+        public static final int HANGUL_END=0xd7a3;
+
+        public static final int JAMO_L_COUNT=19;
+        public static final int JAMO_V_COUNT=21;
+        public static final int JAMO_T_COUNT=28;
+
+        public static final int HANGUL_COUNT=JAMO_L_COUNT*JAMO_V_COUNT*JAMO_T_COUNT;
+        public static final int HANGUL_LIMIT=HANGUL_BASE+HANGUL_COUNT;
+
+        public static boolean isHangul(int c) {
+            return HANGUL_BASE<=c && c<HANGUL_LIMIT;
+        }
+        public static boolean isHangulLV(int c) {
+            c-=HANGUL_BASE;
+            return 0<=c && c<HANGUL_COUNT && c%JAMO_T_COUNT==0;
+        }
+
+        /**
+         * Decomposes c, which must be a Hangul syllable, into buffer
+         * and returns the length of the decomposition (2 or 3).
+         */
+        public static int decompose(int c, Appendable buffer) {
+            try {
+                c-=HANGUL_BASE;
+                int c2=c%JAMO_T_COUNT;
+                c/=JAMO_T_COUNT;
+                buffer.append((char)(JAMO_L_BASE+c/JAMO_V_COUNT));
+                buffer.append((char)(JAMO_V_BASE+c%JAMO_V_COUNT));
+                if(c2==0) {
+                    return 2;
+                } else {
+                    buffer.append((char)(JAMO_T_BASE+c2));
+                    return 3;
+                }
+            } catch(IOException e) {
+                throw new InternalError(e);
+            }
+        }
+    }
+
+    /**
+     * Writable buffer that takes care of canonical ordering.
+     * Its Appendable methods behave like the C++ implementation's
+     * appendZeroCC() methods.
+     * <p>
+     * If dest is a StringBuilder, then the buffer writes directly to it.
+     * Otherwise, the buffer maintains a StringBuilder for intermediate text segments
+     * until no further changes are necessary and whole segments are appended.
+     * append() methods that take combining-class values always write to the StringBuilder.
+     * Other append() methods flush and append to the Appendable.
+     */
+    public static final class ReorderingBuffer implements Appendable {
+        public ReorderingBuffer(NormalizerImpl ni, Appendable dest, int destCapacity) {
+            impl=ni;
+            app=dest;
+            if (app instanceof StringBuilder) {
+                appIsStringBuilder=true;
+                str=(StringBuilder)dest;
+                // In Java, the constructor subsumes public void init(int destCapacity)
+                str.ensureCapacity(destCapacity);
+                reorderStart=0;
+                if(str.length()==0) {
+                    lastCC=0;
+                } else {
+                    setIterator();
+                    lastCC=previousCC();
+                    // Set reorderStart after the last code point with cc<=1 if there is one.
+                    if(lastCC>1) {
+                        while(previousCC()>1) {}
+                    }
+                    reorderStart=codePointLimit;
+                }
+            } else {
+                appIsStringBuilder=false;
+                str=new StringBuilder();
+                reorderStart=0;
+                lastCC=0;
+            }
+        }
+
+        public boolean isEmpty() { return str.length()==0; }
+        public int length() { return str.length(); }
+        public int getLastCC() { return lastCC; }
+
+        public StringBuilder getStringBuilder() { return str; }
+
+        public boolean equals(CharSequence s, int start, int limit) {
+            return UTF16Plus.equal(str, 0, str.length(), s, start, limit);
+        }
+
+        public void append(int c, int cc) {
+            if(lastCC<=cc || cc==0) {
+                str.appendCodePoint(c);
+                lastCC=cc;
+                if(cc<=1) {
+                    reorderStart=str.length();
+                }
+            } else {
+                insert(c, cc);
+            }
+        }
+        public void append(CharSequence s, int start, int limit, boolean isNFD,
+                           int leadCC, int trailCC) {
+            if(start==limit) {
+                return;
+            }
+            if(lastCC<=leadCC || leadCC==0) {
+                if(trailCC<=1) {
+                    reorderStart=str.length()+(limit-start);
+                } else if(leadCC<=1) {
+                    reorderStart=str.length()+1;  // Ok if not a code point boundary.
+                }
+                str.append(s, start, limit);
+                lastCC=trailCC;
+            } else {
+                int c=Character.codePointAt(s, start);
+                start+=Character.charCount(c);
+                insert(c, leadCC);  // insert first code point
+                while(start<limit) {
+                    c=Character.codePointAt(s, start);
+                    start+=Character.charCount(c);
+                    if(start<limit) {
+                        if (isNFD) {
+                            leadCC = getCCFromYesOrMaybe(impl.getNorm16(c));
+                        } else {
+                            leadCC = impl.getCC(impl.getNorm16(c));
+                        }
+                    } else {
+                        leadCC=trailCC;
+                    }
+                    append(c, leadCC);
+                }
+            }
+        }
+        // The following append() methods work like C++ appendZeroCC().
+        // They assume that the cc or trailCC of their input is 0.
+        // Most of them implement Appendable interface methods.
+        @Override
+        public ReorderingBuffer append(char c) {
+            str.append(c);
+            lastCC=0;
+            reorderStart=str.length();
+            return this;
+        }
+        public void appendZeroCC(int c) {
+            str.appendCodePoint(c);
+            lastCC=0;
+            reorderStart=str.length();
+        }
+        @Override
+        public ReorderingBuffer append(CharSequence s) {
+            if(s.length()!=0) {
+                str.append(s);
+                lastCC=0;
+                reorderStart=str.length();
+            }
+            return this;
+        }
+        @Override
+        public ReorderingBuffer append(CharSequence s, int start, int limit) {
+            if(start!=limit) {
+                str.append(s, start, limit);
+                lastCC=0;
+                reorderStart=str.length();
+            }
+            return this;
+        }
+        /**
+         * Flushes from the intermediate StringBuilder to the Appendable,
+         * if they are different objects.
+         * Used after recomposition.
+         * Must be called at the end when writing to a non-StringBuilder Appendable.
+         */
+        public void flush() {
+            if(appIsStringBuilder) {
+                reorderStart=str.length();
+            } else {
+                try {
+                    app.append(str);
+                    str.setLength(0);
+                    reorderStart=0;
+                } catch(IOException e) {
+                    throw new InternalError(e);  // Avoid declaring "throws IOException".
+                }
+            }
+            lastCC=0;
+        }
+        /**
+         * Flushes from the intermediate StringBuilder to the Appendable,
+         * if they are different objects.
+         * Then appends the new text to the Appendable or StringBuilder.
+         * Normally used after quick check loops find a non-empty sequence.
+         */
+        public ReorderingBuffer flushAndAppendZeroCC(CharSequence s, int start, int limit) {
+            if(appIsStringBuilder) {
+                str.append(s, start, limit);
+                reorderStart=str.length();
+            } else {
+                try {
+                    app.append(str).append(s, start, limit);
+                    str.setLength(0);
+                    reorderStart=0;
+                } catch(IOException e) {
+                    throw new InternalError(e);  // Avoid declaring "throws IOException".
+                }
+            }
+            lastCC=0;
+            return this;
+        }
+        public void remove() {
+            str.setLength(0);
+            lastCC=0;
+            reorderStart=0;
+        }
+        public void removeSuffix(int suffixLength) {
+            int oldLength=str.length();
+            str.delete(oldLength-suffixLength, oldLength);
+            lastCC=0;
+            reorderStart=str.length();
+        }
+
+        // Inserts c somewhere before the last character.
+        // Requires 0<cc<lastCC which implies reorderStart<limit.
+        private void insert(int c, int cc) {
+            for(setIterator(), skipPrevious(); previousCC()>cc;) {}
+            // insert c at codePointLimit, after the character with prevCC<=cc
+            if(c<=0xffff) {
+                str.insert(codePointLimit, (char)c);
+                if(cc<=1) {
+                    reorderStart=codePointLimit+1;
+                }
+            } else {
+                str.insert(codePointLimit, Character.toChars(c));
+                if(cc<=1) {
+                    reorderStart=codePointLimit+2;
+                }
+            }
+        }
+
+        private final NormalizerImpl impl;
+        private final Appendable app;
+        private final StringBuilder str;
+        private final boolean appIsStringBuilder;
+        private int reorderStart;
+        private int lastCC;
+
+        // private backward iterator
+        private void setIterator() { codePointStart=str.length(); }
+        private void skipPrevious() {  // Requires 0<codePointStart.
+            codePointLimit=codePointStart;
+            codePointStart=str.offsetByCodePoints(codePointStart, -1);
+        }
+        private int previousCC() {  // Returns 0 if there is no previous character.
+            codePointLimit=codePointStart;
+            if(reorderStart>=codePointStart) {
+                return 0;
+            }
+            int c=str.codePointBefore(codePointStart);
+            codePointStart-=Character.charCount(c);
+            return impl.getCCFromYesOrMaybeCP(c);
+        }
+        private int codePointStart, codePointLimit;
+    }
+
+    // TODO: Propose as public API on the UTF16 class.
+    // TODO: Propose widening UTF16 methods that take char to take int.
+    // TODO: Propose widening UTF16 methods that take String to take CharSequence.
+    public static final class UTF16Plus {
+        /**
+         * Is this code point a lead surrogate (U+d800..U+dbff)?
+         * @param c code unit or code point
+         * @return true or false
+         */
+        public static boolean isLeadSurrogate(int c) { return (c & 0xfffffc00) == 0xd800; }
+        /**
+         * Assuming c is a surrogate code point (UTF16.isSurrogate(c)),
+         * is it a lead surrogate?
+         * @param c code unit or code point
+         * @return true or false
+         */
+        public static boolean isSurrogateLead(int c) { return (c&0x400)==0; }
+
+        /**
+         * Compares two CharSequence subsequences for binary equality.
+         * @param s1 first sequence
+         * @param start1 start offset in first sequence
+         * @param limit1 limit offset in first sequence
+         * @param s2 second sequence
+         * @param start2 start offset in second sequence
+         * @param limit2 limit offset in second sequence
+         * @return true if s1.subSequence(start1, limit1) contains the same text
+         *              as s2.subSequence(start2, limit2)
+         */
+        public static boolean equal(CharSequence s1, int start1, int limit1,
+                                    CharSequence s2, int start2, int limit2) {
+            if((limit1-start1)!=(limit2-start2)) {
+                return false;
+            }
+            if(s1==s2 && start1==start2) {
+                return true;
+            }
+            while(start1<limit1) {
+                if(s1.charAt(start1++)!=s2.charAt(start2++)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    public NormalizerImpl() {}
+
+    private static final class IsAcceptable implements ICUBinary.Authenticate {
+        public boolean isDataVersionAcceptable(byte version[]) {
+            return version[0]==4;
+        }
+    }
+    private static final IsAcceptable IS_ACCEPTABLE = new IsAcceptable();
+    private static final int DATA_FORMAT = 0x4e726d32;  // "Nrm2"
+
+    public NormalizerImpl load(ByteBuffer bytes) {
+        try {
+            dataVersion=ICUBinary.readHeaderAndDataVersion(bytes, DATA_FORMAT, IS_ACCEPTABLE);
+            int indexesLength=bytes.getInt()/4;  // inIndexes[IX_NORM_TRIE_OFFSET]/4
+            if(indexesLength<=IX_MIN_LCCC_CP) {
+                throw new InternalError("Normalizer2 data: not enough indexes");
+            }
+            int[] inIndexes=new int[indexesLength];
+            inIndexes[0]=indexesLength*4;
+            for(int i=1; i<indexesLength; ++i) {
+                inIndexes[i]=bytes.getInt();
+            }
+
+            minDecompNoCP=inIndexes[IX_MIN_DECOMP_NO_CP];
+            minCompNoMaybeCP=inIndexes[IX_MIN_COMP_NO_MAYBE_CP];
+            minLcccCP=inIndexes[IX_MIN_LCCC_CP];
+
+            minYesNo=inIndexes[IX_MIN_YES_NO];
+            minYesNoMappingsOnly=inIndexes[IX_MIN_YES_NO_MAPPINGS_ONLY];
+            minNoNo=inIndexes[IX_MIN_NO_NO];
+            minNoNoCompBoundaryBefore=inIndexes[IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE];
+            minNoNoCompNoMaybeCC=inIndexes[IX_MIN_NO_NO_COMP_NO_MAYBE_CC];
+            minNoNoEmpty=inIndexes[IX_MIN_NO_NO_EMPTY];
+            limitNoNo=inIndexes[IX_LIMIT_NO_NO];
+            minMaybeYes=inIndexes[IX_MIN_MAYBE_YES];
+            assert((minMaybeYes&7)==0);  // 8-aligned for noNoDelta bit fields
+            centerNoNoDelta=(minMaybeYes>>DELTA_SHIFT)-MAX_DELTA-1;
+
+            // Read the normTrie.
+            int offset=inIndexes[IX_NORM_TRIE_OFFSET];
+            int nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];
+            int triePosition = bytes.position();
+            normTrie = CodePointTrie.Fast16.fromBinary(bytes);
+            int trieLength = bytes.position() - triePosition;
+            if(trieLength>(nextOffset-offset)) {
+                throw new InternalError("Normalizer2 data: not enough bytes for normTrie");
+            }
+            ICUBinary.skipBytes(bytes, (nextOffset-offset)-trieLength);  // skip padding after trie bytes
+
+            // Read the composition and mapping data.
+            offset=nextOffset;
+            nextOffset=inIndexes[IX_SMALL_FCD_OFFSET];
+            int numChars=(nextOffset-offset)/2;
+            if(numChars!=0) {
+                maybeYesCompositions=ICUBinary.getString(bytes, numChars, 0);
+                extraData=maybeYesCompositions.substring((MIN_NORMAL_MAYBE_YES-minMaybeYes)>>OFFSET_SHIFT);
+            }
+
+            // smallFCD: new in formatVersion 2
+            offset=nextOffset;
+            smallFCD=new byte[0x100];
+            bytes.get(smallFCD);
+
+            return this;
+        } catch(IOException e) {
+            throw new InternalError(e);
+        }
+    }
+    public NormalizerImpl load(String name) {
+        return load(ICUBinary.getRequiredData(name));
+    }
+
+    // The trie stores values for lead surrogate code *units*.
+    // Surrogate code *points* are inert.
+    public int getNorm16(int c) {
+        return UTF16Plus.isLeadSurrogate(c) ? INERT : normTrie.get(c);
+    }
+    public int getRawNorm16(int c) { return normTrie.get(c); }
+    public boolean isAlgorithmicNoNo(int norm16) { return limitNoNo<=norm16 && norm16<minMaybeYes; }
+    public boolean isCompNo(int norm16) { return minNoNo<=norm16 && norm16<minMaybeYes; }
+    public boolean isDecompYes(int norm16) { return norm16<minYesNo || minMaybeYes<=norm16; }
+
+    public int getCC(int norm16) {
+        if(norm16>=MIN_NORMAL_MAYBE_YES) {
+            return getCCFromNormalYesOrMaybe(norm16);
+        }
+        if(norm16<minNoNo || limitNoNo<=norm16) {
+            return 0;
+        }
+        return getCCFromNoNo(norm16);
+    }
+    public static int getCCFromNormalYesOrMaybe(int norm16) {
+        return (norm16 >> OFFSET_SHIFT) & 0xff;
+    }
+    public static int getCCFromYesOrMaybe(int norm16) {
+        return norm16>=MIN_NORMAL_MAYBE_YES ? getCCFromNormalYesOrMaybe(norm16) : 0;
+    }
+    public int getCCFromYesOrMaybeCP(int c) {
+        if (c < minCompNoMaybeCP) { return 0; }
+        return getCCFromYesOrMaybe(getNorm16(c));
+    }
+
+    /**
+     * Returns the FCD data for code point c.
+     * @param c A Unicode code point.
+     * @return The lccc(c) in bits 15..8 and tccc(c) in bits 7..0.
+     */
+    public int getFCD16(int c) {
+        if(c<minDecompNoCP) {
+            return 0;
+        } else if(c<=0xffff) {
+            if(!singleLeadMightHaveNonZeroFCD16(c)) { return 0; }
+        }
+        return getFCD16FromNormData(c);
+    }
+    /** Returns true if the single-or-lead code unit c might have non-zero FCD data. */
+    public boolean singleLeadMightHaveNonZeroFCD16(int lead) {
+        // 0<=lead<=0xffff
+        byte bits=smallFCD[lead>>8];
+        if(bits==0) { return false; }
+        return ((bits>>((lead>>5)&7))&1)!=0;
+    }
+
+    /** Gets the FCD value from the regular normalization data. */
+    public int getFCD16FromNormData(int c) {
+        int norm16=getNorm16(c);
+        if (norm16 >= limitNoNo) {
+            if(norm16>=MIN_NORMAL_MAYBE_YES) {
+                // combining mark
+                norm16=getCCFromNormalYesOrMaybe(norm16);
+                return norm16|(norm16<<8);
+            } else if(norm16>=minMaybeYes) {
+                return 0;
+            } else {  // isDecompNoAlgorithmic(norm16)
+                int deltaTrailCC = norm16 & DELTA_TCCC_MASK;
+                if (deltaTrailCC <= DELTA_TCCC_1) {
+                    return deltaTrailCC >> OFFSET_SHIFT;
+                }
+                // Maps to an isCompYesAndZeroCC.
+                c=mapAlgorithmic(c, norm16);
+                norm16=getRawNorm16(c);
+            }
+        }
+        if(norm16<=minYesNo || isHangulLVT(norm16)) {
+            // no decomposition or Hangul syllable, all zeros
+            return 0;
+        }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int firstUnit=extraData.charAt(mapping);
+        int fcd16=firstUnit>>8;  // tccc
+        if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
+            fcd16|=extraData.charAt(mapping-1)&0xff00;  // lccc
+        }
+        return fcd16;
+    }
+
+    /**
+     * Gets the decomposition for one code point.
+     * @param c code point
+     * @return c's decomposition, if it has one; returns null if it does not have a decomposition
+     */
+    public String getDecomposition(int c) {
+        int norm16;
+        if(c<minDecompNoCP || isMaybeOrNonZeroCC(norm16=getNorm16(c))) {
+            // c does not decompose
+            return null;
+        }
+        int decomp = -1;
+        if(isDecompNoAlgorithmic(norm16)) {
+            // Maps to an isCompYesAndZeroCC.
+            decomp=c=mapAlgorithmic(c, norm16);
+            // The mapping might decompose further.
+            norm16 = getRawNorm16(c);
+        }
+        if (norm16 < minYesNo) {
+            if(decomp<0) {
+                return null;
+            } else {
+                return UTF16.valueOf(decomp);
+            }
+        } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
+            // Hangul syllable: decompose algorithmically
+            StringBuilder buffer=new StringBuilder();
+            Hangul.decompose(c, buffer);
+            return buffer.toString();
+        }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int length=extraData.charAt(mapping++)&MAPPING_LENGTH_MASK;
+        return extraData.substring(mapping, mapping+length);
+    }
+
+    // Fixed norm16 values.
+    public static final int MIN_YES_YES_WITH_CC=0xfe02;
+    public static final int JAMO_VT=0xfe00;
+    public static final int MIN_NORMAL_MAYBE_YES=0xfc00;
+    public static final int JAMO_L=2;  // offset=1 hasCompBoundaryAfter=FALSE
+    public static final int INERT=1;  // offset=0 hasCompBoundaryAfter=TRUE
+
+    // norm16 bit 0 is comp-boundary-after.
+    public static final int HAS_COMP_BOUNDARY_AFTER=1;
+    public static final int OFFSET_SHIFT=1;
+
+    // For algorithmic one-way mappings, norm16 bits 2..1 indicate the
+    // tccc (0, 1, >1) for quick FCC boundary-after tests.
+    public static final int DELTA_TCCC_0=0;
+    public static final int DELTA_TCCC_1=2;
+    public static final int DELTA_TCCC_GT_1=4;
+    public static final int DELTA_TCCC_MASK=6;
+    public static final int DELTA_SHIFT=3;
+
+    public static final int MAX_DELTA=0x40;
+
+    // Byte offsets from the start of the data, after the generic header.
+    public static final int IX_NORM_TRIE_OFFSET=0;
+    public static final int IX_EXTRA_DATA_OFFSET=1;
+    public static final int IX_SMALL_FCD_OFFSET=2;
+    public static final int IX_RESERVED3_OFFSET=3;
+    public static final int IX_TOTAL_SIZE=7;
+    public static final int MIN_CCC_LCCC_CP=0x300;
+    // Code point thresholds for quick check codes.
+    public static final int IX_MIN_DECOMP_NO_CP=8;
+    public static final int IX_MIN_COMP_NO_MAYBE_CP=9;
+
+    // Norm16 value thresholds for quick check combinations and types of extra data.
+
+    /** Mappings & compositions in [minYesNo..minYesNoMappingsOnly[. */
+    public static final int IX_MIN_YES_NO=10;
+    /** Mappings are comp-normalized. */
+    public static final int IX_MIN_NO_NO=11;
+    public static final int IX_LIMIT_NO_NO=12;
+    public static final int IX_MIN_MAYBE_YES=13;
+
+    /** Mappings only in [minYesNoMappingsOnly..minNoNo[. */
+    public static final int IX_MIN_YES_NO_MAPPINGS_ONLY=14;
+    /** Mappings are not comp-normalized but have a comp boundary before. */
+    public static final int IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE=15;
+    /** Mappings do not have a comp boundary before. */
+    public static final int IX_MIN_NO_NO_COMP_NO_MAYBE_CC=16;
+    /** Mappings to the empty string. */
+    public static final int IX_MIN_NO_NO_EMPTY=17;
+
+    public static final int IX_MIN_LCCC_CP=18;
+    public static final int IX_COUNT=20;
+
+    public static final int MAPPING_HAS_CCC_LCCC_WORD=0x80;
+    public static final int MAPPING_HAS_RAW_MAPPING=0x40;
+    // unused bit 0x20;
+    public static final int MAPPING_LENGTH_MASK=0x1f;
+
+    public static final int COMP_1_LAST_TUPLE=0x8000;
+    public static final int COMP_1_TRIPLE=1;
+    public static final int COMP_1_TRAIL_LIMIT=0x3400;
+    public static final int COMP_1_TRAIL_MASK=0x7ffe;
+    public static final int COMP_1_TRAIL_SHIFT=9;  // 10-1 for the "triple" bit
+    public static final int COMP_2_TRAIL_SHIFT=6;
+    public static final int COMP_2_TRAIL_MASK=0xffc0;
+
+    // higher-level functionality ------------------------------------------ ***
+
+    /**
+     * Decomposes s[src, limit[ and writes the result to dest.
+     * limit can be NULL if src is NUL-terminated.
+     * destLengthEstimate is the initial dest buffer capacity and can be -1.
+     */
+    public void decompose(CharSequence s, int src, int limit, StringBuilder dest,
+                   int destLengthEstimate) {
+        if(destLengthEstimate<0) {
+            destLengthEstimate=limit-src;
+        }
+        dest.setLength(0);
+        ReorderingBuffer buffer=new ReorderingBuffer(this, dest, destLengthEstimate);
+        decompose(s, src, limit, buffer);
+    }
+
+    // Dual functionality:
+    // buffer!=NULL: normalize
+    // buffer==NULL: isNormalized/quickCheck/spanQuickCheckYes
+    public int decompose(CharSequence s, int src, int limit,
+                         ReorderingBuffer buffer) {
+        int minNoCP=minDecompNoCP;
+
+        int prevSrc;
+        int c=0;
+        int norm16=0;
+
+        // only for quick check
+        int prevBoundary=src;
+        int prevCC=0;
+
+        for(;;) {
+            // count code units below the minimum or with irrelevant data for the quick check
+            for(prevSrc=src; src!=limit;) {
+                if( (c=s.charAt(src))<minNoCP ||
+                    isMostDecompYesAndZeroCC(norm16=normTrie.bmpGet(c))
+                ) {
+                    ++src;
+                } else if(!UTF16Plus.isLeadSurrogate(c)) {
+                    break;
+                } else {
+                    char c2;
+                    if ((src + 1) != limit && Character.isLowSurrogate(c2 = s.charAt(src + 1))) {
+                        c = Character.toCodePoint((char)c, c2);
+                        norm16 = normTrie.suppGet(c);
+                        if (isMostDecompYesAndZeroCC(norm16)) {
+                            src += 2;
+                        } else {
+                            break;
+                        }
+                    } else {
+                        ++src;  // unpaired lead surrogate: inert
+                    }
+                }
+            }
+            // copy these code units all at once
+            if(src!=prevSrc) {
+                if(buffer!=null) {
+                    buffer.flushAndAppendZeroCC(s, prevSrc, src);
+                } else {
+                    prevCC=0;
+                    prevBoundary=src;
+                }
+            }
+            if(src==limit) {
+                break;
+            }
+
+            // Check one above-minimum, relevant code point.
+            src+=Character.charCount(c);
+            if(buffer!=null) {
+                decompose(c, norm16, buffer);
+            } else {
+                if(isDecompYes(norm16)) {
+                    int cc=getCCFromYesOrMaybe(norm16);
+                    if(prevCC<=cc || cc==0) {
+                        prevCC=cc;
+                        if(cc<=1) {
+                            prevBoundary=src;
+                        }
+                        continue;
+                    }
+                }
+                return prevBoundary;  // "no" or cc out of order
+            }
+        }
+        return src;
+    }
+    public void decomposeAndAppend(CharSequence s, boolean doDecompose, ReorderingBuffer buffer) {
+        int limit=s.length();
+        if(limit==0) {
+            return;
+        }
+        if(doDecompose) {
+            decompose(s, 0, limit, buffer);
+            return;
+        }
+        // Just merge the strings at the boundary.
+        int c=Character.codePointAt(s, 0);
+        int src=0;
+        int firstCC, prevCC, cc;
+        firstCC=prevCC=cc=getCC(getNorm16(c));
+        while(cc!=0) {
+            prevCC=cc;
+            src+=Character.charCount(c);
+            if(src>=limit) {
+                break;
+            }
+            c=Character.codePointAt(s, src);
+            cc=getCC(getNorm16(c));
+        };
+        buffer.append(s, 0, src, false, firstCC, prevCC);
+        buffer.append(s, src, limit);
+    }
+
+    // Very similar to composeQuickCheck(): Make the same changes in both places if relevant.
+    // doCompose: normalize
+    // !doCompose: isNormalized (buffer must be empty and initialized)
+    public boolean compose(CharSequence s, int src, int limit,
+                           boolean onlyContiguous,
+                           boolean doCompose,
+                           ReorderingBuffer buffer) {
+        int prevBoundary=src;
+        int minNoMaybeCP=minCompNoMaybeCP;
+
+        for (;;) {
+            // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
+            // or with (compYes && ccc==0) properties.
+            int prevSrc;
+            int c = 0;
+            int norm16 = 0;
+            for (;;) {
+                if (src == limit) {
+                    if (prevBoundary != limit && doCompose) {
+                        buffer.append(s, prevBoundary, limit);
+                    }
+                    return true;
+                }
+                if( (c=s.charAt(src))<minNoMaybeCP ||
+                    isCompYesAndZeroCC(norm16=normTrie.bmpGet(c))
+                ) {
+                    ++src;
+                } else {
+                    prevSrc = src++;
+                    if (!UTF16Plus.isLeadSurrogate(c)) {
+                        break;
+                    } else {
+                        char c2;
+                        if (src != limit && Character.isLowSurrogate(c2 = s.charAt(src))) {
+                            ++src;
+                            c = Character.toCodePoint((char)c, c2);
+                            norm16 = normTrie.suppGet(c);
+                            if (!isCompYesAndZeroCC(norm16)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
+            // The current character is either a "noNo" (has a mapping)
+            // or a "maybeYes" (combines backward)
+            // or a "yesYes" with ccc!=0.
+            // It is not a Hangul syllable or Jamo L because those have "yes" properties.
+
+            // Medium-fast path: Handle cases that do not require full decomposition and recomposition.
+            if (!isMaybeOrNonZeroCC(norm16)) {  // minNoNo <= norm16 < minMaybeYes
+                if (!doCompose) {
+                    return false;
+                }
+                // Fast path for mapping a character that is immediately surrounded by boundaries.
+                // In this case, we need not decompose around the current character.
+                if (isDecompNoAlgorithmic(norm16)) {
+                    // Maps to a single isCompYesAndZeroCC character
+                    // which also implies hasCompBoundaryBefore.
+                    if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
+                            hasCompBoundaryBefore(s, src, limit)) {
+                        if (prevBoundary != prevSrc) {
+                            buffer.append(s, prevBoundary, prevSrc);
+                        }
+                        buffer.append(mapAlgorithmic(c, norm16), 0);
+                        prevBoundary = src;
+                        continue;
+                    }
+                } else if (norm16 < minNoNoCompBoundaryBefore) {
+                    // The mapping is comp-normalized which also implies hasCompBoundaryBefore.
+                    if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) ||
+                            hasCompBoundaryBefore(s, src, limit)) {
+                        if (prevBoundary != prevSrc) {
+                            buffer.append(s, prevBoundary, prevSrc);
+                        }
+                        int mapping = norm16 >> OFFSET_SHIFT;
+                        int length = extraData.charAt(mapping++) & MAPPING_LENGTH_MASK;
+                        buffer.append(extraData, mapping, mapping + length);
+                        prevBoundary = src;
+                        continue;
+                    }
+                } else if (norm16 >= minNoNoEmpty) {
+                    // The current character maps to nothing.
+                    // Simply omit it from the output if there is a boundary before _or_ after it.
+                    // The character itself implies no boundaries.
+                    if (hasCompBoundaryBefore(s, src, limit) ||
+                            hasCompBoundaryAfter(s, prevBoundary, prevSrc, onlyContiguous)) {
+                        if (prevBoundary != prevSrc) {
+                            buffer.append(s, prevBoundary, prevSrc);
+                        }
+                        prevBoundary = src;
+                        continue;
+                    }
+                }
+                // Other "noNo" type, or need to examine more text around this character:
+                // Fall through to the slow path.
+            } else if (isJamoVT(norm16) && prevBoundary != prevSrc) {
+                char prev=s.charAt(prevSrc-1);
+                if(c<Hangul.JAMO_T_BASE) {
+                    // The current character is a Jamo Vowel,
+                    // compose with previous Jamo L and following Jamo T.
+                    char l = (char)(prev-Hangul.JAMO_L_BASE);
+                    if(l<Hangul.JAMO_L_COUNT) {
+                        if (!doCompose) {
+                            return false;
+                        }
+                        int t;
+                        if (src != limit &&
+                                0 < (t = (s.charAt(src) - Hangul.JAMO_T_BASE)) &&
+                                t < Hangul.JAMO_T_COUNT) {
+                            // The next character is a Jamo T.
+                            ++src;
+                        } else if (hasCompBoundaryBefore(s, src, limit)) {
+                            // No Jamo T follows, not even via decomposition.
+                            t = 0;
+                        } else {
+                            t = -1;
+                        }
+                        if (t >= 0) {
+                            int syllable = Hangul.HANGUL_BASE +
+                                (l*Hangul.JAMO_V_COUNT + (c-Hangul.JAMO_V_BASE)) *
+                                Hangul.JAMO_T_COUNT + t;
+                            --prevSrc;  // Replace the Jamo L as well.
+                            if (prevBoundary != prevSrc) {
+                                buffer.append(s, prevBoundary, prevSrc);
+                            }
+                            buffer.append((char)syllable);
+                            prevBoundary = src;
+                            continue;
+                        }
+                        // If we see L+V+x where x!=T then we drop to the slow path,
+                        // decompose and recompose.
+                        // This is to deal with NFKC finding normal L and V but a
+                        // compatibility variant of a T.
+                        // We need to either fully compose that combination here
+                        // (which would complicate the code and may not work with strange custom data)
+                        // or use the slow path.
+                    }
+                } else if (Hangul.isHangulLV(prev)) {
+                    // The current character is a Jamo Trailing consonant,
+                    // compose with previous Hangul LV that does not contain a Jamo T.
+                    if (!doCompose) {
+                        return false;
+                    }
+                    int syllable = prev + c - Hangul.JAMO_T_BASE;
+                    --prevSrc;  // Replace the Hangul LV as well.
+                    if (prevBoundary != prevSrc) {
+                        buffer.append(s, prevBoundary, prevSrc);
+                    }
+                    buffer.append((char)syllable);
+                    prevBoundary = src;
+                    continue;
+                }
+                // No matching context, or may need to decompose surrounding text first:
+                // Fall through to the slow path.
+            } else if (norm16 > JAMO_VT) {  // norm16 >= MIN_YES_YES_WITH_CC
+                // One or more combining marks that do not combine-back:
+                // Check for canonical order, copy unchanged if ok and
+                // if followed by a character with a boundary-before.
+                int cc = getCCFromNormalYesOrMaybe(norm16);  // cc!=0
+                if (onlyContiguous /* FCC */ && getPreviousTrailCC(s, prevBoundary, prevSrc) > cc) {
+                    // Fails FCD test, need to decompose and contiguously recompose.
+                    if (!doCompose) {
+                        return false;
+                    }
+                } else {
+                    // If !onlyContiguous (not FCC), then we ignore the tccc of
+                    // the previous character which passed the quick check "yes && ccc==0" test.
+                    int n16;
+                    for (;;) {
+                        if (src == limit) {
+                            if (doCompose) {
+                                buffer.append(s, prevBoundary, limit);
+                            }
+                            return true;
+                        }
+                        int prevCC = cc;
+                        c = Character.codePointAt(s, src);
+                        n16 = normTrie.get(c);
+                        if (n16 >= MIN_YES_YES_WITH_CC) {
+                            cc = getCCFromNormalYesOrMaybe(n16);
+                            if (prevCC > cc) {
+                                if (!doCompose) {
+                                    return false;
+                                }
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                        src += Character.charCount(c);
+                    }
+                    // p is after the last in-order combining mark.
+                    // If there is a boundary here, then we continue with no change.
+                    if (norm16HasCompBoundaryBefore(n16)) {
+                        if (isCompYesAndZeroCC(n16)) {
+                            src += Character.charCount(c);
+                        }
+                        continue;
+                    }
+                    // Use the slow path. There is no boundary in [prevSrc, src[.
+                }
+            }
+
+            // Slow path: Find the nearest boundaries around the current character,
+            // decompose and recompose.
+            if (prevBoundary != prevSrc && !norm16HasCompBoundaryBefore(norm16)) {
+                c = Character.codePointBefore(s, prevSrc);
+                norm16 = normTrie.get(c);
+                if (!norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                    prevSrc -= Character.charCount(c);
+                }
+            }
+            if (doCompose && prevBoundary != prevSrc) {
+                buffer.append(s, prevBoundary, prevSrc);
+            }
+            int recomposeStartIndex=buffer.length();
+            // We know there is not a boundary here.
+            decomposeShort(s, prevSrc, src, false /* !stopAtCompBoundary */, onlyContiguous,
+                           buffer);
+            // Decompose until the next boundary.
+            src = decomposeShort(s, src, limit, true /* stopAtCompBoundary */, onlyContiguous,
+                                 buffer);
+            recompose(buffer, recomposeStartIndex, onlyContiguous);
+            if(!doCompose) {
+                if(!buffer.equals(s, prevSrc, src)) {
+                    return false;
+                }
+                buffer.remove();
+            }
+            prevBoundary=src;
+        }
+    }
+
+    /**
+     * Very similar to compose(): Make the same changes in both places if relevant.
+     * doSpan: spanQuickCheckYes (ignore bit 0 of the return value)
+     * !doSpan: quickCheck
+     * @return bits 31..1: spanQuickCheckYes (==s.length() if "yes") and
+     *         bit 0: set if "maybe"; otherwise, if the span length&lt;s.length()
+     *         then the quick check result is "no"
+     */
+    public int composeQuickCheck(CharSequence s, int src, int limit,
+                                 boolean onlyContiguous, boolean doSpan) {
+        int qcResult=0;
+        int prevBoundary=src;
+        int minNoMaybeCP=minCompNoMaybeCP;
+
+        for(;;) {
+            // Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
+            // or with (compYes && ccc==0) properties.
+            int prevSrc;
+            int c = 0;
+            int norm16 = 0;
+            for (;;) {
+                if(src==limit) {
+                    return (src<<1)|qcResult;  // "yes" or "maybe"
+                }
+                if( (c=s.charAt(src))<minNoMaybeCP ||
+                    isCompYesAndZeroCC(norm16=normTrie.bmpGet(c))
+                ) {
+                    ++src;
+                } else {
+                    prevSrc = src++;
+                    if (!UTF16Plus.isLeadSurrogate(c)) {
+                        break;
+                    } else {
+                        char c2;
+                        if (src != limit && Character.isLowSurrogate(c2 = s.charAt(src))) {
+                            ++src;
+                            c = Character.toCodePoint((char)c, c2);
+                            norm16 = normTrie.suppGet(c);
+                            if (!isCompYesAndZeroCC(norm16)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            // isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
+            // The current character is either a "noNo" (has a mapping)
+            // or a "maybeYes" (combines backward)
+            // or a "yesYes" with ccc!=0.
+            // It is not a Hangul syllable or Jamo L because those have "yes" properties.
+
+            int prevNorm16 = INERT;
+            if (prevBoundary != prevSrc) {
+                prevBoundary = prevSrc;
+                if (!norm16HasCompBoundaryBefore(norm16)) {
+                    c = Character.codePointBefore(s, prevSrc);
+                    int n16 = getNorm16(c);
+                    if (!norm16HasCompBoundaryAfter(n16, onlyContiguous)) {
+                        prevBoundary -= Character.charCount(c);
+                        prevNorm16 = n16;
+                    }
+                }
+            }
+
+            if(isMaybeOrNonZeroCC(norm16)) {
+                int cc=getCCFromYesOrMaybe(norm16);
+                if (onlyContiguous /* FCC */ && cc != 0 &&
+                        getTrailCCFromCompYesAndZeroCC(prevNorm16) > cc) {
+                    // The [prevBoundary..prevSrc[ character
+                    // passed the quick check "yes && ccc==0" test
+                    // but is out of canonical order with the current combining mark.
+                } else {
+                    // If !onlyContiguous (not FCC), then we ignore the tccc of
+                    // the previous character which passed the quick check "yes && ccc==0" test.
+                    for (;;) {
+                        if (norm16 < MIN_YES_YES_WITH_CC) {
+                            if (!doSpan) {
+                                qcResult = 1;
+                            } else {
+                                return prevBoundary << 1;  // spanYes does not care to know it's "maybe"
+                            }
+                        }
+                        if (src == limit) {
+                            return (src<<1) | qcResult;  // "yes" or "maybe"
+                        }
+                        int prevCC = cc;
+                        c = Character.codePointAt(s, src);
+                        norm16 = getNorm16(c);
+                        if (isMaybeOrNonZeroCC(norm16)) {
+                            cc = getCCFromYesOrMaybe(norm16);
+                            if (!(prevCC <= cc || cc == 0)) {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                        src += Character.charCount(c);
+                    }
+                    // src is after the last in-order combining mark.
+                    if (isCompYesAndZeroCC(norm16)) {
+                        prevBoundary = src;
+                        src += Character.charCount(c);
+                        continue;
+                    }
+                }
+            }
+            return prevBoundary<<1;  // "no"
+        }
+    }
+    public void composeAndAppend(CharSequence s,
+                                 boolean doCompose,
+                                 boolean onlyContiguous,
+                                 ReorderingBuffer buffer) {
+        int src=0, limit=s.length();
+        if(!buffer.isEmpty()) {
+            int firstStarterInSrc=findNextCompBoundary(s, 0, limit, onlyContiguous);
+            if(0!=firstStarterInSrc) {
+                int lastStarterInDest=findPreviousCompBoundary(buffer.getStringBuilder(),
+                                                               buffer.length(), onlyContiguous);
+                StringBuilder middle=new StringBuilder((buffer.length()-lastStarterInDest)+
+                                                       firstStarterInSrc+16);
+                middle.append(buffer.getStringBuilder(), lastStarterInDest, buffer.length());
+                buffer.removeSuffix(buffer.length()-lastStarterInDest);
+                middle.append(s, 0, firstStarterInSrc);
+                compose(middle, 0, middle.length(), onlyContiguous, true, buffer);
+                src=firstStarterInSrc;
+            }
+        }
+        if(doCompose) {
+            compose(s, src, limit, onlyContiguous, true, buffer);
+        } else {
+            buffer.append(s, src, limit);
+        }
+    }
+    // Dual functionality:
+    // buffer!=NULL: normalize
+    // buffer==NULL: isNormalized/quickCheck/spanQuickCheckYes
+    public int makeFCD(CharSequence s, int src, int limit, ReorderingBuffer buffer) {
+        // Note: In this function we use buffer->appendZeroCC() because we track
+        // the lead and trail combining classes here, rather than leaving it to
+        // the ReorderingBuffer.
+        // The exception is the call to decomposeShort() which uses the buffer
+        // in the normal way.
+
+        // Tracks the last FCD-safe boundary, before lccc=0 or after properly-ordered tccc<=1.
+        // Similar to the prevBoundary in the compose() implementation.
+        int prevBoundary=src;
+        int prevSrc;
+        int c=0;
+        int prevFCD16=0;
+        int fcd16=0;
+
+        for(;;) {
+            // count code units with lccc==0
+            for(prevSrc=src; src!=limit;) {
+                if((c=s.charAt(src))<minLcccCP) {
+                    prevFCD16=~c;
+                    ++src;
+                } else if(!singleLeadMightHaveNonZeroFCD16(c)) {
+                    prevFCD16=0;
+                    ++src;
+                } else {
+                    if (UTF16Plus.isLeadSurrogate(c)) {
+                        char c2;
+                        if ((src + 1) != limit && Character.isLowSurrogate(c2 = s.charAt(src + 1))) {
+                            c = Character.toCodePoint((char)c, c2);
+                        }
+                    }
+                    if((fcd16=getFCD16FromNormData(c))<=0xff) {
+                        prevFCD16=fcd16;
+                        src+=Character.charCount(c);
+                    } else {
+                        break;
+                    }
+                }
+            }
+            // copy these code units all at once
+            if(src!=prevSrc) {
+                if(src==limit) {
+                    if(buffer!=null) {
+                        buffer.flushAndAppendZeroCC(s, prevSrc, src);
+                    }
+                    break;
+                }
+                prevBoundary=src;
+                // We know that the previous character's lccc==0.
+                if(prevFCD16<0) {
+                    // Fetching the fcd16 value was deferred for this below-minLcccCP code point.
+                    int prev=~prevFCD16;
+                    if(prev<minDecompNoCP) {
+                        prevFCD16=0;
+                    } else {
+                        prevFCD16=getFCD16FromNormData(prev);
+                        if(prevFCD16>1) {
+                            --prevBoundary;
+                        }
+                    }
+                } else {
+                    int p=src-1;
+                    if( Character.isLowSurrogate(s.charAt(p)) && prevSrc<p &&
+                        Character.isHighSurrogate(s.charAt(p-1))
+                    ) {
+                        --p;
+                        // Need to fetch the previous character's FCD value because
+                        // prevFCD16 was just for the trail surrogate code point.
+                        prevFCD16=getFCD16FromNormData(Character.toCodePoint(s.charAt(p), s.charAt(p+1)));
+                        // Still known to have lccc==0 because its lead surrogate unit had lccc==0.
+                    }
+                    if(prevFCD16>1) {
+                        prevBoundary=p;
+                    }
+                }
+                if(buffer!=null) {
+                    // The last lccc==0 character is excluded from the
+                    // flush-and-append call in case it needs to be modified.
+                    buffer.flushAndAppendZeroCC(s, prevSrc, prevBoundary);
+                    buffer.append(s, prevBoundary, src);
+                }
+                // The start of the current character (c).
+                prevSrc=src;
+            } else if(src==limit) {
+                break;
+            }
+
+            src+=Character.charCount(c);
+            // The current character (c) at [prevSrc..src[ has a non-zero lead combining class.
+            // Check for proper order, and decompose locally if necessary.
+            if((prevFCD16&0xff)<=(fcd16>>8)) {
+                // proper order: prev tccc <= current lccc
+                if((fcd16&0xff)<=1) {
+                    prevBoundary=src;
+                }
+                if(buffer!=null) {
+                    buffer.appendZeroCC(c);
+                }
+                prevFCD16=fcd16;
+                continue;
+            } else if(buffer==null) {
+                return prevBoundary;  // quick check "no"
+            } else {
+                /*
+                 * Back out the part of the source that we copied or appended
+                 * already but is now going to be decomposed.
+                 * prevSrc is set to after what was copied/appended.
+                 */
+                buffer.removeSuffix(prevSrc-prevBoundary);
+                /*
+                 * Find the part of the source that needs to be decomposed,
+                 * up to the next safe boundary.
+                 */
+                src=findNextFCDBoundary(s, src, limit);
+                /*
+                 * The source text does not fulfill the conditions for FCD.
+                 * Decompose and reorder a limited piece of the text.
+                 */
+                decomposeShort(s, prevBoundary, src, false, false, buffer);
+                prevBoundary=src;
+                prevFCD16=0;
+            }
+        }
+        return src;
+    }
+
+    public boolean hasDecompBoundaryBefore(int c) {
+        return c < minLcccCP || (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) ||
+            norm16HasDecompBoundaryBefore(getNorm16(c));
+    }
+    public boolean norm16HasDecompBoundaryBefore(int norm16) {
+        if (norm16 < minNoNoCompNoMaybeCC) {
+            return true;
+        }
+        if (norm16 >= limitNoNo) {
+            return norm16 <= MIN_NORMAL_MAYBE_YES || norm16 == JAMO_VT;
+        }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int firstUnit=extraData.charAt(mapping);
+        // true if leadCC==0 (hasFCDBoundaryBefore())
+        return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (extraData.charAt(mapping-1)&0xff00)==0;
+    }
+    public boolean hasDecompBoundaryAfter(int c) {
+        if (c < minDecompNoCP) {
+            return true;
+        }
+        if (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) {
+            return true;
+        }
+        return norm16HasDecompBoundaryAfter(getNorm16(c));
+    }
+    public boolean norm16HasDecompBoundaryAfter(int norm16) {
+        if(norm16 <= minYesNo || isHangulLVT(norm16)) {
+            return true;
+        }
+        if (norm16 >= limitNoNo) {
+            if (isMaybeOrNonZeroCC(norm16)) {
+                return norm16 <= MIN_NORMAL_MAYBE_YES || norm16 == JAMO_VT;
+            }
+            // Maps to an isCompYesAndZeroCC.
+            return (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1;
+        }
+        // c decomposes, get everything from the variable-length extra data
+        int mapping=norm16>>OFFSET_SHIFT;
+        int firstUnit=extraData.charAt(mapping);
+        // decomp after-boundary: same as hasFCDBoundaryAfter(),
+        // fcd16<=1 || trailCC==0
+        if(firstUnit>0x1ff) {
+            return false;  // trailCC>1
+        }
+        if(firstUnit<=0xff) {
+            return true;  // trailCC==0
+        }
+        // if(trailCC==1) test leadCC==0, same as checking for before-boundary
+        // true if leadCC==0 (hasFCDBoundaryBefore())
+        return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 || (extraData.charAt(mapping-1)&0xff00)==0;
+    }
+    public boolean isDecompInert(int c) { return isDecompYesAndZeroCC(getNorm16(c)); }
+
+    public boolean hasCompBoundaryBefore(int c) {
+        return c<minCompNoMaybeCP || norm16HasCompBoundaryBefore(getNorm16(c));
+    }
+    public boolean hasCompBoundaryAfter(int c, boolean onlyContiguous) {
+        return norm16HasCompBoundaryAfter(getNorm16(c), onlyContiguous);
+    }
+
+    private boolean isMaybe(int norm16) { return minMaybeYes<=norm16 && norm16<=JAMO_VT; }
+    private boolean isMaybeOrNonZeroCC(int norm16) { return norm16>=minMaybeYes; }
+    private static boolean isInert(int norm16) { return norm16==INERT; }
+    private static boolean isJamoVT(int norm16) { return norm16==JAMO_VT; }
+    private int hangulLVT() { return minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER; }
+    private boolean isHangulLV(int norm16) { return norm16==minYesNo; }
+    private boolean isHangulLVT(int norm16) {
+        return norm16==hangulLVT();
+    }
+    private boolean isCompYesAndZeroCC(int norm16) { return norm16<minNoNo; }
+    // UBool isCompYes(uint16_t norm16) const {
+    //     return norm16>=MIN_YES_YES_WITH_CC || norm16<minNoNo;
+    // }
+    // UBool isCompYesOrMaybe(uint16_t norm16) const {
+    //     return norm16<minNoNo || minMaybeYes<=norm16;
+    // }
+    // private boolean hasZeroCCFromDecompYes(int norm16) {
+    //     return norm16<=MIN_NORMAL_MAYBE_YES || norm16==JAMO_VT;
+    // }
+    private boolean isDecompYesAndZeroCC(int norm16) {
+        return norm16<minYesNo ||
+               norm16==JAMO_VT ||
+               (minMaybeYes<=norm16 && norm16<=MIN_NORMAL_MAYBE_YES);
+    }
+    /**
+     * A little faster and simpler than isDecompYesAndZeroCC() but does not include
+     * the MaybeYes which combine-forward and have ccc=0.
+     * (Standard Unicode 10 normalization does not have such characters.)
+     */
+    private boolean isMostDecompYesAndZeroCC(int norm16) {
+        return norm16<minYesNo || norm16==MIN_NORMAL_MAYBE_YES || norm16==JAMO_VT;
+    }
+    private boolean isDecompNoAlgorithmic(int norm16) { return norm16>=limitNoNo; }
+
+    // For use with isCompYes().
+    // Perhaps the compiler can combine the two tests for MIN_YES_YES_WITH_CC.
+    // static uint8_t getCCFromYes(uint16_t norm16) {
+    //     return norm16>=MIN_YES_YES_WITH_CC ? getCCFromNormalYesOrMaybe(norm16) : 0;
+    // }
+    private int getCCFromNoNo(int norm16) {
+        int mapping=norm16>>OFFSET_SHIFT;
+        if((extraData.charAt(mapping)&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
+            return extraData.charAt(mapping-1)&0xff;
+        } else {
+            return 0;
+        }
+    }
+    int getTrailCCFromCompYesAndZeroCC(int norm16) {
+        if(norm16<=minYesNo) {
+            return 0;  // yesYes and Hangul LV have ccc=tccc=0
+        } else {
+            // For Hangul LVT we harmlessly fetch a firstUnit with tccc=0 here.
+            return extraData.charAt(norm16>>OFFSET_SHIFT)>>8;  // tccc from yesNo
+        }
+    }
+
+    // Requires algorithmic-NoNo.
+    private int mapAlgorithmic(int c, int norm16) {
+        return c+(norm16>>DELTA_SHIFT)-centerNoNoDelta;
+    }
+
+    // Requires minYesNo<norm16<limitNoNo.
+    // private int getMapping(int norm16) { return extraData+(norm16>>OFFSET_SHIFT); }
+
+    /**
+     * @return index into maybeYesCompositions, or -1
+     */
+    private int getCompositionsListForDecompYes(int norm16) {
+        if(norm16<JAMO_L || MIN_NORMAL_MAYBE_YES<=norm16) {
+            return -1;
+        } else {
+            if((norm16-=minMaybeYes)<0) {
+                // norm16<minMaybeYes: index into extraData which is a substring at
+                //     maybeYesCompositions[MIN_NORMAL_MAYBE_YES-minMaybeYes]
+                // same as (MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16
+                norm16+=MIN_NORMAL_MAYBE_YES;  // for yesYes; if Jamo L: harmless empty list
+            }
+            return norm16>>OFFSET_SHIFT;
+        }
+    }
+    /**
+     * @return index into maybeYesCompositions
+     */
+    private int getCompositionsListForComposite(int norm16) {
+        // A composite has both mapping & compositions list.
+        int list=((MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16)>>OFFSET_SHIFT;
+        int firstUnit=maybeYesCompositions.charAt(list);
+        return list+  // mapping in maybeYesCompositions
+            1+  // +1 to skip the first unit with the mapping length
+            (firstUnit&MAPPING_LENGTH_MASK);  // + mapping length
+    }
+
+    // Decompose a short piece of text which is likely to contain characters that
+    // fail the quick check loop and/or where the quick check loop's overhead
+    // is unlikely to be amortized.
+    // Called by the compose() and makeFCD() implementations.
+    // Public in Java for collation implementation code.
+    private int decomposeShort(
+            CharSequence s, int src, int limit,
+            boolean stopAtCompBoundary, boolean onlyContiguous,
+            ReorderingBuffer buffer) {
+        while(src<limit) {
+            int c=Character.codePointAt(s, src);
+            if (stopAtCompBoundary && c < minCompNoMaybeCP) {
+                return src;
+            }
+            int norm16 = getNorm16(c);
+            if (stopAtCompBoundary && norm16HasCompBoundaryBefore(norm16)) {
+                return src;
+            }
+            src+=Character.charCount(c);
+            decompose(c, norm16, buffer);
+            if (stopAtCompBoundary && norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                return src;
+            }
+        }
+        return src;
+    }
+    private void decompose(int c, int norm16, ReorderingBuffer buffer) {
+        // get the decomposition and the lead and trail cc's
+        if (norm16 >= limitNoNo) {
+            if (isMaybeOrNonZeroCC(norm16)) {
+                buffer.append(c, getCCFromYesOrMaybe(norm16));
+                return;
+            }
+            // Maps to an isCompYesAndZeroCC.
+            c=mapAlgorithmic(c, norm16);
+            norm16=getRawNorm16(c);
+        }
+        if (norm16 < minYesNo) {
+            // c does not decompose
+            buffer.append(c, 0);
+        } else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
+            // Hangul syllable: decompose algorithmically
+            Hangul.decompose(c, buffer);
+        } else {
+            // c decomposes, get everything from the variable-length extra data
+            int mapping=norm16>>OFFSET_SHIFT;
+            int firstUnit=extraData.charAt(mapping);
+            int length=firstUnit&MAPPING_LENGTH_MASK;
+            int leadCC, trailCC;
+            trailCC=firstUnit>>8;
+            if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
+                leadCC=extraData.charAt(mapping-1)>>8;
+            } else {
+                leadCC=0;
+            }
+            ++mapping;  // skip over the firstUnit
+            buffer.append(extraData, mapping, mapping+length, true, leadCC, trailCC);
+        }
+    }
+
+    /**
+     * Finds the recomposition result for
+     * a forward-combining "lead" character,
+     * specified with a pointer to its compositions list,
+     * and a backward-combining "trail" character.
+     *
+     * <p>If the lead and trail characters combine, then this function returns
+     * the following "compositeAndFwd" value:
+     * <pre>
+     * Bits 21..1  composite character
+     * Bit      0  set if the composite is a forward-combining starter
+     * </pre>
+     * otherwise it returns -1.
+     *
+     * <p>The compositions list has (trail, compositeAndFwd) pair entries,
+     * encoded as either pairs or triples of 16-bit units.
+     * The last entry has the high bit of its first unit set.
+     *
+     * <p>The list is sorted by ascending trail characters (there are no duplicates).
+     * A linear search is used.
+     *
+     * <p>See normalizer2impl.h for a more detailed description
+     * of the compositions list format.
+     */
+    private static int combine(String compositions, int list, int trail) {
+        int key1, firstUnit;
+        if(trail<COMP_1_TRAIL_LIMIT) {
+            // trail character is 0..33FF
+            // result entry may have 2 or 3 units
+            key1=(trail<<1);
+            while(key1>(firstUnit=compositions.charAt(list))) {
+                list+=2+(firstUnit&COMP_1_TRIPLE);
+            }
+            if(key1==(firstUnit&COMP_1_TRAIL_MASK)) {
+                if((firstUnit&COMP_1_TRIPLE)!=0) {
+                    return (compositions.charAt(list+1)<<16)|compositions.charAt(list+2);
+                } else {
+                    return compositions.charAt(list+1);
+                }
+            }
+        } else {
+            // trail character is 3400..10FFFF
+            // result entry has 3 units
+            key1=COMP_1_TRAIL_LIMIT+(((trail>>COMP_1_TRAIL_SHIFT))&~COMP_1_TRIPLE);
+            int key2=(trail<<COMP_2_TRAIL_SHIFT)&0xffff;
+            int secondUnit;
+            for(;;) {
+                if(key1>(firstUnit=compositions.charAt(list))) {
+                    list+=2+(firstUnit&COMP_1_TRIPLE);
+                } else if(key1==(firstUnit&COMP_1_TRAIL_MASK)) {
+                    if(key2>(secondUnit=compositions.charAt(list+1))) {
+                        if((firstUnit&COMP_1_LAST_TUPLE)!=0) {
+                            break;
+                        } else {
+                            list+=3;
+                        }
+                    } else if(key2==(secondUnit&COMP_2_TRAIL_MASK)) {
+                        return ((secondUnit&~COMP_2_TRAIL_MASK)<<16)|compositions.charAt(list+2);
+                    } else {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+        }
+        return -1;
+    }
+
+    /*
+     * Recomposes the buffer text starting at recomposeStartIndex
+     * (which is in NFD - decomposed and canonically ordered),
+     * and truncates the buffer contents.
+     *
+     * Note that recomposition never lengthens the text:
+     * Any character consists of either one or two code units;
+     * a composition may contain at most one more code unit than the original starter,
+     * while the combining mark that is removed has at least one code unit.
+     */
+    private void recompose(ReorderingBuffer buffer, int recomposeStartIndex,
+                           boolean onlyContiguous) {
+        StringBuilder sb=buffer.getStringBuilder();
+        int p=recomposeStartIndex;
+        if(p==sb.length()) {
+            return;
+        }
+
+        int starter, pRemove;
+        int compositionsList;
+        int c, compositeAndFwd;
+        int norm16;
+        int cc, prevCC;
+        boolean starterIsSupplementary;
+
+        // Some of the following variables are not used until we have a forward-combining starter
+        // and are only initialized now to avoid compiler warnings.
+        compositionsList=-1;  // used as indicator for whether we have a forward-combining starter
+        starter=-1;
+        starterIsSupplementary=false;
+        prevCC=0;
+
+        for(;;) {
+            c=sb.codePointAt(p);
+            p+=Character.charCount(c);
+            norm16=getNorm16(c);
+            cc=getCCFromYesOrMaybe(norm16);
+            if( // this character combines backward and
+                isMaybe(norm16) &&
+                // we have seen a starter that combines forward and
+                compositionsList>=0 &&
+                // the backward-combining character is not blocked
+                (prevCC<cc || prevCC==0)
+            ) {
+                if(isJamoVT(norm16)) {
+                    // c is a Jamo V/T, see if we can compose it with the previous character.
+                    if(c<Hangul.JAMO_T_BASE) {
+                        // c is a Jamo Vowel, compose with previous Jamo L and following Jamo T.
+                        char prev=(char)(sb.charAt(starter)-Hangul.JAMO_L_BASE);
+                        if(prev<Hangul.JAMO_L_COUNT) {
+                            pRemove=p-1;
+                            char syllable=(char)
+                                (Hangul.HANGUL_BASE+
+                                 (prev*Hangul.JAMO_V_COUNT+(c-Hangul.JAMO_V_BASE))*
+                                 Hangul.JAMO_T_COUNT);
+                            char t;
+                            if(p!=sb.length() && (t=(char)(sb.charAt(p)-Hangul.JAMO_T_BASE))<Hangul.JAMO_T_COUNT) {
+                                ++p;
+                                syllable+=t;  // The next character was a Jamo T.
+                            }
+                            sb.setCharAt(starter, syllable);
+                            // remove the Jamo V/T
+                            sb.delete(pRemove, p);
+                            p=pRemove;
+                        }
+                    }
+                    /*
+                     * No "else" for Jamo T:
+                     * Since the input is in NFD, there are no Hangul LV syllables that
+                     * a Jamo T could combine with.
+                     * All Jamo Ts are combined above when handling Jamo Vs.
+                     */
+                    if(p==sb.length()) {
+                        break;
+                    }
+                    compositionsList=-1;
+                    continue;
+                } else if((compositeAndFwd=combine(maybeYesCompositions, compositionsList, c))>=0) {
+                    // The starter and the combining mark (c) do combine.
+                    int composite=compositeAndFwd>>1;
+
+                    // Remove the combining mark.
+                    pRemove=p-Character.charCount(c);  // pRemove & p: start & limit of the combining mark
+                    sb.delete(pRemove, p);
+                    p=pRemove;
+                    // Replace the starter with the composite.
+                    if(starterIsSupplementary) {
+                        if(composite>0xffff) {
+                            // both are supplementary
+                            sb.setCharAt(starter, UTF16.getLeadSurrogate(composite));
+                            sb.setCharAt(starter+1, UTF16.getTrailSurrogate(composite));
+                        } else {
+                            sb.setCharAt(starter, (char)c);
+                            sb.deleteCharAt(starter+1);
+                            // The composite is shorter than the starter,
+                            // move the intermediate characters forward one.
+                            starterIsSupplementary=false;
+                            --p;
+                        }
+                    } else if(composite>0xffff) {
+                        // The composite is longer than the starter,
+                        // move the intermediate characters back one.
+                        starterIsSupplementary=true;
+                        sb.setCharAt(starter, UTF16.getLeadSurrogate(composite));
+                        sb.insert(starter+1, UTF16.getTrailSurrogate(composite));
+                        ++p;
+                    } else {
+                        // both are on the BMP
+                        sb.setCharAt(starter, (char)composite);
+                    }
+
+                    // Keep prevCC because we removed the combining mark.
+
+                    if(p==sb.length()) {
+                        break;
+                    }
+                    // Is the composite a starter that combines forward?
+                    if((compositeAndFwd&1)!=0) {
+                        compositionsList=
+                            getCompositionsListForComposite(getRawNorm16(composite));
+                    } else {
+                        compositionsList=-1;
+                    }
+
+                    // We combined; continue with looking for compositions.
+                    continue;
+                }
+            }
+
+            // no combination this time
+            prevCC=cc;
+            if(p==sb.length()) {
+                break;
+            }
+
+            // If c did not combine, then check if it is a starter.
+            if(cc==0) {
+                // Found a new starter.
+                if((compositionsList=getCompositionsListForDecompYes(norm16))>=0) {
+                    // It may combine with something, prepare for it.
+                    if(c<=0xffff) {
+                        starterIsSupplementary=false;
+                        starter=p-1;
+                    } else {
+                        starterIsSupplementary=true;
+                        starter=p-2;
+                    }
+                }
+            } else if(onlyContiguous) {
+                // FCC: no discontiguous compositions; any intervening character blocks.
+                compositionsList=-1;
+            }
+        }
+        buffer.flush();
+    }
+
+    /**
+     * Does c have a composition boundary before it?
+     * True if its decomposition begins with a character that has
+     * ccc=0 && NFC_QC=Yes (isCompYesAndZeroCC()).
+     * As a shortcut, this is true if c itself has ccc=0 && NFC_QC=Yes
+     * (isCompYesAndZeroCC()) so we need not decompose.
+     */
+    private boolean hasCompBoundaryBefore(int c, int norm16) {
+        return c<minCompNoMaybeCP || norm16HasCompBoundaryBefore(norm16);
+    }
+    private boolean norm16HasCompBoundaryBefore(int norm16) {
+        return norm16 < minNoNoCompNoMaybeCC || isAlgorithmicNoNo(norm16);
+    }
+    private boolean hasCompBoundaryBefore(CharSequence s, int src, int limit) {
+        return src == limit || hasCompBoundaryBefore(Character.codePointAt(s, src));
+    }
+    private boolean norm16HasCompBoundaryAfter(int norm16, boolean onlyContiguous) {
+        return (norm16 & HAS_COMP_BOUNDARY_AFTER) != 0 &&
+            (!onlyContiguous || isTrailCC01ForCompBoundaryAfter(norm16));
+    }
+    private boolean hasCompBoundaryAfter(CharSequence s, int start, int p, boolean onlyContiguous) {
+        return start == p || hasCompBoundaryAfter(Character.codePointBefore(s, p), onlyContiguous);
+    }
+    /** For FCC: Given norm16 HAS_COMP_BOUNDARY_AFTER, does it have tccc<=1? */
+    private boolean isTrailCC01ForCompBoundaryAfter(int norm16) {
+        return isInert(norm16) || (isDecompNoAlgorithmic(norm16) ?
+            (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1 : extraData.charAt(norm16 >> OFFSET_SHIFT) <= 0x1ff);
+    }
+
+    private int findPreviousCompBoundary(CharSequence s, int p, boolean onlyContiguous) {
+        while(p>0) {
+            int c=Character.codePointBefore(s, p);
+            int norm16 = getNorm16(c);
+            if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                break;
+            }
+            p-=Character.charCount(c);
+            if(hasCompBoundaryBefore(c, norm16)) {
+                break;
+            }
+        }
+        return p;
+    }
+    private int findNextCompBoundary(CharSequence s, int p, int limit, boolean onlyContiguous) {
+        while(p<limit) {
+            int c=Character.codePointAt(s, p);
+            int norm16=normTrie.get(c);
+            if(hasCompBoundaryBefore(c, norm16)) {
+                break;
+            }
+            p+=Character.charCount(c);
+            if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+                break;
+            }
+        }
+        return p;
+    }
+
+
+    private int findNextFCDBoundary(CharSequence s, int p, int limit) {
+        while(p<limit) {
+            int c=Character.codePointAt(s, p);
+            int norm16;
+            if (c < minLcccCP || norm16HasDecompBoundaryBefore(norm16 = getNorm16(c))) {
+                break;
+            }
+            p+=Character.charCount(c);
+            if (norm16HasDecompBoundaryAfter(norm16)) {
+                break;
+            }
+        }
+        return p;
+    }
+
+    /**
+     * Get the canonical decomposition
+     * sherman  for ComposedCharIter
+     */
+    public static int getDecompose(int chars[], String decomps[]) {
+        Normalizer2 impl = Normalizer2.getNFDInstance();
+
+        int length=0;
+        int norm16 = 0;
+        int ch = -1;
+        int i = 0;
+
+        while (++ch < 0x2fa1e) {   //no cannoical above 0x3ffff
+            //TBD !!!! the hack code heres save us about 50ms for startup
+            //need a better solution/lookup
+            if (ch == 0x30ff)
+                ch = 0xf900;
+            else if (ch == 0x115bc)
+                ch = 0x1d15e;
+            else if (ch == 0x1d1c1)
+                ch = 0x2f800;
+
+            String s = impl.getDecomposition(ch);
+
+            if(s != null && i < chars.length) {
+                chars[i] = ch;
+                decomps[i++] = s;
+            }
+        }
+        return i;
+    }
+
+    //------------------------------------------------------
+    // special method for Collation (RBTableBuilder.build())
+    //------------------------------------------------------
+    private static boolean needSingleQuotation(char c) {
+        return (c >= 0x0009 && c <= 0x000D) ||
+               (c >= 0x0020 && c <= 0x002F) ||
+               (c >= 0x003A && c <= 0x0040) ||
+               (c >= 0x005B && c <= 0x0060) ||
+               (c >= 0x007B && c <= 0x007E);
+    }
+
+    public static String canonicalDecomposeWithSingleQuotation(String string) {
+       Normalizer2 impl = Normalizer2.getNFDInstance();
+       char[] src = string.toCharArray();
+       int    srcIndex = 0;
+       int    srcLimit = src.length;
+       char[] dest = new char[src.length * 3];  //MAX_BUF_SIZE_DECOMPOSE = 3
+       int    destIndex = 0;
+       int    destLimit = dest.length;
+
+        int prevSrc;
+        String norm;
+        int reorderStartIndex, length;
+        char c1, c2;
+        int cp;
+        int minNoMaybe = 0x00c0;
+        int cc, prevCC, trailCC;
+        char[] p;
+        int pStart;
+
+        // initialize
+        reorderStartIndex = 0;
+        prevCC = 0;
+        norm = null;
+        cp = 0;
+        pStart = 0;
+
+        cc = trailCC = -1; // initialize to bogus value
+        c1 = 0;
+        for (;;) {
+            prevSrc=srcIndex;
+            //quick check (1)less than minNoMaybe (2)no decomp (3)hangual
+            while (srcIndex != srcLimit &&
+                   ((c1 = src[srcIndex]) < minNoMaybe ||
+                    (norm = impl.getDecomposition(cp = string.codePointAt(srcIndex))) == null ||
+                    (c1 >= '\uac00' && c1 <= '\ud7a3'))) { // Hangul Syllables
+                prevCC = 0;
+                srcIndex += (cp < 0x10000) ? 1 : 2;
+            }
+
+            // copy these code units all at once
+            if (srcIndex != prevSrc) {
+                length = srcIndex - prevSrc;
+                if ((destIndex + length) <= destLimit) {
+                    System.arraycopy(src,prevSrc,dest,destIndex,length);
+                }
+
+                destIndex += length;
+                reorderStartIndex = destIndex;
+            }
+
+            // end of source reached?
+            if (srcIndex == srcLimit) {
+                break;
+            }
+
+            // cp already contains *src and norm32 is set for it, increment src
+            srcIndex += (cp < 0x10000) ? 1 : 2;
+
+            if (cp < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
+                c2 = 0;
+                length = 1;
+
+                if (Character.isHighSurrogate(c1)
+                    || Character.isLowSurrogate(c1)) {
+                    norm = null;
+                }
+            } else {
+                length = 2;
+                c2 = src[srcIndex-1];
+            }
+
+          // get the decomposition and the lead and trail cc's
+          if (norm == null) {
+              // cp does not decompose
+              cc = trailCC = UCharacter.getCombiningClass(cp);
+              p = null;
+              pStart = -1;
+          } else {
+
+                pStart = 0;
+                p = norm.toCharArray();
+                length = p.length;
+                int cpNum = norm.codePointCount(0, length);
+                cc= UCharacter.getCombiningClass(norm.codePointAt(0));
+                trailCC= UCharacter.getCombiningClass(norm.codePointAt(cpNum-1));
+                if (length == 1) {
+                    // fastpath a single code unit from decomposition
+                    c1 = p[pStart];
+                    c2 = 0;
+                    p = null;
+                    pStart = -1;
+                }
+            }
+
+            if((destIndex + length * 3) >= destLimit) {  // 2 SingleQuotations
+                // buffer overflow
+                char[] tmpBuf = new char[destLimit * 2];
+                System.arraycopy(dest, 0, tmpBuf, 0, destIndex);
+                dest = tmpBuf;
+                destLimit = dest.length;
+            }
+
+            // append the decomposition to the destination buffer, assume length>0
+            {
+                int reorderSplit = destIndex;
+                if (p == null) {
+                    // fastpath: single code point
+                    if (needSingleQuotation(c1)) {
+                        //if we need single quotation, no need to consider "prevCC"
+                        //and it must NOT be a supplementary pair
+                        dest[destIndex++] = '\'';
+                        dest[destIndex++] = c1;
+                        dest[destIndex++] = '\'';
+                        trailCC = 0;
+                    } else if(cc != 0 && cc < prevCC) {
+                        // (c1, c2) is out of order with respect to the preceding
+                        //  text
+                        destIndex += length;
+                        trailCC = insertOrdered(dest, reorderStartIndex,
+                                                reorderSplit, destIndex, c1, c2, cc);
+                    } else {
+                        // just append (c1, c2)
+                        dest[destIndex++] = c1;
+                        if(c2 != 0) {
+                            dest[destIndex++] = c2;
+                        }
+                    }
+                } else {
+                    // general: multiple code points (ordered by themselves)
+                    // from decomposition
+                    if (needSingleQuotation(p[pStart])) {
+                        dest[destIndex++] = '\'';
+                        dest[destIndex++] = p[pStart++];
+                        dest[destIndex++] = '\'';
+                        length--;
+                        do {
+                            dest[destIndex++] = p[pStart++];
+                        } while(--length > 0);
+                    } else if (cc != 0 && cc < prevCC) {
+                        destIndex += length;
+                        trailCC = mergeOrdered(dest, reorderStartIndex,
+                                               reorderSplit, p, pStart,
+                                               pStart+length);
+                    } else {
+                        // just append the decomposition
+                        do {
+                            dest[destIndex++] = p[pStart++];
+                        } while (--length > 0);
+                    }
+                }
+            }
+            prevCC = trailCC;
+            if(prevCC == 0) {
+                reorderStartIndex = destIndex;
+            }
+        }
+
+        return new String(dest, 0, destIndex);
+    }
+
+    /**
+     * simpler, single-character version of mergeOrdered() -
+     * bubble-insert one single code point into the preceding string
+     * which is already canonically ordered
+     * (c, c2) may or may not yet have been inserted at src[current]..src[p]
+     *
+     * it must be p=current+lengthof(c, c2) i.e. p=current+(c2==0 ? 1 : 2)
+     *
+     * before: src[start]..src[current] is already ordered, and
+     *         src[current]..src[p]     may or may not hold (c, c2) but
+     *                          must be exactly the same length as (c, c2)
+     * after: src[start]..src[p] is ordered
+     *
+     * @return the trailing combining class
+     */
+    private static int/*unsigned byte*/ insertOrdered(char[] source,
+                                                      int start,
+                                                      int current, int p,
+                                                      char c1, char c2,
+                                                      int/*unsigned byte*/ cc) {
+        int back, preBack;
+        int r;
+        int prevCC, trailCC=cc;
+
+        if (start<current && cc!=0) {
+            // search for the insertion point where cc>=prevCC
+            preBack=back=current;
+
+            PrevArgs prevArgs = new PrevArgs();
+            prevArgs.current  = current;
+            prevArgs.start    = start;
+            prevArgs.src      = source;
+            prevArgs.c1       = c1;
+            prevArgs.c2       = c2;
+
+            // get the prevCC
+            prevCC=getPrevCC(prevArgs);
+            preBack = prevArgs.current;
+
+            if(cc<prevCC) {
+                // this will be the last code point, so keep its cc
+                trailCC=prevCC;
+                back=preBack;
+                while(start<preBack) {
+                    prevCC=getPrevCC(prevArgs);
+                    preBack=prevArgs.current;
+                    if(cc>=prevCC) {
+                        break;
+                    }
+                    back=preBack;
+                }
+
+                // this is where we are right now with all these indicies:
+                // [start]..[pPreBack] 0..? code points that we can ignore
+                // [pPreBack]..[pBack] 0..1 code points with prevCC<=cc
+                // [pBack]..[current] 0..n code points with >cc, move up to insert (c, c2)
+                // [current]..[p]         1 code point (c, c2) with cc
+
+                // move the code units in between up
+                r=p;
+                do {
+                    source[--r]=source[--current];
+                } while (back!=current);
+            }
+        }
+
+        // insert (c1, c2)
+        source[current] = c1;
+        if (c2!=0) {
+            source[(current+1)] = c2;
+        }
+
+        // we know the cc of the last code point
+        return trailCC;
+    }
+    /**
+     * merge two UTF-16 string parts together
+     * to canonically order (order by combining classes) their concatenation
+     *
+     * the two strings may already be adjacent, so that the merging is done
+     * in-place if the two strings are not adjacent, then the buffer holding the
+     * first one must be large enough
+     * the second string may or may not be ordered in itself
+     *
+     * before: [start]..[current] is already ordered, and
+     *         [next]..[limit]    may be ordered in itself, but
+     *                          is not in relation to [start..current[
+     * after: [start..current+(limit-next)[ is ordered
+     *
+     * the algorithm is a simple bubble-sort that takes the characters from
+     * src[next++] and inserts them in correct combining class order into the
+     * preceding part of the string
+     *
+     * since this function is called much less often than the single-code point
+     * insertOrdered(), it just uses that for easier maintenance
+     *
+     * @return the trailing combining class
+     */
+    private static int /*unsigned byte*/ mergeOrdered(char[] source,
+                                                      int start,
+                                                      int current,
+                                                      char[] data,
+                                                        int next,
+                                                        int limit) {
+            int r;
+            int /*unsigned byte*/ cc, trailCC=0;
+            boolean adjacent;
+
+            adjacent= current==next;
+            NextCCArgs ncArgs = new NextCCArgs();
+            ncArgs.source = data;
+            ncArgs.next   = next;
+            ncArgs.limit  = limit;
+
+            if(start!=current) {
+
+                while(ncArgs.next<ncArgs.limit) {
+                    cc=getNextCC(ncArgs);
+                    if(cc==0) {
+                        // does not bubble back
+                        trailCC=0;
+                        if(adjacent) {
+                            current=ncArgs.next;
+                        } else {
+                            data[current++]=ncArgs.c1;
+                            if(ncArgs.c2!=0) {
+                                data[current++]=ncArgs.c2;
+                            }
+                        }
+                        break;
+                    } else {
+                        r=current+(ncArgs.c2==0 ? 1 : 2);
+                        trailCC=insertOrdered(source,start, current, r,
+                                              ncArgs.c1, ncArgs.c2, cc);
+                        current=r;
+                    }
+                }
+            }
+
+            if(ncArgs.next==ncArgs.limit) {
+                // we know the cc of the last code point
+                return trailCC;
+            } else {
+                if(!adjacent) {
+                    // copy the second string part
+                    do {
+                        source[current++]=data[ncArgs.next++];
+                    } while(ncArgs.next!=ncArgs.limit);
+                    ncArgs.limit=current;
+                }
+                PrevArgs prevArgs = new PrevArgs();
+                prevArgs.src   = data;
+                prevArgs.start = start;
+                prevArgs.current =  ncArgs.limit;
+                return getPrevCC(prevArgs);
+            }
+
+    }
+    private static final class PrevArgs{
+        char[] src;
+        int start;
+        int current;
+        char c1;
+        char c2;
+    }
+
+    private static final class NextCCArgs{
+        char[] source;
+        int next;
+        int limit;
+        char c1;
+        char c2;
+    }
+    private static int /*unsigned byte*/ getNextCC(NextCCArgs args) {
+        args.c1=args.source[args.next++];
+        args.c2=0;
+
+        if (UTF16.isTrailSurrogate(args.c1)) {
+            /* unpaired second surrogate */
+            return 0;
+        } else if (!UTF16.isLeadSurrogate(args.c1)) {
+            return UCharacter.getCombiningClass(args.c1);
+        } else if (args.next!=args.limit &&
+                        UTF16.isTrailSurrogate(args.c2=args.source[args.next])){
+            ++args.next;
+            return UCharacter.getCombiningClass(Character.toCodePoint(args.c1, args.c2));
+        } else {
+            /* unpaired first surrogate */
+            args.c2=0;
+            return 0;
+        }
+    }
+    private static int /*unsigned*/ getPrevCC(PrevArgs args) {
+        args.c1=args.src[--args.current];
+        args.c2=0;
+
+        if (args.c1 < MIN_CCC_LCCC_CP) {
+            return 0;
+        } else if (UTF16.isLeadSurrogate(args.c1)) {
+            /* unpaired first surrogate */
+            return 0;
+        } else if (!UTF16.isTrailSurrogate(args.c1)) {
+            return UCharacter.getCombiningClass(args.c1);
+        } else if (args.current!=args.start &&
+                    UTF16.isLeadSurrogate(args.c2=args.src[args.current-1])) {
+            --args.current;
+            return UCharacter.getCombiningClass(Character.toCodePoint(args.c2, args.c1));
+        } else {
+            /* unpaired second surrogate */
+            args.c2=0;
+            return 0;
+        }
+    }
+
+    private int getPreviousTrailCC(CharSequence s, int start, int p) {
+        if (start == p) {
+            return 0;
+        }
+        return getFCD16(Character.codePointBefore(s, p));
+    }
+
+    private VersionInfo dataVersion;
+
+    // BMP code point thresholds for quick check loops looking at single UTF-16 code units.
+    private int minDecompNoCP;
+    private int minCompNoMaybeCP;
+    private int minLcccCP;
+
+    // Norm16 value thresholds for quick check combinations and types of extra data.
+    private int minYesNo;
+    private int minYesNoMappingsOnly;
+    private int minNoNo;
+    private int minNoNoCompBoundaryBefore;
+    private int minNoNoCompNoMaybeCC;
+    private int minNoNoEmpty;
+    private int limitNoNo;
+    private int centerNoNoDelta;
+    private int minMaybeYes;
+
+    private CodePointTrie.Fast16 normTrie;
+    private String maybeYesCompositions;
+    private String extraData;  // mappings and/or compositions for yesYes, yesNo & noNo characters
+    private byte[] smallFCD;  // [0x100] one bit per 32 BMP code points, set if any FCD!=0
+}