1                + 256 * 0x39,  /*0x062F*/        1                + 256 * 0x3B,  /*0x0630*/        1                + 256 * 0x3D,  /*0x0631*/        1                + 256 * 0x3F,  /*0x0632*/        1 + 2            + 256 * 0x41,  /*0x0633*/        1 + 2            + 256 * 0x45,  /*0x0634*/        1 + 2            + 256 * 0x49,  /*0x0635*/        1 + 2            + 256 * 0x4D,  /*0x0636*/        1 + 2            + 256 * 0x51,  /*0x0637*/        1 + 2            + 256 * 0x55,  /*0x0638*/        1 + 2            + 256 * 0x59,  /*0x0639*/        1 + 2            + 256 * 0x5D,  /*0x063A*/        0, 0, 0, 0, 0,                  /*0x063B-0x063F*/        1 + 2,                          /*0x0640*/        1 + 2            + 256 * 0x61,  /*0x0641*/        1 + 2            + 256 * 0x65,  /*0x0642*/        1 + 2            + 256 * 0x69,  /*0x0643*/        1 + 2       + 16 + 256 * 0x6D,  /*0x0644*/        1 + 2            + 256 * 0x71,  /*0x0645*/        1 + 2            + 256 * 0x75,  /*0x0646*/        1 + 2            + 256 * 0x79,  /*0x0647*/        1                + 256 * 0x7D,  /*0x0648*/        1                + 256 * 0x7F,  /*0x0649*/        1 + 2            + 256 * 0x81,  /*0x064A*/        4, 4, 4, 4,                     /*0x064B-0x064E*/        4, 4, 4, 4,                     /*0x064F-0x0652*/        4, 4, 4, 0, 0,                  /*0x0653-0x0657*/        0, 0, 0, 0,                     /*0x0658-0x065B*/        1                + 256 * 0x85,  /*0x065C*/        1                + 256 * 0x87,  /*0x065D*/        1                + 256 * 0x89,  /*0x065E*/        1                + 256 * 0x8B,  /*0x065F*/        0, 0, 0, 0, 0,                  /*0x0660-0x0664*/        0, 0, 0, 0, 0,                  /*0x0665-0x0669*/        0, 0, 0, 0, 0, 0,               /*0x066A-0x066F*/        4,                              /*0x0670*/        0,                              /*0x0671*/        1           + 32,               /*0x0672*/        1           + 32,               /*0x0673*/        0,                              /*0x0674*/        1           + 32,               /*0x0675*/        1, 1,                           /*0x0676-0x0677*/        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x0678-0x067D*/        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x067E-0x0683*/        1+2, 1+2, 1+2, 1+2,             /*0x0684-0x0687*/        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,   /*0x0688-0x0691*/        1, 1, 1, 1, 1, 1, 1, 1,         /*0x0692-0x0699*/        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x069A-0x06A3*/        1+2, 1+2, 1+2, 1+2,             /*0x069A-0x06A3*/        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x06A4-0x06AD*/        1+2, 1+2, 1+2, 1+2,             /*0x06A4-0x06AD*/        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x06AE-0x06B7*/        1+2, 1+2, 1+2, 1+2,             /*0x06AE-0x06B7*/        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x06B8-0x06BF*/        1+2, 1+2,                       /*0x06B8-0x06BF*/        1,                              /*0x06C0*/        1+2,                            /*0x06C1*/        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,   /*0x06C2-0x06CB*/        1+2,                            /*0x06CC*/        1,                              /*0x06CD*/        1+2, 1+2, 1+2, 1+2,             /*0x06CE-0x06D1*/        1, 1                            /*0x06D2-0x06D3*/    };    private static final int[] presLink = {        1 + 2,                        /*0xFE70*/        1 + 2,                        /*0xFE71*/        1 + 2, 0, 1+ 2, 0, 1+ 2,      /*0xFE72-0xFE76*/        1 + 2,                        /*0xFE77*/        1+ 2, 1 + 2, 1+2, 1 + 2,      /*0xFE78-0xFE81*/        1+ 2, 1 + 2, 1+2, 1 + 2,      /*0xFE82-0xFE85*/        0, 0 + 32, 1 + 32, 0 + 32,    /*0xFE86-0xFE89*/        1 + 32, 0, 1,  0 + 32,        /*0xFE8A-0xFE8D*/        1 + 32, 0, 2,  1 + 2,         /*0xFE8E-0xFE91*/        1, 0 + 32, 1 + 32, 0,         /*0xFE92-0xFE95*/        2, 1 + 2, 1, 0,               /*0xFE96-0xFE99*/        1, 0, 2, 1 + 2,               /*0xFE9A-0xFE9D*/        1, 0, 2, 1 + 2,               /*0xFE9E-0xFEA1*/        1, 0, 2, 1 + 2,               /*0xFEA2-0xFEA5*/        1, 0, 2, 1 + 2,               /*0xFEA6-0xFEA9*/        1, 0, 2, 1 + 2,               /*0xFEAA-0xFEAD*/        1, 0, 1, 0,                   /*0xFEAE-0xFEB1*/        1, 0, 1, 0,                   /*0xFEB2-0xFEB5*/        1, 0, 2, 1+2,                 /*0xFEB6-0xFEB9*/        1, 0, 2, 1+2,                 /*0xFEBA-0xFEBD*/        1, 0, 2, 1+2,                 /*0xFEBE-0xFEC1*/        1, 0, 2, 1+2,                 /*0xFEC2-0xFEC5*/        1, 0, 2, 1+2,                 /*0xFEC6-0xFEC9*/        1, 0, 2, 1+2,                 /*0xFECA-0xFECD*/        1, 0, 2, 1+2,                 /*0xFECE-0xFED1*/        1, 0, 2, 1+2,                 /*0xFED2-0xFED5*/        1, 0, 2, 1+2,                 /*0xFED6-0xFED9*/        1, 0, 2, 1+2,                 /*0xFEDA-0xFEDD*/        1, 0, 2, 1+2,                 /*0xFEDE-0xFEE1*/        1, 0 + 16, 2 + 16, 1 + 2 +16, /*0xFEE2-0xFEE5*/        1 + 16, 0, 2, 1+2,            /*0xFEE6-0xFEE9*/        1, 0, 2, 1+2,                 /*0xFEEA-0xFEED*/        1, 0, 2, 1+2,                 /*0xFEEE-0xFEF1*/        1, 0, 1, 0,                   /*0xFEF2-0xFEF5*/        1, 0, 2, 1+2,                 /*0xFEF6-0xFEF9*/        1, 0, 1, 0,                   /*0xFEFA-0xFEFD*/        1, 0, 1, 0,        1    };    private static int[] convertFEto06 = {        /***********0******1******2******3******4******5******6******7******8******9******A******B******C******D******E******F***/        /*FE7*/   0x64B, 0x64B, 0x64C, 0x64C, 0x64D, 0x64D, 0x64E, 0x64E, 0x64F, 0x64F, 0x650, 0x650, 0x651, 0x651, 0x652, 0x652,        /*FE8*/   0x621, 0x622, 0x622, 0x623, 0x623, 0x624, 0x624, 0x625, 0x625, 0x626, 0x626, 0x626, 0x626, 0x627, 0x627, 0x628,        /*FE9*/   0x628, 0x628, 0x628, 0x629, 0x629, 0x62A, 0x62A, 0x62A, 0x62A, 0x62B, 0x62B, 0x62B, 0x62B, 0x62C, 0x62C, 0x62C,        /*FEA*/   0x62C, 0x62D, 0x62D, 0x62D, 0x62D, 0x62E, 0x62E, 0x62E, 0x62E, 0x62F, 0x62F, 0x630, 0x630, 0x631, 0x631, 0x632,        /*FEB*/   0x632, 0x633, 0x633, 0x633, 0x633, 0x634, 0x634, 0x634, 0x634, 0x635, 0x635, 0x635, 0x635, 0x636, 0x636, 0x636,        /*FEC*/   0x636, 0x637, 0x637, 0x637, 0x637, 0x638, 0x638, 0x638, 0x638, 0x639, 0x639, 0x639, 0x639, 0x63A, 0x63A, 0x63A,        /*FED*/   0x63A, 0x641, 0x641, 0x641, 0x641, 0x642, 0x642, 0x642, 0x642, 0x643, 0x643, 0x643, 0x643, 0x644, 0x644, 0x644,        /*FEE*/   0x644, 0x645, 0x645, 0x645, 0x645, 0x646, 0x646, 0x646, 0x646, 0x647, 0x647, 0x647, 0x647, 0x648, 0x648, 0x649,        /*FEF*/   0x649, 0x64A, 0x64A, 0x64A, 0x64A, 0x65C, 0x65C, 0x65D, 0x65D, 0x65E, 0x65E, 0x65F, 0x65F    };    private static final int shapeTable[][][] = {        { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,1} },        { {0,0,2,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} },        { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,3} },        { {0,0,1,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} }    };    /*     * This function shapes European digits to Arabic-Indic digits     * in-place, writing over the input characters.  Data is in visual     * order.     */    private void shapeToArabicDigitsWithContext(char[] dest,                                                int start,                                                int length,                                                char digitBase,                                                boolean lastStrongWasAL) {    }/*        digitBase -= '0'; // move common adjustment out of loop        for(int i = start + length; --i >= start;) {            char ch = dest[i];            switch (UCharacter.getDirection(ch)) {            case UCharacterDirection.LEFT_TO_RIGHT:            case UCharacterDirection.RIGHT_TO_LEFT:                lastStrongWasAL = false;                break;            case UCharacterDirection.RIGHT_TO_LEFT_ARABIC:                lastStrongWasAL = true;                break;            case UCharacterDirection.EUROPEAN_NUMBER:                if (lastStrongWasAL && ch <= '\u0039') {                    dest[i] = (char)(ch + digitBase);                }                break;            default:                break;            }        }    }*/    /*     * Name    : invertBuffer     * Function: This function inverts the buffer, it's used     *           in case the user specifies the buffer to be     *           TEXT_DIRECTION_LOGICAL     */    private static void invertBuffer(char[] buffer,                                     int start,                                     int length) {        for(int i = start, j = start + length - 1; i < j; i++, --j) {            char temp = buffer[i];            buffer[i] = buffer[j];            buffer[j] = temp;        }    }    /*     * Name    : changeLamAlef     * Function: Converts the Alef characters into an equivalent     *           LamAlef location in the 0x06xx Range, this is an     *           intermediate stage in the operation of the program     *           later it'll be converted into the 0xFExx LamAlefs      *           in the shaping function.     */    private static char changeLamAlef(char ch) {        switch(ch) {        case '\u0622': return '\u065C';        case '\u0623': return '\u065D';        case '\u0625': return '\u065E';        case '\u0627': return '\u065F';        default:  return '\u0000'; // not a lamalef        }    }    /*     * Name    : specialChar     * Function: Special Arabic characters need special handling in the shapeUnicode     *           function, this function returns 1 or 2 for these special characters     */    private static int specialChar(char ch) {        if ((ch > '\u0621' && ch < '\u0626') ||             (ch == '\u0627') ||            (ch > '\u062E' && ch < '\u0633') ||            (ch > '\u0647' && ch < '\u064A') ||            (ch == '\u0629')) {            return 1;        } else if (ch >= '\u064B' && ch<= '\u0652') {            return 2;        } else if (ch >= 0x0653 && ch <= 0x0655 ||                    ch == 0x0670 ||                   ch >= 0xFE70 && ch <= 0xFE7F) {            return 3;        } else {            return 0;        }    }        /*     * Name    : getLink     * Function: Resolves the link between the characters as      *           Arabic characters have four forms :     *           Isolated, Initial, Middle and Final Form     */    private static int getLink(char ch) {        if (ch >= '\u0622' && ch <= '\u06D3') {            return araLink[ch - '\u0622'];        } else if (ch == '\u200D') {            return 3;        } else if (ch >= '\u206D' && ch <= '\u206F') {            return 4;        } else if (ch >= '\uFE70' && ch <= '\uFEFC') {            return presLink[ch - '\uFE70'];        } else {            return 0;        }    }    /*     * Name    : countSpaces     * Function: Counts the number of spaces     *           at each end of the logical buffer     */    private static int countSpacesLeft(char[] dest,                                        int start,                                       int count) {        for (int i = start, e = start + count; i < e; ++i) {            if (dest[i] != '\u0020') {                return i - start;            }        }        return count;    }    private static int countSpacesRight(char[] dest,                                        int start,                                        int count) {        for (int i = start + count; --i >= start;) {            if (dest[i] != '\u0020') {                return start + count - 1 - i;            }        }        return count;    }    /*     * Name    : isTashkeelChar     * Function: Returns 1 for Tashkeel characters else return 0     */    private static boolean isTashkeelChar(char ch) {        return ch >='\u064B' && ch <= '\u0652';    }    /*     * Name    : isAlefChar     * Function: Returns 1 for Alef characters else return 0     */    private static boolean isAlefChar(char ch) {        return ch == '\u0622' || ch == '\u0623' || ch == '\u0625' || ch == '\u0627';    }    /*     * Name    : isLamAlefChar     * Function: Returns 1 for LamAlef characters else return 0     */    private static boolean isLamAlefChar(char ch) {        return ch >= '\uFEF5' && ch <= '\uFEFC';    }    private static boolean isNormalizedLamAlefChar(char ch) {        return ch >= '\u065C' && ch <= '\u065F';    }    /*     * Name    : calculateSize     * Function: This function calculates the destSize to be used in preflighting     *           when the destSize is equal to 0     */    private int calculateSize(char[] source,                              int sourceStart,                              int sourceLength) {	        int destSize = sourceLength;        switch (options & LETTERS_MASK) {        case LETTERS_SHAPE:        case LETTERS_SHAPE_TASHKEEL_ISOLATED:            if (isLogical) {                for (int i = sourceStart, e = sourceStart + sourceLength - 1; i < e; ++i) {                    if (source[i] == '\u0644' && isAlefChar(source[i+1])) {                        --destSize;                    }                }            } else { // visual                for(int i = sourceStart + 1, e = sourceStart + sourceLength; i < e; ++i) {                    if (source[i] == '\u0644' && isAlefChar(source[i-1])) {                        --destSize;                    }                }            }            break;        case LETTERS_UNSHAPE:            for(int i = sourceStart, e = sourceStart + sourceLength; i < e; ++i) {                if (isLamAlefChar(source[i])) {                    destSize++;                }            }            break;        default:            break;        }        return destSize;    }    /*     * Name    : removeLamAlefSpaces     * Function: The shapeUnicode function converts Lam + Alef into LamAlef + space,     *           this function removes the spaces behind the LamAlefs according to     *           the options the user specifies, the spaces are removed to the end     *           of the buffer, or shrink the buffer and remove spaces for good     *           or leave the buffer as it is LamAlef + space.     */    private int removeLamAlefSpaces(char[] dest,                                     int start,                                    int length) {	        int lenOptions = options & LENGTH_MASK;        if (!isLogical) {            switch (lenOptions) {            case LENGTH_FIXED_SPACES_AT_BEGINNING: lenOptions = LENGTH_FIXED_SPACES_AT_END; break;            case LENGTH_FIXED_SPACES_AT_END: lenOptions = LENGTH_FIXED_SPACES_AT_BEGINNING; break;            default: break;            }        }        if (lenOptions == LENGTH_FIXED_SPACES_NEAR) {            for (int i = start, e = i + length; i < e; ++i) {                if (dest[i] == '\uffff') {                    dest[i] = '\u0020';                }            }        } else {            final int e = start + length;            int w = e;            int r = e;            while (--r >= start) {                char ch = dest[r];                if (ch != '\uffff') {                    --w;                    if (w != r) {                        dest[w] = ch;                    }                }            }            if (lenOptions == LENGTH_FIXED_SPACES_AT_END) {                while (w > start) {                    dest[--w] = '\u0020';                }            } else {                if (w > start) {                    // shift, assume small buffer size so don't use arraycopy                    r = w;                    w = start;                    while (r < e) {                        dest[w++] = dest[r++];                    }                } else {                    w = e;                }                if (lenOptions == LENGTH_GROW_SHRINK) {