Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    * 
    *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation and was
   * originally based on software copyright (c) 1999, International
   * Business Machines, Inc., http://www.apache.org.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  package org.apache.jasper.xmlparser;
  
  import java.util.Arrays;

This class defines the basic XML character properties. The data in this class can be used to verify that a character is a valid XML character or if the character is a space, name start, or name character.

A series of convenience methods are supplied to ease the burden of the developer. Because inlining the checks can improve per character performance, the tables of character properties are public. Using the character as an index into the CHARS array and applying the appropriate mask flag (e.g. MASK_VALID), yields the same results as calling the convenience methods. There is one exception: check the comments for the isValid method for details.

Author(s):
Glenn Marcy, IBM
Andy Clark, IBM
Eric Ye, IBM
Arnaud Le Hors, IBM
Michael Glavassevich, IBM
Rahul Srivastava, Sun Microsystems Inc.
Version:
$Id: XMLChar.java 515 2008-03-17 21:02:23Z jfrederic.clere@jboss.com $
  
  public class XMLChar {
  
      //
      // Constants
      //
  
    
Character flags.
  
      private static final byte[] CHARS = new byte[1 << 16];

    
Valid character mask.
  
      public static final int MASK_VALID = 0x01;

    
Space character mask.
  
      public static final int MASK_SPACE = 0x02;

    
Name start character mask.
  
      public static final int MASK_NAME_START = 0x04;

    
Name character mask.
  
      public static final int MASK_NAME = 0x08;

    
Pubid character mask.
  
      public static final int MASK_PUBID = 0x10;
    
    
Content character mask. Special characters are those that can be considered the start of markup, such as '<' and '&'. The various newline characters are considered special as well. All other valid XML characters can be considered content.

This is an optimization for the inner loop of character scanning.

  
      public static final int MASK_CONTENT = 0x20;

    
NCName start character mask.
  
      public static final int MASK_NCNAME_START = 0x40;

    
NCName character mask.
  
      public static final int MASK_NCNAME = 0x80;
  
      //
      // Static initialization
      //
  
      static {
          
         // Initializing the Character Flag Array
         // Code generated by: XMLCharGenerator.
         
         [9] = 35;
         [10] = 19;
         [13] = 19;
         [32] = 51;
         [33] = 49;
         [34] = 33;
         Arrays.fill(, 35, 38, (byte) 49 ); // Fill 3 of value (byte) 49
         [38] = 1;
         Arrays.fill(, 39, 45, (byte) 49 ); // Fill 6 of value (byte) 49
         Arrays.fill(, 45, 47, (byte) -71 ); // Fill 2 of value (byte) -71
         [47] = 49;
         Arrays.fill(, 48, 58, (byte) -71 ); // Fill 10 of value (byte) -71
         [58] = 61;
         [59] = 49;
         [60] = 1;
         [61] = 49;
         [62] = 33;
         Arrays.fill(, 63, 65, (byte) 49 ); // Fill 2 of value (byte) 49
         Arrays.fill(, 65, 91, (byte) -3 ); // Fill 26 of value (byte) -3
         Arrays.fill(, 91, 93, (byte) 33 ); // Fill 2 of value (byte) 33
         [93] = 1;
         [94] = 33;
         [95] = -3;
         [96] = 33;
         Arrays.fill(, 97, 123, (byte) -3 ); // Fill 26 of value (byte) -3
         Arrays.fill(, 123, 183, (byte) 33 ); // Fill 60 of value (byte) 33
         [183] = -87;
         Arrays.fill(, 184, 192, (byte) 33 ); // Fill 8 of value (byte) 33
         Arrays.fill(, 192, 215, (byte) -19 ); // Fill 23 of value (byte) -19
         [215] = 33;
         Arrays.fill(, 216, 247, (byte) -19 ); // Fill 31 of value (byte) -19
         [247] = 33;
         Arrays.fill(, 248, 306, (byte) -19 ); // Fill 58 of value (byte) -19
         Arrays.fill(, 306, 308, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 308, 319, (byte) -19 ); // Fill 11 of value (byte) -19
         Arrays.fill(, 319, 321, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 321, 329, (byte) -19 ); // Fill 8 of value (byte) -19
         [329] = 33;
         Arrays.fill(, 330, 383, (byte) -19 ); // Fill 53 of value (byte) -19
         [383] = 33;
         Arrays.fill(, 384, 452, (byte) -19 ); // Fill 68 of value (byte) -19
         Arrays.fill(, 452, 461, (byte) 33 ); // Fill 9 of value (byte) 33
         Arrays.fill(, 461, 497, (byte) -19 ); // Fill 36 of value (byte) -19
         Arrays.fill(, 497, 500, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 500, 502, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 502, 506, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 506, 536, (byte) -19 ); // Fill 30 of value (byte) -19
         Arrays.fill(, 536, 592, (byte) 33 ); // Fill 56 of value (byte) 33
         Arrays.fill(, 592, 681, (byte) -19 ); // Fill 89 of value (byte) -19
         Arrays.fill(, 681, 699, (byte) 33 ); // Fill 18 of value (byte) 33
         Arrays.fill(, 699, 706, (byte) -19 ); // Fill 7 of value (byte) -19
         Arrays.fill(, 706, 720, (byte) 33 ); // Fill 14 of value (byte) 33
         Arrays.fill(, 720, 722, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 722, 768, (byte) 33 ); // Fill 46 of value (byte) 33
         Arrays.fill(, 768, 838, (byte) -87 ); // Fill 70 of value (byte) -87
         Arrays.fill(, 838, 864, (byte) 33 ); // Fill 26 of value (byte) 33
         Arrays.fill(, 864, 866, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 866, 902, (byte) 33 ); // Fill 36 of value (byte) 33
         [902] = -19;
         [903] = -87;
         Arrays.fill(, 904, 907, (byte) -19 ); // Fill 3 of value (byte) -19
         [907] = 33;
         [908] = -19;
         [909] = 33;
         Arrays.fill(, 910, 930, (byte) -19 ); // Fill 20 of value (byte) -19
         [930] = 33;
         Arrays.fill(, 931, 975, (byte) -19 ); // Fill 44 of value (byte) -19
         [975] = 33;
         Arrays.fill(, 976, 983, (byte) -19 ); // Fill 7 of value (byte) -19
         Arrays.fill(, 983, 986, (byte) 33 ); // Fill 3 of value (byte) 33
         [986] = -19;
         [987] = 33;
         [988] = -19;
         [989] = 33;
         [990] = -19;
         [991] = 33;
         [992] = -19;
         [993] = 33;
         Arrays.fill(, 994, 1012, (byte) -19 ); // Fill 18 of value (byte) -19
         Arrays.fill(, 1012, 1025, (byte) 33 ); // Fill 13 of value (byte) 33
         Arrays.fill(, 1025, 1037, (byte) -19 ); // Fill 12 of value (byte) -19
         [1037] = 33;
         Arrays.fill(, 1038, 1104, (byte) -19 ); // Fill 66 of value (byte) -19
         [1104] = 33;
         Arrays.fill(, 1105, 1117, (byte) -19 ); // Fill 12 of value (byte) -19
         [1117] = 33;
         Arrays.fill(, 1118, 1154, (byte) -19 ); // Fill 36 of value (byte) -19
         [1154] = 33;
         Arrays.fill(, 1155, 1159, (byte) -87 ); // Fill 4 of value (byte) -87
         Arrays.fill(, 1159, 1168, (byte) 33 ); // Fill 9 of value (byte) 33
         Arrays.fill(, 1168, 1221, (byte) -19 ); // Fill 53 of value (byte) -19
         Arrays.fill(, 1221, 1223, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 1223, 1225, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 1225, 1227, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 1227, 1229, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 1229, 1232, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 1232, 1260, (byte) -19 ); // Fill 28 of value (byte) -19
         Arrays.fill(, 1260, 1262, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 1262, 1270, (byte) -19 ); // Fill 8 of value (byte) -19
         Arrays.fill(, 1270, 1272, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 1272, 1274, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 1274, 1329, (byte) 33 ); // Fill 55 of value (byte) 33
         Arrays.fill(, 1329, 1367, (byte) -19 ); // Fill 38 of value (byte) -19
         Arrays.fill(, 1367, 1369, (byte) 33 ); // Fill 2 of value (byte) 33
         [1369] = -19;
         Arrays.fill(, 1370, 1377, (byte) 33 ); // Fill 7 of value (byte) 33
         Arrays.fill(, 1377, 1415, (byte) -19 ); // Fill 38 of value (byte) -19
         Arrays.fill(, 1415, 1425, (byte) 33 ); // Fill 10 of value (byte) 33
         Arrays.fill(, 1425, 1442, (byte) -87 ); // Fill 17 of value (byte) -87
         [1442] = 33;
         Arrays.fill(, 1443, 1466, (byte) -87 ); // Fill 23 of value (byte) -87
         [1466] = 33;
         Arrays.fill(, 1467, 1470, (byte) -87 ); // Fill 3 of value (byte) -87
         [1470] = 33;
         [1471] = -87;
         [1472] = 33;
         Arrays.fill(, 1473, 1475, (byte) -87 ); // Fill 2 of value (byte) -87
         [1475] = 33;
         [1476] = -87;
         Arrays.fill(, 1477, 1488, (byte) 33 ); // Fill 11 of value (byte) 33
         Arrays.fill(, 1488, 1515, (byte) -19 ); // Fill 27 of value (byte) -19
         Arrays.fill(, 1515, 1520, (byte) 33 ); // Fill 5 of value (byte) 33
         Arrays.fill(, 1520, 1523, (byte) -19 ); // Fill 3 of value (byte) -19
         Arrays.fill(, 1523, 1569, (byte) 33 ); // Fill 46 of value (byte) 33
         Arrays.fill(, 1569, 1595, (byte) -19 ); // Fill 26 of value (byte) -19
         Arrays.fill(, 1595, 1600, (byte) 33 ); // Fill 5 of value (byte) 33
         [1600] = -87;
         Arrays.fill(, 1601, 1611, (byte) -19 ); // Fill 10 of value (byte) -19
         Arrays.fill(, 1611, 1619, (byte) -87 ); // Fill 8 of value (byte) -87
         Arrays.fill(, 1619, 1632, (byte) 33 ); // Fill 13 of value (byte) 33
         Arrays.fill(, 1632, 1642, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 1642, 1648, (byte) 33 ); // Fill 6 of value (byte) 33
         [1648] = -87;
         Arrays.fill(, 1649, 1720, (byte) -19 ); // Fill 71 of value (byte) -19
         Arrays.fill(, 1720, 1722, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 1722, 1727, (byte) -19 ); // Fill 5 of value (byte) -19
         [1727] = 33;
         Arrays.fill(, 1728, 1743, (byte) -19 ); // Fill 15 of value (byte) -19
         [1743] = 33;
         Arrays.fill(, 1744, 1748, (byte) -19 ); // Fill 4 of value (byte) -19
         [1748] = 33;
         [1749] = -19;
         Arrays.fill(, 1750, 1765, (byte) -87 ); // Fill 15 of value (byte) -87
         Arrays.fill(, 1765, 1767, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 1767, 1769, (byte) -87 ); // Fill 2 of value (byte) -87
         [1769] = 33;
         Arrays.fill(, 1770, 1774, (byte) -87 ); // Fill 4 of value (byte) -87
         Arrays.fill(, 1774, 1776, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 1776, 1786, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 1786, 2305, (byte) 33 ); // Fill 519 of value (byte) 33
         Arrays.fill(, 2305, 2308, (byte) -87 ); // Fill 3 of value (byte) -87
         [2308] = 33;
         Arrays.fill(, 2309, 2362, (byte) -19 ); // Fill 53 of value (byte) -19
         Arrays.fill(, 2362, 2364, (byte) 33 ); // Fill 2 of value (byte) 33
         [2364] = -87;
         [2365] = -19;
         Arrays.fill(, 2366, 2382, (byte) -87 ); // Fill 16 of value (byte) -87
         Arrays.fill(, 2382, 2385, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2385, 2389, (byte) -87 ); // Fill 4 of value (byte) -87
         Arrays.fill(, 2389, 2392, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2392, 2402, (byte) -19 ); // Fill 10 of value (byte) -19
         Arrays.fill(, 2402, 2404, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 2404, 2406, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2406, 2416, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 2416, 2433, (byte) 33 ); // Fill 17 of value (byte) 33
         Arrays.fill(, 2433, 2436, (byte) -87 ); // Fill 3 of value (byte) -87
         [2436] = 33;
         Arrays.fill(, 2437, 2445, (byte) -19 ); // Fill 8 of value (byte) -19
         Arrays.fill(, 2445, 2447, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2447, 2449, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 2449, 2451, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2451, 2473, (byte) -19 ); // Fill 22 of value (byte) -19
         [2473] = 33;
         Arrays.fill(, 2474, 2481, (byte) -19 ); // Fill 7 of value (byte) -19
         [2481] = 33;
         [2482] = -19;
         Arrays.fill(, 2483, 2486, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2486, 2490, (byte) -19 ); // Fill 4 of value (byte) -19
         Arrays.fill(, 2490, 2492, (byte) 33 ); // Fill 2 of value (byte) 33
         [2492] = -87;
         [2493] = 33;
         Arrays.fill(, 2494, 2501, (byte) -87 ); // Fill 7 of value (byte) -87
         Arrays.fill(, 2501, 2503, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2503, 2505, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 2505, 2507, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2507, 2510, (byte) -87 ); // Fill 3 of value (byte) -87
         Arrays.fill(, 2510, 2519, (byte) 33 ); // Fill 9 of value (byte) 33
         [2519] = -87;
         Arrays.fill(, 2520, 2524, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 2524, 2526, (byte) -19 ); // Fill 2 of value (byte) -19
         [2526] = 33;
         Arrays.fill(, 2527, 2530, (byte) -19 ); // Fill 3 of value (byte) -19
         Arrays.fill(, 2530, 2532, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 2532, 2534, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2534, 2544, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 2544, 2546, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 2546, 2562, (byte) 33 ); // Fill 16 of value (byte) 33
         [2562] = -87;
         Arrays.fill(, 2563, 2565, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2565, 2571, (byte) -19 ); // Fill 6 of value (byte) -19
         Arrays.fill(, 2571, 2575, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 2575, 2577, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 2577, 2579, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2579, 2601, (byte) -19 ); // Fill 22 of value (byte) -19
         [2601] = 33;
         Arrays.fill(, 2602, 2609, (byte) -19 ); // Fill 7 of value (byte) -19
         [2609] = 33;
         Arrays.fill(, 2610, 2612, (byte) -19 ); // Fill 2 of value (byte) -19
         [2612] = 33;
         Arrays.fill(, 2613, 2615, (byte) -19 ); // Fill 2 of value (byte) -19
         [2615] = 33;
         Arrays.fill(, 2616, 2618, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 2618, 2620, (byte) 33 ); // Fill 2 of value (byte) 33
         [2620] = -87;
         [2621] = 33;
         Arrays.fill(, 2622, 2627, (byte) -87 ); // Fill 5 of value (byte) -87
         Arrays.fill(, 2627, 2631, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 2631, 2633, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 2633, 2635, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2635, 2638, (byte) -87 ); // Fill 3 of value (byte) -87
         Arrays.fill(, 2638, 2649, (byte) 33 ); // Fill 11 of value (byte) 33
         Arrays.fill(, 2649, 2653, (byte) -19 ); // Fill 4 of value (byte) -19
         [2653] = 33;
         [2654] = -19;
         Arrays.fill(, 2655, 2662, (byte) 33 ); // Fill 7 of value (byte) 33
         Arrays.fill(, 2662, 2674, (byte) -87 ); // Fill 12 of value (byte) -87
         Arrays.fill(, 2674, 2677, (byte) -19 ); // Fill 3 of value (byte) -19
         Arrays.fill(, 2677, 2689, (byte) 33 ); // Fill 12 of value (byte) 33
         Arrays.fill(, 2689, 2692, (byte) -87 ); // Fill 3 of value (byte) -87
         [2692] = 33;
         Arrays.fill(, 2693, 2700, (byte) -19 ); // Fill 7 of value (byte) -19
         [2700] = 33;
         [2701] = -19;
         [2702] = 33;
         Arrays.fill(, 2703, 2706, (byte) -19 ); // Fill 3 of value (byte) -19
         [2706] = 33;
         Arrays.fill(, 2707, 2729, (byte) -19 ); // Fill 22 of value (byte) -19
         [2729] = 33;
         Arrays.fill(, 2730, 2737, (byte) -19 ); // Fill 7 of value (byte) -19
         [2737] = 33;
         Arrays.fill(, 2738, 2740, (byte) -19 ); // Fill 2 of value (byte) -19
         [2740] = 33;
         Arrays.fill(, 2741, 2746, (byte) -19 ); // Fill 5 of value (byte) -19
         Arrays.fill(, 2746, 2748, (byte) 33 ); // Fill 2 of value (byte) 33
         [2748] = -87;
         [2749] = -19;
         Arrays.fill(, 2750, 2758, (byte) -87 ); // Fill 8 of value (byte) -87
         [2758] = 33;
         Arrays.fill(, 2759, 2762, (byte) -87 ); // Fill 3 of value (byte) -87
         [2762] = 33;
         Arrays.fill(, 2763, 2766, (byte) -87 ); // Fill 3 of value (byte) -87
         Arrays.fill(, 2766, 2784, (byte) 33 ); // Fill 18 of value (byte) 33
         [2784] = -19;
         Arrays.fill(, 2785, 2790, (byte) 33 ); // Fill 5 of value (byte) 33
         Arrays.fill(, 2790, 2800, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 2800, 2817, (byte) 33 ); // Fill 17 of value (byte) 33
         Arrays.fill(, 2817, 2820, (byte) -87 ); // Fill 3 of value (byte) -87
         [2820] = 33;
         Arrays.fill(, 2821, 2829, (byte) -19 ); // Fill 8 of value (byte) -19
         Arrays.fill(, 2829, 2831, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2831, 2833, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 2833, 2835, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2835, 2857, (byte) -19 ); // Fill 22 of value (byte) -19
         [2857] = 33;
         Arrays.fill(, 2858, 2865, (byte) -19 ); // Fill 7 of value (byte) -19
         [2865] = 33;
         Arrays.fill(, 2866, 2868, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 2868, 2870, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2870, 2874, (byte) -19 ); // Fill 4 of value (byte) -19
         Arrays.fill(, 2874, 2876, (byte) 33 ); // Fill 2 of value (byte) 33
         [2876] = -87;
         [2877] = -19;
         Arrays.fill(, 2878, 2884, (byte) -87 ); // Fill 6 of value (byte) -87
         Arrays.fill(, 2884, 2887, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2887, 2889, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 2889, 2891, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 2891, 2894, (byte) -87 ); // Fill 3 of value (byte) -87
         Arrays.fill(, 2894, 2902, (byte) 33 ); // Fill 8 of value (byte) 33
         Arrays.fill(, 2902, 2904, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 2904, 2908, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 2908, 2910, (byte) -19 ); // Fill 2 of value (byte) -19
         [2910] = 33;
         Arrays.fill(, 2911, 2914, (byte) -19 ); // Fill 3 of value (byte) -19
         Arrays.fill(, 2914, 2918, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 2918, 2928, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 2928, 2946, (byte) 33 ); // Fill 18 of value (byte) 33
         Arrays.fill(, 2946, 2948, (byte) -87 ); // Fill 2 of value (byte) -87
         [2948] = 33;
         Arrays.fill(, 2949, 2955, (byte) -19 ); // Fill 6 of value (byte) -19
         Arrays.fill(, 2955, 2958, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2958, 2961, (byte) -19 ); // Fill 3 of value (byte) -19
         [2961] = 33;
         Arrays.fill(, 2962, 2966, (byte) -19 ); // Fill 4 of value (byte) -19
         Arrays.fill(, 2966, 2969, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2969, 2971, (byte) -19 ); // Fill 2 of value (byte) -19
         [2971] = 33;
         [2972] = -19;
         [2973] = 33;
         Arrays.fill(, 2974, 2976, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 2976, 2979, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2979, 2981, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 2981, 2984, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2984, 2987, (byte) -19 ); // Fill 3 of value (byte) -19
         Arrays.fill(, 2987, 2990, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 2990, 2998, (byte) -19 ); // Fill 8 of value (byte) -19
         [2998] = 33;
         Arrays.fill(, 2999, 3002, (byte) -19 ); // Fill 3 of value (byte) -19
         Arrays.fill(, 3002, 3006, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3006, 3011, (byte) -87 ); // Fill 5 of value (byte) -87
         Arrays.fill(, 3011, 3014, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 3014, 3017, (byte) -87 ); // Fill 3 of value (byte) -87
         [3017] = 33;
         Arrays.fill(, 3018, 3022, (byte) -87 ); // Fill 4 of value (byte) -87
         Arrays.fill(, 3022, 3031, (byte) 33 ); // Fill 9 of value (byte) 33
         [3031] = -87;
         Arrays.fill(, 3032, 3047, (byte) 33 ); // Fill 15 of value (byte) 33
         Arrays.fill(, 3047, 3056, (byte) -87 ); // Fill 9 of value (byte) -87
         Arrays.fill(, 3056, 3073, (byte) 33 ); // Fill 17 of value (byte) 33
         Arrays.fill(, 3073, 3076, (byte) -87 ); // Fill 3 of value (byte) -87
         [3076] = 33;
         Arrays.fill(, 3077, 3085, (byte) -19 ); // Fill 8 of value (byte) -19
         [3085] = 33;
         Arrays.fill(, 3086, 3089, (byte) -19 ); // Fill 3 of value (byte) -19
         [3089] = 33;
         Arrays.fill(, 3090, 3113, (byte) -19 ); // Fill 23 of value (byte) -19
         [3113] = 33;
         Arrays.fill(, 3114, 3124, (byte) -19 ); // Fill 10 of value (byte) -19
         [3124] = 33;
         Arrays.fill(, 3125, 3130, (byte) -19 ); // Fill 5 of value (byte) -19
         Arrays.fill(, 3130, 3134, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3134, 3141, (byte) -87 ); // Fill 7 of value (byte) -87
         [3141] = 33;
         Arrays.fill(, 3142, 3145, (byte) -87 ); // Fill 3 of value (byte) -87
         [3145] = 33;
         Arrays.fill(, 3146, 3150, (byte) -87 ); // Fill 4 of value (byte) -87
         Arrays.fill(, 3150, 3157, (byte) 33 ); // Fill 7 of value (byte) 33
         Arrays.fill(, 3157, 3159, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 3159, 3168, (byte) 33 ); // Fill 9 of value (byte) 33
         Arrays.fill(, 3168, 3170, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 3170, 3174, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3174, 3184, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 3184, 3202, (byte) 33 ); // Fill 18 of value (byte) 33
         Arrays.fill(, 3202, 3204, (byte) -87 ); // Fill 2 of value (byte) -87
         [3204] = 33;
         Arrays.fill(, 3205, 3213, (byte) -19 ); // Fill 8 of value (byte) -19
         [3213] = 33;
         Arrays.fill(, 3214, 3217, (byte) -19 ); // Fill 3 of value (byte) -19
         [3217] = 33;
         Arrays.fill(, 3218, 3241, (byte) -19 ); // Fill 23 of value (byte) -19
         [3241] = 33;
         Arrays.fill(, 3242, 3252, (byte) -19 ); // Fill 10 of value (byte) -19
         [3252] = 33;
         Arrays.fill(, 3253, 3258, (byte) -19 ); // Fill 5 of value (byte) -19
         Arrays.fill(, 3258, 3262, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3262, 3269, (byte) -87 ); // Fill 7 of value (byte) -87
         [3269] = 33;
         Arrays.fill(, 3270, 3273, (byte) -87 ); // Fill 3 of value (byte) -87
         [3273] = 33;
         Arrays.fill(, 3274, 3278, (byte) -87 ); // Fill 4 of value (byte) -87
         Arrays.fill(, 3278, 3285, (byte) 33 ); // Fill 7 of value (byte) 33
         Arrays.fill(, 3285, 3287, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 3287, 3294, (byte) 33 ); // Fill 7 of value (byte) 33
         [3294] = -19;
         [3295] = 33;
         Arrays.fill(, 3296, 3298, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 3298, 3302, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3302, 3312, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 3312, 3330, (byte) 33 ); // Fill 18 of value (byte) 33
         Arrays.fill(, 3330, 3332, (byte) -87 ); // Fill 2 of value (byte) -87
         [3332] = 33;
         Arrays.fill(, 3333, 3341, (byte) -19 ); // Fill 8 of value (byte) -19
         [3341] = 33;
         Arrays.fill(, 3342, 3345, (byte) -19 ); // Fill 3 of value (byte) -19
         [3345] = 33;
         Arrays.fill(, 3346, 3369, (byte) -19 ); // Fill 23 of value (byte) -19
         [3369] = 33;
         Arrays.fill(, 3370, 3386, (byte) -19 ); // Fill 16 of value (byte) -19
         Arrays.fill(, 3386, 3390, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3390, 3396, (byte) -87 ); // Fill 6 of value (byte) -87
         Arrays.fill(, 3396, 3398, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 3398, 3401, (byte) -87 ); // Fill 3 of value (byte) -87
         [3401] = 33;
         Arrays.fill(, 3402, 3406, (byte) -87 ); // Fill 4 of value (byte) -87
         Arrays.fill(, 3406, 3415, (byte) 33 ); // Fill 9 of value (byte) 33
         [3415] = -87;
         Arrays.fill(, 3416, 3424, (byte) 33 ); // Fill 8 of value (byte) 33
         Arrays.fill(, 3424, 3426, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 3426, 3430, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3430, 3440, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 3440, 3585, (byte) 33 ); // Fill 145 of value (byte) 33
         Arrays.fill(, 3585, 3631, (byte) -19 ); // Fill 46 of value (byte) -19
         [3631] = 33;
         [3632] = -19;
         [3633] = -87;
         Arrays.fill(, 3634, 3636, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 3636, 3643, (byte) -87 ); // Fill 7 of value (byte) -87
         Arrays.fill(, 3643, 3648, (byte) 33 ); // Fill 5 of value (byte) 33
         Arrays.fill(, 3648, 3654, (byte) -19 ); // Fill 6 of value (byte) -19
         Arrays.fill(, 3654, 3663, (byte) -87 ); // Fill 9 of value (byte) -87
         [3663] = 33;
         Arrays.fill(, 3664, 3674, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 3674, 3713, (byte) 33 ); // Fill 39 of value (byte) 33
         Arrays.fill(, 3713, 3715, (byte) -19 ); // Fill 2 of value (byte) -19
         [3715] = 33;
         [3716] = -19;
         Arrays.fill(, 3717, 3719, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 3719, 3721, (byte) -19 ); // Fill 2 of value (byte) -19
         [3721] = 33;
         [3722] = -19;
         Arrays.fill(, 3723, 3725, (byte) 33 ); // Fill 2 of value (byte) 33
         [3725] = -19;
         Arrays.fill(, 3726, 3732, (byte) 33 ); // Fill 6 of value (byte) 33
         Arrays.fill(, 3732, 3736, (byte) -19 ); // Fill 4 of value (byte) -19
         [3736] = 33;
         Arrays.fill(, 3737, 3744, (byte) -19 ); // Fill 7 of value (byte) -19
         [3744] = 33;
         Arrays.fill(, 3745, 3748, (byte) -19 ); // Fill 3 of value (byte) -19
         [3748] = 33;
         [3749] = -19;
         [3750] = 33;
         [3751] = -19;
         Arrays.fill(, 3752, 3754, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 3754, 3756, (byte) -19 ); // Fill 2 of value (byte) -19
         [3756] = 33;
         Arrays.fill(, 3757, 3759, (byte) -19 ); // Fill 2 of value (byte) -19
         [3759] = 33;
         [3760] = -19;
         [3761] = -87;
         Arrays.fill(, 3762, 3764, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 3764, 3770, (byte) -87 ); // Fill 6 of value (byte) -87
         [3770] = 33;
         Arrays.fill(, 3771, 3773, (byte) -87 ); // Fill 2 of value (byte) -87
         [3773] = -19;
         Arrays.fill(, 3774, 3776, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 3776, 3781, (byte) -19 ); // Fill 5 of value (byte) -19
         [3781] = 33;
         [3782] = -87;
         [3783] = 33;
         Arrays.fill(, 3784, 3790, (byte) -87 ); // Fill 6 of value (byte) -87
         Arrays.fill(, 3790, 3792, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 3792, 3802, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 3802, 3864, (byte) 33 ); // Fill 62 of value (byte) 33
         Arrays.fill(, 3864, 3866, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 3866, 3872, (byte) 33 ); // Fill 6 of value (byte) 33
         Arrays.fill(, 3872, 3882, (byte) -87 ); // Fill 10 of value (byte) -87
         Arrays.fill(, 3882, 3893, (byte) 33 ); // Fill 11 of value (byte) 33
         [3893] = -87;
         [3894] = 33;
         [3895] = -87;
         [3896] = 33;
         [3897] = -87;
         Arrays.fill(, 3898, 3902, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3902, 3904, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 3904, 3912, (byte) -19 ); // Fill 8 of value (byte) -19
         [3912] = 33;
         Arrays.fill(, 3913, 3946, (byte) -19 ); // Fill 33 of value (byte) -19
         Arrays.fill(, 3946, 3953, (byte) 33 ); // Fill 7 of value (byte) 33
         Arrays.fill(, 3953, 3973, (byte) -87 ); // Fill 20 of value (byte) -87
         [3973] = 33;
         Arrays.fill(, 3974, 3980, (byte) -87 ); // Fill 6 of value (byte) -87
         Arrays.fill(, 3980, 3984, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 3984, 3990, (byte) -87 ); // Fill 6 of value (byte) -87
         [3990] = 33;
         [3991] = -87;
         [3992] = 33;
         Arrays.fill(, 3993, 4014, (byte) -87 ); // Fill 21 of value (byte) -87
         Arrays.fill(, 4014, 4017, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 4017, 4024, (byte) -87 ); // Fill 7 of value (byte) -87
         [4024] = 33;
         [4025] = -87;
         Arrays.fill(, 4026, 4256, (byte) 33 ); // Fill 230 of value (byte) 33
         Arrays.fill(, 4256, 4294, (byte) -19 ); // Fill 38 of value (byte) -19
         Arrays.fill(, 4294, 4304, (byte) 33 ); // Fill 10 of value (byte) 33
         Arrays.fill(, 4304, 4343, (byte) -19 ); // Fill 39 of value (byte) -19
         Arrays.fill(, 4343, 4352, (byte) 33 ); // Fill 9 of value (byte) 33
         [4352] = -19;
         [4353] = 33;
         Arrays.fill(, 4354, 4356, (byte) -19 ); // Fill 2 of value (byte) -19
         [4356] = 33;
         Arrays.fill(, 4357, 4360, (byte) -19 ); // Fill 3 of value (byte) -19
         [4360] = 33;
         [4361] = -19;
         [4362] = 33;
         Arrays.fill(, 4363, 4365, (byte) -19 ); // Fill 2 of value (byte) -19
         [4365] = 33;
         Arrays.fill(, 4366, 4371, (byte) -19 ); // Fill 5 of value (byte) -19
         Arrays.fill(, 4371, 4412, (byte) 33 ); // Fill 41 of value (byte) 33
         [4412] = -19;
         [4413] = 33;
         [4414] = -19;
         [4415] = 33;
         [4416] = -19;
         Arrays.fill(, 4417, 4428, (byte) 33 ); // Fill 11 of value (byte) 33
         [4428] = -19;
         [4429] = 33;
         [4430] = -19;
         [4431] = 33;
         [4432] = -19;
         Arrays.fill(, 4433, 4436, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 4436, 4438, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 4438, 4441, (byte) 33 ); // Fill 3 of value (byte) 33
         [4441] = -19;
         Arrays.fill(, 4442, 4447, (byte) 33 ); // Fill 5 of value (byte) 33
         Arrays.fill(, 4447, 4450, (byte) -19 ); // Fill 3 of value (byte) -19
         [4450] = 33;
         [4451] = -19;
         [4452] = 33;
         [4453] = -19;
         [4454] = 33;
         [4455] = -19;
         [4456] = 33;
         [4457] = -19;
         Arrays.fill(, 4458, 4461, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 4461, 4463, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 4463, 4466, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 4466, 4468, (byte) -19 ); // Fill 2 of value (byte) -19
         [4468] = 33;
         [4469] = -19;
         Arrays.fill(, 4470, 4510, (byte) 33 ); // Fill 40 of value (byte) 33
         [4510] = -19;
         Arrays.fill(, 4511, 4520, (byte) 33 ); // Fill 9 of value (byte) 33
         [4520] = -19;
         Arrays.fill(, 4521, 4523, (byte) 33 ); // Fill 2 of value (byte) 33
         [4523] = -19;
         Arrays.fill(, 4524, 4526, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 4526, 4528, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 4528, 4535, (byte) 33 ); // Fill 7 of value (byte) 33
         Arrays.fill(, 4535, 4537, (byte) -19 ); // Fill 2 of value (byte) -19
         [4537] = 33;
         [4538] = -19;
         [4539] = 33;
         Arrays.fill(, 4540, 4547, (byte) -19 ); // Fill 7 of value (byte) -19
         Arrays.fill(, 4547, 4587, (byte) 33 ); // Fill 40 of value (byte) 33
         [4587] = -19;
         Arrays.fill(, 4588, 4592, (byte) 33 ); // Fill 4 of value (byte) 33
         [4592] = -19;
         Arrays.fill(, 4593, 4601, (byte) 33 ); // Fill 8 of value (byte) 33
         [4601] = -19;
         Arrays.fill(, 4602, 7680, (byte) 33 ); // Fill 3078 of value (byte) 33
         Arrays.fill(, 7680, 7836, (byte) -19 ); // Fill 156 of value (byte) -19
         Arrays.fill(, 7836, 7840, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 7840, 7930, (byte) -19 ); // Fill 90 of value (byte) -19
         Arrays.fill(, 7930, 7936, (byte) 33 ); // Fill 6 of value (byte) 33
         Arrays.fill(, 7936, 7958, (byte) -19 ); // Fill 22 of value (byte) -19
         Arrays.fill(, 7958, 7960, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 7960, 7966, (byte) -19 ); // Fill 6 of value (byte) -19
         Arrays.fill(, 7966, 7968, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 7968, 8006, (byte) -19 ); // Fill 38 of value (byte) -19
         Arrays.fill(, 8006, 8008, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 8008, 8014, (byte) -19 ); // Fill 6 of value (byte) -19
         Arrays.fill(, 8014, 8016, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 8016, 8024, (byte) -19 ); // Fill 8 of value (byte) -19
         [8024] = 33;
         [8025] = -19;
         [8026] = 33;
         [8027] = -19;
         [8028] = 33;
         [8029] = -19;
         [8030] = 33;
         Arrays.fill(, 8031, 8062, (byte) -19 ); // Fill 31 of value (byte) -19
         Arrays.fill(, 8062, 8064, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 8064, 8117, (byte) -19 ); // Fill 53 of value (byte) -19
         [8117] = 33;
         Arrays.fill(, 8118, 8125, (byte) -19 ); // Fill 7 of value (byte) -19
         [8125] = 33;
         [8126] = -19;
         Arrays.fill(, 8127, 8130, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 8130, 8133, (byte) -19 ); // Fill 3 of value (byte) -19
         [8133] = 33;
         Arrays.fill(, 8134, 8141, (byte) -19 ); // Fill 7 of value (byte) -19
         Arrays.fill(, 8141, 8144, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 8144, 8148, (byte) -19 ); // Fill 4 of value (byte) -19
         Arrays.fill(, 8148, 8150, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 8150, 8156, (byte) -19 ); // Fill 6 of value (byte) -19
         Arrays.fill(, 8156, 8160, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 8160, 8173, (byte) -19 ); // Fill 13 of value (byte) -19
         Arrays.fill(, 8173, 8178, (byte) 33 ); // Fill 5 of value (byte) 33
         Arrays.fill(, 8178, 8181, (byte) -19 ); // Fill 3 of value (byte) -19
         [8181] = 33;
         Arrays.fill(, 8182, 8189, (byte) -19 ); // Fill 7 of value (byte) -19
         Arrays.fill(, 8189, 8400, (byte) 33 ); // Fill 211 of value (byte) 33
         Arrays.fill(, 8400, 8413, (byte) -87 ); // Fill 13 of value (byte) -87
         Arrays.fill(, 8413, 8417, (byte) 33 ); // Fill 4 of value (byte) 33
         [8417] = -87;
         Arrays.fill(, 8418, 8486, (byte) 33 ); // Fill 68 of value (byte) 33
         [8486] = -19;
         Arrays.fill(, 8487, 8490, (byte) 33 ); // Fill 3 of value (byte) 33
         Arrays.fill(, 8490, 8492, (byte) -19 ); // Fill 2 of value (byte) -19
         Arrays.fill(, 8492, 8494, (byte) 33 ); // Fill 2 of value (byte) 33
         [8494] = -19;
         Arrays.fill(, 8495, 8576, (byte) 33 ); // Fill 81 of value (byte) 33
         Arrays.fill(, 8576, 8579, (byte) -19 ); // Fill 3 of value (byte) -19
         Arrays.fill(, 8579, 12293, (byte) 33 ); // Fill 3714 of value (byte) 33
         [12293] = -87;
         [12294] = 33;
         [12295] = -19;
         Arrays.fill(, 12296, 12321, (byte) 33 ); // Fill 25 of value (byte) 33
         Arrays.fill(, 12321, 12330, (byte) -19 ); // Fill 9 of value (byte) -19
         Arrays.fill(, 12330, 12336, (byte) -87 ); // Fill 6 of value (byte) -87
         [12336] = 33;
         Arrays.fill(, 12337, 12342, (byte) -87 ); // Fill 5 of value (byte) -87
         Arrays.fill(, 12342, 12353, (byte) 33 ); // Fill 11 of value (byte) 33
         Arrays.fill(, 12353, 12437, (byte) -19 ); // Fill 84 of value (byte) -19
         Arrays.fill(, 12437, 12441, (byte) 33 ); // Fill 4 of value (byte) 33
         Arrays.fill(, 12441, 12443, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 12443, 12445, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 12445, 12447, (byte) -87 ); // Fill 2 of value (byte) -87
         Arrays.fill(, 12447, 12449, (byte) 33 ); // Fill 2 of value (byte) 33
         Arrays.fill(, 12449, 12539, (byte) -19 ); // Fill 90 of value (byte) -19
         [12539] = 33;
         Arrays.fill(, 12540, 12543, (byte) -87 ); // Fill 3 of value (byte) -87
         Arrays.fill(, 12543, 12549, (byte) 33 ); // Fill 6 of value (byte) 33
         Arrays.fill(, 12549, 12589, (byte) -19 ); // Fill 40 of value (byte) -19
         Arrays.fill(, 12589, 19968, (byte) 33 ); // Fill 7379 of value (byte) 33
         Arrays.fill(, 19968, 40870, (byte) -19 ); // Fill 20902 of value (byte) -19
         Arrays.fill(, 40870, 44032, (byte) 33 ); // Fill 3162 of value (byte) 33
         Arrays.fill(, 44032, 55204, (byte) -19 ); // Fill 11172 of value (byte) -19
         Arrays.fill(, 55204, 55296, (byte) 33 ); // Fill 92 of value (byte) 33
         Arrays.fill(, 57344, 65534, (byte) 33 ); // Fill 8190 of value (byte) 33
 
     } // <clinit>()
 
     //
     // Public static methods
     //
 
    
Returns true if the specified character is a supplemental character.

Parameters:
c The character to check.
 
     public static boolean isSupplemental(int c) {
         return (c >= 0x10000 && c <= 0x10FFFF);
     }

    
Returns true the supplemental character corresponding to the given surrogates.

Parameters:
h The high surrogate.
l The low surrogate.
 
     public static int supplemental(char hchar l) {
         return (h - 0xD800) * 0x400 + (l - 0xDC00) + 0x10000;
     }

    
Returns the high surrogate of a supplemental character

Parameters:
c The supplemental character to "split".
 
     public static char highSurrogate(int c) {
         return (char) (((c - 0x00010000) >> 10) + 0xD800);
     }

    
Returns the low surrogate of a supplemental character

Parameters:
c The supplemental character to "split".
 
     public static char lowSurrogate(int c) {
         return (char) (((c - 0x00010000) & 0x3FF) + 0xDC00);
     }

    
Returns whether the given character is a high surrogate

Parameters:
c The character to check.
 
     public static boolean isHighSurrogate(int c) {
         return (0xD800 <= c && c <= 0xDBFF);
     }

    
Returns whether the given character is a low surrogate

Parameters:
c The character to check.
 
     public static boolean isLowSurrogate(int c) {
         return (0xDC00 <= c && c <= 0xDFFF);
     }


    
Returns true if the specified character is valid. This method also checks the surrogate character range from 0x10000 to 0x10FFFF.

If the program chooses to apply the mask directly to the CHARS array, then they are responsible for checking the surrogate character range.

Parameters:
c The character to check.
 
     public static boolean isValid(int c) {
         return (c < 0x10000 && ([c] & ) != 0) ||
                (0x10000 <= c && c <= 0x10FFFF);
     } // isValid(int):boolean
 
    
Returns true if the specified character is invalid.

Parameters:
c The character to check.
 
     public static boolean isInvalid(int c) {
         return !isValid(c);
     } // isInvalid(int):boolean
 
    
Returns true if the specified character can be considered content.

Parameters:
c The character to check.
 
     public static boolean isContent(int c) {
         return (c < 0x10000 && ([c] & ) != 0) ||
                (0x10000 <= c && c <= 0x10FFFF);
     } // isContent(int):boolean
 
    
Returns true if the specified character can be considered markup. Markup characters include '<', '&', and '%'.

Parameters:
c The character to check.
 
     public static boolean isMarkup(int c) {
         return c == '<' || c == '&' || c == '%';
     } // isMarkup(int):boolean
 
    
Returns true if the specified character is a space character as defined by production [3] in the XML 1.0 specification.

Parameters:
c The character to check.
 
     public static boolean isSpace(int c) {
         return c <= 0x20 && ([c] & ) != 0;
     } // isSpace(int):boolean
 
    
Returns true if the specified character is a valid name start character as defined by production [5] in the XML 1.0 specification.

Parameters:
c The character to check.
 
     public static boolean isNameStart(int c) {
         return c < 0x10000 && ([c] & ) != 0;
     } // isNameStart(int):boolean
 
    
Returns true if the specified character is a valid name character as defined by production [4] in the XML 1.0 specification.

Parameters:
c The character to check.
 
     public static boolean isName(int c) {
         return c < 0x10000 && ([c] & ) != 0;
     } // isName(int):boolean
 
    
Returns true if the specified character is a valid NCName start character as defined by production [4] in Namespaces in XML recommendation.

Parameters:
c The character to check.
 
     public static boolean isNCNameStart(int c) {
         return c < 0x10000 && ([c] & ) != 0;
     } // isNCNameStart(int):boolean
 
    
Returns true if the specified character is a valid NCName character as defined by production [5] in Namespaces in XML recommendation.

Parameters:
c The character to check.
 
     public static boolean isNCName(int c) {
         return c < 0x10000 && ([c] & ) != 0;
     } // isNCName(int):boolean
 
    
Returns true if the specified character is a valid Pubid character as defined by production [13] in the XML 1.0 specification.

Parameters:
c The character to check.
 
     public static boolean isPubid(int c) {
         return c < 0x10000 && ([c] & ) != 0;
     } // isPubid(int):boolean
 
     /*
      * [5] Name ::= (Letter | '_' | ':') (NameChar)*
      */
    
Check to see if a string is a valid Name according to [5] in the XML 1.0 Recommendation

Parameters:
name string to check
Returns:
true if name is a valid Name
 
     public static boolean isValidName(String name) {
         if (name.length() == 0)
             return false;
         char ch = name.charAt(0);
         ifisNameStart(ch) == false)
            return false;
         for (int i = 1; i < name.length(); i++ ) {
            ch = name.charAt(i);
            ifisNamech ) == false ){
               return false;
            }
         }
         return true;
     } // isValidName(String):boolean
     
 
     /*
      * from the namespace rec
      * [4] NCName ::= (Letter | '_') (NCNameChar)*
      */
    
