--- old/src/java.base/share/classes/sun/net/idn/Punycode.java	2020-01-10 15:57:32.000000000 -0800
+++ /dev/null	2020-01-10 15:57:32.000000000 -0800
@@ -1,511 +0,0 @@
-/*
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-/*
- *******************************************************************************
- * Copyright (C) 2003-2004, International Business Machines Corporation and    *
- * others. All Rights Reserved.                                                *
- *******************************************************************************
- */
-//
-// CHANGELOG
-//      2005-05-19 Edward Wang
-//          - copy this file from icu4jsrc_3_2/src/com/ibm/icu/text/Punycode.java
-//          - move from package com.ibm.icu.text to package sun.net.idn
-//          - use ParseException instead of StringPrepParseException
-//      2007-08-14 Martin Buchholz
-//          - remove redundant casts
-//
-package sun.net.idn;
-
-import java.text.ParseException;
-import sun.text.normalizer.UCharacter;
-import sun.text.normalizer.UTF16;
-
-/**
- * Ported code from ICU punycode.c
- * @author ram
- */
-
-/* Package Private class */
-public final class Punycode {
-
-    /* Punycode parameters for Bootstring */
-    private static final int BASE           = 36;
-    private static final int TMIN           = 1;
-    private static final int TMAX           = 26;
-    private static final int SKEW           = 38;
-    private static final int DAMP           = 700;
-    private static final int INITIAL_BIAS   = 72;
-    private static final int INITIAL_N      = 0x80;
-
-    /* "Basic" Unicode/ASCII code points */
-    private static final int HYPHEN         = 0x2d;
-    private static final int DELIMITER      = HYPHEN;
-
-    private static final int ZERO           = 0x30;
-    private static final int NINE           = 0x39;
-
-    private static final int SMALL_A        = 0x61;
-    private static final int SMALL_Z        = 0x7a;
-
-    private static final int CAPITAL_A      = 0x41;
-    private static final int CAPITAL_Z      = 0x5a;
-
-    //  TODO: eliminate the 256 limitation
-    private static final int MAX_CP_COUNT   = 256;
-
-    private static final int UINT_MAGIC     = 0x80000000;
-    private static final long ULONG_MAGIC   = 0x8000000000000000L;
-
-    private static int adaptBias(int delta, int length, boolean firstTime){
-        if(firstTime){
-            delta /=DAMP;
-        }else{
-            delta /=  2;
-        }
-        delta += delta/length;
-
-        int count=0;
-        for(; delta>((BASE-TMIN)*TMAX)/2; count+=BASE) {
-            delta/=(BASE-TMIN);
-        }
-
-        return count+(((BASE-TMIN+1)*delta)/(delta+SKEW));
-    }
-
-    /**
-     * basicToDigit[] contains the numeric value of a basic code
-     * point (for use in representing integers) in the range 0 to
-     * BASE-1, or -1 if b is does not represent a value.
-     */
-    static final int[]    basicToDigit= new int[]{
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
-
-        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-
-        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-    };
-
-    private static char asciiCaseMap(char b, boolean uppercase) {
-        if(uppercase) {
-            if(SMALL_A<=b && b<=SMALL_Z) {
-                b-=(SMALL_A-CAPITAL_A);
-            }
-        } else {
-            if(CAPITAL_A<=b && b<=CAPITAL_Z) {
-                b+=(SMALL_A-CAPITAL_A);
-            }
-        }
-        return b;
-    }
-
-    /**
-     * digitToBasic() returns the basic code point whose value
-     * (when used for representing integers) is d, which must be in the
-     * range 0 to BASE-1. The lowercase form is used unless the uppercase flag is
-     * nonzero, in which case the uppercase form is used.
-     */
-    private static char digitToBasic(int digit, boolean uppercase) {
-        /*  0..25 map to ASCII a..z or A..Z */
-        /* 26..35 map to ASCII 0..9         */
-        if(digit<26) {
-            if(uppercase) {
-                return (char)(CAPITAL_A+digit);
-            } else {
-                return (char)(SMALL_A+digit);
-            }
-        } else {
-            return (char)((ZERO-26)+digit);
-        }
-    }
-    /**
-     * Converts Unicode to Punycode.
-     * The input string must not contain single, unpaired surrogates.
-     * The output will be represented as an array of ASCII code points.
-     *
-     * @param src
-     * @param caseFlags
-     * @return
-     * @throws ParseException
-     */
-    public static StringBuffer encode(StringBuffer src, boolean[] caseFlags) throws ParseException{
-
-        int[] cpBuffer = new int[MAX_CP_COUNT];
-        int n, delta, handledCPCount, basicLength, destLength, bias, j, m, q, k, t, srcCPCount;
-        char c, c2;
-        int srcLength = src.length();
-        int destCapacity = MAX_CP_COUNT;
-        char[] dest = new char[destCapacity];
-        StringBuffer result = new StringBuffer();
-        /*
-         * Handle the basic code points and
-         * convert extended ones to UTF-32 in cpBuffer (caseFlag in sign bit):
-         */
-        srcCPCount=destLength=0;
-
-        for(j=0; j<srcLength; ++j) {
-            if(srcCPCount==MAX_CP_COUNT) {
-                /* too many input code points */
-                throw new IndexOutOfBoundsException();
-            }
-            c=src.charAt(j);
-            if(isBasic(c)) {
-                if(destLength<destCapacity) {
-                    cpBuffer[srcCPCount++]=0;
-                    dest[destLength]=
-                        caseFlags!=null ?
-                            asciiCaseMap(c, caseFlags[j]) :
-                            c;
-                }
-                ++destLength;
-            } else {
-                n=((caseFlags!=null && caseFlags[j])? 1 : 0)<<31L;
-                if(!UTF16.isSurrogate(c)) {
-                    n|=c;
-                } else if(UTF16.isLeadSurrogate(c) && (j+1)<srcLength && UTF16.isTrailSurrogate(c2=src.charAt(j+1))) {
-                    ++j;
-
-                    n|=UCharacter.getCodePoint(c, c2);
-                } else {
-                    /* error: unmatched surrogate */
-                    throw new ParseException("Illegal char found", -1);
-                }
-                cpBuffer[srcCPCount++]=n;
-            }
-        }
-
-        /* Finish the basic string - if it is not empty - with a delimiter. */
-        basicLength=destLength;
-        if(basicLength>0) {
-            if(destLength<destCapacity) {
-                dest[destLength]=DELIMITER;
-            }
-            ++destLength;
-        }
-
-        /*
-         * handledCPCount is the number of code points that have been handled
-         * basicLength is the number of basic code points
-         * destLength is the number of chars that have been output
-         */
-
-        /* Initialize the state: */
-        n=INITIAL_N;
-        delta=0;
-        bias=INITIAL_BIAS;
-
-        /* Main encoding loop: */
-        for(handledCPCount=basicLength; handledCPCount<srcCPCount; /* no op */) {
-            /*
-             * All non-basic code points < n have been handled already.
-             * Find the next larger one:
-             */
-            for(m=0x7fffffff, j=0; j<srcCPCount; ++j) {
-                q=cpBuffer[j]&0x7fffffff; /* remove case flag from the sign bit */
-                if(n<=q && q<m) {
-                    m=q;
-                }
-            }
-
-            /*
-             * Increase delta enough to advance the decoder's
-             * <n,i> state to <m,0>, but guard against overflow:
-             */
-            if(m-n>(0x7fffffff-MAX_CP_COUNT-delta)/(handledCPCount+1)) {
-                throw new RuntimeException("Internal program error");
-            }
-            delta+=(m-n)*(handledCPCount+1);
-            n=m;
-
-            /* Encode a sequence of same code points n */
-            for(j=0; j<srcCPCount; ++j) {
-                q=cpBuffer[j]&0x7fffffff; /* remove case flag from the sign bit */
-                if(q<n) {
-                    ++delta;
-                } else if(q==n) {
-                    /* Represent delta as a generalized variable-length integer: */
-                    for(q=delta, k=BASE; /* no condition */; k+=BASE) {
-
-                        /** RAM: comment out the old code for conformance with draft-ietf-idn-punycode-03.txt
-
-                        t=k-bias;
-                        if(t<TMIN) {
-                            t=TMIN;
-                        } else if(t>TMAX) {
-                            t=TMAX;
-                        }
-                        */
-
-                        t=k-bias;
-                        if(t<TMIN) {
-                            t=TMIN;
-                        } else if(k>=(bias+TMAX)) {
-                            t=TMAX;
-                        }
-
-                        if(q<t) {
-                            break;
-                        }
-
-                        if(destLength<destCapacity) {
-                            dest[destLength++]=digitToBasic(t+(q-t)%(BASE-t), false);
-                        }
-                        q=(q-t)/(BASE-t);
-                    }
-
-                    if(destLength<destCapacity) {
-                        dest[destLength++]=digitToBasic(q, (cpBuffer[j]<0));
-                    }
-                    bias=adaptBias(delta, handledCPCount+1,(handledCPCount==basicLength));
-                    delta=0;
-                    ++handledCPCount;
-                }
-            }
-
-            ++delta;
-            ++n;
-        }
-
-        return result.append(dest, 0, destLength);
-    }
-
-    private static boolean isBasic(int ch){
-        return (ch < INITIAL_N);
-    }
-
-    private static boolean isBasicUpperCase(int ch){
-        return( CAPITAL_A <= ch && ch <= CAPITAL_Z);
-    }
-
-    private static boolean isSurrogate(int ch){
-        return (((ch)&0xfffff800)==0xd800);
-    }
-    /**
-     * Converts Punycode to Unicode.
-     * The Unicode string will be at most as long as the Punycode string.
-     *
-     * @param src
-     * @param caseFlags
-     * @return
-     * @throws ParseException
-     */
-    public static StringBuffer decode(StringBuffer src, boolean[] caseFlags)
-                               throws ParseException{
-        int srcLength = src.length();
-        StringBuffer result = new StringBuffer();
-        int n, destLength, i, bias, basicLength, j, in, oldi, w, k, digit, t,
-                destCPCount, firstSupplementaryIndex, cpLength;
-        char b;
-        int destCapacity = MAX_CP_COUNT;
-        char[] dest = new char[destCapacity];
-
-        /*
-         * Handle the basic code points:
-         * Let basicLength be the number of input code points
-         * before the last delimiter, or 0 if there is none,
-         * then copy the first basicLength code points to the output.
-         *
-         * The two following loops iterate backward.
-         */
-        for(j=srcLength; j>0;) {
-            if(src.charAt(--j)==DELIMITER) {
-                break;
-            }
-        }
-        destLength=basicLength=destCPCount=j;
-
-        while(j>0) {
-            b=src.charAt(--j);
-            if(!isBasic(b)) {
-                throw new ParseException("Illegal char found", -1);
-            }
-
-            if(j<destCapacity) {
-                dest[j]= b;
-
-                if(caseFlags!=null) {
-                    caseFlags[j]=isBasicUpperCase(b);
-                }
-            }
-        }
-
-        /* Initialize the state: */
-        n=INITIAL_N;
-        i=0;
-        bias=INITIAL_BIAS;
-        firstSupplementaryIndex=1000000000;
-
-        /*
-         * Main decoding loop:
-         * Start just after the last delimiter if any
-         * basic code points were copied; start at the beginning otherwise.
-         */
-        for(in=basicLength>0 ? basicLength+1 : 0; in<srcLength; /* no op */) {
-            /*
-             * in is the index of the next character to be consumed, and
-             * destCPCount is the number of code points in the output array.
-             *
-             * Decode a generalized variable-length integer into delta,
-             * which gets added to i.  The overflow checking is easier
-             * if we increase i as we go, then subtract off its starting
-             * value at the end to obtain delta.
-             */
-            for(oldi=i, w=1, k=BASE; /* no condition */; k+=BASE) {
-                if(in>=srcLength) {
-                    throw new ParseException("Illegal char found", -1);
-                }
-
-                digit=basicToDigit[(byte)src.charAt(in++)];
-                if(digit<0) {
-                    throw new ParseException("Invalid char found", -1);
-                }
-                if(digit>(0x7fffffff-i)/w) {
-                    /* integer overflow */
-                    throw new ParseException("Illegal char found", -1);
-                }
-
-                i+=digit*w;
-                t=k-bias;
-                if(t<TMIN) {
-                    t=TMIN;
-                } else if(k>=(bias+TMAX)) {
-                    t=TMAX;
-                }
-                if(digit<t) {
-                    break;
-                }
-
-                if(w>0x7fffffff/(BASE-t)) {
-                    /* integer overflow */
-                    throw new ParseException("Illegal char found", -1);
-                }
-                w*=BASE-t;
-            }
-
-            /*
-             * Modification from sample code:
-             * Increments destCPCount here,
-             * where needed instead of in for() loop tail.
-             */
-            ++destCPCount;
-            bias=adaptBias(i-oldi, destCPCount, (oldi==0));
-
-            /*
-             * i was supposed to wrap around from (incremented) destCPCount to 0,
-             * incrementing n each time, so we'll fix that now:
-             */
-            if(i/destCPCount>(0x7fffffff-n)) {
-                /* integer overflow */
-                throw new ParseException("Illegal char found", -1);
-            }
-
-            n+=i/destCPCount;
-            i%=destCPCount;
-            /* not needed for Punycode: */
-            /* if (decode_digit(n) <= BASE) return punycode_invalid_input; */
-
-            if(n>0x10ffff || isSurrogate(n)) {
-                /* Unicode code point overflow */
-                throw new ParseException("Illegal char found", -1);
-            }
-
-            /* Insert n at position i of the output: */
-            cpLength=UTF16.getCharCount(n);
-            if((destLength+cpLength)<destCapacity) {
-                int codeUnitIndex;
-
-                /*
-                 * Handle indexes when supplementary code points are present.
-                 *
-                 * In almost all cases, there will be only BMP code points before i
-                 * and even in the entire string.
-                 * This is handled with the same efficiency as with UTF-32.
-                 *
-                 * Only the rare cases with supplementary code points are handled
-                 * more slowly - but not too bad since this is an insertion anyway.
-                 */
-                if(i<=firstSupplementaryIndex) {
-                    codeUnitIndex=i;
-                    if(cpLength>1) {
-                        firstSupplementaryIndex=codeUnitIndex;
-                    } else {
-                        ++firstSupplementaryIndex;
-                    }
-                } else {
-                    codeUnitIndex=firstSupplementaryIndex;
-                    codeUnitIndex=UTF16.moveCodePointOffset(dest, 0, destLength, codeUnitIndex, i-codeUnitIndex);
-                }
-
-                /* use the UChar index codeUnitIndex instead of the code point index i */
-                if(codeUnitIndex<destLength) {
-                    System.arraycopy(dest, codeUnitIndex,
-                                     dest, codeUnitIndex+cpLength,
-                                    (destLength-codeUnitIndex));
-                    if(caseFlags!=null) {
-                        System.arraycopy(caseFlags, codeUnitIndex,
-                                         caseFlags, codeUnitIndex+cpLength,
-                                         destLength-codeUnitIndex);
-                    }
-                }
-                if(cpLength==1) {
-                    /* BMP, insert one code unit */
-                    dest[codeUnitIndex]=(char)n;
-                } else {
-                    /* supplementary character, insert two code units */
-                    dest[codeUnitIndex]=UTF16.getLeadSurrogate(n);
-                    dest[codeUnitIndex+1]=UTF16.getTrailSurrogate(n);
-                }
-                if(caseFlags!=null) {
-                    /* Case of last character determines uppercase flag: */
-                    caseFlags[codeUnitIndex]=isBasicUpperCase(src.charAt(in-1));
-                    if(cpLength==2) {
-                        caseFlags[codeUnitIndex+1]=false;
-                    }
-                }
-            }
-            destLength+=cpLength;
-            ++i;
-        }
-        result.append(dest, 0, destLength);
-        return result;
-    }
-}
--- /dev/null	2020-01-10 15:57:32.000000000 -0800
+++ new/src/java.base/share/classes/jdk/internal/icu/impl/Punycode.java	2020-01-10 15:57:32.000000000 -0800
@@ -0,0 +1,512 @@
+/*
+ * Copyright (c) 2005, 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) 2003-2004, International Business Machines Corporation and    *
+ * others. All Rights Reserved.                                                *
+ *******************************************************************************
+ */
+//
+// CHANGELOG
+//      2005-05-19 Edward Wang
+//          - copy this file from icu4jsrc_3_2/src/com/ibm/icu/text/Punycode.java
+//          - move from package com.ibm.icu.text to package sun.net.idn
+//          - use ParseException instead of StringPrepParseException
+//      2007-08-14 Martin Buchholz
+//          - remove redundant casts
+//
+package jdk.internal.icu.impl;
+
+import java.text.ParseException;
+import jdk.internal.icu.lang.UCharacter;
+import jdk.internal.icu.text.UTF16;
+
+/**
+ * Ported code from ICU punycode.c
+ * @author ram
+ */
+
+/* Package Private class */
+public final class Punycode {
+
+    /* Punycode parameters for Bootstring */
+    private static final int BASE           = 36;
+    private static final int TMIN           = 1;
+    private static final int TMAX           = 26;
+    private static final int SKEW           = 38;
+    private static final int DAMP           = 700;
+    private static final int INITIAL_BIAS   = 72;
+    private static final int INITIAL_N      = 0x80;
+
+    /* "Basic" Unicode/ASCII code points */
+    private static final int HYPHEN         = 0x2d;
+    private static final int DELIMITER      = HYPHEN;
+
+    private static final int ZERO           = 0x30;
+    private static final int NINE           = 0x39;
+
+    private static final int SMALL_A        = 0x61;
+    private static final int SMALL_Z        = 0x7a;
+
+    private static final int CAPITAL_A      = 0x41;
+    private static final int CAPITAL_Z      = 0x5a;
+
+    //  TODO: eliminate the 256 limitation
+    private static final int MAX_CP_COUNT   = 256;
+
+    private static final int UINT_MAGIC     = 0x80000000;
+    private static final long ULONG_MAGIC   = 0x8000000000000000L;
+
+    private static int adaptBias(int delta, int length, boolean firstTime){
+        if(firstTime){
+            delta /=DAMP;
+        }else{
+            delta /=  2;
+        }
+        delta += delta/length;
+
+        int count=0;
+        for(; delta>((BASE-TMIN)*TMAX)/2; count+=BASE) {
+            delta/=(BASE-TMIN);
+        }
+
+        return count+(((BASE-TMIN+1)*delta)/(delta+SKEW));
+    }
+
+    /**
+     * basicToDigit[] contains the numeric value of a basic code
+     * point (for use in representing integers) in the range 0 to
+     * BASE-1, or -1 if b is does not represent a value.
+     */
+    static final int[]    basicToDigit= new int[]{
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
+
+        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+
+        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+    };
+
+    private static char asciiCaseMap(char b, boolean uppercase) {
+        if(uppercase) {
+            if(SMALL_A<=b && b<=SMALL_Z) {
+                b-=(SMALL_A-CAPITAL_A);
+            }
+        } else {
+            if(CAPITAL_A<=b && b<=CAPITAL_Z) {
+                b+=(SMALL_A-CAPITAL_A);
+            }
+        }
+        return b;
+    }
+
+    /**
+     * digitToBasic() returns the basic code point whose value
+     * (when used for representing integers) is d, which must be in the
+     * range 0 to BASE-1. The lowercase form is used unless the uppercase flag is
+     * nonzero, in which case the uppercase form is used.
+     */
+    private static char digitToBasic(int digit, boolean uppercase) {
+        /*  0..25 map to ASCII a..z or A..Z */
+        /* 26..35 map to ASCII 0..9         */
+        if(digit<26) {
+            if(uppercase) {
+                return (char)(CAPITAL_A+digit);
+            } else {
+                return (char)(SMALL_A+digit);
+            }
+        } else {
+            return (char)((ZERO-26)+digit);
+        }
+    }
+    /**
+     * Converts Unicode to Punycode.
+     * The input string must not contain single, unpaired surrogates.
+     * The output will be represented as an array of ASCII code points.
+     *
+     * @param src
+     * @param caseFlags
+     * @return
+     * @throws ParseException
+     */
+    public static StringBuffer encode(StringBuffer src, boolean[] caseFlags) throws ParseException{
+
+        int[] cpBuffer = new int[MAX_CP_COUNT];
+        int n, delta, handledCPCount, basicLength, destLength, bias, j, m, q, k, t, srcCPCount;
+        char c, c2;
+        int srcLength = src.length();
+        int destCapacity = MAX_CP_COUNT;
+        char[] dest = new char[destCapacity];
+        StringBuffer result = new StringBuffer();
+        /*
+         * Handle the basic code points and
+         * convert extended ones to UTF-32 in cpBuffer (caseFlag in sign bit):
+         */
+        srcCPCount=destLength=0;
+
+        for(j=0; j<srcLength; ++j) {
+            if(srcCPCount==MAX_CP_COUNT) {
+                /* too many input code points */
+                throw new IndexOutOfBoundsException();
+            }
+            c=src.charAt(j);
+            if(isBasic(c)) {
+                if(destLength<destCapacity) {
+                    cpBuffer[srcCPCount++]=0;
+                    dest[destLength]=
+                        caseFlags!=null ?
+                            asciiCaseMap(c, caseFlags[j]) :
+                            c;
+                }
+                ++destLength;
+            } else {
+                n=((caseFlags!=null && caseFlags[j])? 1 : 0)<<31L;
+                if(!UTF16.isSurrogate(c)) {
+                    n|=c;
+                } else if(UTF16.isLeadSurrogate(c) && (j+1)<srcLength && UTF16.isTrailSurrogate(c2=src.charAt(j+1))) {
+                    ++j;
+
+                    n|=UCharacter.getCodePoint(c, c2);
+                } else {
+                    /* error: unmatched surrogate */
+                    throw new ParseException("Illegal char found", -1);
+                }
+                cpBuffer[srcCPCount++]=n;
+            }
+        }
+
+        /* Finish the basic string - if it is not empty - with a delimiter. */
+        basicLength=destLength;
+        if(basicLength>0) {
+            if(destLength<destCapacity) {
+                dest[destLength]=DELIMITER;
+            }
+            ++destLength;
+        }
+
+        /*
+         * handledCPCount is the number of code points that have been handled
+         * basicLength is the number of basic code points
+         * destLength is the number of chars that have been output
+         */
+
+        /* Initialize the state: */
+        n=INITIAL_N;
+        delta=0;
+        bias=INITIAL_BIAS;
+
+        /* Main encoding loop: */
+        for(handledCPCount=basicLength; handledCPCount<srcCPCount; /* no op */) {
+            /*
+             * All non-basic code points < n have been handled already.
+             * Find the next larger one:
+             */
+            for(m=0x7fffffff, j=0; j<srcCPCount; ++j) {
+                q=cpBuffer[j]&0x7fffffff; /* remove case flag from the sign bit */
+                if(n<=q && q<m) {
+                    m=q;
+                }
+            }
+
+            /*
+             * Increase delta enough to advance the decoder's
+             * <n,i> state to <m,0>, but guard against overflow:
+             */
+            if(m-n>(0x7fffffff-MAX_CP_COUNT-delta)/(handledCPCount+1)) {
+                throw new RuntimeException("Internal program error");
+            }
+            delta+=(m-n)*(handledCPCount+1);
+            n=m;
+
+            /* Encode a sequence of same code points n */
+            for(j=0; j<srcCPCount; ++j) {
+                q=cpBuffer[j]&0x7fffffff; /* remove case flag from the sign bit */
+                if(q<n) {
+                    ++delta;
+                } else if(q==n) {
+                    /* Represent delta as a generalized variable-length integer: */
+                    for(q=delta, k=BASE; /* no condition */; k+=BASE) {
+
+                        /** RAM: comment out the old code for conformance with draft-ietf-idn-punycode-03.txt
+
+                        t=k-bias;
+                        if(t<TMIN) {
+                            t=TMIN;
+                        } else if(t>TMAX) {
+                            t=TMAX;
+                        }
+                        */
+
+                        t=k-bias;
+                        if(t<TMIN) {
+                            t=TMIN;
+                        } else if(k>=(bias+TMAX)) {
+                            t=TMAX;
+                        }
+
+                        if(q<t) {
+                            break;
+                        }
+
+                        if(destLength<destCapacity) {
+                            dest[destLength++]=digitToBasic(t+(q-t)%(BASE-t), false);
+                        }
+                        q=(q-t)/(BASE-t);
+                    }
+
+                    if(destLength<destCapacity) {
+                        dest[destLength++]=digitToBasic(q, (cpBuffer[j]<0));
+                    }
+                    bias=adaptBias(delta, handledCPCount+1,(handledCPCount==basicLength));
+                    delta=0;
+                    ++handledCPCount;
+                }
+            }
+
+            ++delta;
+            ++n;
+        }
+
+        return result.append(dest, 0, destLength);
+    }
+
+    private static boolean isBasic(int ch){
+        return (ch < INITIAL_N);
+    }
+
+    private static boolean isBasicUpperCase(int ch){
+        return( CAPITAL_A <= ch && ch <= CAPITAL_Z);
+    }
+
+    private static boolean isSurrogate(int ch){
+        return (((ch)&0xfffff800)==0xd800);
+    }
+    /**
+     * Converts Punycode to Unicode.
+     * The Unicode string will be at most as long as the Punycode string.
+     *
+     * @param src
+     * @param caseFlags
+     * @return
+     * @throws ParseException
+     */
+    public static StringBuffer decode(StringBuffer src, boolean[] caseFlags)
+                               throws ParseException{
+        int srcLength = src.length();
+        StringBuffer result = new StringBuffer();
+        int n, destLength, i, bias, basicLength, j, in, oldi, w, k, digit, t,
+                destCPCount, firstSupplementaryIndex, cpLength;
+        char b;
+        int destCapacity = MAX_CP_COUNT;
+        char[] dest = new char[destCapacity];
+
+        /*
+         * Handle the basic code points:
+         * Let basicLength be the number of input code points
+         * before the last delimiter, or 0 if there is none,
+         * then copy the first basicLength code points to the output.
+         *
+         * The two following loops iterate backward.
+         */
+        for(j=srcLength; j>0;) {
+            if(src.charAt(--j)==DELIMITER) {
+                break;
+            }
+        }
+        destLength=basicLength=destCPCount=j;
+
+        while(j>0) {
+            b=src.charAt(--j);
+            if(!isBasic(b)) {
+                throw new ParseException("Illegal char found", -1);
+            }
+
+            if(j<destCapacity) {
+                dest[j]= b;
+
+                if(caseFlags!=null) {
+                    caseFlags[j]=isBasicUpperCase(b);
+                }
+            }
+        }
+
+        /* Initialize the state: */
+        n=INITIAL_N;
+        i=0;
+        bias=INITIAL_BIAS;
+        firstSupplementaryIndex=1000000000;
+
+        /*
+         * Main decoding loop:
+         * Start just after the last delimiter if any
+         * basic code points were copied; start at the beginning otherwise.
+         */
+        for(in=basicLength>0 ? basicLength+1 : 0; in<srcLength; /* no op */) {
+            /*
+             * in is the index of the next character to be consumed, and
+             * destCPCount is the number of code points in the output array.
+             *
+             * Decode a generalized variable-length integer into delta,
+             * which gets added to i.  The overflow checking is easier
+             * if we increase i as we go, then subtract off its starting
+             * value at the end to obtain delta.
+             */
+            for(oldi=i, w=1, k=BASE; /* no condition */; k+=BASE) {
+                if(in>=srcLength) {
+                    throw new ParseException("Illegal char found", -1);
+                }
+
+                digit=basicToDigit[(byte)src.charAt(in++)];
+                if(digit<0) {
+                    throw new ParseException("Invalid char found", -1);
+                }
+                if(digit>(0x7fffffff-i)/w) {
+                    /* integer overflow */
+                    throw new ParseException("Illegal char found", -1);
+                }
+
+                i+=digit*w;
+                t=k-bias;
+                if(t<TMIN) {
+                    t=TMIN;
+                } else if(k>=(bias+TMAX)) {
+                    t=TMAX;
+                }
+                if(digit<t) {
+                    break;
+                }
+
+                if(w>0x7fffffff/(BASE-t)) {
+                    /* integer overflow */
+                    throw new ParseException("Illegal char found", -1);
+                }
+                w*=BASE-t;
+            }
+
+            /*
+             * Modification from sample code:
+             * Increments destCPCount here,
+             * where needed instead of in for() loop tail.
+             */
+            ++destCPCount;
+            bias=adaptBias(i-oldi, destCPCount, (oldi==0));
+
+            /*
+             * i was supposed to wrap around from (incremented) destCPCount to 0,
+             * incrementing n each time, so we'll fix that now:
+             */
+            if(i/destCPCount>(0x7fffffff-n)) {
+                /* integer overflow */
+                throw new ParseException("Illegal char found", -1);
+            }
+
+            n+=i/destCPCount;
+            i%=destCPCount;
+            /* not needed for Punycode: */
+            /* if (decode_digit(n) <= BASE) return punycode_invalid_input; */
+
+            if(n>0x10ffff || isSurrogate(n)) {
+                /* Unicode code point overflow */
+                throw new ParseException("Illegal char found", -1);
+            }
+
+            /* Insert n at position i of the output: */
+            cpLength=UTF16.getCharCount(n);
+            if((destLength+cpLength)<destCapacity) {
+                int codeUnitIndex;
+
+                /*
+                 * Handle indexes when supplementary code points are present.
+                 *
+                 * In almost all cases, there will be only BMP code points before i
+                 * and even in the entire string.
+                 * This is handled with the same efficiency as with UTF-32.
+                 *
+                 * Only the rare cases with supplementary code points are handled
+                 * more slowly - but not too bad since this is an insertion anyway.
+                 */
+                if(i<=firstSupplementaryIndex) {
+                    codeUnitIndex=i;
+                    if(cpLength>1) {
+                        firstSupplementaryIndex=codeUnitIndex;
+                    } else {
+                        ++firstSupplementaryIndex;
+                    }
+                } else {
+                    codeUnitIndex=firstSupplementaryIndex;
+                    codeUnitIndex=UTF16.moveCodePointOffset(dest, 0, destLength, codeUnitIndex, i-codeUnitIndex);
+                }
+
+                /* use the UChar index codeUnitIndex instead of the code point index i */
+                if(codeUnitIndex<destLength) {
+                    System.arraycopy(dest, codeUnitIndex,
+                                     dest, codeUnitIndex+cpLength,
+                                    (destLength-codeUnitIndex));
+                    if(caseFlags!=null) {
+                        System.arraycopy(caseFlags, codeUnitIndex,
+                                         caseFlags, codeUnitIndex+cpLength,
+                                         destLength-codeUnitIndex);
+                    }
+                }
+                if(cpLength==1) {
+                    /* BMP, insert one code unit */
+                    dest[codeUnitIndex]=(char)n;
+                } else {
+                    /* supplementary character, insert two code units */
+                    dest[codeUnitIndex]=UTF16.getLeadSurrogate(n);
+                    dest[codeUnitIndex+1]=UTF16.getTrailSurrogate(n);
+                }
+                if(caseFlags!=null) {
+                    /* Case of last character determines uppercase flag: */
+                    caseFlags[codeUnitIndex]=isBasicUpperCase(src.charAt(in-1));
+                    if(cpLength==2) {
+                        caseFlags[codeUnitIndex+1]=false;
+                    }
+                }
+            }
+            destLength+=cpLength;
+            ++i;
+        }
+        result.append(dest, 0, destLength);
+        return result;
+    }
+}