001    /*
002     *  Licensed to the Apache Software Foundation (ASF) under one
003     *  or more contributor license agreements.  See the NOTICE file
004     *  distributed with this work for additional information
005     *  regarding copyright ownership.  The ASF licenses this file
006     *  to you under the Apache License, Version 2.0 (the
007     *  "License"); you may not use this file except in compliance
008     *  with the License.  You may obtain a copy of the License at
009     *  
010     *    http://www.apache.org/licenses/LICENSE-2.0
011     *  
012     *  Unless required by applicable law or agreed to in writing,
013     *  software distributed under the License is distributed on an
014     *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015     *  KIND, either express or implied.  See the License for the
016     *  specific language governing permissions and limitations
017     *  under the License. 
018     *  
019     */
020    
021    package org.apache.directory.shared.ldap.schema;
022    
023    import java.io.IOException;
024    
025    import org.apache.directory.shared.ldap.util.StringTools;
026    import org.apache.directory.shared.ldap.util.unicode.InvalidCharacterException;
027    
028    /**
029     * 
030     * This class implements the 6 steps described in RFC 4518
031     *
032     * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
033     * @version $Rev$, $Date$
034     */
035    public class PrepareString
036    {
037        /** A flag used to lowercase chars during the map process */
038        private static final boolean CASE_SENSITIVE = true;
039        
040        /** A flag used to keep casing during the map process */
041        private static final boolean IGNORE_CASE = false;
042    
043        /** All the possible combining marks */
044        private static final char[][] COMBINING_MARKS = new char[][] 
045            {
046                { 0x0300, 0x034F }, { 0x0360, 0x036F }, { 0x0483, 0x0486 },  { 0x0488, 0x0489 }, 
047                { 0x0591, 0x05A1 }, { 0x05A3, 0x05B9 }, { 0x05BB, 0x05BC }, { 0x05BF, 0x05BF }, 
048                { 0x05C1, 0x05C2 }, { 0x05C4, 0x05C4 }, { 0x064B, 0x0655 }, { 0x0670, 0x0670 }, 
049                { 0x06D6, 0x06DC }, { 0x06DE, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, 
050                { 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 }, { 0x0901, 0x0903 }, 
051                { 0x093C, 0x093C }, { 0x093E, 0x094F }, { 0x0951, 0x0954 }, { 0x0962, 0x0963 },
052                { 0x0981, 0x0983 }, { 0x09BC, 0x09BC }, { 0x09BE, 0x09C4 }, { 0x09C7, 0x09C8 }, 
053                { 0x09CB, 0x09CD }, { 0x09D7, 0x09D7 }, { 0x09E2, 0x09E3 }, { 0x0A02, 0x0A02 }, 
054                { 0x0A3C, 0x0A3C }, { 0x0A3E, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },
055                { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A83 }, { 0x0ABC, 0x0ABC }, { 0x0ABE, 0x0AC5 }, 
056                { 0x0AC7, 0x0AC9 }, { 0x0ACB, 0x0ACD }, { 0x0B01, 0x0B03 }, { 0x0B3C, 0x0B3C },
057                { 0x0B3E, 0x0B43 }, { 0x0B47, 0x0B48 }, { 0x0B4B, 0x0B4D }, { 0x0B56, 0x0B57 },
058                { 0x0B82, 0x0B82 }, { 0x0BBE, 0x0BC2 }, { 0x0BC6, 0x0BC8 }, { 0x0BCA, 0x0BCD }, 
059                { 0x0BD7, 0x0BD7 }, { 0x0C01, 0x0C03 }, { 0x0C3E, 0x0C44 }, { 0x0C46, 0x0C48 }, 
060                { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0C82, 0x0C83 }, { 0x0CBE, 0x0CC4 }, 
061                { 0x0CC6, 0x0CC8 }, { 0x0CCA, 0x0CCD }, { 0x0CD5, 0x0CD6 }, { 0x0D02, 0x0D03 },
062                { 0x0D3E, 0x0D43 }, { 0x0D46, 0x0D48 }, { 0x0D4A, 0x0D4D }, { 0x0D57, 0x0D57 },
063                { 0x0D82, 0x0D83 }, { 0x0DCA, 0x0DCA }, { 0x0DCF, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
064                { 0x0DD8, 0x0DDF }, { 0x0DF2, 0x0DF3 }, { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A },
065                { 0x0E47, 0x0E4E }, { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC }, 
066                { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 }, { 0x0F37, 0x0F37 },
067                { 0x0F39, 0x0F39 }, { 0x0F3E, 0x0F3F }, { 0x0F71, 0x0F84 }, { 0x0F86, 0x0F87 }, 
068                { 0x0F90, 0x0F97 }, { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102C, 0x1032 }, 
069                { 0x1036, 0x1039 }, { 0x1056, 0x1059 }, { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, 
070                { 0x1752, 0x1753 }, { 0x1772, 0x1773 }, { 0x17B4, 0x17D3 }, { 0x180B, 0x180D }, 
071                { 0x18A9, 0x18A9 }, { 0x20D0, 0x20EA }, { 0x302A, 0x302F }, { 0x3099, 0x309A }, 
072                { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE20, 0xFE23 }
073            };
074        
075        /**
076         * The type of String we have to normalize
077         */
078        public enum StringType 
079        {
080            NOT_STRING,         
081            NUMERIC_STRING,
082            CASE_EXACT,
083            CASE_EXACT_IA5,
084            CASE_IGNORE_IA5,
085            CASE_IGNORE_LIST,
086            CASE_IGNORE,
087            DIRECTORY_STRING,
088            TELEPHONE_NUMBER,
089            WORD
090        }
091        
092        
093        /**
094         * A private constructor, to avoid instance creation of this static class.
095         */
096        private PrepareString()
097        {
098            // Do nothing
099        }
100        
101        
102        /**
103         * Tells if a char is a combining mark.
104         *
105         * @param c The char to check
106         * @return <code>true> if the char is a combining mark, false otherwise
107         */
108        private static boolean isCombiningMark( char c )
109        {
110            if ( c < COMBINING_MARKS[0][0] )
111            {
112                return false;
113            }
114            
115            for ( char[] interval:COMBINING_MARKS )
116            {
117                if ( ( c >= interval[0] ) && ( c <= interval[1] ) )
118                {
119                    return true;
120                }
121            }
122            
123            return false;
124        }
125        
126        /**
127        *
128        * We have to go through 6 steps :
129        *
130        * 1) Transcode
131        * 2) Map
132        * 3) Normalize
133        * 4) Prohibit
134        * 5) Bidi
135        * 6) Insignifiant Character Handling
136        *
137        * The first step is already done, the step (3) is not done.
138        *
139        * @param str The String to normalize
140        * @param type The string type
141        * @return A normalized string.
142        * @throws IOException
143        */
144       public static String normalize( String str, StringType type ) throws IOException
145       {
146           switch ( type )
147           {
148               case NUMERIC_STRING :
149                   return insignifiantCharNumericString( str );
150    
151               case TELEPHONE_NUMBER :
152                   return insignifiantCharTelephoneNumber( str );
153    
154               case CASE_EXACT :
155               case CASE_EXACT_IA5 :
156               case DIRECTORY_STRING :
157                   return insignifiantSpacesString( str, CASE_SENSITIVE );
158    
159               case CASE_IGNORE_IA5 :
160               case CASE_IGNORE_LIST :
161               case CASE_IGNORE :
162                   return insignifiantSpacesString( str, IGNORE_CASE );
163                   
164               case WORD :
165                   return str;
166    
167               default :  
168                   return str;
169                   
170           }
171       }
172       
173        /**
174         * Execute the mapping step of the string preparation :
175         * - suppress useless chars
176         * - transform to spaces
177         * - lowercase
178         * 
179         * @param c The char to map
180         * @param target The array which will collect the transformed char
181         * @param pos The current position in the target
182         * @param lowerCase A mask to lowercase the char, if necessary
183         * @return The transformed StringBuilder
184         */
185        private static int map( char c, char[] target, int pos, char lowerCase )
186        {
187            int start = pos;
188            
189            switch ( c )
190            {
191                case 0x0000:
192                case 0x0001:
193                case 0x0002:
194                case 0x0003:
195                case 0x0004:
196                case 0x0005:
197                case 0x0006:
198                case 0x0007:
199                case 0x0008:
200                    break;
201                    
202                case 0x0009:
203                case 0x000A:
204                case 0x000B:
205                case 0x000C:
206                case 0x000D:
207                    target[pos++] = (char)0x20;
208                    break;
209                    
210                case 0x000E:
211                case 0x000F:
212                case 0x0010:
213                case 0x0011:
214                case 0x0012:
215                case 0x0013:
216                case 0x0014:
217                case 0x0015:
218                case 0x0016:
219                case 0x0017:
220                case 0x0018:
221                case 0x0019:
222                case 0x001A:
223                case 0x001B:
224                case 0x001C:
225                case 0x001D:
226                case 0x001E:
227                case 0x001F:
228                    break;
229    
230                case 0x0041 : 
231                case 0x0042 : 
232                case 0x0043 : 
233                case 0x0044 : 
234                case 0x0045 : 
235                case 0x0046 : 
236                case 0x0047 : 
237                case 0x0048 : 
238                case 0x0049 : 
239                case 0x004A : 
240                case 0x004B : 
241                case 0x004C : 
242                case 0x004D : 
243                case 0x004E : 
244                case 0x004F : 
245                case 0x0050 : 
246                case 0x0051 : 
247                case 0x0052 : 
248                case 0x0053 : 
249                case 0x0054 : 
250                case 0x0055 : 
251                case 0x0056 : 
252                case 0x0057 : 
253                case 0x0058 : 
254                case 0x0059 : 
255                case 0x005A : 
256                    target[pos++] = (char)( c | lowerCase );
257                    break;
258        
259                case 0x007F:
260                case 0x0080:
261                case 0x0081:
262                case 0x0082:
263                case 0x0083:
264                case 0x0084:
265                    break;
266                    
267                case 0x0085:
268                    target[pos++] = (char)0x20;
269                    break;
270    
271                case 0x0086:
272                case 0x0087:
273                case 0x0088:
274                case 0x0089:
275                case 0x008A:
276                case 0x008B:
277                case 0x008C:
278                case 0x008D:
279                case 0x008E:
280                case 0x008F:
281                case 0x0090:
282                case 0x0091:
283                case 0x0092:
284                case 0x0093:
285                case 0x0094:
286                case 0x0095:
287                case 0x0096:
288                case 0x0097:
289                case 0x0098:
290                case 0x0099:
291                case 0x009A:
292                case 0x009B:
293                case 0x009C:
294                case 0x009D:
295                case 0x009E:
296                case 0x009F:
297                    break;
298                    
299                case 0x00A0:
300                    target[pos++] = (char)0x20;
301                    break;
302    
303                case 0x00AD:
304                    break;
305    
306                    
307                case 0x00B5 : 
308                    target[pos++] = (char)0x03BC;
309                    break;
310        
311                case 0x00C0 : 
312                case 0x00C1 : 
313                case 0x00C2 : 
314                case 0x00C3 : 
315                case 0x00C4 : 
316                case 0x00C5 : 
317                case 0x00C6 : 
318                case 0x00C7 : 
319                case 0x00C8 : 
320                case 0x00C9 : 
321                case 0x00CA : 
322                case 0x00CB : 
323                case 0x00CC : 
324                case 0x00CD : 
325                case 0x00CE : 
326                case 0x00CF : 
327                case 0x00D0 : 
328                case 0x00D1 : 
329                case 0x00D2 : 
330                case 0x00D3 : 
331                case 0x00D4 : 
332                case 0x00D5 : 
333                case 0x00D6 : 
334                case 0x00D8 : 
335                case 0x00D9 : 
336                case 0x00DA : 
337                case 0x00DB : 
338                case 0x00DC : 
339                case 0x00DD : 
340                case 0x00DE : 
341                    target[pos++] = (char)( c | lowerCase );
342                    break;
343        
344                case 0x00DF : 
345                    target[pos++] = (char)0x0073;
346                    target[pos++] = (char)0x0073;
347                    break;
348        
349                case 0x0100 : 
350                    target[pos++] = (char)0x0101;
351                    break;
352        
353                case 0x0102 : 
354                    target[pos++] = (char)0x0103;
355                    break;
356        
357                case 0x0104 : 
358                    target[pos++] = 0x0105;
359                    break;
360        
361                case 0x0106 : 
362                    target[pos++] = 0x0107;
363                    break;
364        
365                case 0x0108 : 
366                    target[pos++] = 0x0109;
367                    break;
368        
369                case 0x010A : 
370                    target[pos++] = 0x010B;
371                    break;
372        
373                case 0x010C : 
374                    target[pos++] = 0x010D;
375                    break;
376        
377                case 0x010E : 
378                    target[pos++] = 0x010F;
379                    break;
380        
381                case 0x0110 : 
382                    target[pos++] = 0x0111;
383                    break;
384        
385                case 0x0112 : 
386                    target[pos++] = 0x0113;
387                    break;
388        
389                case 0x0114 : 
390                    target[pos++] = 0x0115;
391                    break;
392        
393                case 0x0116 : 
394                    target[pos++] = 0x0117;
395                    break;
396        
397                case 0x0118 : 
398                    target[pos++] = 0x0119;
399                    break;
400        
401                case 0x011A : 
402                    target[pos++] = 0x011B;
403                    break;
404        
405                case 0x011C : 
406                    target[pos++] = 0x011D;
407                    break;
408        
409                case 0x011E : 
410                    target[pos++] = 0x011F;
411                    break;
412        
413                case 0x0120 : 
414                    target[pos++] = 0x0121;
415                    break;
416        
417                case 0x0122 : 
418                    target[pos++] = 0x0123;
419                    break;
420        
421                case 0x0124 : 
422                    target[pos++] = 0x0125;
423                    break;
424        
425                case 0x0126 : 
426                    target[pos++] = 0x0127;
427                    break;
428        
429                case 0x0128 : 
430                    target[pos++] = 0x0129;
431                    break;
432        
433                case 0x012A : 
434                    target[pos++] = 0x012B;
435                    break;
436        
437                case 0x012C : 
438                    target[pos++] = 0x012D;
439                    break;
440        
441                case 0x012E : 
442                    target[pos++] = 0x012F;
443                    break;
444        
445                case 0x0130 : 
446                    target[pos++] = 0x0069;
447                    target[pos++] = 0x0307;
448                    break;
449        
450                case 0x0132 : 
451                    target[pos++] = 0x0133;
452                    break;
453        
454                case 0x0134 : 
455                    target[pos++] = 0x0135;
456                    break;
457        
458                case 0x0136 : 
459                    target[pos++] = 0x0137;
460                    break;
461        
462                case 0x0139 : 
463                    target[pos++] = 0x013A;
464                    break;
465        
466                case 0x013B : 
467                    target[pos++] = 0x013C;
468                    break;
469        
470                case 0x013D : 
471                    target[pos++] = 0x013E;
472                    break;
473        
474                case 0x013F : 
475                    target[pos++] = 0x0140;
476                    break;
477        
478                case 0x0141 : 
479                    target[pos++] = 0x0142;
480                    break;
481        
482                case 0x0143 : 
483                    target[pos++] = 0x0144;
484                    break;
485        
486                case 0x0145 : 
487                    target[pos++] = 0x0146;
488                    break;
489        
490                case 0x0147 : 
491                    target[pos++] = 0x0148;
492                    break;
493        
494                case 0x0149 : 
495                    target[pos++] = 0x02BC;
496                    target[pos++] = 0x006E;
497                    break;
498        
499                case 0x014A : 
500                    target[pos++] = 0x014B;
501                    break;
502        
503                case 0x014C : 
504                    target[pos++] = 0x014D;
505                    break;
506        
507                case 0x014E : 
508                    target[pos++] = 0x014F;
509                    break;
510        
511                case 0x0150 : 
512                    target[pos++] = 0x0151;
513                    break;
514        
515                case 0x0152 : 
516                    target[pos++] = 0x0153;
517                    break;
518        
519                case 0x0154 : 
520                    target[pos++] = 0x0155;
521                    break;
522        
523                case 0x0156 : 
524                    target[pos++] = 0x0157;
525                    break;
526        
527                case 0x0158 : 
528                    target[pos++] = 0x0159;
529                    break;
530        
531                case 0x015A : 
532                    target[pos++] = 0x015B;
533                    break;
534        
535                case 0x015C : 
536                    target[pos++] = 0x015D;
537                    break;
538        
539                case 0x015E : 
540                    target[pos++] = 0x015F;
541                    break;
542        
543                case 0x0160 : 
544                    target[pos++] = 0x0161;
545                    break;
546        
547                case 0x0162 : 
548                    target[pos++] = 0x0163;
549                    break;
550        
551                case 0x0164 : 
552                    target[pos++] = 0x0165;
553                    break;
554        
555                case 0x0166 : 
556                    target[pos++] = 0x0167;
557                    break;
558        
559                case 0x0168 : 
560                    target[pos++] = 0x0169;
561                    break;
562        
563                case 0x016A : 
564                    target[pos++] = 0x016B;
565                    break;
566        
567                case 0x016C : 
568                    target[pos++] = 0x016D;
569                    break;
570        
571                case 0x016E : 
572                    target[pos++] = 0x016F;
573                    break;
574        
575                case 0x0170 : 
576                    target[pos++] = 0x0171;
577                    break;
578        
579                case 0x0172 : 
580                    target[pos++] = 0x0173;
581                    break;
582        
583                case 0x0174 : 
584                    target[pos++] = 0x0175;
585                    break;
586        
587                case 0x0176 : 
588                    target[pos++] = 0x0177;
589                    break;
590        
591                case 0x0178 : 
592                    target[pos++] = 0x00FF;
593                    break;
594        
595                case 0x0179 : 
596                    target[pos++] = 0x017A;
597                    break;
598        
599                case 0x017B : 
600                    target[pos++] = 0x017C;
601                    break;
602        
603                case 0x017D : 
604                    target[pos++] = 0x017E;
605                    break;
606        
607                case 0x017F : 
608                    target[pos++] = 0x0073;
609                    break;
610        
611                case 0x0181 : 
612                    target[pos++] = 0x0253;
613                    break;
614        
615                case 0x0182 : 
616                    target[pos++] = 0x0183;
617                    break;
618        
619                case 0x0184 : 
620                    target[pos++] = 0x0185;
621                    break;
622        
623                case 0x0186 : 
624                    target[pos++] = 0x0254;
625                    break;
626        
627                case 0x0187 : 
628                    target[pos++] = 0x0188;
629                    break;
630        
631                case 0x0189 : 
632                    target[pos++] = 0x0256;
633                    break;
634        
635                case 0x018A : 
636                    target[pos++] = 0x0257;
637                    break;
638        
639                case 0x018B : 
640                    target[pos++] = 0x018C;
641                    break;
642        
643                case 0x018E : 
644                    target[pos++] = 0x01DD;
645                    break;
646        
647                case 0x018F : 
648                    target[pos++] = 0x0259;
649                    break;
650        
651                case 0x0190 : 
652                    target[pos++] = 0x025B;
653                    break;
654        
655                case 0x0191 : 
656                    target[pos++] = 0x0192;
657                    break;
658        
659                case 0x0193 : 
660                    target[pos++] = 0x0260;
661                    break;
662        
663                case 0x0194 : 
664                    target[pos++] = 0x0263;
665                    break;
666        
667                case 0x0196 : 
668                    target[pos++] = 0x0269;
669                    break;
670        
671                case 0x0197 : 
672                    target[pos++] = 0x0268;
673                    break;
674        
675                case 0x0198 : 
676                    target[pos++] = 0x0199;
677                    break;
678        
679                case 0x019C : 
680                    target[pos++] = 0x026F;
681                    break;
682        
683                case 0x019D : 
684                    target[pos++] = 0x0272;
685                    break;
686        
687                case 0x019F : 
688                    target[pos++] = 0x0275;
689                    break;
690        
691                case 0x01A0 : 
692                    target[pos++] = 0x01A1;
693                    break;
694        
695                case 0x01A2 : 
696                    target[pos++] = 0x01A3;
697                    break;
698        
699                case 0x01A4 : 
700                    target[pos++] = 0x01A5;
701                    break;
702        
703                case 0x01A6 : 
704                    target[pos++] = 0x0280;
705                    break;
706        
707                case 0x01A7 : 
708                    target[pos++] = 0x01A8;
709                    break;
710        
711                case 0x01A9 : 
712                    target[pos++] = 0x0283;
713                    break;
714        
715                case 0x01AC : 
716                    target[pos++] = 0x01AD;
717                    break;
718        
719                case 0x01AE : 
720                    target[pos++] = 0x0288;
721                    break;
722        
723                case 0x01AF : 
724                    target[pos++] = 0x01B0;
725                    break;
726        
727                case 0x01B1 : 
728                    target[pos++] = 0x028A;
729                    break;
730        
731                case 0x01B2 : 
732                    target[pos++] = 0x028B;
733                    break;
734        
735                case 0x01B3 : 
736                    target[pos++] = 0x01B4;
737                    break;
738        
739                case 0x01B5 : 
740                    target[pos++] = 0x01B6;
741                    break;
742        
743                case 0x01B7 : 
744                    target[pos++] = 0x0292;
745                    break;
746        
747                case 0x01B8 : 
748                    target[pos++] = 0x01B9;
749                    break;
750        
751                case 0x01BC : 
752                    target[pos++] = 0x01BD;
753                    break;
754        
755                case 0x01C4 : 
756                    target[pos++] = 0x01C6;
757                    break;
758        
759                case 0x01C5 : 
760                    target[pos++] = 0x01C6;
761                    break;
762        
763                case 0x01C7 : 
764                    target[pos++] = 0x01C9;
765                    break;
766        
767                case 0x01C8 : 
768                    target[pos++] = 0x01C9;
769                    break;
770        
771                case 0x01CA : 
772                    target[pos++] = 0x01CC;
773                    break;
774        
775                case 0x01CB : 
776                    target[pos++] = 0x01CC;
777                    break;
778        
779                case 0x01CD : 
780                    target[pos++] = 0x01CE;
781                    break;
782        
783                case 0x01CF : 
784                    target[pos++] = 0x01D0;
785                    break;
786        
787                case 0x01D1 : 
788                    target[pos++] = 0x01D2;
789                    break;
790        
791                case 0x01D3 : 
792                    target[pos++] = 0x01D4;
793                    break;
794        
795                case 0x01D5 : 
796                    target[pos++] = 0x01D6;
797                    break;
798        
799                case 0x01D7 : 
800                    target[pos++] = 0x01D8;
801                    break;
802        
803                case 0x01D9 : 
804                    target[pos++] = 0x01DA;
805                    break;
806        
807                case 0x01DB : 
808                    target[pos++] = 0x01DC;
809                    break;
810        
811                case 0x01DE : 
812                    target[pos++] = 0x01DF;
813                    break;
814        
815                case 0x01E0 : 
816                    target[pos++] = 0x01E1;
817                    break;
818        
819                case 0x01E2 : 
820                    target[pos++] = 0x01E3;
821                    break;
822        
823                case 0x01E4 : 
824                    target[pos++] = 0x01E5;
825                    break;
826        
827                case 0x01E6 : 
828                    target[pos++] = 0x01E7;
829                    break;
830        
831                case 0x01E8 : 
832                    target[pos++] = 0x01E9;
833                    break;
834        
835                case 0x01EA : 
836                    target[pos++] = 0x01EB;
837                    break;
838        
839                case 0x01EC : 
840                    target[pos++] = 0x01ED;
841                    break;
842        
843                case 0x01EE : 
844                    target[pos++] = 0x01EF;
845                    break;
846        
847                case 0x01F0 : 
848                    target[pos++] = 0x006A;
849                    target[pos++] = 0x030C;
850                    break;
851        
852                case 0x01F1 : 
853                    target[pos++] = 0x01F3;
854                    break;
855        
856                case 0x01F2 : 
857                    target[pos++] = 0x01F3;
858                    break;
859        
860                case 0x01F4 : 
861                    target[pos++] = 0x01F5;
862                    break;
863        
864                case 0x01F6 : 
865                    target[pos++] = 0x0195;
866                    break;
867        
868                case 0x01F7 : 
869                    target[pos++] = 0x01BF;
870                    break;
871        
872                case 0x01F8 : 
873                    target[pos++] = 0x01F9;
874                    break;
875        
876                case 0x01FA : 
877                    target[pos++] = 0x01FB;
878                    break;
879        
880                case 0x01FC : 
881                    target[pos++] = 0x01FD;
882                    break;
883        
884                case 0x01FE : 
885                    target[pos++] = 0x01FF;
886                    break;
887        
888                case 0x0200 : 
889                    target[pos++] = 0x0201;
890                    break;
891        
892                case 0x0202 : 
893                    target[pos++] = 0x0203;
894                    break;
895        
896                case 0x0204 : 
897                    target[pos++] = 0x0205;
898                    break;
899        
900                case 0x0206 : 
901                    target[pos++] = 0x0207;
902                    break;
903        
904                case 0x0208 : 
905                    target[pos++] = 0x0209;
906                    break;
907        
908                case 0x020A : 
909                    target[pos++] = 0x020B;
910                    break;
911        
912                case 0x020C : 
913                    target[pos++] = 0x020D;
914                    break;
915        
916                case 0x020E : 
917                    target[pos++] = 0x020F;
918                    break;
919        
920                case 0x0210 : 
921                    target[pos++] = 0x0211;
922                    break;
923        
924                case 0x0212 : 
925                    target[pos++] = 0x0213;
926                    break;
927        
928                case 0x0214 : 
929                    target[pos++] = 0x0215;
930                    break;
931        
932                case 0x0216 : 
933                    target[pos++] = 0x0217;
934                    break;
935        
936                case 0x0218 : 
937                    target[pos++] = 0x0219;
938                    break;
939        
940                case 0x021A : 
941                    target[pos++] = 0x021B;
942                    break;
943        
944                case 0x021C : 
945                    target[pos++] = 0x021D;
946                    break;
947        
948                case 0x021E : 
949                    target[pos++] = 0x021F;
950                    break;
951        
952                case 0x0220 : 
953                    target[pos++] = 0x019E;
954                    break;
955        
956                case 0x0222 : 
957                    target[pos++] = 0x0223;
958                    break;
959        
960                case 0x0224 : 
961                    target[pos++] = 0x0225;
962                    break;
963        
964                case 0x0226 : 
965                    target[pos++] = 0x0227;
966                    break;
967        
968                case 0x0228 : 
969                    target[pos++] = 0x0229;
970                    break;
971        
972                case 0x022A : 
973                    target[pos++] = 0x022B;
974                    break;
975        
976                case 0x022C : 
977                    target[pos++] = 0x022D;
978                    break;
979        
980                case 0x022E : 
981                    target[pos++] = 0x022F;
982                    break;
983        
984                case 0x0230 : 
985                    target[pos++] = 0x0231;
986                    break;
987        
988                case 0x0232 : 
989                    target[pos++] = 0x0233;
990                    break;
991        
992                case 0x0345 : 
993                    target[pos++] = 0x03B9;
994                    break;
995        
996                case 0x034F : 
997                    break;
998        
999                case 0x037A : 
1000                    target[pos++] = 0x0020;
1001                    target[pos++] = 0x03B9;
1002                    break;
1003        
1004                case 0x0386 : 
1005                    target[pos++] = 0x03AC;
1006                    break;
1007        
1008                case 0x0388 : 
1009                    target[pos++] = 0x03AD;
1010                    break;
1011        
1012                case 0x0389 : 
1013                    target[pos++] = 0x03AE;
1014                    break;
1015        
1016                case 0x038A : 
1017                    target[pos++] = 0x03AF;
1018                    break;
1019        
1020                case 0x038C : 
1021                    target[pos++] = 0x03CC;
1022                    break;
1023        
1024                case 0x038E : 
1025                    target[pos++] = 0x03CD;
1026                    break;
1027        
1028                case 0x038F : 
1029                    target[pos++] = 0x03CE;
1030                    break;
1031        
1032                case 0x0390 : 
1033                    target[pos++] = 0x03B9;
1034                    target[pos++] = 0x0308;
1035                    target[pos++] = 0x0301;
1036                    break;
1037        
1038                case 0x0391 : 
1039                    target[pos++] = 0x03B1;
1040                    break;
1041        
1042                case 0x0392 : 
1043                    target[pos++] = 0x03B2;
1044                    break;
1045        
1046                case 0x0393 : 
1047                    target[pos++] = 0x03B3;
1048                    break;
1049        
1050                case 0x0394 : 
1051                    target[pos++] = 0x03B4;
1052                    break;
1053        
1054                case 0x0395 : 
1055                    target[pos++] = 0x03B5;
1056                    break;
1057        
1058                case 0x0396 : 
1059                    target[pos++] = 0x03B6;
1060                    break;
1061        
1062                case 0x0397 : 
1063                    target[pos++] = 0x03B7;
1064                    break;
1065        
1066                case 0x0398 : 
1067                    target[pos++] = 0x03B8;
1068                    break;
1069        
1070                case 0x0399 : 
1071                    target[pos++] = 0x03B9;
1072                    break;
1073        
1074                case 0x039A : 
1075                    target[pos++] = 0x03BA;
1076                    break;
1077        
1078                case 0x039B : 
1079                    target[pos++] = 0x03BB;
1080                    break;
1081        
1082                case 0x039C : 
1083                    target[pos++] = 0x03BC;
1084                    break;
1085        
1086                case 0x039D : 
1087                    target[pos++] = 0x03BD;
1088                    break;
1089        
1090                case 0x039E : 
1091                    target[pos++] = 0x03BE;
1092                    break;
1093        
1094                case 0x039F : 
1095                    target[pos++] = 0x03BF;
1096                    break;
1097        
1098                case 0x03A0 : 
1099                    target[pos++] = 0x03C0;
1100                    break;
1101        
1102                case 0x03A1 : 
1103                    target[pos++] = 0x03C1;
1104                    break;
1105        
1106                case 0x03A3 : 
1107                    target[pos++] = 0x03C3;
1108                    break;
1109        
1110                case 0x03A4 : 
1111                    target[pos++] = 0x03C4;
1112                    break;
1113        
1114                case 0x03A5 : 
1115                    target[pos++] = 0x03C5;
1116                    break;
1117        
1118                case 0x03A6 : 
1119                    target[pos++] = 0x03C6;
1120                    break;
1121        
1122                case 0x03A7 : 
1123                    target[pos++] = 0x03C7;
1124                    break;
1125        
1126                case 0x03A8 : 
1127                    target[pos++] = 0x03C8;
1128                    break;
1129        
1130                case 0x03A9 : 
1131                    target[pos++] = 0x03C9;
1132                    break;
1133        
1134                case 0x03AA : 
1135                    target[pos++] = 0x03CA;
1136                    break;
1137        
1138                case 0x03AB : 
1139                    target[pos++] = 0x03CB;
1140                    break;
1141        
1142                case 0x03B0 : 
1143                    target[pos++] = 0x03C5;
1144                    target[pos++] = 0x0308;
1145                    target[pos++] = 0x0301;
1146                    break;
1147        
1148                case 0x03C2 : 
1149                    target[pos++] = 0x03C3;
1150                    break;
1151        
1152                case 0x03D0 : 
1153                    target[pos++] = 0x03B2;
1154                    break;
1155        
1156                case 0x03D1 : 
1157                    target[pos++] = 0x03B8;
1158                    break;
1159        
1160                case 0x03D2 : 
1161                    target[pos++] = 0x03C5;
1162                    break;
1163        
1164                case 0x03D3 : 
1165                    target[pos++] = 0x03CD;
1166                    break;
1167        
1168                case 0x03D4 : 
1169                    target[pos++] = 0x03CB;
1170                    break;
1171        
1172                case 0x03D5 : 
1173                    target[pos++] = 0x03C6;
1174                    break;
1175        
1176                case 0x03D6 : 
1177                    target[pos++] = 0x03C0;
1178                    break;
1179        
1180                case 0x03D8 : 
1181                    target[pos++] = 0x03D9;
1182                    break;
1183        
1184                case 0x03DA : 
1185                    target[pos++] = 0x03DB;
1186                    break;
1187        
1188                case 0x03DC : 
1189                    target[pos++] = 0x03DD;
1190                    break;
1191        
1192                case 0x03DE : 
1193                    target[pos++] = 0x03DF;
1194                    break;
1195        
1196                case 0x03E0 : 
1197                    target[pos++] = 0x03E1;
1198                    break;
1199        
1200                case 0x03E2 : 
1201                    target[pos++] = 0x03E3;
1202                    break;
1203        
1204                case 0x03E4 : 
1205                    target[pos++] = 0x03E5;
1206                    break;
1207        
1208                case 0x03E6 : 
1209                    target[pos++] = 0x03E7;
1210                    break;
1211        
1212                case 0x03E8 : 
1213                    target[pos++] = 0x03E9;
1214                    break;
1215        
1216                case 0x03EA : 
1217                    target[pos++] = 0x03EB;
1218                    break;
1219        
1220                case 0x03EC : 
1221                    target[pos++] = 0x03ED;
1222                    break;
1223        
1224                case 0x03EE : 
1225                    target[pos++] = 0x03EF;
1226                    break;
1227        
1228                case 0x03F0 : 
1229                    target[pos++] = 0x03BA;
1230                    break;
1231        
1232                case 0x03F1 : 
1233                    target[pos++] = 0x03C1;
1234                    break;
1235        
1236                case 0x03F2 : 
1237                    target[pos++] = 0x03C3;
1238                    break;
1239        
1240                case 0x03F4 : 
1241                    target[pos++] = 0x03B8;
1242                    break;
1243        
1244                case 0x03F5 : 
1245                    target[pos++] = 0x03B5;
1246                    break;
1247        
1248                case 0x0400 : 
1249                    target[pos++] = 0x0450;
1250                    break;
1251        
1252                case 0x0401 : 
1253                    target[pos++] = 0x0451;
1254                    break;
1255        
1256                case 0x0402 : 
1257                    target[pos++] = 0x0452;
1258                    break;
1259        
1260                case 0x0403 : 
1261                    target[pos++] = 0x0453;
1262                    break;
1263        
1264                case 0x0404 : 
1265                    target[pos++] = 0x0454;
1266                    break;
1267        
1268                case 0x0405 : 
1269                    target[pos++] = 0x0455;
1270                    break;
1271        
1272                case 0x0406 : 
1273                    target[pos++] = 0x0456;
1274                    break;
1275        
1276                case 0x0407 : 
1277                    target[pos++] = 0x0457;
1278                    break;
1279        
1280                case 0x0408 : 
1281                    target[pos++] = 0x0458;
1282                    break;
1283        
1284                case 0x0409 : 
1285                    target[pos++] = 0x0459;
1286                    break;
1287        
1288                case 0x040A : 
1289                    target[pos++] = 0x045A;
1290                    break;
1291        
1292                case 0x040B : 
1293                    target[pos++] = 0x045B;
1294                    break;
1295        
1296                case 0x040C : 
1297                    target[pos++] = 0x045C;
1298                    break;
1299        
1300                case 0x040D : 
1301                    target[pos++] = 0x045D;
1302                    break;
1303        
1304                case 0x040E : 
1305                    target[pos++] = 0x045E;
1306                    break;
1307        
1308                case 0x040F : 
1309                    target[pos++] = 0x045F;
1310                    break;
1311        
1312                case 0x0410 : 
1313                    target[pos++] = 0x0430;
1314                    break;
1315        
1316                case 0x0411 : 
1317                    target[pos++] = 0x0431;
1318                    break;
1319        
1320                case 0x0412 : 
1321                    target[pos++] = 0x0432;
1322                    break;
1323        
1324                case 0x0413 : 
1325                    target[pos++] = 0x0433;
1326                    break;
1327        
1328                case 0x0414 : 
1329                    target[pos++] = 0x0434;
1330                    break;
1331        
1332                case 0x0415 : 
1333                    target[pos++] = 0x0435;
1334                    break;
1335        
1336                case 0x0416 : 
1337                    target[pos++] = 0x0436;
1338                    break;
1339        
1340                case 0x0417 : 
1341                    target[pos++] = 0x0437;
1342                    break;
1343        
1344                case 0x0418 : 
1345                    target[pos++] = 0x0438;
1346                    break;
1347        
1348                case 0x0419 : 
1349                    target[pos++] = 0x0439;
1350                    break;
1351        
1352                case 0x041A : 
1353                    target[pos++] = 0x043A;
1354                    break;
1355        
1356                case 0x041B : 
1357                    target[pos++] = 0x043B;
1358                    break;
1359        
1360                case 0x041C : 
1361                    target[pos++] = 0x043C;
1362                    break;
1363        
1364                case 0x041D : 
1365                    target[pos++] = 0x043D;
1366                    break;
1367        
1368                case 0x041E : 
1369                    target[pos++] = 0x043E;
1370                    break;
1371        
1372                case 0x041F : 
1373                    target[pos++] = 0x043F;
1374                    break;
1375        
1376                case 0x0420 : 
1377                    target[pos++] = 0x0440;
1378                    break;
1379        
1380                case 0x0421 : 
1381                    target[pos++] = 0x0441;
1382                    break;
1383        
1384                case 0x0422 : 
1385                    target[pos++] = 0x0442;
1386                    break;
1387        
1388                case 0x0423 : 
1389                    target[pos++] = 0x0443;
1390                    break;
1391        
1392                case 0x0424 : 
1393                    target[pos++] = 0x0444;
1394                    break;
1395        
1396                case 0x0425 : 
1397                    target[pos++] = 0x0445;
1398                    break;
1399        
1400                case 0x0426 : 
1401                    target[pos++] = 0x0446;
1402                    break;
1403        
1404                case 0x0427 : 
1405                    target[pos++] = 0x0447;
1406                    break;
1407        
1408                case 0x0428 : 
1409                    target[pos++] = 0x0448;
1410                    break;
1411        
1412                case 0x0429 : 
1413                    target[pos++] = 0x0449;
1414                    break;
1415        
1416                case 0x042A : 
1417                    target[pos++] = 0x044A;
1418                    break;
1419        
1420                case 0x042B : 
1421                    target[pos++] = 0x044B;
1422                    break;
1423        
1424                case 0x042C : 
1425                    target[pos++] = 0x044C;
1426                    break;
1427        
1428                case 0x042D : 
1429                    target[pos++] = 0x044D;
1430                    break;
1431        
1432                case 0x042E : 
1433                    target[pos++] = 0x044E;
1434                    break;
1435        
1436                case 0x042F : 
1437                    target[pos++] = 0x044F;
1438                    break;
1439        
1440                case 0x0460 : 
1441                    target[pos++] = 0x0461;
1442                    break;
1443        
1444                case 0x0462 : 
1445                    target[pos++] = 0x0463;
1446                    break;
1447        
1448                case 0x0464 : 
1449                    target[pos++] = 0x0465;
1450                    break;
1451        
1452                case 0x0466 : 
1453                    target[pos++] = 0x0467;
1454                    break;
1455        
1456                case 0x0468 : 
1457                    target[pos++] = 0x0469;
1458                    break;
1459        
1460                case 0x046A : 
1461                    target[pos++] = 0x046B;
1462                    break;
1463        
1464                case 0x046C : 
1465                    target[pos++] = 0x046D;
1466                    break;
1467        
1468                case 0x046E : 
1469                    target[pos++] = 0x046F;
1470                    break;
1471        
1472                case 0x0470 : 
1473                    target[pos++] = 0x0471;
1474                    break;
1475        
1476                case 0x0472 : 
1477                    target[pos++] = 0x0473;
1478                    break;
1479        
1480                case 0x0474 : 
1481                    target[pos++] = 0x0475;
1482                    break;
1483        
1484                case 0x0476 : 
1485                    target[pos++] = 0x0477;
1486                    break;
1487        
1488                case 0x0478 : 
1489                    target[pos++] = 0x0479;
1490                    break;
1491        
1492                case 0x047A : 
1493                    target[pos++] = 0x047B;
1494                    break;
1495        
1496                case 0x047C : 
1497                    target[pos++] = 0x047D;
1498                    break;
1499        
1500                case 0x047E : 
1501                    target[pos++] = 0x047F;
1502                    break;
1503        
1504                case 0x0480 : 
1505                    target[pos++] = 0x0481;
1506                    break;
1507        
1508                case 0x048A : 
1509                    target[pos++] = 0x048B;
1510                    break;
1511        
1512                case 0x048C : 
1513                    target[pos++] = 0x048D;
1514                    break;
1515        
1516                case 0x048E : 
1517                    target[pos++] = 0x048F;
1518                    break;
1519        
1520                case 0x0490 : 
1521                    target[pos++] = 0x0491;
1522                    break;
1523        
1524                case 0x0492 : 
1525                    target[pos++] = 0x0493;
1526                    break;
1527        
1528                case 0x0494 : 
1529                    target[pos++] = 0x0495;
1530                    break;
1531        
1532                case 0x0496 : 
1533                    target[pos++] = 0x0497;
1534                    break;
1535        
1536                case 0x0498 : 
1537                    target[pos++] = 0x0499;
1538                    break;
1539        
1540                case 0x049A : 
1541                    target[pos++] = 0x049B;
1542                    break;
1543        
1544                case 0x049C : 
1545                    target[pos++] = 0x049D;
1546                    break;
1547        
1548                case 0x049E : 
1549                    target[pos++] = 0x049F;
1550                    break;
1551        
1552                case 0x04A0 : 
1553                    target[pos++] = 0x04A1;
1554                    break;
1555        
1556                case 0x04A2 : 
1557                    target[pos++] = 0x04A3;
1558                    break;
1559        
1560                case 0x04A4 : 
1561                    target[pos++] = 0x04A5;
1562                    break;
1563        
1564                case 0x04A6 : 
1565                    target[pos++] = 0x04A7;
1566                    break;
1567        
1568                case 0x04A8 : 
1569                    target[pos++] = 0x04A9;
1570                    break;
1571        
1572                case 0x04AA : 
1573                    target[pos++] = 0x04AB;
1574                    break;
1575        
1576                case 0x04AC : 
1577                    target[pos++] = 0x04AD;
1578                    break;
1579        
1580                case 0x04AE : 
1581                    target[pos++] = 0x04AF;
1582                    break;
1583        
1584                case 0x04B0 : 
1585                    target[pos++] = 0x04B1;
1586                    break;
1587        
1588                case 0x04B2 : 
1589                    target[pos++] = 0x04B3;
1590                    break;
1591        
1592                case 0x04B4 : 
1593                    target[pos++] = 0x04B5;
1594                    break;
1595        
1596                case 0x04B6 : 
1597                    target[pos++] = 0x04B7;
1598                    break;
1599        
1600                case 0x04B8 : 
1601                    target[pos++] = 0x04B9;
1602                    break;
1603        
1604                case 0x04BA : 
1605                    target[pos++] = 0x04BB;
1606                    break;
1607        
1608                case 0x04BC : 
1609                    target[pos++] = 0x04BD;
1610                    break;
1611        
1612                case 0x04BE : 
1613                    target[pos++] = 0x04BF;
1614                    break;
1615        
1616                case 0x04C1 : 
1617                    target[pos++] = 0x04C2;
1618                    break;
1619        
1620                case 0x04C3 : 
1621                    target[pos++] = 0x04C4;
1622                    break;
1623        
1624                case 0x04C5 : 
1625                    target[pos++] = 0x04C6;
1626                    break;
1627        
1628                case 0x04C7 : 
1629                    target[pos++] = 0x04C8;
1630                    break;
1631        
1632                case 0x04C9 : 
1633                    target[pos++] = 0x04CA;
1634                    break;
1635        
1636                case 0x04CB : 
1637                    target[pos++] = 0x04CC;
1638                    break;
1639        
1640                case 0x04CD : 
1641                    target[pos++] = 0x04CE;
1642                    break;
1643        
1644                case 0x04D0 : 
1645                    target[pos++] = 0x04D1;
1646                    break;
1647        
1648                case 0x04D2 : 
1649                    target[pos++] = 0x04D3;
1650                    break;
1651        
1652                case 0x04D4 : 
1653                    target[pos++] = 0x04D5;
1654                    break;
1655        
1656                case 0x04D6 : 
1657                    target[pos++] = 0x04D7;
1658                    break;
1659        
1660                case 0x04D8 : 
1661                    target[pos++] = 0x04D9;
1662                    break;
1663        
1664                case 0x04DA : 
1665                    target[pos++] = 0x04DB;
1666                    break;
1667        
1668                case 0x04DC : 
1669                    target[pos++] = 0x04DD;
1670                    break;
1671        
1672                case 0x04DE : 
1673                    target[pos++] = 0x04DF;
1674                    break;
1675        
1676                case 0x04E0 : 
1677                    target[pos++] = 0x04E1;
1678                    break;
1679        
1680                case 0x04E2 : 
1681                    target[pos++] = 0x04E3;
1682                    break;
1683        
1684                case 0x04E4 : 
1685                    target[pos++] = 0x04E5;
1686                    break;
1687        
1688                case 0x04E6 : 
1689                    target[pos++] = 0x04E7;
1690                    break;
1691        
1692                case 0x04E8 : 
1693                    target[pos++] = 0x04E9;
1694                    break;
1695        
1696                case 0x04EA : 
1697                    target[pos++] = 0x04EB;
1698                    break;
1699        
1700                case 0x04EC : 
1701                    target[pos++] = 0x04ED;
1702                    break;
1703        
1704                case 0x04EE : 
1705                    target[pos++] = 0x04EF;
1706                    break;
1707        
1708                case 0x04F0 : 
1709                    target[pos++] = 0x04F1;
1710                    break;
1711        
1712                case 0x04F2 : 
1713                    target[pos++] = 0x04F3;
1714                    break;
1715        
1716                case 0x04F4 : 
1717                    target[pos++] = 0x04F5;
1718                    break;
1719        
1720                case 0x04F8 : 
1721                    target[pos++] = 0x04F9;
1722                    break;
1723        
1724                case 0x0500 : 
1725                    target[pos++] = 0x0501;
1726                    break;
1727        
1728                case 0x0502 : 
1729                    target[pos++] = 0x0503;
1730                    break;
1731        
1732                case 0x0504 : 
1733                    target[pos++] = 0x0505;
1734                    break;
1735        
1736                case 0x0506 : 
1737                    target[pos++] = 0x0507;
1738                    break;
1739        
1740                case 0x0508 : 
1741                    target[pos++] = 0x0509;
1742                    break;
1743        
1744                case 0x050A : 
1745                    target[pos++] = 0x050B;
1746                    break;
1747        
1748                case 0x050C : 
1749                    target[pos++] = 0x050D;
1750                    break;
1751        
1752                case 0x050E : 
1753                    target[pos++] = 0x050F;
1754                    break;
1755        
1756                case 0x0531 : 
1757                    target[pos++] = 0x0561;
1758                    break;
1759        
1760                case 0x0532 : 
1761                    target[pos++] = 0x0562;
1762                    break;
1763        
1764                case 0x0533 : 
1765                    target[pos++] = 0x0563;
1766                    break;
1767        
1768                case 0x0534 : 
1769                    target[pos++] = 0x0564;
1770                    break;
1771        
1772                case 0x0535 : 
1773                    target[pos++] = 0x0565;
1774                    break;
1775        
1776                case 0x0536 : 
1777                    target[pos++] = 0x0566;
1778                    break;
1779        
1780                case 0x0537 : 
1781                    target[pos++] = 0x0567;
1782                    break;
1783        
1784                case 0x0538 : 
1785                    target[pos++] = 0x0568;
1786                    break;
1787        
1788                case 0x0539 : 
1789                    target[pos++] = 0x0569;
1790                    break;
1791        
1792                case 0x053A : 
1793                    target[pos++] = 0x056A;
1794                    break;
1795        
1796                case 0x053B : 
1797                    target[pos++] = 0x056B;
1798                    break;
1799        
1800                case 0x053C : 
1801                    target[pos++] = 0x056C;
1802                    break;
1803        
1804                case 0x053D : 
1805                    target[pos++] = 0x056D;
1806                    break;
1807        
1808                case 0x053E : 
1809                    target[pos++] = 0x056E;
1810                    break;
1811        
1812                case 0x053F : 
1813                    target[pos++] = 0x056F;
1814                    break;
1815        
1816                case 0x0540 : 
1817                    target[pos++] = 0x0570;
1818                    break;
1819        
1820                case 0x0541 : 
1821                    target[pos++] = 0x0571;
1822                    break;
1823        
1824                case 0x0542 : 
1825                    target[pos++] = 0x0572;
1826                    break;
1827        
1828                case 0x0543 : 
1829                    target[pos++] = 0x0573;
1830                    break;
1831        
1832                case 0x0544 : 
1833                    target[pos++] = 0x0574;
1834                    break;
1835        
1836                case 0x0545 : 
1837                    target[pos++] = 0x0575;
1838                    break;
1839        
1840                case 0x0546 : 
1841                    target[pos++] = 0x0576;
1842                    break;
1843        
1844                case 0x0547 : 
1845                    target[pos++] = 0x0577;
1846                    break;
1847        
1848                case 0x0548 : 
1849                    target[pos++] = 0x0578;
1850                    break;
1851        
1852                case 0x0549 : 
1853                    target[pos++] = 0x0579;
1854                    break;
1855        
1856                case 0x054A : 
1857                    target[pos++] = 0x057A;
1858                    break;
1859        
1860                case 0x054B : 
1861                    target[pos++] = 0x057B;
1862                    break;
1863        
1864                case 0x054C : 
1865                    target[pos++] = 0x057C;
1866                    break;
1867        
1868                case 0x054D : 
1869                    target[pos++] = 0x057D;
1870                    break;
1871        
1872                case 0x054E : 
1873                    target[pos++] = 0x057E;
1874                    break;
1875        
1876                case 0x054F : 
1877                    target[pos++] = 0x057F;
1878                    break;
1879        
1880                case 0x0550 : 
1881                    target[pos++] = 0x0580;
1882                    break;
1883        
1884                case 0x0551 : 
1885                    target[pos++] = 0x0581;
1886                    break;
1887        
1888                case 0x0552 : 
1889                    target[pos++] = 0x0582;
1890                    break;
1891        
1892                case 0x0553 : 
1893                    target[pos++] = 0x0583;
1894                    break;
1895        
1896                case 0x0554 : 
1897                    target[pos++] = 0x0584;
1898                    break;
1899        
1900                case 0x0555 : 
1901                    target[pos++] = 0x0585;
1902                    break;
1903        
1904                case 0x0556 : 
1905                    target[pos++] = 0x0586;
1906                    break;
1907        
1908                case 0x0587 : 
1909                    target[pos++] = 0x0565;
1910                    target[pos++] = 0x0582;
1911                    break;
1912        
1913                case 0x06DD : 
1914                    break;
1915        
1916                case 0x070F : 
1917                    break;
1918        
1919                case 0x1680 :
1920                    target[pos++] = 0x0020;
1921                    break;
1922        
1923                case 0x1806 : 
1924                    break;
1925        
1926                case 0x180B : 
1927                case 0x180C : 
1928                case 0x180D : 
1929                case 0x180E : 
1930                    break;
1931        
1932                    
1933                case 0x1E00 : 
1934                    target[pos++] = 0x1E01;
1935                    break;
1936        
1937                case 0x1E02 : 
1938                    target[pos++] = 0x1E03;
1939                    break;
1940        
1941                case 0x1E04 : 
1942                    target[pos++] = 0x1E05;
1943                    break;
1944        
1945                case 0x1E06 : 
1946                    target[pos++] = 0x1E07;
1947                    break;
1948        
1949                case 0x1E08 : 
1950                    target[pos++] = 0x1E09;
1951                    break;
1952        
1953                case 0x1E0A : 
1954                    target[pos++] = 0x1E0B;
1955                    break;
1956        
1957                case 0x1E0C : 
1958                    target[pos++] = 0x1E0D;
1959                    break;
1960        
1961                case 0x1E0E : 
1962                    target[pos++] = 0x1E0F;
1963                    break;
1964        
1965                case 0x1E10 : 
1966                    target[pos++] = 0x1E11;
1967                    break;
1968        
1969                case 0x1E12 : 
1970                    target[pos++] = 0x1E13;
1971                    break;
1972        
1973                case 0x1E14 : 
1974                    target[pos++] = 0x1E15;
1975                    break;
1976        
1977                case 0x1E16 : 
1978                    target[pos++] = 0x1E17;
1979                    break;
1980        
1981                case 0x1E18 : 
1982                    target[pos++] = 0x1E19;
1983                    break;
1984        
1985                case 0x1E1A : 
1986                    target[pos++] = 0x1E1B;
1987                    break;
1988        
1989                case 0x1E1C : 
1990                    target[pos++] = 0x1E1D;
1991                    break;
1992        
1993                case 0x1E1E : 
1994                    target[pos++] = 0x1E1F;
1995                    break;
1996        
1997                case 0x1E20 : 
1998                    target[pos++] = 0x1E21;
1999                    break;
2000        
2001                case 0x1E22 : 
2002                    target[pos++] = 0x1E23;
2003                    break;
2004        
2005                case 0x1E24 : 
2006                    target[pos++] = 0x1E25;
2007                    break;
2008        
2009                case 0x1E26 : 
2010                    target[pos++] = 0x1E27;
2011                    break;
2012        
2013                case 0x1E28 : 
2014                    target[pos++] = 0x1E29;
2015                    break;
2016        
2017                case 0x1E2A : 
2018                    target[pos++] = 0x1E2B;
2019                    break;
2020        
2021                case 0x1E2C : 
2022                    target[pos++] = 0x1E2D;
2023                    break;
2024        
2025                case 0x1E2E : 
2026                    target[pos++] = 0x1E2F;
2027                    break;
2028        
2029                case 0x1E30 : 
2030                    target[pos++] = 0x1E31;
2031                    break;
2032        
2033                case 0x1E32 : 
2034                    target[pos++] = 0x1E33;
2035                    break;
2036        
2037                case 0x1E34 : 
2038                    target[pos++] = 0x1E35;
2039                    break;
2040        
2041                case 0x1E36 : 
2042                    target[pos++] = 0x1E37;
2043                    break;
2044        
2045                case 0x1E38 : 
2046                    target[pos++] = 0x1E39;
2047                    break;
2048        
2049                case 0x1E3A : 
2050                    target[pos++] = 0x1E3B;
2051                    break;
2052        
2053                case 0x1E3C : 
2054                    target[pos++] = 0x1E3D;
2055                    break;
2056        
2057                case 0x1E3E : 
2058                    target[pos++] = 0x1E3F;
2059                    break;
2060        
2061                case 0x1E40 : 
2062                    target[pos++] = 0x1E41;
2063                    break;
2064        
2065                case 0x1E42 : 
2066                    target[pos++] = 0x1E43;
2067                    break;
2068        
2069                case 0x1E44 : 
2070                    target[pos++] = 0x1E45;
2071                    break;
2072        
2073                case 0x1E46 : 
2074                    target[pos++] = 0x1E47;
2075                    break;
2076        
2077                case 0x1E48 : 
2078                    target[pos++] = 0x1E49;
2079                    break;
2080        
2081                case 0x1E4A : 
2082                    target[pos++] = 0x1E4B;
2083                    break;
2084        
2085                case 0x1E4C : 
2086                    target[pos++] = 0x1E4D;
2087                    break;
2088        
2089                case 0x1E4E : 
2090                    target[pos++] = 0x1E4F;
2091                    break;
2092        
2093                case 0x1E50 : 
2094                    target[pos++] = 0x1E51;
2095                    break;
2096        
2097                case 0x1E52 : 
2098                    target[pos++] = 0x1E53;
2099                    break;
2100        
2101                case 0x1E54 : 
2102                    target[pos++] = 0x1E55;
2103                    break;
2104        
2105                case 0x1E56 : 
2106                    target[pos++] = 0x1E57;
2107                    break;
2108        
2109                case 0x1E58 : 
2110                    target[pos++] = 0x1E59;
2111                    break;
2112        
2113                case 0x1E5A : 
2114                    target[pos++] = 0x1E5B;
2115                    break;
2116        
2117                case 0x1E5C : 
2118                    target[pos++] = 0x1E5D;
2119                    break;
2120        
2121                case 0x1E5E : 
2122                    target[pos++] = 0x1E5F;
2123                    break;
2124        
2125                case 0x1E60 : 
2126                    target[pos++] = 0x1E61;
2127                    break;
2128        
2129                case 0x1E62 : 
2130                    target[pos++] = 0x1E63;
2131                    break;
2132        
2133                case 0x1E64 : 
2134                    target[pos++] = 0x1E65;
2135                    break;
2136        
2137                case 0x1E66 : 
2138                    target[pos++] = 0x1E67;
2139                    break;
2140        
2141                case 0x1E68 : 
2142                    target[pos++] = 0x1E69;
2143                    break;
2144        
2145                case 0x1E6A : 
2146                    target[pos++] = 0x1E6B;
2147                    break;
2148        
2149                case 0x1E6C : 
2150                    target[pos++] = 0x1E6D;
2151                    break;
2152        
2153                case 0x1E6E : 
2154                    target[pos++] = 0x1E6F;
2155                    break;
2156        
2157                case 0x1E70 : 
2158                    target[pos++] = 0x1E71;
2159                    break;
2160        
2161                case 0x1E72 : 
2162                    target[pos++] = 0x1E73;
2163                    break;
2164        
2165                case 0x1E74 : 
2166                    target[pos++] = 0x1E75;
2167                    break;
2168        
2169                case 0x1E76 : 
2170                    target[pos++] = 0x1E77;
2171                    break;
2172        
2173                case 0x1E78 : 
2174                    target[pos++] = 0x1E79;
2175                    break;
2176        
2177                case 0x1E7A : 
2178                    target[pos++] = 0x1E7B;
2179                    break;
2180        
2181                case 0x1E7C : 
2182                    target[pos++] = 0x1E7D;
2183                    break;
2184        
2185                case 0x1E7E : 
2186                    target[pos++] = 0x1E7F;
2187                    break;
2188        
2189                case 0x1E80 : 
2190                    target[pos++] = 0x1E81;
2191                    break;
2192        
2193                case 0x1E82 : 
2194                    target[pos++] = 0x1E83;
2195                    break;
2196        
2197                case 0x1E84 : 
2198                    target[pos++] = 0x1E85;
2199                    break;
2200        
2201                case 0x1E86 : 
2202                    target[pos++] = 0x1E87;
2203                    break;
2204        
2205                case 0x1E88 : 
2206                    target[pos++] = 0x1E89;
2207                    break;
2208        
2209                case 0x1E8A : 
2210                    target[pos++] = 0x1E8B;
2211                    break;
2212        
2213                case 0x1E8C : 
2214                    target[pos++] = 0x1E8D;
2215                    break;
2216        
2217                case 0x1E8E : 
2218                    target[pos++] = 0x1E8F;
2219                    break;
2220        
2221                case 0x1E90 : 
2222                    target[pos++] = 0x1E91;
2223                    break;
2224        
2225                case 0x1E92 : 
2226                    target[pos++] = 0x1E93;
2227                    break;
2228        
2229                case 0x1E94 : 
2230                    target[pos++] = 0x1E95;
2231                    break;
2232        
2233                case 0x1E96 : 
2234                    target[pos++] = 0x0068;
2235                    target[pos++] = 0x0331;
2236                    break;
2237        
2238                case 0x1E97 : 
2239                    target[pos++] = 0x0074;
2240                    target[pos++] = 0x0308;
2241                    break;
2242        
2243                case 0x1E98 : 
2244                    target[pos++] = 0x0077;
2245                    target[pos++] = 0x030A;
2246                    break;
2247        
2248                case 0x1E99 : 
2249                    target[pos++] = 0x0079;
2250                    target[pos++] = 0x030A;
2251                    break;
2252        
2253                case 0x1E9A : 
2254                    target[pos++] = 0x0061;
2255                    target[pos++] = 0x02BE;
2256                    break;
2257        
2258                case 0x1E9B : 
2259                    target[pos++] = 0x1E61;
2260                    break;
2261        
2262                case 0x1EA0 : 
2263                    target[pos++] = 0x1EA1;
2264                    break;
2265        
2266                case 0x1EA2 : 
2267                    target[pos++] = 0x1EA3;
2268                    break;
2269        
2270                case 0x1EA4 : 
2271                    target[pos++] = 0x1EA5;
2272                    break;
2273        
2274                case 0x1EA6 : 
2275                    target[pos++] = 0x1EA7;
2276                    break;
2277        
2278                case 0x1EA8 : 
2279                    target[pos++] = 0x1EA9;
2280                    break;
2281        
2282                case 0x1EAA : 
2283                    target[pos++] = 0x1EAB;
2284                    break;
2285        
2286                case 0x1EAC : 
2287                    target[pos++] = 0x1EAD;
2288                    break;
2289        
2290                case 0x1EAE : 
2291                    target[pos++] = 0x1EAF;
2292                    break;
2293        
2294                case 0x1EB0 : 
2295                    target[pos++] = 0x1EB1;
2296                    break;
2297        
2298                case 0x1EB2 : 
2299                    target[pos++] = 0x1EB3;
2300                    break;
2301        
2302                case 0x1EB4 : 
2303                    target[pos++] = 0x1EB5;
2304                    break;
2305        
2306                case 0x1EB6 : 
2307                    target[pos++] = 0x1EB7;
2308                    break;
2309        
2310                case 0x1EB8 : 
2311                    target[pos++] = 0x1EB9;
2312                    break;
2313        
2314                case 0x1EBA : 
2315                    target[pos++] = 0x1EBB;
2316                    break;
2317        
2318                case 0x1EBC : 
2319                    target[pos++] = 0x1EBD;
2320                    break;
2321        
2322                case 0x1EBE : 
2323                    target[pos++] = 0x1EBF;
2324                    break;
2325        
2326                case 0x1EC0 : 
2327                    target[pos++] = 0x1EC1;
2328                    break;
2329        
2330                case 0x1EC2 : 
2331                    target[pos++] = 0x1EC3;
2332                    break;
2333        
2334                case 0x1EC4 : 
2335                    target[pos++] = 0x1EC5;
2336                    break;
2337        
2338                case 0x1EC6 : 
2339                    target[pos++] = 0x1EC7;
2340                    break;
2341        
2342                case 0x1EC8 : 
2343                    target[pos++] = 0x1EC9;
2344                    break;
2345        
2346                case 0x1ECA : 
2347                    target[pos++] = 0x1ECB;
2348                    break;
2349        
2350                case 0x1ECC : 
2351                    target[pos++] = 0x1ECD;
2352                    break;
2353        
2354                case 0x1ECE : 
2355                    target[pos++] = 0x1ECF;
2356                    break;
2357        
2358                case 0x1ED0 : 
2359                    target[pos++] = 0x1ED1;
2360                    break;
2361        
2362                case 0x1ED2 : 
2363                    target[pos++] = 0x1ED3;
2364                    break;
2365        
2366                case 0x1ED4 : 
2367                    target[pos++] = 0x1ED5;
2368                    break;
2369        
2370                case 0x1ED6 : 
2371                    target[pos++] = 0x1ED7;
2372                    break;
2373        
2374                case 0x1ED8 : 
2375                    target[pos++] = 0x1ED9;
2376                    break;
2377        
2378                case 0x1EDA : 
2379                    target[pos++] = 0x1EDB;
2380                    break;
2381        
2382                case 0x1EDC : 
2383                    target[pos++] = 0x1EDD;
2384                    break;
2385        
2386                case 0x1EDE : 
2387                    target[pos++] = 0x1EDF;
2388                    break;
2389        
2390                case 0x1EE0 : 
2391                    target[pos++] = 0x1EE1;
2392                    break;
2393        
2394                case 0x1EE2 : 
2395                    target[pos++] = 0x1EE3;
2396                    break;
2397        
2398                case 0x1EE4 : 
2399                    target[pos++] = 0x1EE5;
2400                    break;
2401        
2402                case 0x1EE6 : 
2403                    target[pos++] = 0x1EE7;
2404                    break;
2405        
2406                case 0x1EE8 : 
2407                    target[pos++] = 0x1EE9;
2408                    break;
2409        
2410                case 0x1EEA : 
2411                    target[pos++] = 0x1EEB;
2412                    break;
2413        
2414                case 0x1EEC : 
2415                    target[pos++] = 0x1EED;
2416                    break;
2417        
2418                case 0x1EEE : 
2419                    target[pos++] = 0x1EEF;
2420                    break;
2421        
2422                case 0x1EF0 : 
2423                    target[pos++] = 0x1EF1;
2424                    break;
2425        
2426                case 0x1EF2 : 
2427                    target[pos++] = 0x1EF3;
2428                    break;
2429        
2430                case 0x1EF4 : 
2431                    target[pos++] = 0x1EF5;
2432                    break;
2433        
2434                case 0x1EF6 : 
2435                    target[pos++] = 0x1EF7;
2436                    break;
2437        
2438                case 0x1EF8 : 
2439                    target[pos++] = 0x1EF9;
2440                    break;
2441        
2442                case 0x1F08 : 
2443                    target[pos++] = 0x1F00;
2444                    break;
2445        
2446                case 0x1F09 : 
2447                    target[pos++] = 0x1F01;
2448                    break;
2449        
2450                case 0x1F0A : 
2451                    target[pos++] = 0x1F02;
2452                    break;
2453        
2454                case 0x1F0B : 
2455                    target[pos++] = 0x1F03;
2456                    break;
2457        
2458                case 0x1F0C : 
2459                    target[pos++] = 0x1F04;
2460                    break;
2461        
2462                case 0x1F0D : 
2463                    target[pos++] = 0x1F05;
2464                    break;
2465        
2466                case 0x1F0E : 
2467                    target[pos++] = 0x1F06;
2468                    break;
2469        
2470                case 0x1F0F : 
2471                    target[pos++] = 0x1F07;
2472                    break;
2473        
2474                case 0x1F18 : 
2475                    target[pos++] = 0x1F10;
2476                    break;
2477        
2478                case 0x1F19 : 
2479                    target[pos++] = 0x1F11;
2480                    break;
2481        
2482                case 0x1F1A : 
2483                    target[pos++] = 0x1F12;
2484                    break;
2485        
2486                case 0x1F1B : 
2487                    target[pos++] = 0x1F13;
2488                    break;
2489        
2490                case 0x1F1C : 
2491                    target[pos++] = 0x1F14;
2492                    break;
2493        
2494                case 0x1F1D : 
2495                    target[pos++] = 0x1F15;
2496                    break;
2497        
2498                case 0x1F28 : 
2499                    target[pos++] = 0x1F20;
2500                    break;
2501        
2502                case 0x1F29 : 
2503                    target[pos++] = 0x1F21;
2504                    break;
2505        
2506                case 0x1F2A : 
2507                    target[pos++] = 0x1F22;
2508                    break;
2509        
2510                case 0x1F2B : 
2511                    target[pos++] = 0x1F23;
2512                    break;
2513        
2514                case 0x1F2C : 
2515                    target[pos++] = 0x1F24;
2516                    break;
2517        
2518                case 0x1F2D : 
2519                    target[pos++] = 0x1F25;
2520                    break;
2521        
2522                case 0x1F2E : 
2523                    target[pos++] = 0x1F26;
2524                    break;
2525        
2526                case 0x1F2F : 
2527                    target[pos++] = 0x1F27;
2528                    break;
2529        
2530                case 0x1F38 : 
2531                    target[pos++] = 0x1F30;
2532                    break;
2533        
2534                case 0x1F39 : 
2535                    target[pos++] = 0x1F31;
2536                    break;
2537        
2538                case 0x1F3A : 
2539                    target[pos++] = 0x1F32;
2540                    break;
2541        
2542                case 0x1F3B : 
2543                    target[pos++] = 0x1F33;
2544                    break;
2545        
2546                case 0x1F3C : 
2547                    target[pos++] = 0x1F34;
2548                    break;
2549        
2550                case 0x1F3D : 
2551                    target[pos++] = 0x1F35;
2552                    break;
2553        
2554                case 0x1F3E : 
2555                    target[pos++] = 0x1F36;
2556                    break;
2557        
2558                case 0x1F3F : 
2559                    target[pos++] = 0x1F37;
2560                    break;
2561        
2562                case 0x1F48 : 
2563                    target[pos++] = 0x1F40;
2564                    break;
2565        
2566                case 0x1F49 : 
2567                    target[pos++] = 0x1F41;
2568                    break;
2569        
2570                case 0x1F4A : 
2571                    target[pos++] = 0x1F42;
2572                    break;
2573        
2574                case 0x1F4B : 
2575                    target[pos++] = 0x1F43;
2576                    break;
2577        
2578                case 0x1F4C : 
2579                    target[pos++] = 0x1F44;
2580                    break;
2581        
2582                case 0x1F4D : 
2583                    target[pos++] = 0x1F45;
2584                    break;
2585        
2586                case 0x1F50 : 
2587                    target[pos++] = 0x03C5;
2588                    target[pos++] = 0x0313;
2589                    break;
2590        
2591                case 0x1F52 : 
2592                    target[pos++] = 0x03C5;
2593                    target[pos++] = 0x0313;
2594                    target[pos++] = 0x0300;
2595                    break;
2596        
2597                case 0x1F54 : 
2598                    target[pos++] = 0x03C5;
2599                    target[pos++] = 0x0313;
2600                    target[pos++] = 0x0301;
2601                    break;
2602        
2603                case 0x1F56 : 
2604                    target[pos++] = 0x03C5;
2605                    target[pos++] = 0x0313;
2606                    target[pos++] = 0x0342;
2607                    break;
2608        
2609                case 0x1F59 : 
2610                    target[pos++] = 0x1F51;
2611                    break;
2612        
2613                case 0x1F5B : 
2614                    target[pos++] = 0x1F53;
2615                    break;
2616        
2617                case 0x1F5D : 
2618                    target[pos++] = 0x1F55;
2619                    break;
2620        
2621                case 0x1F5F : 
2622                    target[pos++] = 0x1F57;
2623                    break;
2624        
2625                case 0x1F68 : 
2626                    target[pos++] = 0x1F60;
2627                    break;
2628        
2629                case 0x1F69 : 
2630                    target[pos++] = 0x1F61;
2631                    break;
2632        
2633                case 0x1F6A : 
2634                    target[pos++] = 0x1F62;
2635                    break;
2636        
2637                case 0x1F6B : 
2638                    target[pos++] = 0x1F63;
2639                    break;
2640        
2641                case 0x1F6C : 
2642                    target[pos++] = 0x1F64;
2643                    break;
2644        
2645                case 0x1F6D : 
2646                    target[pos++] = 0x1F65;
2647                    break;
2648        
2649                case 0x1F6E : 
2650                    target[pos++] = 0x1F66;
2651                    break;
2652        
2653                case 0x1F6F : 
2654                    target[pos++] = 0x1F67;
2655                    break;
2656        
2657                case 0x1F80 : 
2658                    target[pos++] = 0x1F00;
2659                    target[pos++] = 0x03B9;
2660                    break;
2661        
2662                case 0x1F81 : 
2663                    target[pos++] = 0x1F01;
2664                    target[pos++] = 0x03B9;
2665                    break;
2666        
2667                case 0x1F82 : 
2668                    target[pos++] = 0x1F02;
2669                    target[pos++] = 0x03B9;
2670                    break;
2671        
2672                case 0x1F83 : 
2673                    target[pos++] = 0x1F03;
2674                    target[pos++] = 0x03B9;
2675                    break;
2676        
2677                case 0x1F84 : 
2678                    target[pos++] = 0x1F04;
2679                    target[pos++] = 0x03B9;
2680                    break;
2681        
2682                case 0x1F85 : 
2683                    target[pos++] = 0x1F05;
2684                    target[pos++] = 0x03B9;
2685                    break;
2686        
2687                case 0x1F86 : 
2688                    target[pos++] = 0x1F06;
2689                    target[pos++] = 0x03B9;
2690                    break;
2691        
2692                case 0x1F87 : 
2693                    target[pos++] = 0x1F07;
2694                    target[pos++] = 0x03B9;
2695                    break;
2696        
2697                case 0x1F88 : 
2698                    target[pos++] = 0x1F00;
2699                    target[pos++] = 0x03B9;
2700                    break;
2701        
2702                case 0x1F89 : 
2703                    target[pos++] = 0x1F01;
2704                    target[pos++] = 0x03B9;
2705                    break;
2706        
2707                case 0x1F8A : 
2708                    target[pos++] = 0x1F02;
2709                    target[pos++] = 0x03B9;
2710                    break;
2711        
2712                case 0x1F8B : 
2713                    target[pos++] = 0x1F03;
2714                    target[pos++] = 0x03B9;
2715                    break;
2716        
2717                case 0x1F8C : 
2718                    target[pos++] = 0x1F04;
2719                    target[pos++] = 0x03B9;
2720                    break;
2721        
2722                case 0x1F8D : 
2723                    target[pos++] = 0x1F05;
2724                    target[pos++] = 0x03B9;
2725                    break;
2726        
2727                case 0x1F8E : 
2728                    target[pos++] = 0x1F06;
2729                    target[pos++] = 0x03B9;
2730                    break;
2731        
2732                case 0x1F8F : 
2733                    target[pos++] = 0x1F07;
2734                    target[pos++] = 0x03B9;
2735                    break;
2736        
2737                case 0x1F90 : 
2738                    target[pos++] = 0x1F20;
2739                    target[pos++] = 0x03B9;
2740                    break;
2741        
2742                case 0x1F91 : 
2743                    target[pos++] = 0x1F21;
2744                    target[pos++] = 0x03B9;
2745                    break;
2746        
2747                case 0x1F92 : 
2748                    target[pos++] = 0x1F22;
2749                    target[pos++] = 0x03B9;
2750                    break;
2751        
2752                case 0x1F93 : 
2753                    target[pos++] = 0x1F23;
2754                    target[pos++] = 0x03B9;
2755                    break;
2756        
2757                case 0x1F94 : 
2758                    target[pos++] = 0x1F24;
2759                    target[pos++] = 0x03B9;
2760                    break;
2761        
2762                case 0x1F95 : 
2763                    target[pos++] = 0x1F25;
2764                    target[pos++] = 0x03B9;
2765                    break;
2766        
2767                case 0x1F96 : 
2768                    target[pos++] = 0x1F26;
2769                    target[pos++] = 0x03B9;
2770                    break;
2771        
2772                case 0x1F97 : 
2773                    target[pos++] = 0x1F27;
2774                    target[pos++] = 0x03B9;
2775                    break;
2776        
2777                case 0x1F98 : 
2778                    target[pos++] = 0x1F20;
2779                    target[pos++] = 0x03B9;
2780                    break;
2781        
2782                case 0x1F99 : 
2783                    target[pos++] = 0x1F21;
2784                    target[pos++] = 0x03B9;
2785                    break;
2786        
2787                case 0x1F9A : 
2788                    target[pos++] = 0x1F22;
2789                    target[pos++] = 0x03B9;
2790                    break;
2791        
2792                case 0x1F9B : 
2793                    target[pos++] = 0x1F23;
2794                    target[pos++] = 0x03B9;
2795                    break;
2796        
2797                case 0x1F9C : 
2798                    target[pos++] = 0x1F24;
2799                    target[pos++] = 0x03B9;
2800                    break;
2801        
2802                case 0x1F9D : 
2803                    target[pos++] = 0x1F25;
2804                    target[pos++] = 0x03B9;
2805                    break;
2806        
2807                case 0x1F9E : 
2808                    target[pos++] = 0x1F26;
2809                    target[pos++] = 0x03B9;
2810                    break;
2811        
2812                case 0x1F9F : 
2813                    target[pos++] = 0x1F27;
2814                    target[pos++] = 0x03B9;
2815                    break;
2816        
2817                case 0x1FA0 : 
2818                    target[pos++] = 0x1F60;
2819                    target[pos++] = 0x03B9;
2820                    break;
2821        
2822                case 0x1FA1 : 
2823                    target[pos++] = 0x1F61;
2824                    target[pos++] = 0x03B9;
2825                    break;
2826        
2827                case 0x1FA2 : 
2828                    target[pos++] = 0x1F62;
2829                    target[pos++] = 0x03B9;
2830                    break;
2831        
2832                case 0x1FA3 : 
2833                    target[pos++] = 0x1F63;
2834                    target[pos++] = 0x03B9;
2835                    break;
2836        
2837                case 0x1FA4 : 
2838                    target[pos++] = 0x1F64;
2839                    target[pos++] = 0x03B9;
2840                    break;
2841        
2842                case 0x1FA5 : 
2843                    target[pos++] = 0x1F65;
2844                    target[pos++] = 0x03B9;
2845                    break;
2846        
2847                case 0x1FA6 : 
2848                    target[pos++] = 0x1F66;
2849                    target[pos++] = 0x03B9;
2850                    break;
2851        
2852                case 0x1FA7 : 
2853                    target[pos++] = 0x1F67;
2854                    target[pos++] = 0x03B9;
2855                    break;
2856        
2857                case 0x1FA8 : 
2858                    target[pos++] = 0x1F60;
2859                    target[pos++] = 0x03B9;
2860                    break;
2861        
2862                case 0x1FA9 : 
2863                    target[pos++] = 0x1F61;
2864                    target[pos++] = 0x03B9;
2865                    break;
2866        
2867                case 0x1FAA : 
2868                    target[pos++] = 0x1F62;
2869                    target[pos++] = 0x03B9;
2870                    break;
2871        
2872                case 0x1FAB : 
2873                    target[pos++] = 0x1F63;
2874                    target[pos++] = 0x03B9;
2875                    break;
2876        
2877                case 0x1FAC : 
2878                    target[pos++] = 0x1F64;
2879                    target[pos++] = 0x03B9;
2880                    break;
2881        
2882                case 0x1FAD : 
2883                    target[pos++] = 0x1F65;
2884                    target[pos++] = 0x03B9;
2885                    break;
2886        
2887                case 0x1FAE : 
2888                    target[pos++] = 0x1F66;
2889                    target[pos++] = 0x03B9;
2890                    break;
2891        
2892                case 0x1FAF : 
2893                    target[pos++] = 0x1F67;
2894                    target[pos++] = 0x03B9;
2895                    break;
2896        
2897                case 0x1FB2 : 
2898                    target[pos++] = 0x1F70;
2899                    target[pos++] = 0x03B9;
2900                    break;
2901        
2902                case 0x1FB3 : 
2903                    target[pos++] = 0x03B1;
2904                    target[pos++] = 0x03B9;
2905                    break;
2906        
2907                case 0x1FB4 : 
2908                    target[pos++] = 0x03AC;
2909                    target[pos++] = 0x03B9;
2910                    break;
2911        
2912                case 0x1FB6 : 
2913                    target[pos++] = 0x03B1;
2914                    target[pos++] = 0x0342;
2915                    break;
2916        
2917                case 0x1FB7 : 
2918                    target[pos++] = 0x03B1;
2919                    target[pos++] = 0x0342;
2920                    target[pos++] = 0x03B9;
2921                    break;
2922        
2923                case 0x1FB8 : 
2924                    target[pos++] = 0x1FB0;
2925                    break;
2926        
2927                case 0x1FB9 : 
2928                    target[pos++] = 0x1FB1;
2929                    break;
2930        
2931                case 0x1FBA : 
2932                    target[pos++] = 0x1F70;
2933                    break;
2934        
2935                case 0x1FBB : 
2936                    target[pos++] = 0x1F71;
2937                    break;
2938        
2939                case 0x1FBC : 
2940                    target[pos++] = 0x03B1;
2941                    target[pos++] = 0x03B9;
2942                    break;
2943        
2944                case 0x1FBE : 
2945                    target[pos++] = 0x03B9;
2946                    break;
2947        
2948                case 0x1FC2 : 
2949                    target[pos++] = 0x1F74;
2950                    target[pos++] = 0x03B9;
2951                    break;
2952        
2953                case 0x1FC3 : 
2954                    target[pos++] = 0x03B7;
2955                    target[pos++] = 0x03B9;
2956                    break;
2957        
2958                case 0x1FC4 : 
2959                    target[pos++] = 0x03AE;
2960                    target[pos++] = 0x03B9;
2961                    break;
2962        
2963                case 0x1FC6 : 
2964                    target[pos++] = 0x03B7;
2965                    target[pos++] = 0x0342;
2966                    break;
2967        
2968                case 0x1FC7 : 
2969                    target[pos++] = 0x03B7;
2970                    target[pos++] = 0x0342;
2971                    target[pos++] = 0x03B9;
2972                    break;
2973        
2974                case 0x1FC8 : 
2975                    target[pos++] = 0x1F72;
2976                    break;
2977        
2978                case 0x1FC9 : 
2979                    target[pos++] = 0x1F73;
2980                    break;
2981        
2982                case 0x1FCA : 
2983                    target[pos++] = 0x1F74;
2984                    break;
2985        
2986                case 0x1FCB : 
2987                    target[pos++] = 0x1F75;
2988                    break;
2989        
2990                case 0x1FCC : 
2991                    target[pos++] = 0x03B7;
2992                    target[pos++] = 0x03B9;
2993                    break;
2994        
2995                case 0x1FD2 : 
2996                    target[pos++] = 0x03B9;
2997                    target[pos++] = 0x0308;
2998                    target[pos++] = 0x0300;
2999                    break;
3000        
3001                case 0x1FD3 : 
3002                    target[pos++] = 0x03B9;
3003                    target[pos++] = 0x0308;
3004                    target[pos++] = 0x0301;
3005                    break;
3006        
3007                case 0x1FD6 : 
3008                    target[pos++] = 0x03B9;
3009                    target[pos++] = 0x0342;
3010                    break;
3011        
3012                case 0x1FD7 : 
3013                    target[pos++] = 0x03B9;
3014                    target[pos++] = 0x0308;
3015                    target[pos++] = 0x0342;
3016                    break;
3017        
3018                case 0x1FD8 : 
3019                    target[pos++] = 0x1FD0;
3020                    break;
3021        
3022                case 0x1FD9 : 
3023                    target[pos++] = 0x1FD1;
3024                    break;
3025        
3026                case 0x1FDA : 
3027                    target[pos++] = 0x1F76;
3028                    break;
3029        
3030                case 0x1FDB : 
3031                    target[pos++] = 0x1F77;
3032                    break;
3033        
3034                case 0x1FE2 : 
3035                    target[pos++] = 0x03C5;
3036                    target[pos++] = 0x0308;
3037                    target[pos++] = 0x0300;
3038                    break;
3039        
3040                case 0x1FE3 : 
3041                    target[pos++] = 0x03C5;
3042                    target[pos++] = 0x0308;
3043                    target[pos++] = 0x0301;
3044                    break;
3045        
3046                case 0x1FE4 : 
3047                    target[pos++] = 0x03C1;
3048                    target[pos++] = 0x0313;
3049                    break;
3050        
3051                case 0x1FE6 : 
3052                    target[pos++] = 0x03C5;
3053                    target[pos++] = 0x0342;
3054                    break;
3055        
3056                case 0x1FE7 : 
3057                    target[pos++] = 0x03C5;
3058                    target[pos++] = 0x0308;
3059                    target[pos++] = 0x0342;
3060                    break;
3061        
3062                case 0x1FE8 : 
3063                    target[pos++] = 0x1FE0;
3064                    break;
3065        
3066                case 0x1FE9 : 
3067                    target[pos++] = 0x1FE1;
3068                    break;
3069        
3070                case 0x1FEA : 
3071                    target[pos++] = 0x1F7A;
3072                    break;
3073        
3074                case 0x1FEB : 
3075                    target[pos++] = 0x1F7B;
3076                    break;
3077        
3078                case 0x1FEC : 
3079                    target[pos++] = 0x1FE5;
3080                    break;
3081        
3082                case 0x1FF2 : 
3083                    target[pos++] = 0x1F7C;
3084                    target[pos++] = 0x03B9;
3085                    break;
3086        
3087                case 0x1FF3 : 
3088                    target[pos++] = 0x03C9;
3089                    target[pos++] = 0x03B9;
3090                    break;
3091        
3092                case 0x1FF4 : 
3093                    target[pos++] = 0x03CE;
3094                    target[pos++] = 0x03B9;
3095                    break;
3096        
3097                case 0x1FF6 : 
3098                    target[pos++] = 0x03C9;
3099                    target[pos++] = 0x0342;
3100                    break;
3101        
3102                case 0x1FF7 : 
3103                    target[pos++] = 0x03C9;
3104                    target[pos++] = 0x0342;
3105                    target[pos++] = 0x03B9;
3106                    break;
3107        
3108                case 0x1FF8 : 
3109                    target[pos++] = 0x1F78;
3110                    break;
3111        
3112                case 0x1FF9 : 
3113                    target[pos++] = 0x1F79;
3114                    break;
3115        
3116                case 0x1FFA : 
3117                    target[pos++] = 0x1F7C;
3118                    break;
3119        
3120                case 0x1FFB : 
3121                    target[pos++] = 0x1F7D;
3122                    break;
3123        
3124                case 0x1FFC : 
3125                    target[pos++] = 0x03C9;
3126                    target[pos++] = 0x03B9;
3127                    break;
3128        
3129                case 0x2000 :
3130                case 0x2001 :
3131                case 0x2002 :
3132                case 0x2003 :
3133                case 0x2004 :
3134                case 0x2005 :
3135                case 0x2006 :
3136                case 0x2007 :
3137                case 0x2008 :
3138                case 0x2009 :
3139                case 0x200A :
3140                    target[pos++] = 0x0020;
3141                    break;
3142        
3143                case 0x200B :
3144                case 0x200C :
3145                case 0x200D :
3146                case 0x200E :
3147                case 0x200F :
3148                    break;
3149        
3150                case 0x2028 :
3151                case 0x2029 :
3152                    target[pos++] = 0x0020;
3153                    break;
3154        
3155                case 0x202A :
3156                case 0x202B :
3157                case 0x202C :
3158                case 0x202D :
3159                case 0x202E :
3160                    break;
3161        
3162                case 0x202F :
3163                    target[pos++] = 0x0020;
3164                    break;
3165        
3166                case 0x205F :
3167                    target[pos++] = 0x0020;
3168                    break;
3169        
3170                case 0x2060 :
3171                case 0x2061 :
3172                case 0x2062 :
3173                case 0x2063 :
3174                    break;
3175        
3176                case 0x206A :
3177                case 0x206B :
3178                case 0x206C :
3179                case 0x206D :
3180                case 0x206E :
3181                case 0x206F :
3182                    break;
3183        
3184                case 0x20A8 : 
3185                    target[pos++] = 0x0072;
3186                    target[pos++] = 0x0073;
3187                    break;
3188        
3189                case 0x2102 : 
3190                    target[pos++] = 0x0063;
3191                    break;
3192        
3193                case 0x2103 : 
3194                    target[pos++] = 0x00B0;
3195                    target[pos++] = 0x0063;
3196                    break;
3197        
3198                case 0x2107 : 
3199                    target[pos++] = 0x025B;
3200                    break;
3201        
3202                case 0x2109 : 
3203                    target[pos++] = 0x00B0;
3204                    target[pos++] = 0x0066;
3205                    break;
3206        
3207                case 0x210B : 
3208                    target[pos++] = 0x0068;
3209                    break;
3210        
3211                case 0x210C : 
3212                    target[pos++] = 0x0068;
3213                    break;
3214        
3215                case 0x210D : 
3216                    target[pos++] = 0x0068;
3217                    break;
3218        
3219                case 0x2110 : 
3220                    target[pos++] = 0x0069;
3221                    break;
3222        
3223                case 0x2111 : 
3224                    target[pos++] = 0x0069;
3225                    break;
3226        
3227                case 0x2112 : 
3228                    target[pos++] = 0x006C;
3229                    break;
3230        
3231                case 0x2115 : 
3232                    target[pos++] = 0x006E;
3233                    break;
3234        
3235                case 0x2116 : 
3236                    target[pos++] = 0x006E;
3237                    target[pos++] = 0x006F;
3238                    break;
3239        
3240                case 0x2119 : 
3241                    target[pos++] = 0x0070;
3242                    break;
3243        
3244                case 0x211A : 
3245                    target[pos++] = 0x0071;
3246                    break;
3247        
3248                case 0x211B : 
3249                    target[pos++] = 0x0072;
3250                    break;
3251        
3252                case 0x211C : 
3253                    target[pos++] = 0x0072;
3254                    break;
3255        
3256                case 0x211D : 
3257                    target[pos++] = 0x0072;
3258                    break;
3259        
3260                case 0x2120 : 
3261                    target[pos++] = 0x0073;
3262                    target[pos++] = 0x006D;
3263                    break;
3264        
3265                case 0x2121 : 
3266                    target[pos++] = 0x0074;
3267                    target[pos++] = 0x0065;
3268                    target[pos++] = 0x006C;
3269                    break;
3270        
3271                case 0x2122 : 
3272                    target[pos++] = 0x0074;
3273                    target[pos++] = 0x006D;
3274                    break;
3275        
3276                case 0x2124 : 
3277                    target[pos++] = 0x007A;
3278                    break;
3279        
3280                case 0x2126 : 
3281                    target[pos++] = 0x03C9;
3282                    break;
3283        
3284                case 0x2128 : 
3285                    target[pos++] = 0x007A;
3286                    break;
3287        
3288                case 0x212A : 
3289                    target[pos++] = 0x006B;
3290                    break;
3291        
3292                case 0x212B : 
3293                    target[pos++] = 0x00E5;
3294                    break;
3295        
3296                case 0x212C : 
3297                    target[pos++] = 0x0062;
3298                    break;
3299        
3300                case 0x212D : 
3301                    target[pos++] = 0x0063;
3302                    break;
3303        
3304                case 0x2130 : 
3305                    target[pos++] = 0x0065;
3306                    break;
3307        
3308                case 0x2131 : 
3309                    target[pos++] = 0x0066;
3310                    break;
3311        
3312                case 0x2133 : 
3313                    target[pos++] = 0x006D;
3314                    break;
3315        
3316                case 0x213E : 
3317                    target[pos++] = 0x03B3;
3318                    break;
3319        
3320                case 0x213F : 
3321                    target[pos++] = 0x03C0;
3322                    break;
3323        
3324                case 0x2145 : 
3325                    target[pos++] = 0x0064;
3326                    break;
3327        
3328                case 0x2160 : 
3329                    target[pos++] = 0x2170;
3330                    break;
3331        
3332                case 0x2161 : 
3333                    target[pos++] = 0x2171;
3334                    break;
3335        
3336                case 0x2162 : 
3337                    target[pos++] = 0x2172;
3338                    break;
3339        
3340                case 0x2163 : 
3341                    target[pos++] = 0x2173;
3342                    break;
3343        
3344                case 0x2164 : 
3345                    target[pos++] = 0x2174;
3346                    break;
3347        
3348                case 0x2165 : 
3349                    target[pos++] = 0x2175;
3350                    break;
3351        
3352                case 0x2166 : 
3353                    target[pos++] = 0x2176;
3354                    break;
3355        
3356                case 0x2167 : 
3357                    target[pos++] = 0x2177;
3358                    break;
3359        
3360                case 0x2168 : 
3361                    target[pos++] = 0x2178;
3362                    break;
3363        
3364                case 0x2169 : 
3365                    target[pos++] = 0x2179;
3366                    break;
3367        
3368                case 0x216A : 
3369                    target[pos++] = 0x217A;
3370                    break;
3371        
3372                case 0x216B : 
3373                    target[pos++] = 0x217B;
3374                    break;
3375        
3376                case 0x216C : 
3377                    target[pos++] = 0x217C;
3378                    break;
3379        
3380                case 0x216D : 
3381                    target[pos++] = 0x217D;
3382                    break;
3383        
3384                case 0x216E : 
3385                    target[pos++] = 0x217E;
3386                    break;
3387        
3388                case 0x216F : 
3389                    target[pos++] = 0x217F;
3390                    break;
3391        
3392                case 0x24B6 : 
3393                    target[pos++] = 0x24D0;
3394                    break;
3395        
3396                case 0x24B7 : 
3397                    target[pos++] = 0x24D1;
3398                    break;
3399        
3400                case 0x24B8 : 
3401                    target[pos++] = 0x24D2;
3402                    break;
3403        
3404                case 0x24B9 : 
3405                    target[pos++] = 0x24D3;
3406                    break;
3407        
3408                case 0x24BA : 
3409                    target[pos++] = 0x24D4;
3410                    break;
3411        
3412                case 0x24BB : 
3413                    target[pos++] = 0x24D5;
3414                    break;
3415        
3416                case 0x24BC : 
3417                    target[pos++] = 0x24D6;
3418                    break;
3419        
3420                case 0x24BD : 
3421                    target[pos++] = 0x24D7;
3422                    break;
3423        
3424                case 0x24BE : 
3425                    target[pos++] = 0x24D8;
3426                    break;
3427        
3428                case 0x24BF : 
3429                    target[pos++] = 0x24D9;
3430                    break;
3431        
3432                case 0x24C0 : 
3433                    target[pos++] = 0x24DA;
3434                    break;
3435        
3436                case 0x24C1 : 
3437                    target[pos++] = 0x24DB;
3438                    break;
3439        
3440                case 0x24C2 : 
3441                    target[pos++] = 0x24DC;
3442                    break;
3443        
3444                case 0x24C3 : 
3445                    target[pos++] = 0x24DD;
3446                    break;
3447        
3448                case 0x24C4 : 
3449                    target[pos++] = 0x24DE;
3450                    break;
3451        
3452                case 0x24C5 : 
3453                    target[pos++] = 0x24DF;
3454                    break;
3455        
3456                case 0x24C6 : 
3457                    target[pos++] = 0x24E0;
3458                    break;
3459        
3460                case 0x24C7 : 
3461                    target[pos++] = 0x24E1;
3462                    break;
3463        
3464                case 0x24C8 : 
3465                    target[pos++] = 0x24E2;
3466                    break;
3467        
3468                case 0x24C9 : 
3469                    target[pos++] = 0x24E3;
3470                    break;
3471        
3472                case 0x24CA : 
3473                    target[pos++] = 0x24E4;
3474                    break;
3475        
3476                case 0x24CB : 
3477                    target[pos++] = 0x24E5;
3478                    break;
3479        
3480                case 0x24CC : 
3481                    target[pos++] = 0x24E6;
3482                    break;
3483        
3484                case 0x24CD : 
3485                    target[pos++] = 0x24E7;
3486                    break;
3487        
3488                case 0x24CE : 
3489                    target[pos++] = 0x24E8;
3490                    break;
3491        
3492                case 0x24CF : 
3493                    target[pos++] = 0x24E9;
3494                    break;
3495        
3496                case 0x3000 :
3497                    target[pos++] = 0x0020;
3498                    break;
3499        
3500                case 0x3371 : 
3501                    target[pos++] = 0x0068;
3502                    target[pos++] = 0x0070;
3503                    target[pos++] = 0x0061;
3504                    break;
3505        
3506                case 0x3373 : 
3507                    target[pos++] = 0x0061;
3508                    target[pos++] = 0x0075;
3509                    break;
3510        
3511                case 0x3375 : 
3512                    target[pos++] = 0x006F;
3513                    target[pos++] = 0x0076;
3514                    break;
3515        
3516                case 0x3380 : 
3517                    target[pos++] = 0x0070;
3518                    target[pos++] = 0x0061;
3519                    break;
3520        
3521                case 0x3381 : 
3522                    target[pos++] = 0x006E;
3523                    target[pos++] = 0x0061;
3524                    break;
3525        
3526                case 0x3382 : 
3527                    target[pos++] = 0x03BC;
3528                    target[pos++] = 0x0061;
3529                    break;
3530        
3531                case 0x3383 : 
3532                    target[pos++] = 0x006D;
3533                    target[pos++] = 0x0061;
3534                    break;
3535        
3536                case 0x3384 : 
3537                    target[pos++] = 0x006B;
3538                    target[pos++] = 0x0061;
3539                    break;
3540        
3541                case 0x3385 : 
3542                    target[pos++] = 0x006B;
3543                    target[pos++] = 0x0062;
3544                    break;
3545        
3546                case 0x3386 : 
3547                    target[pos++] = 0x006D;
3548                    target[pos++] = 0x0062;
3549                    break;
3550        
3551                case 0x3387 : 
3552                    target[pos++] = 0x0067;
3553                    target[pos++] = 0x0062;
3554                    break;
3555        
3556                case 0x338A : 
3557                    target[pos++] = 0x0070;
3558                    target[pos++] = 0x0066;
3559                    break;
3560        
3561                case 0x338B : 
3562                    target[pos++] = 0x006E;
3563                    target[pos++] = 0x0066;
3564                    break;
3565        
3566                case 0x338C : 
3567                    target[pos++] = 0x03BC;
3568                    target[pos++] = 0x0066;
3569                    break;
3570        
3571                case 0x3390 : 
3572                    target[pos++] = 0x0068;
3573                    target[pos++] = 0x007A;
3574                    break;
3575        
3576                case 0x3391 : 
3577                    target[pos++] = 0x006B;
3578                    target[pos++] = 0x0068;
3579                    target[pos++] = 0x007A;
3580                    break;
3581        
3582                case 0x3392 : 
3583                    target[pos++] = 0x006D;
3584                    target[pos++] = 0x0068;
3585                    target[pos++] = 0x007A;
3586                    break;
3587        
3588                case 0x3393 : 
3589                    target[pos++] = 0x0067;
3590                    target[pos++] = 0x0068;
3591                    target[pos++] = 0x007A;
3592                    break;
3593        
3594                case 0x3394 : 
3595                    target[pos++] = 0x0074;
3596                    target[pos++] = 0x0068;
3597                    target[pos++] = 0x007A;
3598                    break;
3599        
3600                case 0x33A9 : 
3601                    target[pos++] = 0x0070;
3602                    target[pos++] = 0x0061;
3603                    break;
3604        
3605                case 0x33AA : 
3606                    target[pos++] = 0x006B;
3607                    target[pos++] = 0x0070;
3608                    target[pos++] = 0x0061;
3609                    break;
3610        
3611                case 0x33AB : 
3612                    target[pos++] = 0x006D;
3613                    target[pos++] = 0x0070;
3614                    target[pos++] = 0x0061;
3615                    break;
3616        
3617                case 0x33AC : 
3618                    target[pos++] = 0x0067;
3619                    target[pos++] = 0x0070;
3620                    target[pos++] = 0x0061;
3621                    break;
3622        
3623                case 0x33B4 : 
3624                    target[pos++] = 0x0070;
3625                    target[pos++] = 0x0076;
3626                    break;
3627        
3628                case 0x33B5 : 
3629                    target[pos++] = 0x006E;
3630                    target[pos++] = 0x0076;
3631                    break;
3632        
3633                case 0x33B6 : 
3634                    target[pos++] = 0x03BC;
3635                    target[pos++] = 0x0076;
3636                    break;
3637        
3638                case 0x33B7 : 
3639                    target[pos++] = 0x006D;
3640                    target[pos++] = 0x0076;
3641                    break;
3642        
3643                case 0x33B8 : 
3644                    target[pos++] = 0x006B;
3645                    target[pos++] = 0x0076;
3646                    break;
3647        
3648                case 0x33B9 : 
3649                    target[pos++] = 0x006D;
3650                    target[pos++] = 0x0076;
3651                    break;
3652        
3653                case 0x33BA : 
3654                    target[pos++] = 0x0070;
3655                    target[pos++] = 0x0077;
3656                    break;
3657        
3658                case 0x33BB : 
3659                    target[pos++] = 0x006E;
3660                    target[pos++] = 0x0077;
3661                    break;
3662        
3663                case 0x33BC : 
3664                    target[pos++] = 0x03BC;
3665                    target[pos++] = 0x0077;
3666                    break;
3667        
3668                case 0x33BD : 
3669                    target[pos++] = 0x006D;
3670                    target[pos++] = 0x0077;
3671                    break;
3672        
3673                case 0x33BE : 
3674                    target[pos++] = 0x006B;
3675                    target[pos++] = 0x0077;
3676                    break;
3677        
3678                case 0x33BF : 
3679                    target[pos++] = 0x006D;
3680                    target[pos++] = 0x0077;
3681                    break;
3682        
3683                case 0x33C0 : 
3684                    target[pos++] = 0x006B;
3685                    target[pos++] = 0x03C9;
3686                    break;
3687        
3688                case 0x33C1 : 
3689                    target[pos++] = 0x006D;
3690                    target[pos++] = 0x03C9;
3691                    break;
3692        
3693                case 0x33C3 : 
3694                    target[pos++] = 0x0062;
3695                    target[pos++] = 0x0071;
3696                    break;
3697        
3698                case 0x33C6 : 
3699                    target[pos++] = 0x0063;
3700                    target[pos++] = 0x2215;
3701                    target[pos++] = 0x006B;
3702                    target[pos++] = 0x0067;
3703                    break;
3704        
3705                case 0x33C7 : 
3706                    target[pos++] = 0x0063;
3707                    target[pos++] = 0x006F;
3708                    target[pos++] = 0x002E;
3709                    break;
3710        
3711                case 0x33C8 : 
3712                    target[pos++] = 0x0064;
3713                    target[pos++] = 0x0062;
3714                    break;
3715        
3716                case 0x33C9 : 
3717                    target[pos++] = 0x0067;
3718                    target[pos++] = 0x0079;
3719                    break;
3720        
3721                case 0x33CB : 
3722                    target[pos++] = 0x0068;
3723                    target[pos++] = 0x0070;
3724                    break;
3725        
3726                case 0x33CD : 
3727                    target[pos++] = 0x006B;
3728                    target[pos++] = 0x006B;
3729                    break;
3730        
3731                case 0x33CE : 
3732                    target[pos++] = 0x006B;
3733                    target[pos++] = 0x006D;
3734                    break;
3735        
3736                case 0x33D7 : 
3737                    target[pos++] = 0x0070;
3738                    target[pos++] = 0x0068;
3739                    break;
3740        
3741                case 0x33D9 : 
3742                    target[pos++] = 0x0070;
3743                    target[pos++] = 0x0070;
3744                    target[pos++] = 0x006D;
3745                    break;
3746        
3747                case 0x33DA : 
3748                    target[pos++] = 0x0070;
3749                    target[pos++] = 0x0072;
3750                    break;
3751        
3752                case 0x33DC : 
3753                    target[pos++] = 0x0073;
3754                    target[pos++] = 0x0076;
3755                    break;
3756        
3757                case 0x33DD : 
3758                    target[pos++] = 0x0077;
3759                    target[pos++] = 0x0062;
3760                    break;
3761        
3762                case 0xFB00 : 
3763                    target[pos++] = 0x0066;
3764                    target[pos++] = 0x0066;
3765                    break;
3766        
3767                case 0xFB01 : 
3768                    target[pos++] = 0x0066;
3769                    target[pos++] = 0x0069;
3770                    break;
3771        
3772                case 0xFB02 : 
3773                    target[pos++] = 0x0066;
3774                    target[pos++] = 0x006C;
3775                    break;
3776        
3777                case 0xFB03 : 
3778                    target[pos++] = 0x0066;
3779                    target[pos++] = 0x0066;
3780                    target[pos++] = 0x0069;
3781                    break;
3782        
3783                case 0xFB04 : 
3784                    target[pos++] = 0x0066;
3785                    target[pos++] = 0x0066;
3786                    target[pos++] = 0x006C;
3787                    break;
3788        
3789                case 0xFB05 : 
3790                    target[pos++] = 0x0073;
3791                    target[pos++] = 0x0074;
3792                    break;
3793        
3794                case 0xFB06 : 
3795                    target[pos++] = 0x0073;
3796                    target[pos++] = 0x0074;
3797                    break;
3798        
3799                case 0xFB13 : 
3800                    target[pos++] = 0x0574;
3801                    target[pos++] = 0x0576;
3802                    break;
3803        
3804                case 0xFB14 : 
3805                    target[pos++] = 0x0574;
3806                    target[pos++] = 0x0565;
3807                    break;
3808        
3809                case 0xFB15 : 
3810                    target[pos++] = 0x0574;
3811                    target[pos++] = 0x056B;
3812                    break;
3813        
3814                case 0xFB16 : 
3815                    target[pos++] = 0x057E;
3816                    target[pos++] = 0x0576;
3817                    break;
3818        
3819                case 0xFB17 : 
3820                    target[pos++] = 0x0574;
3821                    target[pos++] = 0x056D;
3822                    break;
3823        
3824                case 0xFE00 :
3825                case 0xFE01 :
3826                case 0xFE02 :
3827                case 0xFE03 :
3828                case 0xFE04 :
3829                case 0xFE05 :
3830                case 0xFE06 :
3831                case 0xFE07 :
3832                case 0xFE08 :
3833                case 0xFE09 :
3834                case 0xFE0A :
3835                case 0xFE0B :
3836                case 0xFE0C :
3837                case 0xFE0D :
3838                case 0xFE0E :
3839                case 0xFE0F :
3840                    break;
3841        
3842                case 0xFEFF :
3843                    break;
3844        
3845                case 0xFF21 : 
3846                    target[pos++] = 0xFF41;
3847                    break;
3848        
3849                case 0xFF22 : 
3850                    target[pos++] = 0xFF42;
3851                    break;
3852        
3853                case 0xFF23 : 
3854                    target[pos++] = 0xFF43;
3855                    break;
3856        
3857                case 0xFF24 : 
3858                    target[pos++] = 0xFF44;
3859                    break;
3860        
3861                case 0xFF25 : 
3862                    target[pos++] = 0xFF45;
3863                    break;
3864        
3865                case 0xFF26 : 
3866                    target[pos++] = 0xFF46;
3867                    break;
3868        
3869                case 0xFF27 : 
3870                    target[pos++] = 0xFF47;
3871                    break;
3872        
3873                case 0xFF28 : 
3874                    target[pos++] = 0xFF48;
3875                    break;
3876        
3877                case 0xFF29 : 
3878                    target[pos++] = 0xFF49;
3879                    break;
3880        
3881                case 0xFF2A : 
3882                    target[pos++] = 0xFF4A;
3883                    break;
3884        
3885                case 0xFF2B : 
3886                    target[pos++] = 0xFF4B;
3887                    break;
3888        
3889                case 0xFF2C : 
3890                    target[pos++] = 0xFF4C;
3891                    break;
3892        
3893                case 0xFF2D : 
3894                    target[pos++] = 0xFF4D;
3895                    break;
3896        
3897                case 0xFF2E : 
3898                    target[pos++] = 0xFF4E;
3899                    break;
3900        
3901                case 0xFF2F : 
3902                    target[pos++] = 0xFF4F;
3903                    break;
3904        
3905                case 0xFF30 : 
3906                    target[pos++] = 0xFF50;
3907                    break;
3908        
3909                case 0xFF31 : 
3910                    target[pos++] = 0xFF51;
3911                    break;
3912        
3913                case 0xFF32 : 
3914                    target[pos++] = 0xFF52;
3915                    break;
3916        
3917                case 0xFF33 : 
3918                    target[pos++] = 0xFF53;
3919                    break;
3920        
3921                case 0xFF34 : 
3922                    target[pos++] = 0xFF54;
3923                    break;
3924        
3925                case 0xFF35 : 
3926                    target[pos++] = 0xFF55;
3927                    break;
3928        
3929                case 0xFF36 : 
3930                    target[pos++] = 0xFF56;
3931                    break;
3932        
3933                case 0xFF37 : 
3934                    target[pos++] = 0xFF57;
3935                    break;
3936        
3937                case 0xFF38 : 
3938                    target[pos++] = 0xFF58;
3939                    break;
3940        
3941                case 0xFF39 : 
3942                    target[pos++] = 0xFF59;
3943                    break;
3944        
3945                case 0xFF3A : 
3946                    target[pos++] = 0xFF5A;
3947                    break;
3948                    
3949                case 0xFFF9 :
3950                case 0xFFFA :
3951                case 0xFFFB :
3952                case 0xFFFC :
3953                    break;
3954        
3955                default :
3956                    // First, eliminate surrogates, and replace them by FFFD char
3957                    if ( ( c >= 0xD800 ) && ( c <= 0xDFFF ) )
3958                    {
3959                        target[pos++] = (char)0xFFFD ;
3960                        break;
3961                    }
3962                    
3963                    target[pos++] = c;
3964                    break;
3965            }
3966    
3967            return pos - start;
3968        }
3969        
3970        /**
3971         * 
3972         * Prohibit characters described in RFC 4518 :
3973         *  - Table A.1 of RFC 3454
3974         *  - Table C.3 of RFC 3454
3975         *  - Table C.4 of RFC 3454
3976         *  - Table C.5 of RFC 3454
3977         *  - Table C.8 of RFC 3454
3978         *  - character U-FFFD
3979         *
3980         * @param c The char to analyze
3981         * @throws InvalidCharacterException If any character is prohibited
3982         */
3983        private static void checkProhibited( char c ) throws InvalidCharacterException
3984        {
3985            // Shortcut chars above 0x0221
3986            if ( c < 0x221 )
3987            {
3988                return;
3989            }
3990            
3991            // RFC 3454, Table A.1
3992            switch ( c )
3993            {
3994                case 0x0221 :
3995                case 0x038B :
3996                case 0x038D :
3997                case 0x03A2 :
3998                case 0x03CF :
3999                case 0x0487 :
4000                case 0x04CF :
4001                case 0x0560 :
4002                case 0x0588 :
4003                case 0x05A2 :
4004                case 0x05BA :
4005                case 0x0620 :
4006                case 0x06FF :
4007                case 0x070E :
4008                case 0x0904 :
4009                case 0x0984 :
4010                case 0x09A9 :
4011                case 0x09B1 :
4012                case 0x09BD :
4013                case 0x09DE :
4014                case 0x0A29 :
4015                case 0x0A31 :
4016                case 0x0A34 :
4017                case 0x0A37 :
4018                case 0x0A3D :
4019                case 0x0A5D :
4020                case 0x0A84 :
4021                case 0x0A8C :
4022                case 0x0A8E :
4023                case 0x0A92 :
4024                case 0x0AA9 :
4025                case 0x0AB1 :
4026                case 0x0AB4 :
4027                case 0x0AC6 :
4028                case 0x0ACA :
4029                case 0x0B04 :
4030                case 0x0B29 :
4031                case 0x0B31 :
4032                case 0x0B5E :
4033                case 0x0B84 :
4034                case 0x0B91 :
4035                case 0x0B9B :
4036                case 0x0B9D :
4037                case 0x0BB6 :
4038                case 0x0BC9 :
4039                case 0x0C04 :
4040                case 0x0C0D :
4041                case 0x0C11 :
4042                case 0x0C29 :
4043                case 0x0C34 :
4044                case 0x0C45 :
4045                case 0x0C49 :
4046                case 0x0C84 :
4047                case 0x0C8D :
4048                case 0x0C91 :
4049                case 0x0CA9 :
4050                case 0x0CB4 :
4051                case 0x0CC5 :
4052                case 0x0CC9 :
4053                case 0x0CDF :
4054                case 0x0D04 :
4055                case 0x0D0D :
4056                case 0x0D11 :
4057                case 0x0D29 :
4058                case 0x0D49 :
4059                case 0x0D84 :
4060                case 0x0DB2 :
4061                case 0x0DBC :
4062                case 0x0DD5 :
4063                case 0x0DD7 :
4064                case 0x0E83 :
4065                case 0x0E89 :
4066                case 0x0E98 :
4067                case 0x0EA0 :
4068                case 0x0EA4 :
4069                case 0x0EA6 :
4070                case 0x0EAC :
4071                case 0x0EBA :
4072                case 0x0EC5 :
4073                case 0x0EC7 :
4074                case 0x0F48 :
4075                case 0x0F98 :
4076                case 0x0FBD :
4077                case 0x1022 :
4078                case 0x1028 :
4079                case 0x102B :
4080                case 0x1207 :
4081                case 0x1247 :
4082                case 0x1249 :
4083                case 0x1257 :
4084                case 0x1259 :
4085                case 0x1287 :
4086                case 0x1289 :
4087                case 0x12AF :
4088                case 0x12B1 :
4089                case 0x12BF :
4090                case 0x12C1 :
4091                case 0x12CF :
4092                case 0x12D7 :
4093                case 0x12EF :
4094                case 0x130F :
4095                case 0x1311 :
4096                case 0x131F :
4097                case 0x1347 :
4098                case 0x170D :
4099                case 0x176D :
4100                case 0x1771 :
4101                case 0x180F :
4102                case 0x1F58 :
4103                case 0x1F5A :
4104                case 0x1F5C :
4105                case 0x1F5E :
4106                case 0x1FB5 :
4107                case 0x1FC5 :
4108                case 0x1FDC :
4109                case 0x1FF5 :
4110                case 0x1FFF :
4111                case 0x24FF :
4112                case 0x2618 :
4113                case 0x2705 :
4114                case 0x2728 :
4115                case 0x274C :
4116                case 0x274E :
4117                case 0x2757 :
4118                case 0x27B0 :
4119                case 0x2E9A :
4120                case 0x3040 :
4121                case 0x318F :
4122                case 0x32FF :
4123                case 0x33FF :
4124                case 0xFB37 :
4125                case 0xFB3D :
4126                case 0xFB3F :
4127                case 0xFB42 :
4128                case 0xFB45 :
4129                case 0xFE53 :
4130                case 0xFE67 :
4131                case 0xFE75 :
4132                case 0xFF00 :
4133                case 0xFFE7 :
4134                    throw new InvalidCharacterException( c );
4135                default:
4136                    break;
4137            }
4138            
4139            // RFC 3454, Table A.1, intervals
4140            if ( ( c >= 0x0234 ) && ( c <= 0x024F ) ) 
4141            {
4142                throw new InvalidCharacterException( c );
4143            }
4144    
4145            if ( ( c >= 0x02AE ) && ( c <= 0x02AF ) ) 
4146            {
4147                throw new InvalidCharacterException( c );
4148            }
4149    
4150            if ( ( c >= 0x02EF ) && ( c <= 0x02FF ) ) 
4151            {
4152                throw new InvalidCharacterException( c );
4153            }
4154    
4155            if ( ( c >= 0x0350 ) && ( c <= 0x035F ) ) 
4156            {
4157                throw new InvalidCharacterException( c );
4158            }
4159    
4160            if ( ( c >= 0x0370 ) && ( c <= 0x0373 ) ) 
4161            {
4162                throw new InvalidCharacterException( c );
4163            }
4164    
4165            if ( ( c >= 0x0376 ) && ( c <= 0x0379 ) ) 
4166            {
4167                throw new InvalidCharacterException( c );
4168            }
4169    
4170            if ( ( c >= 0x037B ) && ( c <= 0x037D ) ) 
4171            {
4172                throw new InvalidCharacterException( c );
4173            }
4174    
4175            if ( ( c >= 0x037F ) && ( c <= 0x0383 ) ) 
4176            {
4177                throw new InvalidCharacterException( c );
4178            }
4179    
4180            if ( ( c >= 0x03F7 ) && ( c <= 0x03FF ) ) 
4181            {
4182                throw new InvalidCharacterException( c );
4183            }
4184    
4185            if ( ( c >= 0x04F6 ) && ( c <= 0x04F7 ) ) 
4186            {
4187                throw new InvalidCharacterException( c );
4188            }
4189    
4190            if ( ( c >= 0x04FA ) && ( c <= 0x04FF ) ) 
4191            {
4192                throw new InvalidCharacterException( c );
4193            }
4194    
4195            if ( ( c >= 0x0510 ) && ( c <= 0x0530 ) ) 
4196            {
4197                throw new InvalidCharacterException( c );
4198            }
4199    
4200            if ( ( c >= 0x0557 ) && ( c <= 0x0558 ) ) 
4201            {
4202                throw new InvalidCharacterException( c );
4203            }
4204    
4205            if ( ( c >= 0x058B ) && ( c <= 0x0590 ) ) 
4206            {
4207                throw new InvalidCharacterException( c );
4208            }
4209    
4210            if ( ( c >= 0x05C5 ) && ( c <= 0x05CF ) ) 
4211            {
4212                throw new InvalidCharacterException( c );
4213            }
4214    
4215            if ( ( c >= 0x05EB ) && ( c <= 0x05EF ) ) 
4216            {
4217                throw new InvalidCharacterException( c );
4218            }
4219    
4220            if ( ( c >= 0x05F5 ) && ( c <= 0x060B ) ) 
4221            {
4222                throw new InvalidCharacterException( c );
4223            }
4224    
4225            if ( ( c >= 0x060D ) && ( c <= 0x061A ) ) 
4226            {
4227                throw new InvalidCharacterException( c );
4228            }
4229    
4230            if ( ( c >= 0x061C ) && ( c <= 0x061E ) ) 
4231            {
4232                throw new InvalidCharacterException( c );
4233            }
4234    
4235            if ( ( c >= 0x063B ) && ( c <= 0x063F ) ) 
4236            {
4237                throw new InvalidCharacterException( c );
4238            }
4239    
4240            if ( ( c >= 0x0656 ) && ( c <= 0x065F ) ) 
4241            {
4242                throw new InvalidCharacterException( c );
4243            }
4244    
4245            if ( ( c >= 0x06EE ) && ( c <= 0x06EF ) ) 
4246            {
4247                throw new InvalidCharacterException( c );
4248            }
4249    
4250            if ( ( c >= 0x072D ) && ( c <= 0x072F ) ) 
4251            {
4252                throw new InvalidCharacterException( c );
4253            }
4254    
4255            if ( ( c >= 0x074B ) && ( c <= 0x077F ) ) 
4256            {
4257                throw new InvalidCharacterException( c );
4258            }
4259    
4260            if ( ( c >= 0x07B2 ) && ( c <= 0x0900 ) ) 
4261            {
4262                throw new InvalidCharacterException( c );
4263            }
4264    
4265            if ( ( c >= 0x093A ) && ( c <= 0x093B ) ) 
4266            {
4267                throw new InvalidCharacterException( c );
4268            }
4269    
4270            if ( ( c >= 0x094E ) && ( c <= 0x094F ) ) 
4271            {
4272                throw new InvalidCharacterException( c );
4273            }
4274    
4275            if ( ( c >= 0x0955 ) && ( c <= 0x0957 ) ) 
4276            {
4277                throw new InvalidCharacterException( c );
4278            }
4279    
4280            if ( ( c >= 0x0971 ) && ( c <= 0x0980 ) ) 
4281            {
4282                throw new InvalidCharacterException( c );
4283            }
4284    
4285            if ( ( c >= 0x098D ) && ( c <= 0x098E ) ) 
4286            {
4287                throw new InvalidCharacterException( c );
4288            }
4289    
4290            if ( ( c >= 0x0991 ) && ( c <= 0x0992 ) ) 
4291            {
4292                throw new InvalidCharacterException( c );
4293            }
4294    
4295            if ( ( c >= 0x09B3 ) && ( c <= 0x09B5 ) ) 
4296            {
4297                throw new InvalidCharacterException( c );
4298            }
4299    
4300            if ( ( c >= 0x09BA ) && ( c <= 0x09BB ) ) 
4301            {
4302                throw new InvalidCharacterException( c );
4303            }
4304    
4305            if ( ( c >= 0x09C5 ) && ( c <= 0x09C6 ) ) 
4306            {
4307                throw new InvalidCharacterException( c );
4308            }
4309    
4310            if ( ( c >= 0x09C9 ) && ( c <= 0x09CA ) ) 
4311            {
4312                throw new InvalidCharacterException( c );
4313            }
4314    
4315            if ( ( c >= 0x09CE ) && ( c <= 0x09D6 ) ) 
4316            {
4317                throw new InvalidCharacterException( c );
4318            }
4319    
4320            if ( ( c >= 0x09D8 ) && ( c <= 0x09DB ) ) 
4321            {
4322                throw new InvalidCharacterException( c );
4323            }
4324    
4325            if ( ( c >= 0x09E4 ) && ( c <= 0x09E5 ) ) 
4326            {
4327                throw new InvalidCharacterException( c );
4328            }
4329    
4330            if ( ( c >= 0x09FB ) && ( c <= 0x0A01 ) ) 
4331            {
4332                throw new InvalidCharacterException( c );
4333            }
4334    
4335            if ( ( c >= 0x0A03 ) && ( c <= 0x0A04 ) ) 
4336            {
4337                throw new InvalidCharacterException( c );
4338            }
4339    
4340            if ( ( c >= 0x0A0B ) && ( c <= 0x0A0E ) ) 
4341            {
4342                throw new InvalidCharacterException( c );
4343            }
4344    
4345            if ( ( c >= 0x0A11 ) && ( c <= 0x0A12 ) ) 
4346            {
4347                throw new InvalidCharacterException( c );
4348            }
4349    
4350            if ( ( c >= 0x0A3A ) && ( c <= 0x0A3B ) ) 
4351            {
4352                throw new InvalidCharacterException( c );
4353            }
4354    
4355            if ( ( c >= 0x0A43 ) && ( c <= 0x0A46 ) ) 
4356            {
4357                throw new InvalidCharacterException( c );
4358            }
4359    
4360            if ( ( c >= 0x0A49 ) && ( c <= 0x0A4A ) ) 
4361            {
4362                throw new InvalidCharacterException( c );
4363            }
4364    
4365            if ( ( c >= 0x0A4E ) && ( c <= 0x0A58 ) ) 
4366            {
4367                throw new InvalidCharacterException( c );
4368            }
4369    
4370            if ( ( c >= 0x0A5F ) && ( c <= 0x0A65 ) ) 
4371            {
4372                throw new InvalidCharacterException( c );
4373            }
4374    
4375            if ( ( c >= 0x0A75 ) && ( c <= 0x0A80 ) ) 
4376            {
4377                throw new InvalidCharacterException( c );
4378            }
4379    
4380            if ( ( c >= 0x0ABA ) && ( c <= 0x0ABB ) ) 
4381            {
4382                throw new InvalidCharacterException( c );
4383            }
4384    
4385            if ( ( c >= 0x0ACE ) && ( c <= 0x0ACF ) ) 
4386            {
4387                throw new InvalidCharacterException( c );
4388            }
4389    
4390            if ( ( c >= 0x0AD1 ) && ( c <= 0x0ADF ) ) 
4391            {
4392                throw new InvalidCharacterException( c );
4393            }
4394    
4395            if ( ( c >= 0x0AE1 ) && ( c <= 0x0AE5 ) ) 
4396            {
4397                throw new InvalidCharacterException( c );
4398            }
4399    
4400            if ( ( c >= 0x0AF0 ) && ( c <= 0x0B00 ) ) 
4401            {
4402                throw new InvalidCharacterException( c );
4403            }
4404    
4405            if ( ( c >= 0x0B0D ) && ( c <= 0x0B0E ) ) 
4406            {
4407                throw new InvalidCharacterException( c );
4408            }
4409    
4410            if ( ( c >= 0x0B11 ) && ( c <= 0x0B12 ) ) 
4411            {
4412                throw new InvalidCharacterException( c );
4413            }
4414    
4415            if ( ( c >= 0x0B34 ) && ( c <= 0x0B35 ) ) 
4416            {
4417                throw new InvalidCharacterException( c );
4418            }
4419    
4420            if ( ( c >= 0x0B3A ) && ( c <= 0x0B3B ) ) 
4421            {
4422                throw new InvalidCharacterException( c );
4423            }
4424    
4425            if ( ( c >= 0x0B44 ) && ( c <= 0x0B46 ) ) 
4426            {
4427                throw new InvalidCharacterException( c );
4428            }
4429    
4430            if ( ( c >= 0x0B49 ) && ( c <= 0x0B4A ) ) 
4431            {
4432                throw new InvalidCharacterException( c );
4433            }
4434    
4435            if ( ( c >= 0x0B4E ) && ( c <= 0x0B55 ) ) 
4436            {
4437                throw new InvalidCharacterException( c );
4438            }
4439    
4440            if ( ( c >= 0x0B58 ) && ( c <= 0x0B5B ) ) 
4441            {
4442                throw new InvalidCharacterException( c );
4443            }
4444    
4445            if ( ( c >= 0x0B62 ) && ( c <= 0x0B65 ) ) 
4446            {
4447                throw new InvalidCharacterException( c );
4448            }
4449    
4450            if ( ( c >= 0x0B71 ) && ( c <= 0x0B81 ) ) 
4451            {
4452                throw new InvalidCharacterException( c );
4453            }
4454    
4455            if ( ( c >= 0x0B8B ) && ( c <= 0x0B8D ) ) 
4456            {
4457                throw new InvalidCharacterException( c );
4458            }
4459    
4460            if ( ( c >= 0x0B96 ) && ( c <= 0x0B98 ) ) 
4461            {
4462                throw new InvalidCharacterException( c );
4463            }
4464    
4465            if ( ( c >= 0x0BA0 ) && ( c <= 0x0BA2 ) ) 
4466            {
4467                throw new InvalidCharacterException( c );
4468            }
4469    
4470            if ( ( c >= 0x0BA5 ) && ( c <= 0x0BA7 ) ) 
4471            {
4472                throw new InvalidCharacterException( c );
4473            }
4474    
4475            if ( ( c >= 0x0BAB ) && ( c <= 0x0BAD ) ) 
4476            {
4477                throw new InvalidCharacterException( c );
4478            }
4479    
4480            if ( ( c >= 0x0BBA ) && ( c <= 0x0BBD ) ) 
4481            {
4482                throw new InvalidCharacterException( c );
4483            }
4484    
4485            if ( ( c >= 0x0BC3 ) && ( c <= 0x0BC5 ) ) 
4486            {
4487                throw new InvalidCharacterException( c );
4488            }
4489    
4490            if ( ( c >= 0x0BCE ) && ( c <= 0x0BD6 ) ) 
4491            {
4492                throw new InvalidCharacterException( c );
4493            }
4494    
4495            if ( ( c >= 0x0BD8 ) && ( c <= 0x0BE6 ) ) 
4496            {
4497                throw new InvalidCharacterException( c );
4498            }
4499    
4500            if ( ( c >= 0x0BF3 ) && ( c <= 0x0C00 ) ) 
4501            {
4502                throw new InvalidCharacterException( c );
4503            }
4504    
4505            // RFC 3454, Table C.3
4506            if ( ( c >= 0xE000 ) && ( c <= 0xF8FF ) )
4507            {
4508                throw new InvalidCharacterException( c );
4509            }
4510    
4511            // RFC 3454, Table C.4
4512            if ( ( c >= 0xFDD0 ) && ( c <= 0xFDEF ) )
4513            {
4514                throw new InvalidCharacterException( c );
4515            }
4516    
4517            if ( ( c == 0xFFFE ) || ( c == 0xFFFF ) )
4518            {
4519                throw new InvalidCharacterException( c );
4520            }
4521    
4522            // RFC 3454, Table C.5 (Surrogates)
4523            if ( ( c >= 0xD800 ) && ( c <= 0xDFFF ) )
4524            {
4525                throw new InvalidCharacterException( c );
4526            }
4527    
4528            // RFC 3454, Table C.8 
4529            switch ( c) 
4530            {
4531                case 0x0340 : // COMBINING GRAVE TONE MARK
4532                case 0x0341 : // COMBINING ACUTE TONE MARK
4533                case 0x200E : // LEFT-TO-RIGHT MARK
4534                case 0x200F : // RIGHT-TO-LEFT MARK
4535                case 0x202A : // LEFT-TO-RIGHT EMBEDDING
4536                case 0x202B : // RIGHT-TO-LEFT EMBEDDING
4537                case 0x202C : // POP DIRECTIONAL FORMATTING
4538                case 0x202D : // LEFT-TO-RIGHT OVERRIDE
4539                case 0x202E : // RIGHT-TO-LEFT OVERRIDE
4540                case 0x206A : // INHIBIT SYMMETRIC SWAPPING
4541                case 0x206B : // ACTIVATE SYMMETRIC SWAPPING
4542                case 0x206C : // INHIBIT ARABIC FORM SHAPING
4543                case 0x206D : // ACTIVATE ARABIC FORM SHAPING
4544                case 0x206E : // NATIONAL DIGIT SHAPES
4545                case 0x206F : // NOMINAL DIGIT SHAPES
4546                    throw new InvalidCharacterException( c );
4547                default :
4548                    break;
4549            }
4550            
4551            if ( c == 0xFFFD ) 
4552            {
4553                throw new InvalidCharacterException( c );
4554            }
4555            
4556            return;
4557        }
4558        
4559        /**
4560         * 
4561         * Remove all bidirectionnal chars. This is not really clear in RFC 4518
4562         * what we should do with bidi chars :
4563         * "Bidirectional characters are ignored."
4564         * 
4565         * But it's not explained what is a bidi chars...
4566         * 
4567         * So this method just do nothing atm.
4568         *
4569         * @param str The string where bidi chars are to be removed
4570         * @return The cleaned string
4571         */
4572        public static String bidi( String str )
4573        {
4574            return str;
4575        }
4576        
4577        /**
4578         * 
4579         * Remove all bidirectionnal chars. This is not really clear in RFC 4518
4580         * what we should do with bidi chars :
4581         * "Bidirectional characters are ignored."
4582         * 
4583         * But it's not explained what is a bidi chars...
4584         * 
4585         * So this method just do nothing atm.
4586         *
4587         * @param array The char array where bidi chars are to be removed
4588         * @return The cleaned StringBuilder
4589         */
4590        public static StringBuilder bidi( char[] array )
4591        {
4592            StringBuilder sb = new StringBuilder( array == null ? 0 : array.length );
4593            
4594            if ( array != null )
4595            {
4596                sb.append( array );
4597            }
4598            
4599            return sb;
4600        }
4601        
4602        /**
4603         * 
4604         * Remove all insignifiant chars in a Telephone Number :
4605         * Hyphen and spaces. 
4606         * 
4607         * For instance, the following telephone number :
4608         * "+ (33) 1-123--456  789"
4609         * will be trasnformed to :
4610         * "+(33)1123456789"
4611         *
4612         * @param str The telephone number
4613         * @return The modified telephone number String
4614         */
4615        private static String insignifiantCharTelephoneNumber( String str )
4616        {
4617            if ( StringTools.isEmpty( str ) )
4618            {
4619                return "";
4620            }
4621    
4622            char[] array = str.toCharArray();
4623            
4624            boolean isSpaceOrHyphen = false;
4625            char soh = '\0';
4626            int pos = 0;
4627            
4628            for ( char c:array )
4629            {
4630                switch ( c )
4631                {
4632                    case 0x0020 : // SPACE
4633                    case 0x002D : // HYPHEN-MINUS
4634                    case 0x058A : // ARMENIAN HYPHEN
4635                    case 0x2010 : // HYPHEN
4636                    case 0x2011 : // NON-BREAKING HYPHEN
4637                    case 0x2212 : // MINUS SIGN
4638                    case 0xFE63 : // SMALL HYPHEN-MINUS
4639                    case 0xFF0D : // FULLWIDTH HYPHEN-MINUS
4640                        soh = c;
4641                        break;
4642                        
4643                    default :
4644                        if ( isSpaceOrHyphen && isCombiningMark( c ) )
4645                        {
4646                            array[pos++] = soh;
4647                            isSpaceOrHyphen = false;
4648                        }
4649                    
4650                        array[pos++] = c;
4651                        break;
4652                }
4653            }
4654            
4655            return new String( array, 0, pos );
4656        }
4657    
4658        /**
4659         * 
4660         * Remove all insignifiant spaces in a numeric string. For
4661         * instance, the following numeric string :
4662         * "  123  456  789  "
4663         * will be transformed to :
4664         * "123456789"
4665         *
4666         * @param str The numeric String
4667         * @return The modified numeric StringBuilder
4668         */
4669        private static String insignifiantCharNumericString( String str )
4670        {
4671            if ( StringTools.isEmpty( str ) )
4672            {
4673                return "";
4674            }
4675    
4676            char[] array = str.toCharArray();
4677    
4678            boolean isSpace = false;
4679            int pos = 0;
4680            
4681            for ( char c:array )
4682            {
4683                if ( c != 0x20 )
4684                {
4685                    if ( isSpace && isCombiningMark( c ) )
4686                    {
4687                        array[pos++] = ' ';
4688                        isSpace = false;
4689                    }
4690                        
4691                    array[pos++] = c;
4692                }
4693                else
4694                {
4695                    isSpace = true;
4696                }
4697            }
4698            
4699            return new String( array, 0, pos );
4700        }
4701    
4702        /**
4703         * 
4704         * Remove all insignifiant spaces in a string.
4705         * 
4706         * This method use a finite state machine to parse
4707         * the text.
4708         * 
4709         * @param str The String to modify
4710         * @param caseSensitive A flag telling if the chars must be lowercased
4711         * @return The modified StringBuilder
4712         * @throws InvalidCharacterException If an invalid character is found in the String
4713         */
4714        private static String insignifiantSpacesString( String str, boolean caseSensitive ) throws InvalidCharacterException
4715        {
4716            if ( StringTools.isEmpty( str ) )
4717            {
4718                // Special case : an empty strings is replaced by 2 spaces
4719                return "";
4720            }
4721    
4722            char[] array = str.toCharArray();
4723            
4724            // Create a target char array which is 3 times bigger than the original size. 
4725            // We have to do that because the map phase may transform a char to
4726            // three chars.
4727            // TODO : we have to find a way to prevent this waste of space.
4728            char[] target = new char[ str.length() * 3 + 2 ];
4729            
4730            int pos = 0;
4731            char lowerCase = (char)( caseSensitive ? 0x00 : 0x20 );
4732            
4733            // First pass to map the chars
4734            for ( char c:array )
4735            {
4736                pos += map( c, target, pos, lowerCase );
4737            }
4738    
4739            int limit = pos;
4740            pos = 0;
4741            
4742            // Second pass to remove spaces. We work on the target
4743            int i = 0;
4744            char c = '\0';
4745            
4746            // First remove starting spaces
4747            for ( i=0; i < limit; i++ )
4748            {
4749                c = target[i];
4750                
4751                if ( c != ' ' )
4752                {
4753                    checkProhibited( c );
4754                    break;
4755                }
4756            }
4757            
4758            // Now, 'i' will be the starting point. We will just handle the special
4759            // case of a combining character
4760            int start = i;
4761            
4762            if ( start == limit )
4763            {
4764                // we only have spaces
4765                return "";
4766            }
4767            else if ( isCombiningMark( c ) )
4768            {
4769                if ( start == 0 )
4770                {
4771                    // The first char can't be a combining char
4772                    throw new InvalidCharacterException( c );
4773                }
4774                else
4775                {
4776                    target[pos++] = ' ';
4777                    target[pos++] = c;
4778                    start++;
4779                }
4780            }
4781            else 
4782            {
4783                target[pos++] = c;
4784                start++;
4785            }
4786            
4787            // Now remove the spaces at the end
4788            for ( i = limit-1; i > start; i-- )
4789            {
4790                if ( target[i] != ' ' )
4791                {
4792                    break;
4793                }
4794            }
4795            
4796            limit = i + 1;
4797            
4798            // Let's deal with the following chars. It will be
4799            // a list of chars and spaces. We will consider that
4800            // we have couples of chars and spaces :
4801            // (char * space*)*. We have a special case :
4802            // a space followed by a combining char.
4803            boolean spaceSeen = false;
4804            boolean space2Seen = false;
4805            
4806            for ( i = start; i < limit; i++ )
4807            {
4808                c = target[i];
4809                
4810                checkProhibited( c );
4811                
4812                if ( isCombiningMark( c ) )
4813                {
4814                    if ( spaceSeen )
4815                    {
4816                        if ( space2Seen )
4817                        {
4818                            target[pos++] = ' ';
4819                        }
4820    
4821                        target[pos++] = ' ';
4822                        target[pos++] = c;
4823                        spaceSeen = false;
4824                        space2Seen = false;
4825                    }
4826                    else
4827                    {
4828                        target[pos++] = c;
4829                    }
4830                }
4831                else if ( c == ' ' )
4832                {
4833                    if ( spaceSeen )
4834                    {
4835                        space2Seen = true;
4836                    }
4837                    else
4838                    {
4839                        spaceSeen = true;
4840                    }
4841                }
4842                else
4843                {
4844                    if ( spaceSeen )
4845                    {
4846                        target[pos++] = ' ';
4847                        spaceSeen = false;
4848                        space2Seen = false;
4849                    }
4850                    
4851                    target[pos++] = c;
4852                }
4853            }
4854            
4855            return new String( target, 0, pos );
4856        }
4857    }