Check to see if a string is a valid NCName according to [4] from the XML Namespaces 1.0 Recommendation

Parameters:
ncName string to check
Returns:
true if name is a valid NCName
 
     public static boolean isValidNCName(String ncName) {
         if (ncName.length() == 0)
             return false;
         char ch = ncName.charAt(0);
         ifisNCNameStart(ch) == false)
            return false;
         for (int i = 1; i < ncName.length(); i++ ) {
            ch = ncName.charAt(i);
            ifisNCNamech ) == false ){
               return false;
            }
         }
         return true;
     } // isValidNCName(String):boolean
 
     /*
      * [7] Nmtoken ::= (NameChar)+
      */
    
Check to see if a string is a valid Nmtoken according to [7] in the XML 1.0 Recommendation

Parameters:
nmtoken string to check
Returns:
true if nmtoken is a valid Nmtoken
 
     public static boolean isValidNmtoken(String nmtoken) {
         if (nmtoken.length() == 0)
             return false;
         for (int i = 0; i < nmtoken.length(); i++ ) {
            char ch = nmtoken.charAt(i);
            if(  ! isNamech ) ){
               return false;
            }
         }
         return true;
     } // isValidName(String):boolean
 
 
 
 
 
     // encodings
 
    
Returns true if the encoding name is a valid IANA encoding. This method does not verify that there is a decoder available for this encoding, only that the characters are valid for an IANA encoding name.

Parameters:
ianaEncoding The IANA encoding name.
 
     public static boolean isValidIANAEncoding(String ianaEncoding) {
         if (ianaEncoding != null) {
             int length = ianaEncoding.length();
             if (length > 0) {
                 char c = ianaEncoding.charAt(0);
                 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
                     for (int i = 1; i < lengthi++) {
                         c = ianaEncoding.charAt(i);
                         if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
                             (c < '0' || c > '9') && c != '.' && c != '_' &&
                             c != '-') {
                             return false;
                         }
                     }
                     return true;
                 }
             }
        }
        return false;
    } // isValidIANAEncoding(String):boolean

    
Returns true if the encoding name is a valid Java encoding. This method does not verify that there is a decoder available for this encoding, only that the characters are valid for an Java encoding name.

Parameters:
javaEncoding The Java encoding name.
    public static boolean isValidJavaEncoding(String javaEncoding) {
        if (javaEncoding != null) {
            int length = javaEncoding.length();
            if (length > 0) {
                for (int i = 1; i < lengthi++) {
                    char c = javaEncoding.charAt(i);
                    if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
                        (c < '0' || c > '9') && c != '.' && c != '_' &&
                        c != '-') {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    } // isValidIANAEncoding(String):boolean
// class XMLChar